Add basic support for recussive TypeVar defaults (PEP 696)

Author: cdce8p

mypy/applytype.py

@@ -147,7 +147,7 @@ def apply_generic_arguments(
     # TODO: move apply_poly() logic from checkexpr.py here when new inference
     # becomes universally used (i.e. in all passes + in unification).
     # With this new logic we can actually *add* some new free variables.
-    remaining_tvars = [tv for tv in tvars if tv.id not in id_to_type]
+    remaining_tvars = [expand_type(tv, id_to_type) for tv in tvars if tv.id not in id_to_type]
 
     return callable.copy_modified(
         ret_type=expand_type(callable.ret_type, id_to_type),

mypy/expandtype.py

@@ -179,6 +179,7 @@ class ExpandTypeVisitor(TrivialSyntheticTypeTranslator):
 
     def __init__(self, variables: Mapping[TypeVarId, Type]) -> None:
         self.variables = variables
+        self.recursive_tvar_guard: dict[TypeVarId, Type | None] = {}
 
     def visit_unbound_type(self, t: UnboundType) -> Type:
         return t
@@ -226,6 +227,14 @@ def visit_type_var(self, t: TypeVarType) -> Type:
             # TODO: do we really need to do this?
             # If I try to remove this special-casing ~40 tests fail on reveal_type().
             return repl.copy_modified(last_known_value=None)
+        if isinstance(repl, TypeVarType) and repl.has_default():
+            if (tvar_id := repl.id) in self.recursive_tvar_guard:
+                return self.recursive_tvar_guard[tvar_id] or repl
+            self.recursive_tvar_guard[tvar_id] = None
+            repl = repl.accept(self)
+            if isinstance(repl, TypeVarType):
+                repl.default = repl.default.accept(self)
+            self.recursive_tvar_guard[tvar_id] = repl
         return repl
 
     def visit_param_spec(self, t: ParamSpecType) -> Type:

mypy/semanal.py

@@ -1954,6 +1954,14 @@ class Foo(Bar, Generic[T]): ...
             del base_type_exprs[i]
         tvar_defs: list[TypeVarLikeType] = []
         for name, tvar_expr in declared_tvars:
+            if isinstance(tvar_expr.default, UnboundType):
+                # Assumption here is that the names cannot be duplicated
+                # TODO: - detect out of order and self-referencing typevars
+                #       - nested default types, e.g. list[T1]
+                for fullname, type_var in self.tvar_scope.scope.items():
+                    type_var_name = fullname.rpartition(".")[2]
+                    if tvar_expr.default.name == type_var_name:
+                        tvar_expr.default = type_var
             tvar_def = self.tvar_scope.bind_new(name, tvar_expr)
             tvar_defs.append(tvar_def)
         return base_type_exprs, tvar_defs, is_protocol

mypy/tvar_scope.py

@@ -15,6 +15,26 @@
     TypeVarTupleType,
     TypeVarType,
 )
+from mypy.typetraverser import TypeTraverserVisitor
+
+
+class TypeVarLikeNamespaceSetter(TypeTraverserVisitor):
+    """Set namespace for all TypeVarLikeTypes types."""
+
+    def __init__(self, namespace: str) -> None:
+        self.namespace = namespace
+
+    def visit_type_var(self, t: TypeVarType) -> None:
+        t.id.namespace = self.namespace
+        super().visit_type_var(t)
+
+    def visit_param_spec(self, t: ParamSpecType) -> None:
+        t.id.namespace = self.namespace
+        return super().visit_param_spec(t)
+
+    def visit_type_var_tuple(self, t: TypeVarTupleType) -> None:
+        t.id.namespace = self.namespace
+        super().visit_type_var_tuple(t)
 
 
 class TypeVarLikeScope:
@@ -88,6 +108,8 @@ def bind_new(self, name: str, tvar_expr: TypeVarLikeExpr) -> TypeVarLikeType:
             i = self.func_id
             # TODO: Consider also using namespaces for functions
             namespace = ""
+        tvar_expr.default.accept(TypeVarLikeNamespaceSetter(namespace))
+
         if isinstance(tvar_expr, TypeVarExpr):
             tvar_def: TypeVarLikeType = TypeVarType(
                 name=name,

mypy/typetraverser.py

@@ -61,16 +61,16 @@ def visit_type_var(self, t: TypeVarType) -> None:
         # Note that type variable values and upper bound aren't treated as
         # components, since they are components of the type variable
         # definition. We want to traverse everything just once.
-        pass
+        t.default.accept(self)
 
     def visit_param_spec(self, t: ParamSpecType) -> None:
-        pass
+        t.default.accept(self)
 
     def visit_parameters(self, t: Parameters) -> None:
         self.traverse_types(t.arg_types)
 
     def visit_type_var_tuple(self, t: TypeVarTupleType) -> None:
-        pass
+        t.default.accept(self)
 
     def visit_literal_type(self, t: LiteralType) -> None:
         t.fallback.accept(self)

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

@@ -377,6 +377,54 @@ class ClassD1(Generic[T1, T2]): ...
 #     reveal_type(c)
 [builtins fixtures/tuple.pyi]
 
+[case testTypeVarDefaultsClassRecursive1]
+# flags: --disallow-any-generics
+from typing import Generic, TypeVar
+
+T1 = TypeVar("T1", default=str)
+T2 = TypeVar("T2", default=T1)
+T3 = TypeVar("T3", default=T2)
+
+class ClassD1(Generic[T1, T2]): ...
+
+def func_d1(
+    a: ClassD1,
+    b: ClassD1[int],
+    c: ClassD1[int, float]
+) -> None:
+    reveal_type(a)  # N: Revealed type is "__main__.ClassD1[builtins.str, builtins.str]"
+    reveal_type(b)  # N: Revealed type is "__main__.ClassD1[builtins.int, builtins.int]"
+    reveal_type(c)  # N: Revealed type is "__main__.ClassD1[builtins.int, builtins.float]"
+
+    k = ClassD1()
+    reveal_type(k)  # N: Revealed type is "__main__.ClassD1[builtins.str, builtins.str]"
+    l = ClassD1[int]()
+    reveal_type(l)  # N: Revealed type is "__main__.ClassD1[builtins.int, builtins.int]"
+    m = ClassD1[int, float]()
+    reveal_type(m)  # N: Revealed type is "__main__.ClassD1[builtins.int, builtins.float]"
+
+class ClassD2(Generic[T1, T2, T3]): ...
+
+def func_d2(
+    a: ClassD2,
+    b: ClassD2[int],
+    c: ClassD2[int, float],
+    d: ClassD2[int, float, str],
+) -> None:
+    reveal_type(a)  # N: Revealed type is "__main__.ClassD2[builtins.str, builtins.str, builtins.str]"
+    reveal_type(b)  # N: Revealed type is "__main__.ClassD2[builtins.int, builtins.int, builtins.int]"
+    reveal_type(c)  # N: Revealed type is "__main__.ClassD2[builtins.int, builtins.float, builtins.float]"
+    reveal_type(d)  # N: Revealed type is "__main__.ClassD2[builtins.int, builtins.float, builtins.str]"
+
+    k = ClassD2()
+    reveal_type(k)  # N: Revealed type is "__main__.ClassD2[builtins.str, builtins.str, builtins.str]"
+    l = ClassD2[int]()
+    reveal_type(l)  # N: Revealed type is "__main__.ClassD2[builtins.int, builtins.int, builtins.int]"
+    m = ClassD2[int, float]()
+    reveal_type(m)  # N: Revealed type is "__main__.ClassD2[builtins.int, builtins.float, builtins.float]"
+    n = ClassD2[int, float, str]()
+    reveal_type(n)  # N: Revealed type is "__main__.ClassD2[builtins.int, builtins.float, builtins.str]"
+
 [case testTypeVarDefaultsTypeAlias1]
 # flags: --disallow-any-generics
 from typing import Any, Dict, List, Tuple, TypeVar, Union