eslint-plugin-no-mistakes 0.57.0 → 0.58.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-no-mistakes",
-  "version": "0.57.0",
+  "version": "0.58.0",
   "description": "ESLint and Oxlint rules that keep code static enough for no-mistakes analyzers and coding agents",
   "license": "MIT",
   "repository": {
@@ -21,9 +21,9 @@
     "test": "vitest run --coverage"
   },
   "devDependencies": {
-    "@typescript-eslint/parser": "^8.67.0",
+    "@typescript-eslint/parser": "^8.68.0",
     "@vitest/coverage-v8": "^4.1.11",
-    "eslint": "^10.9.0",
+    "eslint": "^10.9.1",
     "oxlint": "^1.80.0",
     "vitest": "^4.1.11"
   },

package/src/index.js

@@ -14,6 +14,7 @@ const rules = {
   "no-global-fetch-outside-helper": require("./rules/no-global-fetch-outside-helper"),
   "no-delete-property": require("./rules/no-delete-property"),
   "no-import-only-test-files": require("./rules/no-import-only-test-files"),
+  "no-inline-noop-promise-catch": require("./rules/no-inline-noop-promise-catch"),
   "no-placeholder-never-type-exports": require("./rules/no-placeholder-never-type-exports"),
   "no-vitest-sequential": require("./rules/no-vitest-sequential"),
   "playwright-consistent-attribute": require("./rules/playwright-consistent-attribute"),
@@ -38,6 +39,7 @@ const rules = {
   "react-no-use-promise-resolve": require("./rules/react-no-use-promise-resolve"),
   "server-require-nullable-fetch-wrapper": require("./rules/server-require-nullable-fetch-wrapper"),
   "test-no-error-message-matching": require("./rules/test-no-error-message-matching"),
+  "test-no-delayed-rejects": require("./rules/test-no-delayed-rejects"),
   "test-no-shared-state": require("./rules/test-no-shared-state"),
   "ts-no-const-aliases": require("./rules/ts-no-const-aliases"),
   "ts-no-export-renaming": require("./rules/ts-no-export-renaming"),
@@ -96,6 +98,7 @@ plugin.configs.strict = {
     "no-mistakes/react-no-iife-in-jsx": "error",
     "no-mistakes/react-no-use-promise-resolve": "error",
     "no-mistakes/test-no-error-message-matching": "error",
+    "no-mistakes/test-no-delayed-rejects": "error",
     "no-mistakes/test-no-shared-state": "error",
     "no-mistakes/vitest-mock-test-file-naming": "error",
   },

package/src/rules/no-inline-noop-promise-catch-helpers.js

@@ -0,0 +1,92 @@
+"use strict";
+
+const { unwrapExpression } = require("./async-ast");
+const {
+  memberPropertyName,
+  repoRelativeFilename,
+  stringMatches,
+} = require("./module-mock-helpers");
+
+const CHAIN_METHODS = new Set(["catch", "finally", "then"]);
+
+function shouldCheckFile(filename, options) {
+  const file = repoRelativeFilename(filename);
+  const checked = options.checkedPathPatterns ?? [];
+  const allowed = options.allowedPathPatterns ?? [];
+  if (checked.length > 0 && !stringMatches(file, checked)) return false;
+  return !stringMatches(file, allowed);
+}
+
+function promiseMethodName(call) {
+  const callee = unwrapExpression(call.callee);
+  if (callee?.type !== "MemberExpression" || callee.computed) return null;
+  return callee.property.name;
+}
+
+function rejectionHandler(call) {
+  const method = promiseMethodName(call);
+  if (method === "catch") return call.arguments[0] ?? null;
+  if (method === "then") return call.arguments[1] ?? null;
+  return null;
+}
+
+function isVoidZero(node) {
+  const current = unwrapExpression(node);
+  if (current?.type !== "UnaryExpression" || current.operator !== "void") return false;
+  const argument = unwrapExpression(current.argument);
+  return argument?.type === "Literal" && argument.value === 0;
+}
+
+function isNoopExpression(node) {
+  const current = unwrapExpression(node);
+  if (current.type === "Identifier" && current.name === "undefined") return true;
+  return isVoidZero(current);
+}
+
+function isNoopStatement(statement) {
+  if (statement.type === "EmptyStatement") return true;
+  if (statement.type === "ReturnStatement") {
+    return statement.argument == null || isNoopExpression(statement.argument);
+  }
+  return statement.type === "ExpressionStatement" && isNoopExpression(statement.expression);
+}
+
+function isInlineFunction(node) {
+  if (node?.type === "ArrowFunctionExpression") return true;
+  return node?.type === "FunctionExpression" && node.id == null;
+}
+
+function isInlineNoopFunction(node) {
+  const current = unwrapExpression(node);
+  if (!isInlineFunction(current)) return false;
+  if (current.body.type !== "BlockStatement") return isNoopExpression(current.body);
+  return current.body.body.every(isNoopStatement);
+}
+
+function originatingCalleeName(call) {
+  let current = unwrapExpression(call);
+  while (current?.type === "CallExpression") {
+    const method = promiseMethodName(current);
+    if (!CHAIN_METHODS.has(method)) break;
+    const callee = unwrapExpression(current.callee);
+    current = unwrapExpression(callee?.object);
+  }
+  if (current?.type !== "CallExpression") return null;
+  const callee = unwrapExpression(current.callee);
+  if (callee?.type === "Identifier") return callee.name;
+  if (callee?.type === "MemberExpression") return memberPropertyName(callee);
+  return null;
+}
+
+function isAllowedCallee(call, options) {
+  const name = originatingCalleeName(call);
+  return Boolean(name && stringMatches(name, options.allowedCalleeNamePatterns ?? []));
+}
+
+module.exports = {
+  isAllowedCallee,
+  isInlineNoopFunction,
+  originatingCalleeName,
+  rejectionHandler,
+  shouldCheckFile,
+};

package/src/rules/no-inline-noop-promise-catch.js

@@ -0,0 +1,48 @@
+"use strict";
+
+const { rule } = require("../helpers");
+const helpers = require("./no-inline-noop-promise-catch-helpers");
+
+const { isAllowedCallee, isInlineNoopFunction, rejectionHandler, shouldCheckFile } = helpers;
+
+const patternList = { type: "array", items: { type: "string" } };
+
+module.exports = Object.assign(
+  rule(
+    {
+      type: "problem",
+      docs: {
+        description: "disallow inline Promise catch callbacks that do not handle the rejection",
+        recommended: false,
+      },
+      schema: [
+        {
+          type: "object",
+          properties: {
+            checkedPathPatterns: patternList,
+            allowedPathPatterns: patternList,
+            allowedCalleeNamePatterns: patternList,
+          },
+          additionalProperties: false,
+        },
+      ],
+      messages: {
+        noopCatch:
+          "Replace this inline no-op Promise catch with a named handler, logging, reporting, transformation, or rethrow so rejection handling stays reviewable.",
+      },
+    },
+    (context) => {
+      const options = context.options?.[0] ?? {};
+      if (!shouldCheckFile(context.filename, options)) return {};
+      return {
+        CallExpression(node) {
+          const handler = rejectionHandler(node);
+          if (!handler || !isInlineNoopFunction(handler)) return;
+          if (isAllowedCallee(node, options)) return;
+          context.report({ node: handler, messageId: "noopCatch" });
+        },
+      };
+    },
+  ),
+  { __test: helpers },
+);

package/src/rules/test-no-delayed-rejects-abrupt.js

@@ -0,0 +1,180 @@
+"use strict";
+
+function contains(ancestor, node) {
+  return ancestor.range[0] <= node.range[0] && ancestor.range[1] >= node.range[1];
+}
+
+function alwaysExits(statement) {
+  if (statement.type === "ReturnStatement" || statement.type === "ThrowStatement") return true;
+  if (statement.type === "BlockStatement") return statement.body.some(alwaysExits);
+  if (statement.type === "TryStatement") {
+    if (statement.finalizer && alwaysExits(statement.finalizer)) return true;
+    if (!alwaysExits(statement.block)) return false;
+    return (
+      !statement.handler || alwaysReturns(statement.block) || alwaysExits(statement.handler.body)
+    );
+  }
+  return (
+    statement.type === "IfStatement" &&
+    statement.alternate &&
+    alwaysExits(statement.consequent) &&
+    alwaysExits(statement.alternate)
+  );
+}
+
+function alwaysReturns(statement) {
+  if (statement.type === "ReturnStatement") return true;
+  if (statement.type === "BlockStatement") {
+    const exit = statement.body.find(alwaysExits);
+    return Boolean(exit && alwaysReturns(exit));
+  }
+  if (statement.type === "TryStatement") {
+    if (statement.finalizer && alwaysExits(statement.finalizer)) {
+      return alwaysReturns(statement.finalizer);
+    }
+    if (alwaysReturns(statement.block)) return true;
+    return Boolean(
+      statement.handler && alwaysExits(statement.block) && alwaysReturns(statement.handler.body),
+    );
+  }
+  return (
+    statement.type === "IfStatement" &&
+    statement.alternate &&
+    alwaysReturns(statement.consequent) &&
+    alwaysReturns(statement.alternate)
+  );
+}
+
+function alwaysThrows(statement) {
+  if (statement.type === "ThrowStatement") return true;
+  if (statement.type === "BlockStatement") {
+    const exit = statement.body.find(alwaysExits);
+    return Boolean(exit && alwaysThrows(exit));
+  }
+  if (statement.type === "TryStatement") {
+    if (statement.finalizer && alwaysExits(statement.finalizer)) {
+      return alwaysThrows(statement.finalizer);
+    }
+    return (
+      alwaysThrows(statement.block) && (!statement.handler || alwaysThrows(statement.handler.body))
+    );
+  }
+  return (
+    statement.type === "IfStatement" &&
+    statement.alternate &&
+    alwaysThrows(statement.consequent) &&
+    alwaysThrows(statement.alternate)
+  );
+}
+
+function matcherRunsInClause(node, matcher, clause) {
+  let current = node;
+  while (current.parent) {
+    const parent = current.parent;
+    if (parent.type === "TryStatement" && clause(parent, current, matcher)) return true;
+    current = parent;
+  }
+  return false;
+}
+
+function abruptCompletionReachesMatcher(node, matcher) {
+  const runsInFinally = matcherRunsInClause(
+    node,
+    matcher,
+    (parent, current) =>
+      parent.finalizer &&
+      (current === parent.block || current === parent.handler) &&
+      contains(parent.finalizer, matcher),
+  );
+  const runsInCatch = matcherRunsInClause(
+    node,
+    matcher,
+    (parent, current) =>
+      current === parent.block && parent.handler && contains(parent.handler, matcher),
+  );
+  return runsInFinally || (alwaysThrows(node) && runsInCatch);
+}
+
+function caughtThrowCanContinue(node, matcher) {
+  if (!alwaysThrows(node)) return false;
+  let current = node;
+  while (current.parent) {
+    const parent = current.parent;
+    if (parent.type === "TryStatement" && current === parent.block) {
+      if (parent.finalizer && alwaysExits(parent.finalizer)) {
+        if (!alwaysThrows(parent.finalizer)) return false;
+      } else if (parent.handler) {
+        if (contains(parent, matcher)) return false;
+        if (!alwaysExits(parent.handler.body)) return true;
+        if (!alwaysThrows(parent.handler.body)) return false;
+      }
+    }
+    current = parent;
+  }
+  return false;
+}
+
+function isLoop(node) {
+  return (
+    node.type === "WhileStatement" ||
+    node.type === "DoWhileStatement" ||
+    node.type === "ForStatement" ||
+    node.type === "ForInStatement" ||
+    node.type === "ForOfStatement"
+  );
+}
+
+function directJumpSkipsMatcher(node, matcher) {
+  let current = node.parent;
+  while (true) {
+    const isTarget = node.label
+      ? current.type === "LabeledStatement" && current.label.name === node.label.name
+      : isLoop(current) || (node.type === "BreakStatement" && current.type === "SwitchStatement");
+    if (isTarget) return contains(current, matcher);
+    current = current.parent;
+  }
+}
+
+function jumpSkipsMatcher(node, matcher, type) {
+  if (node.type === type) return directJumpSkipsMatcher(node, matcher);
+  if (node.type === "BlockStatement" || node.type === "SwitchCase") {
+    const statements = node.type === "BlockStatement" ? node.body : node.consequent;
+    return statements.some((statement) => jumpSkipsMatcher(statement, matcher, type));
+  }
+  if (node.type === "TryStatement") {
+    if (node.finalizer && jumpSkipsMatcher(node.finalizer, matcher, type)) return true;
+    if (node.finalizer && alwaysExits(node.finalizer)) {
+      return jumpSkipsMatcher(node.finalizer, matcher, type);
+    }
+    if (jumpSkipsMatcher(node.block, matcher, type)) return true;
+    return Boolean(
+      node.handler &&
+      alwaysThrows(node.block) &&
+      jumpSkipsMatcher(node.handler.body, matcher, type),
+    );
+  }
+  return Boolean(
+    node.type === "IfStatement" &&
+    node.alternate &&
+    jumpSkipsMatcher(node.consequent, matcher, type) &&
+    jumpSkipsMatcher(node.alternate, matcher, type),
+  );
+}
+
+function breakSkipsMatcher(node, matcher) {
+  return jumpSkipsMatcher(node, matcher, "BreakStatement");
+}
+
+function continueSkipsMatcher(node, matcher) {
+  return jumpSkipsMatcher(node, matcher, "ContinueStatement");
+}
+
+module.exports = {
+  abruptCompletionReachesMatcher,
+  alwaysExits,
+  alwaysThrows,
+  breakSkipsMatcher,
+  continueSkipsMatcher,
+  caughtThrowCanContinue,
+  contains,
+};

package/src/rules/test-no-delayed-rejects-chains.js

@@ -0,0 +1,83 @@
+"use strict";
+
+const { unwrapExpression, unwrapTransparentParent } = require("./async-ast");
+const {
+  isNonRejectingHandler,
+  isNonRejectingHandlerOrAbsent,
+} = require("./test-no-delayed-rejects-handlers");
+
+const PROMISE_CHAIN_METHODS = new Set(["catch", "finally", "then"]);
+
+function literalPropertyName(member) {
+  if (!member.computed && member.property.type === "Identifier") return member.property.name;
+  if (member.computed && member.property.type === "Literal") return member.property.value;
+  return null;
+}
+
+function isPromiseChainMember(node) {
+  return node.type === "MemberExpression" && PROMISE_CHAIN_METHODS.has(literalPropertyName(node));
+}
+
+function promiseChainBase(node) {
+  let current = unwrapExpression(node);
+  while (current.type === "CallExpression" && isPromiseChainMember(current.callee)) {
+    current = unwrapExpression(current.callee.object);
+  }
+  return current;
+}
+
+function continuationCall(node) {
+  const chainNode = unwrapTransparentParent(node);
+  const member = chainNode.parent;
+  if (
+    member?.type !== "MemberExpression" ||
+    member.object !== chainNode ||
+    !PROMISE_CHAIN_METHODS.has(literalPropertyName(member)) ||
+    member.parent?.type !== "CallExpression" ||
+    member.parent.callee !== member
+  ) {
+    return null;
+  }
+  return member.parent;
+}
+
+function initialCallIsSafe(node) {
+  const property = literalPropertyName(node.callee);
+  if (property === "catch") return isNonRejectingHandler(node.arguments[0]);
+  return (
+    property === "then" &&
+    isNonRejectingHandlerOrAbsent(node.arguments[0]) &&
+    isNonRejectingHandler(node.arguments[1])
+  );
+}
+
+function applyContinuationSafety(safe, node) {
+  const property = literalPropertyName(node.callee);
+  if (property === "finally") {
+    return safe && isNonRejectingHandlerOrAbsent(node.arguments[0]);
+  }
+  if (property === "catch") {
+    return safe || isNonRejectingHandler(node.arguments[0]);
+  }
+  if (safe) return isNonRejectingHandlerOrAbsent(node.arguments[0]);
+  return isNonRejectingHandler(node.arguments[0]) && isNonRejectingHandler(node.arguments[1]);
+}
+
+function chainIsSafelyObserved(node) {
+  let safe = initialCallIsSafe(node);
+  if (!safe) return false;
+  let current = node;
+  while (true) {
+    const continuation = continuationCall(current);
+    if (!continuation) return safe;
+    safe = applyContinuationSafety(safe, continuation);
+    current = continuation;
+  }
+}
+
+module.exports = {
+  chainIsSafelyObserved,
+  isPromiseChainMember,
+  literalPropertyName,
+  promiseChainBase,
+};

package/src/rules/test-no-delayed-rejects-finalizers.js

@@ -0,0 +1,29 @@
+"use strict";
+
+const {
+  abruptCompletionReachesMatcher,
+  alwaysExits,
+  caughtThrowCanContinue,
+  contains,
+  continueSkipsMatcher,
+} = require("./test-no-delayed-rejects-abrupt");
+
+function finalizerPreventsReach(parent, child, matcher) {
+  if (
+    parent?.type !== "TryStatement" ||
+    child === parent.finalizer ||
+    !parent.finalizer ||
+    contains(parent, matcher)
+  ) {
+    return false;
+  }
+  if (continueSkipsMatcher(parent.finalizer, matcher)) return true;
+  return (
+    alwaysExits(parent.finalizer) &&
+    !contains(parent.finalizer, matcher) &&
+    !abruptCompletionReachesMatcher(parent.finalizer, matcher) &&
+    !caughtThrowCanContinue(parent.finalizer, matcher)
+  );
+}
+
+module.exports = { finalizerPreventsReach };

package/src/rules/test-no-delayed-rejects-flow.js

@@ -0,0 +1,201 @@
+"use strict";
+
+const {
+  abruptCompletionReachesMatcher,
+  alwaysExits,
+  alwaysThrows,
+  breakSkipsMatcher,
+  continueSkipsMatcher,
+  caughtThrowCanContinue,
+  contains,
+} = require("./test-no-delayed-rejects-abrupt");
+const { finalizerPreventsReach } = require("./test-no-delayed-rejects-finalizers");
+const {
+  mayThrow,
+  possibleCaughtThrowCanContinue,
+  thrownCompletionCanReachMatcher,
+} = require("./test-no-delayed-rejects-transfers");
+const { childExecutesBefore } = require("./test-no-delayed-rejects-order");
+
+function isLoop(node) {
+  return (
+    node?.type === "WhileStatement" ||
+    node?.type === "DoWhileStatement" ||
+    node?.type === "ForStatement" ||
+    node?.type === "ForInStatement" ||
+    node?.type === "ForOfStatement"
+  );
+}
+
+function isOptionalCall(node) {
+  if (node.type !== "CallExpression") return false;
+  if (node.optional) return true;
+  let current = node.callee;
+  while (current.type === "MemberExpression") {
+    if (current.optional) return true;
+    current = current.object;
+  }
+  return false;
+}
+
+function hasLoopBackedge(node, functionNode) {
+  let current = node.parent;
+  while (current && current !== functionNode) {
+    if (isLoop(current)) return true;
+    current = current.parent;
+  }
+  return false;
+}
+
+function branchesAreExclusive(current, parent, matcher, suspension, functionNode) {
+  if (parent?.type === "IfStatement" || parent?.type === "ConditionalExpression") {
+    if (hasLoopBackedge(parent, functionNode)) return false;
+    return (
+      (current === parent.consequent && parent.alternate && contains(parent.alternate, matcher)) ||
+      (current === parent.alternate && contains(parent.consequent, matcher))
+    );
+  }
+  if (current.type === "SwitchCase" && parent?.type === "SwitchStatement") {
+    if (hasLoopBackedge(parent, functionNode)) return false;
+    const currentIndex = parent.cases.indexOf(current);
+    const matcherIndex = parent.cases.findIndex((item) => contains(item, matcher));
+    if (matcherIndex === -1 || matcherIndex === currentIndex) return false;
+    if (matcherIndex < currentIndex) return true;
+    const suspensionIndex = current.consequent.findIndex((item) => contains(item, suspension));
+    return current.consequent
+      .slice(suspensionIndex + 1)
+      .some(
+        (item) =>
+          item.type === "BreakStatement" ||
+          alwaysExits(item) ||
+          continueSkipsMatcher(item, matcher),
+      );
+  }
+  return false;
+}
+
+function canReachMatcher(suspension, matcher, functionNode) {
+  if (thrownCompletionCanReachMatcher(suspension, matcher)) return true;
+  let current = suspension;
+  while (current && current !== functionNode) {
+    if (
+      (current.type === "ReturnStatement" || current.type === "ThrowStatement") &&
+      !contains(current, matcher) &&
+      !abruptCompletionReachesMatcher(current, matcher) &&
+      !caughtThrowCanContinue(current, matcher)
+    ) {
+      return false;
+    }
+    if (!contains(current, matcher) && breakSkipsMatcher(current, matcher)) return false;
+    if (!contains(current, matcher) && continueSkipsMatcher(current, matcher)) return false;
+    const parent = current.parent;
+    if (finalizerPreventsReach(parent, current, matcher)) return false;
+    if (branchesAreExclusive(current, parent, matcher, suspension, functionNode)) return false;
+    const statements =
+      parent?.type === "BlockStatement"
+        ? parent.body
+        : parent?.type === "SwitchCase"
+          ? parent.consequent
+          : null;
+    if (statements) {
+      const currentIndex = statements.indexOf(current);
+      if (currentIndex !== -1) {
+        const matcherIndex = statements.findIndex((statement) => contains(statement, matcher));
+        const end = matcherIndex === -1 ? statements.length : matcherIndex;
+        const following = statements.slice(currentIndex + 1, end);
+        const exitIndex = following.findIndex(
+          (statement) =>
+            alwaysExits(statement) ||
+            breakSkipsMatcher(statement, matcher) ||
+            continueSkipsMatcher(statement, matcher),
+        );
+        const exit = following[exitIndex];
+        const caughtThrow =
+          exit &&
+          following
+            .slice(0, exitIndex + 1)
+            .some((statement) => possibleCaughtThrowCanContinue(statement, matcher));
+        if (
+          exit &&
+          !caughtThrow &&
+          !abruptCompletionReachesMatcher(exit, matcher) &&
+          !caughtThrowCanContinue(exit, matcher)
+        ) {
+          return false;
+        }
+      }
+    }
+    current = parent;
+  }
+  return true;
+}
+
+function throwCanSkipObserver(block, observer, suspension) {
+  const observerIndex = block.body.findIndex((statement) => contains(statement, observer));
+  return block.body
+    .slice(0, observerIndex)
+    .some(
+      (statement) => mayThrow(statement) && thrownCompletionCanReachMatcher(statement, suspension),
+    );
+}
+
+function isConditionalBoundary(node, child, observer, suspension) {
+  if (node.type === "IfStatement" || node.type === "ConditionalExpression") {
+    return child !== node.test;
+  }
+  if (node.type === "LogicalExpression") return child === node.right;
+  if (node.type === "AssignmentPattern") return child === node.right;
+  if (node.type === "SwitchStatement") return child !== node.discriminant;
+  if (node.type === "TryStatement") {
+    if (child === node.handler) return !alwaysThrows(node.block);
+    return Boolean(child === node.block && throwCanSkipObserver(node.block, observer, suspension));
+  }
+  if (node.type === "ForStatement") return child !== node.init && child !== node.test;
+  if (node.type === "WhileStatement") return child !== node.test;
+  if (node.type === "ForInStatement" || node.type === "ForOfStatement") {
+    return child !== node.right;
+  }
+  return isOptionalCall(node) || node.type === "DoWhileStatement";
+}
+
+function statementsFor(container) {
+  return container.type === "BlockStatement" ? container.body : container.consequent;
+}
+
+function directChildIn(node, container) {
+  let current = node;
+  while (current.parent && current.parent !== container) current = current.parent;
+  return current.parent === container ? current : null;
+}
+
+function executesBefore(observer, suspension) {
+  if (contains(suspension, observer)) {
+    let current = observer;
+    while (current !== suspension) {
+      const parent = current.parent;
+      if (isConditionalBoundary(parent, current, observer, suspension)) {
+        return false;
+      }
+      current = parent;
+    }
+    return true;
+  }
+  let current = observer;
+  let conditional = false;
+  while (current.parent) {
+    const parent = current.parent;
+    if (!conditional && childExecutesBefore(parent, current, suspension)) return true;
+    if ((parent.type === "BlockStatement" || parent.type === "SwitchCase") && !conditional) {
+      const suspensionStatement = directChildIn(suspension, parent);
+      if (suspensionStatement) {
+        const statements = statementsFor(parent);
+        if (statements.indexOf(current) < statements.indexOf(suspensionStatement)) return true;
+      }
+    }
+    if (isConditionalBoundary(parent, current, observer, suspension)) conditional = true;
+    current = parent;
+  }
+  return false;
+}
+
+module.exports = { canReachMatcher, contains, executesBefore };