diff --git a/crates/oxc_span/src/lib.rs b/crates/oxc_span/src/lib.rs index 4dfafeb7e..cf595e883 100644 --- a/crates/oxc_span/src/lib.rs +++ b/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}, }; diff --git a/crates/oxc_span/src/span.rs b/crates/oxc_span/src/span.rs index 9c1f67280..f37e91c20 100644 --- a/crates/oxc_span/src/span.rs +++ b/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. diff --git a/crates/oxc_transformer/src/es2019/optional_catch_binding.rs b/crates/oxc_transformer/src/es2019/optional_catch_binding.rs index 54b988303..34dfc0f71 100644 --- a/crates/oxc_transformer/src/es2019/optional_catch_binding.rs +++ b/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); diff --git a/crates/oxc_transformer/src/es2020/nullish_coalescing_operator.rs b/crates/oxc_transformer/src/es2020/nullish_coalescing_operator.rs index 555400b27..2dd0fb3a6 100644 --- a/crates/oxc_transformer/src/es2020/nullish_coalescing_operator.rs +++ b/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)); - self.ast.binary_expression(span, assignment, BinaryOperator::Inequality, null) + let null = self.ast.literal_null_expression(NullLiteral::new(SPAN)); + 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 left = self.ast.binary_expression(span, self.ast.copy(&assignment), op, null); + let null = self.ast.literal_null_expression(NullLiteral::new(SPAN)); + 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); } } diff --git a/crates/oxc_transformer/src/es2021/logical_assignment_operators.rs b/crates/oxc_transformer/src/es2021/logical_assignment_operators.rs index 5c5cc736a..bdd2d411e 100644 --- a/crates/oxc_transformer/src/es2021/logical_assignment_operators.rs +++ b/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 = - self.ast.assignment_expression(Span::default(), assign_op, assign_target, right); + let right = self.ast.assignment_expression(SPAN, 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; } diff --git a/crates/oxc_transformer/src/es2022/class_static_block.rs b/crates/oxc_transformer/src/es2022/class_static_block.rs index 7f9817dfe..667644f2a 100644 --- a/crates/oxc_transformer/src/es2022/class_static_block.rs +++ b/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 { - span: Span::default(), - name: static_block_private_id.clone(), - })); + let key = + PropertyKey::PrivateIdentifier(self.ast.alloc(PrivateIdentifier { + 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( - Span::default(), - callee, - self.ast.new_vec(), - false, - None, - ); + let value = + self.ast.call_expression(SPAN, 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()); } } } diff --git a/crates/oxc_transformer/src/react_jsx/mod.rs b/crates/oxc_transformer/src/react_jsx/mod.rs index f6e6f71f5..a8bec15bc 100644 --- a/crates/oxc_transformer/src/react_jsx/mod.rs +++ b/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: diff --git a/crates/oxc_transformer/src/regexp/regexp_flags.rs b/crates/oxc_transformer/src/regexp/regexp_flags.rs index 8600c8e66..8029e08bd 100644 --- a/crates/oxc_transformer/src/regexp/regexp_flags.rs +++ b/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 flags = StringLiteral::new(Span::default(), Atom::from(regex.flags.to_string())); + let pattern = StringLiteral::new(SPAN, Atom::from(regex.pattern.as_str())); + 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); } } diff --git a/crates/oxc_transformer/src/typescript/mod.rs b/crates/oxc_transformer/src/typescript/mod.rs index ef954cc84..ed35dc228 100644 --- a/crates/oxc_transformer/src/typescript/mod.rs +++ b/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,