sarj-python-lint 1.70.1__tar.gz → 1.70.2__tar.gz

{sarj_python_lint-1.70.1 → sarj_python_lint-1.70.2}/PKG-INFO

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

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

sarj_python_lint-1.70.2/src/sarj_python_lint/rules/_annotation_origins.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import ast
+from typing import TYPE_CHECKING
+
+from sarj_python_lint.rules._imports import ImportIndex
+
+
+if TYPE_CHECKING:
+    from sarj_python_lint._file_context import PythonFileContext
+
+
+class AnnotationOrigins:
+    def __init__(self, context: PythonFileContext) -> None:
+        self.context = context
+        self.provenance = context.static_resource_provenance
+        self.imports = {
+            node: ImportIndex.from_tree(ast.Module(body=[node], type_ignores=[]))
+            for node in context.nodes(ast.Import, ast.ImportFrom)
+        }
+
+    def shadowed(self, name: str, at: ast.AST) -> bool:
+        return type_parameter_shadow(name, at, self.context)
+
+    def qualified(self, node: ast.expr, at: ast.AST) -> str | None:
+        root = node
+        while isinstance(root, ast.Attribute):
+            root = root.value
+        if (
+            not isinstance(root, ast.Name)
+            or root.id in self.provenance.mutated | self.provenance.external_bindings
+            or type_parameter_shadow(root.id, at, self.context)
+        ):
+            return None
+        binding = self.provenance.binding(root.id, at)
+        parent = self.context.parents.get(binding) if binding is not None else None
+        index = self.imports.get(parent) if isinstance(parent, ast.Import | ast.ImportFrom) else None
+        return index.resolved_qualified_name(node) if index is not None else None
+
+    def builtin(self, node: ast.expr, name: str, at: ast.AST) -> bool:
+        return (
+            self.provenance.builtin_namespace_untouched
+            and isinstance(node, ast.Name)
+            and node.id == name
+            and not type_parameter_shadow(name, at, self.context)
+            and self.provenance.binding(name, at) is None
+        )
+
+
+def type_parameter_shadow(name: str, at: ast.AST, context: PythonFileContext) -> bool:
+    outside: set[ast.AST] = set()
+    current = at
+    while (parent := context.parents.get(current)) is not None:
+        if (
+            isinstance(parent, ast.arguments)
+            and (current in parent.defaults or current in parent.kw_defaults)
+            and (owner := context.parents.get(parent)) is not None
+        ):
+            outside.add(owner)
+        if (
+            isinstance(parent, ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef | ast.TypeAlias)
+            and parent not in outside
+            and not (
+                isinstance(parent, ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef)
+                and current in parent.decorator_list
+            )
+            and any(
+                isinstance(parameter, ast.TypeVar | ast.ParamSpec | ast.TypeVarTuple) and parameter.name == name
+                for parameter in parent.type_params
+            )
+        ):
+            return True
+        current = parent
+    return False

{sarj_python_lint-1.70.1 → sarj_python_lint-1.70.2}/src/sarj_python_lint/rules/_annotation_semantics.py

@@ -63,7 +63,7 @@ class AnnotationSemantics:
                 candidates[name] = value
         if not candidates:
             return cls(imports, MappingProxyType({}))
-        rebound = _module_rebindings(tree)
+        rebound = module_rebindings(tree)
         aliases = {name: value for name, value in candidates.items() if name not in ambiguous and name not in rebound}
         return cls(imports, MappingProxyType(aliases))
 
@@ -139,7 +139,7 @@ class AnnotationSemantics:
         return [node.slice]
 
 
-def _module_rebindings(tree: ast.Module) -> set[str]:
+def module_rebindings(tree: ast.Module) -> set[str]:
     counts: dict[str, int] = {}
     for statement in tree.body:
         for name in _bound_names(statement):

{sarj_python_lint-1.70.1 → sarj_python_lint-1.70.2}/src/sarj_python_lint/rules/_ast_index.py

@@ -15,7 +15,32 @@ if TYPE_CHECKING:
 _AST = ast.AST
 
 
