claude-dev-env 2.27.0 → 2.28.1

package/hooks/blocking/code_rules_dead_split_branch.py

@@ -1,225 +0,0 @@
-"""Dead-conditional-branch check for a truthiness test on an always-non-empty split."""
-
-import ast
-import sys
-from pathlib import Path
-
-_blocking_directory = str(Path(__file__).resolve().parent)
-_hooks_directory = str(Path(__file__).resolve().parent.parent)
-if _blocking_directory not in sys.path:
-    sys.path.insert(0, _blocking_directory)
-if _hooks_directory not in sys.path:
-    sys.path.insert(0, _hooks_directory)
-
-from code_rules_path_utils import (  # noqa: E402
-    is_config_file,
-)
-from code_rules_shared import (  # noqa: E402
-    _collect_annotated_arguments,
-    _walk_skipping_nested_function_defs,
-    is_test_file,
-)
-
-from hooks_constants.code_rules_enforcer_constants import (  # noqa: E402
-    ALL_ALWAYS_NONEMPTY_SPLIT_METHOD_NAMES,
-    DEAD_SPLIT_BRANCH_MESSAGE_SUFFIX,
-    MAX_DEAD_SPLIT_BRANCH_ISSUES,
-)
-
-
-def _is_separator_split_call(call_node: ast.Call) -> bool:
-    """Return True for an ``x.split(sep)`` / ``x.rsplit(sep)`` with a non-empty separator.
-
-    ``str.split`` and ``bytes.split`` return a list holding at least one element
-    whenever a separator argument is supplied, so the result is always truthy.
-    Requiring a non-empty string or bytes literal separator keeps the guarantee
-    airtight: ``split()`` with no argument can return an empty list, and an
-    empty separator raises at runtime. The receiver is restricted to a bare
-    ``Name`` or a string/bytes literal so an intermediate attribute chain such
-    as a pandas ``s.str.split(",")`` — whose result is a Series, not a list —
-    is not treated as an always-non-empty split.
-
-    Args:
-        call_node: The call expression on the right-hand side of an assignment.
-
-    Returns:
-        True when the call is a separator-bearing split that never returns an
-        empty list.
-    """
-    function_node = call_node.func
-    if not isinstance(function_node, ast.Attribute):
-        return False
-    if function_node.attr not in ALL_ALWAYS_NONEMPTY_SPLIT_METHOD_NAMES:
-        return False
-    receiver_node = function_node.value
-    if isinstance(receiver_node, ast.Constant):
-        if not isinstance(receiver_node.value, (str, bytes)):
-            return False
-    elif not isinstance(receiver_node, ast.Name):
-        return False
-    if not call_node.args:
-        return False
-    first_argument = call_node.args[0]
-    if not isinstance(first_argument, ast.Constant):
-        return False
-    separator_value = first_argument.value
-    if not isinstance(separator_value, (str, bytes)):
-        return False
-    return len(separator_value) > 0
-
-
-def _separator_split_target_names(
-    function_node: ast.FunctionDef | ast.AsyncFunctionDef,
-) -> set[str]:
-    """Return names bound exactly once in the function from a separator split.
-
-    A name qualifies when its single binding in the function body is an
-    assignment whose value is a separator-bearing ``split`` / ``rsplit`` call,
-    so the bound list is always truthy. A name bound more than once, or also a
-    parameter, is excluded because a later rebinding could make it falsy.
-
-    Args:
-        function_node: The function whose body is inspected.
-
-    Returns:
-        The set of always-truthy split-result names safe to reason about.
-    """
-    all_store_counts: dict[str, int] = {}
-    all_split_names: set[str] = set()
-    for each_statement in function_node.body:
-        for each_node in _walk_skipping_nested_function_defs(each_statement):
-            if isinstance(each_node, ast.Name) and isinstance(each_node.ctx, ast.Store):
-                all_store_counts[each_node.id] = (
-                    all_store_counts.get(each_node.id, 0) + 1
-                )
-            if not isinstance(each_node, ast.Assign):
-                continue
-            if len(each_node.targets) != 1:
-                continue
-            assignment_target = each_node.targets[0]
-            if not isinstance(assignment_target, ast.Name):
-                continue
-            if isinstance(each_node.value, ast.Call) and _is_separator_split_call(
-                each_node.value
-            ):
-                all_split_names.add(assignment_target.id)
-    all_parameter_names = {
-        each_argument.arg
-        for each_argument in _collect_annotated_arguments(function_node)
-    }
-    return {
-        each_name
-        for each_name in all_split_names
-        if all_store_counts.get(each_name, 0) == 1
-        and each_name not in all_parameter_names
-    }
-
-
-def _truthiness_target(
-    test_node: ast.expr, all_candidate_names: set[str]
-) -> str | None:
-    """Return the candidate name a bare ``Name`` truthiness test reads, else None."""
-    if isinstance(test_node, ast.Name) and test_node.id in all_candidate_names:
-        return test_node.id
-    return None
-
-
-def _negated_truthiness_target(
-    test_node: ast.expr, all_candidate_names: set[str]
-) -> str | None:
-    """Return the candidate name a ``not Name`` test reads, else None."""
-    if not isinstance(test_node, ast.UnaryOp) or not isinstance(test_node.op, ast.Not):
-        return None
-    operand = test_node.operand
-    if isinstance(operand, ast.Name) and operand.id in all_candidate_names:
-        return operand.id
-    return None
-
-
-def _branch_finding_for_node(
-    node: ast.AST, all_candidate_names: set[str]
-) -> tuple[int, str] | None:
-    """Return ``(line, name)`` when a node carries a dead branch, else None.
-
-    A conditional expression always carries an else arm, so any truthiness test
-    on a candidate name is a dead branch. An ``if`` statement only carries a
-    dead else when it has one, while an ``if not name`` statement always has a
-    dead body.
-    """
-    if isinstance(node, ast.IfExp):
-        truthy_name = _truthiness_target(node.test, all_candidate_names)
-        if truthy_name is not None:
-            return node.lineno, truthy_name
-        return _negated_branch_finding(node.test, node.lineno, all_candidate_names)
-    if isinstance(node, ast.If):
-        truthy_name = _truthiness_target(node.test, all_candidate_names)
-        if truthy_name is not None and node.orelse:
-            return node.lineno, truthy_name
-        return _negated_branch_finding(node.test, node.lineno, all_candidate_names)
-    return None
-
-
-def _negated_branch_finding(
-    test_node: ast.expr, line_number: int, all_candidate_names: set[str]
-) -> tuple[int, str] | None:
-    negated_name = _negated_truthiness_target(test_node, all_candidate_names)
-    if negated_name is not None:
-        return line_number, negated_name
-    return None
-
-
-def _dead_branch_findings(
-    function_node: ast.FunctionDef | ast.AsyncFunctionDef,
-    all_candidate_names: set[str],
-) -> list[tuple[int, str]]:
-    """Return every ``(line, name)`` dead-branch finding in the function body."""
-    all_findings: list[tuple[int, str]] = []
-    for each_statement in function_node.body:
-        for each_node in _walk_skipping_nested_function_defs(each_statement):
-            finding = _branch_finding_for_node(each_node, all_candidate_names)
-            if finding is not None:
-                all_findings.append(finding)
-    return all_findings
-
-
-def check_dead_split_truthiness_branch(content: str, file_path: str) -> list[str]:
-    """Flag a conditional whose branch is unreachable after a separator split.
-
-    ``str.split(sep)`` and ``bytes.split(sep)`` with a separator always return a
-    list holding at least one element, so a value bound from such a call is
-    always truthy. A conditional that tests that value's truthiness carries a
-    dead branch: ``parts[0] if parts else fallback`` never reaches ``fallback``,
-    and ``if not parts:`` never runs its body. Both the conditional-expression
-    form and the ``if`` / ``if not`` statement form are reported, scoped to a
-    value bound exactly once in the function from a separator split. Config
-    files and test files are exempt.
-
-    Args:
-        content: The source text to inspect.
-        file_path: The path the source will be written to, used for exemptions.
-
-    Returns:
-        One issue per dead conditional branch found, capped at the module limit.
-    """
-    if is_test_file(file_path) or is_config_file(file_path):
-        return []
-    try:
-        tree = ast.parse(content)
-    except SyntaxError:
-        return []
-    issues: list[str] = []
-    for each_function_node in ast.walk(tree):
-        if not isinstance(each_function_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            continue
-        all_candidate_names = _separator_split_target_names(each_function_node)
-        if not all_candidate_names:
-            continue
-        for each_line, each_name in _dead_branch_findings(
-            each_function_node, all_candidate_names
-        ):
-            issues.append(
-                f"Line {each_line}: {each_name!r} {DEAD_SPLIT_BRANCH_MESSAGE_SUFFIX}"
-            )
-            if len(issues) >= MAX_DEAD_SPLIT_BRANCH_ISSUES:
-                return issues
-    return issues

package/hooks/blocking/code_rules_mock_completeness.py

@@ -1,295 +0,0 @@
-"""Incomplete-mock test-quality check and its scope-shadowing helpers."""
-
-import ast
-import sys
-from pathlib import Path
-
-_blocking_directory = str(Path(__file__).resolve().parent)
-_hooks_directory = str(Path(__file__).resolve().parent.parent)
-if _blocking_directory not in sys.path:
-    sys.path.insert(0, _blocking_directory)
-if _hooks_directory not in sys.path:
-    sys.path.insert(0, _hooks_directory)
-
-from code_rules_shared import (  # noqa: E402
-    is_test_file,
-)
-
-from hooks_constants.code_rules_enforcer_constants import (  # noqa: E402
-    ALL_BUILTIN_DICT_METHOD_NAMES,
-)
-
-
-def _collect_mock_dict_keys(assign_value: ast.expr) -> set[str] | None:
-    """Return the string key set for a dict literal, or None if not a dict literal."""
-    if not isinstance(assign_value, ast.Dict):
-        return None
-    key_names: set[str] = set()
-    for each_key in assign_value.keys:
-        if isinstance(each_key, ast.Constant) and isinstance(each_key.value, str):
-            key_names.add(each_key.value)
-    return key_names
-
-
-def _target_binds_name(target_node: ast.AST, variable_name: str) -> bool:
-    """Return True when an assignment target binds variable_name.
-
-    Handles the recursive assignment target shapes Python permits:
-    a bare ``Name``, a ``Tuple`` or ``List`` of targets (including
-    nested ones), and a ``Starred`` wrapper around any of the above.
-    """
-    if isinstance(target_node, ast.Name):
-        return target_node.id == variable_name
-    if isinstance(target_node, (ast.Tuple, ast.List)):
-        return any(_target_binds_name(each_element, variable_name) for each_element in target_node.elts)
-    if isinstance(target_node, ast.Starred):
-        return _target_binds_name(target_node.value, variable_name)
-    return False
-
-
-def _function_arguments_bind_name(
-    arguments_node: ast.arguments,
-    variable_name: str,
-) -> bool:
-    """Return True when any parameter slot declares variable_name."""
-    all_positional_arguments = list(arguments_node.posonlyargs) + list(arguments_node.args)
-    for each_argument in all_positional_arguments + list(arguments_node.kwonlyargs):
-        if each_argument.arg == variable_name:
-            return True
-    if arguments_node.vararg is not None and arguments_node.vararg.arg == variable_name:
-        return True
-    if arguments_node.kwarg is not None and arguments_node.kwarg.arg == variable_name:
-        return True
-    return False
-
-
-def _node_binds_name(node: ast.AST, variable_name: str) -> bool:
-    """Return True when a single AST node binds variable_name in its enclosing scope."""
-    if isinstance(node, ast.Assign):
-        return any(_target_binds_name(each_target, variable_name) for each_target in node.targets)
-    if isinstance(node, ast.AnnAssign):
-        return _target_binds_name(node.target, variable_name)
-    if isinstance(node, ast.AugAssign):
-        return _target_binds_name(node.target, variable_name)
-    if isinstance(node, (ast.For, ast.AsyncFor)):
-        return _target_binds_name(node.target, variable_name)
-    if isinstance(node, (ast.With, ast.AsyncWith)):
-        for each_item in node.items:
-            optional_target = each_item.optional_vars
-            if optional_target is not None and _target_binds_name(optional_target, variable_name):
-                return True
-        return False
-    if isinstance(node, ast.ExceptHandler):
-        return node.name == variable_name
-    if isinstance(node, ast.NamedExpr):
-        return _target_binds_name(node.target, variable_name)
-    if isinstance(node, (ast.Import, ast.ImportFrom)):
-        for each_alias in node.names:
-            bound_name = each_alias.asname if each_alias.asname is not None else each_alias.name.split(".")[0]
-            if bound_name == variable_name:
-                return True
-        return False
-    if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
-        return node.name == variable_name
-    return False
-
-
-def _body_binds_name_recursively(all_body_statements: list[ast.stmt], variable_name: str) -> bool:
-    """Return True when any node reachable within all_body_statements binds variable_name.
-
-    Walks the body using a stack, descending into control-flow constructs
-    (if/for/while/try/with) but treating nested function, async-function,
-    class, and lambda definitions as opaque: their bodies belong to a
-    different scope and do not affect bindings in the enclosing one.
-    Function/class definitions themselves still bind their own name in
-    the enclosing scope, which is handled by _node_binds_name.
-    """
-    nodes_to_visit: list[ast.AST] = list(all_body_statements)
-    while nodes_to_visit:
-        current_node = nodes_to_visit.pop()
-        if _node_binds_name(current_node, variable_name):
-            return True
-        if isinstance(current_node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef, ast.Lambda)):
-            continue
-        nodes_to_visit.extend(ast.iter_child_nodes(current_node))
-    return False
-
-
-def _scope_shadows_name(
-    scope_node: ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef,
-    variable_name: str,
-) -> bool:
-    """Return True when scope_node locally binds variable_name.
-
-    Detects every binding form Python treats as a local assignment:
-    plain ``Assign``, annotated ``AnnAssign``, augmented ``AugAssign``,
-    ``for`` targets, ``with`` as-targets, ``except`` handler names,
-    walrus ``NamedExpr`` targets, ``import`` and ``from`` bindings
-    (base name or ``as`` alias), nested function/class definitions
-    (whose own name binds locally), and function parameters for
-    ``FunctionDef`` / ``AsyncFunctionDef`` scopes. Bindings are
-    detected at any nesting depth inside control-flow constructs;
-    nested function, async-function, class, and lambda bodies are
-    treated as opaque because their contents live in a different scope.
-    """
-    if isinstance(scope_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-        if _function_arguments_bind_name(scope_node.args, variable_name):
-            return True
-    return _body_binds_name_recursively(list(scope_node.body), variable_name)
-
-
-def _walk_scope_skipping_shadowed(
-    scope_node: ast.AST,
-    variable_name: str,
-) -> list[ast.AST]:
-    """Walk all nodes in a scope, skipping nested function/class bodies that shadow variable_name."""
-    collected: list[ast.AST] = []
-    nodes_to_visit: list[ast.AST] = [scope_node]
-    while nodes_to_visit:
-        current = nodes_to_visit.pop()
-        collected.append(current)
-        for each_child in ast.iter_child_nodes(current):
-            if (
-                isinstance(each_child, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef))
-                and each_child is not scope_node
-                and _scope_shadows_name(each_child, variable_name)
-            ):
-                continue
-            nodes_to_visit.append(each_child)
-    return collected
-
-
-def _collect_mock_field_accesses_in_scope(
-    scope_node: ast.AST,
-    mock_name: str,
-) -> list[tuple[str, int]]:
-    """Return (field_name, line_number) for attribute or subscript accesses on mock_name within a scope.
-
-    Skips nested function/class bodies that locally redefine the same mock
-    variable to avoid false positives from name shadowing.
-    """
-    accesses: list[tuple[str, int]] = []
-    for each_node in _walk_scope_skipping_shadowed(scope_node, mock_name):
-        if isinstance(each_node, ast.Attribute):
-            if isinstance(each_node.value, ast.Name) and each_node.value.id == mock_name:
-                if isinstance(each_node.ctx, ast.Load):
-                    if each_node.attr in ALL_BUILTIN_DICT_METHOD_NAMES:
-                        continue
-                    accesses.append((each_node.attr, each_node.lineno))
-        elif isinstance(each_node, ast.Subscript):
-            if isinstance(each_node.value, ast.Name) and each_node.value.id == mock_name:
-                if isinstance(each_node.ctx, ast.Load):
-                    slice_node = each_node.slice
-                    if isinstance(slice_node, ast.Constant) and isinstance(slice_node.value, str):
-                        accesses.append((slice_node.value, each_node.lineno))
-    return accesses
-
-
-def _collect_mock_attribute_assignments_in_scope(
-    scope_node: ast.AST,
-    mock_name: str,
-) -> set[str]:
-    """Return field names assigned on a mock variable within a scope.
-
-    Collects both attribute assignments (mock_x.field = ...) and subscript
-    assignments with constant string keys (mock_x['field'] = ...).
-
-    Skips nested function/class bodies that locally redefine the same mock
-    variable, mirroring _collect_mock_field_accesses_in_scope so an outer
-    mock's known-fields set cannot absorb assignments made on a shadowed
-    inner mock of the same name.
-    """
-    assigned_fields: set[str] = set()
-    for each_node in _walk_scope_skipping_shadowed(scope_node, mock_name):
-        if not isinstance(each_node, ast.Assign):
-            continue
-        for each_target in each_node.targets:
-            if (
-                isinstance(each_target, ast.Attribute)
-                and isinstance(each_target.value, ast.Name)
-                and each_target.value.id == mock_name
-            ):
-                assigned_fields.add(each_target.attr)
-            elif (
-                isinstance(each_target, ast.Subscript)
-                and isinstance(each_target.value, ast.Name)
-                and each_target.value.id == mock_name
-                and isinstance(each_target.slice, ast.Constant)
-                and isinstance(each_target.slice.value, str)
-            ):
-                assigned_fields.add(each_target.slice.value)
-    return assigned_fields
-
-
-def _collect_scoped_mock_definitions(
-    module_tree: ast.Module,
-) -> list[tuple[int, str, set[str], int, ast.AST]]:
-    """Return (scope_id, mock_name, declared_keys, definition_line, scope_node) for each mock.
-
-    Keyed by (scope_node id, variable_name) so the same mock name in two different
-    test functions is tracked independently. Scope is the enclosing function node,
-    or the module node for module-level assignments.
-    """
-    scope_definitions: list[tuple[int, str, set[str], int, ast.AST]] = []
-    for each_scope in ast.walk(module_tree):
-        if not isinstance(each_scope, (ast.FunctionDef, ast.AsyncFunctionDef, ast.Module)):
-            continue
-        scope_body = each_scope.body
-        for each_stmt in scope_body:
-            if not isinstance(each_stmt, ast.Assign):
-                continue
-            for each_target in each_stmt.targets:
-                if not isinstance(each_target, ast.Name):
-                    continue
-                target_name = each_target.id
-                if not (target_name.startswith("mock_") or target_name.startswith("MOCK_")):
-                    continue
-                mock_keys = _collect_mock_dict_keys(each_stmt.value)
-                if mock_keys is not None:
-                    scope_definitions.append(
-                        (id(each_scope), target_name, mock_keys, each_stmt.lineno, each_scope)
-                    )
-                elif isinstance(each_stmt.value, ast.Call):
-                    scope_definitions.append(
-                        (id(each_scope), target_name, set(), each_stmt.lineno, each_scope)
-                    )
-    return scope_definitions
-
-
-def check_incomplete_mocks(content: str, file_path: str) -> None:
-    """Emit stderr advisories when a mock dict/object is missing fields that are accessed.
-
-    Scans test files for variables named mock_* or MOCK_* whose value is a dict
-    literal. Each mock definition is keyed by (scope_node_id, variable_name) so
-    the same name in different test functions is checked independently. Advisories
-    are deduplicated per (mock_name, field_name) pair within each scope.
-
-    This is advisory-only (no return value, no blocking).
-    """
-    if not is_test_file(file_path):
-        return
-
-    try:
-        module_tree = ast.parse(content)
-    except SyntaxError:
-        return
-
-    all_scoped_definitions = _collect_scoped_mock_definitions(module_tree)
-
-    for each_scope_id, each_mock_name, each_declared_keys, each_definition_line, each_scope_node in all_scoped_definitions:  # noqa: B007
-        assigned_attributes = _collect_mock_attribute_assignments_in_scope(each_scope_node, each_mock_name)
-        all_known_fields = each_declared_keys | assigned_attributes
-        field_accesses = _collect_mock_field_accesses_in_scope(each_scope_node, each_mock_name)
-        already_advised: set[tuple[str, str]] = set()
-        for each_accessed_field, each_access_line in field_accesses:
-            if each_accessed_field in all_known_fields:
-                continue
-            advisory_key = (each_mock_name, each_accessed_field)
-            if advisory_key in already_advised:
-                continue
-            already_advised.add(advisory_key)
-            print(
-                f"[CODE_RULES advisory] Line {each_definition_line}: mock {each_mock_name}"
-                f" missing field {each_accessed_field} accessed at line {each_access_line}",
-                file=sys.stderr,
-            )

