Support ParamSpec for TypeAliasType

src/test_typing_extensions.py

@@ -7237,7 +7237,7 @@ def test_getitem(self):
         self.assertEqual(get_args(subscripted), (int,))
         self.assertIs(get_origin(subscripted), ListOrSetT)
         with self.assertRaises(TypeError):
-            subscripted[str]
+            subscripted[int]  # TypeError: ListOrSetT[int] is not a generic class
 
         still_generic = ListOrSetT[Iterable[T]]
         self.assertEqual(get_args(still_generic), (Iterable[T],))
@@ -7246,6 +7246,42 @@ def test_getitem(self):
         self.assertEqual(get_args(fully_subscripted), (Iterable[float],))
         self.assertIs(get_origin(fully_subscripted), ListOrSetT)
 
+        # Test ParamSpec and Ellipsis
+        P = ParamSpec('P')
+        CallableP = TypeAliasType("CallableP", Callable[P, Any], type_params=(P,))
+        # () -> Any
+        callable_no_arg = CallableP[[]]
+        self.assertEqual(get_args(callable_no_arg), ([],))
+        # (int) -> Any
+        callable_arg_raw = CallableP[int]
+        self.assertEqual(get_args(callable_arg_raw), (int,))
+        callable_arg = CallableP[[int]]
+        self.assertEqual(get_args(callable_arg), ([int],))
+        # (int, int) -> Any
+        callable_arg2 = CallableP[[int, int]]
+        self.assertEqual(get_args(callable_arg2), ([int, int],))
+        # (...) -> Any
+        callable_ellipsis = CallableP[...]
+        self.assertEqual(get_args(callable_ellipsis), (...,))
+        callable_ellipsis2 = CallableP[(...,)]
+        self.assertEqual(callable_ellipsis, callable_ellipsis2)
+        # (int, ...) -> Any
+        callable_arg_more = CallableP[[int, ...]]
+        self.assertEqual(get_args(callable_arg_more), ([int, ...],))
+        # (T) -> Any
+        callable_generic = CallableP[[T]]
+        self.assertEqual(get_args(callable_generic), ([T],))
+        callable_generic_raw = CallableP[T]
+        self.assertEqual(get_args(callable_generic_raw), (T,))
+
+        # test invalid usage
+        if not TYPING_3_11_0:
+            with self.assertRaises(TypeError):
+                ListOrSetT[Generic[T]]
+            with self.assertRaises(TypeError):
+                ListOrSetT[(Generic[T], )]
+
+
     def test_pickle(self):
         global Alias
         Alias = TypeAliasType("Alias", int)

src/typing_extensions.py

@@ -3487,6 +3487,8 @@ def __init__(self, name: str, value, *, type_params=()):
             self.__type_params__ = type_params
 
             parameters = []
+            if not isinstance(type_params, tuple):
+                raise TypeError("type_params must be a tuple")
             for type_param in type_params:
                 if isinstance(type_param, TypeVarTuple):
                     parameters.extend(type_param)
@@ -3524,16 +3526,47 @@ def _raise_attribute_error(self, name: str) -> Never:
         def __repr__(self) -> str:
             return self.__name__
 
-        def __getitem__(self, parameters):
-            if not isinstance(parameters, tuple):
-                parameters = (parameters,)
-            parameters = [
-                typing._type_check(
-                    item, f'Subscripting {self.__name__} requires a type.'
-                )
-                for item in parameters
-            ]
-            return typing._GenericAlias(self, tuple(parameters))
+        if sys.version_info >= (3, 11):
+            def __getitem__(self, parameters):
+                if not isinstance(parameters, tuple):
+                    parameters = (parameters,)
+                parameters = [
+                        typing._type_check(
+                            item, f'Subscripting {self.__name__} requires a type.'
+                        )
+                        for item in parameters
+                    ]
+                alias = typing._GenericAlias(self, tuple(parameters))
+                alias.__value__ = self.__value__
+                alias.__type_params__ = self.__type_params__
+                return alias
+        else:
+            def _check_parameter(self, item, typ=_marker):
+                # Allow [], [int], [int, str], [int, ...], [int, T]
+                if not isinstance(typ, ParamSpec) and typ is not _marker:
+                    return typing._type_check(
+                            item, f'Subscripting {self.__name__} requires a type.'
+                    )
+                if item is ...:
+                    return ...
+                elif isinstance(item, list) and typ is not _marker:
+                    return [self._check_parameter(arg) for arg in item]
+                else:
+                    return typing._type_check(
+                        item, f'Subscripting {self.__name__} requires a type.'
+                    )
+
+            def __getitem__(self, parameters):
+                if not isinstance(parameters, tuple):
+                    parameters = (parameters,)
+                parameters = [
+                        self._check_parameter(item, typ)
+                        for item, typ in zip(parameters, self.__type_params__)
+                ]
+                alias = typing._GenericAlias(self, tuple(parameters))
+                alias.__value__ = self.__value__
+                alias.__type_params__ = self.__type_params__
+                return alias
 
         def __reduce__(self):
             return self.__name__