-def object_list(value: object) -> TypeIs[list[object]]:
+def statement_blocks(statements: list[ast.stmt]) -> Iterator[list[ast.stmt]]:
+    pending = [statements]
+    while pending:
+        block = pending.pop()
+        yield block
+        for statement in reversed(block):
+            match statement:
+                case ast.For() | ast.AsyncFor() | ast.While() | ast.If():
+                    nested = [statement.body, statement.orelse]
+                case ast.With() | ast.AsyncWith():
+                    nested = [statement.body]
+                case ast.Try() | ast.TryStar():
+                    nested = [
+                        statement.body,
+                        *(handler.body for handler in statement.handlers),
+                        statement.orelse,
+                        statement.finalbody,
+                    ]
+                case ast.Match():
+                    nested = [case.body for case in statement.cases]
+                case _:
+                    continue
+            pending.extend(reversed(nested))
+
+
+def object_list(value: object) -> TypeIs[list[object]]:  # sarj-noqa: SARJ528 -- narrows opaque AST fields.
     return isinstance(value, list)
 
 

{sarj_python_lint-1.70.1 → sarj_python_lint-1.70.2}/src/sarj_python_lint/rules/_declared_contracts.py

@@ -28,27 +28,30 @@ class DeclaredClass:
 
 
 def _class_metadata_annotation(annotation: ast.expr, semantics: AnnotationSemantics) -> bool:
-    pending = [annotation]
     seen: set[str] = set()
-    while pending:
-        node = semantics.parse(pending.pop())
-        if node is None:
+    node = semantics.parse(annotation)
+    while node is not None:
+        if isinstance(node, ast.Name) and node.id in semantics.aliases and node.id not in seen:
+            seen.add(node.id)
+            node = semantics.parse(semantics.aliases[node.id])
+            continue
+        if not isinstance(node, ast.Subscript):
+            return False
+        wrapper = semantics.imports.resolved_symbol(node.value, sources=_TYPING_SOURCES)
+        if wrapper in {"ClassVar", "Final"}:
+            return True
+        if wrapper != "Annotated":
+            return False
+        if isinstance(node.slice, ast.Tuple) and not node.slice.elts:
             return True
-        for member in ast.walk(node):
-            if isinstance(member, ast.Subscript) and semantics.imports.resolved_symbol(
-                member.value, sources=_TYPING_SOURCES
-            ) in {"ClassVar", "Final"}:
-                return True
-            if isinstance(member, ast.Name) and member.id in semantics.aliases and member.id not in seen:
-                seen.add(member.id)
-                pending.append(semantics.aliases[member.id])
-    return False
+        node = semantics.parse(node.slice.elts[0] if isinstance(node.slice, ast.Tuple) else node.slice)
+    return True
 
 
 class DeclaredContracts:
     def __init__(self, context: PythonFileContext) -> None:
         self.context = context
-        self._field_cache: dict[ast.ClassDef, dict[str, ast.AnnAssign]] = {}
+        self._field_cache: dict[tuple[ast.ClassDef, bool], dict[str, ast.AnnAssign]] = {}
         self._module_annotations: dict[Path, AnnotationSemantics] = {}
         self.project = context.session.project or ProjectIndexSet.single(context.path, context.source)
         self.unit = self.project.unit(context.path)
@@ -130,23 +133,32 @@ class DeclaredContracts:
     def inherits(self, model: DeclaredClass, bases: frozenset[str]) -> bool:
         return self.project.class_inherits_from(model.unit, model.declaration.name, bases)
 
-    def model_fields(self, model: DeclaredClass) -> dict[str, ast.AnnAssign]:
+    def model_fields(
+        self, model: DeclaredClass, *, inherited: bool = False, seen: frozenset[ast.ClassDef] = frozenset()
+    ) -> dict[str, ast.AnnAssign]:
         if model.unit.tree is None:
             return {}
-        cached = self._field_cache.get(model.declaration)
+        key = (model.declaration, inherited)
+        cached = self._field_cache.get(key)
         if cached is not None:
             return cached
+        if model.declaration in seen or len(seen) >= _MAX_DEPTH:
+            return {}
         semantics = self._module_semantics(model.unit)
