eslint-plugin-no-mistakes 0.61.7 → 0.61.9

package/package.json

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

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

@@ -2,6 +2,7 @@
 
 const { unwrapExpression } = require("./async-ast");
 const { compileTargets, matchingTargets } = require("./async-patterns");
+const { isDefinitelyUndefinedValue } = require("./imported-call-undefined");
 const { propertyName, literalString } = require("./module-mock-helpers");
 
 const importedCallOptionsSchema = [
@@ -65,20 +66,32 @@ function staticPropertyName(property) {
   return propertyName(property.key);
 }
 
-function visiblePropertyNames(node) {
-  const names = new Set();
-  if (node?.type !== "ObjectExpression") return names;
+function visiblePropertyValues(node) {
+  const values = new Map();
+  if (node?.type !== "ObjectExpression") return values;
   for (const property of node.properties) {
     const name = staticPropertyName(property);
-    if (name) names.add(name);
+    if (name) values.set(name, property.value);
+  }
+  return values;
+}
+
+function visiblePropertyNames(node) {
+  return new Set(visiblePropertyValues(node).keys());
+}
+
+function presentPropertyNames(node, sourceCode) {
+  const names = new Set();
+  for (const [name, value] of visiblePropertyValues(node)) {
+    if (!isDefinitelyUndefinedValue(value, sourceCode)) names.add(name);
   }
   return names;
 }
 
-function hasRequiredOptions(argument, target) {
+function hasRequiredOptions(argument, target, sourceCode) {
   const object = unwrapExpression(argument);
   if (object?.type !== "ObjectExpression") return false;
-  const names = visiblePropertyNames(object);
+  const names = presentPropertyNames(object, sourceCode);
   if (target.propertyMatch === "all") {
     return target.requiredProperties.every((name) => names.has(name));
   }
@@ -89,6 +102,7 @@ module.exports = {
   compileImportedCallTargets,
   hasRequiredOptions,
   importedCallOptionsSchema,
+  isDefinitelyUndefinedValue,
   matchingTargets,
   staticPropertyName,
   visiblePropertyNames,

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

@@ -0,0 +1,54 @@
+"use strict";
+
+const { unwrapExpression } = require("./async-ast");
+
+function findVariable(sourceCode, identifier) {
+  if (!sourceCode?.getScope) return null;
+  let scope = sourceCode.getScope(identifier);
+  while (scope) {
+    const variable = scope.variables.find((candidate) => candidate.name === identifier.name);
+    if (variable) return variable;
+    scope = scope.upper;
+  }
+  return null;
+}
+
+function isShadowedUndefined(identifier, sourceCode) {
+  const variable = findVariable(sourceCode, identifier);
+  return Boolean(variable?.defs.some((def) => def.type && def.type !== "ImplicitGlobalVariable"));
+}
+
+function isDefinitelyUndefinedLiteral(node, sourceCode) {
+  const current = unwrapExpression(node);
+  if (!current) return false;
+  if (current.type === "UnaryExpression" && current.operator === "void") return true;
+  if (current.type === "Identifier" && current.name === "undefined") {
+    return !isShadowedUndefined(current, sourceCode);
+  }
+  return false;
+}
+
+function hasLaterWrite(variable) {
+  return variable.references.some((reference) => reference.isWrite() && !reference.init);
+}
+
+function isDefinitelyUndefinedBinding(variable, sourceCode, seen) {
+  if (variable.defs.length !== 1) return false;
+  const def = variable.defs[0];
+  if (def.type !== "Variable" || !def.node?.init || hasLaterWrite(variable)) return false;
+  return isDefinitelyUndefinedValue(def.node.init, sourceCode, seen);
+}
+
+function isDefinitelyUndefinedValue(node, sourceCode, seen = new Set()) {
+  if (isDefinitelyUndefinedLiteral(node, sourceCode)) return true;
+  const current = unwrapExpression(node);
+  if (current?.type !== "Identifier") return false;
+  const variable = findVariable(sourceCode, current);
+  if (!variable || seen.has(variable)) return false;
+  seen.add(variable);
+  return isDefinitelyUndefinedBinding(variable, sourceCode, seen);
+}
+
+module.exports = {
+  isDefinitelyUndefinedValue,
+};

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

@@ -6,6 +6,7 @@ const {
   compileImportedCallTargets,
   hasRequiredOptions,
   importedCallOptionsSchema,
+  isDefinitelyUndefinedValue,
   matchingTargets,
   staticPropertyName,
   visiblePropertyNames,
@@ -41,7 +42,15 @@ module.exports = Object.assign(
             resolved.source,
             resolved.calleeName,
           )) {
-            if (hasRequiredOptions(node.arguments[target.optionsPosition - 1], target)) continue;
+            if (
+              hasRequiredOptions(
+                node.arguments[target.optionsPosition - 1],
+                target,
+                context.sourceCode,
+              )
+            ) {
+              continue;
+            }
             context.report({
               node,
               messageId: "missingOptions",
@@ -62,6 +71,7 @@ module.exports = Object.assign(
     __test: {
       compileImportedCallTargets,
       hasRequiredOptions,
+      isDefinitelyUndefinedValue,
       staticPropertyName,
       visiblePropertyNames,
     },