Add UnpackType type and basic semanal (#12367)

jhance · web-flow · commit aa0d18638bdd · 2022-03-17T12:49:13.000Z
Adds very basic support for Unpack expressions (where Unpack
is either from typing or typing_extensions). Many of the visitors
implementations are not implemented yet.

The only supported feature we have so far is validating that the
argument to UnpackType actually makes sense. Currently we don't
support unions, though. Since TypeVarTuple isn't yet implemented,
we don't support that from UnpackType either.

We don't want anyone to start using variadic generics at all until
we have real support for it. We also don't want to implement it in
one huge PR. So mypy is learning a new flag called
--enable-incomplete-features which we can enable by default in any
testsuite that needs to use incomplete features, as well as pass on
the command line for debugging, but it is undocumented and suppressed
from the help output so nobody should find it.
diff --git a/mypy/constraints.py b/mypy/constraints.py
@@ -8,8 +8,7 @@
     TupleType, TypedDictType, UnionType, Overloaded, ErasedType, PartialType, DeletedType,
     UninhabitedType, TypeType, TypeVarId, TypeQuery, is_named_instance, TypeOfAny, LiteralType,
     ProperType, ParamSpecType, get_proper_type, TypeAliasType, is_union_with_any,
-    callable_with_ellipsis,
-    TUPLE_LIKE_INSTANCE_NAMES,
+    UnpackType, callable_with_ellipsis, TUPLE_LIKE_INSTANCE_NAMES,
 )
 from mypy.maptype import map_instance_to_supertype
 import mypy.subtypes
@@ -404,6 +403,9 @@ def visit_param_spec(self, template: ParamSpecType) -> List[Constraint]:
         # Can't infer ParamSpecs from component values (only via Callable[P, T]).
         return []
 
+    def visit_unpack_type(self, template: UnpackType) -> List[Constraint]:
+        raise NotImplementedError
+
     # Non-leaf types
 
     def visit_instance(self, template: Instance) -> List[Constraint]:
diff --git a/mypy/erasetype.py b/mypy/erasetype.py
@@ -4,7 +4,7 @@
     Type, TypeVisitor, UnboundType, AnyType, NoneType, TypeVarId, Instance, TypeVarType,
     CallableType, TupleType, TypedDictType, UnionType, Overloaded, ErasedType, PartialType,
     DeletedType, TypeTranslator, UninhabitedType, TypeType, TypeOfAny, LiteralType, ProperType,
-    get_proper_type, get_proper_types, TypeAliasType, ParamSpecType
+    get_proper_type, get_proper_types, TypeAliasType, ParamSpecType, UnpackType
 )
 from mypy.nodes import ARG_STAR, ARG_STAR2
 
@@ -59,6 +59,9 @@ def visit_type_var(self, t: TypeVarType) -> ProperType:
     def visit_param_spec(self, t: ParamSpecType) -> ProperType:
         return AnyType(TypeOfAny.special_form)
 
+    def visit_unpack_type(self, t: UnpackType) -> ProperType:
+        raise NotImplementedError
+
     def visit_callable_type(self, t: CallableType) -> ProperType:
         # We must preserve the fallback type for overload resolution to work.
         any_type = AnyType(TypeOfAny.special_form)
diff --git a/mypy/expandtype.py b/mypy/expandtype.py
@@ -5,7 +5,7 @@
     NoneType, Overloaded, TupleType, TypedDictType, UnionType,
     ErasedType, PartialType, DeletedType, UninhabitedType, TypeType, TypeVarId,
     FunctionLike, TypeVarType, LiteralType, get_proper_type, ProperType,
-    TypeAliasType, ParamSpecType, TypeVarLikeType
+    TypeAliasType, ParamSpecType, TypeVarLikeType, UnpackType
 )
 
 
@@ -111,6 +111,9 @@ def visit_param_spec(self, t: ParamSpecType) -> Type:
         else:
             return repl
 
+    def visit_unpack_type(self, t: UnpackType) -> Type:
+        raise NotImplementedError
+
     def visit_callable_type(self, t: CallableType) -> Type:
         param_spec = t.param_spec()
         if param_spec is not None:
diff --git a/mypy/fixup.py b/mypy/fixup.py
@@ -10,7 +10,8 @@
 from mypy.types import (
     CallableType, Instance, Overloaded, TupleType, TypedDictType,
     TypeVarType, UnboundType, UnionType, TypeVisitor, LiteralType,
-    TypeType, NOT_READY, TypeAliasType, AnyType, TypeOfAny, ParamSpecType
+    TypeType, NOT_READY, TypeAliasType, AnyType, TypeOfAny, ParamSpecType,
+    UnpackType,
 )
 from mypy.visitor import NodeVisitor
 from mypy.lookup import lookup_fully_qualified
