eslint-plugin-no-mistakes 0.98.0 → 0.100.0

package/README.md

@@ -9,6 +9,24 @@ callers, fetches, or selectors behind aliases and dynamic values. See
 npm install --save-dev eslint-plugin-no-mistakes
 ```
 
+For `async-call-disposition` to inspect imported callback implementations when
+the linter does not provide a TypeScript program (including Oxlint's
+`--type-aware` mode), also install `typescript` in your project:
+
+```sh
+npm install --save-dev typescript
+```
+
+`typescript` and `@typescript-eslint/parser` are optional peers, but only
+`typescript` is required for the cross-file proof. When the ESLint parser is
+absent, the proof parses supported syntax with `ts.createSourceFile`; unsupported
+syntax stays unproven. This fallback requires TypeScript 5 or
+later for Bundler module resolution. With older TypeScript or missing or
+incompatible tooling, calls that rely on this cross-file proof are reported as
+unproven. Same-file proofs and explicitly configured awaiting-consumer
+contracts continue to work. When ESLint provides a typed TypeScript program,
+the rule continues to use that program for its typed proof.
+
 Configure the plugin in a flat config and scope rules with `files` globs. For
 example, this checks test files for skipped or exclusive tests while allowing
 `todo`:
@@ -32,7 +50,9 @@ for the complete list.
 To cap long Vitest timeouts, enable `no-mistakes/vitest-timeout-cap` in the
 test and Vitest config files selected by your flat-config globs. It defaults to
 5,000 ms for configured test and hook timeouts and 30,000 ms for per-test and
-hook overrides. See the [rule documentation](../../docs/eslint-rules/vitest-timeout-cap.md)
+hook overrides. Overrides above the default cap require an adjacent
+`// no-mistakes-timeout-reason: <specific reason>` comment.
+See the [rule documentation](../../docs/eslint-rules/vitest-timeout-cap.md)
 for options and examples.
 
 `gh-api-argument-safety` is an opt-in rule for structured endpoint fields and explicit API methods.
@@ -47,6 +67,9 @@ See [options and examples](../../docs/eslint-rules/no-comment-phrases.md).
 `forbidden-member-chains` is an opt-in rule for configured static member-access chains.
 See [options and examples](../../docs/eslint-rules/forbidden-member-chains.md).
 
+`playwright-no-swallowed-visibility` is an opt-in rule for Playwright state checks whose rejection becomes a boolean literal.
+See [options and examples](../../docs/eslint-rules/playwright-no-swallowed-visibility.md).
+
 `no-object-mutation` is an opt-in rule for shared object writes and mutating calls.
 See [options and examples](../../docs/eslint-rules/no-object-mutation.md).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-no-mistakes",
-  "version": "0.98.0",
+  "version": "0.100.0",
   "description": "ESLint and Oxlint rules that keep code static enough for no-mistakes analyzers and coding agents",
   "license": "MIT",
   "repository": {
@@ -21,16 +21,28 @@
     "test": "vitest run --coverage"
   },
   "devDependencies": {
-    "@typescript-eslint/parser": "^8.71.1",
-    "@vitest/coverage-v8": "^5.0.4",
-    "eslint": "^10.12.0",
-    "oxlint": "^1.87.0",
-    "vitest": "^5.0.4"
+    "@typescript-eslint/parser": "^8.72.0",
+    "@vitest/coverage-v8": "^5.0.5",
+    "eslint": "^10.13.0",
+    "oxlint": "^1.89.0",
+    "typescript": "^6.0.3",
+    "vitest": "^5.0.5"
   },
   "peerDependencies": {
-    "eslint": ">=9"
+    "@typescript-eslint/parser": ">=8",
+    "eslint": ">=9",
+    "typescript": ">=5"
+  },
+  "peerDependenciesMeta": {
+    "@typescript-eslint/parser": {
+      "optional": true
+    },
+    "typescript": {
+      "optional": true
+    }
   },
   "engines": {
     "node": "^20.19.0 || ^22.13.0 || >=24"
-  }
+  },
+  "//": "typescript stays on 6.0.3. TypeScript 7 makes the typescript-eslint parser throw on load. https://github.com/typescript-eslint/typescript-eslint/issues/12518 Related: https://github.com/typescript-eslint/typescript-eslint/issues/10940"
 }

