dan/oxc
1
0
Fork 0
mirror of https://github.com/danbulant/oxc synced 2026-05-24 12:21:58 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

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

Browse source
This commit is contained in:
Boshen 2023-10-26 18:43:53 +08:00 committed by GitHub
parent d8f1a7fce6
commit d9ba532ca6
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
9 changed files with 43 additions and 51 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
crates/oxc_span/src/lib.rs
View file

@ -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},
};

3
crates/oxc_span/src/span.rs
View file

@ -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.

4
crates/oxc_transformer/src/es2019/optional_catch_binding.rs
View file

@ -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);

19
crates/oxc_transformer/src/es2020/nullish_coalescing_operator.rs
View file

@ -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);
}
}

16
crates/oxc_transformer/src/es2021/logical_assignment_operators.rs
View file

@ -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;
}

32
crates/oxc_transformer/src/es2022/class_static_block.rs
View file

@ -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());
}
}
}

4
crates/oxc_transformer/src/react_jsx/mod.rs
View file

@ -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:

10
crates/oxc_transformer/src/regexp/regexp_flags.rs
View file

@ -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);
}
}

4
crates/oxc_transformer/src/typescript/mod.rs
View file

@ -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,