sarj-python-lint 1.28.6__tar.gz → 1.29.0__tar.gz

{sarj_python_lint-1.28.6 → sarj_python_lint-1.29.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sarj-python-lint
-Version: 1.28.6
+Version: 1.29.0
 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.28.6 → sarj_python_lint-1.29.0}/pyproject.toml

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

{sarj_python_lint-1.28.6 → sarj_python_lint-1.29.0}/src/sarj_python_lint/__main__.py

@@ -177,6 +177,7 @@ _DIAGNOSTIC_PRECEDENCE = MappingProxyType(
         "SARJ447": frozenset({"SARJ008"}),
         "SARJ457": frozenset({"SARJ045"}),
         "SARJ465": frozenset({"SARJ071"}),
+        "SARJ491": frozenset({"SARJ400"}),
     }
 )
 
@@ -190,6 +191,33 @@ class _OwnerLocation(NamedTuple):
     column: int
 
 
+@dataclass(frozen=True, slots=True)
+class _DiagnosticOwners:
+    docstrings: dict[int, _OwnerLocation]
+    signatures: dict[int, _OwnerLocation]
+    fields: tuple[ast.AnnAssign, ...]
+
+    def location(self, diagnostic: Diagnostic) -> _OwnerLocation:
+        if diagnostic.code in {"SARJ400", "SARJ491"}:
+            return _field_owner_location(diagnostic, self.fields)
+        owners = (
+            self.signatures
+            if diagnostic.code in {"SARJ008", "SARJ034", "SARJ093", "SARJ094", "SARJ447"}
+            else self.docstrings
+        )
+        return _OwnerLocation(*owners.get(diagnostic.line, (diagnostic.line, diagnostic.col)))
+
+    def presence(self, diags: list[Diagnostic]) -> dict[tuple[Path, int, int], dict[str, set[Severity]]]:
+        present: dict[tuple[Path, int, int], dict[str, set[Severity]]] = {}
+        for diagnostic in diags:
+            if diagnostic.code == "SARJ094" and not diagnostic.message.startswith("[return]"):
+                continue
+            location = self.location(diagnostic)
+            by_code = present.setdefault((diagnostic.path, location.line, location.column), {})
+            by_code.setdefault(diagnostic.code, set()).add(diagnostic.severity)
+        return present
+
+
 def deduplicate_diagnostics(
     diags: list[Diagnostic], *, source: str | None = None, context: PythonFileContext | None = None
 ) -> list[Diagnostic]:
@@ -203,30 +231,20 @@ def deduplicate_diagnostics(
         or ("SARJ094" in codes and not codes.isdisjoint(_DIAGNOSTIC_PRECEDENCE["SARJ094"]))
     )
     needs_composition_owners = {"SARJ066", "SARJ457"} <= codes
+    needs_field_owners = {"SARJ400", "SARJ491"} <= codes
     tree = (
         _diagnostic_owner_tree(source, context)
-        if needs_docstring_owners or needs_signature_owners or needs_composition_owners
+        if needs_docstring_owners or needs_signature_owners or needs_composition_owners or needs_field_owners
         else None
     )
     diags = _deduplicate_test_composition(diags, tree)
