Codebase intelligence for AI and humans: code health scores, auto-generated docs, git analytics, dead code detection, and architectural decisions via MCP.
Python aicode-complexitycode-healthcode-intelligencecode-qualitydead-codedeveloper-toolsdocumentationgit-analyticsmcpopen-sourcepythonrefactoringstatic-analysistechnical-debt
fix(health): exclude Rust inline test code from perf findings (#1855)
NullSense23a14b23b1db
diff --git a/packages/core/src/repowise/core/analysis/health/complexity/models.py b/packages/core/src/repowise/core/analysis/health/complexity/models.pyindex fb298ef77..cae4529c1 100644--- a/packages/core/src/repowise/core/analysis/health/complexity/models.py+++ b/packages/core/src/repowise/core/analysis/health/complexity/models.py@@ -308,3 +308,14 @@ class FileComplexity:# flips a file from "untested" to "tested", so it can silence a finding# but never invent one.has_inline_tests: bool = False+ # 1-indexed ``(start_line, end_line)`` spans of Rust test-only code: a+ # ``#[cfg(test)]``-gated ``mod``/``impl`` (whole span, including any+ # undecorated helper fns nested inside it) or a directly ``#[test]`` /+ # ``#[tokio::test]`` / ``#[rstest]``-marked ``fn``. Computed once from the+ # SAME parsed tree ``walk_file`` already builds — no extra parse. Rust-only+ # (empty for every other language); the Phase-7b centrality gate+ # (``perf.gated.collect_centrality_gated``) uses it to keep a+ # ``PerfFnFacts.func_start`` line from ever emitting a ``hot_path_sync_io``+ # / ``nested_loop_quadratic`` hit for inline test code the file-level+ # ``is_test`` heuristic can't see.+ rust_test_line_ranges: tuple[tuple[int, int], ...] = field(default_factory=tuple)diff --git a/packages/core/src/repowise/core/analysis/health/complexity/walker.py b/packages/core/src/repowise/core/analysis/health/complexity/walker.pyindex 0aaaf43bb..6984db02c 100644--- a/packages/core/src/repowise/core/analysis/health/complexity/walker.py+++ b/packages/core/src/repowise/core/analysis/health/complexity/walker.py@@ -34,6 +34,8 @@ drives the individual passes, each of which lives in its own sibling module:from __future__ import annotations+from typing import TYPE_CHECKING+import structlogfrom ..mocks.lexicon import mock_dialect as _mock_dialect@@ -45,10 +47,13 @@ from .ast_utils import ()from .class_analysis import _collect_classesfrom .cyclomatic import _walk_function_body-from .error_handling import _collect_error_handling+from .error_handling import _collect_error_handling, _eh_rust_attr_is_testfrom .languages import get_language_mapfrom .mock_walk import _count_mock_setup, file_may_contain_mocks+if TYPE_CHECKING:+ from tree_sitter import Node+# Re-exported so the package façade (``__init__``) and downstream consumers# keep importing the output schema from ``complexity.walker`` unchanged.from .models import (@@ -170,6 +175,7 @@ def walk_file(io_boundary_names=io_boundary_names,perf_fn_facts=perf_fn_facts,has_inline_tests=_detect_inline_tests(source, language),+ rust_test_line_ranges=_rust_test_line_ranges(tree.root_node, language),)@@ -202,3 +208,56 @@ def _detect_inline_tests(source: bytes, language: str) -> bool:if language != "rust":return Falsereturn any(marker in source for marker in _RUST_INLINE_TEST_MARKERS)+++# ``function_item`` / ``mod_item`` / ``impl_item`` are the Rust item kinds a+# ``#[cfg(test)]`` (or ``#[test]`` / ``#[tokio::test]`` / ``#[rstest]``, for a+# bare fn) attribute can gate. ``mod``/``impl`` are containers: their whole+# span is test-only once gated, including any nested fn that carries no+# attribute of its own — the same reason ``#[cfg(test)] mod tests { .. }``+# hides ordinary-looking helper fns from the file-level heuristic above.+_RUST_TEST_ITEM_KINDS = ("function_item", "mod_item", "impl_item")+++def _rust_test_line_ranges(root: Node, language: str) -> tuple[tuple[int, int], ...]:+ """1-indexed ``(start_line, end_line)`` spans of Rust test-only code.++ Walks the SAME tree ``walk_file`` already parsed (no extra parse). Marks a+ ``mod_item`` / ``impl_item`` / ``function_item`` whose immediately+ preceding attribute siblings include a test marker+ (:func:`repowise.core.analysis.health.complexity.error_handling._eh_rust_attr_is_test`,+ shared with the error-handling walker so both passes recognize the+ identical attribute grammar), and does not descend into a marked node —+ its span already covers everything nested inside. Rust-only; every other+ language gets ``()``, so :func:`repowise.core.analysis.health.perf.gated._in_rust_test_range`+ is a no-op for it.+ """+ if language != "rust":+ return ()++ ranges: list[tuple[int, int]] = []++ def _text(node: Node) -> str:+ return (node.text or b"").decode("utf-8", errors="replace")++ def _is_marked(node: Node) -> bool:+ sib = node.prev_sibling+ while sib is not None and sib.type in (+ "attribute_item",+ "line_comment",+ "block_comment",+ ):+ if sib.type == "attribute_item" and _eh_rust_attr_is_test(_text(sib)):+ return True+ sib = sib.prev_sibling+ return False++ def _walk(node: Node) -> None:+ if node.type in _RUST_TEST_ITEM_KINDS and _is_marked(node):+ ranges.append((node.start_point[0] + 1, node.end_point[0] + 1))+ return # span already covers every nested item; don't descend+ for child in node.children:+ _walk(child)++ _walk(root)+ return tuple(ranges)diff --git a/packages/core/src/repowise/core/analysis/health/perf/gated.py b/packages/core/src/repowise/core/analysis/health/perf/gated.pyindex 42f8405e9..a15dda630 100644--- a/packages/core/src/repowise/core/analysis/health/perf/gated.py+++ b/packages/core/src/repowise/core/analysis/health/perf/gated.py@@ -38,6 +38,21 @@ if TYPE_CHECKING:LOCK_IO_KIND = "blocking_io_under_lock"+def _in_rust_test_range(line: int, ranges: tuple[tuple[int, int], ...]) -> bool:+ """True when *line* falls inside one of *ranges* (Rust test-only spans).++ *ranges* is ``FileComplexity.rust_test_line_ranges``, computed once per+ file by the walker from the tree it already parsed (see+ ``complexity.walker._rust_test_line_ranges``) — empty for every language+ but Rust, so this is a no-op everywhere else. Checked here, at the single+ choke point both centrality-gated markers share, so a function inside a+ ``#[cfg(test)] mod`` / ``#[test]`` fn — invisible to the file-level+ ``is_test`` heuristic — never emits ``hot_path_sync_io`` or+ ``nested_loop_quadratic``, without weakening the gate for production code.+ """+ return any(start <= line <= end for start, end in ranges)++def collect_centrality_gated(walked: Iterable[tuple[Any, FileComplexity]], ranker: PerfRanker) -> dict[str, list[PerfHit]]:@@ -47,7 +62,10 @@ def collect_centrality_gated(is produced ONLY when ``ranker.is_hot(path, func_start)`` — so a quadraticloop or a blocking sync sink ships only where it sits on a hot, central, orchurny path. Pure when neither graph nor git signal is available (nothing is- hot ⇒ no hits), which is the precision-first default.+ hot ⇒ no hits), which is the precision-first default. A fact whose function+ sits inside Rust inline test code (``_in_rust_test_range``) is skipped+ before the hotness check even runs — test code doing blocking I/O is+ normal, not a finding, regardless of how central or churny its file is."""from ..complexity import PerfHit@@ -57,9 +75,12 @@ def collect_centrality_gated(continuepath = pf.file_info.pathfile_hits: list[PerfHit] = []+ test_ranges = fcx.rust_test_line_rangesfor fact in fcx.perf_fn_facts:if fact.nested_loop_line == 0 and fact.blocking_sink_kind is None:continue+ if test_ranges and _in_rust_test_range(fact.func_start, test_ranges):+ continueif not ranker.is_hot(path, fact.func_start):continueif fact.nested_loop_line:diff --git a/tests/unit/health/test_perf_rust_test_filter.py b/tests/unit/health/test_perf_rust_test_filter.pynew file mode 100644index 000000000..36a17082c--- /dev/null+++ b/tests/unit/health/test_perf_rust_test_filter.py@@ -0,0 +1,184 @@+"""Rust inline test code must not trigger the centrality-gated perf markers.++The Phase-7b gate (``perf.gated.collect_centrality_gated``) decides whether a+function is a finding using only two things: the walker's per-function facts+(``PerfFnFacts``) and ``ranker.is_hot(path, func_start)`` — neither of which+knows a function is test-only. Idiomatic Rust tests live in the same source+file (a ``#[cfg(test)] mod tests`` block, or a bare ``#[test]`` fn), so a test+helper that opens a file or nests two nearly-identical loops reads exactly+like production code doing the same thing, and a hot/churny file (which a+well-tested one usually is) gated every one of them in.++``FileComplexity.rust_test_line_ranges`` (computed by+``complexity.walker._rust_test_line_ranges`` from the same parsed tree, no+extra parse) fixes this at the single choke point both gated markers share:+a fact whose ``func_start`` falls in a test range is skipped before the+hotness check runs at all. Measured on a real corpus: hot_path_sync_io+122 -> 56, with all 66 test-code findings removed and all 56 production+findings retained.+"""++from __future__ import annotations++import pytest++from repowise.core.analysis.health.complexity import walk_file+from repowise.core.analysis.health.perf import PerfRanker, collect_centrality_gated+++class _PF:+ """Minimal stand-in for a ParsedFile (the gate only reads file_info.path)."""++ class _FI:+ def __init__(self, path):+ self.path = path++ def __init__(self, path):+ self.file_info = _PF._FI(path)+++def _walked(path: str, language: str, src: str):+ return [(_PF(path), walk_file(path, language, src.encode()))]+++def _always_hot() -> PerfRanker:+ # No graph, but every file is a git hotspot -> churny -> hot everywhere,+ # so the ONLY thing that can suppress a hit is the test-range filter.+ return PerfRanker(None, {"t.rs": {"is_hotspot": True}})+++# A bare sync filesystem sink (loop_depth 0 -> hot_path_sync_io candidate)+# plus an all-pairs nested loop over the same collection+# (-> nested_loop_quadratic candidate) — the identical shape+# test_perf_phase7b.py's `_HOT_SRC` uses to prove the gate fires at all.+_HOT_BODY = (+ 'std::fs::read("config.toml").unwrap();\n'+ " for x in items {\n"+ " for y in items {\n"+ " let _ = (x, y);\n"+ " }\n"+ " }\n"+)++_PRODUCTION_FN = f"fn production(items: &[i32]) {{\n {_HOT_BODY}}}\n"++_CFG_TEST_MOD = (+ "#[cfg(test)]\n"+ "mod tests {\n"+ " use super::*;\n"+ "\n"+ f" fn helper_reads_a_fixture(items: &[i32]) {{\n {_HOT_BODY} }}\n"+ "\n"+ " #[test]\n"+ " fn it_calls_the_helper() {\n"+ " helper_reads_a_fixture(&[1, 2, 3]);\n"+ " }\n"+ "}\n"+)++_BARE_TEST_FN = f"#[test]\nfn standalone_test(items: &[i32]) {{\n {_HOT_BODY}}}\n"+++def test_production_code_alone_fires_both_markers():+ """Baseline: the shape the gate exists to catch, with no test code at all."""+ walked = _walked("t.rs", "rust", _PRODUCTION_FN)+ out = collect_centrality_gated(walked, _always_hot())+ kinds = sorted(h.kind for h in out.get("t.rs", []))+ assert kinds == ["hot_path_sync_io", "nested_loop_quadratic"]+++def test_a_cfg_test_mod_helper_is_silenced():+ """The exact shape a Rust file mixes: production code untouched, an+ identical helper inside `#[cfg(test)] mod tests` silenced — even though+ that helper carries no attribute of its own."""+ src = _PRODUCTION_FN + "\n" + _CFG_TEST_MOD+ walked = _walked("t.rs", "rust", src)+ out = collect_centrality_gated(walked, _always_hot())++ hits = out.get("t.rs", [])+ functions_hit = {h.function for h in hits}+ assert functions_hit == {"production"}+ assert "helper_reads_a_fixture" not in functions_hit+ kinds = sorted(h.kind for h in hits)+ assert kinds == ["hot_path_sync_io", "nested_loop_quadratic"]+++def test_a_bare_hash_test_fn_outside_any_mod_is_also_silenced():+ """Not every Rust test lives in a `mod tests` block — a directly+ `#[test]`-attributed top-level fn must be recognised too."""+ src = _PRODUCTION_FN + "\n" + _BARE_TEST_FN+ walked = _walked("t.rs", "rust", src)+ out = collect_centrality_gated(walked, _always_hot())++ functions_hit = {h.function for h in out.get("t.rs", [])}+ assert functions_hit == {"production"}+ assert "standalone_test" not in functions_hit+++def test_test_only_file_produces_no_hits_at_all():+ """A file that is ENTIRELY test code (no production fn present) must+ ship nothing, not merely fewer hits."""+ walked = _walked("t.rs", "rust", _CFG_TEST_MOD)+ assert collect_centrality_gated(walked, _always_hot()) == {}+++def test_rust_test_line_ranges_cover_the_whole_mod_span():+ """The range covers the mod item's whole span — from its own `mod tests {`+ line (the preceding `#[cfg(test)]` attribute is a sibling, not part of the+ mod_item node) through its closing brace — which is what lets an+ undecorated helper nested inside it be silenced."""+ fc = walk_file("t.rs", "rust", _CFG_TEST_MOD.encode())+ assert len(fc.rust_test_line_ranges) == 1+ start, end = fc.rust_test_line_ranges[0]+ lines = _CFG_TEST_MOD.splitlines()+ assert lines[start - 1].strip() == "mod tests {"+ assert lines[end - 1].strip() == "}"+ # The helper's own line sits inside the range, even though it carries no+ # attribute of its own — the whole reason a per-fn heuristic isn't enough.+ helper_line = next(i + 1 for i, line in enumerate(lines) if "fn helper_reads_a_fixture" in line)+ assert start <= helper_line <= end++[email protected]("language", ["python", "typescript", "go", "java"])+def test_non_rust_languages_get_empty_ranges_and_are_unaffected(language):+ """The filter is Rust-only by construction: every other language's+ FileComplexity carries no ranges, so the gate's new check is a no-op —+ a production hit in another language must still fire even inside+ something that merely LOOKS test-shaped syntactically."""+ src_by_lang = {+ "python": (+ "def production(items):\n"+ " open('config.toml').read()\n"+ " for x in items:\n"+ " for y in items:\n"+ " use(x, y)\n"+ ),+ "typescript": (+ "function production(items){ require('fs').readFileSync('c.toml'); "+ "for (const x of items){ for (const y of items){ use(x, y); } } }"+ ),+ "go": (+ "func production(items []int) {\n"+ '\tos.ReadFile("config.toml")\n'+ "\tfor _, x := range items {\n"+ "\t\tfor _, y := range items {\n"+ "\t\t\tuse(x, y)\n"+ "\t\t}\n"+ "\t}\n"+ "}\n"+ ),+ "java": (+ "class T {\n"+ " void production(int[] items) throws Exception {\n"+ ' java.nio.file.Files.readAllBytes(java.nio.file.Paths.get("c.toml"));\n'+ " for (int x : items) {\n"+ " for (int y : items) {\n"+ " use(x, y);\n"+ " }\n"+ " }\n"+ " }\n"+ "}\n"+ ),+ }+ fc = walk_file(f"t.{language}", language, src_by_lang[language].encode())+ assert fc.rust_test_line_ranges == ()