Support ParamSpec for TypeAliasType

src/test_typing_extensions.py

@@ -7173,6 +7173,89 @@ def test_attributes(self):
         self.assertEqual(Variadic.__type_params__, (Ts,))
         self.assertEqual(Variadic.__parameters__, tuple(iter(Ts)))
 
+        P = ParamSpec('P')
+        CallableP = TypeAliasType("CallableP", Callable[P, Any], type_params=(P, ))
+        self.assertEqual(CallableP.__name__, "CallableP")
+        self.assertEqual(CallableP.__value__,  Callable[P, Any])
+        self.assertEqual(CallableP.__type_params__, (P,))
+        self.assertEqual(CallableP.__parameters__, (P,))
+
+    def test_alias_types_and_substitutions(self):
+        T = TypeVar('T')
+        T2 = TypeVar('T2')
+        T_default = TypeVar("T_default", default=int)
+        Ts = TypeVarTuple("Ts")
+        P = ParamSpec('P')
+
+        test_argument_cases = {
+            # arguments : expected parameters
+            int : (),
+            ... : (),
+            T2 : (T2,),
+            Union[int, List[T2]] : (T2,),
+            Tuple[int, str] : (),
+            Tuple[T, T_default, T2] : (T, T_default, T2),
+            Tuple[Unpack[Ts]] : (Ts,),
+            Callable[[Unpack[Ts]], T2] : (Ts, T2),
+            Callable[P, T2] : (P, T2),
+            Callable[Concatenate[T2,  P], T_default] : (T2, P, T_default),
+            TypeAliasType("NestedAlias", List[T], type_params=(T,))[T2] : (T2,),
+        }
+        # currently a limitation, these args are no longer unpacked in 3.11
+        # OK if GenericAlias in __getitem__ is used
+        test_argument_cases_310_plus = {
+            Unpack[Ts] : (Ts,),
+            Unpack[Tuple[int, T2]] : (T2,),
+            Concatenate[int,  P] : (P,),
+        }
+        test_argument_cases_311_plus = {
+            Ts : (Ts,),  # invalid case
+        }
+        test_argument_cases.update(test_argument_cases_310_plus)
+        test_argument_cases.update(test_argument_cases_311_plus)
+
+        test_alias_cases = [
+            # Simple cases
+            TypeAliasType("ListT", List[T], type_params=(T,)),
+            TypeAliasType("UnionT", Union[int, List[T]], type_params=(T,)),
+            # Value has no parameter but in type_param
+            TypeAliasType("ValueWithoutT", int, type_params=(T,)),
+            # Callable
+            TypeAliasType("CallableP", Callable[P, Any], type_params=(P, )),
+            TypeAliasType("CallableT", Callable[..., T], type_params=(T, )),
+            TypeAliasType("CallableTs", Callable[[Unpack[Ts]], Any], type_params=(Ts, )),
+            # TypeVarTuple
+            TypeAliasType("Variadic", Tuple[int, Unpack[Ts]], type_params=(Ts,)),
+            # TypeVar with default
+            TypeAliasType("TupleT_default", Tuple[T_default, T], type_params=(T, T_default)),
+            TypeAliasType("CallableT_default", Callable[[T], T_default], type_params=(T, T_default)),
+            # default order reversed
+            TypeAliasType("TupleT_default_reversed", Tuple[T_default, T], type_params=(T_default, T)),
+            TypeAliasType("CallableT_default_reversed", Callable[[T], T_default], type_params=(T_default, T)),
+        ]
+
+        for alias in test_alias_cases:
+            with self.subTest(alias=alias, args=[]):
+                subscripted = alias[[]]
+                self.assertEqual(get_args(subscripted), ([],))
+                self.assertEqual(subscripted.__parameters__, ())
+            with self.subTest(alias=alias, args=()):
+                subscripted = alias[()]
+                self.assertEqual(get_args(subscripted), ())
+                self.assertEqual(subscripted.__parameters__, ())
+            with self.subTest(alias=alias, args=(int, float)):
+                subscripted = alias[int, float]
+                self.assertEqual(get_args(subscripted), (int, float))
+                self.assertEqual(subscripted.__parameters__, ())
+            for expected_args, expected_parameters in test_argument_cases.items():
+                with self.subTest(alias=alias, args=expected_args):
+                    if expected_args in test_argument_cases_310_plus and sys.version_info < (3, 10):
+                        self.skipTest("args are unpacked before 3.11 or need GenericAlias")
+                    if expected_args in test_argument_cases_311_plus and sys.version_info < (3, 11):
+                        self.skipTest("Case is not valid before 3.11")
+                    self.assertEqual(get_args(alias[expected_args]), (expected_args,))
+                    self.assertEqual(alias[expected_args].__parameters__, expected_parameters)
+
     def test_cannot_set_attributes(self):
         Simple = TypeAliasType("Simple", int)
         with self.assertRaisesRegex(AttributeError, "readonly attribute"):
