eslint-plugin-no-mistakes 0.11.1 → 0.12.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-no-mistakes",
-  "version": "0.11.1",
+  "version": "0.12.1",
   "description": "ESLint and Oxlint rules for deterministic no-mistakes code analysis",
   "license": "MIT",
   "repository": {
@@ -23,8 +23,8 @@
   "devDependencies": {
     "@typescript-eslint/parser": "^8.48.0",
     "@vitest/coverage-v8": "^4.1.6",
-    "eslint": "^10.3.0",
-    "oxlint": "^1.64.0",
+    "eslint": "^10.4.0",
+    "oxlint": "^1.65.0",
     "vitest": "^4.1.6"
   },
   "peerDependencies": {

package/src/helpers.js

@@ -134,14 +134,28 @@ function selectorValueNode(attribute) {
   return expression && expression.type !== "JSXEmptyExpression" ? expression : null;
 }
 
-const LOCAL_BINDING_TYPES = new Set(["Variable", "Parameter", "CatchClause", "FunctionName"]);
+const LOCAL_BINDING_TYPES = new Set([
+  "Variable",
+  "Parameter",
+  "CatchClause",
+  "FunctionName",
+  "ImportBinding",
+  "ClassName",
+]);
 
 function isFetchShadowed(scope) {
   while (scope) {
-    const variable = scope.variables.find((v) => v.name === "fetch");
+    const get = scope.set?.get;
+    const variable = typeof get === "function" ? get.call(scope.set, "fetch") : null;
     if (variable) {
       return variable.defs.some((def) => LOCAL_BINDING_TYPES.has(def.type));
     }
+    if (!scope.set || typeof get !== "function") {
+      const fallback = scope.variables?.find((item) => item.name === "fetch");
+      if (fallback) {
+        return fallback.defs.some((def) => LOCAL_BINDING_TYPES.has(def.type));
+      }
+    }
     scope = scope.upper;
   }
   return false;

package/src/returned-jsx.js

@@ -17,7 +17,9 @@ function collectReturnBranches(node, branches) {
     return;
   }
   if (node.type === "ReturnStatement") {
-    branches.push(...jsxBranches(node.argument));
+    for (const branch of jsxBranches(node.argument)) {
+      branches.push(branch);
+    }
     return;
   }
   if (node.type === "ClassDeclaration" || node.type === "ClassExpression") {
@@ -101,7 +103,11 @@ function childNodes(node) {
       continue;
     }
     if (Array.isArray(value)) {
-      children.push(...value.filter(isAstNode));
+      for (const child of value) {
+        if (isAstNode(child)) {
+          children.push(child);
+        }
+      }
     } else if (isAstNode(value)) {
       children.push(value);
     }

package/src/rules/playwright-no-set-timeout.js

@@ -25,7 +25,11 @@ function propertyName(node, computed = false) {
 function isGlobalSetTimeout(node, context) {
   let scope = context.sourceCode.getScope(node);
   while (scope) {
-    const variable = scope.variables.find((candidate) => candidate.name === "setTimeout");
+    const get = scope.set?.get;
+    const variable =
+      typeof get === "function"
+        ? get.call(scope.set, "setTimeout")
+        : scope.variables.find((candidate) => candidate.name === "setTimeout");
     if (variable) return variable.defs.length === 0;
     scope = scope.upper;
   }

package/src/rules/test-no-shared-state-analysis.js

@@ -23,17 +23,24 @@ function isInsideUncalledNestedFunction(node, testDepth, setupDepth) {
   return false;
 }
 
-function isModuleMutable(context, mutableTopLevel, node, name) {
+function isModuleMutable({ context, mutableTopLevel, node, name }) {
   let scope = context.sourceCode.getScope(node);
   while (scope) {
-    const variable = scope.variables.find((candidate) => candidate.name === name);
-    if (variable) {
-      return (
-        mutableTopLevel.has(variable.name) &&
-        (variable.scope.type === "module" || variable.scope.block.type === "Program")
-      );
+    const get = scope.set?.get;
+    const variable = typeof get === "function" ? get.call(scope.set, name) : null;
+    const resolvedVariable =
+      variable ||
+      (typeof get !== "function" ? scope.variables?.find((item) => item.name === name) : null);
+
+    if (!resolvedVariable) {
+      scope = scope.upper;
+      continue;
     }
-    scope = scope.upper;
+
+    return (
+      mutableTopLevel.has(resolvedVariable.name) &&
+      (resolvedVariable.scope.type === "module" || resolvedVariable.scope.block.type === "Program")
+    );
   }
   return false;
 }
@@ -112,7 +119,7 @@ function createRegistryReports(context, mutableTopLevel, cleanupTracker, isCaptu
         testDepth > 0 &&
         setupDepth === 0 &&
         !isCaptured(name) &&
-        isModuleMutable(context, mutableTopLevel, node, name)
+        isModuleMutable({ context, mutableTopLevel, node, name })
       ) {
         pending.push({ node, path, suiteKey: cleanupTracker.currentSuiteKey() });
       }

package/src/rules/test-no-shared-state-helpers.js

@@ -2,6 +2,7 @@
 
 const TEST_CALLEES = new Set(["it", "test", "describe"]);
 const SETUP_CALLEES = new Set(["beforeEach", "afterEach", "beforeAll", "afterAll"]);
+const PER_TEST_CALLEES = new Set(["beforeEach", "afterEach"]);
 const MUTATING_METHODS = new Set(
   "add clear copyWithin delete fill pop push reverse set shift sort splice unshift".split(" "),
 );
@@ -25,15 +26,13 @@ function isTestCall(node) {
 
 function setupCallbackKind(node) {
   const name = calleeName(node.callee);
-  return name === "beforeEach" || name === "afterEach"
-    ? "per-test"
-    : name === "beforeAll" || name === "afterAll"
-      ? "once"
-      : null;
-}
-
-function isSetupCall(node) {
-  return SETUP_CALLEES.has(calleeName(node.callee));
+  if (PER_TEST_CALLEES.has(name)) return "per-test";
+  if (name === "beforeAll") return "before-once";
+  if (name === "afterAll") return "once";
+  if (node.callee.type !== "MemberExpression" || !TEST_CALLEES.has(name)) return null;
+  if (PER_TEST_CALLEES.has(node.callee.property.name)) return "per-test";
+  if (node.callee.property.name === "beforeAll") return "before-once";
+  return node.callee.property.name === "afterAll" ? "once" : null;
 }
 
 function collectPatternNames(node, names = new Set()) {
@@ -101,7 +100,8 @@ function isInlineTestCallback(node) {
 }
 
 function isInlineSetupCallback(node) {
-  return node.parent?.type === "CallExpression" && isSetupCall(node.parent);
+  const p = node.parent;
+  return p?.type === "CallExpression" && SETUP_CALLEES.has(calleeName(p.callee));
 }
 
 function isCalledFunction(node) {
@@ -152,12 +152,13 @@ function firstNamedCallbackArgument(args) {
   return args[0]?.type === "Identifier" ? args[0] : undefined;
 }
 
-function createCleanupTracker() {
+function createCleanupTracker(options = {}) {
   const pathsBySuite = new Map();
   const suiteStack = [];
-  let activeSuiteKey;
-  let replaySuiteKey;
+  let activeSuiteKey, replaySuiteKey;
   let nextSuiteId = 0;
+  const ao = options.allowBeforeAllAssignments;
+  const sKinds = new Set(ao ? ["per-test", "before-once"] : ["per-test"]);
 
   function currentSuiteKey() {
     return replaySuiteKey ?? suiteStack.join("/");
@@ -175,7 +176,7 @@ function createCleanupTracker() {
 
   return {
     beginSetup(kind, suiteKey = currentSuiteKey()) {
-      activeSuiteKey = kind === "per-test" ? suiteKey : undefined;
+      activeSuiteKey = sKinds.has(kind) ? suiteKey : undefined;
     },
     clearReplaySuite() {
       replaySuiteKey = undefined;
@@ -194,8 +195,7 @@ function createCleanupTracker() {
     remember(path) {
       if (!path || activeSuiteKey === undefined) return;
       const paths = pathsBySuite.get(activeSuiteKey) ?? new Set();
-      paths.add(path);
-      pathsBySuite.set(activeSuiteKey, paths);
+      pathsBySuite.set(activeSuiteKey, paths.add(path));
     },
     setReplaySuite(suiteKey) {
       replaySuiteKey = suiteKey;
@@ -214,7 +214,6 @@ module.exports = {
   isInlineTestCallback,
   isMutableInitializer,
   calleeName,
-  isSetupCall,
   isTestCall,
   mutatingCallPropertyName,
   mutatingCallTarget,

package/src/rules/test-no-shared-state.js

@@ -1,6 +1,7 @@
 "use strict";
 
 const { rule } = require("../helpers");
+
 const {
   createRegistryReports,
   createViMockTracker,
@@ -9,6 +10,7 @@ const {
   isResetAssignment,
   walkSharedMutations,
 } = require("./test-no-shared-state-analysis");
+
 const {
   calleeName,
   collectPatternNames,
@@ -29,7 +31,7 @@ module.exports = rule(
   {
     type: "problem",
     docs: { description: "disallow mutable module-scope test state", recommended: false },
-    schema: [],
+    schema: [{ type: "object", properties: { allowBeforeAllAssignments: { type: "boolean" } } }],
     messages: {
       shared:
         "Shared mutable module-scope state between tests: use local variables inside each test instead.",
@@ -39,7 +41,8 @@ module.exports = rule(
     const mutableTopLevel = new Set();
     const pendingNamedCallbacks = [];
     const pendingNamedSetupCallbacks = [];
-    const cleanupTracker = createCleanupTracker();
+    const ruleOptions = context.options?.[0] ?? {};
+    const cleanupTracker = createCleanupTracker(ruleOptions);
     const viMockTracker = createViMockTracker(context, mutableTopLevel);
     const registryReports = createRegistryReports(
       context,
@@ -56,10 +59,9 @@ module.exports = rule(
         testDepth > 0 &&
         setupDepth === 0 &&
         !viMockTracker.isCaptured(name) &&
-        isModuleMutable(context, mutableTopLevel, node, name)
-      ) {
+        isModuleMutable({ context, mutableTopLevel, node, name })
+      )
         context.report({ node, messageId: "shared" });
-      }
     }
 
     function reportAssignment(node) {
@@ -73,10 +75,9 @@ module.exports = rule(
         name &&
         setupDepth > 0 &&
         mutableTopLevel.has(name) &&
-        isModuleMutable(context, mutableTopLevel, node, name)
-      ) {
+        isModuleMutable({ context, mutableTopLevel, node, name })
+      )
         cleanupTracker.remember(path);
-      }
     }
 
     function rememberCall(node) {
@@ -97,16 +98,36 @@ module.exports = rule(
       rememberSetupCleanup(node, mutationRootName(node.left), mutationPath(node.left.object));
     }
 
+    const mutationWalk = {
+      onAssignment: (assignment) => {
+        rememberAssignmentCleanup(assignment);
+        reportAssignment(assignment);
+      },
+      onCall: rememberCall,
+      onUpdate: (update) => reportIfShared(update, mutationRootName(update.argument)),
+    };
+
     function resolveFunctionCallback(node, callback) {
       let scope = context.sourceCode.getScope(node);
       while (scope) {
-        const variable = scope.variables.find((candidate) => candidate.name === callback.name);
-        const declaration = variable?.defs[0]?.node;
+        const get = scope.set?.get;
+        const resolvedVariable =
+          (typeof get === "function" ? get.call(scope.set, callback.name) : null) ||
+          (typeof get !== "function"
+            ? scope.variables?.find((item) => item.name === callback.name)
+            : null);
+
+        if (!resolvedVariable) {
+          scope = scope.upper;
+          continue;
+        }
+
+        const declaration = resolvedVariable.defs[0]?.node;
         if (declaration?.type === "FunctionDeclaration") return declaration;
         if (declaration?.type === "VariableDeclarator" && isFunctionNode(declaration.init)) {
           return declaration.init;
         }
-        scope = scope.upper;
+        return null;
       }
       return null;
     }
@@ -127,7 +148,7 @@ module.exports = rule(
           const previousSetupDepth = setupDepth;
           setupDepth = 1;
           cleanupTracker.beginSetup(kind, suiteKey);
-          checkSharedMutations(declaration.body);
+          walkSharedMutations(declaration.body, mutationWalk);
           setupDepth = previousSetupDepth;
           cleanupTracker.endSetup();
         }
@@ -135,7 +156,7 @@ module.exports = rule(
         for (const { declaration, suiteKey } of pendingNamedCallbacks) {
           if (!declaration) continue;
           cleanupTracker.setReplaySuite(suiteKey);
-          checkSharedMutations(declaration.body);
+          walkSharedMutations(declaration.body, mutationWalk);
           cleanupTracker.clearReplaySuite();
         }
         registryReports.flush();
@@ -146,7 +167,7 @@ module.exports = rule(
         if (isTestCall(node)) {
           testDepth += 1;
           const callback = namedCallbackArgument(node.arguments);
-          if (callback) {
+          if (callback && !setupCallbackKind(node)) {
             pendingNamedCallbacks.push({
               declaration: resolveFunctionCallback(node, callback),
               suiteKey: cleanupTracker.currentSuiteKey(),
@@ -154,15 +175,13 @@ module.exports = rule(
           }
         }
         const setupKind = setupCallbackKind(node);
-        if (setupKind) {
-          const callback = firstNamedCallbackArgument(node.arguments);
-          if (callback) {
-            pendingNamedSetupCallbacks.push({
-              declaration: resolveFunctionCallback(node, callback),
-              suiteKey: cleanupTracker.currentSuiteKey(),
-              kind: setupKind,
-            });
-          }
+        const setupCallback = setupKind && firstNamedCallbackArgument(node.arguments);
+        if (setupCallback) {
+          pendingNamedSetupCallbacks.push({
+            declaration: resolveFunctionCallback(node, setupCallback),
+            suiteKey: cleanupTracker.currentSuiteKey(),
+            kind: setupKind,
+          });
         }
         if (setupKind) {
           setupDepth += 1;
@@ -185,24 +204,9 @@ module.exports = rule(
           cleanupTracker.endSetup();
         }
         const isInsideNested = isInsideUncalledNestedFunction(node, testDepth, setupDepth);
-        if (!isInsideNested) {
-          rememberCall(node);
-        }
+        if (!isInsideNested) rememberCall(node);
         if (calleeName(node.callee) === "describe") cleanupTracker.exitSuite();
       },
     };
-
-    function checkSharedMutations(node) {
-      walkSharedMutations(node, {
-        onAssignment: (assignment) => {
-          rememberAssignmentCleanup(assignment);
-          reportAssignment(assignment);
-        },
-        onCall: (call) => {
-          rememberCall(call);
-        },
-        onUpdate: (update) => reportIfShared(update, mutationRootName(update.argument)),
-      });
-    }
   },
 );

package/src/rules/vitest-mock-test-file-naming.js

@@ -19,6 +19,20 @@ const MOCK_METHODS = new Set([
   "setSystemTime",
 ]);
 
+const MOCK_CHAIN_METHODS = new Set([
+  "mockImplementation",
+  "mockImplementationOnce",
+  "mockReturnValue",
+  "mockReturnValueOnce",
+  "mockResolvedValue",
+  "mockResolvedValueOnce",
+  "mockRejectedValue",
+  "mockRejectedValueOnce",
+  "mockReset",
+  "mockRestore",
+  "mockClear",
+]);
+
 function isTestFile(filename) {
   return TEST_FILE_PATTERN.test(filename.replace(/\\/g, "/"));
 }
@@ -83,9 +97,13 @@ module.exports = rule(
   },
   (context) => {
     let usesMocking = false;
+    function isMockChainCall(node) {
+      if (node.callee.type !== "MemberExpression") return false;
+      return MOCK_CHAIN_METHODS.has(propertyName(node.callee.property));
+    }
     return {
       CallExpression(node) {
-        if (isMockingCall(node, context)) usesMocking = true;
+        if (isMockingCall(node, context) || isMockChainCall(node)) usesMocking = true;
       },
       "Program:exit"(node) {
         if (!isTestFile(context.filename)) return;