Don't wrap ParamSpec *args and **kwargs types in tuple[...] or dict[...]

JukkaL · Nov 23, 2021 · Nov 18, 2021 · Nov 18, 2021 · Nov 18, 2021 · Nov 18, 2021
commit 22afc1d2bbd2a33bfc995c21dd473a6bf2d259f5
diff --git a/mypy/checker.py b/mypy/checker.py
@@ -37,7 +37,8 @@
     UnionType, TypeVarId, TypeVarType, PartialType, DeletedType, UninhabitedType,
     is_named_instance, union_items, TypeQuery, LiteralType,
     is_optional, remove_optional, TypeTranslator, StarType, get_proper_type, ProperType,
-    get_proper_types, is_literal_type, TypeAliasType, TypeGuardedType)
+    get_proper_types, is_literal_type, TypeAliasType, TypeGuardedType, ParamSpecType
+)
 from mypy.sametypes import is_same_type
 from mypy.messages import (
     MessageBuilder, make_inferred_type_note, append_invariance_notes, pretty_seq,
@@ -977,12 +978,14 @@ def check_func_def(self, defn: FuncItem, typ: CallableType, name: Optional[str])
                             self.fail(message_registry.FUNCTION_PARAMETER_CANNOT_BE_COVARIANT, ctx)
                     if typ.arg_kinds[i] == nodes.ARG_STAR:
                         # builtins.tuple[T] is typing.Tuple[T, ...]
-                        arg_type = self.named_generic_type('builtins.tuple',
-                                                           [arg_type])
+                        if not isinstance(arg_type, ParamSpecType):
+                            arg_type = self.named_generic_type('builtins.tuple',
+                                                               [arg_type])
                     elif typ.arg_kinds[i] == nodes.ARG_STAR2:
-                        arg_type = self.named_generic_type('builtins.dict',
-                                                           [self.str_type(),
-                                                            arg_type])
+                        if not isinstance(arg_type, ParamSpecType):
+                            arg_type = self.named_generic_type('builtins.dict',
+                                                               [self.str_type(),
+                                                                arg_type])
                     item.arguments[i].variable.type = arg_type
 
                 # Type check initialization expressions.

diff --git a/mypy/checkexpr.py b/mypy/checkexpr.py
@@ -18,7 +18,7 @@
     Type, AnyType, CallableType, Overloaded, NoneType, TypeVarType,
     TupleType, TypedDictType, Instance, ErasedType, UnionType,
     PartialType, DeletedType, UninhabitedType, TypeType, TypeOfAny, LiteralType, LiteralValue,
-    is_named_instance, FunctionLike, ParamSpecType,
+    is_named_instance, FunctionLike, ParamSpecType, ParamSpecFlavor,
     StarType, is_optional, remove_optional, is_generic_instance, get_proper_type, ProperType,
     get_proper_types, flatten_nested_unions
 )
@@ -3999,15 +3999,18 @@ def is_valid_var_arg(self, typ: Type) -> bool:
         return (isinstance(typ, TupleType) or
                 is_subtype(typ, self.chk.named_generic_type('typing.Iterable',
                                                             [AnyType(TypeOfAny.special_form)])) or
-                isinstance(typ, AnyType))
+                isinstance(typ, AnyType) or
+                (isinstance(typ, ParamSpecType) and typ.flavor == ParamSpecFlavor.ARGS))
 
     def is_valid_keyword_var_arg(self, typ: Type) -> bool:
         """Is a type valid as a **kwargs argument?"""
         ret = (
                 is_subtype(typ, self.chk.named_generic_type('typing.Mapping',
                     [self.named_type('builtins.str'), AnyType(TypeOfAny.special_form)])) or
                 is_subtype(typ, self.chk.named_generic_type('typing.Mapping',
-                    [UninhabitedType(), UninhabitedType()])))
+                    [UninhabitedType(), UninhabitedType()])) or
+                (isinstance(typ, ParamSpecType) and typ.flavor == ParamSpecFlavor.KWARGS)
+        )
         if self.chk.options.python_version[0] < 3:
             ret = ret or is_subtype(typ, self.chk.named_generic_type('typing.Mapping',
                 [self.named_type('builtins.unicode'), AnyType(TypeOfAny.special_form)]))

diff --git a/mypy/types.py b/mypy/types.py
@@ -2176,10 +2176,15 @@ def visit_type_var(self, t: TypeVarType) -> str:
     def visit_param_spec(self, t: ParamSpecType) -> str:
         if t.name is None:
             # Anonymous type variable type (only numeric id).
-            s = '`{}'.format(t.id)
+            s = f'`{t.id}'
         else:
             # Named type variable type.
-            s = '{}`{}'.format(t.name, t.id)
+            suffix = ''
+            if t.flavor == ParamSpecFlavor.ARGS:
+                suffix = '.args'
+            elif t.flavor == ParamSpecFlavor.KWARGS:
+                suffix = '.kwargs'
+            s = f'{t.name}{suffix}`{t.id}'
         return s
 
     def visit_callable_type(self, t: CallableType) -> str:

diff --git a/test-data/unit/check-parameter-specification.test b/test-data/unit/check-parameter-specification.test
@@ -225,3 +225,17 @@ def g(x: int, y: str = '') -> int: ...
 
 reveal_type(g)  # N: Revealed type is "def (x: builtins.int, y: builtins.str =) -> builtins.list[builtins.int*]"
 [builtins fixtures/dict.pyi]
+
+[case testParamSpecArgsAndKwargsTypes]
+from typing import Callable, TypeVar, Generic
+from typing_extensions import ParamSpec
+
+P = ParamSpec('P')
+
+class C(Generic[P]):
+    def __init__(self, x: Callable[P, None]) -> None: ...
+
+    def m(self, *args: P.args, **kwargs: P.kwargs) -> None:
+        reveal_type(args)  # N: Revealed type is "P.args`1"
+        reveal_type(kwargs)  # N: Revealed type is "P.kwargs`1"
+[builtins fixtures/dict.pyi]