WIP 3

Author: cdce8p

mypy/semanal.py

@@ -226,6 +226,7 @@
     SELF_TYPE_NAMES,
     FindTypeVarVisitor,
     TypeAnalyser,
+    TypeVarDefaultTranslator,
     TypeVarLikeList,
     analyze_type_alias,
     check_for_explicit_any,
@@ -1954,15 +1955,8 @@ class Foo(Bar, Generic[T]): ...
             del base_type_exprs[i]
         tvar_defs: list[TypeVarLikeType] = []
         for name, tvar_expr in declared_tvars:
-            tvar_expr_default = tvar_expr.default
-            if isinstance(tvar_expr_default, UnboundType):
-                # TODO: - detect out of order and self-referencing TypeVars
-                #       - nested default types, e.g. list[T1]
-                n = self.lookup_qualified(
-                    tvar_expr_default.name, tvar_expr_default, suppress_errors=True
-                )
-                if n is not None and (default := self.tvar_scope.get_binding(n)) is not None:
-                    tvar_expr.default = default
+            # TODO: detect out of order and self-referencing TypeVars
+            tvar_expr.default = tvar_expr.default.accept(TypeVarDefaultTranslator(self))
             tvar_def = self.tvar_scope.bind_new(name, tvar_expr)
             tvar_defs.append(tvar_def)
         return base_type_exprs, tvar_defs, is_protocol
@@ -2855,6 +2849,9 @@ def visit_assignment_stmt(self, s: AssignmentStmt) -> None:
             with self.allow_unbound_tvars_set():
                 s.rvalue.accept(self)
             self.basic_type_applications = old_basic_type_applications
+        elif self.can_possibly_be_typevarlike_declaration(s):
+            with self.allow_unbound_tvars_set():
+                s.rvalue.accept(self)
         else:
             s.rvalue.accept(self)
 
@@ -3031,6 +3028,24 @@ def can_possibly_be_type_form(self, s: AssignmentStmt) -> bool:
         # Something that looks like Foo = Bar[Baz, ...]
         return True
 
+    def can_possibly_be_typevarlike_declaration(self, s: AssignmentStmt) -> bool:
+        if len(s.lvalues) != 1 or not isinstance(s.lvalues[0], NameExpr):
+            return False
+        if not isinstance(s.rvalue, CallExpr) or not isinstance(s.rvalue.callee, NameExpr):
+            return False
+        ref = s.rvalue.callee
+        ref.accept(self)
+        if ref.fullname not in {
+            "typing.TypeVar",
+            "typing_extensions.TypeVar",
+            "typing.ParamSpec",
+            "typing_extensions.ParamSpec",
+            "typing.TypeVarTuple",
+            "typing_extensions.TypeVarTuple",
+        }:
+            return False
+        return True
+
     def is_type_ref(self, rv: Expression, bare: bool = False) -> bool:
         """Does this expression refer to a type?
 

mypy/typeanal.py

@@ -38,7 +38,12 @@
 )
 from mypy.options import Options
 from mypy.plugin import AnalyzeTypeContext, Plugin, TypeAnalyzerPluginInterface
-from mypy.semanal_shared import SemanticAnalyzerCoreInterface, paramspec_args, paramspec_kwargs
+from mypy.semanal_shared import (
+    SemanticAnalyzerCoreInterface,
+    SemanticAnalyzerInterface,
+    paramspec_args,
+    paramspec_kwargs,
+)
 from mypy.state import state
 from mypy.tvar_scope import TypeVarLikeScope
 from mypy.types import (
@@ -2508,3 +2513,24 @@ def process_types(self, types: list[Type] | tuple[Type, ...]) -> None:
         else:
             for t in types:
                 t.accept(self)
+
+
+class TypeVarDefaultTranslator(TrivialSyntheticTypeTranslator):
+    def __init__(self, api: SemanticAnalyzerInterface) -> None:
+        self.api = api
+        self.seen_aliases: set[TypeAliasType] | None = None
+
+    def visit_unbound_type(self, t: UnboundType) -> Type:
+        n = self.api.lookup_qualified(t.name, t, suppress_errors=True)
+        if n is not None and (type_var := self.api.tvar_scope.get_binding(n)):
+            return type_var
+        return super().visit_unbound_type(t)
+
+    def visit_type_alias_type(self, t: TypeAliasType) -> Type:
+        if self.seen_aliases is None:
+            self.seen_aliases = set()
+        elif t in self.seen_aliases:
+            return t
+        self.seen_aliases.add(t)
+        t.args = [arg.accept(self) for arg in t.args]
+        return t

test-data/unit/check-typevar-defaults.test

@@ -379,11 +379,12 @@ class ClassD1(Generic[T1, T2]): ...
 
 [case testTypeVarDefaultsClassRecursive1]
 # flags: --disallow-any-generics
-from typing import Generic, TypeVar
+from typing import Generic, TypeVar, List
 
 T1 = TypeVar("T1", default=str)
 T2 = TypeVar("T2", default=T1)
 T3 = TypeVar("T3", default=T2)
+T4 = TypeVar("T4", default=List[T1])
 
 class ClassD1(Generic[T1, T2]): ...
 
@@ -425,6 +426,24 @@ def func_d2(
     n = ClassD2[int, float, str]()
     reveal_type(n)  # N: Revealed type is "__main__.ClassD2[builtins.int, builtins.float, builtins.str]"
 
+class ClassD3(Generic[T1, T4]): ...
+
+def func_d3(
+    a: ClassD3,
+    b: ClassD3[int],
+    c: ClassD3[int, float],
+) -> None:
+    reveal_type(a)  # N: Revealed type is "__main__.ClassD3[builtins.str, builtins.list[builtins.str]]"
+    reveal_type(b)  # N: Revealed type is "__main__.ClassD3[builtins.int, builtins.list[builtins.int]]"
+    reveal_type(c)  # N: Revealed type is "__main__.ClassD3[builtins.int, builtins.float]"
+
+    # k = ClassD3()
+    # reveal_type(k)  # Revealed type is "__main__.ClassD3[builtins.str, builtins.list[builtins.str]]"
+    l = ClassD3[int]()
+    reveal_type(l)  # N: Revealed type is "__main__.ClassD3[builtins.int, builtins.list[builtins.int]]"
+    m = ClassD3[int, float]()
+    reveal_type(m)  # N: Revealed type is "__main__.ClassD3[builtins.int, builtins.float]"
+
 [case testTypeVarDefaultsClassRecursiveMultipleFiles]
 # flags: --disallow-any-generics
 from typing import Generic, TypeVar