feat(ast): add range field to custom serializers

crates/oxc_ast/src/serialize/js.rs

@@ -54,6 +54,8 @@ struct BindingPatternKindAndTsFields<'a, 'b> {
 
 impl ESTree for BindingPatternKindAndTsFields<'_, '_> {
     fn serialize<S: Serializer>(&self, serializer: S) {
+        let ranges = serializer.ranges();
+
         let mut state = serializer.serialize_struct();
 
         match &self.kind {
@@ -91,6 +93,18 @@ impl ESTree for BindingPatternKindAndTsFields<'_, '_> {
         state.serialize_field("optional", &self.optional);
         state.serialize_field("typeAnnotation", &self.type_annotation);
 
+        if ranges {
+            let (span_start, span_end) = match &self.kind {
+                BindingPatternKind::BindingIdentifier(ident) => (ident.span.start, ident.span.end),
+                BindingPatternKind::ObjectPattern(object) => (object.span.start, object.span.end),
+                BindingPatternKind::ArrayPattern(array) => (array.span.start, array.span.end),
+                BindingPatternKind::AssignmentPattern(assignment) => {
+                    (assignment.span.start, assignment.span.end)
+                }
+            };
+            state.serialize_field("range", &[&span_start, &span_end]);
+        }
+
         state.end();
     }
 }
@@ -165,6 +179,7 @@ struct FormalParametersRest<'a, 'b>(&'b BindingRestElement<'a>);
 impl ESTree for FormalParametersRest<'_, '_> {
     fn serialize<S: Serializer>(&self, serializer: S) {
         let rest = self.0;
+        let ranges = serializer.ranges();
         let mut state = serializer.serialize_struct();
         state.serialize_field("type", &JsonSafeString("RestElement"));
         state.serialize_field("start", &rest.span.start);
@@ -174,6 +189,9 @@ impl ESTree for FormalParametersRest<'_, '_> {
         state.serialize_ts_field("optional", &rest.argument.optional);
         state.serialize_ts_field("typeAnnotation", &rest.argument.type_annotation);
         state.serialize_ts_field("value", &Null(()));
+        if ranges {
+            state.serialize_field("range", &[&rest.span.start, &rest.span.end]);
+        }
         state.end();
     }
 }
@@ -223,6 +241,8 @@ impl ESTree for FormalParameterConverter<'_, '_> {
     fn serialize<S: Serializer>(&self, serializer: S) {
         let param = self.0;
 
+        let ranges = serializer.ranges();
+
         if S::INCLUDE_TS_FIELDS {
             if param.has_modifier() {
                 let mut state = serializer.serialize_struct();
@@ -235,6 +255,9 @@ impl ESTree for FormalParameterConverter<'_, '_> {
                 state.serialize_field("parameter", &param.pattern);
                 state.serialize_field("readonly", &param.readonly);
                 state.serialize_field("static", &false);
+                if ranges {
+                    state.serialize_field("range", &[&param.span.start, &param.span.end]);
+                }
                 state.end();
             } else {
                 BindingPatternKindAndTsFields {
@@ -436,6 +459,8 @@ pub struct AssignmentTargetPropertyIdentifierInit<'a>(
 
 impl ESTree for AssignmentTargetPropertyIdentifierInit<'_> {
     fn serialize<S: Serializer>(&self, serializer: S) {
+        let ranges = serializer.ranges();
+
         if let Some(init) = &self.0.init {
             let mut state = serializer.serialize_struct();
             state.serialize_field("type", &JsonSafeString("AssignmentPattern"));
@@ -446,6 +471,9 @@ impl ESTree for AssignmentTargetPropertyIdentifierInit<'_> {
             state.serialize_field("right", init);
             state.serialize_ts_field("optional", &false);
             state.serialize_ts_field("typeAnnotation", &Null(()));
+            if ranges {
+                state.serialize_field("range", &[&self.0.span.start, &self.0.span.end]);
+            }
             state.end();
         } else {
             self.0.binding.serialize(serializer);

crates/oxc_ast/src/serialize/jsx.rs

@@ -22,6 +22,8 @@ impl ESTree for JSXElementOpeningElement<'_, '_> {
         let element = self.0;
         let opening_element = element.opening_element.as_ref();
 
+        let ranges = serializer.ranges();
+
         let mut state = serializer.serialize_struct();
         state.serialize_field("type", &JsonSafeString("JSXOpeningElement"));
         state.serialize_field("start", &opening_element.span.start);
@@ -30,6 +32,12 @@ impl ESTree for JSXElementOpeningElement<'_, '_> {
         state.serialize_ts_field("typeArguments", &opening_element.type_arguments);
         state.serialize_field("attributes", &opening_element.attributes);
         state.serialize_field("selfClosing", &element.closing_element.is_none());
+        if ranges {
+            state.serialize_field(
+                "range",
+                &[&opening_element.span.start, &opening_element.span.end],
+            );
+        }
         state.end();
     }
 }

crates/oxc_ast/src/serialize/literal.rs

@@ -209,6 +209,7 @@ pub struct TemplateElementConverter<'a, 'b>(pub &'b TemplateElement<'a>);
 impl ESTree for TemplateElementConverter<'_, '_> {
     fn serialize<S: Serializer>(&self, serializer: S) {
         let element = self.0;
+        let ranges = serializer.ranges();
         let mut state = serializer.serialize_struct();
         state.serialize_field("type", &JsonSafeString("TemplateElement"));
 
@@ -222,6 +223,9 @@ impl ESTree for TemplateElementConverter<'_, '_> {
 
         state.serialize_field("value", &TemplateElementValue(element));
         state.serialize_field("tail", &element.tail);
+        if ranges {
+            state.serialize_field("range", &[&span.start, &span.end]);
+        }
         state.end();
     }
 }

crates/oxc_ast/src/serialize/ts.rs

@@ -165,6 +165,8 @@ struct TSModuleDeclarationIdParts<'a, 'b>(&'b [&'b BindingIdentifier<'a>]);
 
 impl ESTree for TSModuleDeclarationIdParts<'_, '_> {
     fn serialize<S: Serializer>(&self, serializer: S) {
+        let ranges = serializer.ranges();
+
         let parts = self.0;
         assert!(!parts.is_empty());
 
@@ -185,6 +187,9 @@ impl ESTree for TSModuleDeclarationIdParts<'_, '_> {
         }
 
         state.serialize_field("right", last);
+        if ranges {
+            state.serialize_field("range", &[&span_start, &last.span.end]);
+        }
         state.end();
     }
 }
@@ -334,6 +339,7 @@ struct TSTypeNameAsMemberExpression<'a, 'b>(&'b TSTypeName<'a>);
 
 impl ESTree for TSTypeNameAsMemberExpression<'_, '_> {
     fn serialize<S: Serializer>(&self, serializer: S) {
+        let ranges = serializer.ranges();
         match self.0 {
             TSTypeName::IdentifierReference(ident) => {
                 TSTypeNameIdentifierReference(ident).serialize(serializer);
@@ -349,6 +355,9 @@ impl ESTree for TSTypeNameAsMemberExpression<'_, '_> {
                 state.serialize_field("property", &name.right);
                 state.serialize_field("optional", &false);
                 state.serialize_field("computed", &false);
+                if ranges {
+                    state.serialize_field("range", &[&name.span.start, &name.span.end]);
+                }
                 state.end();
             }
         }