refactor(transformer): add an empty SPAN utility for creating AST nodes (#1067)

crates/oxc_span/src/lib.rs

@@ -9,5 +9,5 @@ mod span;
 pub use crate::{
     atom::Atom,
     source_type::{Language, LanguageVariant, ModuleKind, SourceType, VALID_EXTENSIONS},
-    span::{GetSpan, Span},
+    span::{GetSpan, Span, SPAN},
 };

crates/oxc_span/src/span.rs

@@ -4,6 +4,9 @@ use miette::{SourceOffset, SourceSpan};
 #[cfg(feature = "serde")]
 use serde::Serialize;
 
+/// An Empty span useful for creating AST nodes.
+pub const SPAN: Span = Span::new(0, 0);
+
 /// Newtype for working with text ranges
 ///
 /// See the [`text-size`](https://docs.rs/text-size) crate for details.

crates/oxc_transformer/src/es2019/optional_catch_binding.rs

@@ -1,7 +1,7 @@
 use std::rc::Rc;
 
 use oxc_ast::{ast::*, AstBuilder};
-use oxc_span::Span;
+use oxc_span::SPAN;
 
 use crate::options::{TransformOptions, TransformTarget};
 
@@ -24,7 +24,7 @@ impl<'a> OptionalCatchBinding<'a> {
         if clause.param.is_some() {
             return;
         }
-        let binding_identifier = BindingIdentifier::new(Span::default(), "_unused".into());
+        let binding_identifier = BindingIdentifier::new(SPAN, "_unused".into());
         let binding_pattern_kind = self.ast.binding_pattern_identifier(binding_identifier);
         let binding_pattern = self.ast.binding_pattern(binding_pattern_kind, None, false);
         clause.param = Some(binding_pattern);

crates/oxc_transformer/src/es2020/nullish_coalescing_operator.rs

@@ -3,7 +3,7 @@ use std::rc::Rc;
 
 use oxc_allocator::Vec;
 use oxc_ast::{ast::*, AstBuilder};
-use oxc_span::Span;
+use oxc_span::SPAN;
 use oxc_syntax::operator::{AssignmentOperator, BinaryOperator, LogicalOperator};
 
 use crate::{
@@ -66,7 +66,6 @@ impl<'a> NullishCoalescingOperator<'a> {
             return;
         }
 
-        let span = Span::default();
         let reference;
         let assignment;
 
@@ -82,25 +81,25 @@ impl<'a> NullishCoalescingOperator<'a> {
             );
             let right = self.ast.copy(&logical_expr.left);
             assignment =
-                self.ast.assignment_expression(span, AssignmentOperator::Assign, left, right);
+                self.ast.assignment_expression(SPAN, AssignmentOperator::Assign, left, right);
         };
 
         let test = if self.no_document_all {
-            let null = self.ast.literal_null_expression(NullLiteral::new(span));
+            let null = self.ast.literal_null_expression(NullLiteral::new(SPAN));
-            self.ast.binary_expression(span, assignment, BinaryOperator::Inequality, null)
+            self.ast.binary_expression(SPAN, assignment, BinaryOperator::Inequality, null)
         } else {
             let op = BinaryOperator::StrictInequality;
-            let null = self.ast.literal_null_expression(NullLiteral::new(span));
+            let null = self.ast.literal_null_expression(NullLiteral::new(SPAN));
-            let left = self.ast.binary_expression(span, self.ast.copy(&assignment), op, null);
+            let left = self.ast.binary_expression(SPAN, self.ast.copy(&assignment), op, null);
 
             let right =
-                self.ast.binary_expression(span, self.ast.copy(&reference), op, self.ast.void_0());
+                self.ast.binary_expression(SPAN, self.ast.copy(&reference), op, self.ast.void_0());
 
-            self.ast.logical_expression(span, left, LogicalOperator::And, right)
+            self.ast.logical_expression(SPAN, left, LogicalOperator::And, right)
         };
 
         let right = self.ast.move_expression(&mut logical_expr.right);
 
-        *expr = self.ast.conditional_expression(span, test, reference, right);
+        *expr = self.ast.conditional_expression(SPAN, test, reference, right);
     }
 }

crates/oxc_transformer/src/es2021/logical_assignment_operators.rs

@@ -2,7 +2,7 @@ use std::rc::Rc;
 
 use oxc_allocator::Vec;
 use oxc_ast::{ast::*, AstBuilder};