package/hooks/blocking/code_rules_scope_binding.py

@@ -1,151 +0,0 @@
-"""Lexical scope-binding collectors used by the unused-import check."""
-
-import ast
-
-from hooks_constants.stuttering_import_binding_constants import (
-    WILDCARD_IMPORT_SENTINEL,
-)
-
-
-def _attribute_root_name_if_loaded(attribute_node: ast.Attribute) -> ast.Name | None:
-    current: ast.expr = attribute_node
-    while isinstance(current, ast.Attribute):
-        current = current.value
-    if isinstance(current, ast.Name) and isinstance(current.ctx, ast.Load):
-        return current
-    return None
-
-
-class _ScopeBindingCollector(ast.NodeVisitor):
-    def __init__(self) -> None:
-        self.binding_names: set[str] = set()
-        self.global_names: set[str] = set()
-
-    def collect_arguments(self, arguments: ast.arguments) -> None:
-        for each_argument in (
-            arguments.posonlyargs
-            + arguments.args
-            + arguments.kwonlyargs
-        ):
-            self.binding_names.add(each_argument.arg)
-        if arguments.vararg is not None:
-            self.binding_names.add(arguments.vararg.arg)
-        if arguments.kwarg is not None:
-            self.binding_names.add(arguments.kwarg.arg)
-
-    def visit_Global(self, node: ast.Global) -> None:
-        self.global_names.update(node.names)
-
-    def visit_Nonlocal(self, node: ast.Nonlocal) -> None:
-        self.binding_names.update(node.names)
-
-    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
-        self.binding_names.add(node.name)
-
-    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
-        self.binding_names.add(node.name)
-
-    def visit_ClassDef(self, node: ast.ClassDef) -> None:
-        self.binding_names.add(node.name)
-
-    def visit_Lambda(self, node: ast.Lambda) -> None:
-        return None
-
-    def visit_Name(self, node: ast.Name) -> None:
-        if isinstance(node.ctx, ast.Store):
-            self.binding_names.add(node.id)
-
-    def visit_Import(self, node: ast.Import) -> None:
-        for each_alias in node.names:
-            self.binding_names.add(each_alias.asname or each_alias.name.split(".")[0])
-
-    def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
-        for each_alias in node.names:
-            if each_alias.name != WILDCARD_IMPORT_SENTINEL:
-                self.binding_names.add(each_alias.asname or each_alias.name)
-
-    def visit_ListComp(self, node: ast.ListComp) -> None:
-        return None
-
-    def visit_SetComp(self, node: ast.SetComp) -> None:
-        return None
-
-    def visit_DictComp(self, node: ast.DictComp) -> None:
-        return None
-
-    def visit_GeneratorExp(self, node: ast.GeneratorExp) -> None:
-        return None
-
-    def visit_ExceptHandler(self, node: ast.ExceptHandler) -> None:
-        if node.name is not None:
-            self.binding_names.add(node.name)
-        self.generic_visit(node)
-
-
-def _scope_binding_names(scope_node: ast.AST) -> tuple[set[str], set[str]]:
-    collector = _ScopeBindingCollector()
-    if isinstance(scope_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-        collector.collect_arguments(scope_node.args)
-        for each_statement in scope_node.body:
-            collector.visit(each_statement)
-    elif isinstance(scope_node, ast.Lambda):
-        collector.collect_arguments(scope_node.args)
-        collector.visit(scope_node.body)
-    elif isinstance(scope_node, ast.ClassDef):
-        for each_statement in scope_node.body:
-            collector.visit(each_statement)
-    return collector.binding_names, collector.global_names
-
-
-def _load_name_is_shadowed(
-    load_node: ast.AST,
-    name: str,
-    parent_by_node_id: dict[int, ast.AST],
-) -> bool:
-    current = parent_by_node_id.get(id(load_node))
-    has_passed_function_scope = False
-    while current is not None:
-        if isinstance(current, (ast.FunctionDef, ast.AsyncFunctionDef, ast.Lambda)):
-            has_passed_function_scope = True
-            binding_names, global_names = _scope_binding_names(current)
-            if name in global_names:
-                return False
-            if name in binding_names:
-                return True
-        elif isinstance(current, ast.ClassDef) and not has_passed_function_scope:
-            # Class body bindings are order-dependent (name resolution is
-            # dynamic, unlike function locals). A load before an assignment
-            # still resolves to the module-level name, so conservatively
-            # skip class-body shadow detection to avoid false positives.
-            pass
-        current = parent_by_node_id.get(id(current))
-    return False
-
-
-def _names_from_annotation_text(annotation_text: str) -> set[str]:
-    try:
-        annotation_tree = ast.parse(annotation_text, mode="eval")
-    except SyntaxError:
-        return set()
-    referenced_names: set[str] = set()
-    for each_node in ast.walk(annotation_tree):
-        if isinstance(each_node, ast.Name):
-            referenced_names.add(each_node.id)
-        elif isinstance(each_node, ast.Attribute):
-            root_name = _attribute_root_name_if_loaded(each_node)
-            if root_name is not None:
-                referenced_names.add(root_name.id)
-    return referenced_names
-
-
-def _collect_string_annotation_names(tree: ast.Module) -> set[str]:
-    referenced_names: set[str] = set()
-    for each_node in ast.walk(tree):
-        annotation = None
-        if isinstance(each_node, ast.arg):
-            annotation = each_node.annotation
-        elif isinstance(each_node, (ast.AnnAssign, ast.FunctionDef, ast.AsyncFunctionDef)):
-            annotation = each_node.annotation if isinstance(each_node, ast.AnnAssign) else each_node.returns
-        if isinstance(annotation, ast.Constant) and isinstance(annotation.value, str):
-            referenced_names.update(_names_from_annotation_text(annotation.value))
-    return referenced_names