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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sarj-python-lint
-Version: 0.26.0
+Version: 0.28.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.28.0}/pyproject.toml

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

sarj_python_lint-0.28.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.26.0 → sarj_python_lint-0.28.0}/src/sarj_python_lint/rules/_comments.py

@@ -397,7 +397,12 @@ def restates(comment_tokens: Sequence[str], code: Iterable[str]) -> bool:
 _LAYOUT_TOKENS = frozenset({tokenize.NL, tokenize.NEWLINE, tokenize.INDENT, tokenize.DEDENT})
 _NON_CODE_TOKENS = _LAYOUT_TOKENS | frozenset({tokenize.COMMENT, tokenize.ENCODING, tokenize.ENDMARKER})
 
-_Scan = tuple[list[tuple[int, int, str]], list[tuple[int, int, str]], set[int], int]
+# `(line, col0, body, standalone)` for every comment, in source order. This is
+# what `_suppression_comments` needs, and it is a by-product of the pass below
+# rather than a reason to run a second one — see `all_comments`.
+_Ordered = list[tuple[int, int, str, bool]]
+
+_Scan = tuple[list[tuple[int, int, str]], list[tuple[int, int, str]], set[int], int, _Ordered]
 
 _last_scan: tuple[str, _Scan] | None = None
 
@@ -405,6 +410,7 @@ _last_scan: tuple[str, _Scan] | None = None
 def _scan(source: str) -> _Scan:
     standalone: list[tuple[int, int, str]] = []
     trailing: list[tuple[int, int, str]] = []
+    ordered: _Ordered = []
     nested: set[int] = set()
     first_code_line = 1 << 30
     prev_end_row = 0
@@ -412,8 +418,11 @@ def _scan(source: str) -> _Scan:
     readline = io.StringIO(source).readline
     for tok in tokenize.generate_tokens(readline):
         if tok.type == tokenize.COMMENT:
-            entry = (tok.start[0], tok.start[1], tok.string.lstrip("#").strip())
-            (trailing if tok.start[0] == prev_end_row else standalone).append(entry)
+            body = tok.string.lstrip("#").strip()
+            entry = (tok.start[0], tok.start[1], body)
+            is_standalone = tok.start[0] != prev_end_row
+            (standalone if is_standalone else trailing).append(entry)
+            ordered.append((tok.start[0], tok.start[1], body, is_standalone))
             if depth > 0:
                 nested.add(tok.start[0])
         elif tok.type == tokenize.OP:
@@ -425,7 +434,28 @@ def _scan(source: str) -> _Scan:
             prev_end_row = tok.end[0]
         if tok.type not in _NON_CODE_TOKENS:
             first_code_line = min(first_code_line, tok.start[0])
-    return standalone, trailing, nested, first_code_line
+    return standalone, trailing, nested, first_code_line, ordered
+
+
+def all_comments(source: str) -> tuple[_Ordered, int]:
+    """Return every comment as `(line, col0, body, standalone)`, plus the first code line.
+
+    Exists so the suppression rules (SARJ038/054) can share this module's
+    tokenize pass instead of running a second one. Both scanners computed the
+    same three facts — comment text, whether it stands alone on its line, and
+    where the first real code token is — from identical token-class sets, so the
+    second pass was pure duplicated work: SARJ038 alone spent ~4% of total rule
+    time on it.
+
+    `col0` is 0-based, matching this module's other accessors; the suppression
+    layer adds one for its 1-based `Comment.col`.
+
+    Returns:
+        The ordered comments and the first code line's row.
+
+    """
+    _, _, _, first_code_line, ordered = _scan_memo(source)
+    return ordered, first_code_line
 
 
 def _scan_memo(source: str) -> _Scan:
@@ -482,7 +512,7 @@ def standalone_comments(source: str) -> tuple[list[tuple[int, int, str]], int]:
         The standalone comments and the first code line's row.
 
     """
-    standalone, _, _, first_code_line = _scan_memo(source)
+    standalone, _, _, first_code_line, _ = _scan_memo(source)
     return standalone, first_code_line
 
 

sarj_python_lint-0.28.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.28.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.28.0}/src/sarj_python_lint/rules/_registry.py

@@ -69,7 +69,6 @@ from sarj_python_lint.rules.prefer_non_nullable_collection import (
     PreferNonNullableCollection,
 )
 from sarj_python_lint.rules.prefer_or_pattern import PreferOrPattern
-from sarj_python_lint.rules.prefer_pattern_matching import PreferPatternMatching
 from sarj_python_lint.rules.prefer_real_store_in_tests import PreferRealStoreInTests
 from sarj_python_lint.rules.prefer_self_type_annotation import PreferSelfTypeAnnotation
 from sarj_python_lint.rules.prefer_str_enum import PreferStrEnum
@@ -84,9 +83,6 @@ from sarj_python_lint.rules.prefer_walrus_comprehension_filter import (
 )
 from sarj_python_lint.rules.prefer_walrus_regex_match import PreferWalrusRegexMatch
 from sarj_python_lint.rules.prefer_walrus_stream_loop import PreferWalrusStreamLoop
-from sarj_python_lint.rules.primary_export_file_name import (
-    PrimaryExportFileName,
-)
 from sarj_python_lint.rules.pydantic_at_boundaries import PydanticAtBoundaries
 from sarj_python_lint.rules.redundant_docstring import RedundantDocstring
 from sarj_python_lint.rules.require_port_for_service import RequirePortForService
@@ -173,11 +169,9 @@ REGISTRY: dict[str, type[Rule]] = {
     PreferFstringOverConcat.id: PreferFstringOverConcat,
     PreferMatchPatternDestructuring.id: PreferMatchPatternDestructuring,
     PreferOrPattern.id: PreferOrPattern,
-    PreferPatternMatching.id: PreferPatternMatching,
     RequirePortForService.id: RequirePortForService,
     PreferNonNullableCollection.id: PreferNonNullableCollection,
     PreferMatchTypeDispatch.id: PreferMatchTypeDispatch,
-    PrimaryExportFileName.id: PrimaryExportFileName,
     PreferWalrusRegexMatch.id: PreferWalrusRegexMatch,
     PreferWalrusComprehensionFilter.id: PreferWalrusComprehensionFilter,
     PreferWalrusStreamLoop.id: PreferWalrusStreamLoop,

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

@@ -9,17 +9,9 @@ drifting apart on what "file-level" means.
 
 from __future__ import annotations
 
-from dataclasses import dataclass, replace
-import io
-import tokenize
+from dataclasses import dataclass
 
-
-# Sentinel row for "this file has no statement at all" (empty / comments-only):
-# every comment then counts as preceding the first statement.
-_NO_STATEMENT_LINE = 1 << 30
-
-_LAYOUT_TOKENS = frozenset({tokenize.NL, tokenize.NEWLINE, tokenize.INDENT, tokenize.DEDENT})
-_NON_STATEMENT_TOKENS = _LAYOUT_TOKENS | frozenset({tokenize.COMMENT, tokenize.ENCODING, tokenize.ENDMARKER})
+from sarj_python_lint.rules._comments import all_comments
 
 
 @dataclass(frozen=True, slots=True)
@@ -34,7 +26,7 @@ class Comment:
 
 
 def scan_comments(source: str) -> list[Comment]:
-    """Tokenize `source` and describe every comment in it.
+    """Describe every comment in `source`, in source order.
 
     A comment is standalone when no token ended on its line before it, and
     precedes the first statement when it sits above the first non-comment,
@@ -43,29 +35,28 @@ def scan_comments(source: str) -> list[Comment]:
     Anything `tokenize` cannot lex propagates as `tokenize.TokenError`,
     `IndentationError` or `SyntaxError`; callers treat that as "no diagnostics".
 
+    Built from `_comments.all_comments`, which is the same tokenize pass the
+    comment-hygiene rules already run. This module used to lex the file a second
+    time to compute exactly the same three facts from identical token-class
+    sets, which cost SARJ038 ~4% of total rule time for no additional
+    information. The memo now lives in one place rather than two.
+
     Returns:
-        Every comment, in source order.
+        Every comment, in source order. `Comment` is frozen and the list is
+        read-only to callers.
 
     """
-    comments: list[Comment] = []
-    first_statement_line = _NO_STATEMENT_LINE
-    prev_end_row = 0
-    readline = io.StringIO(source).readline
-    for tok in tokenize.generate_tokens(readline):
-        if tok.type == tokenize.COMMENT:
-            comments.append(
-                Comment(
-                    line=tok.start[0],
-                    col=tok.start[1] + 1,
-                    body=comment_body(tok.string),
-                    standalone=tok.start[0] != prev_end_row,
-                )
-            )
-        if tok.type not in _LAYOUT_TOKENS:
-            prev_end_row = tok.end[0]
-        if tok.type not in _NON_STATEMENT_TOKENS:
-            first_statement_line = min(first_statement_line, tok.start[0])
-    return [replace(c, before_first_statement=c.line < first_statement_line) for c in comments]
+    ordered, first_statement_line = all_comments(source)
+    return [
+        Comment(
+            line=line,
+            col=col + 1,
+            body=body,
+            standalone=standalone,
+            before_first_statement=line < first_statement_line,
+        )
+        for line, col, body, standalone in ordered
+    ]
 
 
 def comment_body(raw: str) -> str:

{sarj_python_lint-0.26.0 → sarj_python_lint-0.28.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.28.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.28.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.28.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)