-        fields = {
-            node.target.id: node
-            for node in model.declaration.body
-            if isinstance(node, ast.AnnAssign)
-            and isinstance(node.target, ast.Name)
-            and not node.target.id.startswith("_")
-            and node.target.id != "model_config"
-            and not _class_metadata_annotation(node.annotation, semantics)
-        }
-        self._field_cache[model.declaration] = fields
+        fields: dict[str, ast.AnnAssign] = {}
+        if inherited and len(model.declaration.bases) == 1:
+            parent = self.class_type(model.declaration.bases[0], model.unit)
+            if parent is not None:
+                fields.update(self.model_fields(parent, inherited=True, seen=seen | {model.declaration}))
+        for node in model.declaration.body:
+            if not isinstance(node, ast.AnnAssign) or not isinstance(node.target, ast.Name):
+                continue
+            name = node.target.id
+            if name.startswith("_") or name == "model_config" or _class_metadata_annotation(node.annotation, semantics):
+                fields.pop(name, None)
+            else:
+                fields[name] = node
+        self._field_cache[key] = fields
         return fields
 
     def _module_semantics(self, unit: SourceUnit) -> AnnotationSemantics:

{sarj_python_lint-1.70.1 → sarj_python_lint-1.70.2}/src/sarj_python_lint/rules/_test_composition.py

@@ -5,6 +5,7 @@ from collections import Counter
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
+from sarj_python_lint.rules._declared_contracts import DeclaredClass
 from sarj_python_lint.rules._project_index import ProjectIndexSet, SourceUnit, SymbolRef
 
 
@@ -40,9 +41,7 @@ def direct_nodes(node: ast.AST) -> Iterator[ast.AST]:
             yield from direct_nodes(child)
 
 
-def _class_owner(
-    context: PythonFileContext, expression: ast.expr, project: ProjectIndexSet
-) -> tuple[SourceUnit, ast.ClassDef] | None:
+def _class_owner(context: PythonFileContext, expression: ast.expr, project: ProjectIndexSet) -> DeclaredClass | None:
     qualified = context.module_imports.resolved_qualified_name(expression)
     unit = project.unit(context.path)
     if qualified is not None:
@@ -62,7 +61,7 @@ def _class_owner(
         for node in direct_nodes(unit.tree)
     ):
         return None