@@ -7233,12 +7316,13 @@ def test_or(self):
             Alias | "Ref"
 
     def test_getitem(self):
+        T = TypeVar('T')
         ListOrSetT = TypeAliasType("ListOrSetT", Union[List[T], Set[T]], type_params=(T,))
         subscripted = ListOrSetT[int]
         self.assertEqual(get_args(subscripted), (int,))
         self.assertIs(get_origin(subscripted), ListOrSetT)
-        with self.assertRaises(TypeError):
-            subscripted[str]
+        with self.assertRaises(TypeError, msg="not a generic class"):
+            subscripted[int]
 
         still_generic = ListOrSetT[Iterable[T]]
         self.assertEqual(get_args(still_generic), (Iterable[T],))
@@ -7247,6 +7331,159 @@ def test_getitem(self):
         self.assertEqual(get_args(fully_subscripted), (Iterable[float],))
         self.assertIs(get_origin(fully_subscripted), ListOrSetT)
 
+        ValueWithoutTypeVar = TypeAliasType("ValueWithoutTypeParam", int, type_params=(T,))
+        still_subscripted = ValueWithoutTypeVar[str]
+        self.assertEqual(get_args(still_subscripted), (str,))
+
+    def test_callable_without_concatenate(self):
+        P = ParamSpec('P')
+        CallableP = TypeAliasType("CallableP", Callable[P, Any], type_params=(P,))
+        get_args_test_cases = [
+            # List of (alias, expected_args)
+            # () -> Any
+            (CallableP[()], ()),
+            (CallableP[[]], ([],)),
+            # (int) -> Any
+            (CallableP[int], (int,)),
+            (CallableP[[int]], ([int],)),
+            # (int, int) -> Any
+            (CallableP[int, int],  (int, int)),
+            (CallableP[[int, int]], ([int, int],)),
+            # (...) -> Any
+            (CallableP[...], (...,)),
+            # (int, ...) -> Any
+            (CallableP[[int, ...]], ([int, ...],)),
+        ]
+
+        for index, (expression, expected_args) in enumerate(get_args_test_cases):
+            with self.subTest(index=index, expression=expression):
+                self.assertEqual(get_args(expression), expected_args)
+
+        self.assertEqual(CallableP[...], CallableP[(...,)])
+        # (T) -> Any
+        CallableT = CallableP[T]
+        self.assertEqual(get_args(CallableT), (T,))
+        self.assertEqual(CallableT.__parameters__, (T,))
+
+    def test_callable_with_concatenate(self):
+        P = ParamSpec('P')
+        CallableP = TypeAliasType("CallableP", Callable[P, Any], type_params=(P,))
+
+        callable_concat = CallableP[Concatenate[int, P]]
+        self.assertEqual(callable_concat.__parameters__, (P,))
+        concat_usage = callable_concat[str]
+        with self.subTest("get_args of Concatenate in TypeAliasType"):
+            if sys.version_info < (3, 10, 2):
+                self.skipTest("GenericAlias keeps Concatenate in __args__ prior to 3.10.2")
+            self.assertEqual(get_args(concat_usage), ((int, str),))
+        with self.subTest("Equality of parameter_expression without []"):
+            if not TYPING_3_10_0:
+                self.skipTest("Nested list is invalid type form")
+            self.assertEqual(concat_usage, callable_concat[[str]])
+
+    def test_substitution(self):
+        # To pass these tests alias.__args__ in TypeAliasType.__getitem__ needs adjustment
+        # Unpack and Concatenate are unpacked in versions before
+        T = TypeVar('T')
+        Ts = TypeVarTuple("Ts")
+
+        CallableTs = TypeAliasType("CallableTs", Callable[[Unpack[Ts]], Any], type_params=(Ts, ))
+        unpack_callable = CallableTs[Unpack[Tuple[int, T]]]
+        self.assertEqual(get_args(unpack_callable), (Unpack[Tuple[int, T]],))
+
+        P = ParamSpec('P')
+        CallableP = TypeAliasType("CallableP", Callable[P, T], type_params=(P, T))
+        callable_concat = CallableP[Concatenate[int, P], Any]
+        self.assertEqual(get_args(callable_concat), (Concatenate[int, P], Any))
+
+    @skipUnless(TYPING_3_12_0, "__args__ behaves differently")
+    def test_substitution_312_plus(self):
+        # To pass these tests alias.__args__ in TypeAliasType.__getitem__ needs adjustment
+        # Would raise: TypeError: Substitution of bare TypeVarTuple is not supported
+        T = TypeVar('T')
+        Ts = TypeVarTuple("Ts")
+        Variadic = TypeAliasType("Variadic", Tuple[int, Unpack[Ts]], type_params=(Ts,))
+
+        subcriped_callable_tvt = Variadic[Callable[[Unpack[Ts]], T]]
+        variadic_tvt_callableA = subcriped_callable_tvt[str, object]
+        variadic_tvt_callableA2 = subcriped_callable_tvt[Unpack[Tuple[str]], object]
+        self.assertEqual(variadic_tvt_callableA, variadic_tvt_callableA2)
+
+        variadic_tvt_callableB = subcriped_callable_tvt[[str, int], object]
+        variadic_tvt_callableB2 = subcriped_callable_tvt[Unpack[Tuple[str, int]], object]
+        variadic_tvt_callableB3 = subcriped_callable_tvt[str, int, object]
+        self.assertNotEqual(variadic_tvt_callableB, variadic_tvt_callableB2)
+        self.assertEqual(variadic_tvt_callableB2, variadic_tvt_callableB3)
+
+    def test_wrong_amount_of_parameters(self):
+        T = TypeVar('T')
+        T2 = TypeVar("T2")
+        P = ParamSpec('P')
+        ListOrSetT = TypeAliasType("ListOrSetT", Union[List[T], Set[T]], type_params=(T,))
+        TwoT = TypeAliasType("TwoT", Union[List[T], Set[T2]], type_params=(T, T2))
+        CallablePT = TypeAliasType("CallablePT", Callable[P, T], type_params=(P, T))
+
+        # Not enough parameters
+        test_cases = [
+            # not_enough
+            (TwoT[int],                              [(int,), ()]),
+            (TwoT[T],                                [(T,), (T,)]),
+            # callable and not enough
+            (CallablePT[int],                        [(int,), ()]),
+            # too many
+            (ListOrSetT[int, bool],                  [(int, bool), ()]),
+            # callable and too many
+            (CallablePT[str, float, int],            [(str, float, int), ()]),
+            # Check if TypeVar is still present even if over substituted
+            (ListOrSetT[int, T],                     [(int, T), (T,)]),
+            # With and without list for ParamSpec
+            (CallablePT[str, float, T],              [(str, float, T), (T,)]),
+            (CallablePT[[str], float, int, T2],      [([str], float, int, T2), (T2,)]),
+        ]
+
+        for index, (alias, [expected_args, expected_params]) in enumerate(test_cases):
+            with self.subTest(index=index, alias=alias):
+                self.assertEqual(get_args(alias), expected_args)
+                self.assertEqual(alias.__parameters__, expected_params)
+
+    def test_list_argument(self):
+        # NOTE: These cases could be seen as valid but result in a parameterless
+        # variable. If these tests fail the specificiation might have changed
+
+        # Callable
+        P = ParamSpec('P')
+        CallableP = TypeAliasType("CallableP", Callable[P, Any], type_params=(P,))
+        CallableT_list = CallableP[[T]]
+        self.assertEqual(get_args(CallableT_list), ([T],))
+        self.assertEqual(CallableT_list.__parameters__, ())
+        with self.assertRaises(TypeError, msg="is not a generic class"):
+            CallableT_list[str]
+
+        ImplicitConcatP = CallableP[[int, P]]
+        self.assertEqual(get_args(ImplicitConcatP), ([int, P],))
+        self.assertEqual(ImplicitConcatP.__parameters__, ())
+        with self.assertRaises(TypeError, msg="is not a generic class"):
+            ImplicitConcatP[str]
+
+        # TypeVarTuple
+        Ts = TypeVarTuple("Ts")
+        Variadic = TypeAliasType("Variadic", Tuple[int, Unpack[Ts]], type_params=(Ts,))
+        invalid_tupleT = Variadic[[int, T]]
+        self.assertEqual(get_args(invalid_tupleT), ([int, T],))
+        self.assertEqual(invalid_tupleT.__parameters__, ())
+        with self.assertRaises(TypeError, msg="is not a generic class"):
+            invalid_tupleT[str]
+
+    # The condition should align with the version of GeneriAlias usage in __getitem__
+    @skipIf(TYPING_3_10_0, "Most cases are allowed in 3.11+ or with GenericAlias")
+    def test_invalid_cases_before_3_11(self):
+        T = TypeVar('T')
+        ListOrSetT = TypeAliasType("ListOrSetT", Union[List[T], Set[T]], type_params=(T,))
+        with self.assertRaises(TypeError):
+            ListOrSetT[Generic[T]]
+        with self.assertRaises(TypeError):
+            ListOrSetT[(Generic[T], )]
+
     def test_alias_attributes(self):
         T = TypeVar('T')
         T2 = TypeVar('T2')

