Adjusted error messages to match cpython

Author: Daraan

src/test_typing_extensions.py

@@ -7318,63 +7318,58 @@ def test_type_params_possibilities(self):
         with self.assertRaisesRegex(TypeError, "type_params must be a tuple"):
             TypeAliasType("InvalidTypeParams", List[T], type_params=[T])
 
-        # Regression test assure compatibility with typing.TypeVar
+        # Regression test to assure compatibility with typing.TypeVar
         typing_T = typing.TypeVar('T')
         with self.subTest(type_params="typing.TypeVar"):
             TypeAliasType("TypingTypeParams", List[typing_T], type_params=(typing_T,))
 
-        # Test default order
+        # Test default order and other invalid inputs
         T_default = TypeVar('T_default', default=int)
         Ts = TypeVarTuple('Ts')
         Ts_default = TypeVarTuple('Ts_default', default=Unpack[Tuple[str, int]])
         P = ParamSpec('P')
         P_default = ParamSpec('P_default', default=[str, int])
-        P_default2 = ParamSpec('P_default2', default=...)
+        P_default2 = ParamSpec('P_default2', default=P_default)
 
         ok_cases = [
             (T, T_default),
             (T, Ts_default),
-            (T, T_default, Ts_default),
             (T, P, Ts),
-            (T, P, Ts_default),
+            (P, T_default, Ts_default),
+            (Ts, P, Ts_default),
             (T, P_default),
             (T, P_default, T_default),
             (T, P_default, Ts_default),
             (T, Ts_default, P_default),
             (T, P_default, P_default2),
         ]
         invalid_cases = [
-            (T_default, T),
-            (Ts_default, T),
-           
-            # TypeVar after TypeVarTuple
+            ((T_default, T),    f"non-default type parameter {T!r} follows default"),
+            ((P_default, P),   f"non-default type parameter {P!r} follows default"),
+            ((Ts_default, Ts),   f"non-default type parameter {Ts!r} follows default"),
+
+            # Potentially add invalid inputs, e.g. literals or classes
+            # depends on upstream
+            ((1,),  "Expected a type param, got 1"),
+            ((str,), f"Expected a type param, got {str!r}"),
+
             # "TypeVars with defaults cannot immediately follow TypeVarTuples"
+            # is currently not enfored for the type statement, only for Generics
             # (T, Ts, T_default),
             # (T, Ts_default, T_default),
-            
-            # Two TypeVarTuples in a row, should the reverse be also invalid?
-            (T, Ts_default, Ts),
-
-            (P_default, T),
-            (P_default, Ts),
-            
-            # Double defintion
+
+            # Double use; however T2 = T; (T, T2) would likely be fine for a type checker
             # (T, T)
             # (Ts, *Ts)
             # (P, **P)
-            
-            # Potentially add invalid inputs, e.g. literals or classes
-            # depends on upstream
-            # (1,)
-            # (str,)
         ]
 
         for case in ok_cases:
             with self.subTest(type_params=case):
                 TypeAliasType("OkCase", List[T], type_params=case)
-        for case in invalid_cases:
+        for case, msg in invalid_cases:
             with self.subTest(type_params=case):
-                with self.assertRaises(TypeError):
+                with self.assertRaisesRegex(TypeError, msg):
                     TypeAliasType("InvalidCase", List[T], type_params=case)
 
 class DocTests(BaseTestCase):

src/typing_extensions.py

@@ -3541,10 +3541,12 @@ def __init__(self, name: str, value, *, type_params=()):
             for type_param in type_params:
                 if not isinstance(type_param, (TypeVar, TypeVarTuple, ParamSpec)):
                     raise TypeError(f"Expected a type param, got {type_param!r}")
-                has_default = getattr(type_param, '__default__', NoDefault) is not NoDefault
+                has_default = (
+                    getattr(type_param, '__default__', NoDefault) is not NoDefault
+                )
                 if default_value_encountered and not has_default:
-                    raise TypeError(f'Type parameter {type_param!r} without a default'
-                                    ' follows type parameter with a default')
+                    raise TypeError(f'non-default type parameter {type_param!r}'
+                                    ' follows default type parameter')
                 if has_default:
                     default_value_encountered = True
                 if isinstance(type_param, TypeVarTuple):