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

refactor(transformer/react-refresh): shorten code by using BoundIdentifier (#6815)

Browse source 
Pure refactor. Use `BoundIdentifier` for shorter code.
This commit is contained in:
overlookmotel 2024-10-23 13:26:22 +00:00
parent ce1d8cf20b
commit 8316069e7d
1 changed files with 28 additions and 65 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

93
crates/oxc_transformer/src/react/refresh.rs
View file

@ -9,7 +9,7 @@ use oxc_ast::{ast::*, match_expression, AstBuilder, NONE};
use oxc_semantic::{Reference, ReferenceFlags, ScopeFlags, ScopeId, SymbolFlags, SymbolId}; use oxc_semantic::{Reference, ReferenceFlags, ScopeFlags, ScopeId, SymbolFlags, SymbolId};
use oxc_span::{Atom, GetSpan, SPAN}; use oxc_span::{Atom, GetSpan, SPAN};
use oxc_syntax::operator::AssignmentOperator; use oxc_syntax::operator::AssignmentOperator;
use oxc_traverse::{Ancestor, Traverse, TraverseCtx}; use oxc_traverse::{Ancestor, BoundIdentifier, Traverse, TraverseCtx};
use crate::TransformCtx; use crate::TransformCtx;
@ -156,29 +156,18 @@ impl<'a, 'ctx> Traverse<'a> for ReactRefresh<'a, 'ctx> {
let mut new_statements = ctx.ast.vec_with_capacity(self.registrations.len() + 1); let mut new_statements = ctx.ast.vec_with_capacity(self.registrations.len() + 1);
for (symbol_id, persistent_id) in self.registrations.drain(..) { for (symbol_id, persistent_id) in self.registrations.drain(..) {
let name = ctx.ast.atom(ctx.symbols().get_name(symbol_id)); let name = ctx.ast.atom(ctx.symbols().get_name(symbol_id));
let binding_identifier = let binding = BoundIdentifier::new(name, symbol_id);
ctx.ast.binding_identifier_with_symbol_id(SPAN, name, symbol_id); variable_declarator_items.push(ctx.ast.variable_declarator(
variable_declarator_items.push( SPAN,
ctx.ast.variable_declarator( VariableDeclarationKind::Var,
SPAN, binding.create_binding_pattern(ctx),
VariableDeclarationKind::Var, None,
ctx.ast.binding_pattern( false,
ctx.ast.binding_pattern_kind_from_binding_identifier( ));
binding_identifier.clone(),
),
NONE,
false,
),
None,
false,
),
);
let callee = self.refresh_reg.to_expression(ctx); let callee = self.refresh_reg.to_expression(ctx);
let mut arguments = ctx.ast.vec_with_capacity(2); let mut arguments = ctx.ast.vec_with_capacity(2);
arguments.push(ctx.ast.argument_expression( arguments.push(Argument::from(binding.create_read_expression(ctx)));
Self::create_identifier_reference_from_binding_identifier(&binding_identifier, ctx),
));
arguments.push(ctx.ast.argument_expression( arguments.push(ctx.ast.argument_expression(
ctx.ast.expression_string_literal(SPAN, ctx.ast.atom(&persistent_id)), ctx.ast.expression_string_literal(SPAN, ctx.ast.atom(&persistent_id)),
)); ));
@ -265,6 +254,7 @@ impl<'a, 'ctx> Traverse<'a> for ReactRefresh<'a, 'ctx> {
let Some((binding_identifier, mut arguments)) = signature else { let Some((binding_identifier, mut arguments)) = signature else {
return; return;
}; };
let binding = BoundIdentifier::from_binding_ident(&binding_identifier);
if !matches!(expr, Expression::CallExpression(_)) { if !matches!(expr, Expression::CallExpression(_)) {
if let Ancestor::VariableDeclaratorInit(declarator) = ctx.parent() { if let Ancestor::VariableDeclaratorInit(declarator) = ctx.parent() {
@ -276,31 +266,25 @@ impl<'a, 'ctx> Traverse<'a> for ReactRefresh<'a, 'ctx> {
// Result: let Foo = () => {}; __signature(Foo, ...); // Result: let Foo = () => {}; __signature(Foo, ...);
let id = declarator.id().get_binding_identifier().unwrap(); let id = declarator.id().get_binding_identifier().unwrap();
let symbol_id = id.symbol_id.get().unwrap(); let id_binding = BoundIdentifier::from_binding_ident(id);
let first_argument = Argument::from(ctx.ast.expression_from_identifier_reference(
ctx.create_bound_reference_id( let first_argument = Argument::from(id_binding.create_read_expression(ctx));
SPAN,
id.name.clone(),
symbol_id,
ReferenceFlags::Read,
),
));
arguments.insert(0, first_argument); arguments.insert(0, first_argument);
let statement = ctx.ast.statement_expression( let statement = ctx.ast.statement_expression(
SPAN, SPAN,
ctx.ast.expression_call( ctx.ast.expression_call(
SPAN, SPAN,
Self::create_identifier_reference_from_binding_identifier( binding.create_read_expression(ctx),
&binding_identifier,
ctx,
),
NONE, NONE,
arguments, arguments,
false, false,
), ),
); );
self.extra_statements.entry(symbol_id).or_insert(ctx.ast.vec()).push(statement); self.extra_statements
.entry(id_binding.symbol_id)
.or_insert(ctx.ast.vec())
.push(statement);
return; return;
} }
} }
@ -324,7 +308,7 @@ impl<'a, 'ctx> Traverse<'a> for ReactRefresh<'a, 'ctx> {
arguments.insert(0, Argument::from(ctx.ast.move_expression(expr))); arguments.insert(0, Argument::from(ctx.ast.move_expression(expr)));
*expr = ctx.ast.expression_call( *expr = ctx.ast.expression_call(
SPAN, SPAN,
Self::create_identifier_reference_from_binding_identifier(&binding_identifier, ctx), binding.create_read_expression(ctx),
NONE, NONE,
arguments, arguments,
false, false,
@ -347,21 +331,17 @@ impl<'a, 'ctx> Traverse<'a> for ReactRefresh<'a, 'ctx> {
let Some(id) = func.id.as_ref() else { let Some(id) = func.id.as_ref() else {
return; return;
}; };
let id_binding = BoundIdentifier::from_binding_ident(id);
arguments.insert( arguments.insert(0, Argument::from(id_binding.create_read_expression(ctx)));
0,
Argument::from(Self::create_identifier_reference_from_binding_identifier(id, ctx)),
);
self.extra_statements.entry(id.symbol_id.get().unwrap()).or_insert(ctx.ast.vec()).push( let binding = BoundIdentifier::from_binding_ident(&binding_identifier);
self.extra_statements.entry(id_binding.symbol_id).or_insert(ctx.ast.vec()).push(
ctx.ast.statement_expression( ctx.ast.statement_expression(
SPAN, SPAN,
ctx.ast.expression_call( ctx.ast.expression_call(
SPAN, SPAN,
Self::create_identifier_reference_from_binding_identifier( binding.create_read_expression(ctx),
&binding_identifier,
ctx,
),
NONE, NONE,
arguments, arguments,
false, false,
@ -564,19 +544,6 @@ impl<'a, 'ctx> ReactRefresh<'a, 'ctx> {
true true
} }
/// Create an identifier reference from a binding identifier.
fn create_identifier_reference_from_binding_identifier(
id: &BindingIdentifier<'a>,
ctx: &mut TraverseCtx<'a>,
) -> Expression<'a> {
ctx.ast.expression_from_identifier_reference(ctx.create_bound_reference_id(
SPAN,
id.name.clone(),
id.symbol_id.get().unwrap(),
ReferenceFlags::Read,
))
}
/// _c = id.name; /// _c = id.name;
fn create_assignment_expression( fn create_assignment_expression(
&mut self, &mut self,
@ -684,14 +651,13 @@ impl<'a, 'ctx> ReactRefresh<'a, 'ctx> {
.unwrap_or_else(|| ctx.current_scope_id()); .unwrap_or_else(|| ctx.current_scope_id());
let binding = ctx.generate_uid("s", target_scope_id, SymbolFlags::FunctionScopedVariable); let binding = ctx.generate_uid("s", target_scope_id, SymbolFlags::FunctionScopedVariable);
let binding_identifier = binding.create_binding_identifier(ctx);
// _s(); // _s();
let call_expression = ctx.ast.statement_expression( let call_expression = ctx.ast.statement_expression(
SPAN, SPAN,
ctx.ast.expression_call( ctx.ast.expression_call(
SPAN, SPAN,
Self::create_identifier_reference_from_binding_identifier(&binding_identifier, ctx), binding.create_read_expression(ctx),
NONE, NONE,
ctx.ast.vec(), ctx.ast.vec(),
false, false,
@ -704,11 +670,7 @@ impl<'a, 'ctx> ReactRefresh<'a, 'ctx> {
self.signature_declarator_items.last_mut().unwrap().push(ctx.ast.variable_declarator( self.signature_declarator_items.last_mut().unwrap().push(ctx.ast.variable_declarator(
SPAN, SPAN,
VariableDeclarationKind::Var, VariableDeclarationKind::Var,
ctx.ast.binding_pattern( binding.create_binding_pattern(ctx),
ctx.ast.binding_pattern_kind_from_binding_identifier(binding_identifier.clone()),
NONE,
false,
),
Some(ctx.ast.expression_call( Some(ctx.ast.expression_call(
SPAN, SPAN,
self.refresh_sig.to_expression(ctx), self.refresh_sig.to_expression(ctx),
@ -722,6 +684,7 @@ impl<'a, 'ctx> ReactRefresh<'a, 'ctx> {
// Following is the signature call expression, will be generated in call site. // Following is the signature call expression, will be generated in call site.
// _s(App, signature_key, false, function() { return [] }); // _s(App, signature_key, false, function() { return [] });
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ custom hooks only // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ custom hooks only
let binding_identifier = binding.create_binding_identifier(ctx);
Some((binding_identifier, arguments)) Some((binding_identifier, arguments))
} }