src/typing_extensions.py

@@ -3518,6 +3518,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)
@@ -3555,6 +3557,34 @@ def _raise_attribute_error(self, name: str) -> Never:
         def __repr__(self) -> str:
             return self.__name__
 
+        if sys.version_info < (3, 11):
+            def _check_single_param(self, param, recursion=0):
+                # Allow [], [int], [int, str], [int, ...], [int, T]
+                if param is ...:
+                    yield ...
+                # Note in < 3.9 _ConcatenateGenericAlias inherits from list
+                elif isinstance(param, list) and recursion == 0:
+                    yield [checked
+                           for arg in param
+                           for checked in self._check_single_param(arg, recursion+1)]
+                else:
+                    yield typing._type_check(
+                        param, f'Subscripting {self.__name__} requires a type.'
+                    )
+
+        def _check_parameters(self, parameters):
+            if sys.version_info < (3, 11):
+                return tuple(
+                    checked
+                    for item in parameters
+                    for checked in self._check_single_param(item)
+                )
+            return tuple(typing._type_check(
+                        item, f'Subscripting {self.__name__} requires a type.'
+                    )
+                    for item in parameters
+            )
+
         def __getitem__(self, parameters):
             if not self.__type_params__:
                 raise TypeError("Only generic type aliases are subscriptable")
@@ -3563,13 +3593,13 @@ def __getitem__(self, parameters):
             # Using 3.9 here will create problems with Concatenate
             if sys.version_info >= (3, 10):
                 return _types.GenericAlias(self, parameters)
-            parameters = tuple(
-                typing._type_check(
-                    item, f'Subscripting {self.__name__} requires a type.'
-                )
-                for item in parameters
-            )
-            return _TypeAliasGenericAlias(self, parameters)
+            type_vars = _collect_type_vars(parameters)
+            parameters = self._check_parameters(parameters)
+            alias = _TypeAliasGenericAlias(self, parameters)
+            # If Concatenate is present its parameters were not collected
+            if len(alias.__parameters__) < len(type_vars):
+                alias.__parameters__ = tuple(type_vars)
+            return alias
 
         def __reduce__(self):
             return self.__name__