-use oxc_span::Span;
+use oxc_span::SPAN;
 use oxc_syntax::operator::{AssignmentOperator, LogicalOperator};
 
 use crate::{
@@ -73,7 +73,6 @@ impl<'a> LogicalAssignmentOperators<'a> {
                     assign_target = self.ast.simple_assignment_target_identifier((*ident).clone());
                 }
                 SimpleAssignmentTarget::MemberAssignmentTarget(member_expr) => {
-                    let span = Span::default();
                     let op = AssignmentOperator::Assign;
 
                     // `a.b &&= c` -> `var _a; (_a = a).b && (_a.b = c)`
@@ -86,7 +85,7 @@ impl<'a> LogicalAssignmentOperators<'a> {
                                     self.ast.simple_assignment_target_identifier(ident.clone()),
                                 );
                                 expr.object =
-                                    self.ast.assignment_expression(span, op, target, right);
+                                    self.ast.assignment_expression(SPAN, op, target, right);
                                 left_expr = self.ast.member_expression(
                                     MemberExpression::StaticMemberExpression(expr),
                                 );
@@ -122,7 +121,7 @@ impl<'a> LogicalAssignmentOperators<'a> {
                                     self.ast.simple_assignment_target_identifier(ident.clone()),
                                 );
                                 expr.object =
-                                    self.ast.assignment_expression(span, op, target, right);
+                                    self.ast.assignment_expression(SPAN, op, target, right);
                                 if let Some(property_ident) = &property_ident {
                                     let left = AssignmentTarget::SimpleAssignmentTarget(
                                         self.ast.simple_assignment_target_identifier(
@@ -131,7 +130,7 @@ impl<'a> LogicalAssignmentOperators<'a> {
                                     );
                                     let right = self.ast.copy(&computed_expr.expression);
                                     expr.expression =
-                                        self.ast.assignment_expression(span, op, left, right);
+                                        self.ast.assignment_expression(SPAN, op, left, right);
                                 }
                                 left_expr = self.ast.member_expression(
                                     MemberExpression::ComputedMemberExpression(expr),
@@ -167,7 +166,7 @@ impl<'a> LogicalAssignmentOperators<'a> {
                                     );
                                     let right = self.ast.copy(&computed_expr.expression);
                                     expr.expression =
-                                        self.ast.assignment_expression(span, op, left, right);
+                                        self.ast.assignment_expression(SPAN, op, left, right);
                                 }
                                 left_expr = self.ast.member_expression(
                                     MemberExpression::ComputedMemberExpression(expr),
@@ -199,10 +198,9 @@ impl<'a> LogicalAssignmentOperators<'a> {
         let assign_op = AssignmentOperator::Assign;
         let assign_target = AssignmentTarget::SimpleAssignmentTarget(assign_target);
         let right = self.ast.move_expression(&mut assignment_expr.right);
-        let right =
+        let right = self.ast.assignment_expression(SPAN, assign_op, assign_target, right);
-            self.ast.assignment_expression(Span::default(), assign_op, assign_target, right);
 
-        let logical_expr = self.ast.logical_expression(Span::default(), left_expr, operator, right);
+        let logical_expr = self.ast.logical_expression(SPAN, left_expr, operator, right);
 
         *expr = logical_expr;
     }

crates/oxc_transformer/src/es2022/class_static_block.rs

@@ -1,7 +1,7 @@
 use std::{collections::HashSet, rc::Rc};
 
 use oxc_ast::{ast::*, AstBuilder};
-use oxc_span::{Atom, Span};
+use oxc_span::{Atom, SPAN};
 
 use crate::options::{TransformOptions, TransformTarget};
 
@@ -38,13 +38,12 @@ impl<'a> ClassStaticBlock<'a> {
                 continue;
             };
 
-            let span = block.span;
-
             let static_block_private_id = generate_uid(&private_names, &mut i);
-            let key = PropertyKey::PrivateIdentifier(self.ast.alloc(PrivateIdentifier {
+            let key =
-                span: Span::default(),
+                PropertyKey::PrivateIdentifier(self.ast.alloc(PrivateIdentifier {
-                name: static_block_private_id.clone(),
+                    span: SPAN,
-            }));
+                    name: static_block_private_id.clone(),
+                }));
 
             let value = match block.body.len() {
                 0 => None,
@@ -75,7 +74,7 @@ impl<'a> ClassStaticBlock<'a> {
                 }
                 _ => {
                     let params = self.ast.formal_parameters(
-                        Span::default(),
+                        SPAN,
                         FormalParameterKind::ArrowFormalParameters,
                         self.ast.new_vec(),
                         None,
@@ -83,10 +82,10 @@ impl<'a> ClassStaticBlock<'a> {
 
                     let statements = self.ast.move_statement_vec(&mut block.body);
                     let function_body =
-                        self.ast.function_body(Span::default(), self.ast.new_vec(), statements);
+                        self.ast.function_body(SPAN, self.ast.new_vec(), statements);
 
                     let callee = self.ast.arrow_expression(
-                        Span::default(),
+                        SPAN,
                         false,
                         false,
                         false,
@@ -96,20 +95,15 @@ impl<'a> ClassStaticBlock<'a> {
                         None,
                     );
 
-                    let callee = self.ast.parenthesized_expression(Span::default(), callee);
+                    let callee = self.ast.parenthesized_expression(SPAN, callee);
 
-                    let value = self.ast.call_expression(
+                    let value =
-                        Span::default(),
+                        self.ast.call_expression(SPAN, callee, self.ast.new_vec(), false, None);
-                        callee,
-                        self.ast.new_vec(),
-                        false,
-                        None,
-                    );
                     Some(value)
                 }
             };
 
-            *element = self.ast.class_property(span, key, value, false, true, self.ast.new_vec());
+            *element = self.ast.class_property(SPAN, key, value, false, true, self.ast.new_vec());
         }
     }
 }

crates/oxc_transformer/src/react_jsx/mod.rs

@@ -4,12 +4,10 @@ use std::rc::Rc;
 
 use oxc_allocator::Vec;
 use oxc_ast::{ast::*, AstBuilder};
-use oxc_span::Span;
+use oxc_span::SPAN;
 
 pub use self::options::{ReactJsxOptions, ReactJsxRuntime};
 
-const SPAN: Span = Span::new(0, 0);
-
 /// Transform React JSX
 ///
 /// References:

crates/oxc_transformer/src/regexp/regexp_flags.rs

@@ -1,5 +1,5 @@
 use oxc_ast::{ast::*, AstBuilder};
-use oxc_span::{Atom, Span};
+use oxc_span::{Atom, SPAN};
 
 use std::rc::Rc;
 
@@ -57,15 +57,15 @@ impl<'a> RegexpFlags<'a> {
         if regex.flags.intersection(self.transform_flags).is_empty() {
             return;
         }
-        let ident = IdentifierReference::new(Span::default(), Atom::from("RegExp"));
+        let ident = IdentifierReference::new(SPAN, Atom::from("RegExp"));
         let callee = self.ast.identifier_reference_expression(ident);
-        let pattern = StringLiteral::new(Span::default(), Atom::from(regex.pattern.as_str()));
+        let pattern = StringLiteral::new(SPAN, Atom::from(regex.pattern.as_str()));
-        let flags = StringLiteral::new(Span::default(), Atom::from(regex.flags.to_string()));
+        let flags = StringLiteral::new(SPAN, Atom::from(regex.flags.to_string()));
         let pattern_literal = self.ast.literal_string_expression(pattern);
         let flags_literal = self.ast.literal_string_expression(flags);
         let mut arguments = self.ast.new_vec_with_capacity(2);
         arguments.push(Argument::Expression(pattern_literal));
         arguments.push(Argument::Expression(flags_literal));
-        *expr = self.ast.new_expression(Span::default(), callee, arguments, None);
+        *expr = self.ast.new_expression(SPAN, callee, arguments, None);
     }
 }

crates/oxc_transformer/src/typescript/mod.rs

@@ -1,5 +1,5 @@
 use oxc_ast::{ast::*, AstBuilder};
-use oxc_span::{Atom, Span};
+use oxc_span::{Atom, SPAN};
 
 use std::rc::Rc;
 
@@ -116,7 +116,7 @@ impl<'a> TypeScript<'a> {
             && !program.body.iter().any(|s| matches!(s, Statement::ModuleDeclaration(_)))
         {
             let empty_export = self.ast.export_named_declaration(
-                Span::default(),
+                SPAN,
                 None,
                 self.ast.new_vec(),
                 None,