@@ -251,6 +252,9 @@ def visit_type_var(self, tvt: TypeVarType) -> None:
     def visit_param_spec(self, p: ParamSpecType) -> None:
         p.upper_bound.accept(self)
 
+    def visit_unpack_type(self, u: UnpackType) -> None:
+        u.type.accept(self)
+
     def visit_unbound_type(self, o: UnboundType) -> None:
         for a in o.args:
             a.accept(self)
diff --git a/mypy/indirection.py b/mypy/indirection.py
@@ -67,6 +67,9 @@ def visit_type_var(self, t: types.TypeVarType) -> Set[str]:
     def visit_param_spec(self, t: types.ParamSpecType) -> Set[str]:
         return set()
 
+    def visit_unpack_type(self, t: types.UnpackType) -> Set[str]:
+        return t.type.accept(self)
+
     def visit_instance(self, t: types.Instance) -> Set[str]:
         out = self._visit(t.args)
         if t.type:
diff --git a/mypy/join.py b/mypy/join.py
@@ -7,7 +7,8 @@
     Type, AnyType, NoneType, TypeVisitor, Instance, UnboundType, TypeVarType, CallableType,
     TupleType, TypedDictType, ErasedType, UnionType, FunctionLike, Overloaded, LiteralType,
     PartialType, DeletedType, UninhabitedType, TypeType, TypeOfAny, get_proper_type,
-    ProperType, get_proper_types, TypeAliasType, PlaceholderType, ParamSpecType
+    ProperType, get_proper_types, TypeAliasType, PlaceholderType, ParamSpecType,
+    UnpackType
 )
 from mypy.maptype import map_instance_to_supertype
 from mypy.subtypes import (
@@ -256,6 +257,9 @@ def visit_param_spec(self, t: ParamSpecType) -> ProperType:
             return t
         return self.default(self.s)
 
+    def visit_unpack_type(self, t: UnpackType) -> UnpackType:
+        raise NotImplementedError
+
     def visit_instance(self, t: Instance) -> ProperType:
         if isinstance(self.s, Instance):
             if self.instance_joiner is None:
diff --git a/mypy/main.py b/mypy/main.py
@@ -862,6 +862,8 @@ def add_invertible_flag(flag: str,
     # Must be followed by another flag or by '--' (and then only file args may follow).
     parser.add_argument('--cache-map', nargs='+', dest='special-opts:cache_map',
                         help=argparse.SUPPRESS)
+    parser.add_argument('--enable-incomplete-features', default=False,
+                        help=argparse.SUPPRESS)
 
     # options specifying code to check
     code_group = parser.add_argument_group(
diff --git a/mypy/meet.py b/mypy/meet.py
@@ -6,7 +6,7 @@
     TupleType, TypedDictType, ErasedType, UnionType, PartialType, DeletedType,
     UninhabitedType, TypeType, TypeOfAny, Overloaded, FunctionLike, LiteralType,
     ProperType, get_proper_type, get_proper_types, TypeAliasType, TypeGuardedType,
-    ParamSpecType
+    ParamSpecType, UnpackType,
 )
 from mypy.subtypes import is_equivalent, is_subtype, is_callable_compatible, is_proper_subtype
 from mypy.erasetype import erase_type
@@ -506,6 +506,9 @@ def visit_param_spec(self, t: ParamSpecType) -> ProperType:
         else:
             return self.default(self.s)
 
+    def visit_unpack_type(self, t: UnpackType) -> ProperType:
+        raise NotImplementedError
+
     def visit_instance(self, t: Instance) -> ProperType:
         if isinstance(self.s, Instance):
             if t.type == self.s.type:
diff --git a/mypy/message_registry.py b/mypy/message_registry.py
@@ -152,6 +152,7 @@ def format(self, *args: object, **kwargs: object) -> "ErrorMessage":
 IMPLICIT_GENERIC_ANY_BUILTIN: Final = (
     'Implicit generic "Any". Use "{}" and specify generic parameters'
 )
+INVALID_UNPACK = "{} cannot be unpacked (must be tuple or TypeVarTuple)"
 
 # TypeVar
 INCOMPATIBLE_TYPEVAR_VALUE: Final = 'Value of type variable "{}" of {} cannot be {}'
diff --git a/mypy/options.py b/mypy/options.py
@@ -258,6 +258,7 @@ def __init__(self) -> None:
         self.dump_type_stats = False
         self.dump_inference_stats = False
         self.dump_build_stats = False
+        self.enable_incomplete_features = False
 
         # -- test options --
         # Stop after the semantic analysis phase
diff --git a/mypy/sametypes.py b/mypy/sametypes.py
@@ -4,7 +4,7 @@
     Type, UnboundType, AnyType, NoneType, TupleType, TypedDictType,
     UnionType, CallableType, TypeVarType, Instance, TypeVisitor, ErasedType,
     Overloaded, PartialType, DeletedType, UninhabitedType, TypeType, LiteralType,
-    ProperType, get_proper_type, TypeAliasType, ParamSpecType
+    ProperType, get_proper_type, TypeAliasType, ParamSpecType, UnpackType
 )
 from mypy.typeops import tuple_fallback, make_simplified_union
 
@@ -102,6 +102,10 @@ def visit_param_spec(self, left: ParamSpecType) -> bool:
         return (isinstance(self.right, ParamSpecType) and
                 left.id == self.right.id and left.flavor == self.right.flavor)
 
+    def visit_unpack_type(self, left: UnpackType) -> bool:
+        return (isinstance(self.right, UnpackType) and
+                is_same_type(left.type, self.right.type))
+
     def visit_callable_type(self, left: CallableType) -> bool:
         # FIX generics
         if isinstance(self.right, CallableType):
diff --git a/mypy/semanal_typeargs.py b/mypy/semanal_typeargs.py
@@ -10,7 +10,7 @@
 from mypy.nodes import TypeInfo, Context, MypyFile, FuncItem, ClassDef, Block, FakeInfo
 from mypy.types import (
     Type, Instance, TypeVarType, AnyType, get_proper_types, TypeAliasType, ParamSpecType,
-    get_proper_type
+    UnpackType, TupleType, get_proper_type
 )
 from mypy.mixedtraverser import MixedTraverserVisitor
 from mypy.subtypes import is_subtype
@@ -95,6 +95,14 @@ def visit_instance(self, t: Instance) -> None:
                         t, code=codes.TYPE_VAR)
         super().visit_instance(t)
 
