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

refactor(ast): improve simple_assignment_target_identifier and simple_assignment_target_member_expression method (#2153)

Browse source 
Based on current usage, I think returning AssignmentTarget is better.
This commit is contained in:
Dunqing 2024-01-24 11:24:27 +08:00 committed by GitHub
parent 7f89bfea0d
commit b261e86ea9
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
6 changed files with 41 additions and 66 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

13
crates/oxc_ast/src/ast_builder.rs
View file

@ -86,7 +86,6 @@ impl<'a> AstBuilder<'a> {
) -> AssignmentTarget<'a> { ) -> AssignmentTarget<'a> {
let ident = IdentifierReference::new(Span::default(), "".into()); let ident = IdentifierReference::new(Span::default(), "".into());
let dummy = self.simple_assignment_target_identifier(ident); let dummy = self.simple_assignment_target_identifier(ident);
let dummy = AssignmentTarget::SimpleAssignmentTarget(dummy);
mem::replace(target, dummy) mem::replace(target, dummy)
} }
@ -454,15 +453,19 @@ impl<'a> AstBuilder<'a> {
pub fn simple_assignment_target_identifier( pub fn simple_assignment_target_identifier(
&self, &self,
ident: IdentifierReference, ident: IdentifierReference,
) -> SimpleAssignmentTarget<'a> { ) -> AssignmentTarget<'a> {
SimpleAssignmentTarget::AssignmentTargetIdentifier(self.alloc(ident)) AssignmentTarget::SimpleAssignmentTarget(
SimpleAssignmentTarget::AssignmentTargetIdentifier(self.alloc(ident)),
)
} }
pub fn simple_assignment_target_member_expression( pub fn simple_assignment_target_member_expression(
&self, &self,
expr: MemberExpression<'a>, expr: MemberExpression<'a>,
) -> SimpleAssignmentTarget<'a> { ) -> AssignmentTarget<'a> {
SimpleAssignmentTarget::MemberAssignmentTarget(self.alloc(expr)) AssignmentTarget::SimpleAssignmentTarget(SimpleAssignmentTarget::MemberAssignmentTarget(
self.alloc(expr),
))
} }
pub fn await_expression(&self, span: Span, argument: Expression<'a>) -> Expression<'a> { pub fn await_expression(&self, span: Span, argument: Expression<'a>) -> Expression<'a> {

8
crates/oxc_transformer/src/es2016/exponentiation_operator.rs
View file

@ -140,12 +140,7 @@ impl<'a> ExponentiationOperator<'a> {
) )
} }
}; };
( (self.ast.simple_assignment_target_member_expression(reference), uid)
AssignmentTarget::SimpleAssignmentTarget(
self.ast.simple_assignment_target_member_expression(reference),
),
uid,
)
} }
_ => return None, _ => return None,
}; };
@ -231,7 +226,6 @@ impl<'a> ExponentiationOperator<'a> {
let ident = self.create_new_var(&expr); let ident = self.create_new_var(&expr);
// Add new reference `_name = name` to nodes // Add new reference `_name = name` to nodes
let target = self.ast.simple_assignment_target_identifier(ident.clone()); let target = self.ast.simple_assignment_target_identifier(ident.clone());
let target = AssignmentTarget::SimpleAssignmentTarget(target);
let op = AssignmentOperator::Assign; let op = AssignmentOperator::Assign;
nodes.push(self.ast.assignment_expression(Span::default(), op, target, expr)); nodes.push(self.ast.assignment_expression(Span::default(), op, target, expr));
self.ast.identifier_reference_expression(ident) self.ast.identifier_reference_expression(ident)

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

@ -76,9 +76,7 @@ impl<'a> NullishCoalescingOperator<'a> {
} else { } else {
let ident = self.create_new_var(&logical_expr.left); let ident = self.create_new_var(&logical_expr.left);
reference = self.ast.identifier_reference_expression(ident.clone()); reference = self.ast.identifier_reference_expression(ident.clone());
let left = AssignmentTarget::SimpleAssignmentTarget( let left = self.ast.simple_assignment_target_identifier(ident);
self.ast.simple_assignment_target_identifier(ident),
);
let right = self.ast.copy(&logical_expr.left); let right = self.ast.copy(&logical_expr.left);
assignment = assignment =
self.ast.assignment_expression(SPAN, AssignmentOperator::Assign, left, right); self.ast.assignment_expression(SPAN, AssignmentOperator::Assign, left, right);

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

@ -63,7 +63,7 @@ impl<'a> LogicalAssignmentOperators<'a> {
// ^ left_expr // ^ left_expr
let left_expr: Expression<'a>; let left_expr: Expression<'a>;
let assign_target: SimpleAssignmentTarget<'a>; let assign_target: AssignmentTarget<'_>;
// TODO: refactor this block, add tests, cover private identifier // TODO: refactor this block, add tests, cover private identifier
match &assignment_expr.left { match &assignment_expr.left {
@ -81,9 +81,8 @@ impl<'a> LogicalAssignmentOperators<'a> {
if let Some(ident) = self.maybe_generate_memoised(&static_expr.object) { if let Some(ident) = self.maybe_generate_memoised(&static_expr.object) {
let right = self.ast.copy(&static_expr.object); let right = self.ast.copy(&static_expr.object);
let mut expr = self.ast.copy(static_expr); let mut expr = self.ast.copy(static_expr);
let target = AssignmentTarget::SimpleAssignmentTarget( let target =
self.ast.simple_assignment_target_identifier(ident.clone()), self.ast.simple_assignment_target_identifier(ident.clone());
);
expr.object = expr.object =
self.ast.assignment_expression(SPAN, op, target, right); self.ast.assignment_expression(SPAN, op, target, right);
left_expr = self.ast.member_expression( left_expr = self.ast.member_expression(
@ -102,9 +101,10 @@ impl<'a> LogicalAssignmentOperators<'a> {
self.ast.copy(static_expr), self.ast.copy(static_expr),
), ),
); );
assign_target = SimpleAssignmentTarget::MemberAssignmentTarget( assign_target =
self.ast.copy(member_expr), self.ast.simple_assignment_target_member_expression(
); self.ast.copy(member_expr),
);
}; };
} }
// `a[b.y] &&= c;` -> // `a[b.y] &&= c;` ->
@ -117,16 +117,13 @@ impl<'a> LogicalAssignmentOperators<'a> {
let right = self.ast.copy(&computed_expr.object); let right = self.ast.copy(&computed_expr.object);
let mut expr = self.ast.copy(computed_expr); let mut expr = self.ast.copy(computed_expr);
let target = AssignmentTarget::SimpleAssignmentTarget( let target =
self.ast.simple_assignment_target_identifier(ident.clone()), self.ast.simple_assignment_target_identifier(ident.clone());
);
expr.object = 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 { if let Some(property_ident) = &property_ident {
let left = AssignmentTarget::SimpleAssignmentTarget( let left = self.ast.simple_assignment_target_identifier(
self.ast.simple_assignment_target_identifier( property_ident.clone(),
property_ident.clone(),
),
); );
let right = self.ast.copy(&computed_expr.expression); let right = self.ast.copy(&computed_expr.expression);
expr.expression = expr.expression =
@ -159,10 +156,8 @@ impl<'a> LogicalAssignmentOperators<'a> {
// expr.object = // 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 { if let Some(property_ident) = &property_ident {
let left = AssignmentTarget::SimpleAssignmentTarget( let left = self.ast.simple_assignment_target_identifier(
self.ast.simple_assignment_target_identifier( property_ident.clone(),
property_ident.clone(),
),
); );
let right = self.ast.copy(&computed_expr.expression); let right = self.ast.copy(&computed_expr.expression);
expr.expression = expr.expression =
@ -196,7 +191,6 @@ impl<'a> LogicalAssignmentOperators<'a> {
}; };
let assign_op = AssignmentOperator::Assign; 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.move_expression(&mut assignment_expr.right);
let right = self.ast.assignment_expression(SPAN, assign_op, assign_target, right); let right = self.ast.assignment_expression(SPAN, assign_op, assign_target, right);

32
crates/oxc_transformer/src/proposals/decorators.rs
View file

@ -224,12 +224,10 @@ impl<'a> Decorators<'a> {
{ {
// insert _classDecs = decorators; // insert _classDecs = decorators;
let left = AssignmentTarget::SimpleAssignmentTarget( let left = self.ast.simple_assignment_target_identifier(IdentifierReference::new(
self.ast.simple_assignment_target_identifier(IdentifierReference::new( SPAN,
SPAN, class_decs_name.clone(),
class_decs_name.clone(), ));
)),
);
let right = let right =
self.ast.array_expression( self.ast.array_expression(
@ -296,19 +294,15 @@ impl<'a> Decorators<'a> {
let mut elements = self.ast.new_vec(); let mut elements = self.ast.new_vec();
elements.push(Some(AssignmentTargetMaybeDefault::AssignmentTarget( elements.push(Some(AssignmentTargetMaybeDefault::AssignmentTarget(
AssignmentTarget::SimpleAssignmentTarget( self.ast.simple_assignment_target_identifier(IdentifierReference::new(
self.ast.simple_assignment_target_identifier(IdentifierReference::new( SPAN, class_name,
SPAN, class_name, )),
)),
),
))); )));
elements.push(Some(AssignmentTargetMaybeDefault::AssignmentTarget( elements.push(Some(AssignmentTargetMaybeDefault::AssignmentTarget(
AssignmentTarget::SimpleAssignmentTarget( self.ast.simple_assignment_target_identifier(IdentifierReference::new(
self.ast.simple_assignment_target_identifier(IdentifierReference::new( SPAN,
SPAN, init_class_name.clone(),
init_class_name.clone(), )),
)),
),
))); )));
let left = self let left = self
.ast .ast
@ -364,9 +358,7 @@ impl<'a> Decorators<'a> {
self.top_statements self.top_statements
.push(Statement::Declaration(Declaration::VariableDeclaration(decl))); .push(Statement::Declaration(Declaration::VariableDeclaration(decl)));
let left = AssignmentTarget::SimpleAssignmentTarget( let left = self.ast.simple_assignment_target_identifier(class_identifier.clone());
self.ast.simple_assignment_target_identifier(class_identifier.clone()),
);
let right = self.ast.class_expression(self.ast.copy(class)); let right = self.ast.class_expression(self.ast.copy(class));
let new_expr = let new_expr =
self.ast.assignment_expression(SPAN, AssignmentOperator::Assign, left, right); self.ast.assignment_expression(SPAN, AssignmentOperator::Assign, left, right);

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

@ -390,9 +390,7 @@ impl<'a> TypeScript<'a> {
self.ast.computed_member(SPAN, obj, expr, false) self.ast.computed_member(SPAN, obj, expr, false)
}; };
let left = AssignmentTarget::SimpleAssignmentTarget( let left = self.ast.simple_assignment_target_member_expression(member_expr);
self.ast.simple_assignment_target_member_expression(member_expr),
);
let mut expr = let mut expr =
self.ast.assignment_expression(SPAN, AssignmentOperator::Assign, left, init); self.ast.assignment_expression(SPAN, AssignmentOperator::Assign, left, init);
@ -405,9 +403,7 @@ impl<'a> TypeScript<'a> {
)); ));
self.ast.computed_member(SPAN, obj, expr, false) self.ast.computed_member(SPAN, obj, expr, false)
}; };
let left = AssignmentTarget::SimpleAssignmentTarget( let left = self.ast.simple_assignment_target_member_expression(member_expr);
self.ast.simple_assignment_target_member_expression(member_expr),
);
let right = self let right = self
.ast .ast
.literal_string_expression(StringLiteral::new(SPAN, member_name.clone())); .literal_string_expression(StringLiteral::new(SPAN, member_name.clone()));
@ -741,12 +737,10 @@ impl<'a> TypeScript<'a> {
let arguments = { let arguments = {
let right = { let right = {
let left = AssignmentTarget::SimpleAssignmentTarget( let left = self.ast.simple_assignment_target_identifier(IdentifierReference::new(
self.ast.simple_assignment_target_identifier(IdentifierReference::new( SPAN,
SPAN, name.clone(),
name.clone(), ));
)),
);
let right = self.ast.object_expression(SPAN, self.ast.new_vec(), None); let right = self.ast.object_expression(SPAN, self.ast.new_vec(), None);
self.ast.parenthesized_expression( self.ast.parenthesized_expression(
SPAN, SPAN,