Support ParamSpec for TypeAliasType

src/test_typing_extensions.py

@@ -7246,6 +7246,34 @@ 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,))
+
     def test_pickle(self):
         global Alias
         Alias = TypeAliasType("Alias", int)

src/typing_extensions.py

@@ -1,3 +1,4 @@
+# pyright: reportShadowedImports=false
 import abc
 import collections
 import collections.abc
@@ -3524,16 +3525,41 @@ 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
+                    ]
+                return typing._GenericAlias(self, tuple(parameters))
+        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__)
+                ]
+                return typing._GenericAlias(self, tuple(parameters))
 
         def __reduce__(self):
             return self.__name__