sarj-python-lint 1.83.0__tar.gz → 1.83.1__tar.gz

{sarj_python_lint-1.83.0 → sarj_python_lint-1.83.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sarj-python-lint
-Version: 1.83.0
+Version: 1.83.1
 Summary: Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults
 Project-URL: Homepage, https://code-standards.sarj.ai/rules/python/
 Project-URL: Documentation, https://code-standards.sarj.ai/rules/python/

{sarj_python_lint-1.83.0 → sarj_python_lint-1.83.1}/pyproject.toml

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

{sarj_python_lint-1.83.0 → sarj_python_lint-1.83.1}/src/sarj_python_lint/_autofix_enums.py

@@ -164,7 +164,7 @@ class EnumFixes:
 
     def _stable_alias(self, alias: ast.TypeAlias) -> bool:
         if any(
-            bindings.get(alias.name.id, []) not in ([], [alias.name]) for bindings in self.provenance.bindings.values()
+            bindings.get(alias.name.id, ()) not in {(), (alias.name,)} for bindings in self.provenance.bindings.values()
         ):
             return False
         if any(

{sarj_python_lint-1.83.0 → sarj_python_lint-1.83.1}/src/sarj_python_lint/_autofix_repeated.py

@@ -115,7 +115,7 @@ class RepeatedLiteralFixes:
 
     def _stable_binding(self, binding: ast.Name, literal: ast.Constant, parent: ast.FunctionDef) -> bool:
         return (
-            self.provenance.bindings.get(parent, {}).get(binding.id) == [binding]
+            self.provenance.bindings.get(parent, {}).get(binding.id) == (binding,)
             and self.provenance.binding(binding.id, literal) is binding
             and binding.id not in self.provenance.external_bindings
             and (binding.lineno, binding.col_offset + 1) not in self.locations

{sarj_python_lint-1.83.0 → sarj_python_lint-1.83.1}/src/sarj_python_lint/_file_context.py

@@ -8,10 +8,12 @@ from sarj_python_lint._analysis_session import AnalysisSession
 from sarj_python_lint._source import python_source_lines, symbol_prefilter_source
 from sarj_python_lint.rules._annotation_semantics import AnnotationSemantics
 from sarj_python_lint.rules._ast_index import NodeIndex
+from sarj_python_lint.rules._binding_inventory import BindingInventory
 from sarj_python_lint.rules._fastapi import FastapiIndex
 from sarj_python_lint.rules._imports import ImportIndex
 from sarj_python_lint.rules._namespace_access import dynamic_namespace_access
 from sarj_python_lint.rules._paths import is_generated
+from sarj_python_lint.rules._runtime_bindings import RuntimeBindings
 
 
 if TYPE_CHECKING:
@@ -23,7 +25,7 @@ if TYPE_CHECKING:
     from sarj_python_lint.rules._test_provenance import TestProvenance
 
 
-@final
+@final  # ruff: ignore[too-many-public-methods] -- one file owns the lazy fact caches and their shared lifetime; splitting providers would duplicate semantic state.
 class PythonFileContext:
     def __init__(self, path: Path, source: str, session: AnalysisSession | None = None) -> None:
         self.path = path
@@ -85,6 +87,14 @@ class PythonFileContext:
     def parents(self) -> Mapping[ast.AST, ast.AST]:
         return self.node_index.parents
 
+    @cached_property
+    def binding_inventory(self) -> BindingInventory:
+        return BindingInventory.from_context(self)
+
+    @cached_property
+    def runtime_bindings(self) -> RuntimeBindings:
+        return RuntimeBindings(self, self.binding_inventory.bindings)
+
     @cached_property
     def imports(self) -> ImportIndex:
         return ImportIndex.from_tree(self._valid_tree())

sarj_python_lint-1.83.1/src/sarj_python_lint/rules/_binding_inventory.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import ast
+from collections import defaultdict
+from collections.abc import Mapping
+from dataclasses import dataclass
+from types import MappingProxyType
+from typing import TYPE_CHECKING, final
+
+
+if TYPE_CHECKING:
+    from sarj_python_lint._file_context import PythonFileContext
+
+
+_SCOPES = (
+    ast.Module,
+    ast.FunctionDef,
+    ast.AsyncFunctionDef,
+    ast.ClassDef,
+    ast.Lambda,
+    ast.ListComp,
+    ast.SetComp,
+    ast.DictComp,
+    ast.GeneratorExp,
+)
+
+
+@final
+@dataclass(frozen=True, slots=True)
+class BindingInventory:
+    parents: Mapping[ast.AST, ast.AST]
+    bindings: Mapping[ast.AST | None, Mapping[str, tuple[ast.AST, ...]]]
+    reads: Mapping[str, tuple[ast.Name, ...]]
+    wildcard: bool
+    mutated: frozenset[str]
+    external_bindings: frozenset[str]
+
+    @classmethod
+    def from_context(cls, context: PythonFileContext) -> BindingInventory:
+        parents = context.parents
+        bindings: dict[ast.AST | None, dict[str, list[ast.AST]]] = defaultdict(lambda: defaultdict(list))
+        reads: dict[str, list[ast.Name]] = defaultdict(list)
+        mutated: set[str] = set()
+        external_bindings: set[str] = set()
+        wildcard = False
+        for node in context.nodes(ast.AST):
+            if isinstance(node, ast.Name) and isinstance(node.ctx, ast.Load):
+                reads[node.id].append(node)
+            for name in _bound_names(node):
+                bindings[_binding_scope(parents, node)][name].append(node)
+                wildcard |= name == "*"
+            if isinstance(node, ast.Global | ast.Nonlocal):
+                external_bindings.update(node.names)
+            if (name := _mutated_namespace(node)) is not None:
+                mutated.add(name)
+        return cls(
+            parents=parents,
+            bindings=MappingProxyType(
+                {
+                    scope: MappingProxyType({name: tuple(nodes) for name, nodes in names.items()})
+                    for scope, names in bindings.items()
+                }
+            ),
+            reads=MappingProxyType({name: tuple(nodes) for name, nodes in reads.items()}),
+            wildcard=wildcard,
+            mutated=frozenset(mutated),
+            external_bindings=frozenset(external_bindings),
+        )
+
+    def scope(self, node: ast.AST) -> ast.AST | None:
+        return _scope(self.parents, node)
+
+
+def _mutated_namespace(node: ast.AST) -> str | None:
+    if not isinstance(node, ast.Attribute) or not isinstance(node.ctx, ast.Store | ast.Del):
+        return None
+    root = node.value
+    while isinstance(root, ast.Attribute):
+        root = root.value
+    return root.id if isinstance(root, ast.Name) else None
+
+
+def _scope(parents: Mapping[ast.AST, ast.AST], node: ast.AST) -> ast.AST | None:
+    parent = parents.get(node)
+    while parent is not None:
+        if isinstance(parent, ast.arguments) and (node in parent.defaults or node in parent.kw_defaults):
+            parent = parents.get(parent)
+        elif isinstance(parent, _SCOPES) and not (
+            (
+                isinstance(parent, ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef)
+                and node in parent.decorator_list
+            )
+            or (isinstance(parent, ast.ClassDef) and (node in parent.bases or node in parent.keywords))
+        ):
+            return parent
+        if parent is None:
+            return None
+        node = parent
+        parent = parents.get(parent)
+    return None
+
+
+def _binding_scope(parents: Mapping[ast.AST, ast.AST], node: ast.AST) -> ast.AST | None:
+    scope = _scope(parents, node)
+    parent = parents.get(node)
+    if isinstance(parent, ast.NamedExpr) and parent.target is node:
+        while isinstance(scope, ast.ListComp | ast.SetComp | ast.DictComp | ast.GeneratorExp):
+            scope = _scope(parents, scope)
+    return scope
+
+
+def _bound_names(node: ast.AST) -> tuple[str, ...]:
+    match node:
+        case ast.Name(id=name, ctx=ast.Store() | ast.Del()) | ast.arg(arg=name):
+            return (name,)
+        case ast.alias():
+            return (node.asname or node.name.partition(".")[0],)
+        case (
+            ast.FunctionDef(name=name)
+            | ast.AsyncFunctionDef(name=name)
+            | ast.ClassDef(name=name)
+            | ast.ExceptHandler(name=str() as name)
+            | ast.MatchAs(name=str() as name)
+            | ast.MatchStar(name=str() as name)
+            | ast.MatchMapping(rest=str() as name)
+        ):
+            return (name,)
+        case ast.Global(names=names) | ast.Nonlocal(names=names):
+            return tuple(names)
+        case _:
+            return ()

{sarj_python_lint-1.83.0 → sarj_python_lint-1.83.1}/src/sarj_python_lint/rules/_closed_helpers.py

@@ -115,7 +115,7 @@ def call_matches(function: ast.FunctionDef, call: ast.Call) -> bool:
 def stable_class(context: PythonFileContext, declaration: ast.ClassDef, provenance: ResourceProvenance) -> bool:
     if declaration.decorator_list or declaration.keywords or context.parents.get(declaration) is not context.tree:
         return False
-    return provenance.bindings.get(context.tree, {}).get(declaration.name) == [declaration]
+    return provenance.bindings.get(context.tree, {}).get(declaration.name) == (declaration,)
 
 
 def plain_class_members(

{sarj_python_lint-1.83.0 → sarj_python_lint-1.83.1}/src/sarj_python_lint/rules/_data_union_discriminator.py

@@ -11,6 +11,8 @@ from sarj_python_lint.rules._resource_provenance import ResourceProvenance
 
 
 if TYPE_CHECKING:
+    from collections.abc import Mapping, Sequence
+
     from sarj_python_lint._file_context import PythonFileContext
 
 
@@ -757,7 +759,7 @@ def _metadata_tuple_index(node: ast.expr) -> int | None:
     return None
 
 
-def _metadata_alias_graph(tree: ast.Module, bindings: dict[str, list[ast.AST]]) -> dict[str, set[str]]:
+def _metadata_alias_graph(tree: ast.Module, bindings: Mapping[str, Sequence[ast.AST]]) -> dict[str, set[str]]:
     graph: dict[str, set[str]] = {}
     for node in tree.body:
         binding = _value_binding(node)

{sarj_python_lint-1.83.0 → sarj_python_lint-1.83.1}/src/sarj_python_lint/rules/_project_index.py

@@ -141,6 +141,7 @@ class ClassSummary:
 
 @dataclass(frozen=True, slots=True)
 class SourceUnit:
+    # Indexes borrow tree and imports; callers must keep them unchanged for each index's lifetime.
     path: Path
     module: str | None
     source: str
@@ -194,6 +195,10 @@ def imports_outside(tree: ast.Module | None, modules: frozenset[str]) -> bool:
 
 @final
 class ProjectIndexSet:
+    # Borrowed ASTs and import mappings must stay unchanged for this index's lifetime.
+    # They remain mutable Python objects; in-place mutation can leave cached facts stale.
+    # Use with_unit() with a fresh unit, or rebuild from an updated source snapshot.
+    # Snapshots capture source strings, not later AST or import mutations.
     def __init__(self, units: Mapping[Path, SourceUnit], roots: Sequence[Path] = ()) -> None:
         self._units = MappingProxyType(dict(units))
         self._roots = tuple(roots)
@@ -550,13 +555,17 @@ class ProjectIndexSet:
     def constructor_consumers(self, unit: SourceUnit, name: str) -> frozenset[tuple[Path, str]]:
         if unit.module is None:
             return frozenset()
-        target = SymbolRef(unit.module, name)
-        consumers: set[tuple[Path, str]] = set()
+        return self._constructor_consumers.get(SymbolRef(unit.module, name), frozenset())
+
+    @cached_property
+    def _constructor_consumers(self) -> Mapping[SymbolRef, frozenset[tuple[Path, str]]]:
+        consumers: dict[SymbolRef, set[tuple[Path, str]]] = {}
         for candidate in self._units.values():
             if candidate.tree is None:
                 continue
-            consumers.update(_unit_constructor_consumers(candidate, candidate.tree, target))
-        return frozenset(consumers)
+            for symbol, owner in _unit_constructor_consumers(candidate, candidate.tree):
+                consumers.setdefault(symbol, set()).add((candidate.path, owner))
+        return MappingProxyType({symbol: frozenset(owners) for symbol, owners in consumers.items()})
 
     def constructor_operations(self, unit: SourceUnit, name: str) -> frozenset[tuple[Path, str]]:
         if unit.module is None:
@@ -582,27 +591,38 @@ class ProjectIndexSet:
     def direct_subclasses(self, unit: SourceUnit, name: str) -> frozenset[tuple[Path, str]]:
         if unit.module is None:
             return frozenset()
-        target = SymbolRef(unit.module, name)
-        return frozenset(
-            (candidate.path, node.name)
-            for candidate in self._units.values()
-            if candidate.tree is not None
-            for node in candidate.tree.body
-            if isinstance(node, ast.ClassDef)
-            and any(_direct_base_symbol(candidate, base) == target for base in node.bases)
-        )
+        return self._direct_subclasses.get(SymbolRef(unit.module, name), frozenset())
+
+    @cached_property
+    def _direct_subclasses(self) -> Mapping[SymbolRef, frozenset[tuple[Path, str]]]:
+        subclasses: dict[SymbolRef, set[tuple[Path, str]]] = {}
+        for candidate in self._units.values():
+            if candidate.tree is None:
+                continue
+            for node in candidate.tree.body:
+                if not isinstance(node, ast.ClassDef):
+                    continue
+                for base in node.bases:
+                    if (symbol := _direct_base_symbol(candidate, base)) is not None:
+                        subclasses.setdefault(symbol, set()).add((candidate.path, node.name))
+        return MappingProxyType({symbol: frozenset(owners) for symbol, owners in subclasses.items()})
 
     def typed_class_consumers(self, unit: SourceUnit, name: str) -> frozenset[tuple[Path, str]]:
         if unit.module is None:
             return frozenset()
-        target = SymbolRef(unit.module, name)
-        return frozenset(
-            (candidate.path, owner.name)
-            for candidate in self._units.values()
-            if candidate.tree is not None
-            for owner in candidate.tree.body
-            if isinstance(owner, ast.ClassDef) and _class_has_typed_dependency(candidate, owner, target)
-        )
+        return self._typed_class_consumers.get(SymbolRef(unit.module, name), frozenset())
+
+    @cached_property
+    def _typed_class_consumers(self) -> Mapping[SymbolRef, frozenset[tuple[Path, str]]]:
+        consumers: dict[SymbolRef, set[tuple[Path, str]]] = {}
+        for candidate in self._units.values():
+            if candidate.tree is None:
+                continue
+            for owner in candidate.tree.body:
+                if isinstance(owner, ast.ClassDef):
+                    for symbol in _class_typed_dependencies(candidate, owner):
+                        consumers.setdefault(symbol, set()).add((candidate.path, owner.name))
+        return MappingProxyType({symbol: frozenset(owners) for symbol, owners in consumers.items()})
 
     @cached_property
     def _mock_specs(self) -> Mapping[SymbolRef, frozenset[Path]]:
@@ -1195,29 +1215,23 @@ def _python_files(root: Path) -> Iterator[Path]:
                 yield parent / name
 
 
-def _unit_constructor_consumers(
-    candidate: SourceUnit, tree: ast.Module, target: SymbolRef
-) -> Iterator[tuple[Path, str]]:
+def _unit_constructor_consumers(candidate: SourceUnit, tree: ast.Module) -> Iterator[tuple[SymbolRef, str]]:
     for owner in tree.body:
         if not isinstance(owner, ast.ClassDef):
             continue
-        initializer = next(
-            (
-                statement
-                for statement in owner.body
-                if isinstance(statement, (ast.FunctionDef, ast.AsyncFunctionDef)) and statement.name == "__init__"
-            ),
-            None,
-        )
-        if initializer is None:
+        for symbol in _constructor_annotation_symbols(candidate, owner):
+            yield symbol, owner.name
+
+
+def _constructor_annotation_symbols(candidate: SourceUnit, owner: ast.ClassDef) -> Iterator[SymbolRef]:
+    for initializer in _direct_functions(owner):
+        if initializer.name != "__init__":
             continue
         parameters = (*initializer.args.posonlyargs, *initializer.args.args, *initializer.args.kwonlyargs)
-        if any(
-            _annotation_contains_symbol(candidate, parameter.annotation, target)
-            for parameter in parameters
-            if parameter.arg != "self"
-        ):
-            yield (candidate.path, owner.name)
+        for parameter in parameters:
+            if parameter.arg != "self":
+                yield from _annotation_symbols(candidate, parameter.annotation)
+        return
 
 
 def _unit_constructor_operations(
@@ -1374,19 +1388,16 @@ def _bound_constructor_names(node: ast.AST) -> frozenset[str]:
     return frozenset(names)
 
 
-def _class_has_typed_dependency(unit: SourceUnit, owner: ast.ClassDef, target: SymbolRef) -> bool:
+def _class_typed_dependencies(unit: SourceUnit, owner: ast.ClassDef) -> Iterator[SymbolRef]:
     for statement in owner.body:
-        if isinstance(statement, ast.AnnAssign) and _annotation_contains_symbol(unit, statement.annotation, target):
-            return True
+        if isinstance(statement, ast.AnnAssign):
+            yield from _annotation_symbols(unit, statement.annotation)
         if not isinstance(statement, (ast.FunctionDef, ast.AsyncFunctionDef)):
             continue
         parameters = (*statement.args.posonlyargs, *statement.args.args, *statement.args.kwonlyargs)
-        if any(
-            parameter.arg not in {"self", "cls"} and _annotation_contains_symbol(unit, parameter.annotation, target)
-            for parameter in parameters
-        ):
-            return True
-    return False
+        for parameter in parameters:
+            if parameter.arg not in {"self", "cls"}:
+                yield from _annotation_symbols(unit, parameter.annotation)
 
 
 def _mock_spec_targets(unit: SourceUnit, call: ast.Call) -> Iterator[SymbolRef]:
@@ -1444,17 +1455,15 @@ def _absolute_import_symbol(statement: ast.stmt, name: str) -> SymbolRef | None:
     return None
 
 
-def _annotation_contains_symbol(unit: SourceUnit, annotation: ast.expr | None, target: SymbolRef) -> bool:
+def _annotation_symbols(unit: SourceUnit, annotation: ast.expr | None) -> Iterator[SymbolRef]:
     if annotation is None:
-        return False
+        return
     if isinstance(annotation, ast.Constant) and isinstance(annotation.value, str):
-        with suppress(SyntaxError):
+        with suppress(SyntaxError, UnicodeError, RecursionError):
             annotation = ast.parse(annotation.value, mode="eval").body
-    return any(
-        _resolve(unit, candidate) == target
-        for candidate in walk_ast(annotation)
-        if isinstance(candidate, (ast.Name, ast.Attribute))
-    )
+    for candidate in walk_ast(annotation):
+        if isinstance(candidate, (ast.Name, ast.Attribute)) and (symbol := _resolve(unit, candidate)) is not None:
+            yield symbol
 
 
 def _record_import(node: ast.stmt, package: str, result: dict[str, SymbolRef]) -> None:

{sarj_python_lint-1.83.0 → sarj_python_lint-1.83.1}/src/sarj_python_lint/rules/_resource_provenance.py

@@ -8,27 +8,16 @@ from typing import TYPE_CHECKING, final
 from weakref import ReferenceType, ref
 
 from sarj_python_lint.rules._ast_index import has_own_yield
-from sarj_python_lint.rules._runtime_bindings import RuntimeBindings
 
 
 if TYPE_CHECKING:
-    from collections.abc import Callable
+    from collections.abc import Callable, Sequence
     from pathlib import Path
 
     from sarj_python_lint._file_context import PythonFileContext
+    from sarj_python_lint.rules._runtime_bindings import RuntimeBindings
 
 
-_SCOPES = (
-    ast.Module,
-    ast.FunctionDef,
-    ast.AsyncFunctionDef,
-    ast.ClassDef,
-    ast.Lambda,
-    ast.ListComp,
-    ast.SetComp,
-    ast.DictComp,
-    ast.GeneratorExp,
-)
 _RESOURCE_OWNERS = MappingProxyType(
     {
         "builtins": frozenset({"open"}),
@@ -84,8 +73,9 @@ class ResourceProvenance:
         )
         self.parents = context.parents
         self.require_static_namespace = require_static_namespace
-        self.bindings: dict[ast.AST | None, dict[str, list[ast.AST]]] = defaultdict(lambda: defaultdict(list))
-        self.reads: dict[str, list[ast.Name]] = defaultdict(list)
+        self.inventory = context.binding_inventory
+        self.bindings = self.inventory.bindings
+        self.reads = self.inventory.reads
         self._reads_by_binding: dict[str, dict[ast.AST, list[ast.Name]]] = {}
         self._runtime_reads_by_binding: dict[str, dict[ast.AST, list[ast.Name]]] = {}
         self._import_read_safety: dict[str, bool] = {}
@@ -93,22 +83,10 @@ class ResourceProvenance:
         self.async_contract_cache: dict[ast.AsyncFunctionDef, bool] = {}
         self.import_contract_cache: dict[str, bool] = {}
         self.runtime_import_cache: dict[ast.alias, bool] = {}
-        self.wildcard = False
-        self.mutated: set[str] = set()
-        self.external_bindings: set[str] = set()
-        for node in context.nodes(ast.AST):
-            if isinstance(node, ast.Name) and isinstance(node.ctx, ast.Load):
-                self.reads[node.id].append(node)
-
-            for name in _bound_names(node):
-                self.bindings[self._binding_scope(node)][name].append(node)
-                self.wildcard |= name == "*"
-            if isinstance(node, ast.Global | ast.Nonlocal):
-                self.external_bindings.update(node.names)
-            if isinstance(node, ast.Attribute) and isinstance(node.ctx, ast.Store | ast.Del):
-                root = _root_name(node)
-                if root is not None:
-                    self.mutated.add(root)
+        self.wildcard = self.inventory.wildcard
+        # Some analyses refine mutation ownership for their own policy.
+        self.mutated = set(self.inventory.mutated)
+        self.external_bindings = self.inventory.external_bindings
 
     @property
     def context(self) -> PythonFileContext:
@@ -123,31 +101,7 @@ class ResourceProvenance:
         return builtin_namespace_untouched(self.context)
 
     def scope(self, node: ast.AST) -> ast.AST | None:
-        parent = self.parents.get(node)
-        while parent is not None:
-            if isinstance(parent, ast.arguments) and (node in parent.defaults or node in parent.kw_defaults):
-                parent = self.parents.get(parent)
-            elif isinstance(parent, _SCOPES) and not (
-                (
-                    isinstance(parent, ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef)
-                    and node in parent.decorator_list
-                )
-                or (isinstance(parent, ast.ClassDef) and (node in parent.bases or node in parent.keywords))
-            ):
-                return parent
-            if parent is None:
-                return None
-            node = parent
-            parent = self.parents.get(parent)
-        return None
-
-    def _binding_scope(self, node: ast.AST) -> ast.AST | None:
-        scope = self.scope(node)
-        parent = self.parents.get(node)
-        if isinstance(parent, ast.NamedExpr) and parent.target is node:
-            while isinstance(scope, ast.ListComp | ast.SetComp | ast.DictComp | ast.GeneratorExp):
-                scope = self.scope(scope)
-        return scope
+        return self.inventory.scope(node)
 
     def binding(self, name: str, at: ast.AST) -> ast.AST | None:
         scope = self.scope(at)
@@ -160,13 +114,13 @@ class ResourceProvenance:
 
     @cached_property
     def runtime_bindings(self) -> RuntimeBindings:
-        return RuntimeBindings(self.context, self.bindings)
+        return self.context.runtime_bindings
 
     def runtime_binding(self, name: str, at: ast.AST) -> ast.AST | None:
         nodes = self.runtime_bindings.lookup(self.scope(at), name)
         if not nodes:
             return None
-        return nodes[0] if len(nodes) == 1 or self._same_import_bindings(list(nodes)) else None
+        return nodes[0] if len(nodes) == 1 or self._same_import_bindings(nodes) else None
 
     def runtime_import_name(self, node: ast.expr) -> str | None:
         root = _root_name(node)
@@ -265,7 +219,7 @@ class ResourceProvenance:
             self.context.path, module, level, facts=self.context.session.first_party
         )
 
-    def _same_import_bindings(self, nodes: list[ast.AST]) -> bool:
+    def _same_import_bindings(self, nodes: Sequence[ast.AST]) -> bool:
         targets: set[tuple[str, str | None, int, str]] = set()
         for node in nodes:
             if not isinstance(node, ast.alias):
@@ -574,25 +528,3 @@ def import_name_for_binding(expression: ast.expr, binding: ast.alias, parent: as
         case _:
             return None
     return ".".join((prefix, *reversed(attributes)))
-
-
-def _bound_names(node: ast.AST) -> tuple[str, ...]:
-    match node:
-        case ast.Name(id=name, ctx=ast.Store() | ast.Del()) | ast.arg(arg=name):
-            return (name,)
-        case ast.alias():
-            return (node.asname or node.name.partition(".")[0],)
-        case (
-            ast.FunctionDef(name=name)
-            | ast.AsyncFunctionDef(name=name)
-            | ast.ClassDef(name=name)
-            | ast.ExceptHandler(name=str() as name)
-            | ast.MatchAs(name=str() as name)
-            | ast.MatchStar(name=str() as name)
-            | ast.MatchMapping(rest=str() as name)
-        ):
-            return (name,)
-        case ast.Global(names=names) | ast.Nonlocal(names=names):
-            return tuple(names)
-        case _:
-            return ()