package/src/adjacent-annotation.js

@@ -0,0 +1,72 @@
+"use strict";
+
+// Parentheses required by a parent construct are not grouping around the target.
+function syntaxParen(sourceCode, node) {
+  // ESTree wraps an optional registration without introducing any syntax.
+  while (node.parent?.type === "ChainExpression") node = node.parent;
+  const parent = node.parent;
+  if (!parent) return null;
+  if (["CallExpression", "NewExpression"].includes(parent.type)) {
+    return sourceCode.getTokenAfter(
+      parent.typeArguments || parent.typeParameters || parent.callee,
+      {
+        filter: (token) => token.value === "(",
+      },
+    );
+  }
+  if (
+    [
+      "IfStatement",
+      "WhileStatement",
+      "SwitchStatement",
+      "WithStatement",
+      "ImportExpression",
+    ].includes(parent.type)
+  )
+    return sourceCode.getTokenAfter(sourceCode.getFirstToken(parent));
+  if (parent.type === "DoWhileStatement")
+    return sourceCode.getTokenAfter(sourceCode.getTokenAfter(parent.body));
+  return null;
+}
+
+// Only comments, whitespace and grouping may separate an annotation and its target.
+// A comment trailing another statement belongs to that statement, never the target.
+function adjacentAnnotations(sourceCode, node, marker) {
+  const comments = [];
+  let left = node;
+  let right = node;
+  const boundary = syntaxParen(sourceCode, node);
+  for (;;) {
+    const previous = sourceCode.getTokenBefore(left, { includeComments: true });
+    if (!previous || left.loc.start.line - previous.loc.end.line > 1) break;
+    if (["Line", "Block"].includes(previous.type)) {
+      comments.push(previous);
+      left = previous;
+      continue;
+    }
+    const closing = sourceCode.getTokenAfter(right);
+    if (
+      previous.value !== "(" ||
+      closing?.value !== ")" ||
+      previous.range[0] === boundary?.range[0]
+    )
+      break;
+    left = previous;
+    right = closing;
+  }
+  const result = [];
+  for (const comment of comments) {
+    const previous = sourceCode.getTokenBefore(comment);
+    if (
+      previous?.loc.end.line === comment.loc.start.line &&
+      !["(", "[", "{", ",", ":"].includes(previous.value)
+    )
+      break;
+    for (const text of comment.value.split(/\r?\n/)) {
+      const normalized = text.replace(/^\s*\*?\s?/, "");
+      if (normalized.startsWith(marker)) result.push(normalized.slice(marker.length).trim());
+    }
+  }
+  return result;
+}
+module.exports = { adjacentAnnotations };

package/src/index.js

