Add exclude_also, additive on top of exclude_lines

[tool.slipcover] exclude-also (config-only, same as exclude-lines)
adds patterns on top of whatever exclude-lines resolved to, matching
coverage.py's own separate setting. The xdist controller resolves
exclude_lines/exclude_also once and propagates the merged pattern
list to workers as plain exclude_lines, so a worker never needs to
redo that resolution itself.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: jaltmayerpizzorno

src/slipcover/__main__.py

@@ -301,14 +301,16 @@ def main():
 
 
     omit_list = args.omit.split(',') if args.omit else None
-    # exclude_lines has no CLI flag -- [tool.slipcover] exclude-lines in
-    # pyproject.toml is the only way to set it, so args won't have this
-    # attribute at all unless apply_config() set it from a config file.
+    # exclude_lines/exclude_also have no CLI flag -- [tool.slipcover]
+    # exclude-lines/exclude-also in pyproject.toml are the only way to set
+    # them, so args won't have these attributes at all unless apply_config()
+    # set them from a config file.
     exclude_lines = getattr(args, 'exclude_lines', None)
+    exclude_also = getattr(args, 'exclude_also', None)
     sci = sc.Slipcover(immediate=args.immediate,
                        d_miss_threshold=args.threshold, branch=args.branch,
                        disassemble=args.dis, source=args.source, omit=omit_list,
-                       exclude_lines=exclude_lines)
+                       exclude_lines=exclude_lines, exclude_also=exclude_also)
 
 
     if not args.dont_wrap_pytest:
@@ -326,13 +328,18 @@ def main():
             os.environ["SLIPCOVER_SOURCE"] = source_str
         if args.omit:
             os.environ["SLIPCOVER_OMIT"] = args.omit
-        if exclude_lines is not None:
-            # newline-joined, not comma-joined: regex patterns can contain
-            # commas. Set even when empty (exclude-lines = [] in config):
-            # the var's mere presence -- not its truthiness -- is what
-            # tells a worker "this was resolved, don't fall back to
-            # defaults" (see pytest_plugin.py's _activate_worker()).
-            os.environ["SLIPCOVER_EXCLUDE_LINES"] = "\n".join(exclude_lines)
+        if exclude_lines is not None or exclude_also:
+            # Propagate the already-resolved pattern list (sci's own
+            # compiled patterns, read back as strings) rather than the raw
+            # exclude_lines/exclude_also, so a worker doesn't need to redo
+            # the replace-then-add resolution itself -- it just gets the
+            # final list as plain exclude_lines. Newline-joined, not
+            # comma-joined: regex patterns can contain commas. Set even
+            # when empty (exclude-lines = [] in config): the var's mere
+            # presence -- not its truthiness -- is what tells a worker
+            # "this was resolved, don't fall back to defaults" (see
+            # pytest_plugin.py's _activate_worker()).
+            os.environ["SLIPCOVER_EXCLUDE_LINES"] = "\n".join(p.pattern for p in sci._exclude_patterns)
 
     if platform.system() != 'Windows':
         os.fork = fork_shim(sci)

src/slipcover/config.py

@@ -145,6 +145,7 @@ def _coerce_format(value):
     "lcov-test-name": str,
     "lcov-comments": _coerce_comments,
     "exclude-lines": _coerce_comments,
+    "exclude-also": _coerce_comments,
 }
 
 

src/slipcover/slipcover.py

@@ -381,7 +381,8 @@ def __init__(self, immediate: bool = False,
                  d_miss_threshold: int = 50, branch: bool = False,
                  disassemble: bool = False, source: Optional[List[str]] = None,
                  omit: Optional[List[str]] = None,
-                 exclude_lines: Optional[List[str]] = None):
+                 exclude_lines: Optional[List[str]] = None,
+                 exclude_also: Optional[List[str]] = None):
         self.immediate = immediate
         self.d_miss_threshold = d_miss_threshold
         self.branch = branch
