Assure that args and parameter tests pass

Author: Daraan

src/test_typing_extensions.py

@@ -7236,14 +7236,14 @@ def test_alias_types_and_substitutions(self):
             TypeAliasType("NestedAlias", List[T], type_params=(T,))[T2] : (T2,),
         }
         # currently a limitation, these args are no longer unpacked in 3.11
-        # also valid on 310 if GenericAlias is used
+        # OK if GenericAlias in __getitem__ is used
         test_argument_cases_310_plus = {
+            Unpack[Ts] : (Ts,),
             Unpack[Tuple[int, T2]] : (T2,),
             Concatenate[int,  P] : (P,),
-            Unpack[Ts] : (Ts,),
         }
         test_argument_cases_311_plus = {
-            Ts : (Ts,),
+            Ts : (Ts,),  # invalid case
         }
         test_argument_cases.update(test_argument_cases_310_plus)
         test_argument_cases.update(test_argument_cases_311_plus)
@@ -7413,8 +7413,7 @@ def test_callable_with_concatenate(self):
                 self.skipTest("Nested list is invalid type form")
             self.assertEqual(concat_usage, callable_concat[[str]])
 
-    @skipUnless(TYPING_3_11_0, "__args__ behaves differently")
-    def test_substitution_311_plus(self):
+    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')
@@ -7428,6 +7427,7 @@ def test_substitution_311_plus(self):
         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))
+        self.assertEqual(callable_concat.__parameters__, (P,))
 
     @skipUnless(TYPING_3_12_0, "__args__ behaves differently")
     def test_substitution_312_plus(self):
@@ -7508,7 +7508,7 @@ def test_list_argument(self):
             invalid_tupleT[str]
 
     # The condition should align with the version of GeneriAlias usage in __getitem__
-    @skipIf(TYPING_3_9_0, "Most cases are allowed in 3.11+ or with GenericAlias")
+    @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,))

src/typing_extensions.py

@@ -3529,13 +3529,9 @@ def __repr__(self) -> str:
         if sys.version_info < (3, 11):
             def _check_single_param(self, param, recursion=0):
                 # Allow [], [int], [int, str], [int, ...], [int, T]
-                if isinstance(param, (_UnpackAlias, _ConcatenateGenericAlias)):
-                    # Unpack
-                    yield from [checked
-                                for arg in param.__args__
-                                for checked in self._check_single_param(arg, recursion+1)]
-                elif param is ...:
+                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
@@ -3563,8 +3559,11 @@ def __getitem__(self, parameters):
                 parameters = (parameters,)
             if sys.version_info >= (3, 10):
                 return _types.GenericAlias(self, tuple(parameters))
+            type_vars = _collect_type_vars(parameters)
             parameters = self._check_parameters(parameters)
             alias = typing._GenericAlias(self, tuple(parameters))
+            if len(alias.__parameters__) < len(type_vars):
+                alias.__parameters__ = tuple(type_vars)
             alias.__value__ = self.__value__
             alias.__type_params__ = self.__type_params__
             alias.__name__ = self.__name__