eslint-plugin-no-mistakes 0.31.7 → 0.32.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-no-mistakes",
-  "version": "0.31.7",
+  "version": "0.32.0",
   "description": "ESLint and Oxlint rules for deterministic no-mistakes code analysis",
   "license": "MIT",
   "repository": {
@@ -21,10 +21,10 @@
     "test": "vitest run --coverage"
   },
   "devDependencies": {
-    "@typescript-eslint/parser": "^8.62.0",
-    "@vitest/coverage-v8": "^4.1.9",
+    "@typescript-eslint/parser": "^8.62.1",
+    "@vitest/coverage-v8": "^4.1.10",
     "eslint": "^10.6.0",
-    "oxlint": "^1.71.0",
+    "oxlint": "^1.72.0",
     "vitest": "^4.1.6"
   },
   "peerDependencies": {

package/src/rules/module-mock-boundary.js

@@ -5,17 +5,14 @@ const { baselineKey, baselineMap } = require("./module-mock-baseline");
 const { matchDirectMockCallApply } = require("./module-mock-call-apply");
 const { integrationAllows } = require("./module-mock-integration");
 const {
-  collectPatternNames,
   importSpecifierName,
-  isFrameworkBinding,
   isInternalSpecifier,
   isModuleMockMemberCall,
-  memberPropertyName,
   moduleMockSpecifierArgument,
   pathAllowed,
-  propertyName,
   repoRelativeFilename,
 } = require("./module-mock-helpers");
+const { createMockAliases } = require("./module-mock-preserve-aliases");
 
 const MODULE_MOCK_METHODS = new Set([
   "doMock",
@@ -54,16 +51,6 @@ function reportMessage(dynamic, specifier) {
   return `Module mock boundary does not allow mocking internal module "${specifier}".`;
 }
 
-function resolveVariable(node, context) {
-  let scope = context.sourceCode.getScope(node);
-  while (scope) {
-    const variable = scope.variables.find((candidate) => candidate.name === node.name);
-    if (variable) return variable;
-    scope = scope.upper;
-  }
-  return null;
-}
-
 module.exports = rule(
   {
     type: "problem",
@@ -81,42 +68,12 @@ module.exports = rule(
     const options = context.options?.[0] ?? {};
     const filename = context.filename;
     const tracker = createBaselineTracker(filename, options.baseline);
-    const mockAliases = new Map();
+    const mockAliases = createMockAliases(context, MODULE_MOCK_METHODS);
     if (!pathAllowed(filename, options)) return {};
 
-    function declareAlias(id, init) {
-      if (!id || !init) return;
-      if (id.type === "ObjectPattern" && isFrameworkBinding(init, context)) {
-        for (const property of id.properties) {
-          if (property.type !== "Property") continue;
-          const method = propertyName(property.key);
-          if (MODULE_MOCK_METHODS.has(method)) {
-            for (const name of collectPatternNames(property.value)) {
-              mockAliases.set(name, resolveVariable(property.value, context));
-            }
-          }
-        }
-        return;
-      }
-      if (
-        init.type === "MemberExpression" &&
-        memberPropertyName(init) &&
-        MODULE_MOCK_METHODS.has(memberPropertyName(init)) &&
-        isFrameworkBinding(init.object, context)
-      ) {
-        for (const name of collectPatternNames(id))
-          mockAliases.set(name, resolveVariable(id, context));
-      }
-    }
-
-    function isUnshadowedMockAlias(node) {
-      return (
-        node.type === "Identifier" && mockAliases.get(node.name) === resolveVariable(node, context)
-      );
-    }
-
     function reportIfDisallowed(
       node,
+      mock,
       specifierNode = node.arguments[0],
       factory = node.arguments[1],
     ) {
@@ -127,7 +84,7 @@ module.exports = rule(
         return;
       }
       if (!specifier || !isInternalSpecifier(specifier, options)) return;
-      if (integrationAllows(specifier, factory, options)) return;
+      if (integrationAllows(specifier, factory, mock, context, options)) return;
       if (tracker.allowed(specifier)) return;
       context.report({
         node,
@@ -141,54 +98,32 @@ module.exports = rule(
         if (node.source.value !== "vitest" && node.source.value !== "@jest/globals") return;
         for (const specifier of node.specifiers) {
           if (specifier.type !== "ImportSpecifier") continue;
-          if (MODULE_MOCK_METHODS.has(importSpecifierName(specifier))) {
-            mockAliases.set(specifier.local.name, resolveVariable(specifier.local, context));
-          }
+          mockAliases.declareImport(
+            specifier.local,
+            node.source.value,
+            importSpecifierName(specifier),
+          );
         }
       },
       VariableDeclarator(node) {
-        declareAlias(node.id, node.init);
+        mockAliases.declare(node.id, node.init);
       },
       AssignmentExpression(node) {
-        if (node.operator === "=") declareAlias(node.left, node.right);
+        if (node.operator === "=") mockAliases.declare(node.left, node.right);
       },
       CallExpression(node) {
         const memberMock = isModuleMockMemberCall(node, context);
         if (memberMock && MODULE_MOCK_METHODS.has(memberMock.method)) {
-          reportIfDisallowed(node);
+          reportIfDisallowed(node, memberMock);
           return;
         }
         const directCall = matchDirectMockCallApply(node, context, MODULE_MOCK_METHODS);
         if (directCall) {
-          reportIfDisallowed(node, directCall.specifierNode, directCall.factory);
+          reportIfDisallowed(node, directCall.mock, directCall.specifierNode, directCall.factory);
           return;
         }
-        if (isUnshadowedMockAlias(node.callee)) {
-          reportIfDisallowed(node);
-          return;
-        }
-        if (
-          node.callee.type === "MemberExpression" &&
-          propertyName(node.callee.property) === "call" &&
-          node.callee.object.type === "Identifier" &&
-          isUnshadowedMockAlias(node.callee.object)
-        ) {
-          reportIfDisallowed(node, node.arguments[1], node.arguments[2]);
-          return;
-        }
-        if (
-          node.callee.type === "MemberExpression" &&
-          propertyName(node.callee.property) === "apply" &&
-          node.callee.object.type === "Identifier" &&
-          isUnshadowedMockAlias(node.callee.object)
-        ) {
-          const args = node.arguments[1];
-          reportIfDisallowed(
-            node,
-            args?.type === "ArrayExpression" ? args.elements[0] : undefined,
-            args?.type === "ArrayExpression" ? args.elements[1] : undefined,
-          );
-        }
+        const alias = mockAliases.matchCall(node);
+        if (alias) reportIfDisallowed(node, alias.mock, alias.specifierNode, alias.factory);
       },
       "Program:exit"(node) {
         for (const entry of tracker.stale()) {

package/src/rules/module-mock-call-apply.js

@@ -13,11 +13,12 @@ function matchDirectMockCallApply(node, context, methods) {
   const direct = isModuleMockMemberCall({ callee: node.callee.object }, context);
   if (!direct || !methods.has(direct.method)) return null;
   if (propertyName(node.callee.property) === "call") {
-    return { factory: node.arguments[2], specifierNode: node.arguments[1] };
+    return { factory: node.arguments[2], mock: direct, specifierNode: node.arguments[1] };
   }
   const args = node.arguments[1];
   return {
     factory: args?.type === "ArrayExpression" ? args.elements[1] : undefined,
+    mock: direct,
     specifierNode: args?.type === "ArrayExpression" ? args.elements[0] : undefined,
   };
 }

package/src/rules/module-mock-integration.js

@@ -1,23 +1,29 @@
 "use strict";
 
-const { existsSync, readFileSync } = require("node:fs");
-const { resolve } = require("node:path");
+const { existsSync, readFileSync, statSync } = require("node:fs");
+const { dirname, join, resolve } = require("node:path");
 const { isInternalSpecifier, propertyName } = require("./module-mock-helpers");
+const { analyzeFactory, spreadPreservesRealModule } = require("./module-mock-preserve-factory");
 
-function mockedExportNames(factory) {
+// Matches the repo's documented TS/JS source-extension set (docs/ast-analysis.md
+// "Shared File Model"), so a barrel re-exporting a .tsx/.jsx leaf (e.g. a React
+// component) resolves the same way the rest of the toolchain treats source files.
+const DEFAULT_REEXPORT_EXTENSIONS = [".mts", ".ts", ".tsx", ".mjs", ".js", ".jsx", ".cts", ".cjs"];
+
+function mockedExportNames(factory, specifier, mock, context) {
   if (!factory) return null;
-  const body = unwrapExpression(factory.type === "ObjectExpression" ? factory : factory.body);
-  const objects = [];
-  if (body?.type === "ObjectExpression") objects.push(body);
-  if (body?.type === "BlockStatement") {
-    for (const statement of body.body) collectReturnedObjects(statement, objects);
-  }
+  const analysis = analyzeFactory(factory, specifier, mock, context);
+  const { objects } = analysis;
   if (objects.length === 0) return null;
   if (objects.some((object) => !object)) return null;
   const names = [];
   for (const object of objects) {
     for (const prop of object.properties) {
-      if (prop.type === "SpreadElement" || prop.computed) return null;
+      if (prop.type === "SpreadElement") {
+        if (!spreadPreservesRealModule(prop, analysis, specifier, mock, context)) return null;
+        continue;
+      }
+      if (prop.computed) return null;
       const name = propertyName(prop.key);
       if (name && name !== "__esModule") names.push(name);
     }
@@ -25,42 +31,6 @@ function mockedExportNames(factory) {
   return names.length > 0 ? names : null;
 }
 
-function unwrapExpression(node) {
-  let current = node;
-  while (
-    current?.type === "TSAsExpression" ||
-    current?.type === "TSSatisfiesExpression" ||
-    current?.type === "TSNonNullExpression" ||
-    current?.type === "TypeCastExpression"
-  ) {
-    current = current.expression;
-  }
-  return current;
-}
-
-function collectReturnedObjects(node, objects) {
-  if (
-    node.type === "FunctionDeclaration" ||
-    node.type === "FunctionExpression" ||
-    node.type === "ArrowFunctionExpression"
-  ) {
-    return;
-  }
-  if (node.type === "ReturnStatement") {
-    const argument = unwrapExpression(node.argument);
-    objects.push(argument?.type === "ObjectExpression" ? argument : null);
-    return;
-  }
-  for (const key of ["block", "body", "consequent", "alternate", "finalizer", "handler"]) {
-    const child = node[key];
-    if (Array.isArray(child)) {
-      for (const item of child) collectReturnedObjects(item, objects);
-    } else if (child?.type) {
-      collectReturnedObjects(child, objects);
-    }
-  }
-}
-
 function integrationSourcePath(specifier, config) {
   const patterns = config.sourcePathTemplates ?? [];
   for (const template of patterns) {
@@ -86,40 +56,142 @@ function safeRegExp(source, flags) {
   }
 }
 
-function integrationExportNames(specifier, config) {
-  const path = integrationSourcePath(specifier, config);
-  if (!path) return null;
-  const source = readFileSync(path, "utf8");
+// Built once per `integrationExportNames` call and reused across every file the
+// local re-export graph reaches. Safe to share: `String.prototype.matchAll` clones
+// the regex per call and never mutates the shared `lastIndex`.
+function tagPatterns(config) {
   const marker = config.markerRegex ?? String.raw`/\*\s*no-mistakes:\s*integration=[^*]+\*/`;
-  const names = new Set();
   const declaration = safeRegExp(
     `${marker}\\s*export\\s+(?:async\\s+)?(?:function|const|let|var|class)\\s+([A-Za-z_$][\\w$]*)`,
     "g",
   );
-  if (!declaration) return null;
-  for (const match of source.matchAll(declaration)) names.add(match[1]);
   const defaultDeclaration = safeRegExp(
     `${marker}\\s*export\\s+default\\s+(?:async\\s+)?(?:function|class)\\b`,
     "g",
   );
-  if (!defaultDeclaration) return null;
-  for (const _match of source.matchAll(defaultDeclaration)) names.add("default");
   const named = safeRegExp(`${marker}\\s*export\\s*\\{([^}]+)\\}`, "g");
-  if (!named) return null;
-  for (const match of source.matchAll(named)) {
+  if (!declaration || !defaultDeclaration || !named) return null;
+  return { declaration, defaultDeclaration, named };
+}
+
+// `includeDefault` is false for every file reached via `export *`: ES modules never
+// re-export a target's default binding through a star re-export, only through the
+// root specifier itself or an explicit named re-export.
+function addTaggedNames(source, patterns, names, includeDefault) {
+  for (const match of source.matchAll(patterns.declaration)) names.add(match[1]);
+  if (includeDefault) {
+    for (const _match of source.matchAll(patterns.defaultDeclaration)) names.add("default");
+  }
+  for (const match of source.matchAll(patterns.named)) {
     for (const part of (match[1] ?? "").split(",")) {
       const exported = part
         .trim()
         .split(/\s+as\s+/)
         .pop()
         ?.trim();
+      if (exported === "default" && !includeDefault) continue; // e.g. `export { x as default }`
       if (/^[A-Za-z_$][\w$]*$/.test(exported ?? "")) names.add(exported);
     }
   }
+}
+
+// Only plain `export * from '<specifier>'` re-exports propagate individual runtime
+// export names; `export * as ns from ...` and type-only re-exports are intentionally
+// left unmatched.
+const REEXPORT_ALL = /export\s*\*\s*from\s*['"]([^'"]+)['"]/g;
+
+// Matches whichever comes first at each position: a string/template literal (kept
+// verbatim — it may be a real re-export's own specifier) or a line/block comment
+// (dropped). This keeps a disabled `// export * from './leaf'` line, or the same
+// text inside a `/* ... */` block, from being mistaken for a live barrel edge.
+// A string literal whose *contents* merely spell out re-export-like text (rather
+// than containing an actual disabled statement) is a narrower, accepted heuristic
+// gap — matching the tag-marker scan's own text-based blind spots elsewhere in
+// this file; resolving it would need a real lexer, not a regex pass.
+const COMMENT_OR_STRING =
+  /"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`|\/\/[^\n]*|\/\*[\s\S]*?\*\//g;
+
+function withoutComments(source) {
+  return source.replace(COMMENT_OR_STRING, (match) => (/^['"`]/.test(match) ? match : ""));
+}
+
+// NodeNext/ESM TypeScript projects conventionally write re-export specifiers with
+// the compiled output extension (`./leaf.js`) even though the checked-in source is
+// `./leaf.ts`. Each emitted extension maps to a specific, ordered set of TS/JS
+// source extensions Node/TypeScript actually resolve it from — trying the full
+// configured extension list instead could pick an unrelated sibling (e.g. probing
+// `.mts`, which emits `.mjs`, ahead of `.ts` for a `.js` specifier).
+const REEXPORT_EXTENSION_SOURCES = {
+  ".js": [".ts", ".tsx"],
+  ".jsx": [".tsx"],
+  ".mjs": [".mts"],
+  ".cjs": [".cts"],
+};
+
+// A specifier carrying a recognized compiled extension only ever resolves through
+// its mapped source extensions (see REEXPORT_EXTENSION_SOURCES) — never through
+// the generic "append any configured extension" or directory-index fallbacks below,
+// which correspond to no real resolver behavior for an already-extension-ful path
+// (e.g. `./leaf.js` never resolves to a literal `leaf.js.ts` file or a `leaf.js/`
+// directory).
+function resolveReexportPath(fromPath, specifier, extensions) {
+  const base = resolve(dirname(fromPath), specifier);
+  const compiledExt = Object.keys(REEXPORT_EXTENSION_SOURCES).find((ext) =>
+    specifier.endsWith(ext),
+  );
+  const stem = compiledExt ? base.slice(0, -compiledExt.length) : null;
+  const candidates = compiledExt
+    ? [
+        base,
+        ...REEXPORT_EXTENSION_SOURCES[compiledExt]
+          .filter((ext) => extensions.includes(ext))
+          .map((ext) => stem + ext),
+      ]
+    : [
+        base,
+        ...extensions.map((ext) => base + ext),
+        ...extensions.map((ext) => join(base, `index${ext}`)),
+      ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate) && statSync(candidate).isFile()) return candidate;
+  }
+  return null;
+}
+
+function reexportTargets(source, fromPath, extensions) {
+  const targets = [];
+  for (const match of withoutComments(source).matchAll(REEXPORT_ALL)) {
+    const specifier = match[1];
+    if (!specifier.startsWith(".")) continue; // leave bare-specifier re-exports unresolved
+    const resolved = resolveReexportPath(fromPath, specifier, extensions);
+    if (resolved) targets.push(resolved);
+  }
+  return targets;
+}
+
+function collectTaggedExports(path, extensions, patterns, names, visited, includeDefault) {
+  if (visited.has(path)) return; // guard against re-export cycles
+  visited.add(path);
+  const source = readFileSync(path, "utf8");
+  addTaggedNames(source, patterns, names, includeDefault);
+  for (const target of reexportTargets(source, path, extensions)) {
+    // `export *` never re-exports `default`, at any recursion depth.
+    collectTaggedExports(target, extensions, patterns, names, visited, false);
+  }
+}
+
+function integrationExportNames(specifier, config) {
+  const path = integrationSourcePath(specifier, config);
+  if (!path) return null;
+  const patterns = tagPatterns(config);
+  if (!patterns) return null;
+  const extensions = config.reexportExtensions ?? DEFAULT_REEXPORT_EXTENSIONS;
+  const names = new Set();
+  collectTaggedExports(path, extensions, patterns, names, new Set(), true);
   return names;
 }
 
-function integrationAllows(specifier, factory, options) {
+function integrationAllows(specifier, factory, mock, context, options) {
   const config = options.integrationExports;
   if (!config) return false;
   const specifierPatterns = config.specifiers ?? [];
@@ -129,7 +201,7 @@ function integrationAllows(specifier, factory, options) {
   ) {
     return false;
   }
-  const mocked = mockedExportNames(factory);
+  const mocked = mockedExportNames(factory, specifier, mock, context);
   if (!mocked) return false;
   const allowed = integrationExportNames(specifier, config);
   if (!allowed) return false;

package/src/rules/module-mock-preserve-aliases.js

@@ -9,6 +9,8 @@ const {
   propertyName,
 } = require("./module-mock-helpers");
 
+const PRESERVE_METHODS = new Set(["mock", "doMock", "unstable_mockModule"]);
+
 function resolveVariable(node, context) {
   let scope = context.sourceCode.getScope(node);
   while (scope) {
@@ -34,7 +36,7 @@ function frameworkMock(object, method, context) {
   return { framework, method, namespace: expressionName(object) };
 }
 
-function createPreserveMockAliases(context) {
+function createMockAliases(context, methods) {
   const aliases = new Map();
 
   function record(name, variable, mock) {
@@ -55,9 +57,7 @@ function createPreserveMockAliases(context) {
 
   return {
     declareImport(local, source, imported) {
-      if (imported !== "mock" && imported !== "doMock" && imported !== "unstable_mockModule") {
-        return;
-      }
+      if (!methods.has(imported)) return;
       record(local.name, resolveVariable(local, context), {
         framework: source,
         method: imported,
@@ -70,15 +70,13 @@ function createPreserveMockAliases(context) {
         for (const property of id.properties) {
           if (property.type !== "Property") continue;
           const method = propertyName(property.key);
-          if (method !== "mock" && method !== "doMock" && method !== "unstable_mockModule") {
-            continue;
-          }
+          if (!methods.has(method)) continue;
           recordPattern(property.value, frameworkMock(init, method, context));
         }
       }
       if (init.type === "MemberExpression" && isFrameworkBinding(init.object, context)) {
         const method = memberPropertyName(init);
-        if (method !== "mock" && method !== "doMock" && method !== "unstable_mockModule") return;
+        if (!methods.has(method)) return;
         recordPattern(id, frameworkMock(init.object, method, context));
       }
     },
@@ -114,7 +112,12 @@ function createPreserveMockAliases(context) {
   };
 }
 
+function createPreserveMockAliases(context) {
+  return createMockAliases(context, PRESERVE_METHODS);
+}
+
 module.exports = {
+  createMockAliases,
   createPreserveMockAliases,
   resolveVariable,
 };

package/src/rules/module-mock-preserve-factory.js

@@ -1,12 +1,16 @@
 "use strict";
 
-const { expressionName, literalString, memberPropertyName } = require("./module-mock-helpers");
+const {
+  frameworkBindingModule,
+  literalString,
+  memberPropertyName,
+} = require("./module-mock-helpers");
 const { resolveVariable } = require("./module-mock-preserve-aliases");
 
-function factoryParamName(factory) {
+function factoryParam(factory) {
   const param = factory?.params?.[0];
   const unwrapped = param?.type === "AssignmentPattern" ? param.left : param;
-  return unwrapped?.type === "Identifier" ? unwrapped.name : undefined;
+  return unwrapped?.type === "Identifier" ? unwrapped : null;
 }
 
 function unwrapExpression(node) {
@@ -30,57 +34,61 @@ function isFunctionNode(node) {
   );
 }
 
-function realModuleCall(call, specifier, paramName, mock) {
+function realModuleCall(call, specifier, paramVariable, mock, context) {
   if (call?.type !== "CallExpression") return false;
   if (call.callee.type === "MemberExpression") {
-    const objectName = expressionName(call.callee.object);
+    const framework = frameworkBindingModule(call.callee.object, context);
     const prop = memberPropertyName(call.callee);
     if (literalString(call.arguments[0]) !== specifier) return false;
-    if (prop === "importActual" && mock.framework === "vitest" && objectName === mock.namespace) {
+    if (prop === "importActual" && mock?.framework === "vitest" && framework === "vitest") {
       return "async";
     }
     if (
       prop === "requireActual" &&
-      mock.framework === "@jest/globals" &&
-      objectName === mock.namespace
+      mock?.framework === "@jest/globals" &&
+      framework === "@jest/globals"
     ) {
       return "sync";
     }
     return false;
   }
-  if (call.callee.type === "Identifier" && paramName && call.callee.name === paramName) {
+  if (
+    call.callee.type === "Identifier" &&
+    paramVariable &&
+    resolveVariable(call.callee, context) === paramVariable
+  ) {
     return "async";
   }
   return false;
 }
 
-function spreadArgumentPreserves(argument, specifier, paramName, mock) {
+function spreadArgumentPreserves(argument, specifier, paramVariable, mock, context) {
   argument = unwrapExpression(argument);
   if (argument?.type === "AwaitExpression") {
-    return Boolean(realModuleCall(argument.argument, specifier, paramName, mock));
+    return Boolean(realModuleCall(argument.argument, specifier, paramVariable, mock, context));
   }
-  return realModuleCall(argument, specifier, paramName, mock) === "sync";
+  return realModuleCall(argument, specifier, paramVariable, mock, context) === "sync";
 }
 
-function collectRealModuleNames(node, realModuleNames, specifier, paramName, mock, context) {
+function collectRealModuleNames(node, realModuleNames, specifier, paramVariable, mock, context) {
   if (isFunctionNode(node)) return;
   if (node.type === "VariableDeclaration" && node.kind === "const") {
     for (const declarator of node.declarations) {
       if (
         declarator.id.type === "Identifier" &&
-        spreadArgumentPreserves(declarator.init, specifier, paramName, mock)
+        spreadArgumentPreserves(declarator.init, specifier, paramVariable, mock, context)
       ) {
         realModuleNames.add(resolveVariable(declarator.id, context));
       }
     }
   }
-  for (const key of ["block", "body", "consequent", "alternate", "finalizer", "handler"]) {
+  for (const key of ["block", "body", "cases", "consequent", "alternate", "finalizer", "handler"]) {
     const child = node[key];
     if (Array.isArray(child)) {
       for (const item of child)
-        collectRealModuleNames(item, realModuleNames, specifier, paramName, mock, context);
+        collectRealModuleNames(item, realModuleNames, specifier, paramVariable, mock, context);
     } else if (child?.type) {
-      collectRealModuleNames(child, realModuleNames, specifier, paramName, mock, context);
+      collectRealModuleNames(child, realModuleNames, specifier, paramVariable, mock, context);
     }
   }
 }
@@ -92,7 +100,7 @@ function collectReturnedObjects(node, objects) {
     objects.push(argument?.type === "ObjectExpression" ? argument : null);
     return;
   }
-  for (const key of ["block", "body", "consequent", "alternate", "finalizer", "handler"]) {
+  for (const key of ["block", "body", "cases", "consequent", "alternate", "finalizer", "handler"]) {
     const child = node[key];
     if (Array.isArray(child)) {
       for (const item of child) collectReturnedObjects(item, objects);
@@ -102,49 +110,49 @@ function collectReturnedObjects(node, objects) {
   }
 }
 
-function analyzeFactoryBody(factory, specifier, paramName, mock, context) {
-  const body = unwrapExpression(factory?.body);
+function analyzeFactory(factory, specifier, mock, context) {
+  const param = mock?.framework === "vitest" ? factoryParam(factory) : null;
+  const paramVariable = param ? resolveVariable(param, context) : null;
+  const body = unwrapExpression(factory?.type === "ObjectExpression" ? factory : factory?.body);
   const objects = [];
   const realModuleNames = new Set();
-  if (!body) return { objects, realModuleNames };
-  if (body.type === "ObjectExpression") return { objects: [body], realModuleNames };
-  if (body.type !== "BlockStatement") return { objects, realModuleNames };
+  const analysis = { objects, paramVariable, realModuleNames };
+  if (!body) return analysis;
+  if (body.type === "ObjectExpression") return { ...analysis, objects: [body] };
+  if (body.type !== "BlockStatement") return analysis;
 
   for (const statement of body.body) {
-    collectRealModuleNames(statement, realModuleNames, specifier, paramName, mock, context);
+    collectRealModuleNames(statement, realModuleNames, specifier, paramVariable, mock, context);
     collectReturnedObjects(statement, objects);
   }
-  return { objects, realModuleNames };
+  return analysis;
+}
+
+function spreadPreservesRealModule(prop, analysis, specifier, mock, context) {
+  if (prop.type !== "SpreadElement") return false;
+  const { paramVariable, realModuleNames } = analysis;
+  if (prop.argument.type === "Identifier") {
+    return realModuleNames.has(resolveVariable(prop.argument, context));
+  }
+  return spreadArgumentPreserves(prop.argument, specifier, paramVariable, mock, context);
 }
 
-function objectSpreadsRealModule(object, specifier, paramName, realModuleNames, mock, context) {
+function objectSpreadsRealModule(object, analysis, specifier, mock, context) {
   return object.properties.some((prop) => {
-    if (prop.type !== "SpreadElement") return false;
-    if (prop.argument.type === "Identifier") {
-      return realModuleNames.has(resolveVariable(prop.argument, context));
-    }
-    return spreadArgumentPreserves(prop.argument, specifier, paramName, mock);
+    return spreadPreservesRealModule(prop, analysis, specifier, mock, context);
   });
 }
 
 function factoryPreservesExports(factory, specifier, mock, context) {
   if (!isFunctionNode(factory)) return false;
-  const paramName = mock.framework === "vitest" ? factoryParamName(factory) : undefined;
-  const { objects, realModuleNames } = analyzeFactoryBody(
-    factory,
-    specifier,
-    paramName,
-    mock,
-    context,
-  );
+  const analysis = analyzeFactory(factory, specifier, mock, context);
+  const { objects } = analysis;
   return (
     objects.length > 0 &&
     objects.every(
-      (object) =>
-        object &&
-        objectSpreadsRealModule(object, specifier, paramName, realModuleNames, mock, context),
+      (object) => object && objectSpreadsRealModule(object, analysis, specifier, mock, context),
     )
   );
 }
 
-module.exports = { factoryPreservesExports };
+module.exports = { analyzeFactory, factoryPreservesExports, spreadPreservesRealModule };