+    def visit_unpack_type(self, typ: UnpackType) -> None:
+        proper_type = get_proper_type(typ.type)
+        if isinstance(proper_type, TupleType):
+            return
+        if isinstance(proper_type, Instance) and proper_type.type.fullname == "builtins.tuple":
+            return
+        self.fail(message_registry.INVALID_UNPACK.format(proper_type), typ)
+
     def check_type_var_values(self, type: TypeInfo, actuals: List[Type], arg_name: str,
                               valids: List[Type], arg_number: int, context: Context) -> None:
         for actual in get_proper_types(actuals):
diff --git a/mypy/server/astdiff.py b/mypy/server/astdiff.py
@@ -59,7 +59,8 @@ class level -- these are handled at attribute level (say, 'mod.Cls.method'
 from mypy.types import (
     Type, TypeVisitor, UnboundType, AnyType, NoneType, UninhabitedType,
     ErasedType, DeletedType, Instance, TypeVarType, CallableType, TupleType, TypedDictType,
-    UnionType, Overloaded, PartialType, TypeType, LiteralType, TypeAliasType, ParamSpecType
+    UnionType, Overloaded, PartialType, TypeType, LiteralType, TypeAliasType, ParamSpecType,
+    UnpackType,
 )
 from mypy.util import get_prefix
 
@@ -317,6 +318,9 @@ def visit_param_spec(self, typ: ParamSpecType) -> SnapshotItem:
                 typ.flavor,
                 snapshot_type(typ.upper_bound))
 
+    def visit_unpack_type(self, typ: UnpackType) -> SnapshotItem:
+        return ('UnpackType', snapshot_type(typ.type))
+
     def visit_callable_type(self, typ: CallableType) -> SnapshotItem:
         # FIX generics
         return ('CallableType',
diff --git a/mypy/server/astmerge.py b/mypy/server/astmerge.py
@@ -59,7 +59,8 @@
     Type, SyntheticTypeVisitor, Instance, AnyType, NoneType, CallableType, ErasedType, DeletedType,
     TupleType, TypeType, TypedDictType, UnboundType, UninhabitedType, UnionType,
     Overloaded, TypeVarType, TypeList, CallableArgument, EllipsisType, StarType, LiteralType,
-    RawExpressionType, PartialType, PlaceholderType, TypeAliasType, ParamSpecType
+    RawExpressionType, PartialType, PlaceholderType, TypeAliasType, ParamSpecType,
+    UnpackType
 )
 from mypy.util import get_prefix, replace_object_state
 from mypy.typestate import TypeState