-    return unit, owner
+    return DeclaredClass(unit, owner)
 
 
 def constructor(
@@ -75,7 +74,7 @@ def constructor(
     resolved = _class_owner(context, expression, project)
     if resolved is None:
         return None
-    unit, owner = resolved
+    unit, owner = resolved.unit, resolved.declaration
     if unit.module is None:
         return None
     initializer = next(
@@ -240,15 +239,9 @@ def wiring(
     spec: Constructor,
     scope: WiringScope,
 ) -> tuple[tuple[str, str], ...] | None:
-    if any(isinstance(arg, ast.Starred) for arg in call.args) or any(keyword.arg is None for keyword in call.keywords):
-        return None
-    if len(call.args) > len(spec.positional):
+    values = call_arguments(call, spec.positional)
+    if values is None:
         return None
-    values = dict(zip(spec.positional, call.args, strict=False))
-    for keyword in call.keywords:
-        if keyword.arg is None or keyword.arg in values:
-            return None
-        values[keyword.arg] = keyword.value
     result: list[tuple[str, str]] = []
     for name in sorted(spec.collaborators):
         value = values.get(name)
@@ -261,6 +254,19 @@ def wiring(
     return tuple(result)
 
 
+def call_arguments(call: ast.Call, positional: tuple[str, ...]) -> dict[str, ast.expr] | None:
+    if any(isinstance(arg, ast.Starred) for arg in call.args) or any(keyword.arg is None for keyword in call.keywords):
+        return None
+    if len(call.args) > len(positional):
+        return None
+    values = dict(zip(positional, call.args, strict=False))
+    for keyword in call.keywords:
+        if keyword.arg is None or keyword.arg in values:
+            return None
+        values[keyword.arg] = keyword.value
+    return values
+
+
 def _value_key(
     context: PythonFileContext,
     project: ProjectIndexSet,
@@ -300,4 +306,4 @@ def _value_key(
     ]
     if any(key is None for key in positional) or any(key is None for _, key in keywords):
         return None
-    return f"{owner[0].module}.{owner[1].name}:{positional!r}:{sorted(keywords)!r}"
+    return f"{owner.unit.module}.{owner.declaration.name}:{positional!r}:{sorted(keywords)!r}"

{sarj_python_lint-1.70.1 → sarj_python_lint-1.70.2}/src/sarj_python_lint/rules/excessive_commentary.py

@@ -16,7 +16,7 @@ from sarj_python_lint.rule_base import (
     RuleExample,
     Severity,
 )
-from sarj_python_lint.rules._ast_index import walk as walk_ast
+from sarj_python_lint.rules._ast_index import statement_blocks
 from sarj_python_lint.rules._comments import has_external_reference
 from sarj_python_lint.rules._prose_budget import (
     groups,
@@ -26,7 +26,6 @@ from sarj_python_lint.rules._prose_budget import (
 
 if TYPE_CHECKING:
     from sarj_python_lint._file_context import PythonFileContext
-    from sarj_python_lint.rules._ast_index import NodeIndex
 
 
 _MIN_LINES = 3
@@ -64,7 +63,7 @@ class ExcessiveCommentary(Rule):
         limitations=(
             "Contiguous standalone implementation comment blocks with at least three non-empty lines and 20 words are inspected.",
             "The paragraph must immediately precede executable implementation code; narrative comments in tests and module setup are included.",
-            "The previously shipped accumulator pattern remains an error; expanded implementation commentary is a warning requiring review, with no automatic deletion.",
+            "The previously shipped accumulator pattern with a proven builtin collection remains an error; expanded implementation commentary is a warning requiring review, with no automatic deletion.",
             "Rationale, technical vocabulary and external citations do not exempt a long paragraph from warning-level review. Their existing protection against accumulator errors remains intact.",
             "Generated files, directives, licenses, structured lists, docstrings, inline comments and short constraints are excluded.",
         ),
@@ -123,7 +122,7 @@ class ExcessiveCommentary(Rule):
             for node in context.nodes(ast.stmt)
             if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef, ast.Import, ast.ImportFrom))
         }
-        accumulator_lines = _narrated_accumulator_lines(tree, node_index=context.node_index)
+        accumulator_lines = _narrated_accumulator_lines(context)
         findings: list[Diagnostic] = []
         for group in groups(path, source):
             lines = tuple(stripped for line in group.text.splitlines() if (stripped := line.strip()))
@@ -164,18 +163,17 @@ class ExcessiveCommentary(Rule):
         return findings
 
 
-def _narrated_accumulator_lines(tree: ast.Module, *, node_index: NodeIndex | None = None) -> set[int]:
+def _narrated_accumulator_lines(context: PythonFileContext) -> set[int]:
     lines: set[int] = set()
-    for function in walk_ast(tree, index=node_index):
-        if not isinstance(function, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            continue
-        _collect_accumulators(function.body, lines)
+    for function in context.nodes(ast.FunctionDef, ast.AsyncFunctionDef):
+        for statements in statement_blocks(function.body):
+            _collect_accumulators(statements, lines, context)
     return lines
 
 
-def _collect_accumulators(statements: list[ast.stmt], lines: set[int]) -> None:
+def _collect_accumulators(statements: list[ast.stmt], lines: set[int], context: PythonFileContext) -> None:
     for index, statement in enumerate(statements):
-        name = _empty_collection_name(statement)
+        name = _empty_collection_name(statement, context)
         if name is not None:
             mutations = 0
             for following in statements[index + 1 :]:
@@ -184,11 +182,9 @@ def _collect_accumulators(statements: list[ast.stmt], lines: set[int]) -> None:
                 mutations += 1
             if mutations >= _MIN_ACCUMULATOR_CALLS:
                 lines.add(statement.lineno)
-        for child_statements in _nested_statement_lists(statement):
-            _collect_accumulators(child_statements, lines)
 
 
-def _empty_collection_name(statement: ast.stmt) -> str | None:
+def _empty_collection_name(statement: ast.stmt, context: PythonFileContext) -> str | None:
     target: ast.expr | None = None
     value: ast.expr | None = None
     if isinstance(statement, ast.AnnAssign):
@@ -208,7 +204,9 @@ def _empty_collection_name(statement: ast.stmt) -> str | None:
         and not value.args
         and not value.keywords
     ):
-        return target.id
+        provenance = context.static_resource_provenance
+        if provenance.builtin_namespace_untouched and provenance.binding(value.func.id, value.func) is None:
+            return target.id
     return None
 
 
@@ -222,22 +220,3 @@ def _is_accumulator_call(statement: ast.stmt, name: str) -> bool:
         and isinstance(function.value, ast.Name)
         and function.value.id == name
     )
-
-
-def _nested_statement_lists(statement: ast.stmt) -> list[list[ast.stmt]]:
-    match statement:
-        case ast.For() | ast.AsyncFor() | ast.While() | ast.If():
-            return [statement.body, statement.orelse]
-        case ast.With() | ast.AsyncWith():
-            return [statement.body]
-        case ast.Try() | ast.TryStar():
-            return [
-                statement.body,
-                statement.orelse,
-                statement.finalbody,
-                *(handler.body for handler in statement.handlers),
-            ]
-        case ast.Match():
-            return [case.body for case in statement.cases]
-        case _:
-            return []

{sarj_python_lint-1.70.1 → sarj_python_lint-1.70.2}/src/sarj_python_lint/rules/prefer_direct_import_module.py

@@ -32,7 +32,7 @@ class PreferDirectImportModule(Rule):
         default_level=Severity.WARNING,
         summary="Prefer static imports for eager module loads with a literal module name.",
         rationale="Static imports expose known dependencies to readers and tooling without dynamic loader indirection.",
-        remediation="Replace a fixed eager module load with a module-level import, preserving its binding: plugin = importlib.import_module('plugins.billing') becomes import plugins.billing as plugin. Keep dynamic loading when module selection or import timing requires it.",
+        remediation="Replace a fixed eager module load with a module-level import, preserving its binding: plugin = importlib.import_module('plugins.billing') becomes import plugins.billing as plugin. Use import plugins.billing when callers use the qualified module name; avoid a redundant alias for a single-component module. Keep dynamic loading when module selection or import timing requires it.",
         category=RuleCategory.STYLE,
         autofix=AutofixPolicy.NONE,
         limitations=(
@@ -89,7 +89,7 @@ class PreferDirectImportModule(Rule):
                 node.lineno,
                 node.col_offset + 1,
                 self.code,
-                f"Use a module-level static import for the known module '{module}'; preserve the binding with 'import {module} as plugin' when needed.",
+                _recommendation(statement, module),
                 severity=Severity.WARNING,
             )
             for statement in context.tree.body
@@ -100,6 +100,20 @@ class PreferDirectImportModule(Rule):
         ]
 
 
+def _recommendation(statement: ast.Assign | ast.AnnAssign | ast.Expr, module: str) -> str:
+    target = statement.target if isinstance(statement, ast.AnnAssign) else None
+    if isinstance(statement, ast.Assign) and len(statement.targets) == 1:
+        target = statement.targets[0]
+    replacement = f"import {module}"
+    if isinstance(target, ast.Name):
+        if target.id != module:
+            replacement += f" as {target.id}"
+        return f"Use the module-level static import '{replacement}' to preserve the '{target.id}' binding."
+    return (
+        f"Use the module-level static import '{replacement}'; update references to the qualified module where needed."
+    )
+
+
 def _literal_module(call: ast.Call) -> str | None:
     match call:
         case ast.Call(args=[ast.Constant(value=str() as module)], keywords=[]):

{sarj_python_lint-1.70.1 → sarj_python_lint-1.70.2}/src/sarj_python_lint/rules/prefer_namedtuple_over_tuple_return.py

@@ -28,7 +28,7 @@ if TYPE_CHECKING:
 _MIN_FIELDS = 2
 _DOCUMENTATION_DIR_NAMES = frozenset({"docs", "docs_src"})
 _TUPLE_SOURCES = frozenset({"builtins"})
-_TYPING_SOURCES = frozenset({"typing"})
+_TYPING_SOURCES = frozenset({"typing", "typing_extensions"})
 
 _MSG = (
     "function returns a fixed positional tuple record — return a dataclass or validation model; "
@@ -55,7 +55,7 @@ class PreferNamedtupleOverTupleReturn(Rule):
         limitations=(
             "Generated files and documentation examples are excluded.",
             "Provenance-resolved builtin or typing fixed tuple return annotations with at least two slots are reported, including stable local aliases, quoted annotations, Annotated wrappers and optional unions in test helpers and fixtures; variadic tuples remain valid collections.",
-            "Existing direct tuple records remain errors; newly resolved local aliases and optional-union records start as warnings for adoption review.",
+            "Existing direct tuple records remain errors; newly resolved typing_extensions providers, local aliases, application types named Unpack and optional-union records start as warnings for adoption review.",
             "Classes with explicit bases, including object, are excluded without requiring an override decorator. Local base declarations do not prove runtime member ownership remains closed; class construction, native hooks and escaped handles can change inheritance. Independent module functions and plain classes remain eligible.",
         ),
         examples=(
@@ -124,7 +124,9 @@ class PreferNamedtupleOverTupleReturn(Rule):
                     col=node.col_offset + 1,
                     code=self.code,
                     message=_MSG,
-                    severity=Severity.ERROR if _is_public_record_tuple(node.returns, imports) else Severity.WARNING,
+                    severity=Severity.ERROR
+                    if _is_public_record_tuple(node.returns, imports, legacy=True)
+                    else Severity.WARNING,
                 )
             )
         return diagnostics
@@ -134,40 +136,47 @@ def _is_documentation_path(path: Path) -> bool:
     return any(part.lower() in _DOCUMENTATION_DIR_NAMES for part in path.parts)
 
 
-def _is_public_record_tuple(annotation: ast.expr, imports: ImportIndex) -> bool:
-    annotation = _unwrap_return_annotation(annotation, imports)
+def _is_public_record_tuple(annotation: ast.expr, imports: ImportIndex, *, legacy: bool = False) -> bool:
+    typing_sources = frozenset({"typing"}) if legacy else _TYPING_SOURCES
+    annotation = _unwrap_return_annotation(annotation, imports, typing_sources)
     if not isinstance(annotation, ast.Subscript) or not isinstance(annotation.slice, ast.Tuple):
         return False
     target = annotation.value
     is_tuple = (
         (isinstance(target, ast.Name) and target.id == "tuple" and imports.builtin_is_unshadowed("tuple"))
         or imports.resolves(target, sources=_TUPLE_SOURCES, symbol="tuple")
-        or imports.resolves(target, sources=_TYPING_SOURCES, symbol="Tuple")
+        or imports.resolves(target, sources=typing_sources, symbol="Tuple")
     )
     if not is_tuple:
         return False
     fields = annotation.slice.elts
-    return len(fields) >= _MIN_FIELDS and not any(_is_variadic_field(field) for field in fields)
+    return len(fields) >= _MIN_FIELDS and not any(_is_variadic_field(field, imports, legacy=legacy) for field in fields)
 
 
-def _unwrap_return_annotation(annotation: ast.expr, imports: ImportIndex) -> ast.expr:
+def _unwrap_return_annotation(annotation: ast.expr, imports: ImportIndex, typing_sources: frozenset[str]) -> ast.expr:
     if isinstance(annotation, ast.Constant) and isinstance(annotation.value, str):
         parsed = parse_or_none(Path("annotation.py"), f"value: {annotation.value}")
         if parsed is not None and isinstance(parsed.body[0], ast.AnnAssign):
             return parsed.body[0].annotation
     if (
         isinstance(annotation, ast.Subscript)
-        and imports.resolves(annotation.value, sources=_TYPING_SOURCES, symbol="Annotated")
+        and imports.resolves(annotation.value, sources=typing_sources, symbol="Annotated")
         and isinstance(annotation.slice, ast.Tuple)
         and annotation.slice.elts
     ):
-        return _unwrap_return_annotation(annotation.slice.elts[0], imports)
+        return _unwrap_return_annotation(annotation.slice.elts[0], imports, typing_sources)
     return annotation
 
 
-def _is_variadic_field(node: ast.expr) -> bool:
+def _is_variadic_field(node: ast.expr, imports: ImportIndex, *, legacy: bool) -> bool:
     return (
         isinstance(node, ast.Starred)
-        or (isinstance(node, ast.Subscript) and _leaf_name(node.value) == "Unpack")
+        or (
+            isinstance(node, ast.Subscript)
+            and (
+                imports.resolves(node.value, sources=frozenset({"typing", "typing_extensions"}), symbol="Unpack")
+                or (legacy and _leaf_name(node.value) == "Unpack")
+            )
+        )
         or (isinstance(node, ast.Constant) and node.value is Ellipsis)
     )