refactor(ast/estree): simplify adding range field

crates/oxc_ast/src/serialize/js.rs

@@ -58,27 +58,30 @@ impl ESTree for BindingPatternKindAndTsFields<'_, '_> {
 
         let mut state = serializer.serialize_struct();
 
-        match &self.kind {
+        let span = match &self.kind {
             BindingPatternKind::BindingIdentifier(ident) => {
                 state.serialize_field("type", &JsonSafeString("Identifier"));
                 state.serialize_field("start", &ident.span.start);
                 state.serialize_field("end", &ident.span.end);
                 state.serialize_field("decorators", &self.decorators);
                 state.serialize_field("name", &JsonSafeString(ident.name.as_str()));
+                ident.span
             }
             BindingPatternKind::ObjectPattern(object) => {
                 state.serialize_field("type", &JsonSafeString("ObjectPattern"));
                 state.serialize_field("start", &object.span.start);
                 state.serialize_field("end", &object.span.end);
                 state.serialize_field("decorators", &self.decorators);
                 state.serialize_field("properties", &Concat2(&object.properties, &object.rest));
+                object.span
             }
             BindingPatternKind::ArrayPattern(array) => {
                 state.serialize_field("type", &JsonSafeString("ArrayPattern"));
                 state.serialize_field("start", &array.span.start);
                 state.serialize_field("end", &array.span.end);
                 state.serialize_field("decorators", &self.decorators);
                 state.serialize_field("elements", &Concat2(&array.elements, &array.rest));
+                array.span
             }
             BindingPatternKind::AssignmentPattern(assignment) => {
                 state.serialize_field("type", &JsonSafeString("AssignmentPattern"));
@@ -87,22 +90,15 @@ impl ESTree for BindingPatternKindAndTsFields<'_, '_> {
                 state.serialize_field("decorators", &self.decorators);
                 state.serialize_field("left", &assignment.left);
                 state.serialize_field("right", &assignment.right);
+                assignment.span
             }
-        }
+        };
 
         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.serialize_field("range", &[span.start, span.end]);
         }
 
         state.end();
@@ -190,7 +186,7 @@ impl ESTree for FormalParametersRest<'_, '_> {
         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.serialize_field("range", &[rest.span.start, rest.span.end]);
         }
         state.end();
     }
@@ -256,7 +252,7 @@ impl ESTree for FormalParameterConverter<'_, '_> {
                 state.serialize_field("readonly", &param.readonly);
                 state.serialize_field("static", &false);
                 if ranges {
-                    state.serialize_field("range", &[&param.span.start, &param.span.end]);
+                    state.serialize_field("range", &[param.span.start, param.span.end]);
                 }
                 state.end();
             } else {
@@ -459,9 +455,9 @@ 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 ranges = serializer.ranges();
+
             let mut state = serializer.serialize_struct();
             state.serialize_field("type", &JsonSafeString("AssignmentPattern"));
             state.serialize_field("start", &self.0.span.start);
@@ -472,7 +468,7 @@ impl ESTree for AssignmentTargetPropertyIdentifierInit<'_> {
             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.serialize_field("range", &[self.0.span.start, self.0.span.end]);
             }
             state.end();
         } else {

crates/oxc_ast/src/serialize/jsx.rs

@@ -33,10 +33,7 @@ impl ESTree for JSXElementOpeningElement<'_, '_> {
         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.serialize_field("range", &[opening_element.span.start, opening_element.span.end]);
         }
         state.end();
     }

crates/oxc_ast/src/serialize/literal.rs

@@ -223,9 +223,11 @@ 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.serialize_field("range", &[span.start, span.end]);
         }
+
         state.end();
     }
 }

crates/oxc_ast/src/serialize/ts.rs

@@ -187,9 +187,11 @@ impl ESTree for TSModuleDeclarationIdParts<'_, '_> {
         }
 
         state.serialize_field("right", last);
+
         if ranges {
-            state.serialize_field("range", &[&span_start, &last.span.end]);
+            state.serialize_field("range", &[span_start, last.span.end]);
         }
+
         state.end();
     }
 }
@@ -339,12 +341,13 @@ 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);
             }
             TSTypeName::QualifiedName(name) => {
+                let ranges = serializer.ranges();
+
                 // Convert to `TSQualifiedName` to `MemberExpression`.
                 // Recursively convert `left` to `MemberExpression` too if it's a `TSQualifiedName`.
                 let mut state = serializer.serialize_struct();
@@ -356,7 +359,7 @@ impl ESTree for TSTypeNameAsMemberExpression<'_, '_> {
                 state.serialize_field("optional", &false);
                 state.serialize_field("computed", &false);
                 if ranges {
-                    state.serialize_field("range", &[&name.span.start, &name.span.end]);
+                    state.serialize_field("range", &[name.span.start, name.span.end]);
                 }
                 state.end();
             }