refactor(transformer): HelperLoader common transform: use hashmap `…

…Entry` API

crates/oxc_transformer/src/common/helper_loader.rs

@@ -208,7 +208,7 @@ impl<'a> HelperLoaderStore<'a> {
     /// Load a helper function and return the callee expression.
     pub fn load(&self, helper_name: Atom<'a>, ctx: &mut TraverseCtx<'a>) -> Expression<'a> {
         match self.mode {
-            HelperLoaderMode::Runtime => self.transform_for_runtime_helper(&helper_name, ctx),
+            HelperLoaderMode::Runtime => self.transform_for_runtime_helper(helper_name, ctx),
             HelperLoaderMode::External => self.transform_for_external_helper(helper_name, ctx),
             HelperLoaderMode::Inline => {
                 unreachable!("Inline helpers are not supported yet");
@@ -221,15 +221,16 @@ impl<'a> HelperLoaderStore<'a> {
 impl<'a> HelperLoaderStore<'a> {
     fn transform_for_runtime_helper(
         &self,
-        helper_name: &Atom<'a>,
+        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)
+        let mut loaded_helpers = self.loaded_helpers.borrow_mut();
+        let (_, binding) = loaded_helpers.entry(helper_name).or_insert_with_key(|helper_name| {
+            let source = ctx.ast.atom(&format!("{}/helpers/{helper_name}", self.module_name));
+            let binding = ctx.generate_uid_in_root_scope(helper_name, SymbolFlags::Import);
+            (source, binding)
+        });
+        binding.create_read_expression(ctx)
     }
 
     fn transform_for_external_helper(
@@ -255,12 +256,6 @@ impl<'a> HelperLoaderStore<'a> {
         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))| {