Fix partial types (and TypeVarTuple)

python · ilevkivskyi · Aug 3, 2023 · Jun 23, 2023 · Jul 2, 2023 · Jul 2, 2023
commit b43f286d1524f1a665b7ea8be8cdfe9bc5a44a90
diff --git a/mypy/checker.py b/mypy/checker.py
@@ -3878,11 +3878,12 @@ def is_valid_defaultdict_partial_value_type(self, t: ProperType) -> bool:
             return True
         if len(t.args) == 1:
             arg = get_proper_type(t.args[0])
-            # TODO: This is too permissive -- we only allow TypeVarType since
-            #       they leak in cases like defaultdict(list) due to a bug.
-            #       This can result in incorrect types being inferred, but only
-            #       in rare cases.
-            if isinstance(arg, (TypeVarType, UninhabitedType, NoneType)):
+            if self.options.new_type_inference:
+                allowed = isinstance(arg, (UninhabitedType, NoneType))
+            else:
+                # Allow leaked TypeVars for legacy inference logic.
+                allowed = isinstance(arg, (UninhabitedType, NoneType, TypeVarType))
+            if allowed:
                 return True
         return False
 

diff --git a/mypy/checkexpr.py b/mypy/checkexpr.py
@@ -1965,11 +1965,15 @@ def infer_function_type_arguments(
                     freeze_all_type_vars(applied)
                     return applied
                 # If it didn't work, erase free variables as <nothing>, to avoid confusing errors.
+                unknown = UninhabitedType()
+                unknown.ambiguous = True
                 inferred_args = [
-                    expand_type(a, {v.id: UninhabitedType() for v in callee_type.variables})
+                    expand_type(
+                        a, {v.id: unknown for v in list(callee_type.variables) + free_vars}
+                    )
                     if a is not None
                     else None
-                    for a in inferred_args
+                    for a in poly_inferred_args
                 ]
         else:
             # In dynamically typed functions use implicit 'Any' types for

diff --git a/mypy/constraints.py b/mypy/constraints.py
@@ -661,13 +661,13 @@ def visit_instance(self, template: Instance) -> list[Constraint]:
                     assert mapped.type.type_var_tuple_prefix is not None
                     assert mapped.type.type_var_tuple_suffix is not None
 
-                    unpack_constraints, mapped_args, instance_args = build_constraints_for_unpack(
-                        mapped.args,
-                        mapped.type.type_var_tuple_prefix,
-                        mapped.type.type_var_tuple_suffix,
+                    unpack_constraints, instance_args, mapped_args = build_constraints_for_unpack(
                         instance.args,
                         instance.type.type_var_tuple_prefix,
                         instance.type.type_var_tuple_suffix,
+                        mapped.args,
+                        mapped.type.type_var_tuple_prefix,
+                        mapped.type.type_var_tuple_suffix,
                         self.direction,
                     )
                     res.extend(unpack_constraints)
@@ -1217,6 +1217,9 @@ def find_and_build_constraints_for_unpack(
 
 
 def build_constraints_for_unpack(
+    # TODO: this naming is misleading, these should be "actual", not "mapped"
+    # both template and actual can be mapped before, depending on direction.
+    # Also the convention is to put template related args first.
     mapped: tuple[Type, ...],
     mapped_prefix_len: int | None,
     mapped_suffix_len: int | None,

diff --git a/mypy/expandtype.py b/mypy/expandtype.py
@@ -271,7 +271,7 @@ def visit_param_spec(self, t: ParamSpecType) -> Type:
             return repl
 
     def visit_type_var_tuple(self, t: TypeVarTupleType) -> Type:
-        # Sometimes solver may need to expand a type variable with itself
+        # Sometimes solver may need to expand a type variable with (a copy of) itself
         # (usually for other TypeVars, and it is hard to filter out TypeVarTuples).
         repl = self.variables[t.id]
         if isinstance(repl, TypeVarTupleType):

diff --git a/mypy/infer.py b/mypy/infer.py
@@ -12,7 +12,7 @@
 )
 from mypy.nodes import ArgKind
 from mypy.solve import solve_constraints
-from mypy.types import CallableType, Instance, Type, TypeVarId, TypeVarType, TypeVarLikeType
+from mypy.types import CallableType, Instance, Type, TypeVarLikeType
 
 
 class ArgumentInferContext(NamedTuple):
@@ -37,7 +37,7 @@ def infer_function_type_arguments(
     context: ArgumentInferContext,
     strict: bool = True,
     allow_polymorphic: bool = False,
-) -> tuple[list[Type | None], list[TypeVarType]]:
+) -> tuple[list[Type | None], list[TypeVarLikeType]]:
     """Infer the type arguments of a generic function.
 
     Return an array of lower bound types for the type variables -1 (at
@@ -62,7 +62,10 @@ def infer_function_type_arguments(
 
 
 def infer_type_arguments(
-    type_var_ids: Sequence[TypeVarLikeType], template: Type, actual: Type, is_supertype: bool = False
+    type_var_ids: Sequence[TypeVarLikeType],
+    template: Type,
+    actual: Type,
+    is_supertype: bool = False,
 ) -> list[Type | None]:
     # Like infer_function_type_arguments, but only match a single type
     # against a generic type.

diff --git a/mypy/solve.py b/mypy/solve.py
@@ -5,7 +5,7 @@
 from collections import defaultdict
 from typing import Iterable, Sequence
 
-from mypy.constraints import SUBTYPE_OF, SUPERTYPE_OF, Constraint, neg_op, infer_constraints
+from mypy.constraints import SUBTYPE_OF, SUPERTYPE_OF, Constraint, infer_constraints, neg_op
 from mypy.expandtype import expand_type
 from mypy.graph_utils import prepare_sccs, strongly_connected_components, topsort
 from mypy.join import join_types
@@ -18,12 +18,12 @@
     Type,
     TypeOfAny,
     TypeVarId,
+    TypeVarLikeType,
     TypeVarType,
     UninhabitedType,
     UnionType,
     get_proper_type,
     remove_dups,
-    TypeVarLikeType,
 )
 from mypy.typestate import type_state
 
@@ -33,7 +33,7 @@ def solve_constraints(
     constraints: list[Constraint],
     strict: bool = True,
     allow_polymorphic: bool = False,
-) -> tuple[list[Type | None], list[TypeVarType]]:
+) -> tuple[list[Type | None], list[TypeVarLikeType]]:
     """Solve type constraints.
 
     Return the best type(s) for type variables; each type can be None if the value of the variable
@@ -65,7 +65,13 @@ def solve_constraints(
             cmap[con.type_var].append(con)
 
     if allow_polymorphic:
-        solutions, free_vars = solve_non_linear(vars + extra_vars, constraints, vars, originals)
+        if constraints:
+            solutions, free_vars = solve_non_linear(
+                vars + extra_vars, constraints, vars, originals
+            )
+        else:
+            solutions = {}
+            free_vars = []
     else:
         solutions = {}
         free_vars = []
@@ -77,7 +83,6 @@ def solve_constraints(
             solution = solve_one(lowers, uppers, [])
 
             # Do not leak type variables in non-polymorphic solutions.
-            # XXX: somehow this breaks defaultdict partial types.
             if solution is None or not get_vars(
                 solution, [tv for tv in extra_vars if tv not in vars]
             ):

diff --git a/mypy/test/testsolve.py b/mypy/test/testsolve.py
@@ -6,7 +6,7 @@
 from mypy.solve import solve_constraints
 from mypy.test.helpers import Suite, assert_equal
 from mypy.test.typefixture import TypeFixture
-from mypy.types import Type, TypeVarId, TypeVarType, TypeVarLikeType
+from mypy.types import Type, TypeVarLikeType, TypeVarType
 
 
 class SolveSuite(Suite):