sarj-python-lint 0.26.0__tar.gz → 0.27.0__tar.gz

{sarj_python_lint-0.26.0 → sarj_python_lint-0.27.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sarj-python-lint
-Version: 0.26.0
+Version: 0.27.0
 Summary: Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults
 Project-URL: Homepage, https://github.com/sarj-ai/standards/tree/main/packages/python
 Project-URL: Repository, https://github.com/sarj-ai/standards

{sarj_python_lint-0.26.0 → sarj_python_lint-0.27.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sarj-python-lint"
-version = "0.26.0"
+version = "0.27.0"
 description = "Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults"
 readme = "README.md"
 authors = [{ name = "sarj-ai" }]

sarj_python_lint-0.27.0/src/sarj_python_lint/rules/_ast_index.py

@@ -0,0 +1,180 @@
+"""One tree traversal per file, shared by every rule that needs node lookups.
+
+Profiling the whole registry over a 1,920-line module showed `ast.walk` and its
+helpers (`iter_child_nodes` / `iter_fields`) accounting for ~60% of all rule
+time. The cause is structural rather than any one rule's fault: the dominant
+shape of a rule is
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Something):
+            ...
+
+so a file with N nodes and R rules asking that question pays R full traversals,
+each one re-deriving the same partition of the tree by node type.
+
+`nodes()` derives that partition **once per file** and answers every subsequent
+type query from it. The index is memoized in a single slot keyed on tree
+identity, mirroring `parse_or_none`: the CLI iterates files on the outer loop
+and rules on the inner one, so one slot is all that is ever live. The slot holds
+a strong reference to the tree, so a recycled `id()` can never alias a stale
+index.
+
+Two invariants make the substitution finding-preserving, not merely faster:
+
+* **Order.** The index is built by breadth-first traversal, the same order
+  `ast.walk` yields, and every query preserves it. `nodes(tree, T)` is therefore
+  elementwise equal to `[n for n in ast.walk(tree) if isinstance(n, T)]`, so a
+  rule that takes the *first* match, or reports in discovery order, is
+  unaffected.
+* **Subclasses.** Queries match by `isinstance`, not by exact type: the buckets
+  are keyed on exact class, and a query resolves to the set of present classes
+  that are subclasses of the requested types. Asking for `ast.stmt` still
+  returns every statement.
+
+`walk()` is the same breadth-first order for the cases the index cannot serve —
+traversing a *subtree* rather than the module, where containment is not
+something a whole-module partition can answer.
+
+No rule may mutate the tree. That was already required — every rule shares one
+memoized parse, and `duplicate_test_body` deep-copies before normalizing — and
+the index inherits the requirement, since it holds references into the tree it
+was built from.
+"""
+
+from __future__ import annotations
+
+import ast
+from typing import TYPE_CHECKING, final
+
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+
+_AST = ast.AST
+
+
+def children(node: ast.AST) -> list[ast.AST]:
+    """`node`'s direct children, in the same order as `ast.iter_child_nodes`.
+
+    A list rather than a generator: every caller either iterates it once or
+    extends a stack with it, and the hand-rolled walkers in this package call
+    this once per node, where the generator's setup cost dominates the work.
+
+    Returns:
+        The child nodes, in field-declaration order.
+
+    """
+    out: list[ast.AST] = []
+    for name in node._fields:
+        value: object = getattr(node, name, None)
+        if isinstance(value, list):
+            out += [item for item in value if isinstance(item, _AST)]  # pyright: ignore[reportUnknownVariableType] — element narrowed by isinstance
+        elif isinstance(value, _AST):
+            out.append(value)
+    return out
+
+
+def walk(node: ast.AST) -> Iterator[ast.AST]:
+    """Yield `node` and every descendant, breadth-first.
+
+    Identical in order to `ast.walk`, but reads each node's fields directly
+    instead of routing every node through two intermediate generators.
+
+    Yields:
+        `node` first, then its descendants breadth-first.
+
+    """
+    queue: list[ast.AST] = [node]
+    i = 0
+    while i < len(queue):
+        current = queue[i]
+        i += 1
+        for name in current._fields:
+            value: object = getattr(current, name, None)
+            if isinstance(value, list):
+                queue += [item for item in value if isinstance(item, _AST)]  # pyright: ignore[reportUnknownVariableType] — element narrowed by isinstance
+            elif isinstance(value, _AST):
+                queue.append(value)
+        yield current
+
+
+@final
+class _NodeIndex:
+    """A module's nodes partitioned by exact class, in breadth-first order."""
+
+    __slots__ = ("_buckets", "_flat", "_queries")
+
+    def __init__(self, tree: ast.AST) -> None:
+        buckets: dict[type[ast.AST], list[ast.AST]] = {}
+        flat: list[ast.AST] = [tree]
+        i = 0
+        while i < len(flat):
+            current = flat[i]
+            i += 1
+            cls = current.__class__
+            bucket = buckets.get(cls)
+            if bucket is None:
+                buckets[cls] = [current]
+            else:
+                bucket.append(current)
+            for name in cls._fields:
+                value: object = getattr(current, name, None)
+                if isinstance(value, list):
+                    flat += [item for item in value if isinstance(item, _AST)]  # pyright: ignore[reportUnknownVariableType] — element narrowed by isinstance
+                elif isinstance(value, _AST):
+                    flat.append(value)
+        self._buckets: dict[type[ast.AST], list[ast.AST]] = buckets
+        self._flat: list[ast.AST] = flat
+        self._queries: dict[tuple[type[ast.AST], ...], list[ast.AST]] = {}
+
+    def query(self, types: tuple[type[ast.AST], ...]) -> list[ast.AST]:
+        """Return every node matching `isinstance(node, types)`, breadth-first.
+
+        Returns:
+            The match list, cached per `types` and shared — treat as read-only.
+
+        """
+        hit = self._queries.get(types)
+        if hit is not None:
+            return hit
+        matched = frozenset(cls for cls in self._buckets if issubclass(cls, types))
+        if len(matched) == 1:
+            # The single bucket is already the answer, in breadth-first order.
+            result = self._buckets[next(iter(matched))]
+        elif len(matched) == len(self._buckets):
+            # Every class present matches — e.g. `nodes(tree, ast.AST)`, asked by
+            # a rule whose loop body inspects every node rather than a few types.
+            result = self._flat
+        elif matched:
+            result = [node for node in self._flat if node.__class__ in matched]
+        else:
+            result = []
+        self._queries[types] = result
+        return result
+
+
+_last_index: tuple[ast.AST, _NodeIndex] | None = None
+
+
+def nodes[NodeT: ast.AST](tree: ast.AST, *types: type[NodeT]) -> list[NodeT]:
+    """Every node of `tree` matching `types`, in `ast.walk` order.
+
+    A drop-in, memoized replacement for the ubiquitous
+    `[n for n in ast.walk(tree) if isinstance(n, types)]`. Pass the *module*
+    tree: the index is per-file, so calling this with a subtree builds a fresh
+    index and evicts the module's. Use `walk` for subtrees.
+
+    Returns:
+        The matching nodes, breadth-first. A fresh list per call; the partition
+        it is drawn from is what gets cached.
+
+    """
+    global _last_index  # ruff: ignore[global-statement] — single-slot memo, mirroring `parse_or_none`
+    if _last_index is None or _last_index[0] is not tree:
+        _last_index = (tree, _NodeIndex(tree))
+    # The `isinstance` pass is what narrows `list[ast.AST]` to `list[NodeT]`
+    # honestly, rather than asserting it with a `cast` the house style bans. It
+    # runs over the matches only — never the tree — and every element passes by
+    # construction, so it costs one type check per node actually returned.
+    return [node for node in _last_index[1].query(types) if isinstance(node, types)]

sarj_python_lint-0.27.0/src/sarj_python_lint/rules/_logging.py

@@ -0,0 +1,54 @@
+"""Shared logging-receiver detection for SARJ012/SARJ017.
+
+A single resolver for "does this receiver expression evaluate to a logger?",
+used by both the secret-in-log and f-string-in-log rules so they recognise the
+same factory/builder forms.
+"""
+
+from __future__ import annotations
+
+import ast
+
+
+_LOGGER_NAMES = frozenset({"logger", "log", "logging", "loguru", "_logger", "_log"})
+
+_LOGGER_FACTORIES = frozenset({"getlogger", "get_logger"})
+
+
+def is_logger_expr(expr: ast.expr) -> bool:
+    """Report whether `expr` evaluates to a logger.
+
+    Resolves the whole receiver chain so adapter/builder/factory calls are
+    caught: `logger.bind(...).info(...)`, `logger.opt(lazy=True).debug(...)`,
+    `logging.getLogger(__name__).info(...)`, `self.logger.error(...)`, and the
+    bare-name factory `get_logger().info(...)`.
+
+    Returns:
+        True when `expr` resolves to a logger receiver.
+
+    """
+    if isinstance(expr, ast.Name):
+        return expr.id.lower() in _LOGGER_NAMES
+    if isinstance(expr, ast.Attribute):
+        if expr.attr.lower() in _LOGGER_NAMES or expr.attr.lower() in _LOGGER_FACTORIES:
+            return True
+        return is_logger_expr(expr.value)
+    if isinstance(expr, ast.Call):
+        # A factory names a logger only when it is *called*: `get_logger()` is a
+        # logger, the bare name `get_logger` is a function — which is why the
+        # factories live in their own set and not in `_LOGGER_NAMES`. Both the
+        # dotted spelling (`structlog.get_logger()`, `logging.getLogger()`) and
+        # the bare one (`from structlog import get_logger`, then `get_logger()`)
+        # have to be recognised right here: a bare callee is an `ast.Name`, and
+        # recursing on it lands in the `_LOGGER_NAMES` branch, which by that
+        # design does not carry the factory names. Omitting this second check is
+        # a silent false negative rather than a crash, so it went unnoticed —
+        # `get_logger().info("auth", token=token)`, structlog's own documented
+        # module-level idiom, was unlinted by both SARJ012 and SARJ017.
+        callee = expr.func
+        if isinstance(callee, ast.Attribute) and callee.attr.lower() in _LOGGER_FACTORIES:
+            return True
+        if isinstance(callee, ast.Name) and callee.id.lower() in _LOGGER_FACTORIES:
+            return True
+        return is_logger_expr(callee)
+    return False

{sarj_python_lint-0.26.0 → sarj_python_lint-0.27.0}/src/sarj_python_lint/rules/_pytest.py

@@ -13,6 +13,8 @@ from __future__ import annotations
 
 import ast
 
+from sarj_python_lint.rules._ast_index import walk
+
 
 # The pytest-benchmark fixture: the test measures time, it does not verify.
 _BENCHMARK = "benchmark"
@@ -33,7 +35,7 @@ def uses_benchmark_fixture(node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool
     """
     args = node.args
     declared = any(arg.arg == _BENCHMARK for arg in (*args.posonlyargs, *args.args, *args.kwonlyargs))
-    return declared and any(isinstance(child, ast.Name) and child.id == _BENCHMARK for child in ast.walk(node))
+    return declared and any(isinstance(child, ast.Name) and child.id == _BENCHMARK for child in walk(node))
 
 
 def has_benchmark_marker(node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:

{sarj_python_lint-0.26.0 → sarj_python_lint-0.27.0}/src/sarj_python_lint/rules/_suppression_comments.py

@@ -33,6 +33,9 @@ class Comment:
     before_first_statement: bool = False
 
 
+_last_scan: tuple[str, list[Comment]] | None = None
+
+
 def scan_comments(source: str) -> list[Comment]:
     """Tokenize `source` and describe every comment in it.
 
@@ -43,10 +46,25 @@ def scan_comments(source: str) -> list[Comment]:
     Anything `tokenize` cannot lex propagates as `tokenize.TokenError`,
     `IndentationError` or `SyntaxError`; callers treat that as "no diagnostics".
 
+    Memoized in a single slot, like `_comments._scan_memo` and
+    `rule_base.parse_or_none`: both suppression rules ask the same question about
+    the same file, and the CLI runs rules per file, so one slot removes the
+    second tokenize pass. `Comment` is frozen and the returned list is read-only
+    to callers.
+
     Returns:
         Every comment, in source order.
 
     """
+    global _last_scan  # ruff: ignore[global-statement] — single-slot memo; the CLI runs rules per file sequentially
+    if _last_scan is not None and _last_scan[0] is source:
+        return _last_scan[1]
+    result = _scan(source)
+    _last_scan = (source, result)
+    return result
+
+
+def _scan(source: str) -> list[Comment]:
     comments: list[Comment] = []
     first_statement_line = _NO_STATEMENT_LINE
     prev_end_row = 0

{sarj_python_lint-0.26.0 → sarj_python_lint-0.27.0}/src/sarj_python_lint/rules/conditional_assertion_in_test.py

@@ -189,6 +189,7 @@ import re
 from typing import TYPE_CHECKING, override
 
 from sarj_python_lint.rule_base import Diagnostic, Rule, parse_or_none
+from sarj_python_lint.rules._ast_index import nodes, walk
 from sarj_python_lint.rules._paths import is_test_path
 
 
@@ -407,7 +408,7 @@ def _is_exempt(node: ast.FunctionDef | ast.AsyncFunctionDef, helpers: frozenset[
     if any(_decorator_name(dec) in _PROPERTY_DECORATORS for dec in node.decorator_list):
         return True
     for stmt in node.body:
-        for child in ast.walk(stmt):
+        for child in walk(stmt):
             # `with self.subTest(...)` drives a table whose emptiness this rule
             # cannot see; a nested `def` holding the assertions may be invoked
             # by a runner (`asyncio.run`, a callback registry) the rule cannot
@@ -592,7 +593,7 @@ def _loop_guarantees(stmt: ast.For | ast.AsyncFor, facts: _Facts) -> bool:
 
 
 def _bound_names(target: ast.expr) -> frozenset[str]:
-    return frozenset(node.id for node in ast.walk(target) if isinstance(node, ast.Name))
+    return frozenset(node.id for node in walk(target) if isinstance(node, ast.Name))
 
 
 def _try_guarantees(stmt: ast.Try, facts: _Facts) -> bool:
@@ -622,7 +623,7 @@ def _is_capability_probe(test: ast.expr) -> bool:
         True when the condition reads a capability flag or calls `hasattr`.
 
     """
-    for node in ast.walk(test):
+    for node in walk(test):
         if isinstance(node, ast.Name) and _CAPABILITY_RE.search(node.id):
             return True
         if isinstance(node, ast.Attribute) and _CAPABILITY_RE.search(node.attr):
@@ -655,7 +656,7 @@ def _expr_names_assertion(expr: ast.expr, helpers: frozenset[str]) -> bool:
 
 
 def _contains_assertion(node: ast.AST, helpers: frozenset[str]) -> bool:
-    return any(_is_assertion(child, helpers) for child in ast.walk(node))
+    return any(_is_assertion(child, helpers) for child in walk(node))
 
 
 def _body_contains_assertion(node: ast.FunctionDef | ast.AsyncFunctionDef, helpers: frozenset[str]) -> bool:
@@ -666,7 +667,7 @@ def _body_contains_assertion(node: ast.FunctionDef | ast.AsyncFunctionDef, helpe
 
 
 def _holds_assertion_call(stmt: ast.stmt, helpers: frozenset[str]) -> bool:
-    return any(_is_assertion(child, helpers) for child in ast.walk(stmt))
+    return any(_is_assertion(child, helpers) for child in walk(stmt))
 
 
 def _is_assertion(child: ast.AST, helpers: frozenset[str]) -> bool:
@@ -711,9 +712,8 @@ def _asserting_helper_names(tree: ast.Module) -> frozenset[str]:
 
     """
     defs: dict[str, ast.FunctionDef | ast.AsyncFunctionDef] = {}
-    for node in ast.walk(tree):
-        if isinstance(node, _FUNC_NODES):
-            defs.setdefault(node.name, node)
+    for node in nodes(tree, *_FUNC_NODES):
+        defs.setdefault(node.name, node)
     verifying = {name for name, node in defs.items() if _contains_assertion(node, frozenset())}
     pending = {name: _called_names(node) for name, node in defs.items() if name not in verifying}
     while True:
@@ -726,7 +726,7 @@ def _asserting_helper_names(tree: ast.Module) -> frozenset[str]:
 
 def _called_names(node: ast.AST) -> set[str]:
     names: set[str] = set()
-    for child in ast.walk(node):
+    for child in walk(node):
         if isinstance(child, ast.Call):
             func = child.func
             if isinstance(func, ast.Attribute):
@@ -779,7 +779,7 @@ def _facts_for(
     helpers: frozenset[str],
 ) -> _Facts:
     bindings = dict(module_bindings)
-    bindings.update(_bindings_in(list(ast.walk(node))))
+    bindings.update(_bindings_in(list(walk(node))))
     bindings.update(_default_bindings(node))
     nonempty = _nonempty_claims(node, helpers) | set(module_nonempty) | _parametrized_nonempty(node)
     base = _Facts(nonempty=frozenset(nonempty), bindings=bindings, imported=imported, helpers=helpers)
@@ -827,10 +827,10 @@ def _accumulators_filled(node: ast.FunctionDef | ast.AsyncFunctionDef, facts: _F
 
     """
     filled: set[str] = set()
-    for child in ast.walk(node):
+    for child in walk(node):
         if not isinstance(child, _LOOP_NODES) or not _iterable_is_nonempty(child.iter, facts, frozenset()):
             continue
-        for inner in ast.walk(child):
+        for inner in walk(child):
             if not (isinstance(inner, ast.Call) and isinstance(inner.func, ast.Attribute)):
                 continue
             receiver = inner.func.value
@@ -847,9 +847,8 @@ def _imported_names(tree: ast.Module) -> frozenset[str]:
 
     """
     names: set[str] = set()
-    for node in ast.walk(tree):
-        if isinstance(node, (ast.Import, ast.ImportFrom)):
-            names.update(alias.asname or alias.name.split(".")[0] for alias in node.names)
+    for node in nodes(tree, ast.Import, ast.ImportFrom):
+        names.update(alias.asname or alias.name.split(".")[0] for alias in node.names)
     return frozenset(names)
 
 
@@ -861,7 +860,7 @@ def _nonempty_claims(node: ast.AST, helpers: frozenset[str]) -> set[str]:
 
     """
     nonempty: set[str] = set()
-    for child in ast.walk(node):
+    for child in walk(node):
         if isinstance(child, ast.Assert):
             nonempty |= _proves_nonempty(child.test)
         elif isinstance(child, ast.Call) and _names_assertion(child.func, helpers):

{sarj_python_lint-0.26.0 → sarj_python_lint-0.27.0}/src/sarj_python_lint/rules/duplicate_test_body.py

@@ -198,6 +198,7 @@ import tokenize
 from typing import TYPE_CHECKING, override
 
 from sarj_python_lint.rule_base import Diagnostic, Rule, parse_or_none
+from sarj_python_lint.rules._ast_index import children
 from sarj_python_lint.rules._comments import standalone_comments, trailing_comments
 from sarj_python_lint.rules._paths import is_generated_source, is_test_path
 
@@ -656,7 +657,7 @@ def _decorator_shape(node: ast.FunctionDef | ast.AsyncFunctionDef) -> str:
 
 def _walk(node: ast.AST) -> Iterator[ast.AST]:
     yield node
-    for child in ast.iter_child_nodes(node):
+    for child in children(node):
         yield from _walk(child)
 
 

{sarj_python_lint-0.26.0 → sarj_python_lint-0.27.0}/src/sarj_python_lint/rules/fixture_returns_bare_tuple.py

@@ -51,6 +51,7 @@ import ast
 from typing import TYPE_CHECKING, override
 
 from sarj_python_lint.rule_base import Diagnostic, Rule, parse_or_none
+from sarj_python_lint.rules._ast_index import children, nodes
 from sarj_python_lint.rules._paths import is_test_path
 
 
@@ -108,8 +109,8 @@ class FixtureReturnsBareTuple(Rule):
 
 def _bare_tuple_results(tree: ast.Module) -> list[tuple[ast.expr, int]]:
     hits: list[tuple[ast.expr, int]] = []
-    for node in ast.walk(tree):
-        if not isinstance(node, _FUNC_NODES) or not _is_fixture(node):
+    for node in nodes(tree, *_FUNC_NODES):
+        if not _is_fixture(node):
             continue
         if _returns_distinctly_typed_tuple(node):
             continue
@@ -175,7 +176,7 @@ def _scan_for_results(node: ast.AST) -> list[tuple[ast.expr, int]]:
         count = _bare_tuple_arity(value)
         if count >= _MIN_FIELDS:
             found.append((value, count))
-    for child in ast.iter_child_nodes(node):
+    for child in children(node):
         found.extend(_scan_for_results(child))
     return found
 

{sarj_python_lint-0.26.0 → sarj_python_lint-0.27.0}/src/sarj_python_lint/rules/inefficient_string_concat_in_loop.py

@@ -48,6 +48,7 @@ import ast
 from typing import TYPE_CHECKING, TypeGuard, override
 
 from sarj_python_lint.rule_base import Diagnostic, Rule, parse_or_none
+from sarj_python_lint.rules._ast_index import children, walk
 from sarj_python_lint.rules._paths import is_generated_source
 
 
@@ -219,7 +220,7 @@ def _test_names(test: ast.expr) -> set[str]:
         The unparsed reads appearing in the test expression.
 
     """
-    return {ast.unparse(n) for n in ast.walk(test) if isinstance(n, (ast.Name, ast.Attribute))}
+    return {ast.unparse(n) for n in walk(test) if isinstance(n, (ast.Name, ast.Attribute))}
 
 
 def _loop_read_names(loop: ast.For | ast.AsyncFor | ast.While) -> frozenset[str]:
@@ -248,7 +249,7 @@ def _loop_read_names(loop: ast.For | ast.AsyncFor | ast.While) -> frozenset[str]
                 if other is not None:
                     stack.append(other)
                 continue
-        stack.extend(ast.iter_child_nodes(node))
+        stack.extend(children(node))
         if isinstance(node, (ast.Name, ast.Attribute)) and isinstance(node.ctx, ast.Load):
             reads.add(ast.unparse(node))
     return frozenset(reads)
@@ -288,7 +289,7 @@ def _collect_reassignments(node: ast.AST, reassigns: dict[str, list[int]]) -> No
         and not _is_accumulation_assign(node.target, node.value)
     ):
         reassigns.setdefault(ast.unparse(node.target), []).append(node.target.lineno)
-    for child in ast.iter_child_nodes(node):
+    for child in children(node):
         _collect_reassignments(child, reassigns)
 
 
@@ -364,7 +365,7 @@ def _collect_string_targets(node: ast.AST, names: set[str]) -> None:
         and _looks_like_string(node.value)
     ):
         names.add(node.target.id)
-    for child in ast.iter_child_nodes(node):
+    for child in children(node):
         _collect_string_targets(child, names)
 
 

{sarj_python_lint-0.26.0 → sarj_python_lint-0.27.0}/src/sarj_python_lint/rules/interaction_only_test.py

@@ -170,6 +170,7 @@ import re
 from typing import TYPE_CHECKING, override
 
 from sarj_python_lint.rule_base import Diagnostic, Rule, parse_or_none
+from sarj_python_lint.rules._ast_index import nodes, walk
 from sarj_python_lint.rules._paths import is_test_path
 
 
@@ -471,7 +472,7 @@ def _function_defs(tree: ast.Module) -> list[ast.FunctionDef | ast.AsyncFunction
         The definitions, in `ast.walk` order.
 
     """
-    return [node for node in ast.walk(tree) if isinstance(node, _FUNC_NODES)]
+    return nodes(tree, *_FUNC_NODES)
 
 
 def _collectible_tests(tree: ast.Module) -> list[ast.FunctionDef | ast.AsyncFunctionDef]:
@@ -531,7 +532,7 @@ def _direct_counts(node: ast.FunctionDef | ast.AsyncFunctionDef, local: frozense
     interaction = 0
     negative = 0
     targets: set[str] = set()
-    for child in ast.walk(node):
+    for child in walk(node):
         kind = _classify(child, local)
         if kind is None:
             continue
@@ -557,7 +558,7 @@ def _interaction_targets(expr: ast.AST) -> set[str]:
 
     """
     targets: set[str] = set()
-    for node in ast.walk(expr):
+    for node in walk(expr):
         if isinstance(node, ast.Attribute) and node.attr in _MOCK_STATE_ATTRS:
             targets.add(_dotted(node.value))
         elif (
@@ -640,7 +641,7 @@ def _call_name(func: ast.expr) -> str | None:
 
 
 def _mentions_mock_state(expr: ast.expr) -> bool:
-    return any(_is_mock_state_read(node) for node in ast.walk(expr))
+    return any(_is_mock_state_read(node) for node in walk(expr))
 
 
 def _is_mock_state_read(node: ast.AST) -> bool:
@@ -702,7 +703,7 @@ def _chain_has_fluent_marker(node: ast.expr) -> bool:
 
 def _called_names(node: ast.AST) -> set[str]:
     names: set[str] = set()
-    for child in ast.walk(node):
+    for child in walk(node):
         if isinstance(child, ast.Call):
             func = child.func
             if isinstance(func, ast.Attribute):

{sarj_python_lint-0.26.0 → sarj_python_lint-0.27.0}/src/sarj_python_lint/rules/kwarg_heavy_construction_in_test.py

@@ -62,6 +62,7 @@ from collections import Counter
 from typing import TYPE_CHECKING, override
 
 from sarj_python_lint.rule_base import Diagnostic, Rule, parse_or_none
+from sarj_python_lint.rules._ast_index import nodes
 from sarj_python_lint.rules._paths import is_test_path
 
 
@@ -166,9 +167,7 @@ class _KwargHeavyVisitor(ast.NodeVisitor):
             The wide constructions that actually have duplication to extract.
 
         """
-        counts = Counter(
-            name for n in ast.walk(tree) if isinstance(n, ast.Call) and (name := _callee_name(n.func)) is not None
-        )
+        counts = Counter(name for n in nodes(tree, ast.Call) if (name := _callee_name(n.func)) is not None)
         return [
             (node, count)
             for node, count in self.hits

{sarj_python_lint-0.26.0 → sarj_python_lint-0.27.0}/src/sarj_python_lint/rules/kwonly_same_type_params.py

@@ -100,6 +100,7 @@ import re
 from typing import TYPE_CHECKING, override
 
 from sarj_python_lint.rule_base import Diagnostic, Rule, parse_or_none
+from sarj_python_lint.rules._ast_index import nodes, walk
 from sarj_python_lint.rules._paths import is_generated_source, is_test_path
 
 
@@ -200,20 +201,24 @@ class KwonlySameTypeParams(Rule):
         tree = parse_or_none(path, source)
         if tree is None:
             return []
+        # The signature test is a local, allocation-free predicate; the three
+        # name/id tables each scan the whole module. Screening on the signature
+        # first means a module with no swap-prone signature at all — the common
+        # case — never builds a table.
+        candidates = [
+            (node, offending)
+            for node in nodes(tree, ast.FunctionDef, ast.AsyncFunctionDef)
+            if not _is_exempt(node) and (offending := _swap_prone_annotation(node.args)) is not None
+        ]
+        if not candidates:
+            return []
         value_referenced = _value_referenced_names(tree)
         overload_names = _overload_stub_names(tree)
         method_ids = _method_node_ids(tree)
         diags: list[Diagnostic] = []
-        for node in ast.walk(tree):
-            if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-                continue
-            if _is_exempt(node):
-                continue
+        for node, offending in candidates:
             if node.name in value_referenced or node.name in overload_names:
                 continue
-            offending = _swap_prone_annotation(node.args)
-            if offending is None:
-                continue
             # Checked last: `_calls_super_same_name` walks the body, so it runs
             # only for the few signatures that would otherwise be reported.
             if id(node) in method_ids and (node.name in _DUCK_PROTOCOL_METHODS or _calls_super_same_name(node)):
@@ -282,8 +287,7 @@ def _method_node_ids(tree: ast.AST) -> frozenset[int]:
     """
     return frozenset(
         id(child)
-        for node in ast.walk(tree)
-        if isinstance(node, ast.ClassDef)
+        for node in nodes(tree, ast.ClassDef)
         for child in node.body
         if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef))
     )
@@ -306,7 +310,7 @@ def _calls_super_same_name(node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool
         and isinstance(inner := func.value, ast.Call)
         and isinstance(inner.func, ast.Name)
         and inner.func.id == "super"
-        for call in ast.walk(node)
+        for call in walk(node)
         if isinstance(call, ast.Call)
     )
 
@@ -444,11 +448,9 @@ def _value_referenced_names(tree: ast.AST) -> frozenset[str]:
         The set of names loaded outside call position.
 
     """
-    call_funcs = {id(node.func) for node in ast.walk(tree) if isinstance(node, ast.Call)}
+    call_funcs = {id(node.func) for node in nodes(tree, ast.Call)}
     return frozenset(
-        node.id
-        for node in ast.walk(tree)
-        if isinstance(node, ast.Name) and isinstance(node.ctx, ast.Load) and id(node) not in call_funcs
+        node.id for node in nodes(tree, ast.Name) if isinstance(node.ctx, ast.Load) and id(node) not in call_funcs
     )
 
 
@@ -464,9 +466,8 @@ def _overload_stub_names(tree: ast.AST) -> frozenset[str]:
     """
     return frozenset(
         node.name
-        for node in ast.walk(tree)
-        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
-        and any(
+        for node in nodes(tree, ast.FunctionDef, ast.AsyncFunctionDef)
+        if any(
             (isinstance(dec, ast.Name) and dec.id == "overload")
             or (isinstance(dec, ast.Attribute) and dec.attr == "overload")
             for dec in node.decorator_list