eslint-plugin-no-mistakes 0.58.0 → 0.60.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-no-mistakes",
-  "version": "0.58.0",
+  "version": "0.60.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

@@ -37,6 +37,7 @@ const rules = {
   "postgres-no-unbounded-query-fanout": require("./rules/postgres-no-unbounded-query-fanout"),
   "react-no-nullish-react-node": require("./rules/react-no-nullish-react-node"),
   "react-no-use-promise-resolve": require("./rules/react-no-use-promise-resolve"),
+  "require-options-on-imported-call": require("./rules/require-options-on-imported-call"),
   "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"),

package/src/rules/async-patterns.js

@@ -0,0 +1,73 @@
+"use strict";
+
+function safeRegExp(source) {
+  try {
+    return new RegExp(source);
+  } catch {
+    return null;
+  }
+}
+
+function patternToRegExp(pattern) {
+  if (pattern.startsWith("/") && pattern.endsWith("/") && pattern.length > 2) {
+    return safeRegExp(pattern.slice(1, -1));
+  }
+  let source = "^";
+  for (let index = 0; index < pattern.length; index += 1) {
+    const ch = pattern[index];
+    const next = pattern[index + 1];
+    if (ch === "*" && next === "*") {
+      if (pattern[index + 2] === "/") {
+        source += "(?:.*/)?";
+        index += 2;
+      } else {
+        source += ".*";
+        index += 1;
+      }
+    } else if (ch === "*") {
+      source += "[^/]*";
+    } else if (ch === "?") {
+      source += "[^/]";
+    } else {
+      source += ch.replace(/[\\^$+?.()|[\]{}]/g, "\\$&");
+    }
+  }
+  return safeRegExp(`${source}$`);
+}
+
+function compileTargets(options, optionKey) {
+  return (options[optionKey] || [])
+    .map((target) => ({
+      sourceSpecifierPatterns: (target.sourceSpecifierPatterns || [])
+        .map(patternToRegExp)
+        .filter(Boolean),
+      calleeNamePatterns: (target.calleeNamePatterns || []).map(patternToRegExp).filter(Boolean),
+    }))
+    .filter(
+      (target) => target.sourceSpecifierPatterns.length > 0 && target.calleeNamePatterns.length > 0,
+    );
+}
+
+function matchesAny(value, patterns) {
+  return typeof value === "string" && patterns.some((pattern) => pattern.test(value));
+}
+
+function matchingTargets(targets, source, calleeName) {
+  return targets.filter(
+    (target) =>
+      matchesAny(source, target.sourceSpecifierPatterns) &&
+      matchesAny(calleeName, target.calleeNamePatterns),
+  );
+}
+
+function targetMatches(targets, source, calleeName) {
+  return matchingTargets(targets, source, calleeName).length > 0;
+}
+
+module.exports = {
+  compileTargets,
+  matchingTargets,
+  matchesAny,
+  patternToRegExp,
+  targetMatches,
+};

package/src/rules/async-targets.js

@@ -1,67 +1,8 @@
 "use strict";
 
 const { unwrapExpression } = require("./async-ast");
