feat(semantic): align class scope with typescript (#4195)

```ts
class Klass <T>   extends Root       <R>                   {}
//    ^^^^^ ^^^           ^^^^       ^^^                   ^^
//    id type_paramter super_class super_type_parameters  body
```
I reorder fields according to the order above

The class scope is not defined in the spec. But we need to create a scope for `class` to store `TypeParamters`

Author: Dunqing

crates/oxc_ast/src/ast/js.rs

@@ -1592,12 +1592,12 @@ pub struct Class<'a> {
     pub decorators: Vec<'a, Decorator<'a>>,
     #[scope(enter_before)]
     pub id: Option<BindingIdentifier<'a>>,
+    pub type_parameters: Option<Box<'a, TSTypeParameterDeclaration<'a>>>,
     #[visit_as(ClassHeritage)]
     pub super_class: Option<Expression<'a>>,
-    pub body: Box<'a, ClassBody<'a>>,
-    pub type_parameters: Option<Box<'a, TSTypeParameterDeclaration<'a>>>,
     pub super_type_parameters: Option<Box<'a, TSTypeParameterInstantiation<'a>>>,
     pub implements: Option<Vec<'a, TSClassImplements<'a>>>,
+    pub body: Box<'a, ClassBody<'a>>,
     pub r#abstract: bool,
     pub declare: bool,
     pub scope_id: Cell<Option<ScopeId>>,

crates/oxc_ast/src/generated/ast_builder.rs

@@ -485,29 +485,29 @@ impl<'a> AstBuilder<'a> {
         span: Span,
         decorators: Vec<'a, Decorator<'a>>,
         id: Option<BindingIdentifier<'a>>,
+        type_parameters: T1,
         super_class: Option<Expression<'a>>,
-        body: T1,
-        type_parameters: T2,
-        super_type_parameters: T3,
+        super_type_parameters: T2,
         implements: Option<Vec<'a, TSClassImplements<'a>>>,
+        body: T3,
         r#abstract: bool,
         declare: bool,
     ) -> Expression<'a>
     where
-        T1: IntoIn<'a, Box<'a, ClassBody<'a>>>,
-        T2: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
-        T3: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,
+        T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T2: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,
+        T3: IntoIn<'a, Box<'a, ClassBody<'a>>>,
     {
         Expression::ClassExpression(self.alloc(self.class(
             r#type,
             span,
             decorators,
             id,
-            super_class,
-            body,
             type_parameters,
+            super_class,
             super_type_parameters,
             implements,
+            body,
             r#abstract,
             declare,
         )))
@@ -2728,29 +2728,29 @@ impl<'a> AstBuilder<'a> {
         span: Span,
         decorators: Vec<'a, Decorator<'a>>,
         id: Option<BindingIdentifier<'a>>,
+        type_parameters: T1,
         super_class: Option<Expression<'a>>,
-        body: T1,
-        type_parameters: T2,
-        super_type_parameters: T3,
+        super_type_parameters: T2,
         implements: Option<Vec<'a, TSClassImplements<'a>>>,
+        body: T3,
         r#abstract: bool,
         declare: bool,
     ) -> Declaration<'a>
     where
-        T1: IntoIn<'a, Box<'a, ClassBody<'a>>>,
-        T2: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
-        T3: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,
+        T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T2: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,
+        T3: IntoIn<'a, Box<'a, ClassBody<'a>>>,
     {
         Declaration::ClassDeclaration(self.alloc(self.class(
             r#type,
             span,
             decorators,
             id,
-            super_class,
-            body,
             type_parameters,
+            super_class,
             super_type_parameters,
             implements,
+            body,
             r#abstract,
             declare,
         )))
@@ -3942,29 +3942,29 @@ impl<'a> AstBuilder<'a> {
         span: Span,
         decorators: Vec<'a, Decorator<'a>>,
         id: Option<BindingIdentifier<'a>>,
+        type_parameters: T1,
         super_class: Option<Expression<'a>>,
-        body: T1,
-        type_parameters: T2,
-        super_type_parameters: T3,
+        super_type_parameters: T2,
         implements: Option<Vec<'a, TSClassImplements<'a>>>,
+        body: T3,
         r#abstract: bool,
         declare: bool,
     ) -> Class<'a>
     where
-        T1: IntoIn<'a, Box<'a, ClassBody<'a>>>,
-        T2: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
-        T3: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,
+        T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T2: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,
+        T3: IntoIn<'a, Box<'a, ClassBody<'a>>>,
     {
         Class {
             r#type,
             span,
             decorators,
             id,
-            super_class,
-            body: body.into_in(self.allocator),
             type_parameters: type_parameters.into_in(self.allocator),
+            super_class,
             super_type_parameters: super_type_parameters.into_in(self.allocator),
             implements,
+            body: body.into_in(self.allocator),
             r#abstract,
             declare,
             scope_id: Default::default(),
@@ -3978,29 +3978,29 @@ impl<'a> AstBuilder<'a> {
         span: Span,
         decorators: Vec<'a, Decorator<'a>>,
         id: Option<BindingIdentifier<'a>>,
+        type_parameters: T1,
         super_class: Option<Expression<'a>>,
-        body: T1,
-        type_parameters: T2,
-        super_type_parameters: T3,
+        super_type_parameters: T2,
         implements: Option<Vec<'a, TSClassImplements<'a>>>,
+        body: T3,
         r#abstract: bool,
         declare: bool,
     ) -> Box<'a, Class<'a>>
     where
-        T1: IntoIn<'a, Box<'a, ClassBody<'a>>>,
-        T2: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
-        T3: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,
+        T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T2: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,
+        T3: IntoIn<'a, Box<'a, ClassBody<'a>>>,
     {
         self.class(
             r#type,
             span,
             decorators,
             id,
-            super_class,
-            body,
             type_parameters,
+            super_class,
             super_type_parameters,
             implements,
+            body,
             r#abstract,
             declare,
         )
@@ -4943,29 +4943,29 @@ impl<'a> AstBuilder<'a> {
         span: Span,
         decorators: Vec<'a, Decorator<'a>>,
         id: Option<BindingIdentifier<'a>>,
+        type_parameters: T1,
         super_class: Option<Expression<'a>>,
-        body: T1,
-        type_parameters: T2,
-        super_type_parameters: T3,
+        super_type_parameters: T2,
         implements: Option<Vec<'a, TSClassImplements<'a>>>,
+        body: T3,
         r#abstract: bool,
         declare: bool,
     ) -> ExportDefaultDeclarationKind<'a>
     where
-        T1: IntoIn<'a, Box<'a, ClassBody<'a>>>,
-        T2: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
-        T3: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,
+        T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,
+        T2: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,
+        T3: IntoIn<'a, Box<'a, ClassBody<'a>>>,
     {
         ExportDefaultDeclarationKind::ClassDeclaration(self.alloc(self.class(
             r#type,
             span,
             decorators,
             id,
-            super_class,
-            body,
             type_parameters,
+            super_class,
             super_type_parameters,
             implements,
+            body,
             r#abstract,
             declare,
         )))

crates/oxc_ast/src/generated/visit.rs

@@ -803,6 +803,16 @@ pub trait Visit<'a>: Sized {
         walk_class_heritage(self, it);
     }
 
+    #[inline]
+    fn visit_ts_class_implementses(&mut self, it: &Vec<'a, TSClassImplements<'a>>) {
+        walk_ts_class_implementses(self, it);
+    }
+
+    #[inline]
+    fn visit_ts_class_implements(&mut self, it: &TSClassImplements<'a>) {
+        walk_ts_class_implements(self, it);
+    }
+
     #[inline]
     fn visit_class_body(&mut self, it: &ClassBody<'a>) {
         walk_class_body(self, it);
@@ -843,16 +853,6 @@ pub trait Visit<'a>: Sized {
         walk_accessor_property(self, it);
     }
 
-    #[inline]
-    fn visit_ts_class_implementses(&mut self, it: &Vec<'a, TSClassImplements<'a>>) {
-        walk_ts_class_implementses(self, it);
-    }
-
-    #[inline]
-    fn visit_ts_class_implements(&mut self, it: &TSClassImplements<'a>) {
-        walk_ts_class_implements(self, it);
-    }
-
     #[inline]
     fn visit_conditional_expression(&mut self, it: &ConditionalExpression<'a>) {
         walk_conditional_expression(self, it);
@@ -2929,19 +2929,19 @@ pub mod walk {
         if let Some(id) = &it.id {
             visitor.visit_binding_identifier(id);
         }
-        if let Some(super_class) = &it.super_class {
-            visitor.visit_class_heritage(super_class);
-        }
-        visitor.visit_class_body(&it.body);
         if let Some(type_parameters) = &it.type_parameters {
             visitor.visit_ts_type_parameter_declaration(type_parameters);
         }
+        if let Some(super_class) = &it.super_class {
+            visitor.visit_class_heritage(super_class);
+        }
         if let Some(super_type_parameters) = &it.super_type_parameters {
             visitor.visit_ts_type_parameter_instantiation(super_type_parameters);
         }
         if let Some(implements) = &it.implements {
             visitor.visit_ts_class_implementses(implements);
         }
+        visitor.visit_class_body(&it.body);
         visitor.leave_scope();
         visitor.leave_node(kind);
     }
@@ -2953,6 +2953,27 @@ pub mod walk {
         visitor.leave_node(kind);
     }
 
+    #[inline]
+    pub fn walk_ts_class_implementses<'a, V: Visit<'a>>(
+        visitor: &mut V,
+        it: &Vec<'a, TSClassImplements<'a>>,
+    ) {
+        for el in it.iter() {
+            visitor.visit_ts_class_implements(el);
+        }
+    }
+
+    #[inline]
+    pub fn walk_ts_class_implements<'a, V: Visit<'a>>(visitor: &mut V, it: &TSClassImplements<'a>) {
+        let kind = AstKind::TSClassImplements(visitor.alloc(it));
+        visitor.enter_node(kind);
+        visitor.visit_ts_type_name(&it.expression);
+        if let Some(type_parameters) = &it.type_parameters {
+            visitor.visit_ts_type_parameter_instantiation(type_parameters);
+        }
+        visitor.leave_node(kind);
+    }
+
     #[inline]
     pub fn walk_class_body<'a, V: Visit<'a>>(visitor: &mut V, it: &ClassBody<'a>) {
         let kind = AstKind::ClassBody(visitor.alloc(it));
@@ -3072,27 +3093,6 @@ pub mod walk {
         }
     }
 
-    #[inline]
-    pub fn walk_ts_class_implementses<'a, V: Visit<'a>>(
-        visitor: &mut V,
-        it: &Vec<'a, TSClassImplements<'a>>,
-    ) {
-        for el in it.iter() {
-            visitor.visit_ts_class_implements(el);
-        }
-    }
-
-    #[inline]
-    pub fn walk_ts_class_implements<'a, V: Visit<'a>>(visitor: &mut V, it: &TSClassImplements<'a>) {
-        let kind = AstKind::TSClassImplements(visitor.alloc(it));
-        visitor.enter_node(kind);
-        visitor.visit_ts_type_name(&it.expression);
-        if let Some(type_parameters) = &it.type_parameters {
-            visitor.visit_ts_type_parameter_instantiation(type_parameters);
-        }
-        visitor.leave_node(kind);
-    }
-
     #[inline]
     pub fn walk_conditional_expression<'a, V: Visit<'a>>(
         visitor: &mut V,