From e0c07e1d517b7d57c1844cc4c2801419013a8f13 Mon Sep 17 00:00:00 2001 From: Dunqing Date: Mon, 19 Aug 2024 11:17:40 +0800 Subject: [PATCH] refactor(transformer/nullish-coalescing-operator): move all entry points to implementation of Traverse trait --- crates/oxc_transformer/src/es2020/mod.rs | 16 +++--- .../src/es2020/nullish_coalescing_operator.rs | 56 +++++++++---------- crates/oxc_transformer/src/lib.rs | 6 +- 3 files changed, 39 insertions(+), 39 deletions(-) diff --git a/crates/oxc_transformer/src/es2020/mod.rs b/crates/oxc_transformer/src/es2020/mod.rs index bcf94cfd6e238..d541a4f8fa117 100644 --- a/crates/oxc_transformer/src/es2020/mod.rs +++ b/crates/oxc_transformer/src/es2020/mod.rs @@ -5,7 +5,7 @@ pub use nullish_coalescing_operator::NullishCoalescingOperator; pub use options::ES2020Options; use oxc_allocator::Vec; use oxc_ast::ast::*; -use oxc_traverse::TraverseCtx; +use oxc_traverse::{Traverse, TraverseCtx}; use std::rc::Rc; use crate::context::Ctx; @@ -27,30 +27,32 @@ impl<'a> ES2020<'a> { options, } } +} - pub fn transform_statements( +impl<'a> Traverse<'a> for ES2020<'a> { + fn enter_statements( &mut self, statements: &mut Vec<'a, Statement<'a>>, ctx: &mut TraverseCtx<'a>, ) { if self.options.nullish_coalescing_operator { - self.nullish_coalescing_operator.transform_statements(statements, ctx); + self.nullish_coalescing_operator.enter_statements(statements, ctx); } } - pub fn transform_statements_on_exit( + fn exit_statements( &mut self, statements: &mut Vec<'a, Statement<'a>>, ctx: &mut TraverseCtx<'a>, ) { if self.options.nullish_coalescing_operator { - self.nullish_coalescing_operator.transform_statements_on_exit(statements, ctx); + self.nullish_coalescing_operator.exit_statements(statements, ctx); } } - pub fn transform_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) { + fn enter_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) { if self.options.nullish_coalescing_operator { - self.nullish_coalescing_operator.transform_expression(expr, ctx); + self.nullish_coalescing_operator.enter_expression(expr, ctx); } } } diff --git a/crates/oxc_transformer/src/es2020/nullish_coalescing_operator.rs b/crates/oxc_transformer/src/es2020/nullish_coalescing_operator.rs index 9f90930d241ce..697d68850585d 100644 --- a/crates/oxc_transformer/src/es2020/nullish_coalescing_operator.rs +++ b/crates/oxc_transformer/src/es2020/nullish_coalescing_operator.rs @@ -26,7 +26,7 @@ use std::cell::Cell; use oxc_semantic::{ReferenceFlag, SymbolFlags}; -use oxc_traverse::TraverseCtx; +use oxc_traverse::{Traverse, TraverseCtx}; use oxc_allocator::{CloneIn, Vec}; use oxc_ast::ast::*; @@ -64,33 +64,6 @@ impl<'a> NullishCoalescingOperator<'a> { } } - pub fn transform_statements( - &mut self, - _statements: &mut Vec<'a, Statement<'a>>, - ctx: &mut TraverseCtx<'a>, - ) { - self.var_declarations.push(ctx.ast.vec()); - } - - pub fn transform_statements_on_exit( - &mut self, - statements: &mut Vec<'a, Statement<'a>>, - ctx: &mut TraverseCtx<'a>, - ) { - if let Some(declarations) = self.var_declarations.pop() { - if declarations.is_empty() { - return; - } - let variable = ctx.ast.alloc_variable_declaration( - SPAN, - VariableDeclarationKind::Var, - declarations, - false, - ); - statements.insert(0, Statement::VariableDeclaration(variable)); - } - } - fn create_new_var_with_expression( &mut self, expr: &Expression<'a>, @@ -125,8 +98,33 @@ impl<'a> NullishCoalescingOperator<'a> { ctx.create_reference_id(SPAN, symbol_name, Some(symbol_id), ReferenceFlag::Read) } +} + +impl<'a> Traverse<'a> for NullishCoalescingOperator<'a> { + fn enter_statements(&mut self, _stmts: &mut Vec<'a, Statement<'a>>, ctx: &mut TraverseCtx<'a>) { + self.var_declarations.push(ctx.ast.vec()); + } + + fn exit_statements( + &mut self, + statements: &mut Vec<'a, Statement<'a>>, + ctx: &mut TraverseCtx<'a>, + ) { + if let Some(declarations) = self.var_declarations.pop() { + if declarations.is_empty() { + return; + } + let variable = ctx.ast.alloc_variable_declaration( + SPAN, + VariableDeclarationKind::Var, + declarations, + false, + ); + statements.insert(0, Statement::VariableDeclaration(variable)); + } + } - pub fn transform_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) { + fn enter_expression(&mut self, expr: &mut Expression<'a>, ctx: &mut TraverseCtx<'a>) { // left ?? right if !matches!(expr, Expression::LogicalExpression(logical_expr) if logical_expr.operator == LogicalOperator::Coalesce) { diff --git a/crates/oxc_transformer/src/lib.rs b/crates/oxc_transformer/src/lib.rs index 5709cfb79ac00..a7eeced14f4dc 100644 --- a/crates/oxc_transformer/src/lib.rs +++ b/crates/oxc_transformer/src/lib.rs @@ -178,7 +178,7 @@ impl<'a> Traverse<'a> for Transformer<'a> { self.x0_typescript.transform_expression(expr); self.x1_react.transform_expression(expr, ctx); self.x2_es2021.transform_expression(expr, ctx); - self.x2_es2020.transform_expression(expr, ctx); + self.x2_es2020.enter_expression(expr, ctx); self.x2_es2016.transform_expression(expr, ctx); self.x3_es2015.transform_expression(expr); } @@ -269,7 +269,7 @@ impl<'a> Traverse<'a> for Transformer<'a> { self.x0_typescript.transform_statements(stmts); self.x1_react.transform_statements(stmts, ctx); self.x2_es2021.transform_statements(stmts, ctx); - self.x2_es2020.transform_statements(stmts, ctx); + self.x2_es2020.enter_statements(stmts, ctx); self.x2_es2016.transform_statements(stmts, ctx); self.x3_es2015.enter_statements(stmts); } @@ -278,7 +278,7 @@ impl<'a> Traverse<'a> for Transformer<'a> { self.x0_typescript.transform_statements_on_exit(stmts, ctx); self.x1_react.transform_statements_on_exit(stmts, ctx); self.x2_es2021.transform_statements_on_exit(stmts, ctx); - self.x2_es2020.transform_statements_on_exit(stmts, ctx); + self.x2_es2020.exit_statements(stmts, ctx); self.x2_es2016.transform_statements_on_exit(stmts, ctx); self.x3_es2015.exit_statements(stmts); }