refactor(ast/estree): do not put TS struct fields last

crates/oxc_ast/src/generated/derive_estree.rs

@@ -322,8 +322,8 @@ impl ESTree for TaggedTemplateExpression<'_> {
         state.serialize_field("start", &self.span.start);
         state.serialize_field("end", &self.span.end);
         state.serialize_field("tag", &self.tag);
-        state.serialize_field("quasi", &self.quasi);
         state.serialize_ts_field("typeArguments", &self.type_arguments);
+        state.serialize_field("quasi", &self.quasi);
         state.end();
     }
 }
@@ -402,9 +402,9 @@ impl ESTree for CallExpression<'_> {
         state.serialize_field("start", &self.span.start);
         state.serialize_field("end", &self.span.end);
         state.serialize_field("callee", &self.callee);
+        state.serialize_ts_field("typeArguments", &self.type_arguments);
         state.serialize_field("arguments", &self.arguments);
         state.serialize_field("optional", &self.optional);
-        state.serialize_ts_field("typeArguments", &self.type_arguments);
         state.end();
     }
 }
@@ -416,8 +416,8 @@ impl ESTree for NewExpression<'_> {
         state.serialize_field("start", &self.span.start);
         state.serialize_field("end", &self.span.end);
         state.serialize_field("callee", &self.callee);
-        state.serialize_field("arguments", &self.arguments);
         state.serialize_ts_field("typeArguments", &self.type_arguments);
+        state.serialize_field("arguments", &self.arguments);
         state.end();
     }
 }
@@ -1768,11 +1768,11 @@ impl ESTree for ExportNamedDeclaration<'_> {
         state.serialize_field("declaration", &self.declaration);
         state.serialize_field("specifiers", &self.specifiers);
         state.serialize_field("source", &self.source);
+        state.serialize_ts_field("exportKind", &self.export_kind);
         state.serialize_field(
             "attributes",
             &crate::serialize::js::ExportNamedDeclarationWithClause(self),
         );
-        state.serialize_ts_field("exportKind", &self.export_kind);
         state.end();
     }
 }

napi/parser/generated/deserialize/ts.js

@@ -177,8 +177,8 @@ function deserializeTaggedTemplateExpression(pos) {
     start: deserializeU32(pos),
     end: deserializeU32(pos + 4),
     tag: deserializeExpression(pos + 8),
-    quasi: deserializeTemplateLiteral(pos + 32),
     typeArguments: deserializeOptionBoxTSTypeParameterInstantiation(pos + 24),
+    quasi: deserializeTemplateLiteral(pos + 32),
   };
 }
 
@@ -243,9 +243,9 @@ function deserializeCallExpression(pos) {
     start: deserializeU32(pos),
     end: deserializeU32(pos + 4),
     callee: deserializeExpression(pos + 8),
+    typeArguments: deserializeOptionBoxTSTypeParameterInstantiation(pos + 24),
     arguments: deserializeVecArgument(pos + 32),
     optional: deserializeBool(pos + 56),
-    typeArguments: deserializeOptionBoxTSTypeParameterInstantiation(pos + 24),
   };
 }
 
@@ -255,8 +255,8 @@ function deserializeNewExpression(pos) {
     start: deserializeU32(pos),
     end: deserializeU32(pos + 4),
     callee: deserializeExpression(pos + 8),
-    arguments: deserializeVecArgument(pos + 32),
     typeArguments: deserializeOptionBoxTSTypeParameterInstantiation(pos + 24),
+    arguments: deserializeVecArgument(pos + 32),
   };
 }
 
@@ -1131,8 +1131,8 @@ function deserializeExportNamedDeclaration(pos) {
     declaration: deserializeOptionDeclaration(pos + 8),
     specifiers: deserializeVecExportSpecifier(pos + 24),
     source: deserializeOptionStringLiteral(pos + 48),
-    attributes: withClause === null ? [] : withClause.attributes,
     exportKind: deserializeImportOrExportKind(pos + 104),
+    attributes: withClause === null ? [] : withClause.attributes,
   };
 }
 

npm/oxc-types/types.d.ts

@@ -125,8 +125,8 @@ export interface TemplateLiteral extends Span {
 export interface TaggedTemplateExpression extends Span {
   type: 'TaggedTemplateExpression';
   tag: Expression;
-  quasi: TemplateLiteral;
   typeArguments?: TSTypeParameterInstantiation | null;
+  quasi: TemplateLiteral;
 }
 
 export interface TemplateElement extends Span {
@@ -169,16 +169,16 @@ export interface PrivateFieldExpression extends Span {
 export interface CallExpression extends Span {
   type: 'CallExpression';
   callee: Expression;
+  typeArguments?: TSTypeParameterInstantiation | null;
   arguments: Array<Argument>;
   optional: boolean;
-  typeArguments?: TSTypeParameterInstantiation | null;
 }
 
 export interface NewExpression extends Span {
   type: 'NewExpression';
   callee: Expression;
-  arguments: Array<Argument>;
   typeArguments?: TSTypeParameterInstantiation | null;
+  arguments: Array<Argument>;
 }
 
 export interface MetaProperty extends Span {
@@ -788,8 +788,8 @@ export interface ExportNamedDeclaration extends Span {
   declaration: Declaration | null;
   specifiers: Array<ExportSpecifier>;
   source: StringLiteral | null;
-  attributes: Array<ImportAttribute>;
   exportKind?: ImportOrExportKind;
+  attributes: Array<ImportAttribute>;
 }
 
 export interface ExportDefaultDeclaration extends Span {

tasks/ast_tools/src/derives/estree.rs

@@ -251,7 +251,7 @@ fn parse_js_only_attr(location: AttrLocation, part: &AttrPart) -> Result<()> {
 fn prepare_field_orders(schema: &mut Schema, estree_derive_id: DeriveId) {
     // Note: Outside the loop to avoid allocating temporary `Vec`s on each turn of the loop.
     // Instead, reuse this `Vec` over and over.
-    let mut field_indices_temp = vec![];
+    let mut unskipped_field_indices = vec![];
 
     for type_id in schema.types.indices() {
         let Some(struct_def) = schema.types[type_id].as_struct() else { continue };
@@ -261,44 +261,29 @@ fn prepare_field_orders(schema: &mut Schema, estree_derive_id: DeriveId) {
 
         if struct_def.estree.field_indices.is_empty() {
             // No field order specified with `#[estree(field_order(...))]`.
-            // Set default order:
-            // 1. Fields without `#[ts]` attr.
-            // 2. Fields with `#[ts]` attr.
-            // 3. Added fields `#[estree(add_fields(...)]`.
-            // 4. Added fields `#[estree(add_fields(...)]`, where converter meta type has `#[ts]` attr.
-            // Within the above groups, ordered in definition order.
+            // Default field order is definition order, with `#[estree(add_fields(...)]` extra fields
+            // added on end in order.
             let mut field_indices = vec![];
-            let ts_field_indices = &mut field_indices_temp;
             for (field_index, field) in struct_def.fields.iter().enumerate() {
                 if !should_skip_field(field, schema) {
                     let field_index = u8::try_from(field_index).unwrap();
-                    if field.estree.is_ts {
-                        ts_field_indices.push(field_index);
-                    } else {
-                        field_indices.push(field_index);
-                    }
-                }
-            }
-
-            let fields_len = struct_def.fields.len();
-            for (index, (_, converter_name)) in struct_def.estree.add_fields.iter().enumerate() {
-                let field_index = u8::try_from(fields_len + index).unwrap();
-                let converter = schema.meta_by_name(converter_name);
-                if converter.estree.is_ts {
-                    ts_field_indices.push(field_index);
-                } else {
                     field_indices.push(field_index);
                 }
             }
 
-            field_indices.append(ts_field_indices);
+            if !struct_def.estree.add_fields.is_empty() {
+                let first_index = u8::try_from(struct_def.fields.len()).unwrap();
+                let last_index =
+                    u8::try_from(struct_def.fields.len() + struct_def.estree.add_fields.len() - 1)
+                        .unwrap();
+                field_indices.extend(first_index..=last_index);
+            }
 
             let struct_def = schema.struct_def_mut(type_id);
             struct_def.estree.field_indices = field_indices;
         } else {
             // Custom field order specified with `#[estree(field_order(...))]`.
             // Verify does not miss any fields, no fields marked `#[estree(skip)]` are included.
-            let unskipped_field_indices = &mut field_indices_temp;
             for (field_index, field) in struct_def.fields.iter().enumerate() {
                 if !should_skip_field(field, schema) {
                     let field_index = u8::try_from(field_index).unwrap();