[syntax-error] Default type parameter followed by non-default type parameter (#21657)

## Summary

This PR implements syntax error where a default type parameter is
followed by a non-default type parameter.
#17412 (comment)


## Test Plan

I have written inline tests as directed in #17412

---------

Signed-off-by: 11happy <[email protected]>
Signed-off-by: 11happy <[email protected]>

Author: 11happy

crates/ruff_linter/src/checkers/ast/mod.rs

@@ -747,6 +747,7 @@ impl SemanticSyntaxContext for Checker<'_> {
             | SemanticSyntaxErrorKind::LoadBeforeNonlocalDeclaration { .. }
             | SemanticSyntaxErrorKind::NonlocalAndGlobal(_)
             | SemanticSyntaxErrorKind::AnnotatedGlobal(_)
+            | SemanticSyntaxErrorKind::TypeParameterDefaultOrder(_)
             | SemanticSyntaxErrorKind::AnnotatedNonlocal(_) => {
                 self.semantic_errors.borrow_mut().push(error);
             }

crates/ruff_python_parser/resources/inline/err/type_parameter_default_order.py

@@ -0,0 +1,3 @@
+class C[T = int, U]: ...
+class C[T1, T2 = int, T3, T4]: ...
+type Alias[T = int, U] = ...

crates/ruff_python_parser/src/semantic_errors.rs

@@ -144,11 +144,16 @@ impl SemanticSyntaxChecker {
                     }
                 }
             }
-            Stmt::ClassDef(ast::StmtClassDef { type_params, .. })
-            | Stmt::TypeAlias(ast::StmtTypeAlias { type_params, .. }) => {
-                if let Some(type_params) = type_params {
-                    Self::duplicate_type_parameter_name(type_params, ctx);
-                }
+            Stmt::ClassDef(ast::StmtClassDef {
+                type_params: Some(type_params),
+                ..
+            })
+            | Stmt::TypeAlias(ast::StmtTypeAlias {
+                type_params: Some(type_params),
+                ..
+            }) => {
+                Self::duplicate_type_parameter_name(type_params, ctx);
+                Self::type_parameter_default_order(type_params, ctx);
             }
             Stmt::Assign(ast::StmtAssign { targets, value, .. }) => {
                 if let [Expr::Starred(ast::ExprStarred { range, .. })] = targets.as_slice() {
@@ -611,6 +616,39 @@ impl SemanticSyntaxChecker {
         }
     }
 
+    fn type_parameter_default_order<Ctx: SemanticSyntaxContext>(
+        type_params: &ast::TypeParams,
+        ctx: &Ctx,
+    ) {
+        let mut seen_default = false;
+        for type_param in type_params.iter() {
+            let has_default = match type_param {
+                ast::TypeParam::TypeVar(ast::TypeParamTypeVar { default, .. })
+                | ast::TypeParam::TypeVarTuple(ast::TypeParamTypeVarTuple { default, .. })
+                | ast::TypeParam::ParamSpec(ast::TypeParamParamSpec { default, .. }) => {
+                    default.is_some()
+                }
+            };
+
+            if seen_default && !has_default {
+                // test_err type_parameter_default_order
+                // class C[T = int, U]: ...
+                // class C[T1, T2 = int, T3, T4]: ...
+                // type Alias[T = int, U] = ...
+                Self::add_error(
+                    ctx,
+                    SemanticSyntaxErrorKind::TypeParameterDefaultOrder(
+                        type_param.name().id.to_string(),
+                    ),
+                    type_param.range(),
+                );
+            }
+            if has_default {
+                seen_default = true;
+            }
+        }
+    }
+
     fn duplicate_parameter_name<Ctx: SemanticSyntaxContext>(
         parameters: &ast::Parameters,
         ctx: &Ctx,
@@ -1066,6 +1104,12 @@ impl Display for SemanticSyntaxError {
             SemanticSyntaxErrorKind::DuplicateTypeParameter => {
                 f.write_str("duplicate type parameter")
             }
+            SemanticSyntaxErrorKind::TypeParameterDefaultOrder(name) => {
+                write!(
+                    f,
+                    "non default type parameter `{name}` follows default type parameter"
+                )
+            }
             SemanticSyntaxErrorKind::MultipleCaseAssignment(name) => {
                 write!(f, "multiple assignments to name `{name}` in pattern")
             }
@@ -1572,6 +1616,9 @@ pub enum SemanticSyntaxErrorKind {
 
     /// Represents a nonlocal statement for a name that has no binding in an enclosing scope.
     NonlocalWithoutBinding(String),
+
+    /// Represents a default type parameter followed by a non-default type parameter.
+    TypeParameterDefaultOrder(String),
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, get_size2::GetSize)]

crates/ruff_python_parser/tests/snapshots/invalid_syntax@type_param_param_spec_invalid_default_expr.py.snap

@@ -375,3 +375,12 @@ Module(
 4 | type X[**P = x := int] = int
 5 | type X[**P = *int] = int
   |
+
+
+  |
+2 | type X[**P = yield x] = int
+3 | type X[**P = yield from x] = int
+4 | type X[**P = x := int] = int
+  |                   ^^^ Syntax Error: non default type parameter `int` follows default type parameter
+5 | type X[**P = *int] = int
+  |

crates/ruff_python_parser/tests/snapshots/invalid_syntax@type_param_type_var_invalid_default_expr.py.snap

@@ -459,3 +459,12 @@ Module(
 5 | type X[T = x := int] = int
 6 | type X[T: int = *int] = int
   |
+
+
+  |
+3 | type X[T = (yield x)] = int
+4 | type X[T = yield from x] = int
+5 | type X[T = x := int] = int
+  |                 ^^^ Syntax Error: non default type parameter `int` follows default type parameter
+6 | type X[T: int = *int] = int
+  |

crates/ruff_python_parser/tests/snapshots/invalid_syntax@type_param_type_var_tuple_invalid_default_expr.py.snap

@@ -384,3 +384,11 @@ Module(
   |              ^^^^^^^^^^^^ Syntax Error: yield expression cannot be used within a TypeVarTuple default
 5 | type X[*Ts = x := int] = int
   |
+
+
+  |
+3 | type X[*Ts = yield x] = int
+4 | type X[*Ts = yield from x] = int
+5 | type X[*Ts = x := int] = int
+  |                   ^^^ Syntax Error: non default type parameter `int` follows default type parameter
+  |