Do not leak type variables in type[T]

Author: ilevkivskyi

mypy/constraints.py

@@ -275,7 +275,11 @@ def infer_constraints_for_callable(
 
 
 def infer_constraints(
-    template: Type, actual: Type, direction: int, skip_neg_op: bool = False
+    template: Type,
+    actual: Type,
+    direction: int,
+    skip_neg_op: bool = False,
+    erase_types: bool = True,
 ) -> list[Constraint]:
     """Infer type constraints.
 
@@ -312,14 +316,14 @@ def infer_constraints(
             # Return early on an empty branch.
             return []
         type_state.inferring.append((template, actual))
-        res = _infer_constraints(template, actual, direction, skip_neg_op)
+        res = _infer_constraints(template, actual, direction, skip_neg_op, erase_types)
         type_state.inferring.pop()
         return res
-    return _infer_constraints(template, actual, direction, skip_neg_op)
+    return _infer_constraints(template, actual, direction, skip_neg_op, erase_types)
 
 
 def _infer_constraints(
-    template: Type, actual: Type, direction: int, skip_neg_op: bool
+    template: Type, actual: Type, direction: int, skip_neg_op: bool, erase_types: bool
 ) -> list[Constraint]:
     orig_template = template
     template = get_proper_type(template)
@@ -424,7 +428,7 @@ def _infer_constraints(
         return []
 
     # Remaining cases are handled by ConstraintBuilderVisitor.
-    return template.accept(ConstraintBuilderVisitor(actual, direction, skip_neg_op))
+    return template.accept(ConstraintBuilderVisitor(actual, direction, skip_neg_op, erase_types))
 
 
 def _is_type_type(tp: ProperType) -> TypeGuard[TypeType | UnionType]:
@@ -659,14 +663,20 @@ class ConstraintBuilderVisitor(TypeVisitor[list[Constraint]]):
     # TODO: The value may be None. Is that actually correct?
     actual: ProperType
 
-    def __init__(self, actual: ProperType, direction: int, skip_neg_op: bool) -> None:
+    def __init__(
+        self, actual: ProperType, direction: int, skip_neg_op: bool, erase_types: bool
+    ) -> None:
         # Direction must be SUBTYPE_OF or SUPERTYPE_OF.
         self.actual = actual
         self.direction = direction
         # Whether to skip polymorphic inference (involves inference in opposite direction)
         # this is used to prevent infinite recursion when both template and actual are
         # generic callables.
         self.skip_neg_op = skip_neg_op
+        # Normally we should erase generic actual type when inferring against type[T]
+        # to avoid leaking type variables, see testGenericClassAsArgumentToType.
+        # The only exception is self-types in generic classes, where we set this to False.
+        self.erase_types = erase_types
 
     # Trivial leaf types
 
@@ -1376,15 +1386,17 @@ def visit_overloaded(self, template: Overloaded) -> list[Constraint]:
     def visit_type_type(self, template: TypeType) -> list[Constraint]:
         if isinstance(self.actual, CallableType):
             if self.actual.is_type_obj():
-                return infer_constraints(
-                    template.item, self.actual.get_instance_type(), self.direction
-                )
+                instance_type = self.actual.get_instance_type()
+                if self.erase_types:
+                    instance_type = erase_typevars(instance_type)
+                return infer_constraints(template.item, instance_type, self.direction)
             return infer_constraints(template.item, self.actual.ret_type, self.direction)
         elif isinstance(self.actual, Overloaded):
             if self.actual.is_type_obj():
-                return infer_constraints(
-                    template.item, self.actual.items[0].get_instance_type(), self.direction
-                )
+                instance_type = self.actual.items[0].get_instance_type()
+                if self.erase_types:
+                    instance_type = erase_typevars(instance_type)
+                return infer_constraints(template.item, instance_type, self.direction)
             return infer_constraints(template.item, self.actual.items[0].ret_type, self.direction)
         elif isinstance(self.actual, TypeType):
             return infer_constraints(template.item, self.actual.item, self.direction)

mypy/infer.py

@@ -70,8 +70,11 @@ def infer_type_arguments(
     actual: Type,
     is_supertype: bool = False,
     skip_unsatisfied: bool = False,
+    erase_types: bool = True,
 ) -> list[Type | None]:
     # Like infer_function_type_arguments, but only match a single type
     # against a generic type.
-    constraints = infer_constraints(template, actual, SUPERTYPE_OF if is_supertype else SUBTYPE_OF)
+    constraints = infer_constraints(
+        template, actual, SUPERTYPE_OF if is_supertype else SUBTYPE_OF, erase_types=erase_types
+    )
     return solve_constraints(type_vars, constraints, skip_unsatisfied=skip_unsatisfied)[0]

mypy/typeops.py

@@ -495,7 +495,7 @@ class B(A): pass
 
         # Solve for these type arguments using the actual class or instance type.
         typeargs = infer_type_arguments(
-            self_vars, self_param_type, original_type, is_supertype=True
+            self_vars, self_param_type, original_type, is_supertype=True, erase_types=False
         )
         if (
             is_classmethod
@@ -504,7 +504,11 @@ class B(A): pass
         ):
             # In case we call a classmethod through an instance x, fallback to type(x).
             typeargs = infer_type_arguments(
-                self_vars, self_param_type, TypeType(original_type), is_supertype=True
+                self_vars,
+                self_param_type,
+                TypeType(original_type),
+                is_supertype=True,
+                erase_types=False,
             )
 
         # Update the method signature with the solutions found.

test-data/unit/check-generics.test

@@ -3688,3 +3688,12 @@ reveal_type(ok3)  # N: Revealed type is "tuple[()]"
 bad1: list[()] = []  # E: "list" expects 1 type argument, but none given \
                      # E: Missing type arguments for generic type "list"
 [builtins fixtures/tuple.pyi]
+
+[case testGenericClassAsArgumentToType]
+from typing import TypeVar, Generic
+
+T = TypeVar("T")
+def test(tp: type[T]) -> T: ...
+
+class C(Generic[T]): ...
+reveal_type(test(C))  # N: Revealed type is "__main__.C[Any]"