@@ -411,6 +412,9 @@ def visit_type_var(self, typ: TypeVarType) -> None:
     def visit_param_spec(self, typ: ParamSpecType) -> None:
         pass
 
+    def visit_unpack_type(self, typ: UnpackType) -> None:
+        typ.type.accept(self)
+
     def visit_typeddict_type(self, typ: TypedDictType) -> None:
         for value_type in typ.items.values():
             value_type.accept(self)
diff --git a/mypy/server/deps.py b/mypy/server/deps.py
@@ -99,7 +99,7 @@ class 'mod.Cls'. This can also refer to an attribute inherited from a
     Type, Instance, AnyType, NoneType, TypeVisitor, CallableType, DeletedType, PartialType,
     TupleType, TypeType, TypeVarType, TypedDictType, UnboundType, UninhabitedType, UnionType,
     FunctionLike, Overloaded, TypeOfAny, LiteralType, ErasedType, get_proper_type, ProperType,
-    TypeAliasType, ParamSpecType
+    TypeAliasType, ParamSpecType, UnpackType
 )
 from mypy.server.trigger import make_trigger, make_wildcard_trigger
 from mypy.util import correct_relative_import
@@ -961,6 +961,9 @@ def visit_param_spec(self, typ: ParamSpecType) -> List[str]:
         triggers.extend(self.get_type_triggers(typ.upper_bound))
         return triggers
 
+    def visit_unpack_type(self, typ: UnpackType) -> List[str]:
+        return typ.type.accept(self)
+
     def visit_typeddict_type(self, typ: TypedDictType) -> List[str]:
         triggers = []
         for item in typ.items.values():
diff --git a/mypy/subtypes.py b/mypy/subtypes.py
@@ -8,7 +8,7 @@
     Instance, TypeVarType, CallableType, TupleType, TypedDictType, UnionType, Overloaded,
     ErasedType, PartialType, DeletedType, UninhabitedType, TypeType, is_named_instance,
     FunctionLike, TypeOfAny, LiteralType, get_proper_type, TypeAliasType, ParamSpecType,
-    TUPLE_LIKE_INSTANCE_NAMES,
+    UnpackType, TUPLE_LIKE_INSTANCE_NAMES,
 )
 import mypy.applytype
 import mypy.constraints
@@ -327,6 +327,9 @@ def visit_param_spec(self, left: ParamSpecType) -> bool:
             return True
         return self._is_subtype(left.upper_bound, self.right)
 
+    def visit_unpack_type(self, left: UnpackType) -> bool:
+        raise NotImplementedError
+
     def visit_callable_type(self, left: CallableType) -> bool:
         right = self.right
         if isinstance(right, CallableType):
@@ -1357,6 +1360,9 @@ def visit_param_spec(self, left: ParamSpecType) -> bool:
             return True
         return self._is_proper_subtype(left.upper_bound, self.right)
 
+    def visit_unpack_type(self, left: UnpackType) -> bool:
+        raise NotImplementedError
+
     def visit_callable_type(self, left: CallableType) -> bool:
         right = self.right
         if isinstance(right, CallableType):
diff --git a/mypy/test/testsemanal.py b/mypy/test/testsemanal.py
@@ -49,6 +49,7 @@ def get_semanal_options(program_text: str, testcase: DataDrivenTestCase) -> Opti
     options.semantic_analysis_only = True
     options.show_traceback = True
     options.python_version = PYTHON3_VERSION
+    options.enable_incomplete_features = True
     return options
 
 
diff --git a/mypy/type_visitor.py b/mypy/type_visitor.py
@@ -23,7 +23,7 @@
     RawExpressionType, Instance, NoneType, TypeType,
     UnionType, TypeVarType, PartialType, DeletedType, UninhabitedType, TypeVarLikeType,
     UnboundType, ErasedType, StarType, EllipsisType, TypeList, CallableArgument,
-    PlaceholderType, TypeAliasType, ParamSpecType, get_proper_type
+    PlaceholderType, TypeAliasType, ParamSpecType, UnpackType, get_proper_type
 )
 
 
@@ -107,6 +107,10 @@ def visit_type_type(self, t: TypeType) -> T:
     def visit_type_alias_type(self, t: TypeAliasType) -> T:
         pass
 