@@ -393,7 +394,10 @@ def __init__(self, immediate: bool = False,
         # all) means "use the defaults"; an explicit [] disables exclusion
         # entirely, including the defaults -- the natural way to express
         # "no exclusion" via [tool.slipcover] exclude-lines = [] in config.
-        self._exclude_patterns = [re.compile(p) for p in (DEFAULT_EXCLUDE if exclude_lines is None else exclude_lines)]
+        # exclude_also, matching coverage.py's own separate setting, is
+        # always additive to whatever that resolves to.
+        base = DEFAULT_EXCLUDE if exclude_lines is None else exclude_lines
+        self._exclude_patterns = [re.compile(p) for p in list(base) + list(exclude_also or [])]
 
         # mutex protecting this state
         self.lock = threading.RLock()

tests/test_config.py

@@ -170,7 +170,7 @@ def _make_args(**kwargs):
         immediate=False, skip_covered=False, fail_under=0,
         threshold=50, missing_width=80, silent=False, dis=False,
         debug=False, dont_wrap_pytest=False, sigterm=False,
-        exclude_lines=None,
+        exclude_lines=None, exclude_also=None,
     )
     defaults.update(kwargs)
     return argparse.Namespace(**defaults)
@@ -208,6 +208,12 @@ def test_apply_config_exclude_lines_scalar_becomes_list():
     assert args.exclude_lines == ["just one"]
 
 
+def test_apply_config_exclude_also():
+    args = _make_args()
+    apply_config({"exclude-also": ["foo", "bar"]}, args)
+    assert args.exclude_also == ["foo", "bar"]
+
+
 def test_apply_config_format_bad_value_raises():
     args = _make_args()
     with pytest.raises(ValueError, match="must be one of"):

tests/test_exclude_lines.py

@@ -19,7 +19,7 @@
 import slipcover.slipcover as sc
 
 
-def _run(tmp_path, source, *, branch=False, exclude_lines=None):
+def _run(tmp_path, source, *, branch=False, exclude_lines=None, exclude_also=None):
     """Compiles, instruments, and runs a real on-disk module, returning its
     file coverage dict. A real file (not an in-memory filename) is needed
     since exclusion matching reads the source text from disk."""
@@ -30,7 +30,7 @@ def _run(tmp_path, source, *, branch=False, exclude_lines=None):
     if branch:
         t = br.preinstrument(t)
 
-    sci = sc.Slipcover(branch=branch, exclude_lines=exclude_lines)
+    sci = sc.Slipcover(branch=branch, exclude_lines=exclude_lines, exclude_also=exclude_also)
     code = compile(t, str(code_path), "exec")
     code = sci.instrument(code)
 
