eslint-plugin-no-mistakes 0.99.0 → 0.100.0

package/README.md

@@ -11,14 +11,16 @@ 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` and
-`@typescript-eslint/parser` in your project:
+`--type-aware` mode), also install `typescript` in your project:
 
 ```sh
-npm install --save-dev typescript @typescript-eslint/parser
+npm install --save-dev typescript
 ```
 
-These are optional peer dependencies. This fallback requires TypeScript 5 or
+`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
@@ -48,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.
@@ -63,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.99.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,17 +21,17 @@
     "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",
+    "@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.4"
+    "vitest": "^5.0.5"
   },
   "peerDependencies": {
     "@typescript-eslint/parser": ">=8",
     "eslint": ">=9",
-    "typescript": ">=4.8.4"
+    "typescript": ">=5"
   },
   "peerDependenciesMeta": {
     "@typescript-eslint/parser": {
@@ -43,5 +43,6 @@
   },
   "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

@@ -19,6 +19,8 @@ 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, consumers, seen = new Set(), catchProven = true) {
   if (seen.has(node)) return false;
@@ -43,7 +45,7 @@ function isDisposed(node, context, consumers, seen = new Set(), catchProven = tr
   );
 }
 
-module.exports = rule(
+const dispositionRule = rule(
   {
     type: "problem",
     docs: {
@@ -60,7 +62,11 @@ module.exports = rule(
   },
   (context) => {
     const matcher = createTargetMatcher(context);
-    const sourceFacts = { typed: new WeakMap(), sources: null, targets: matcher.targets };
+    const sourceFacts = {
+      typed: new WeakMap(),
+      sources: sourcesUnavailable(context) ? false : null,
+      targets: matcher.targets,
+    };
     const { promiseSlotHandoff, promiseTypedTargetCall } = createPromiseHandoff(
       context,
       sourceFacts,
@@ -89,9 +95,13 @@ module.exports = rule(
       ),
       CallExpression(node) {
         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 (!matcher.isTargetCall(node) && !promiseTypedTargetCall(node)) return;
+        if (!target && !promiseTypedTargetCall(node)) return;
         context.report({
           node,
           messageId: "disposition",
@@ -111,3 +121,5 @@ module.exports = rule(
     };
   },
 );
+
+module.exports = withSourceOwner(dispositionRule);

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

@@ -1,6 +1,6 @@
 "use strict";
 
-const { resolveVariable } = require("./async-target-bindings");
+const { resolveVariable, resolveRuntimeVariable } = require("./async-target-bindings");
 const { propertiesWritten } = require("./async-disposition-mocks");
 
 function sameKey(first, key, context) {
@@ -34,18 +34,18 @@ function builtinMap(node, context) {
     references.some(
       (ref) =>
         ["eval", "Function"].includes(ref.identifier.name) &&
-        !resolveVariable(ref.identifier, context)?.defs.length,
+        !resolveRuntimeVariable(ref.identifier, context)?.defs.length,
     )
   )
     return false;
-  const binding = resolveVariable(node, context);
+  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" &&
-        resolveVariable(ref.identifier, context) === binding &&
+        resolveRuntimeVariable(ref.identifier, context) === binding &&
         !(
           ref.identifier.parent.type === "NewExpression" &&
           ref.identifier.parent.callee === ref.identifier
@@ -56,7 +56,7 @@ function builtinMap(node, context) {
   const holders = ["globalThis", "global", "window", "self"];
   return !references.some((ref) => {
     if (!holders.includes(ref.identifier.name)) return false;
-    if (resolveVariable(ref.identifier, context)?.defs.length) 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;

package/src/rules/async-observer-mutations.js

@@ -2,7 +2,10 @@
 
 const { isPromiseMethodCall } = require("./async-disposition-bindings");
 const { unwrapExpression } = require("./async-ast");
-const { resolveVariable, memberPropertyName } = require("./async-target-bindings");
+const {
+  resolveRuntimeVariable: resolveVariable,
+  memberPropertyName,
+} = require("./async-target-bindings");
 
 function observerMutated(node, context, suffix = []) {
   function paths(value, seen = new Set()) {

package/src/rules/async-source-candidates.js

@@ -0,0 +1,35 @@
+"use strict";
+
+const { resolveVariable, stableConstInitializer } = require("./async-target-bindings");
+
+const sourceTypeShapes = new Set([
+  "TSTypeReference",
+  "TSTypeQuery",
+  "TSTypeLiteral",
+  "TSIntersectionType",
+  "TSParenthesizedType",
+]);
+
+// Mirror the shapes valueType can follow without resolving or parsing imports.
+// In particular, an import or function declaration alone has no receiving type.
+function possibleValueType(value, context, seen = new Set()) {
+  if (!value || seen.size >= 32 || seen.has(value)) return false;
+  const next = new Set(seen).add(value);
+  if (value.type === "Identifier") {
+    const variable = resolveVariable(value, context);
+    if (variable?.defs.length !== 1) return false;
+    const type = variable.defs[0].name?.typeAnnotation?.typeAnnotation;
+    // Arrays, function signatures, and primitive annotations cannot establish
+    // targetType or a property contract in the bounded source type model.
+    if (type) return sourceTypeShapes.has(type.type);
+    if (variable.references.some((ref) => ref.isWrite() && !ref.init)) return false;
+    const init = stableConstInitializer(value, context, new Set());
+    return possibleValueType(init, context, next);
+  }
+  // declarations.callable only resolves identifier callees, including imported
+  // factories with a return-type alias. Member calls and IIFEs cannot contribute.
+  if (value.type === "CallExpression") return !value.optional && value.callee.type === "Identifier";
+  return value.type === "MemberExpression" && possibleValueType(value.object, context, next);
+}
+
+module.exports = { possibleValueType };

package/src/rules/async-source-declarations.js

@@ -6,14 +6,14 @@ const { unwrapExpression } = require("./async-ast");
 // Follow bounded static declarations. Missing source, cycles, and changing bindings
 // cannot establish the identity of a configured target or dependency type.
 function createDeclarations(sources) {
-  function exported(filename, name, seen = new Set(), budget = { remaining: 128 }) {
-    const key = `${filename}:${name}`;
-    if (budget.remaining-- <= 0 || seen.size >= 32 || seen.has(key)) return false;
-    seen = new Set(seen).add(key);
-    const source = sources.load(filename);
-    if (!source) return false;
-    const matches = [];
+  function exportIndex(source) {
+    if (source.exportIndex) return source.exportIndex;
+    const names = new Map();
     const stars = [];
+    function add(name, match) {
+      if (!names.has(name)) names.set(name, []);
+      names.get(name).push(match);
+    }
     for (const statement of source.ast.body) {
       if (statement.type === "ExportAllDeclaration") {
         if (!statement.exported) stars.push(statement.source.value);
@@ -21,24 +21,41 @@ function createDeclarations(sources) {
       }
       if (statement.type !== "ExportNamedDeclaration") continue;
       const declaration = statement.declaration;
-      if (declaration?.id?.name === name) matches.push({ local: declaration.id });
+      if (declaration?.id?.name) add(declaration.id.name, { local: declaration.id });
       if (declaration?.type === "VariableDeclaration")
         for (const item of declaration.declarations)
-          if (item.id.type === "Identifier" && item.id.name === name)
-            matches.push({ local: item.id });
+          if (item.id.type === "Identifier") add(item.id.name, { local: item.id });
       for (const item of statement.specifiers)
-        if ((item.exported.name ?? item.exported.value) === name)
-          matches.push({ local: item.local, source: statement.source });
+        add(item.exported.name ?? item.exported.value, {
+          local: item.local,
+          source: statement.source,
+        });
     }
+    const index = { names, stars };
+    source.exportIndex = index;
+    return index;
+  }
+
+  function exported(filename, name, seen = new Set(), budget = { remaining: 128 }) {
+    const key = `${filename}:${name}`;
+    if (budget.remaining-- <= 0 || seen.size >= 32 || seen.has(key)) return false;
+    seen = new Set(seen).add(key);
+    const source = sources.load(filename);
+    if (!source) return false;
+    const { names, stars } = exportIndex(source);
+    const matches = names.get(name) || [];
     if (matches.length > 1) return false;
     if (!matches.length) {
-      const candidates = stars.map((specifier) => {
+      const found = [];
+      for (const specifier of stars) {
+        // Bound resolution work too, including cached or unresolved branches.
+        if (budget.remaining <= 0) return false;
         const target = sources.resolve(specifier, filename);
-        return target ? exported(target, name, seen, budget) : false;
-      });
-      // An unreadable branch may also export this name; absence is not proof.
-      if (candidates.includes(false)) return false;
-      const found = candidates.filter(Boolean);
+        const candidate = target ? exported(target, name, seen, budget) : false;
+        // An unreadable branch may also export this name; absence is not proof.
+        if (candidate === false) return false;
+        if (candidate) found.push(candidate);
+      }
       return found.length > 1 ? false : found[0] || null;
     }
     const match = matches[0];

package/src/rules/async-source-files.js

@@ -0,0 +1,42 @@
+"use strict";
+
+function parsedSource(filename, text, parser) {
+  const parsed = parser.parseForESLint(text, { filePath: filename, range: true, loc: true });
+  function parents(node, parent) {
+    node.parent = parent;
+    for (const key of parsed.visitorKeys[node.type] || []) {
+      const child = node[key];
+      if (Array.isArray(child)) child.forEach((item) => item && parents(item, node));
+      else if (child) parents(child, node);
+    }
+  }
+  parents(parsed.ast, null);
+  const sourceCode = {
+    ...parsed,
+    getScope(node) {
+      // Every parsed node has a Program ancestor with a global scope.
+      for (let owner = node; ; owner = owner.parent) {
+        const scope = parsed.scopeManager.acquire(owner, true);
+        if (scope) return scope;
+      }
+    },
+  };
+  return { ast: parsed.ast, context: { sourceCode, filename } };
+}
+
+function currentSources(context, store) {
+  const filename = context.filename;
+  let main;
+  return {
+    resolve: store.resolve,
+    load(path) {
+      // Oxlint reuses its Context/SourceCode/AST. Keep this overlay per file;
+      // the shared store contains only independently parsed imported sources.
+      return path === filename
+        ? (main ||= { ast: context.sourceCode.ast, context })
+        : store.load(path);
+    },
+  };
+}
+
+module.exports = { parsedSource, currentSources };

package/src/rules/async-source-owner.js

@@ -0,0 +1,75 @@
+"use strict";
+
+const { readFileSync, realpathSync } = require("node:fs");
+const { dirname, resolve } = require("node:path");
+
+// The public npm CLI calls native lint once. Editors, fix passes, and unknown
+// hosts have no invocation boundary available to a JS plugin, so stay per-file.
+function oneShotCli(entry = process.argv[1], args = process.argv.slice(2)) {
+  if (!entry || args.some((arg) => /^--(?:lsp|watch)(?:=|$)/.test(arg) || arg.startsWith("--fix")))
+    return false;
+  try {
+    const filename = realpathSync(entry);
+    const root = resolve(dirname(filename), "..");
+    const manifest = JSON.parse(readFileSync(resolve(root, "package.json"), "utf8"));
+    return (
+      manifest.name === "oxlint" &&
+      typeof manifest.bin?.oxlint === "string" &&
+      realpathSync(resolve(root, manifest.bin.oxlint)) === filename
+    );
+  } catch {
+    return false;
+  }
+}
+
+const activeOwners = new WeakMap();
+
+function sourceOwner(context) {
+  const owner = activeOwners.get(context);
+  if (!owner) return null;
+  owner.shared ??= oneShotCli();
+  return owner.shared ? owner : null;
+}
+
+function sourcesUnavailable(context) {
+  return activeOwners.get(context)?.sources === false;
+}
+
+function withSourceOwner(rule) {
+  rule.createOnce = (context) => {
+    const owner = { sources: null };
+    let visitor;
+    return {
+      ...Object.fromEntries(
+        [
+          "Program",
+          "ImportDeclaration",
+          "TSImportEqualsDeclaration",
+          "VariableDeclarator",
+          "CallExpression",
+        ].map((key) => [key, (node) => visitor[key]?.(node)]),
+      ),
+      before() {
+        activeOwners.set(context, owner);
+        try {
+          visitor = rule.create(context);
+          if (Object.keys(visitor).length === 0) {
+            visitor = null;
+            activeOwners.delete(context);
+            return false;
+          }
+        } catch (error) {
+          activeOwners.delete(context);
+          throw error;
+        }
+      },
+      after() {
+        visitor = null;
+        activeOwners.delete(context);
+      },
+    };
+  };
+  return rule;
+}
+
+module.exports = { oneShotCli, sourceOwner, sourcesUnavailable, withSourceOwner };

package/src/rules/async-source-session.js

@@ -0,0 +1,91 @@
+"use strict";
+
+const { dirname } = require("node:path");
+const { parsedSource } = require("./async-source-files");
+
+function createSourceSession(ts, parser) {
+  // Legacy resolution may inspect `main` while runtime `exports` selects another body.
+  if (
+    ts.ModuleResolutionKind.Bundler === undefined ||
+    typeof ts.createModuleResolutionCache !== "function"
+  )
+    return null;
+  const files = new Map();
+  const configs = new Map();
+  const configFiles = new Map();
+  const resolved = new Map();
+  const resolutionCaches = new Map();
+  const host = { ...ts.sys };
+  for (const method of ["readFile", "fileExists", "directoryExists", "realpath"]) {
+    if (!ts.sys[method]) continue;
+    const results = new Map();
+    host[method] = (path) => {
+      if (!results.has(path)) results.set(path, ts.sys[method](path));
+      return results.get(path);
+    };
+  }
+  function compilerOptions(config, path) {
+    const parsed = ts.parseJsonConfigFileContent(
+      config,
+      { ...host, readDirectory: () => [] },
+      dirname(path),
+      undefined,
+      path,
+    );
+    return parsed.errors.some((error) => error.code !== 18003) ? null : parsed.options;
+  }
+  function options(filename) {
+    const directory = dirname(filename);
+    if (!configs.has(directory)) {
+      const path = ts.findConfigFile(directory, host.fileExists);
+      if (!configFiles.has(path)) {
+        const config = path && ts.readConfigFile(path, host.readFile);
+        configFiles.set(
+          path,
+          config?.error
+            ? null
+            : config
+              ? compilerOptions(config.config, path)
+              : { moduleResolution: ts.ModuleResolutionKind.Bundler },
+        );
+      }
+      configs.set(directory, configFiles.get(path));
+    }
+    return configs.get(directory);
+  }
+  function resolve(source, filename) {
+    if (!resolved.has(filename)) resolved.set(filename, new Map());
+    const imports = resolved.get(filename);
+    if (!imports.has(source)) {
+      const config = options(filename);
+      let target = null;
+      if (config && !config.noResolve) {
+        // Resolver caches must not mix paths/baseUrl from distinct tsconfigs.
+        if (!resolutionCaches.has(config))
+          resolutionCaches.set(
+            config,
+            ts.createModuleResolutionCache(process.cwd(), (path) => path, config),
+          );
+        target = ts.resolveModuleName(source, filename, config, host, resolutionCaches.get(config))
+          .resolvedModule?.resolvedFileName;
+      }
+      imports.set(source, target);
+    }
+    return imports.get(source);
+  }
+  function load(filename) {
+    if (!files.has(filename)) {
+      files.set(filename, null);
+      const text = host.readFile(filename);
+      try {
+        files.set(filename, parsedSource(filename, text, parser));
+      } catch {
+        // Missing, ambient, or unsupported source never establishes an awaiting contract.
+      }
+    }
+    return files.get(filename);
+  }
+  return { resolve, load };
+}
+
+module.exports = { createSourceSession };