fix(ast/estree): use #[estree(append_to)] for TSModuleBlock

crates/oxc_ast/src/ast/ts.rs

@@ -1205,11 +1205,11 @@ pub enum TSModuleDeclarationBody<'a> {
 #[ast(visit)]
 #[derive(Debug)]
 #[generate_derive(CloneIn, GetSpan, GetSpanMut, ContentEq, ESTree)]
-#[estree(custom_serialize)]
 pub struct TSModuleBlock<'a> {
     pub span: Span,
-    #[estree(skip)]
+    #[estree(rename = "body")]
     pub directives: Vec<'a, Directive<'a>>,
+    #[estree(append_to = "directives")]
     pub body: Vec<'a, Statement<'a>>,
 }
 

crates/oxc_ast/src/generated/derive_estree.rs

@@ -3043,6 +3043,20 @@ impl Serialize for TSModuleDeclarationBody<'_> {
     }
 }
 
+impl Serialize for TSModuleBlock<'_> {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        let mut map = serializer.serialize_map(None)?;
+        map.serialize_entry("type", "TSModuleBlock")?;
+        map.serialize_entry("start", &self.span.start)?;
+        map.serialize_entry("end", &self.span.end)?;
+        map.serialize_entry(
+            "body",
+            &AppendToConcat { array: &self.directives, after: &self.body },
+        )?;
+        map.end()
+    }
+}
+
 impl Serialize for TSTypeLiteral<'_> {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         let mut map = serializer.serialize_map(None)?;

crates/oxc_ast/src/serialize.rs

@@ -222,55 +222,6 @@ impl<T: Serialize> Serialize for OptionVecDefault<'_, '_, T> {
     }
 }
 
-/// Serialize `TSModuleBlock` to be ESTree compatible, with `body` and `directives` fields combined,
-/// and directives output as `StringLiteral` expression statements
-impl Serialize for TSModuleBlock<'_> {
-    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        let converted = SerTSModuleBlock {
-            span: self.span,
-            body: DirectivesAndStatements { directives: &self.directives, body: &self.body },
-        };
-        converted.serialize(serializer)
-    }
-}
-
-#[derive(Serialize)]
-#[serde(tag = "type", rename = "TSModuleBlock")]
-struct SerTSModuleBlock<'a, 'b> {
-    #[serde(flatten)]
-    span: Span,
-    body: DirectivesAndStatements<'a, 'b>,
-}
-
-struct DirectivesAndStatements<'a, 'b> {
-    directives: &'b [Directive<'a>],
-    body: &'b [Statement<'a>],
-}
-
-impl Serialize for DirectivesAndStatements<'_, '_> {
-    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        let mut seq = serializer.serialize_seq(Some(self.directives.len() + self.body.len()))?;
-        for directive in self.directives {
-            seq.serialize_element(&DirectiveAsStatement {
-                span: directive.span,
-                expression: &directive.expression,
-            })?;
-        }
-        for stmt in self.body {
-            seq.serialize_element(stmt)?;
-        }
-        seq.end()
-    }
-}
-
-#[derive(Serialize)]
-#[serde(tag = "type", rename = "ExpressionStatement")]
-struct DirectiveAsStatement<'a, 'b> {
-    #[serde(flatten)]
-    span: Span,
-    expression: &'b StringLiteral<'a>,
-}
-
 /// Serializer for `ArrowFunctionExpression`'s `body` field.
 ///
 /// Serializes as either an expression (if `expression` property is set),

npm/oxc-types/types.d.ts

@@ -1280,7 +1280,7 @@ export type TSModuleDeclarationBody = TSModuleDeclaration | TSModuleBlock;
 
 export interface TSModuleBlock extends Span {
   type: 'TSModuleBlock';
-  body: Array<Statement>;
+  body: Array<Directive | Statement>;
 }
 
 export interface TSTypeLiteral extends Span {