-    docstring_owners = _docstring_owner_locations(tree) if needs_docstring_owners else {}
-    signature_owners = _function_signature_owner_locations(tree) if needs_signature_owners else {}
-
-    def owner_location(diagnostic: Diagnostic) -> _OwnerLocation:
-        if diagnostic.code in {"SARJ008", "SARJ034", "SARJ093", "SARJ094", "SARJ447"}:
-            line, column = signature_owners.get(diagnostic.line, (diagnostic.line, diagnostic.col))
-        else:
-            line, column = docstring_owners.get(diagnostic.line, (diagnostic.line, diagnostic.col))
-        return _OwnerLocation(line, column)
-
-    present: dict[tuple[Path, int, int], dict[str, set[Severity]]] = {}
-    for diagnostic in diags:
-        if diagnostic.code == "SARJ094" and not diagnostic.message.startswith("[return]"):
-            continue
-        location = owner_location(diagnostic)
-        by_code = present.setdefault((diagnostic.path, location.line, location.column), {})
-        by_code.setdefault(diagnostic.code, set()).add(diagnostic.severity)
-    suppressed = _suppressed_diagnostics(present)
+    owners = _DiagnosticOwners(
+        docstrings=_docstring_owner_locations(tree) if needs_docstring_owners else {},
+        signatures=_function_signature_owner_locations(tree) if needs_signature_owners else {},
+        fields=_field_owners(tree) if needs_field_owners else (),
+    )
+
+    suppressed = _suppressed_diagnostics(owners.presence(diags))
     return [
         diagnostic
         for diagnostic in diags
@@ -234,8 +252,8 @@ def deduplicate_diagnostics(
             (
                 (
                     diagnostic.path,
-                    owner_location(diagnostic).line,
-                    owner_location(diagnostic).column,
+                    owners.location(diagnostic).line,
+                    owners.location(diagnostic).column,
                 ),
                 diagnostic.code,
                 diagnostic.severity,
@@ -255,6 +273,22 @@ def _diagnostic_owner_tree(source: str | None, context: PythonFileContext | None
     return None
 
 
+def _field_owners(tree: ast.Module | None) -> tuple[ast.AnnAssign, ...]:
+    if tree is None:
+        return ()
+    return tuple(node for node in ast.walk(tree) if isinstance(node, ast.AnnAssign))
+
+
+def _field_owner_location(diagnostic: Diagnostic, fields: tuple[ast.AnnAssign, ...]) -> _OwnerLocation:
+    location = (diagnostic.line, diagnostic.col - 1)
+    for field in fields:
+        start = (field.lineno, field.col_offset)
+        end = (field.end_lineno or field.lineno, field.end_col_offset or field.col_offset)
+        if start <= location < end:
+            return _OwnerLocation(field.lineno, field.col_offset + 1)
+    return _OwnerLocation(diagnostic.line, diagnostic.col)
+
+
 def _deduplicate_test_composition(diags: list[Diagnostic], tree: ast.Module | None) -> list[Diagnostic]:
     codes = {diagnostic.code for diagnostic in diags}
     if tree is None or not {"SARJ066", "SARJ457"} <= codes:

sarj_python_lint-1.29.0/src/sarj_python_lint/rules/_namespace_access.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import ast
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Mapping
+
+    from sarj_python_lint.rules._imports import ImportIndex
+
+
+_NAMESPACE_APIS = frozenset({"globals", "locals", "vars", "exec", "eval", "__import__"})
+_DYNAMIC_MEMBERS = frozenset(
+    {
+        "__dict__",
+        "__globals__",
+        "__code__",
+        "__setattr__",
+        "__delattr__",
+        "__getattribute__",
+        "f_globals",
+        "f_locals",
+        "f_builtins",
+    }
+)
+_MODULE_APIS = {
+    "sys": frozenset({"modules", "_getframe"}),
+    "importlib": frozenset({"import_module"}),
+    "builtins": _NAMESPACE_APIS,
+}
+
+
+def dynamic_namespace_access(
+    nodes: Iterable[ast.AST], imports: ImportIndex, parents: Mapping[ast.AST, ast.AST]
+) -> bool:
+    indexed = tuple(nodes)
+    aliases = _namespace_api_aliases(indexed)
+    modules = _namespace_module_bindings(indexed)
+    return any(_namespace_reference(node, aliases, modules, imports, parents) for node in indexed)
+
+
+def _namespace_api_aliases(nodes: Iterable[ast.AST]) -> set[str]:
+    aliases = set(_NAMESPACE_APIS) | {"__builtins__"}
+    for node in nodes:
+        if not isinstance(node, ast.ImportFrom) or node.module not in _MODULE_APIS:
+            continue
+        members = _MODULE_APIS[node.module]
+        aliases.update(alias.asname or alias.name for alias in node.names if alias.name in members)
+    return aliases
+
+
+def _namespace_module_bindings(nodes: Iterable[ast.AST]) -> dict[str, str]:
+    modules: dict[str, str] = {}
+    for node in nodes:
+        if not isinstance(node, ast.Import):
+            continue
+        modules.update({alias.asname or alias.name: alias.name for alias in node.names if alias.name in _MODULE_APIS})
+    return modules
+
+
+def _namespace_reference(
+    node: ast.AST,
+    aliases: set[str],
+    modules: dict[str, str],
+    imports: ImportIndex,
+    parents: Mapping[ast.AST, ast.AST],
+) -> bool:
+    if isinstance(node, ast.Attribute):
+        if node.attr in _DYNAMIC_MEMBERS:
+            return True
+        qualified = imports.resolved_qualified_name(node)
+        return qualified in {"sys.modules", "importlib.import_module"} or (
+            imports.resolved_symbol(node, sources=frozenset({"builtins"})) in _NAMESPACE_APIS
+        )
+    if not isinstance(node, ast.Name) or not isinstance(node.ctx, ast.Load):
+        return False
+    if node.id in aliases:
+        return True
+    module = modules.get(node.id)
+    if module is None:
+        return False
+    parent = parents.get(node)
+    return not isinstance(parent, ast.Attribute) or parent.value is not node or parent.attr in _MODULE_APIS[module]

sarj_python_lint-1.29.0/src/sarj_python_lint/rules/_pydantic_field_contract.py

@@ -0,0 +1,285 @@
+from __future__ import annotations
+
+import ast
+from collections import Counter
+from functools import lru_cache
+import tomllib
+from typing import TYPE_CHECKING, TypeIs
+
+from packaging.requirements import InvalidRequirement, Requirement
+from packaging.version import InvalidVersion, Version
+
+from sarj_python_lint.json_boundary import is_object_mapping
+from sarj_python_lint.rules._first_party import distribution_root
+from sarj_python_lint.rules._namespace_access import dynamic_namespace_access
+
+
+if TYPE_CHECKING:
+    from sarj_python_lint._file_context import PythonFileContext
+
+
+MODEL_SOURCES = frozenset({"pydantic", "pydantic.main"})
+FIELD_SOURCES = frozenset({"pydantic", "pydantic.fields"})
+DECORATOR_SOURCES = frozenset({"pydantic", "pydantic.functional_validators", "pydantic.functional_serializers"})
+TYPING_SOURCES = frozenset({"typing", "typing_extensions"})
+_ALIAS_VERSION = Version("2.11")
+_BUILTIN_BINDINGS = frozenset({"int", "float", "str", "list", "classmethod", "staticmethod"})
+_SENSITIVE_MODULES = frozenset({"pydantic", "typing", "typing_extensions", "builtins"})
+
+
+def direct_models(context: PythonFileContext, *, methods: bool = False) -> tuple[ast.ClassDef, ...]:
+    tree = context.tree
+    if tree is None or context.generated or context.has_wildcard_import:
+        return ()
+    if (
+        _mutated_imports(context)
+        or _ambiguous_imports(context)
+        or _escaped_imports(context)
+        or dynamic_namespace_access(context.nodes(ast.AST), context.imports, context.parents)
+    ):
+        return ()
+    return tuple(
+        node
+        for node in tree.body
+        if isinstance(node, ast.ClassDef)
+        and len(node.bases) == 1
+        and context.imports.resolves(node.bases[0], sources=MODEL_SOURCES, symbol="BaseModel")
+        and not node.decorator_list
+        and not node.keywords
+        and not node.type_params
+        and all(_plain_member(member, context, methods=methods) for member in node.body)
+    )
+
+
+def _plain_member(node: ast.stmt, context: PythonFileContext, *, methods: bool) -> bool:
+    match node:
+        case ast.AnnAssign(target=ast.Name(id=name), annotation=annotation, value=value):
+            return (
+                not name.startswith("__")
+                and _inert_annotation(annotation, context)
+                and (value is None or _inert_expr(value, context))
+            )
+        case ast.Assign(targets=targets, value=value):
+            return all(
+                isinstance(target, ast.Name) and not target.id.startswith("__") for target in targets
+            ) and _inert_expr(value, context)
+        case ast.FunctionDef(name=name) | ast.AsyncFunctionDef(name=name):
+            return (
+                methods and not name.startswith("__") and name != "model_post_init" and _inert_signature(node, context)
+            )
+        case ast.Pass() | ast.Expr(value=ast.Constant(value=str())):
+            return True
+        case _:
+            return False
+
+
+def _inert_annotation(node: ast.expr, context: PythonFileContext) -> bool:
+    if isinstance(node, ast.Constant) and isinstance(node.value, str):
+        try:
+            node = ast.parse(node.value, mode="eval").body
+        except SyntaxError:
+            return False
+    return _inert_expr(node, context)
+
+
+def _inert_signature(node: ast.FunctionDef | ast.AsyncFunctionDef, context: PythonFileContext) -> bool:
+    if node.type_params:
+        return False
+    arguments = (
+        *node.args.posonlyargs,
+        *node.args.args,
+        *node.args.kwonlyargs,
+        *((node.args.vararg,) if node.args.vararg else ()),
+        *((node.args.kwarg,) if node.args.kwarg else ()),
+    )
+    annotations = [argument.annotation for argument in arguments if argument.annotation is not None]
+    if node.returns is not None:
+        annotations.append(node.returns)
+    defaults = (*node.args.defaults, *(value for value in node.args.kw_defaults if value is not None))
+    return all(_inert_annotation(annotation, context) for annotation in annotations) and all(
+        _inert_expr(value, context) for value in defaults
+    )
+
+
+def _inert_expr(node: ast.AST, context: PythonFileContext) -> bool:
+    if isinstance(node, ast.Lambda):
+        return not node.args.defaults and not node.args.kw_defaults
+    if isinstance(node, ast.Call):
+        target = context.imports.resolved_qualified_name(node.func)
+        if target not in {
+            "pydantic.Field",
+            "pydantic.fields.Field",
+            "pydantic.ConfigDict",
+            "pydantic.config.ConfigDict",
+        }:
+            return False
+        if any(keyword.arg is None for keyword in node.keywords) or any(
+            isinstance(argument, ast.Starred) for argument in node.args
+        ):
+            return False
+    if isinstance(
+        node,
+        (ast.NamedExpr, ast.Await, ast.Yield, ast.YieldFrom, ast.ListComp, ast.SetComp, ast.DictComp, ast.GeneratorExp),
+    ):
+        return False
+    return all(_inert_expr(child, context) for child in ast.iter_child_nodes(node))
+
+
+def _mutated_imports(context: PythonFileContext) -> bool:
+    for node in context.nodes(ast.Attribute, ast.Subscript, ast.Call):
+        if isinstance(node, (ast.Attribute, ast.Subscript)) and isinstance(node.ctx, (ast.Store, ast.Del)):
+            if _sensitive_import_root(node, context):
+                return True
+        elif (
+            isinstance(node, ast.Call)
+            and node.args
+            and _is_attribute_mutator(node.func, context)
+            and _sensitive_import_root(node.args[0], context)
+        ):
+            return True
+    return False
+
+
+def _sensitive_import_root(node: ast.expr, context: PythonFileContext) -> bool:
+    while isinstance(node, (ast.Attribute, ast.Subscript)):
+        node = node.value
+    binding = context.module_imports.bindings.get(node.id) if isinstance(node, ast.Name) else None
+    return binding is not None and binding.module.partition(".")[0] in _SENSITIVE_MODULES
+
+
+def _is_attribute_mutator(node: ast.expr, context: PythonFileContext) -> bool:
+    names = {"setattr", "delattr"}
+    return (
+        isinstance(node, ast.Name) and node.id in names and context.imports.builtin_is_unshadowed(node.id)
+    ) or context.imports.resolved_symbol(node, sources=frozenset({"builtins"})) in names
+
+
+def _escaped_imports(context: PythonFileContext) -> bool:
+    for node in context.nodes(ast.Name, ast.Attribute):
+        if not isinstance(node.ctx, ast.Load) or not _sensitive_import_root(node, context):
+            continue
+        parent = context.parents.get(node)
+        if isinstance(parent, ast.Attribute) and parent.value is node:
+            continue
+        if (isinstance(node, ast.Name) and node.id == "TYPE_CHECKING") or _type_reference(node, parent):
+            continue
+        return True
+    return False
+
+
+def _type_reference(node: ast.expr, parent: ast.AST | None) -> bool:
+    match parent:
+        case ast.Call(func=func):
+            return func is node
+        case ast.ClassDef(bases=bases):
+            return node in bases
+        case ast.Subscript(value=value):
+            return value is node
+        case ast.arg(annotation=annotation) | ast.AnnAssign(annotation=annotation):
+            return annotation is node
+        case ast.FunctionDef(returns=annotation) | ast.AsyncFunctionDef(returns=annotation):
+            return annotation is node
+        case _:
+            return False
+
+
+def _ambiguous_imports(context: PythonFileContext) -> bool:
+    return any(
+        _nested_namespace_import(node, context) or _ambiguous_import(node, context)
+        for node in context.nodes(ast.Import, ast.ImportFrom)
+    )
+
+
+def _nested_namespace_import(node: ast.Import | ast.ImportFrom, context: PythonFileContext) -> bool:
+    if context.parents.get(node) is context.tree:
+        return False
+    if isinstance(node, ast.ImportFrom):
+        return (node.module or "").partition(".")[0] in _SENSITIVE_MODULES
+    return any(alias.name.partition(".")[0] in _SENSITIVE_MODULES for alias in node.names)
+
+
+def _ambiguous_import(node: ast.Import | ast.ImportFrom, context: PythonFileContext) -> bool:
+    for alias in node.names:
+        name = alias.asname or alias.name.partition(".")[0]
+        if name in _BUILTIN_BINDINGS:
+            return True
+        binding = context.module_imports.bindings.get(name)
+        if binding is None or binding.module.partition(".")[0] not in {"pydantic", "typing", "typing_extensions"}:
+            continue
+        if context.parents.get(node) is not context.tree:
+            return True
+        if isinstance(node, ast.ImportFrom) and (
+            node.level != 0 or node.module != binding.module or alias.name != binding.symbol
+        ):
+            return True
+    return False
+
+
+def unique_members(model: ast.ClassDef) -> frozenset[str]:
+    names: list[str] = []
+    for member in model.body:
+        match member:
+            case ast.FunctionDef(name=name) | ast.AsyncFunctionDef(name=name) | ast.AnnAssign(target=ast.Name(id=name)):
+                names.append(name)
+            case ast.Assign(targets=targets):
+                names.extend(target.id for target in targets if isinstance(target, ast.Name))
+            case _:
+                pass
+    return frozenset(name for name, count in Counter(names).items() if count == 1)
+
+
+def has_alias_validation_options(context: PythonFileContext) -> bool:
+    root = distribution_root(context.path, facts=context.session.first_party)
+    if root is None:
+        return False
+    try:
+        source = (root / "pyproject.toml").read_text(encoding="utf-8")
+    except OSError:
+        return False
+    return _declares_alias_validation_options(source)
+
+
+@lru_cache(maxsize=256)
+def _declares_alias_validation_options(source: str) -> bool:
+    try:
+        document = _parse_toml(source)
+    except tomllib.TOMLDecodeError:
+        return False
+    if not is_object_mapping(document):
+        return False
+    project = document.get("project")
+    if not is_object_mapping(project):
+        return False
+    dependencies = project.get("dependencies")
+    if not _is_object_list(dependencies):
+        return False
+    return any(_alias_dependency(raw) for raw in dependencies)
+
+
+def _alias_dependency(raw: object) -> bool:
+    if not isinstance(raw, str):
+        return False
+    try:
+        requirement = Requirement(raw)
+    except InvalidRequirement:
+        return False
+    if requirement.name.casefold() != "pydantic" or requirement.marker is not None or requirement.url is not None:
+        return False
+    for specifier in requirement.specifier:
+        if specifier.operator not in {">", ">=", "==", "===", "~="}:
+            continue
+        try:
+            version = Version(specifier.version.removesuffix(".*"))
+        except InvalidVersion:
+            continue
+        if version >= _ALIAS_VERSION and version.major == _ALIAS_VERSION.major:
+            return True
+    return False
+
+
+def _parse_toml(source: str) -> object:
+    return tomllib.loads(source)
+
+
+def _is_object_list(value: object) -> TypeIs[list[object]]:
+    return isinstance(value, list)

{sarj_python_lint-1.28.6 → sarj_python_lint-1.29.0}/src/sarj_python_lint/rules/_registry.py

@@ -209,12 +209,18 @@ if TYPE_CHECKING:
     from sarj_python_lint.rule_base import Rule
 from sarj_python_lint.rules.duplicate_adjacent_exception_handler import DuplicateAdjacentExceptionHandler
 from sarj_python_lint.rules.duplicate_closed_pure_helper import DuplicateClosedPureHelper
+from sarj_python_lint.rules.no_conflicting_pydantic_alias_validation import NoConflictingPydanticAliasValidation
+from sarj_python_lint.rules.no_impossible_pydantic_field_bounds import NoImpossiblePydanticFieldBounds
+from sarj_python_lint.rules.no_unknown_pydantic_validator_field import NoUnknownPydanticValidatorField
 from sarj_python_lint.rules.redundant_test_constructor_forwarder import RedundantTestConstructorForwarder
 from sarj_python_lint.rules.repeated_unimplemented_test_contract import RepeatedUnimplementedTestContract
 
 
 REGISTRY: Mapping[str, type[Rule]] = MappingProxyType(
     {
+        NoConflictingPydanticAliasValidation.id: NoConflictingPydanticAliasValidation,
+        NoUnknownPydanticValidatorField.id: NoUnknownPydanticValidatorField,
+        NoImpossiblePydanticFieldBounds.id: NoImpossiblePydanticFieldBounds,
         RequireInjectableRetrySleep.id: RequireInjectableRetrySleep,
         NoFixedSleepInLoop.id: NoFixedSleepInLoop,
         NoInterpreterSourceArguments.id: NoInterpreterSourceArguments,

{sarj_python_lint-1.28.6 → sarj_python_lint-1.29.0}/src/sarj_python_lint/rules/no_any_mapping_types.py

@@ -33,6 +33,7 @@ _PYDANTIC_SOURCES = frozenset({"pydantic"})
 _MAPPING_SOURCES = frozenset({"collections.abc", "typing"})
 _MAPPING_NAMES = frozenset({"dict", "Dict", "Mapping", "MutableMapping"})
 _MAPPING_ARGUMENT_COUNT = 2
+_BUILTIN_TYPE_CONTAINERS = frozenset({"dict", "list", "set", "frozenset", "tuple", "type"})
 
 
 @final
@@ -65,6 +66,7 @@ class NoAnyMappingTypes(Rule):
                 "used in a module-level annotation; imported, conditional, rebound, and ambiguous aliases are excluded."
             ),
             "Generated and vendored sources are excluded; exact local suppressions remain auditable.",
+            "Annotated metadata, Literal values and unresolved generic parameter positions are excluded; only type arguments are inspected.",
         ),
         examples=(
             RuleExample(
@@ -117,7 +119,7 @@ class NoAnyMappingTypes(Rule):
         seen: set[tuple[int, int]] = set()
         expressions = [
             *_type_expressions(tree, imports, parents, scope_cache, node_index=context.node_index),
-            *_implicit_mapping_aliases(tree),
+            *_implicit_mapping_aliases(tree, semantics),
         ]
         for expression, owner in expressions:
             for mapping, location in _unshadowed_any_mappings(expression, owner, semantics, parents, scope_cache):
@@ -140,7 +142,7 @@ class NoAnyMappingTypes(Rule):
         return sorted(findings, key=lambda finding: (finding.line, finding.col))
 
 
-def _implicit_mapping_aliases(tree: ast.Module) -> list[tuple[ast.expr, ast.Assign]]:
+def _implicit_mapping_aliases(tree: ast.Module, semantics: AnnotationSemantics) -> list[tuple[ast.expr, ast.Assign]]:
     bindings = [scope_bound_names([statement]) for statement in tree.body]
     aliases: list[tuple[ast.expr, ast.Assign]] = []
     for statement in tree.body:
@@ -151,14 +153,14 @@ def _implicit_mapping_aliases(tree: ast.Module) -> list[tuple[ast.expr, ast.Assi
             continue
         if sum(target.id in names for names in bindings) != 1:
             continue
-        if _used_in_module_annotation(tree, target.id):
+        if _used_in_module_annotation(tree, target.id, semantics):
             aliases.append((statement.value, statement))
     return aliases
 
 
-def _used_in_module_annotation(tree: ast.Module, name: str) -> bool:
+def _used_in_module_annotation(tree: ast.Module, name: str, semantics: AnnotationSemantics) -> bool:
     return any(
-        _annotation_contains_name(annotation, name)
+        _annotation_contains_name(annotation, name, semantics)
         for statement in tree.body
         for annotation in _module_statement_annotations(statement, name)
     )
@@ -179,14 +181,17 @@ def _module_statement_annotations(statement: ast.stmt, alias_name: str) -> list[
     return annotations
 
 
-def _annotation_contains_name(annotation: ast.expr, name: str) -> bool:
-    parsed = annotation
-    if isinstance(annotation, ast.Constant) and isinstance(annotation.value, str):
-        try:
-            parsed = ast.parse(annotation.value, mode="eval").body
-        except SyntaxError:
-            return False
-    return any(isinstance(node, ast.Name) and node.id == name for node in walk_ast(parsed))
+def _annotation_contains_name(annotation: ast.expr, name: str, semantics: AnnotationSemantics) -> bool:
+    parsed = semantics.parse(annotation)
+    if parsed is None:
+        return False
+    pending = [parsed]
+    while pending:
+        node = pending.pop()
+        if isinstance(node, ast.Name) and node.id == name:
+            return True
+        pending.extend(_type_children(node, semantics))
+    return False
 
 
 def _unshadowed_any_mappings(
@@ -320,7 +325,14 @@ def _any_mappings(annotation: ast.expr, semantics: AnnotationSemantics) -> list[
     resolved = semantics.parse(annotation)
     if resolved is None:
         return []
-    return [node for node in walk_ast(resolved) if isinstance(node, ast.Subscript) and _is_any_mapping(node, semantics)]
+    pending = [resolved]
+    mappings: list[ast.Subscript] = []
+    while pending:
+        node = pending.pop()
+        if isinstance(node, ast.Subscript) and _is_any_mapping(node, semantics):
+            mappings.append(node)
+        pending.extend(_type_children(node, semantics))
+    return mappings
 
 
 def _is_any_mapping(node: ast.Subscript, semantics: AnnotationSemantics) -> bool:
@@ -355,11 +367,29 @@ def _contains_any(
         return True
     if isinstance(parsed, ast.Name) and parsed.id in semantics.aliases and parsed.id not in seen:
         return _contains_any(semantics.aliases[parsed.id], semantics, seen=seen | {parsed.id})
-    return any(
-        _contains_any(child, semantics, seen=seen)
-        for child in ast.iter_child_nodes(parsed)
-        if isinstance(child, ast.expr)
-    )
+    return any(_contains_any(child, semantics, seen=seen) for child in _type_children(parsed, semantics))
+
+
+def _type_children(node: ast.expr, semantics: AnnotationSemantics) -> tuple[ast.expr, ...]:
+    if isinstance(node, ast.Subscript):
+        imports = semantics.imports
+        symbol = imports.resolved_symbol(node.value, sources=_TYPING_SOURCES | _MAPPING_SOURCES)
+        if symbol == "Literal":
+            return ()
+        members = tuple(node.slice.elts) if isinstance(node.slice, ast.Tuple) else (node.slice,)
+        if symbol == "Annotated":
+            return members[:1]
+        builtin = (
+            isinstance(node.value, ast.Name)
+            and node.value.id in _BUILTIN_TYPE_CONTAINERS
+            and imports.builtin_is_unshadowed(node.value.id)
+        )
+        return members if builtin or symbol is not None else ()
+    if isinstance(node, ast.BinOp) and isinstance(node.op, ast.BitOr):
+        return node.left, node.right
+    if isinstance(node, (ast.Tuple, ast.List)):
+        return tuple(node.elts)
+    return ()
 
 
 def _is_vendor_path(path: Path) -> bool: