fix(transformer/decorator): transformed decorators should be injected after class-properties has run (oxc-project#12418)

* close rolldown/rolldown#5374

Example:

Input:
```ts
function myPropertyDecorator() {
  return (target: any, propertyKey: number) => {
    console.log(target.constructor.modelName, propertyKey);
  };
}

class Test {
  public static modelName = 'Test';

  @myPropertyDecorator()
  public myProperty = 1;
}

const instance = new Test();

export default instance;
```

Output diff:
```diff
function myPropertyDecorator() {
        return (target, propertyKey) => {
                console.log(target.constructor.modelName, propertyKey);
        };
}
class Test {
        constructor() {
                babelHelpers.defineProperty(this, "myProperty", 1);
        }
}
-babelHelpers.decorate([myPropertyDecorator()], Test.prototype, "myProperty", void 0);
-babelHelpers.defineProperty(Test, "modelName", "Test");
+babelHelpers.defineProperty(Test, "modelName", "Test");
+babelHelpers.decorate([myPropertyDecorator()], Test.prototype, "myProperty", void 0);

const instance = new Test();
export default instance;
```

The cause is that we transform class fields and decorators in two different plugins, and the decorator plugin should be transformed first, and then run the class-properties plugin, because class-properties might erase some decorator information. However, this cause transformed decorators injected before transformed class fields.

This PR fixes this problem by collecting all transformed decorators that wait for injection, and injecting them in batch after the `class-properties` plugin has run.

Author: Dunqing

crates/oxc_transformer/src/decorator/legacy/mod.rs

@@ -54,6 +54,7 @@ use oxc_semantic::{ScopeFlags, SymbolFlags};
 use oxc_span::SPAN;
 use oxc_syntax::operator::AssignmentOperator;
 use oxc_traverse::{Ancestor, BoundIdentifier, Traverse};
+use rustc_hash::FxHashMap;
 
 use crate::{
     Helper,
@@ -92,6 +93,8 @@ pub struct LegacyDecorator<'a, 'ctx> {
     /// we have to transforms decorators to `exit_class` otherwise after class is being transformed by
     /// `class-properties` plugin, the decorators' nodes might be lost.
     class_decorated_data: Option<ClassDecoratedData<'a>>,
+    /// Transformed decorators, they will be inserted in the statements at [`Self::exit_class_at_end`].
+    decorations: FxHashMap<Address, Vec<Statement<'a>>>,
     ctx: &'ctx TransformCtx<'a>,
 }
 
@@ -102,6 +105,7 @@ impl<'a, 'ctx> LegacyDecorator<'a, 'ctx> {
             metadata: LegacyDecoratorMetadata::new(ctx),
             class_decorated_data: None,
             ctx,
+            decorations: FxHashMap::default(),
         }
     }
 }
