eslint-plugin-no-mistakes 0.91.3 → 0.93.0

package/README.md

@@ -34,3 +34,19 @@ 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)
 for options and examples.
+
+`gh-api-argument-safety` is an opt-in rule for structured endpoint fields and explicit API methods.
+See [options and examples](../../docs/eslint-rules/gh-api-argument-safety.md).
+
+`no-argv-main-guard` is an opt-in rule for symlink-sensitive entrypoint comparisons.
+See [options and examples](../../docs/eslint-rules/no-argv-main-guard.md).
+
+`no-comment-phrases` is an opt-in rule for configured phrases in line and block comments.
+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).
+
+`require-options-on-imported-call` requires a static options object on configured
+imports, globals with no local binding, and terminal methods with a matching receiver shape.
+See [options and examples](../../docs/eslint-rules/require-options-on-imported-call.md).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-no-mistakes",
-  "version": "0.91.3",
+  "version": "0.93.0",
   "description": "ESLint and Oxlint rules that keep code static enough for no-mistakes analyzers and coding agents",
   "license": "MIT",
   "repository": {

package/src/index.js

@@ -1,6 +1,10 @@
 "use strict";
 
 const rules = {
+  "forbidden-member-chains": require("./rules/forbidden-member-chains"),
+  "gh-api-argument-safety": require("./rules/gh-api-argument-safety"),
+  "no-argv-main-guard": require("./rules/no-argv-main-guard"),
+  "no-comment-phrases": require("./rules/no-comment-phrases"),
   "async-call-disposition": require("./rules/async-call-disposition"),
   "async-try-catch-return-await": require("./rules/async-try-catch-return-await"),
   "await-array-methods": require("./rules/await-array-methods"),

package/src/rule-suppression.js

@@ -1,11 +1,13 @@
 "use strict";
 
 // Parse actual comments once; directive-looking string literals never suppress.
-function ruleSuppression(context, ruleId) {
+// requireReason is opt-in. Callers that omit it keep today's directive match.
+function ruleSuppression(context, ruleId, suppressionOptions) {
   const lines = new Set();
   let file = false;
   const source = context.sourceCode;
   const first = source.ast.tokens[0];
+  const requireReason = suppressionOptions?.requireReason === true;
   for (const comment of source.getAllComments()) {
     for (const [offset, text] of comment.value.split(/\r?\n/).entries()) {
       const match = /^\s*\*?\s*no-mistakes-disable-(file|line|next-line)\b(.*)$/.exec(text);
@@ -20,6 +22,7 @@ function ruleSuppression(context, ruleId) {
         !names.some((name) => name === ruleId || name === `no-mistakes/${ruleId}`)
       )
         continue;
+      if (requireReason && !directiveReason(match[2])) continue;
       if (match[1] === "file") {
         if (!first || comment.range[1] <= first.range[0]) file = true;
       } else {
@@ -29,4 +32,11 @@ function ruleSuppression(context, ruleId) {
   }
   return (node) => file || lines.has(node.loc.start.line);
 }
+
+function directiveReason(tail) {
+  const marker = tail.indexOf("--");
+  if (marker === -1) return "";
+  return tail.slice(marker + 2).trim();
+}
+
 module.exports = { ruleSuppression };

package/src/rules/argv-main-values.js

@@ -0,0 +1,114 @@
+"use strict";
+const { unwrapExpression } = require("./async-ast");
+const { resolveVariable, memberPropertyName, isLocalRequire } = require("./async-target-bindings");
+const { literalString } = require("./module-mock-helpers");
+
+function globalName(node, name, context) {
+  if (node?.type !== "Identifier" || node.name !== name) return false;
+  return !resolveVariable(node, context)?.defs.length;
+}
+function nodeProcess(node, context) {
+  if (globalName(node, "process", context)) return true;
+  if (node?.type !== "Identifier") return false;
+  const variable = resolveVariable(node, context);
+  const def = variable?.defs.length === 1 ? variable.defs[0] : null;
+  if (def?.type === "ImportBinding") {
+    return (
+      ["ImportDefaultSpecifier", "ImportNamespaceSpecifier"].includes(def.node.type) &&
+      ["process", "node:process"].includes(def.parent.source.value)
+    );
+  }
+  const init = unwrapExpression(def?.node.init);
+  return (
+    def?.parent?.kind === "const" &&
+    def.node.id.type === "Identifier" &&
+    init?.type === "CallExpression" &&
+    init.callee.type === "Identifier" &&
+    init.callee.name === "require" &&
+    !isLocalRequire(init.callee, context) &&
+    ["process", "node:process"].includes(literalString(init.arguments[0]))
+  );
+}
+const ARGV = 1;
+const MAIN = 2;
+const PROCESS = 3;
+const ARGUMENTS = 4;
+function createClassifier(context, wrappers) {
+  const stable = new WeakMap();
+  const aliases = new WeakMap();
+  function classify(input, depth = 0) {
+    const node = unwrapExpression(input);
+    if (!node || depth > 32) return 0;
+    if (node.type === "Identifier") {
+      const variable = resolveVariable(node, context);
+      if (!variable) {
+        if (nodeProcess(node, context)) return PROCESS;
+        return globalName(node, "__filename", context) ? MAIN : 0;
+      }
+      if (!stable.has(variable))
+        stable.set(variable, !variable.references.some((r) => r.isWrite() && !r.init));
+      if (!stable.get(variable)) return 0;
+      if (nodeProcess(node, context)) return PROCESS;
+      if (globalName(node, "__filename", context)) return MAIN;
+      const def = variable.defs.length === 1 ? variable.defs[0] : null;
+      if (
+        def?.type !== "Variable" ||
+        def.parent.kind !== "const" ||
+        def.node.id.type !== "Identifier" ||
+        def.node.range[1] > node.range[0]
+      )
+        return 0;
+      if (!aliases.has(variable)) {
+        aliases.set(variable, 0);
+        aliases.set(variable, classify(def.node.init, depth + 1));
+      }
+      return aliases.get(variable);
+    }
+    if (node.type === "MemberExpression") {
+      const name = memberPropertyName(node);
+      if (
+        node.object.type === "MetaProperty" &&
+        node.object.meta.name === "import" &&
+        node.object.property.name === "meta" &&
+        ["url", "filename"].includes(name)
+      )
+        return MAIN;
+      const object = classify(node.object, depth + 1);
+      if (object === PROCESS && name === "argv") return ARGUMENTS;
+      if (
+        object === ARGUMENTS &&
+        node.computed &&
+        node.property.type === "Literal" &&
+        node.property.value === 1
+      )
+        return ARGV;
+      // A URL conversion's href preserves the same module/argv identity.
+      if (
+        name === "href" &&
+        unwrapExpression(node.object).type === "CallExpression" &&
+        wrappers.resolveCallTarget(unwrapExpression(node.object))?.calleeName === "pathToFileURL"
+      )
+        return object;
+    }
+    if (node.type === "CallExpression") {
+      const callee = unwrapExpression(node.callee);
+      if (
+        callee?.type === "MemberExpression" &&
+        memberPropertyName(callee) === "at" &&
+        classify(callee.object, depth + 1) === ARGUMENTS &&
+        node.arguments.length === 1 &&
+        node.arguments[0].type === "Literal" &&
+        node.arguments[0].value === 1
+      )
+        return ARGV;
+      if (node.arguments.length !== 1 || node.arguments[0].type === "SpreadElement") return 0;
+      if (globalName(callee, "Boolean", context) || wrappers.resolveCallTarget(node)) {
+        const value = classify(node.arguments[0], depth + 1);
+        return value === ARGV || value === MAIN ? value : 0;
+      }
+    }
+    return 0;
+  }
+  return (node) => classify(node);
+}
+module.exports = { createClassifier, ARGV, MAIN };

package/src/rules/forbidden-member-chains-destructure.js

@@ -0,0 +1,82 @@
+"use strict";
+
+const { matches, expressionInfo } = require("./forbidden-member-chains-match");
+
+function patternKey(prop) {
+  const key = prop.key;
+  if (key.type === "Identifier") return key.name;
+  if (key.type === "Literal" && (typeof key.value === "string" || typeof key.value === "number")) {
+    return String(key.value);
+  }
+  return null;
+}
+
+function objectPattern(node) {
+  let current = node;
+  while (current?.type === "AssignmentPattern") current = current.left;
+  return current?.type === "ObjectPattern" ? current : null;
+}
+
+function destructureVisitors({ compiled, context, suppressed, info }) {
+  // The outer pattern and a default can reach the same property and chain.
+  // `const { panel: { open } = other.panel } = other` reports that pair once.
+  const reported = new WeakMap();
+
+  function report(node, chain) {
+    if (suppressed(node)) return;
+    let seen = reported.get(node);
+    if (seen?.has(chain)) return;
+    if (!seen) {
+      seen = new Set();
+      reported.set(node, seen);
+    }
+    seen.add(chain);
+    context.report({ node, messageId: "forbiddenChain", data: { message: chain.message } });
+  }
+
+  // Computed keys are unproven, including string and numeric literals.
+  // A chain already matched by an outer property is not reported again.
+  function walk(pattern, chainInfo, blocked) {
+    for (const prop of pattern.properties) {
+      if (prop.type !== "Property" || prop.computed) continue;
+      const name = patternKey(prop);
+      if (name == null) continue;
+      const next = { segments: chainInfo.segments.concat(name), rooted: chainInfo.rooted };
+      const blockedHere = new Set(blocked);
+      for (const chain of compiled) {
+        if (blockedHere.has(chain) || !matches(next, chain)) continue;
+        report(prop, chain);
+        blockedHere.add(chain);
+      }
+      const nested = objectPattern(prop.value);
+      if (nested) walk(nested, next, blockedHere);
+    }
+  }
+
+  function check(pattern, receiver) {
+    const chainInfo = expressionInfo(receiver, info);
+    if (!chainInfo) return;
+    walk(pattern, chainInfo, new Set());
+  }
+
+  return {
+    VariableDeclarator(node) {
+      const pattern = objectPattern(node.id);
+      if (pattern && node.init) check(pattern, node.init);
+    },
+    AssignmentExpression(node) {
+      const pattern = objectPattern(node.left);
+      if (pattern) check(pattern, node.right);
+    },
+    // A default is a receiver at any depth, not only on a function parameter.
+    // The parser only allows one in a parameter, property, or array element.
+    // `const { x: { open } = other.panel } = {}` reports `*.panel.open`.
+    // An array element is too: `const [{ open } = other.panel] = []`.
+    AssignmentPattern(node) {
+      const pattern = objectPattern(node.left);
+      if (pattern) check(pattern, node.right);
+    },
+  };
+}
+
+module.exports = { destructureVisitors };

package/src/rules/forbidden-member-chains-match.js

@@ -0,0 +1,120 @@
+"use strict";
+
+const MAX_WALK = 32;
+const TRANSPARENT = new Set([
+  "ChainExpression",
+  "ParenthesizedExpression",
+  "TSAsExpression",
+  "TSSatisfiesExpression",
+  "TSNonNullExpression",
+  "TSTypeAssertion",
+  "TSInstantiationExpression",
+  "TypeCastExpression",
+]);
+
+function unwrap(node) {
+  let current = node;
+  while (current && TRANSPARENT.has(current.type)) current = current.expression;
+  return current;
+}
+
+function literalKey(node) {
+  const value = unwrap(node);
+  if (
+    value?.type === "Literal" &&
+    (typeof value.value === "string" || typeof value.value === "number")
+  ) {
+    return String(value.value);
+  }
+  if (value?.type === "TemplateLiteral" && value.expressions.length === 0) {
+    return value.quasis.map((quasi) => quasi.value.cooked).join("");
+  }
+  return null;
+}
+
+function staticProperty(member) {
+  if (member.computed) return literalKey(member.property);
+  const property = member.property;
+  return property.type === "PrivateIdentifier" ? `#${property.name}` : property.name;
+}
+
+function rooted(segments, node) {
+  if (node?.type === "Identifier") segments.unshift(node.name);
+  else if (node?.type === "ThisExpression") segments.unshift("this");
+  else if (node?.type === "Super") segments.unshift("super");
+  else if (node?.type === "MetaProperty") segments.unshift(node.meta.name, node.property.name);
+  else return false;
+  return true;
+}
+
+function computeChain(member) {
+  const segments = [];
+  let current = member;
+  for (let steps = 0; current?.type === "MemberExpression"; steps += 1) {
+    if (steps >= MAX_WALK) return null;
+    const name = staticProperty(current);
+    if (name == null) return { segments, rooted: false };
+    segments.unshift(name);
+    current = unwrap(current.object);
+  }
+  return { segments, rooted: rooted(segments, current) };
+}
+
+function matches(info, chain) {
+  if (!info) return false;
+  const { segments, rooted: fromRoot } = info;
+  const { parts } = chain;
+  if (segments.length < parts.length) return false;
+  const start = segments.length - parts.length;
+  for (let index = 0; index < parts.length; index += 1) {
+    if (segments[start + index] !== parts[index]) return false;
+  }
+  // A wildcard needs a receiver. An opaque receiver is not one of the segments.
+  if (!chain.wildcard) return fromRoot && start === 0;
+  return start > 0 || !fromRoot;
+}
+
+function surface(node) {
+  let current = node;
+  while (
+    current.parent &&
+    TRANSPARENT.has(current.parent.type) &&
+    unwrap(current.parent) === node
+  ) {
+    current = current.parent;
+  }
+  return current;
+}
+
+function hasMatchingAncestor(node, chain, info) {
+  let current = node;
+  for (;;) {
+    const parent = surface(current).parent;
+    if (!parent || parent.type !== "MemberExpression" || unwrap(parent.object) !== current) {
+      return false;
+    }
+    if (matches(info(parent), chain)) return true;
+    current = parent;
+  }
+}
+
+function invocationOf(member) {
+  const parent = surface(member).parent;
+  if (parent.type !== "CallExpression" && parent.type !== "NewExpression") return null;
+  return unwrap(parent.callee) === member ? parent : null;
+}
+
+function expressionInfo(node, memberInfo) {
+  const value = unwrap(node);
+  if (value.type === "MemberExpression") return memberInfo(value);
+  const segments = [];
+  return { segments, rooted: rooted(segments, value) };
+}
+
+module.exports = {
+  matches,
+  computeChain,
+  hasMatchingAncestor,
+  invocationOf,
+  expressionInfo,
+};

package/src/rules/forbidden-member-chains-schema.js

@@ -0,0 +1,132 @@
+"use strict";
+
+const MAX_SEGMENTS = 16;
+// A segment is non-empty and is not exactly "*". The star is only a leading receiver.
+const SEGMENT = "(?!\\*(?:\\.|$))[^.]+";
+const OPEN_PATH = `^(?:\\*(?:\\.${SEGMENT}){1,15}|${SEGMENT}(?:\\.${SEGMENT}){0,15})$`;
+// A named receiver replaces a leading "*" and still counts toward 16 segments.
+const NAMED_PATH = `^(?:\\*|\\*(?:\\.${SEGMENT}){1,15}|${SEGMENT}(?:\\.${SEGMENT}){0,14})$`;
+
+function text(maxLength, pattern) {
+  return pattern
+    ? { type: "string", minLength: 1, maxLength, pattern }
+    : { type: "string", minLength: 1, maxLength };
+}
+
+function nonStar() {
+  return text(128, "^(?!\\*$)[\\s\\S]+$");
+}
+
+// Segment rules run in assertPath so a bad path names the segment. A JSON Schema
+// anyOf only says the value matched none of the alternatives.
+const pathValue = {
+  anyOf: [
+    { type: "string", minLength: 1, maxLength: 256 },
+    {
+      type: "array",
+      minItems: 1,
+      maxItems: 32,
+      items: { type: "string", minLength: 1, maxLength: 128 },
+    },
+  ],
+};
+
+function chain(properties, required) {
+  return {
+    type: "object",
+    additionalProperties: false,
+    required,
+    properties: { message: text(512), ...properties },
+  };
+}
+
+const schema = [
+  {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      chains: {
+        type: "array",
+        maxItems: 64,
+        items: {
+          anyOf: [
+            chain({ path: pathValue }, ["path", "message"]),
+            chain(
+              {
+                path: pathValue,
+                receiver: { type: "string", enum: ["*"] },
+              },
+              ["path", "message", "receiver"],
+            ),
+            chain(
+              {
+                path: pathValue,
+                receiver: nonStar(),
+              },
+              ["path", "message", "receiver"],
+            ),
+          ],
+        },
+      },
+    },
+  },
+];
+
+function shownPath(path) {
+  return Array.isArray(path) ? path.join(".") : String(path);
+}
+
+function assertPath(path, named) {
+  const parts = Array.isArray(path) ? path : String(path).split(".");
+  const shown = shownPath(path);
+  const empty = parts.findIndex((part) => part === "");
+  if (empty !== -1) throw new Error(`empty segment at index ${empty} in '${shown}'`);
+  const star = parts.findIndex((part, index) => part === "*" && index !== 0);
+  if (star !== -1) {
+    throw new Error(`'*' segment at index ${star} in '${shown}'; '*' is only a leading segment`);
+  }
+  if (typeof path === "string") {
+    const pattern = new RegExp(named ? NAMED_PATH : OPEN_PATH);
+    if (pattern.test(path)) return;
+    const limit = named && parts[0] !== "*" ? MAX_SEGMENTS - 1 : MAX_SEGMENTS;
+    if (parts.length > limit) {
+      throw new Error(`path '${shown}' has ${parts.length} segments; the maximum is ${limit}`);
+    }
+    throw new Error(`malformed path '${shown}'`);
+  }
+  const leadingStar = parts[0] === "*";
+  const limit = leadingStar ? MAX_SEGMENTS : named ? MAX_SEGMENTS - 1 : MAX_SEGMENTS;
+  const min = leadingStar ? (named ? 1 : 2) : 1;
+  if (parts.length < min) {
+    throw new Error(`path '${shown}' has ${parts.length} segments; at least ${min} are required`);
+  }
+  if (parts.length > limit) {
+    throw new Error(`path '${shown}' has ${parts.length} segments; the maximum is ${limit}`);
+  }
+}
+
+function assertChains(entries) {
+  if (!Array.isArray(entries)) return;
+  for (const entry of entries) {
+    assertPath(entry.path, typeof entry.receiver === "string" && entry.receiver !== "*");
+  }
+}
+
+function compile(entry) {
+  assertPath(entry.path, typeof entry.receiver === "string" && entry.receiver !== "*");
+  const parts = Array.isArray(entry.path) ? entry.path.slice() : entry.path.split(".");
+  let wildcard = false;
+  let body = parts;
+  if (body[0] === "*") {
+    wildcard = true;
+    body = body.slice(1);
+  }
+  if (entry.receiver === "*") wildcard = true;
+  else if (typeof entry.receiver === "string") {
+    body = [entry.receiver, ...body];
+    wildcard = false;
+  }
+  return { wildcard, parts: body, message: entry.message };
+}
+
+module.exports = { schema, compile, assertChains };

package/src/rules/forbidden-member-chains.js

@@ -0,0 +1,50 @@
+"use strict";
+
+const { ruleSuppression } = require("../rule-suppression");
+const { schema, compile, assertChains } = require("./forbidden-member-chains-schema");
+const {
+  matches,
+  computeChain,
+  hasMatchingAncestor,
+  invocationOf,
+} = require("./forbidden-member-chains-match");
+const { destructureVisitors } = require("./forbidden-member-chains-destructure");
+
+module.exports = {
+  meta: {
+    type: "problem",
+    docs: { description: "ban configured static member-access chains", recommended: false },
+    schema,
+    messages: { forbiddenChain: "{{message}}" },
+  },
+  create(context) {
+    const compiled = [];
+    const entries = context.options[0]?.chains;
+    assertChains(entries);
+    if (Array.isArray(entries)) {
+      for (const entry of entries) compiled.push(compile(entry));
+    }
+    if (compiled.length === 0) return {};
+    const suppressed = ruleSuppression(context, "forbidden-member-chains");
+    const cache = new WeakMap();
+    const info = (member) => {
+      if (cache.has(member)) return cache.get(member);
+      const value = computeChain(member);
+      cache.set(member, value);
+      return value;
+    };
+    const report = (node, chain) => {
+      if (suppressed(node)) return;
+      context.report({ node, messageId: "forbiddenChain", data: { message: chain.message } });
+    };
+    return {
+      MemberExpression(node) {
+        for (const chain of compiled) {
+          if (!matches(info(node), chain) || hasMatchingAncestor(node, chain, info)) continue;
+          report(invocationOf(node) || node, chain);
+        }
+      },
+      ...destructureVisitors({ compiled, context, suppressed, info }),
+    };
+  },
+};