fix(es/jest): Hoisting vars with names starting with mock (#10410)

CodeMan62 · web-flow · commit a29eb2973365 · 2025-04-29T19:45:48.000-07:00
**Description:** When using jest.mock() in conjunction with variables whose names start with "mock", these variables are not correctly hoisted. This results in unexpected behavior during testing, as the mock variables are not available as expected.So this PR tries to fixes that Fixes #9552
diff --git a/.changeset/olive-feet-flow.md b/.changeset/olive-feet-flow.md
@@ -0,0 +1,6 @@
+---
+swc_core: patch
+swc_ecma_ext_transforms: patch
+---
+
+fix: Hoisting issue for variables with names starting with mock
diff --git a/crates/swc_ecma_ext_transforms/src/jest.rs b/crates/swc_ecma_ext_transforms/src/jest.rs
@@ -19,40 +19,74 @@ pub fn jest() -> impl Pass {
 #[derive(Default)]
 struct Jest {
     imported: Vec<Id>,
+    mock_vars: Vec<Id>,
 }
 
 impl Jest {
     fn visit_mut_stmt_like<T>(&mut self, orig: &mut Vec<T>)
     where
         T: StmtLike + VisitMutWith<Self>,
     {
+        // First pass to collect mock variable declarations
         for item in &mut *orig {
+            // Check for declarations with identifiers starting with "mock"
+            if let Some(Stmt::Decl(Decl::Var(var_decl))) = item.as_stmt() {
+                for decl in &var_decl.decls {
+                    if let Pat::Ident(ident) = &decl.name {
+                        let name = &*ident.id.sym;
+                        if name.starts_with("mock") {
+                            self.mock_vars.push(ident.id.to_id());
+                        }
+                    }
+                }
+            }
+
+            // Standard visitation
             item.visit_mut_with(self);
         }
 
         let items = orig.take();
 
         let mut new = Vec::with_capacity(items.len());
         let mut hoisted = Vec::with_capacity(8);
+
         items.into_iter().for_each(|item| {
             match item.try_into_stmt() {
-                Ok(stmt) => match &stmt {
-                    Stmt::Expr(ExprStmt { expr, .. }) => match &**expr {
-                        Expr::Call(CallExpr {
+                Ok(stmt) => {
+                    // Check for mock variable declarations to hoist
+                    if let Stmt::Decl(Decl::Var(var_decl)) = &stmt {
+                        let mut should_hoist = false;
+                        for decl in &var_decl.decls {
+                            if let Pat::Ident(ident) = &decl.name {
+                                if self.mock_vars.iter().any(|id| *id == ident.id.to_id()) {
+                                    should_hoist = true;
+                                    break;
+                                }
+                            }
+                        }
+
+                        if should_hoist {
+                            hoisted.push(T::from(stmt));
+                            return;
+                        }
+                    }
+
+                    // Check for jest calls to hoist
+                    if let Stmt::Expr(ExprStmt { expr, .. }) = &stmt {
+                        if let Expr::Call(CallExpr {
                             callee: Callee::Expr(callee),
                             ..
-                        }) => {
+                        }) = &**expr
+                        {
                             if self.should_hoist(callee) {
-                                hoisted.push(T::from(stmt))
-                            } else {
-                                new.push(T::from(stmt))
+                                hoisted.push(T::from(stmt));
+                                return;
                             }
                         }
-                        _ => new.push(T::from(stmt)),
-                    },
+                    }
 
-                    _ => new.push(T::from(stmt)),
-                },
+                    new.push(T::from(stmt));
+                }
                 Err(node) => new.push(node),
             };
         });
@@ -82,6 +116,7 @@ impl VisitMut for Jest {
     noop_visit_mut_type!();
 
     fn visit_mut_module_items(&mut self, items: &mut Vec<ModuleItem>) {
+        // First collect imported jest methods
         for item in items.iter() {
             if let ModuleItem::ModuleDecl(ModuleDecl::Import(ImportDecl {
                 specifiers, src, ..
@@ -118,6 +153,7 @@ impl VisitMut for Jest {
             }
         }
 
+        // Now process and hoist as needed
         self.visit_mut_stmt_like(items)
     }
 