@@ -492,8 +496,8 @@ impl<'a> LegacyDecorator<'a, '_> {
         };
 
         if has_private_in_expression_in_decorator {
-            let stmts = mem::replace(&mut decoration_stmts, ctx.ast.vec());
-            Self::insert_decorations_into_class_static_block(class, stmts, ctx);
+            let decorations = mem::take(&mut decoration_stmts);
+            Self::insert_decorations_into_class_static_block(class, decorations, ctx);
         } else {
             let address = match ctx.parent() {
                 Ancestor::ExportDefaultDeclarationDeclaration(_)
@@ -503,7 +507,7 @@ impl<'a> LegacyDecorator<'a, '_> {
             };
 
             decoration_stmts.push(constructor_decoration);
-            self.ctx.statement_injector.insert_many_after(&address, decoration_stmts);
+            self.decorations.entry(address).or_default().append(&mut decoration_stmts);
             self.class_decorated_data = Some(ClassDecoratedData {
                 binding: class_binding,
                 // If the class alias has reassigned to `this` in the static block, then
@@ -561,7 +565,7 @@ impl<'a> LegacyDecorator<'a, '_> {
 
     /// Transforms a non-decorated class declaration.
     fn transform_class_declaration_without_class_decorators(
-        &self,
+        &mut self,
         class: &mut Class<'a>,
         has_private_in_expression_in_decorator: bool,
         ctx: &mut TraverseCtx<'a>,
@@ -575,7 +579,7 @@ impl<'a> LegacyDecorator<'a, '_> {
             class_binding
         };
 
-        let decoration_stmts =
+        let mut decoration_stmts =
             self.transform_decorators_of_class_elements(class, &class_binding, ctx);
 
         if has_private_in_expression_in_decorator {
@@ -587,7 +591,7 @@ impl<'a> LegacyDecorator<'a, '_> {
                 // `Class` is always stored in a `Box`, so has a stable memory location
                 _ => Address::from_ptr(class),
             };
-            self.ctx.statement_injector.insert_many_after(&stmt_address, decoration_stmts);
+            self.decorations.entry(stmt_address).or_default().append(&mut decoration_stmts);
         }
     }
 
@@ -598,8 +602,8 @@ impl<'a> LegacyDecorator<'a, '_> {
         class: &mut Class<'a>,
         class_binding: &BoundIdentifier<'a>,
         ctx: &mut TraverseCtx<'a>,
-    ) -> ArenaVec<'a, Statement<'a>> {
-        let mut decoration_stmts = ctx.ast.vec_with_capacity(class.body.body.len());
+    ) -> Vec<Statement<'a>> {
+        let mut decoration_stmts = Vec::with_capacity(class.body.body.len());
 
         for element in &mut class.body.body {
             let (is_static, key, descriptor, decorations) = match element {
@@ -738,10 +742,11 @@ impl<'a> LegacyDecorator<'a, '_> {
     /// ```
     fn insert_decorations_into_class_static_block(
         class: &mut Class<'a>,
-        decorations: ArenaVec<'a, Statement<'a>>,
+        decorations: Vec<Statement<'a>>,
         ctx: &mut TraverseCtx<'a>,
     ) {
         let scope_id = ctx.create_child_scope(class.scope_id(), ScopeFlags::ClassStaticBlock);
+        let decorations = ctx.ast.vec_from_iter(decorations);
         let element = ctx.ast.class_element_static_block_with_scope_id(SPAN, decorations, scope_id);
         class.body.body.push(element);
     }
@@ -780,6 +785,14 @@ impl<'a> LegacyDecorator<'a, '_> {
         }
     }
 
+    /// Injects the class decorator statements after class-properties plugin has run, ensuring that
+    /// all transformed fields are injected before the class decorator statements.
+    pub fn exit_class_at_end(&mut self, _class: &mut Class<'a>, _ctx: &mut TraverseCtx<'a>) {
+        for (address, stmts) in mem::take(&mut self.decorations) {
+            self.ctx.statement_injector.insert_many_after(&address, stmts);
+        }
+    }
+
     /// Converts a vec of [`Decorator`] to [`Expression::ArrayExpression`].
     fn convert_decorators_to_array_expression(
         decorators_iter: impl Iterator<Item = Decorator<'a>>,

crates/oxc_transformer/src/decorator/mod.rs

@@ -82,3 +82,11 @@ impl<'a> Traverse<'a, TransformState<'a>> for Decorator<'a, '_> {
         }
     }
 }
+
+impl<'a> Decorator<'a, '_> {
+    pub fn exit_class_at_end(&mut self, class: &mut Class<'a>, ctx: &mut TraverseCtx<'a>) {
+        if self.options.legacy {
+            self.legacy_decorator.exit_class_at_end(class, ctx);
+        }
+    }
+}

crates/oxc_transformer/src/lib.rs

@@ -300,6 +300,8 @@ impl<'a> Traverse<'a, TransformState<'a>> for TransformerImpl<'a, '_> {
             typescript.exit_class(class, ctx);
         }
         self.x2_es2022.exit_class(class, ctx);
+        // `decorator` has some statements should be inserted after `class-properties` plugin.
+        self.decorator.exit_class_at_end(class, ctx);
     }
 
     fn enter_class_body(&mut self, body: &mut ClassBody<'a>, ctx: &mut TraverseCtx<'a>) {

napi/transform/test/transform.test.ts

@@ -403,18 +403,18 @@ describe('typescript', () => {
         },
       });
       expect(ret.code).toMatchInlineSnapshot(`
-				"import _decorate from "@oxc-project/runtime/helpers/decorate";
-				class Foo {
-					constructor() {
-						this.b = 1;
-					}
-				}
-				_decorate([dec], Foo.prototype, "c", void 0);
-				class StaticFoo {}
-				_decorate([dec], StaticFoo, "c", void 0);
-				StaticFoo.b = 1;
-				"
-			`);
+        "import _decorate from "@oxc-project/runtime/helpers/decorate";
+        class Foo {
+        	constructor() {
+        		this.b = 1;
+        	}
+        }
+        _decorate([dec], Foo.prototype, "c", void 0);
+        class StaticFoo {}
+        StaticFoo.b = 1;
+        _decorate([dec], StaticFoo, "c", void 0);
+        "
+      `);
     });
   });
 });