-const { propertyName } = require("./module-mock-helpers");
-
-function safeRegExp(source) {
-  try {
-    return new RegExp(source);
-  } catch {
-    return null;
-  }
-}
-
-function patternToRegExp(pattern) {
-  if (pattern.startsWith("/") && pattern.endsWith("/") && pattern.length > 2) {
-    return safeRegExp(pattern.slice(1, -1));
-  }
-  let source = "^";
-  for (let index = 0; index < pattern.length; index += 1) {
-    const ch = pattern[index];
-    const next = pattern[index + 1];
-    if (ch === "*" && next === "*") {
-      if (pattern[index + 2] === "/") {
-        source += "(?:.*/)?";
-        index += 2;
-      } else {
-        source += ".*";
-        index += 1;
-      }
-    } else if (ch === "*") {
-      source += "[^/]*";
-    } else if (ch === "?") {
-      source += "[^/]";
-    } else {
-      source += ch.replace(/[\\^$+?.()|[\]{}]/g, "\\$&");
-    }
-  }
-  return safeRegExp(`${source}$`);
-}
-
-function compileTargets(options, optionKey) {
-  return (options[optionKey] || [])
-    .map((target) => ({
-      sourceSpecifierPatterns: (target.sourceSpecifierPatterns || [])
-        .map(patternToRegExp)
-        .filter(Boolean),
-      calleeNamePatterns: (target.calleeNamePatterns || []).map(patternToRegExp).filter(Boolean),
-    }))
-    .filter(
-      (target) => target.sourceSpecifierPatterns.length > 0 && target.calleeNamePatterns.length > 0,
-    );
-}
-
-function matchesAny(value, patterns) {
-  return typeof value === "string" && patterns.some((pattern) => pattern.test(value));
-}
-
-function targetMatches(targets, source, calleeName) {
-  return targets.some(
-    (target) =>
-      matchesAny(source, target.sourceSpecifierPatterns) &&
-      matchesAny(calleeName, target.calleeNamePatterns),
-  );
-}
+const { compileTargets, matchesAny, targetMatches } = require("./async-patterns");
+const { propertyName, literalString } = require("./module-mock-helpers");
 
 function findVariable(scope, name) {
   while (scope) {
@@ -81,14 +22,24 @@ function importSpecifierName(specifier) {
   return imported.type === "Literal" ? String(imported.value) : imported.name;
 }
 
-function requireSource(node) {
+function isLocalRequire(id, context) {
+  const variable = resolveVariable(id, context);
+  return Boolean(variable?.defs.some((def) => def.type && def.type !== "ImplicitGlobalVariable"));
+}
+
+function requireSource(node, context) {
   const expression = unwrapExpression(node);
-  return expression?.type === "CallExpression" &&
-    expression.callee.type === "Identifier" &&
-    expression.callee.name === "require" &&
-    typeof expression.arguments[0]?.value === "string"
-    ? expression.arguments[0].value
-    : null;
+  const source = literalString(unwrapExpression(expression?.arguments?.[0]));
+  if (
+    expression?.type !== "CallExpression" ||
+    expression.callee.type !== "Identifier" ||
+    expression.callee.name !== "require" ||
+    source === null ||
+    isLocalRequire(expression.callee, context)
+  ) {
+    return null;
+  }
+  return source;
 }
 
 function bindingIdentifier(node) {
@@ -98,7 +49,11 @@ function bindingIdentifier(node) {
 
 function memberPropertyName(node) {
   if (!node.computed) return propertyName(node.property);
-  return node.property?.type === "Literal" ? String(node.property.value) : null;
+  return staticComputedPropertyName(node.property);
+}
+
+function staticComputedPropertyName(node) {
+  return literalString(unwrapExpression(node));
 }
 
 function createTargetMatcher(context, optionKey = "targets") {
@@ -107,14 +62,36 @@ function createTargetMatcher(context, optionKey = "targets") {
   const directBindings = new Map();
   const namespaceBindings = new Map();
 
+  function isReassigned(id) {
+    const variable = resolveVariable(id, context);
+    const writes = variable?.references.filter((reference) => reference.isWrite()) || [];
+    const initializationSites = new Set(
+      writes.filter((reference) => reference.init).map((reference) => reference.identifier),
+    );
+    const isVar = variable?.defs.some(
+      (definition) => definition.type === "Variable" && definition.parent?.kind === "var",
+    );
+    return writes.some((reference) => !reference.init) || (isVar && initializationSites.size > 1);
+  }
+
   function recordDirect(id, source, calleeName) {
-    if (id?.type !== "Identifier" || !targetMatches(targets, source, calleeName)) return;
+    if (
+      id?.type !== "Identifier" ||
+      isReassigned(id) ||
+      !targetMatches(targets, source, calleeName)
+    ) {
+      return;
+    }
     const variable = resolveVariable(id, context);
     if (variable) directBindings.set(variable, { source, calleeName });
   }
 
   function recordNamespace(id, source) {
-    if (id.type !== "Identifier" || !matchesAny(source, sourceSpecifierPatterns)) {
+    if (
+      id.type !== "Identifier" ||
+      isReassigned(id) ||
+      !matchesAny(source, sourceSpecifierPatterns)
+    ) {
       return;
     }
     const variable = resolveVariable(id, context);
@@ -122,74 +99,116 @@ function createTargetMatcher(context, optionKey = "targets") {
   }
 
   function recordRequireDeclarator(node) {
-    const source = requireSource(node.init);
-    if (!source) return;
-    if (node.id.type === "Identifier") {
-      recordNamespace(node.id, source);
-      recordDirect(node.id, source, node.id.name);
+    if (node.parent?.type !== "VariableDeclaration") return;
+    const source = requireSource(node.init, context);
+    if (source) {
+      if (node.id.type === "Identifier") {
+        recordNamespace(node.id, source);
+        recordDirect(node.id, source, node.id.name);
+        return;
+      }
+      if (node.id.type === "ObjectPattern") {
+        for (const property of node.id.properties) {
+          if (property.type !== "Property") continue;
+          const name = property.computed
+            ? staticComputedPropertyName(property.key)
+            : propertyName(property.key);
+          if (name) recordDirect(bindingIdentifier(property.value), source, name);
+        }
+      }
       return;
     }
-    if (node.id.type === "ObjectPattern") {
-      for (const property of node.id.properties) {
-        if (property.type !== "Property") continue;
-        recordDirect(bindingIdentifier(property.value), source, propertyName(property.key));
+    const member = unwrapExpression(node.init);
+    if (member?.type !== "MemberExpression" || node.id.type !== "Identifier") return;
+    const memberSource = requireSource(member.object, context);
+    const name = memberPropertyName(member);
+    if (memberSource && name) recordDirect(node.id, memberSource, name);
+  }
+
+  function recordImportEquals(node) {
+    if (node.importKind === "type" || node.id?.type !== "Identifier") return;
+    const ref = node.moduleReference;
+    if (ref?.type !== "TSExternalModuleReference") return;
+    const source = ref.expression?.type === "Literal" ? String(ref.expression.value) : null;
+    if (!source) return;
+    recordNamespace(node.id, source);
+    recordDirect(node.id, source, node.id.name);
+  }
+
+  function recordImportDeclaration(node) {
+    const source = node.source.value;
+    for (const specifier of node.specifiers) {
+      if (specifier.type === "ImportNamespaceSpecifier") {
+        recordNamespace(specifier.local, source);
+      } else if (specifier.type === "ImportDefaultSpecifier") {
+        recordDirect(specifier.local, source, specifier.local.name);
+      } else if (specifier.type === "ImportSpecifier") {
+        const imported = importSpecifierName(specifier);
+        recordDirect(
+          specifier.local,
+          source,
+          imported === "default" ? specifier.local.name : imported,
+        );
       }
     }
   }
 
-  function recordProgramRequires(node) {
-    for (const statement of node.body) {
-      const declarations =
-        statement.type === "VariableDeclaration"
-          ? statement.declarations
-          : statement.type === "ExportNamedDeclaration" &&
-              statement.declaration?.type === "VariableDeclaration"
-            ? statement.declaration.declarations
-            : [];
-      for (const declaration of declarations) recordRequireDeclarator(declaration);
+  function walk(node, visit) {
+    if (!node?.type) return;
+    visit(node);
+    for (const key of context.sourceCode.visitorKeys[node.type] || []) {
+      const value = node[key];
+      if (Array.isArray(value)) {
+        for (const child of value) walk(child, visit);
+      } else {
+        walk(value, visit);
+      }
     }
   }
 
-  function isDirectTarget(node) {
-    if (node.type !== "Identifier") return false;
+  function recordProgram(node) {
+    walk(node, (child) => {
+      if (child.type === "ImportDeclaration") recordImportDeclaration(child);
+      else if (child.type === "TSImportEqualsDeclaration") recordImportEquals(child);
+      else if (child.type === "VariableDeclarator") recordRequireDeclarator(child);
+    });
+  }
+
+  function resolveDirectTarget(node) {
+    if (node.type !== "Identifier") return null;
     const variable = resolveVariable(node, context);
-    return Boolean(variable && directBindings.has(variable));
+    return (variable && directBindings.get(variable)) || null;
   }
 
-  function isNamespaceTarget(node) {
-    if (node.type !== "MemberExpression") return false;
+  function resolveNamespaceTarget(node) {
+    if (node.type !== "MemberExpression") return null;
     const name = memberPropertyName(node);
-    if (!name) return false;
+    if (!name) return null;
+    const object = unwrapExpression(node.object);
     const source =
-      requireSource(node.object) ||
-      (node.object.type === "Identifier"
-        ? namespaceBindings.get(resolveVariable(node.object, context))
+      requireSource(object, context) ||
+      (object.type === "Identifier"
+        ? namespaceBindings.get(resolveVariable(object, context))
         : null);
-    return Boolean(source && targetMatches(targets, source, name));
+    return source && targetMatches(targets, source, name) ? { source, calleeName: name } : null;
+  }
+
+  function resolveCallTarget(node) {
+    const callee = unwrapExpression(node.callee);
+    return resolveDirectTarget(callee) || resolveNamespaceTarget(callee);
   }
 
   return {
     hasTargets: targets.length > 0,
+    resolveCallTarget,
     isTargetCall(node) {
-      return isDirectTarget(node.callee) || isNamespaceTarget(node.callee);
+      return Boolean(resolveCallTarget(node));
     },
     visitors: {
-      Program: recordProgramRequires,
-      ImportDeclaration(node) {
-        const source = node.source.value;
-        for (const specifier of node.specifiers) {
-          if (specifier.type === "ImportNamespaceSpecifier") {
-            recordNamespace(specifier.local, source);
-          } else if (specifier.type === "ImportDefaultSpecifier") {
-            recordDirect(specifier.local, source, specifier.local.name);
-          } else if (specifier.type === "ImportSpecifier") {
-            recordDirect(specifier.local, source, importSpecifierName(specifier));
-          }
-        }
-      },
-      VariableDeclarator(node) {
-        recordRequireDeclarator(node);
-      },
+      Program: recordProgram,
+      ImportDeclaration: recordImportDeclaration,
+      TSImportEqualsDeclaration: recordImportEquals,
+      VariableDeclarator: recordRequireDeclarator,
     },
   };
 }

package/src/rules/imported-call-options.js

@@ -0,0 +1,95 @@
+"use strict";
+
+const { unwrapExpression } = require("./async-ast");
+const { compileTargets, matchingTargets } = require("./async-patterns");
+const { propertyName, literalString } = require("./module-mock-helpers");
+
+const importedCallOptionsSchema = [
+  {
+    type: "object",
+    properties: {
+      targets: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            sourceSpecifierPatterns: { type: "array", items: { type: "string" } },
+            calleeNamePatterns: { type: "array", items: { type: "string" } },
+            optionsPosition: { type: "integer", minimum: 1 },
+            requiredProperties: { type: "array", items: { type: "string" }, minItems: 1 },
+            propertyMatch: { type: "string", enum: ["any", "all"] },
+          },
+          required: [
+            "sourceSpecifierPatterns",
+            "calleeNamePatterns",
+            "optionsPosition",
+            "requiredProperties",
+          ],
+          additionalProperties: false,
+        },
+      },
+    },
+    additionalProperties: false,
+  },
+];
+
+function compileImportedCallTargets(options) {
+  const compiled = [];
+  for (const target of options.targets || []) {
+    const [matched] = compileTargets({ targets: [target] }, "targets");
+    const optionsPosition = target.optionsPosition;
+    const requiredProperties = Array.isArray(target.requiredProperties)
+      ? [...new Set(target.requiredProperties.filter((name) => typeof name === "string" && name))]
+      : [];
+    if (
+      !matched ||
+      !Number.isInteger(optionsPosition) ||
+      optionsPosition < 1 ||
+      requiredProperties.length === 0
+    ) {
+      continue;
+    }
+    compiled.push({
+      ...matched,
+      optionsPosition,
+      requiredProperties,
+      propertyMatch: target.propertyMatch === "all" ? "all" : "any",
+    });
+  }
+  return compiled;
+}
+
+function staticPropertyName(property) {
+  if (property.type !== "Property") return null;
+  if (property.computed) return literalString(unwrapExpression(property.key));
+  return propertyName(property.key);
+}
+
+function visiblePropertyNames(node) {
+  const names = new Set();
+  if (node?.type !== "ObjectExpression") return names;
+  for (const property of node.properties) {
+    const name = staticPropertyName(property);
+    if (name) names.add(name);
+  }
+  return names;
+}
+
+function hasRequiredOptions(argument, target) {
+  const object = unwrapExpression(argument);
+  if (object?.type !== "ObjectExpression") return false;
+  const names = visiblePropertyNames(object);
+  if (target.propertyMatch === "all") {
+    return target.requiredProperties.every((name) => names.has(name));
+  }
+  return target.requiredProperties.some((name) => names.has(name));
+}
+
+module.exports = {
+  compileImportedCallTargets,
+  hasRequiredOptions,
+  importedCallOptionsSchema,
+  matchingTargets,
+  staticPropertyName,
+  visiblePropertyNames,
+};

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

@@ -37,18 +37,40 @@ function isVoidZero(node) {
   return argument?.type === "Literal" && argument.value === 0;
 }
 
-function isNoopExpression(node) {
+function isShadowedUndefined(node, sourceCode) {
+  let scope = sourceCode?.getScope?.(node) ?? null;
+  while (scope) {
+    const variable = scope.set?.get("undefined");
+    if (variable?.defs?.length > 0) return true;
+    scope = scope.upper;
+  }
+  return false;
+}
+
+function isNoopExpression(node, sourceCode) {
   const current = unwrapExpression(node);
-  if (current.type === "Identifier" && current.name === "undefined") return true;
+  if (current.type === "Identifier" && current.name === "undefined") {
+    return Boolean(sourceCode) && !isShadowedUndefined(current, sourceCode);
+  }
   return isVoidZero(current);
 }
 
-function isNoopStatement(statement) {
+function isNoopLiteralExpression(node) {
+  const current = unwrapExpression(node);
+  if (current?.type === "Literal") return true;
+  return current?.type === "TemplateLiteral" && current.expressions.length === 0;
+}
+
+function isNoopStatement(statement, sourceCode) {
   if (statement.type === "EmptyStatement") return true;
   if (statement.type === "ReturnStatement") {
-    return statement.argument == null || isNoopExpression(statement.argument);
+    return statement.argument == null || isNoopExpression(statement.argument, sourceCode);
   }
-  return statement.type === "ExpressionStatement" && isNoopExpression(statement.expression);
+  return (
+    statement.type === "ExpressionStatement" &&
+    (isNoopExpression(statement.expression, sourceCode) ||
+      isNoopLiteralExpression(statement.expression))
+  );
 }
 
 function isInlineFunction(node) {
@@ -56,11 +78,11 @@ function isInlineFunction(node) {
   return node?.type === "FunctionExpression" && node.id == null;
 }
 
-function isInlineNoopFunction(node) {
+function isInlineNoopFunction(node, sourceCode) {
   const current = unwrapExpression(node);
-  if (!isInlineFunction(current)) return false;
-  if (current.body.type !== "BlockStatement") return isNoopExpression(current.body);
-  return current.body.body.every(isNoopStatement);
+  if (!isInlineFunction(current) || current.generator) return false;
+  if (current.body.type !== "BlockStatement") return isNoopExpression(current.body, sourceCode);
+  return current.body.body.every((statement) => isNoopStatement(statement, sourceCode));
 }
 
 function originatingCalleeName(call) {

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

@@ -37,7 +37,7 @@ module.exports = Object.assign(
       return {
         CallExpression(node) {
           const handler = rejectionHandler(node);
-          if (!handler || !isInlineNoopFunction(handler)) return;
+          if (!handler || !isInlineNoopFunction(handler, context.sourceCode)) return;
           if (isAllowedCallee(node, options)) return;
           context.report({ node: handler, messageId: "noopCatch" });
         },

package/src/rules/require-options-on-imported-call.js

@@ -0,0 +1,69 @@
+"use strict";
+
+const { rule } = require("../helpers");
+const { createTargetMatcher } = require("./async-targets");
+const {
+  compileImportedCallTargets,
+  hasRequiredOptions,
+  importedCallOptionsSchema,
+  matchingTargets,
+  staticPropertyName,
+  visiblePropertyNames,
+} = require("./imported-call-options");
+
+module.exports = Object.assign(
+  rule(
+    {
+      type: "problem",
+      docs: {
+        description:
+          "require a statically visible options object on calls resolved from configured imports",
+        recommended: false,
+      },
+      schema: importedCallOptionsSchema,
+      messages: {
+        missingOptions:
+          "Call '{{calleeName}}' from '{{source}}' must pass a statically visible options object at argument {{optionsPosition}} containing {{propertyMatch}} of: {{requiredProperties}}.",
+      },
+    },
+    (context) => {
+      const matcher = createTargetMatcher(context);
+      const optionTargets = compileImportedCallTargets(context.options?.[0] || {});
+      if (!matcher.hasTargets || optionTargets.length === 0) return {};
+
+      return {
+        ...matcher.visitors,
+        CallExpression(node) {
+          const resolved = matcher.resolveCallTarget(node);
+          if (!resolved) return;
+          for (const target of matchingTargets(
+            optionTargets,
+            resolved.source,
+            resolved.calleeName,
+          )) {
+            if (hasRequiredOptions(node.arguments[target.optionsPosition - 1], target)) continue;
+            context.report({
+              node,
+              messageId: "missingOptions",
+              data: {
+                source: resolved.source,
+                calleeName: resolved.calleeName,
+                optionsPosition: String(target.optionsPosition),
+                propertyMatch: target.propertyMatch,
+                requiredProperties: target.requiredProperties.join(", "),
+              },
+            });
+          }
+        },
+      };
+    },
+  ),
+  {
+    __test: {
+      compileImportedCallTargets,
+      hasRequiredOptions,
+      staticPropertyName,
+      visiblePropertyNames,
+    },
+  },
+);