refactor(transformer): HelperLoader common transform: reorder methods

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<RefCell<LoadedHelper<'a>>>,
 }
 
+// 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);
+        });
+    }
+}