+    @abstractmethod
+    def visit_unpack_type(self, t: UnpackType) -> T:
+        pass
+
 
 @trait
 @mypyc_attr(allow_interpreted_subclasses=True)
@@ -189,6 +193,9 @@ def visit_param_spec(self, t: ParamSpecType) -> Type:
     def visit_partial_type(self, t: PartialType) -> Type:
         return t
 
+    def visit_unpack_type(self, t: UnpackType) -> Type:
+        return t.type.accept(self)
+
     def visit_callable_type(self, t: CallableType) -> Type:
         return t.copy_modified(arg_types=self.translate_types(t.arg_types),
                                ret_type=t.ret_type.accept(self),
@@ -301,6 +308,9 @@ def visit_type_var(self, t: TypeVarType) -> T:
     def visit_param_spec(self, t: ParamSpecType) -> T:
         return self.strategy([])
 
+    def visit_unpack_type(self, t: UnpackType) -> T:
+        return self.query_types([t.type])
+
     def visit_partial_type(self, t: PartialType) -> T:
         return self.strategy([])
 
diff --git a/mypy/typeanal.py b/mypy/typeanal.py
@@ -17,8 +17,9 @@
     StarType, PartialType, EllipsisType, UninhabitedType, TypeType, CallableArgument,
     TypeQuery, union_items, TypeOfAny, LiteralType, RawExpressionType,
     PlaceholderType, Overloaded, get_proper_type, TypeAliasType, RequiredType,
-    TypeVarLikeType, ParamSpecType, ParamSpecFlavor, callable_with_ellipsis,
-    TYPE_ALIAS_NAMES, FINAL_TYPE_NAMES, LITERAL_TYPE_NAMES, ANNOTATED_TYPE_NAMES,
+    TypeVarLikeType, ParamSpecType, ParamSpecFlavor, UnpackType,
+    callable_with_ellipsis, TYPE_ALIAS_NAMES, FINAL_TYPE_NAMES,
+    LITERAL_TYPE_NAMES, ANNOTATED_TYPE_NAMES,
 )
 
 from mypy.nodes import (
@@ -377,6 +378,14 @@ def try_analyze_special_unbound_type(self, t: UnboundType, fullname: str) -> Opt
         elif self.anal_type_guard_arg(t, fullname) is not None:
             # In most contexts, TypeGuard[...] acts as an alias for bool (ignoring its args)
             return self.named_type('builtins.bool')
+        elif fullname in ('typing.Unpack', 'typing_extensions.Unpack'):
+            # We don't want people to try to use this yet.
+            if not self.options.enable_incomplete_features:
+                self.fail('"Unpack" is not supported by mypy yet', t)
+                return AnyType(TypeOfAny.from_error)
+            return UnpackType(
+                self.anal_type(t.args[0]), line=t.line, column=t.column,
+            )
         return None
 
     def get_omitted_any(self, typ: Type, fullname: Optional[str] = None) -> AnyType:
@@ -558,6 +567,9 @@ def visit_type_var(self, t: TypeVarType) -> Type:
     def visit_param_spec(self, t: ParamSpecType) -> Type:
         return t
 
+    def visit_unpack_type(self, t: UnpackType) -> Type:
+        raise NotImplementedError
+
     def visit_callable_type(self, t: CallableType, nested: bool = True) -> Type:
         # Every Callable can bind its own type variables, if they're not in the outer scope
         with self.tvar_scope_frame():
diff --git a/mypy/types.py b/mypy/types.py
diff --git a/mypy/typetraverser.py b/mypy/typetraverser.py
diff --git a/test-data/unit/lib-stub/typing_extensions.pyi b/test-data/unit/lib-stub/typing_extensions.pyi
diff --git a/test-data/unit/semanal-errors.test b/test-data/unit/semanal-errors.test

Original file line number	Diff line number	Diff line change
`@@ -152,6 +152,7 @@ def format(self, args: object, *kwargs: object) -> "ErrorMessage":`
`152`	`152`	`IMPLICIT_GENERIC_ANY_BUILTIN: Final = (`
`153`	`153`	`'Implicit generic "Any". Use "{}" and specify generic parameters'`
`154`	`154`	`)`
	`155`	`+INVALID_UNPACK = "{} cannot be unpacked (must be tuple or TypeVarTuple)"`
`155`	`156`
`156`	`157`	`# TypeVar`
`157`	`158`	`INCOMPATIBLE_TYPEVAR_VALUE: Final = 'Value of type variable "{}" of {} cannot be {}'`