@@ -112,9 +112,7 @@ def test_default_type_checking_block_excluded(tmp_path):
 
 def test_custom_pattern_replaces_defaults(tmp_path):
     """Matches coverage.py's exclude_lines setting exactly: providing custom
-    patterns replaces the built-in defaults, it doesn't add to them. (A
-    future exclude_also, matching coverage.py's own separate additive
-    setting, could add the additive behavior back later if wanted.)"""
+    patterns replaces the built-in defaults, it doesn't add to them."""
     cov = _run(tmp_path, """\
         def foo(x):
             if x < 0:  # pragma: no cover
@@ -135,6 +133,53 @@ def foo(x):
     assert 6 in cov['executed_lines']
 
 
+def test_exclude_also_adds_to_defaults(tmp_path):
+    """Matches coverage.py's exclude_also: unlike exclude_lines, it's always
+    additive to whatever's currently active -- here, the untouched
+    defaults."""
+    cov = _run(tmp_path, """\
+        def foo(x):
+            if x < 0:  # pragma: no cover
+                return 1
+            if x < 0:  # custom-also
+                return 2
+            return 3
+
+        foo(1)
+        """, exclude_also=["custom-also"])
+
+    # both the default pragma and the exclude_also pattern apply
+    for ln in (2, 3, 4, 5):
+        assert ln not in cov['executed_lines'] and ln not in cov['missing_lines']
+    assert 6 in cov['executed_lines']
+
+
+def test_exclude_also_adds_to_custom_exclude_lines(tmp_path):
+    """exclude_also adds on top of exclude_lines too, once exclude_lines has
+    already replaced the defaults -- so the (now inactive) default pragma
+    still doesn't apply, but both custom patterns do."""
+    cov = _run(tmp_path, """\
+        def foo(x):
+            if x < 0:  # pragma: no cover
+                return 1
+            if x < 0:  # custom-a
+                return 2
+            if x < 0:  # custom-b
+                return 3
+            return 4
+
+        foo(1)
+        """, exclude_lines=["custom-a"], exclude_also=["custom-b"])
+
+    # the default pragma is still inactive (exclude_lines replaced it)
+    assert 2 in cov['executed_lines']
+    assert 3 in cov['missing_lines']
+    # both custom-a and custom-b apply
+    for ln in (4, 5, 6, 7):
+        assert ln not in cov['executed_lines'] and ln not in cov['missing_lines']
+    assert 8 in cov['executed_lines']
+
+
 def test_single_line_match_excludes_only_that_line(tmp_path):
     cov = _run(tmp_path, """\
         x = 1
@@ -440,3 +485,29 @@ def test_cli_exclude_lines_empty_config_disables_defaults(tmp_path, monkeypatch)
     keys = [k for k in cov['files'] if 'script.py' in k]
     assert keys, f"script.py not in coverage: {list(cov['files'].keys())}"
     assert 3 in cov['files'][keys[0]]['executed_lines']
+
+
+def test_cli_exclude_also_config_applied(tmp_path, monkeypatch):
+    """[tool.slipcover] exclude-also adds a pattern on top of the untouched
+    defaults, confirmed end-to-end, not just at the apply_config() level."""
+    monkeypatch.chdir(tmp_path)
+    (tmp_path / "pyproject.toml").write_text(
+        '[tool.slipcover]\n'
+        'exclude-also = ["custom-nocov"]\n'
+    )
+    (tmp_path / "script.py").write_text(
+        "def foo(x):\n"
+        "    if x < 0:  # custom-nocov\n"
+        "        return 1\n"
+        "    return 2\n"
+        "foo(1)\n"
+    )
+
+    p = subprocess.run([sys.executable, '-m', 'slipcover', '--json', 'script.py'],
+                        capture_output=True, text=True)
+    assert p.returncode == 0, f"stderr: {p.stderr}"
+
+    cov = json.loads(p.stdout)
+    keys = [k for k in cov['files'] if 'script.py' in k]
+    assert keys, f"script.py not in coverage: {list(cov['files'].keys())}"
+    assert 3 not in cov['files'][keys[0]]['missing_lines']

tests/test_xdist.py

@@ -538,3 +538,52 @@ def test_foo():
     # line 3 ("return 1") is genuinely dead code (foo(1) never takes the
     # excluded branch) and would show up as missing without propagation.
     assert 3 not in cov['files'][keys[0]]['missing_lines']
+
+
+def test_xdist_exclude_also_propagation(tmp_path, monkeypatch):
+    """exclude-also's resolution (default patterns + the extra pattern) must
+    reach xdist workers as one already-merged list, not require the worker
+    to redo the replace-then-add itself."""
+    monkeypatch.chdir(tmp_path)
+
+    (tmp_path / "pyproject.toml").write_text(
+        '[tool.slipcover]\n'
+        'exclude-also = ["custom-nocov"]\n'
+    )
+
+    module_file = tmp_path / "target.py"
+    module_file.write_text(dedent("""\
+        def foo(x):
+            if x < 0:  # pragma: no cover
+                return 1
+            if x < 0:  # custom-nocov
+                return 2
+            return 3
+    """))
+
+    test_file = tmp_path / "test_it.py"
+    test_file.write_text(dedent("""\
+        from target import foo
+
+        def test_foo():
+            assert foo(1) == 3
+    """))
+
+    out = tmp_path / "out.json"
+    result = subprocess.run(
+        [sys.executable, '-m', 'slipcover', '--json', '--out', str(out),
+         '-m', 'pytest', '-n', '2', '-q', 'test_it.py'],
+        capture_output=True, text=True
+    )
+    assert result.returncode == 0, f"stdout: {result.stdout}\nstderr: {result.stderr}"
+
+    with out.open() as f:
+        cov = json.load(f)
+    check_summaries(cov)
+
+    keys = [k for k in cov['files'] if 'target.py' in k]
+    assert keys, f"target.py not in coverage: {list(cov['files'].keys())}"
+    # both the default pragma (line 2/3) and the exclude-also pattern
+    # (line 4/5) must be excluded, neither showing up as missing.
+    for ln in (3, 5):
+        assert ln not in cov['files'][keys[0]]['missing_lines']