Implement basic typevartuple constraints/inference (#12688)

Implements basic inference for TypeVarTuple along with various check tests 
verifying uses of TypeVarTuple with functions works reasonably.

Author: jhance

mypy/applytype.py

@@ -5,7 +5,8 @@
 from mypy.expandtype import expand_type
 from mypy.types import (
     Type, TypeVarId, TypeVarType, CallableType, AnyType, PartialType, get_proper_types,
-    TypeVarLikeType, ProperType, ParamSpecType, Parameters, get_proper_type
+    TypeVarLikeType, ProperType, ParamSpecType, Parameters, get_proper_type,
+    TypeVarTupleType,
 )
 from mypy.nodes import Context
 
@@ -20,6 +21,8 @@ def get_target_type(
 ) -> Optional[Type]:
     if isinstance(tvar, ParamSpecType):
         return type
+    if isinstance(tvar, TypeVarTupleType):
+        return type
     assert isinstance(tvar, TypeVarType)
     values = get_proper_types(tvar.values)
     if values:

mypy/constraints.py

@@ -694,6 +694,27 @@ def infer_against_overloaded(self, overloaded: Overloaded,
 
     def visit_tuple_type(self, template: TupleType) -> List[Constraint]:
         actual = self.actual
+        # TODO: Support other items in the tuple besides Unpack
+        # TODO: Support subclasses of Tuple
+        is_varlength_tuple = (
+            isinstance(actual, Instance)
+            and actual.type.fullname == "builtins.tuple"
+        )
+        if len(template.items) == 1:
+            item = get_proper_type(template.items[0])
+            if isinstance(item, UnpackType):
+                unpacked_type = get_proper_type(item.type)
+                if isinstance(unpacked_type, TypeVarTupleType):
+                    if (
+                        isinstance(actual, (TupleType, AnyType))
+                        or is_varlength_tuple
+                    ):
+                        return [Constraint(
+                            type_var=unpacked_type.id,
+                            op=self.direction,
+                            target=actual,
+                        )]
+
         if isinstance(actual, TupleType) and len(actual.items) == len(template.items):
             res: List[Constraint] = []
             for i in range(len(template.items)):

mypy/expandtype.py

@@ -1,4 +1,4 @@
-from typing import Dict, Iterable, List, TypeVar, Mapping, cast
+from typing import Dict, Iterable, List, TypeVar, Mapping, cast, Union, Optional
 
 from mypy.types import (
     Type, Instance, CallableType, TypeVisitor, UnboundType, AnyType,
@@ -45,6 +45,8 @@ def freshen_function_type_vars(callee: F) -> F:
             # TODO(PEP612): fix for ParamSpecType
             if isinstance(v, TypeVarType):
                 tv: TypeVarLikeType = TypeVarType.new_unification_variable(v)
+            elif isinstance(v, TypeVarTupleType):
+                tv = TypeVarTupleType.new_unification_variable(v)
             else:
                 assert isinstance(v, ParamSpecType)
                 tv = ParamSpecType.new_unification_variable(v)
@@ -135,7 +137,36 @@ def visit_type_var_tuple(self, t: TypeVarTupleType) -> Type:
         raise NotImplementedError
 
     def visit_unpack_type(self, t: UnpackType) -> Type:
-        raise NotImplementedError
+        # It is impossible to reasonally implement visit_unpack_type, because
+        # unpacking inherently expands to something more like a list of types.
+        #
+        # Relevant sections that can call unpack should call expand_unpack()
+        # instead.
+        assert False, "Mypy bug: unpacking must happen at a higher level"
+
+    def expand_unpack(self, t: UnpackType) -> Optional[Union[List[Type], Instance, AnyType]]:
+        """May return either a list of types to unpack to, any, or a single
+        variable length tuple. The latter may not be valid in all contexts.
+        """
+        proper_typ = get_proper_type(t.type)
+        if isinstance(proper_typ, TypeVarTupleType):
+            repl = get_proper_type(self.variables.get(proper_typ.id, t))
+            if isinstance(repl, TupleType):
+                return repl.items
+            elif isinstance(repl, Instance) and repl.type.fullname == "builtins.tuple":
+                return repl
+            elif isinstance(repl, AnyType):
+                # tuple[Any, ...] would be better, but we don't have
+                # the type info to construct that type here.
+                return repl
+            elif isinstance(repl, TypeVarTupleType):
+                return [UnpackType(typ=repl)]
+            elif isinstance(repl, UninhabitedType):
+                return None
+            else:
+                raise NotImplementedError("Invalid type to expand: {}".format(repl))
+        else:
+            raise NotImplementedError
 
     def visit_parameters(self, t: Parameters) -> Type:
         return t.copy_modified(arg_types=self.expand_types(t.arg_types))
@@ -179,7 +210,27 @@ def visit_overloaded(self, t: Overloaded) -> Type:
         return Overloaded(items)
 
     def visit_tuple_type(self, t: TupleType) -> Type:
-        return t.copy_modified(items=self.expand_types(t.items))
+        items = []
+        for item in t.items:
+            proper_item = get_proper_type(item)
+            if isinstance(proper_item, UnpackType):
+                unpacked_items = self.expand_unpack(proper_item)
+                if unpacked_items is None:
+                    # TODO: better error, something like tuple of unknown?
+                    return UninhabitedType()
+                elif isinstance(unpacked_items, Instance):
+                    if len(t.items) == 1:
+                        return unpacked_items
+                    else:
+                        assert False, "Invalid unpack of variable length tuple"
+                elif isinstance(unpacked_items, AnyType):
+                    return unpacked_items
+                else:
+                    items.extend(unpacked_items)
+            else:
+                items.append(proper_item.accept(self))
+
+        return t.copy_modified(items=items)
 
     def visit_typeddict_type(self, t: TypedDictType) -> Type:
         return t.copy_modified(item_types=self.expand_types(t.items.values()))

mypy/subtypes.py

@@ -350,7 +350,9 @@ def visit_type_var_tuple(self, left: TypeVarTupleType) -> bool:
         return self._is_subtype(left.upper_bound, self.right)
 
     def visit_unpack_type(self, left: UnpackType) -> bool:
-        raise NotImplementedError
+        if isinstance(self.right, UnpackType):
+            return self._is_subtype(left.type, self.right.type)
+        return False
 
     def visit_parameters(self, left: Parameters) -> bool:
         right = self.right
@@ -1482,7 +1484,9 @@ def visit_type_var_tuple(self, left: TypeVarTupleType) -> bool:
         return self._is_proper_subtype(left.upper_bound, self.right)
 
     def visit_unpack_type(self, left: UnpackType) -> bool:
-        raise NotImplementedError
+        if isinstance(self.right, UnpackType):
+            return self._is_proper_subtype(left.type, self.right.type)
+        return False
 
     def visit_parameters(self, left: Parameters) -> bool:
         right = self.right

mypy/test/testcheck.py

@@ -91,6 +91,7 @@
     'check-errorcodes.test',
     'check-annotated.test',
     'check-parameter-specification.test',
+    'check-typevar-tuple.test',
     'check-generic-alias.test',
     'check-typeguard.test',
     'check-functools.test',
@@ -164,6 +165,7 @@ def run_case_once(self, testcase: DataDrivenTestCase,
         # Parse options after moving files (in case mypy.ini is being moved).
         options = parse_options(original_program_text, testcase, incremental_step)
         options.use_builtins_fixtures = True
+        options.enable_incomplete_features = True
         options.show_traceback = True
 
         # Enable some options automatically based on test file name.

mypy/typeanal.py

@@ -1202,8 +1202,6 @@ def anal_var_def(self, var_def: TypeVarLikeType) -> TypeVarLikeType:
                 var_def.variance,
                 var_def.line
             )
-        elif isinstance(var_def, TypeVarTupleType):
-            raise NotImplementedError
         else:
             return var_def
 

mypy/types.py

@@ -696,6 +696,12 @@ def __eq__(self, other: object) -> bool:
             return NotImplemented
         return self.id == other.id
 
+    @staticmethod
+    def new_unification_variable(old: 'TypeVarTupleType') -> 'TypeVarTupleType':
+        new_id = TypeVarId.new(meta_level=1)
+        return TypeVarTupleType(old.name, old.fullname, new_id, old.upper_bound,
+                             line=old.line, column=old.column)
+
 
 class UnboundType(ProperType):
     """Instance type that has not been bound during semantic analysis."""

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

@@ -0,0 +1,29 @@
+[case testTypeVarTupleBasic]
+from typing import Any, Tuple
+from typing_extensions import Unpack, TypeVarTuple
+
+Ts = TypeVarTuple("Ts")
+
+def f(a: Tuple[Unpack[Ts]]) -> Tuple[Unpack[Ts]]:
+    return a
+
+any: Any
+args: Tuple[int, str] = (1, 'x')
+args2: Tuple[bool, str] = (False, 'y')
+args3: Tuple[int, str, bool] = (2, 'z', True)
+varargs: Tuple[int, ...] = (1, 2, 3)
+
+reveal_type(f(args))  # N: Revealed type is "Tuple[builtins.int, builtins.str]"
+
+reveal_type(f(varargs))  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
+
+f(0)  # E: Argument 1 to "f" has incompatible type "int"; expected <nothing>
+
+def g(a: Tuple[Unpack[Ts]], b: Tuple[Unpack[Ts]]) -> Tuple[Unpack[Ts]]:
+    return a
+
+reveal_type(g(args, args))  # N: Revealed type is "Tuple[builtins.int, builtins.str]"
+reveal_type(g(args, args2))  # N: Revealed type is "Tuple[builtins.int, builtins.str]"
+reveal_type(g(args, args3))  # N: Revealed type is "builtins.tuple[builtins.object, ...]"
+reveal_type(g(any, any))  # N: Revealed type is "Any"
+[builtins fixtures/tuple.pyi]