Ellipsis paramspec literals

JukkaL · Apr 7, 2022 · Dec 24, 2021 · Dec 25, 2021 · Dec 26, 2021 · Dec 26, 2021
commit 14ecfb9753514e4e3448bf8bb5345044b6015af1
diff --git a/mypy/subtypes.py b/mypy/subtypes.py
@@ -929,9 +929,6 @@ def g(x: int) -> int: ...
     if check_args_covariantly:
         is_compat = flip_compat_check(is_compat)
 
-    if right.is_ellipsis_args:
-        return True
-
     return are_parameters_compatible(left, right, is_compat=is_compat,
                                      ignore_pos_arg_names=ignore_pos_arg_names,
                                      check_args_covariantly=check_args_covariantly,
@@ -945,6 +942,9 @@ def are_parameters_compatible(left: Union[Parameters, CallableType],
                               ignore_pos_arg_names: bool = False,
                               check_args_covariantly: bool = False,
                               allow_partial_overlap: bool = False) -> bool:
+    if right.is_ellipsis_args:
+        return True
+
     """Helper function for is_callable_compatible, used for Parameter compatibility"""
     left_star = left.var_arg()
     left_star2 = left.kw_arg()

diff --git a/mypy/typeanal.py b/mypy/typeanal.py
@@ -775,8 +775,15 @@ def visit_partial_type(self, t: PartialType) -> Type:
         assert False, "Internal error: Unexpected partial type"
 
     def visit_ellipsis_type(self, t: EllipsisType) -> Type:
-        self.fail('Unexpected "..."', t)
-        return AnyType(TypeOfAny.from_error)
+        if self.allow_param_spec_literals:
+            any_type = AnyType(TypeOfAny.explicit)
+            return Parameters([any_type, any_type],
+                              [ARG_STAR, ARG_STAR2],
+                              [None, None],
+                              is_ellipsis_args=True)
+        else:
+            self.fail('Unexpected "..."', t)
+            return AnyType(TypeOfAny.from_error)
 
     def visit_type_type(self, t: TypeType) -> Type:
         return TypeType.make_normalized(self.anal_type(t.item), line=t.line)

diff --git a/mypy/types.py b/mypy/types.py
@@ -1092,28 +1092,36 @@ class Parameters(ProperType):
     __slots__ = ('arg_types',
                  'arg_kinds',
                  'arg_names',
-                 'min_args')
+                 'min_args',
+                 'is_ellipsis_args')
 
     def __init__(self,
                  arg_types: Sequence[Type],
                  arg_kinds: List[ArgKind],
                  arg_names: Sequence[Optional[str]],
+                 *,
+                 is_ellipsis_args: bool = False
                  ) -> None:
         self.arg_types = list(arg_types)
         self.arg_kinds = arg_kinds
         self.arg_names = list(arg_names)
-        self.min_args = arg_kinds.count(ARG_POS)
         assert len(arg_types) == len(arg_kinds) == len(arg_names)
+        self.min_args = arg_kinds.count(ARG_POS)
+        self.is_ellipsis_args = is_ellipsis_args
 
     def copy_modified(self,
                       arg_types: Bogus[Sequence[Type]] = _dummy,
                       arg_kinds: Bogus[List[ArgKind]] = _dummy,
-                      arg_names: Bogus[Sequence[Optional[str]]] = _dummy
+                      arg_names: Bogus[Sequence[Optional[str]]] = _dummy,
+                      *,
+                      is_ellipsis_args: Bogus[bool] = _dummy
                       ) -> 'Parameters':
         return Parameters(
             arg_types=arg_types if arg_types is not _dummy else self.arg_types,
             arg_kinds=arg_kinds if arg_kinds is not _dummy else self.arg_kinds,
             arg_names=arg_names if arg_names is not _dummy else self.arg_names,
+            is_ellipsis_args=is_ellipsis_args
+                             if is_ellipsis_args is not _dummy else self.is_ellipsis_args
         )
 
     # the following are copied from CallableType. Is there a way to decrease code duplication?
@@ -1527,11 +1535,13 @@ def expand_param_spec(self,
         if no_prefix:
             return self.copy_modified(arg_types=c.arg_types,
                                       arg_kinds=c.arg_kinds,
-                                      arg_names=c.arg_names)
+                                      arg_names=c.arg_names,
+                                      is_ellipsis_args=c.is_ellipsis_args)
         else:
             return self.copy_modified(arg_types=self.arg_types[:-2] + c.arg_types,
                                       arg_kinds=self.arg_kinds[:-2] + c.arg_kinds,
-                                      arg_names=self.arg_names[:-2] + c.arg_names)
+                                      arg_names=self.arg_names[:-2] + c.arg_names,
+                                      is_ellipsis_args=c.is_ellipsis_args)
 
     def __hash__(self) -> int:
         return hash((self.ret_type, self.is_type_obj(),
@@ -2414,6 +2424,9 @@ def visit_param_spec(self, t: ParamSpecType) -> str:
 
     def visit_parameters(self, t: Parameters) -> str:
         # This is copied from visit_callable -- is there a way to decrease duplication?
+        if t.is_ellipsis_args:
+            return '...'
+
         s = ''
         bare_asterisk = False
         for i in range(len(t.arg_types)):

diff --git a/test-data/unit/check-parameter-specification.test b/test-data/unit/check-parameter-specification.test
@@ -673,3 +673,35 @@ Z[bytes, str](lambda one: None)  # E: Cannot infer type of lambda \
 Z[bytes, str](f2)  # E: Argument 1 to "Z" has incompatible type "Callable[[bytes, int], None]"; expected "Callable[[bytes, str], None]"
 
 [builtins fixtures/tuple.pyi]
+
+[case testParamSpecLiteralEllipsis]
+from typing_extensions import ParamSpec
+from typing import Generic, Callable
+
+P = ParamSpec("P")
+
+class Z(Generic[P]):
+    def __init__(self: 'Z[P]', c: Callable[P, None]) -> None:
+        ...
+
+def f1() -> None: ...
+def f2(*args: int) -> None: ...
+def f3(a: int, *, b: bytes) -> None: ...
+
+def f4(b: bytes) -> None: ...
+
+argh: Callable[..., None] = f4
+
+# check it works
+Z[...](f1)
+Z[...](f2)
+Z[...](f3)
+
+# check subtyping works
+n: Z[...]
+n = Z(f1)
+n = Z(f2)
+n = Z(f3)
+
+[builtins fixtures/tuple.pyi]
+