@@ -34,6 +34,7 @@ const rules = {
   "playwright-no-empty": require("./rules/playwright-no-empty"),
   "playwright-no-hoisted-unique-token": require("./rules/playwright-no-hoisted-unique-token"),
   "playwright-no-raw-scroll-pagination": require("./rules/playwright-no-raw-scroll-pagination"),
+  "playwright-no-swallowed-visibility": require("./rules/playwright-no-swallowed-visibility"),
   "playwright-prefer-get-by-test-id": require("./rules/playwright-prefer-get-by-test-id"),
   "playwright-require-exported-component-attribute": require("./rules/playwright-require-exported-component-attribute"),
   "playwright-require-interactive-test-id": require("./rules/playwright-require-interactive-test-id"),

package/src/rules/async-call-disposition.js

@@ -5,37 +5,36 @@ const { ruleSuppression } = require("../rule-suppression");
 const {
   collectedPromise,
   isPromiseAllCall,
-  retainedCollection,
   retainedPromise,
 } = require("./async-disposition-bindings");
 const {
   directlyDisposed,
+  mappedArgumentDisposed,
   observedExpression,
   promiseAllDisposed,
   mappedPromise,
 } = require("./async-disposition-expressions");
 const { dispositionOptionsSchema } = require("./async-schema");
 const { createTargetMatcher } = require("./async-targets");
+const { promiseChainFrom } = require("./async-disposition-observers");
 const { createAwaitingConsumers } = require("./async-disposition-consumers");
+const { createPromiseHandoff } = require("./async-promise-handoff");
+const { possibleValueType } = require("./async-source-candidates");
+const { sourcesUnavailable, withSourceOwner } = require("./async-source-owner");
 
-function isDisposed(node, context, returnsThroughConsumer, seen = new Set()) {
+function isDisposed(node, context, consumers, seen = new Set(), catchProven = true) {
   if (seen.has(node)) return false;
   seen.add(node);
   const observed = observedExpression(node, context);
-  const disposed = (value) => isDisposed(value, context, returnsThroughConsumer, seen);
+  const retainedCatch =
+    catchProven && (observed === node || promiseChainFrom(observed, node, context));
+  const disposed = (value) => isDisposed(value, context, consumers, seen, retainedCatch);
   return (
-    directlyDisposed(node, context, returnsThroughConsumer) ||
-    directlyDisposed(observed, context, returnsThroughConsumer) ||
-    promiseAllDisposed(observed, context, returnsThroughConsumer) ||
+    directlyDisposed(node, context, consumers) ||
+    directlyDisposed(observed, context, consumers, catchProven ? node : null) ||
+    promiseAllDisposed(observed, context, consumers) ||
     retainedPromise(observed, context, disposed) ||
-    mappedPromise(observed, (value) =>
-      retainedCollection(
-        value,
-        context,
-        (aggregate) => isPromiseAllCall(aggregate, context),
-        disposed,
-      ),
-    ) ||
+    mappedPromise(observed, context, consumers, disposed) ||
     collectedPromise(
       observed,
       context,
@@ -46,7 +45,7 @@ function isDisposed(node, context, returnsThroughConsumer, seen = new Set()) {
   );
 }
 
-module.exports = rule(
+const dispositionRule = rule(
   {
     type: "problem",
     docs: {
@@ -63,7 +62,24 @@ module.exports = rule(
   },
   (context) => {
     const matcher = createTargetMatcher(context);
-    const consumers = createAwaitingConsumers(context);
+    const sourceFacts = {
+      typed: new WeakMap(),
+      sources: sourcesUnavailable(context) ? false : null,
+      targets: matcher.targets,
+    };
+    const { promiseSlotHandoff, promiseTypedTargetCall } = createPromiseHandoff(
+      context,
+      sourceFacts,
+    );
+    const consumers = createAwaitingConsumers(
+      context,
+      (fn, argument) =>
+        mappedArgumentDisposed(fn, argument, context, consumers, (value) =>
+          isDisposed(value, context, consumers),
+        ),
+      sourceFacts,
+      promiseSlotHandoff,
+    );
     const suppressed = ruleSuppression(context, "async-call-disposition");
     if (!matcher.hasTargets) return {};
 
@@ -78,12 +94,14 @@ module.exports = rule(
         ]),
       ),
       CallExpression(node) {
-        if (
-          !matcher.isTargetCall(node) ||
-          suppressed(node) ||
-          isDisposed(node, context, consumers.returnsThroughConsumer)
-        )
+        if (suppressed(node)) return;
+        const target = matcher.isTargetCall(node);
+        // Unrelated calls cannot need a callback-body or imported type proof.
+        if (!target && (sourceFacts.sources === false || !possibleValueType(node.callee, context)))
           return;
+        // Disposed calls need no cross-file type lookup, including local/configured JS consumers.
+        if (isDisposed(node, context, consumers)) return;
+        if (!target && !promiseTypedTargetCall(node)) return;
         context.report({
           node,
           messageId: "disposition",
@@ -103,3 +121,5 @@ module.exports = rule(
     };
   },
 );
+
+module.exports = withSourceOwner(dispositionRule);

package/src/rules/async-consumer-cache-proof.js

@@ -0,0 +1,146 @@
+"use strict";
+
+const { resolveVariable, resolveRuntimeVariable } = require("./async-target-bindings");
+const { propertiesWritten } = require("./async-disposition-mocks");
+
+function sameKey(first, key, context) {
+  if (key?.type === "Literal")
+    return typeof key.value === "string" && first?.type === "Literal" && first.value === key.value;
+  return (
+    first?.type === "Identifier" &&
+    key?.type === "Identifier" &&
+    resolveVariable(first, context) === resolveVariable(key, context)
+  );
+}
+
+function stableKey(key, fn, param, context) {
+  if (key?.type === "Literal") return typeof key.value === "string";
+  if (key?.type !== "Identifier") return false;
+  const variable = resolveVariable(key, context);
+  if (!variable) return false;
+  return (
+    fn.params.some((item) => item !== param && resolveVariable(item, context) === variable) &&
+    !variable.references.some((ref) => ref.isWrite())
+  );
+}
+
+function builtinMap(node, context) {
+  if (resolveVariable(node, context)?.defs.length || propertiesWritten(node, context)) return false;
+  // Global-holder writes can replace Map without mentioning its bare identifier.
+  const references = context.sourceCode.scopeManager.scopes
+    .flatMap((scope) => scope.references)
+    .filter((ref) => !(ref.isTypeReference && !ref.isValueReference));
+  if (
+    references.some(
+      (ref) =>
+        ["eval", "Function"].includes(ref.identifier.name) &&
+        !resolveRuntimeVariable(ref.identifier, context)?.defs.length,
+    )
+  )
+    return false;
+  const binding = resolveRuntimeVariable(node, context);
+  // Do not infer built-in semantics after the constructor/prototype escapes to
+  // reflective APIs or unknown consumers, whose effects are not modeled here.
+  if (
+    references.some(
+      (ref) =>
+        ref.identifier.name === "Map" &&
+        resolveRuntimeVariable(ref.identifier, context) === binding &&
+        !(
+          ref.identifier.parent.type === "NewExpression" &&
+          ref.identifier.parent.callee === ref.identifier
+        ),
+    )
+  )
+    return false;
+  const holders = ["globalThis", "global", "window", "self"];
+  return !references.some((ref) => {
+    if (!holders.includes(ref.identifier.name)) return false;
+    if (resolveRuntimeVariable(ref.identifier, context)?.defs.length) return false;
+    if (propertiesWritten(ref.identifier, context)) return true;
+    const member = ref.identifier.parent;
+    if (member.type !== "MemberExpression" || member.object !== ref.identifier) return true;
+    const name = member.computed ? member.property.value : member.property.name;
+    if (["eval", "Function"].includes(name)) return true;
+    if (name !== "Map" && typeof name === "string") return false;
+    return member.parent.type !== "NewExpression" || member.parent.callee !== member;
+  });
+}
+
+function mapCall(node, method, cache, key, context, count) {
+  const member = node?.callee;
+  const first = node?.arguments?.[0];
+  return (
+    node?.type === "CallExpression" &&
+    !node.optional &&
+    node.arguments.length === count &&
+    member?.type === "MemberExpression" &&
+    !member.computed &&
+    !member.optional &&
+    member.property.name === method &&
+    member.object.type === "Identifier" &&
+    resolveVariable(member.object, context) === cache &&
+    sameKey(first, key, context)
+  );
+}
+
+// This is deliberately a complete body grammar: any intervening effect, alias,
+// escape, overwrite, early return, or exception may strand the stored promise.
+function cachedBodyAwaited(fn, param, context) {
+  if (!fn.async || fn.generator || fn.params.some((item) => item.type !== "Identifier"))
+    return false;
+  const body = fn.body?.type === "BlockStatement" ? fn.body.body : [];
+  if (body.length !== 3) return false;
+  const [declaration, guard, returned] = body;
+  const entry = declaration.declarations?.[0];
+  const init = entry?.init;
+  if (
+    declaration.type !== "VariableDeclaration" ||
+    declaration.kind !== "const" ||
+    declaration.declarations.length !== 1 ||
+    entry.id.type !== "Identifier" ||
+    init?.type !== "NewExpression" ||
+    init.callee.type !== "Identifier" ||
+    init.callee.name !== "Map" ||
+    init.arguments.length !== 0 ||
+    !builtinMap(init.callee, context)
+  )
+    return false;
+  const cache = resolveVariable(entry.id, context);
+  const test = guard.test;
+  const inserted =
+    guard.consequent?.type === "BlockStatement"
+      ? guard.consequent.body.length === 1 && guard.consequent.body[0]
+      : guard.consequent;
+  const set = inserted?.expression;
+  const key = set?.arguments?.[0];
+  if (
+    !stableKey(key, fn, param, context) ||
+    guard.type !== "IfStatement" ||
+    guard.alternate ||
+    test?.type !== "UnaryExpression" ||
+    test.operator !== "!" ||
+    inserted?.type !== "ExpressionStatement" ||
+    !mapCall(test.argument, "has", cache, key, context, 1) ||
+    !mapCall(set, "set", cache, key, context, 2) ||
+    returned.type !== "ReturnStatement" ||
+    returned.argument?.type !== "AwaitExpression" ||
+    !mapCall(returned.argument.argument, "get", cache, key, context, 1)
+  )
+    return false;
+  const invocation = set.arguments[1];
+  const parameter = resolveVariable(param, context);
+  const reads = parameter?.references.filter((ref) => !ref.init) || [];
+  return (
+    invocation?.type === "CallExpression" &&
+    !invocation.optional &&
+    invocation.arguments.length === 0 &&
+    invocation.callee.type === "Identifier" &&
+    resolveVariable(invocation.callee, context) === parameter &&
+    reads.length === 1 &&
+    !reads[0].isWrite() &&
+    reads[0].identifier === invocation.callee
+  );
+}
+
+module.exports = { cachedBodyAwaited };

package/src/rules/async-consumer-copy-spellings.js

@@ -0,0 +1,82 @@
+"use strict";
+
+const { unwrapTransparentParent } = require("./async-ast");
+const { followConst } = require("./async-consumer-property-carrier");
+
+const copyOperators = new Set(["??", "||"]);
+
+// Only the left operand is the supplied callback. The right-hand default is not.
+function unwrapCopyLogical(node) {
+  const selected = unwrapTransparentParent(node);
+  const parent = selected.parent;
+  if (
+    parent?.type === "LogicalExpression" &&
+    copyOperators.has(parent.operator) &&
+    parent.left === selected
+  )
+    return unwrapTransparentParent(parent);
+  return selected;
+}
+
+function logicalCopyLeft(value) {
+  if (value?.type !== "LogicalExpression" || !copyOperators.has(value.operator)) return null;
+  return value.left;
+}
+
+function plainProperty(entry) {
+  return entry.type === "Property" && !entry.computed && !entry.method && entry.kind === "init";
+}
+
+// A key before the spread is overwritten by the source object. A key after it
+// replaces the copied callback, so that order stays unproven.
+function propertyKey(key) {
+  return key.type === "Identifier" ? key.name : key.value;
+}
+
+function patternBinding(value) {
+  const node = value?.type === "AssignmentPattern" ? value.left : value;
+  return node?.type === "Identifier" ? node : null;
+}
+
+function spreadPreserves(object, spread, property) {
+  if (object?.type !== "ObjectExpression") return false;
+  const index = object.properties.indexOf(spread);
+  const keyOf = (entry) => propertyKey(entry.key);
+  return (
+    object.properties.slice(0, index).every(plainProperty) &&
+    object.properties
+      .slice(index + 1)
+      .every((entry) => plainProperty(entry) && keyOf(entry) !== property)
+  );
+}
+
+// Shorthand `const { name }` and `const { name = defaultImpl }` only. A rename,
+// rest, or computed key can hide the callback, so those patterns stay unproven.
+function destructuredBinding(declarator, property) {
+  if (declarator.parent.kind !== "const") return false;
+  let binding = null;
+  for (const entry of declarator.id.properties) {
+    if (entry.type !== "Property" || entry.computed || entry.kind !== "init") return false;
+    const name = propertyKey(entry.key);
+    const id = patternBinding(entry.value);
+    if (id?.name !== name) return false;
+    if (name === property) binding = id;
+  }
+  return binding ?? "safe";
+}
+
+// "safe" is a read of some other field. false is an unproven pattern.
+function destructureMode(value, property, context, shape, api, seen) {
+  const declarator = value.parent;
+  if (
+    declarator?.type !== "VariableDeclarator" ||
+    declarator.init !== value ||
+    declarator.id.type !== "ObjectPattern"
+  )
+    return null;
+  const binding = destructuredBinding(declarator, property);
+  if (binding === "safe" || binding === false) return binding;
+  return followConst(binding, null, context, shape, api, seen);
+}
+
+module.exports = { destructureMode, logicalCopyLeft, spreadPreserves, unwrapCopyLogical };

package/src/rules/async-consumer-imported-proof.js

@@ -0,0 +1,96 @@
+"use strict";
+const { createImportedSources } = require("./async-source-store");
+const { unwrapExpression } = require("./async-ast");
+const { resolveVariable } = require("./async-target-bindings");
+const { propertiesWritten } = require("./async-disposition-mocks");
+const { localFunction } = require("./async-consumer-local-proof");
+
+function exportedFunction(filename, name, sources, seen = new Set()) {
+  if (seen.size >= 32 || seen.has(filename)) return null;
+  seen.add(filename);
+  const source = sources.load(filename);
+  if (!source) return null;
+  const matches = [];
+  for (const statement of source.ast.body) {
+    if (statement.type !== "ExportNamedDeclaration" || statement.exportKind === "type") continue;
+    const declaration = statement.declaration;
+    const ids =
+      declaration?.type === "FunctionDeclaration"
+        ? [declaration.id]
+        : declaration?.type === "VariableDeclaration"
+          ? declaration.declarations.map((item) => item.id)
+          : [];
+    for (const id of ids) if (id?.name === name) matches.push({ local: id });
+    for (const item of statement.specifiers)
+      if (item.exportKind !== "type" && (item.exported.name ?? item.exported.value) === name)
+        matches.push({ local: item.local, source: statement.source });
+  }
+  if (matches.length !== 1) return null;
+  const { local, source: reexport } = matches[0];
+  if (reexport) {
+    const target = sources.resolve(reexport.value, filename);
+    return target ? exportedFunction(target, local.name, sources, seen) : null;
+  }
+  const fn = localFunction(local, source.context);
+  const variable = resolveVariable(local, source.context);
+  // Exporting preserves live binding identity; any other non-call use may mutate it.
+  if (
+    !fn ||
+    variable.references.some((ref) => {
+      if (ref.init) return false;
+      const parent = ref.identifier.parent;
+      return (
+        parent.type !== "ExportSpecifier" &&
+        !(parent.type === "CallExpression" && parent.callee === ref.identifier)
+      );
+    })
+  )
+    return null;
+  return { fn, context: source.context };
+}
+
+function importedAwaited(call, index, context, state, property, proveBody) {
+  const program = context.sourceCode.parserServices?.program;
+  if (program?.getCompilerOptions().noResolve) return false;
+  if (program && property === null)
+    return require("./async-consumer-typed-proof").importedAwaited(
+      call,
+      index,
+      context,
+      state.typed,
+    );
+
+  const resolved = importedFunction(unwrapExpression(call.callee), context, state);
+  if (!resolved) return false;
+  const mode = proveBody(resolved.fn, index, resolved.context, property);
+  return mode?.returned ? { ...mode, async: Boolean(resolved.fn.async) } : mode;
+}
+
+function importedFunction(callee, context, state) {
+  const binding = resolveVariable(callee, context);
+  if (
+    binding?.defs.length !== 1 ||
+    binding.defs[0].type !== "ImportBinding" ||
+    binding.references.some((ref) => ref.isWrite()) ||
+    propertiesWritten(callee, context, new Set(), null, true)
+  )
+    return false;
+  const def = binding.defs[0];
+  if (
+    def.node.type !== "ImportSpecifier" ||
+    def.parent.importKind === "type" ||
+    def.node.importKind === "type"
+  )
+    return false;
+  // Cache unavailable peers too; a new lint context retries without persisting state.
+  if (state.sources === null) state.sources = createImportedSources(context) || false;
+  const sources = state.sources;
+  if (!sources) return false;
+  const filename = context.filename;
+  const target = sources.resolve(def.parent.source.value, filename);
+  const resolved =
+    target && exportedFunction(target, def.node.imported.name ?? def.node.imported.value, sources);
+  return resolved;
+}
+
+module.exports = { importedAwaited, importedFunction, createImportedSources };