no non default value after default value

Also draft for others

Author: Daraan

src/test_typing_extensions.py

@@ -7318,6 +7318,65 @@ 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
+        typing_T = typing.TypeVar('T')
+        with self.subTest(type_params="typing.TypeVar"):
+            TypeAliasType("TypingTypeParams", List[typing_T], type_params=(typing_T,))
+
+        # Test default order
+        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=...)
+
+        ok_cases = [
+            (T, T_default),
+            (T, Ts_default),
+            (T, T_default, Ts_default),
+            (T, P, Ts),
+            (T, 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
+            # "TypeVars with defaults cannot immediately follow TypeVarTuples"
+            # (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
+            # (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:
+            with self.subTest(type_params=case):
+                with self.assertRaises(TypeError):
+                    TypeAliasType("InvalidCase", List[T], type_params=case)
+
 class DocTests(BaseTestCase):
     def test_annotation(self):
 

src/typing_extensions.py

@@ -3536,8 +3536,15 @@ def __init__(self, name: str, value, *, type_params=()):
             self.__value__ = value
             self.__type_params__ = type_params
 
+            default_value_encountered = False
             parameters = []
             for type_param in type_params:
+                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')
+                if has_default:
+                    default_value_encountered = True
                 if isinstance(type_param, TypeVarTuple):
                     parameters.extend(type_param)
                 else: