From 4da9814da41463e09605c74a778bb4461e2c88c6 Mon Sep 17 00:00:00 2001 From: overlookmotel Date: Mon, 14 Oct 2024 20:46:37 +0100 Subject: [PATCH] refactor(transformer): `HelperLoader` common transform: reorder methods --- .../src/common/helper_loader.rs | 120 +++++++++--------- 1 file changed, 61 insertions(+), 59 deletions(-) diff --git a/crates/oxc_transformer/src/common/helper_loader.rs b/crates/oxc_transformer/src/common/helper_loader.rs index 31afa1e009358f..42e4c053e8c522 100644 --- a/crates/oxc_transformer/src/common/helper_loader.rs +++ b/crates/oxc_transformer/src/common/helper_loader.rs @@ -134,24 +134,15 @@ pub struct HelperLoader<'a, 'ctx> { ctx: &'ctx TransformCtx<'a>, } -impl<'a, 'ctx> Traverse<'a> for HelperLoader<'a, 'ctx> { - fn exit_program(&mut self, _program: &mut Program<'a>, _ctx: &mut TraverseCtx<'a>) { - self.add_imports(); - } -} - impl<'a, 'ctx> HelperLoader<'a, 'ctx> { pub fn new(ctx: &'ctx TransformCtx<'a>) -> Self { Self { ctx } } +} - /// By [`TransformCtx::module_imports`] to indirectly insert imports into the program. - fn add_imports(&self) { - self.ctx.helper_loader.loaded_helpers.borrow_mut().drain().for_each( - |(_, (source, import))| { - self.ctx.module_imports.add_default_import(source, import, false); - }, - ); +impl<'a, 'ctx> Traverse<'a> for HelperLoader<'a, 'ctx> { + fn exit_program(&mut self, _program: &mut Program<'a>, _ctx: &mut TraverseCtx<'a>) { + self.ctx.helper_loader.add_imports(self.ctx); } } @@ -168,6 +159,7 @@ pub struct HelperLoaderStore<'a> { loaded_helpers: Rc>>, } +// Public methods impl<'a> HelperLoaderStore<'a> { pub fn new(options: &HelperLoaderOptions) -> Self { Self { @@ -178,50 +170,8 @@ impl<'a> HelperLoaderStore<'a> { } } - fn add_default_import(&self, helper_name: Atom<'a>, ctx: &mut TraverseCtx<'a>) { - let source = ctx.ast.atom(&format!("{}/helpers/{helper_name}", self.module_name)); - let bound_ident = ctx.generate_uid_in_root_scope(&helper_name, SymbolFlags::Import); - self.loaded_helpers.borrow_mut().insert(helper_name, (source, bound_ident)); - } - - fn transform_for_runtime_helper( - &self, - helper_name: &Atom<'a>, - ctx: &mut TraverseCtx<'a>, - ) -> Expression<'a> { - if !self.loaded_helpers.borrow().contains_key(helper_name) { - self.add_default_import(helper_name.clone(), ctx); - } - let bound_ident = self.loaded_helpers.borrow_mut()[helper_name].1.clone(); - let ident = bound_ident.create_read_reference(ctx); - ctx.ast.expression_from_identifier_reference(ident) - } - - fn transform_for_external_helper( - &self, - helper_name: Atom<'a>, - ctx: &mut TraverseCtx<'a>, - ) -> Expression<'a> { - let symbol_id = self.babel_helpers_symbol_id.get().or_else(|| { - let symbol_id = ctx.scopes().get_root_binding("babelHelpers"); - self.babel_helpers_symbol_id.set(symbol_id); - symbol_id - }); - - let ident = ctx.create_reference_id( - SPAN, - Atom::from("babelHelpers"), - symbol_id, - ReferenceFlags::Read, - ); - - let object = ctx.ast.expression_from_identifier_reference(ident); - let property = ctx.ast.identifier_name(SPAN, helper_name); - Expression::from(ctx.ast.member_expression_static(SPAN, object, property, false)) - } - - /// Load and call a helper function and return the CallExpression. - #[allow(dead_code)] + /// Load and call a helper function and return the `CallExpression`. + #[expect(dead_code)] pub fn call( &mut self, helper_name: Atom<'a>, @@ -238,8 +188,8 @@ impl<'a> HelperLoaderStore<'a> { ) } - /// Same as [`HelperLoaderStore::call`], but returns a CallExpression that is wrapped by Expression. - #[allow(dead_code)] + /// Same as [`HelperLoaderStore::call`], but returns a `CallExpression` wrapped in an `Expression`. + #[expect(dead_code)] pub fn call_expr( &mut self, helper_name: Atom<'a>, @@ -267,3 +217,55 @@ impl<'a> HelperLoaderStore<'a> { } } } + +// Internal methods +impl<'a> HelperLoaderStore<'a> { + fn transform_for_runtime_helper( + &self, + helper_name: &Atom<'a>, + ctx: &mut TraverseCtx<'a>, + ) -> Expression<'a> { + if !self.loaded_helpers.borrow().contains_key(helper_name) { + self.add_default_import(helper_name.clone(), ctx); + } + let bound_ident = self.loaded_helpers.borrow_mut()[helper_name].1.clone(); + let ident = bound_ident.create_read_reference(ctx); + ctx.ast.expression_from_identifier_reference(ident) + } + + fn transform_for_external_helper( + &self, + helper_name: Atom<'a>, + ctx: &mut TraverseCtx<'a>, + ) -> Expression<'a> { + let symbol_id = self.babel_helpers_symbol_id.get().or_else(|| { + let symbol_id = ctx.scopes().get_root_binding("babelHelpers"); + self.babel_helpers_symbol_id.set(symbol_id); + symbol_id + }); + + let ident = ctx.create_reference_id( + SPAN, + Atom::from("babelHelpers"), + symbol_id, + ReferenceFlags::Read, + ); + + let object = ctx.ast.expression_from_identifier_reference(ident); + let property = ctx.ast.identifier_name(SPAN, helper_name); + Expression::from(ctx.ast.member_expression_static(SPAN, object, property, false)) + } + + fn add_default_import(&self, helper_name: Atom<'a>, ctx: &mut TraverseCtx<'a>) { + let source = ctx.ast.atom(&format!("{}/helpers/{helper_name}", self.module_name)); + let bound_ident = ctx.generate_uid_in_root_scope(&helper_name, SymbolFlags::Import); + self.loaded_helpers.borrow_mut().insert(helper_name, (source, bound_ident)); + } + + fn add_imports(&self, transform_ctx: &TransformCtx<'a>) { + let mut loaded_helpers = self.loaded_helpers.borrow_mut(); + loaded_helpers.drain().for_each(|(_, (source, import))| { + transform_ctx.module_imports.add_default_import(source, import, false); + }); + } +}