eslint-plugin-no-mistakes 0.96.0 → 0.97.0

package/package.json

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

package/src/rules/react-no-use-promise-resolve-alias.js

@@ -0,0 +1,168 @@
+"use strict";
+
+const { resolveVariable } = require("./test-no-shared-state-aliases");
+const { literalString } = require("./module-mock-helpers");
+
+function writesNamespaceMember(variable) {
+  return variable.references.some((reference) => {
+    const member = reference.identifier.parent;
+    if (member?.type !== "MemberExpression" || member.object !== reference.identifier) return false;
+    const parent = member.parent;
+    return (
+      (parent.type === "AssignmentExpression" && parent.left === member) ||
+      (parent.type === "UpdateExpression" && parent.argument === member) ||
+      (parent.type === "UnaryExpression" && parent.operator === "delete")
+    );
+  });
+}
+
+function aliasUsesStayLocal(variable, context, seen = new Set()) {
+  if (
+    seen.has(variable) ||
+    variable.defs[0].node?.parent?.parent?.type === "ExportNamedDeclaration" ||
+    writesNamespaceMember(variable)
+  )
+    return false;
+  seen.add(variable);
+  return variable.references.every((reference) => {
+    if (reference.init) return true;
+    if (reference.isWrite() || crossesWith(reference.identifier, variable.scope, context))
+      return false;
+    const parent = reference.identifier.parent;
+    if (parent?.type === "MemberExpression" && parent.object === reference.identifier) {
+      const name = parent.computed ? literalString(parent.property) : parent.property.name;
+      return (
+        name === "resolve" &&
+        parent.parent?.type === "CallExpression" &&
+        parent.parent.callee === parent
+      );
+    }
+    if (
+      parent?.type !== "VariableDeclarator" ||
+      parent.init !== reference.identifier ||
+      parent.parent?.kind !== "const" ||
+      parent.id.type !== "Identifier" ||
+      parent.parent.parent?.type === "ExportNamedDeclaration" ||
+      variable.defs[0].node.init.range[1] > parent.init.range[0]
+    )
+      return false;
+    const child = resolveVariable(parent.id, context);
+    return child?.defs.length === 1 && aliasUsesStayLocal(child, context, seen);
+  });
+}
+
+function globalUsesStayLocal(variable, context) {
+  return variable.references.every((reference) => {
+    if (reference.isTypeReference && !reference.isValueReference) return true;
+    if (reference.isWrite()) return false;
+    const parent = reference.identifier.parent;
+    if (parent?.type === "MemberExpression" && parent.object === reference.identifier) {
+      const name = parent.computed ? literalString(parent.property) : parent.property.name;
+      return (
+        ["resolve", "reject", "all", "allSettled", "any", "race"].includes(name) &&
+        parent.parent?.type === "CallExpression" &&
+        parent.parent.callee === parent
+      );
+    }
+    if (parent?.type === "NewExpression" && parent.callee === reference.identifier) return true;
+    if (
+      parent?.type !== "VariableDeclarator" ||
+      parent.init !== reference.identifier ||
+      parent.parent?.kind !== "const" ||
+      parent.id.type !== "Identifier"
+    )
+      return false;
+    const child = resolveVariable(parent.id, context);
+    return child?.defs.length === 1 && aliasUsesStayLocal(child, context);
+  });
+}
+
+function hasGlobalObjectPromiseAccess(context) {
+  const globalScope = context.sourceCode.scopeManager.globalScope;
+  for (const name of ["globalThis", "window", "self", "global"]) {
+    const variable = globalScope.set.get(name);
+    const references =
+      variable && variable.defs.length === 0
+        ? variable.references
+        : globalScope.through.filter(
+            (reference) => reference.identifier.name === name && !reference.resolved,
+          );
+    if (
+      references.some((reference) => {
+        const member = reference.identifier.parent;
+        if (member?.type !== "MemberExpression" || member.object !== reference.identifier)
+          return true; // The global object escaped or was used as a value.
+        const property = member.computed ? literalString(member.property) : member.property.name;
+        if (property === null || property === "Promise") return true;
+        const parent = member.parent;
+        return (
+          (parent.type === "CallExpression" && parent.callee === member) ||
+          (parent.type === "AssignmentExpression" && parent.left === member) ||
+          (parent.type === "UpdateExpression" && parent.argument === member) ||
+          (parent.type === "UnaryExpression" && parent.operator === "delete")
+        );
+      })
+    )
+      return true;
+  }
+  return false;
+}
+
+function crossesWith(identifier, bindingScope, context) {
+  for (
+    let scope = context.sourceCode.getScope(identifier);
+    scope && scope !== bindingScope;
+    scope = scope.upper
+  ) {
+    if (scope.type === "with") return true;
+  }
+  return false;
+}
+
+function immutableAlias(identifier, context) {
+  const variable = resolveVariable(identifier, context);
+  if (variable?.defs.length !== 1) return null;
+  const [definition] = variable.defs;
+  const declarator = definition.node;
+  if (
+    definition.type !== "Variable" ||
+    declarator?.parent?.kind !== "const" ||
+    declarator.id.type !== "Identifier" ||
+    declarator.id.name !== identifier.name ||
+    declarator.init?.type !== "Identifier" ||
+    declarator.parent.parent?.type === "ExportNamedDeclaration" ||
+    variable.references.some((reference) => reference.isWrite() && !reference.init) ||
+    !aliasUsesStayLocal(variable, context) ||
+    declarator.init.range[1] > identifier.range[0] ||
+    crossesWith(identifier, variable.scope, context)
+  )
+    return null;
+  return declarator;
+}
+
+function isGlobalPromiseAlias(identifier, context) {
+  let current = identifier;
+  while (true) {
+    const declarator = immutableAlias(current, context);
+    if (!declarator) return false;
+    const next = declarator.init;
+    const binding = resolveVariable(next, context);
+    // A later const initializer is still in its TDZ at this read. This
+    // decreasing source-order invariant also rules out alias cycles.
+    if (binding?.defs.length && binding.defs[0].node?.init?.range[1] > next.range[0]) return false;
+    if (next.name === "Promise") {
+      return (
+        binding?.defs.length === 0 &&
+        binding.scope.type === "global" &&
+        !writesNamespaceMember(binding) &&
+        globalUsesStayLocal(binding, context) &&
+        !hasGlobalObjectPromiseAccess(context) &&
+        !crossesWith(next, binding?.scope, context)
+      );
+    }
+    if (crossesWith(next, binding?.scope, context)) return false;
+    current = next;
+  }
+}
+
+module.exports = { isGlobalPromiseAlias };

package/src/rules/react-no-use-promise-resolve.js

@@ -4,6 +4,7 @@ const { rule } = require("../helpers");
 const { ruleSuppression } = require("../rule-suppression");
 const { literalString } = require("./module-mock-helpers");
 const { resolveVariable } = require("./test-no-shared-state-aliases");
+const { isGlobalPromiseAlias } = require("./react-no-use-promise-resolve-alias");
 
 function unwrap(node) {
   while (node?.type === "ChainExpression") node = node.expression;
@@ -106,6 +107,36 @@ function isPromiseResolve(node) {
   );
 }
 
+function isAliasedPromiseResolve(node, context) {
+  if (
+    node?.type !== "CallExpression" ||
+    node.optional ||
+    node.arguments.length !== 1 ||
+    node.arguments[0].type === "SpreadElement"
+  )
+    return false;
+  const callee = node.callee;
+  return (
+    callee.type === "MemberExpression" &&
+    !callee.optional &&
+    callee.object.type === "Identifier" &&
+    staticName(callee.property, callee.computed) === "resolve" &&
+    isGlobalPromiseAlias(callee.object, context)
+  );
+}
+
+function ordinaryUseCall(node) {
+  if (node.optional || node.arguments.length !== 1 || node.arguments[0].type === "SpreadElement")
+    return false;
+  const callee = node.callee;
+  return (
+    callee.type === "Identifier" ||
+    (callee.type === "MemberExpression" &&
+      !callee.optional &&
+      !["call", "apply"].includes(staticName(callee.property, callee.computed)))
+  );
+}
+
 module.exports = Object.assign(
   rule(
     {
@@ -141,7 +172,8 @@ module.exports = Object.assign(
           if (
             suppressed(node) ||
             !isReactUse(node.callee, context, useNames) ||
-            !isPromiseResolve(resolvedArgument)
+            (!isPromiseResolve(resolvedArgument) &&
+              !(ordinaryUseCall(node) && isAliasedPromiseResolve(node.arguments[0], context)))
           ) {
             return;
           }

package/src/rules/test-no-delayed-rejects-promise-alias.js

@@ -0,0 +1,69 @@
+"use strict";
+
+const { unwrapExpression } = require("./async-ast");
+
+function findVariable(scope, name) {
+  for (let current = scope; current; current = current.upper) {
+    const variable =
+      current.set?.get?.(name) ?? current.variables?.find((item) => item.name === name);
+    if (variable) return variable;
+  }
+  return null;
+}
+
+function crossesWith(identifier, variable, context) {
+  for (
+    let scope = context.sourceCode.getScope(identifier);
+    scope !== variable.scope;
+    scope = scope.upper
+  ) {
+    if (scope.type === "with") return true;
+  }
+  return false;
+}
+
+function immutableDeclarator(identifier, context) {
+  const variable = findVariable(context.sourceCode.getScope(identifier), identifier.name);
+  if (variable?.defs.length !== 1) return null;
+  const [definition] = variable.defs;
+  if (definition.type !== "Variable") return null;
+  const declarator = definition.node;
+  if (
+    !declarator?.init ||
+    declarator.id.type !== "Identifier" ||
+    declarator.id.name !== identifier.name ||
+    declarator.parent?.type !== "VariableDeclaration" ||
+    declarator.parent.kind !== "const"
+  )
+    return null;
+  return { variable, declarator };
+}
+
+function originDeclarator(identifier, context) {
+  let reference = identifier;
+  while (true) {
+    const binding = immutableDeclarator(reference, context);
+    if (!binding) return null;
+    const { declarator } = binding;
+    const value = unwrapExpression(declarator.init);
+    if (value.type !== "Identifier") return declarator;
+    // A with-object getter can replace an outer lexical value at either read.
+    if (crossesWith(reference, binding.variable, context)) return null;
+    if (binding.variable.references.some((ref) => ref.isWrite() && !ref.init)) return null;
+    // Reading an alias before initialization, or creating it from a binding
+    // still in the TDZ, does not establish promise identity.
+    if (declarator.init.range[1] > reference.range[0]) return null;
+    const target = immutableDeclarator(value, context);
+    // Each hop moves to an earlier initializer. That also rules out cycles.
+    if (
+      !target ||
+      crossesWith(value, target.variable, context) ||
+      target.variable.references.some((ref) => ref.isWrite() && !ref.init) ||
+      target.declarator.init.range[1] > declarator.init.range[0]
+    )
+      return null;
+    reference = value;
+  }
+}
+
+module.exports = { originDeclarator };

package/src/rules/test-no-delayed-rejects.js

@@ -2,7 +2,8 @@
 
 const { rule } = require("../helpers");
 const { ruleSuppression } = require("../rule-suppression");
-const { findContainingRoot, traverse, unwrapExpression } = require("./async-ast");
+const { findContainingRoot, traverse } = require("./async-ast");
+const { originDeclarator } = require("./test-no-delayed-rejects-promise-alias");
 const { chainIsSafelyObserved, promiseChainBase } = require("./test-no-delayed-rejects-chains");
 const { canReachMatcher, contains, executesBefore } = require("./test-no-delayed-rejects-flow");
 const { isImmediateObserver } = require("./test-no-delayed-rejects-observers");
@@ -14,17 +15,6 @@ const {
 
 const { expectedIdentifier } = require("./test-no-delayed-rejects-expect");
 
-function findVariable(scope, name) {
-  let current = scope;
-  while (current) {
-    const variable =
-      current.set?.get?.(name) ?? current.variables?.find((item) => item.name === name);
-    if (variable) return variable;
-    current = current.upper;
-  }
-  return null;
-}
-
 function matcherCall(rejects) {
   let current = rejects;
   while (
@@ -38,27 +28,8 @@ function matcherCall(rejects) {
     : null;
 }
 
-function constDeclarator(identifier, context) {
-  const variable = findVariable(context.sourceCode.getScope(identifier), identifier.name);
-  if (!variable || variable.defs.length !== 1) return null;
-  const [definition] = variable.defs;
-  if (definition.type !== "Variable") return null;
-  const declarator = definition.node;
-  if (
-    !declarator?.init ||
-    declarator.id.type !== "Identifier" ||
-    declarator.id.name !== identifier.name ||
-    declarator.parent?.type !== "VariableDeclaration" ||
-    declarator.parent.kind !== "const"
-  ) {
-    return null;
-  }
-  if (unwrapExpression(declarator.init).type === "Identifier") return null;
-  return declarator;
-}
-
 function isSameConst(identifier, declarator, context) {
-  return identifier.type === "Identifier" && constDeclarator(identifier, context) === declarator;
+  return identifier.type === "Identifier" && originDeclarator(identifier, context) === declarator;
 }
 
 function isRejectionHandlerCall(node, declarator, context) {
@@ -159,7 +130,7 @@ module.exports = rule(
       MemberExpression(node) {
         const identifier = expectedIdentifier(node, context);
         if (!identifier) return;
-        const declarator = constDeclarator(identifier, context);
+        const declarator = originDeclarator(identifier, context);
         const call = matcherCall(node);
         if (
           !declarator ||

package/src/rules/ts-no-function-aliases-ast.js

@@ -6,7 +6,13 @@ function unwrapExpression(expression) {
     current &&
     (current.type === "AwaitExpression" ||
       current.type === "ChainExpression" ||
-      current.type === "TSNonNullExpression")
+      [
+        "TSAsExpression",
+        "TSNonNullExpression",
+        "TSSatisfiesExpression",
+        "TSTypeAssertion",
+        "TSInstantiationExpression",
+      ].includes(current.type))
   ) {
     current = current.type === "AwaitExpression" ? current.argument : current.expression;
   }

package/src/rules/ts-no-function-aliases-cast-proof.js

@@ -0,0 +1,145 @@
+"use strict";
+
+const { staticMemberName } = require("./ts-no-function-aliases-ast");
+const { resolveVariable } = require("./ts-no-function-aliases-self");
+
+function unassertedPath(expression) {
+  let current = expression;
+  while (["ChainExpression", "MemberExpression", "AwaitExpression"].includes(current.type)) {
+    if (current.type === "ChainExpression") current = current.expression;
+    else current = current.type === "AwaitExpression" ? current.argument : current.object;
+  }
+  return !current.type.startsWith("TS");
+}
+
+function typeQueryPath(node) {
+  if (node.type === "Identifier") return [node.name];
+  if (node.type === "TSQualifiedName") return [...typeQueryPath(node.left), node.right.name];
+  // A typeof import() query has no static value path in this file.
+  return null;
+}
+
+function pathRoot(node) {
+  let current = node;
+  while (current?.type === "MemberExpression" || current?.type === "TSQualifiedName")
+    current = current.type === "MemberExpression" ? current.object : current.left;
+  return current?.type === "Identifier" ? current : null;
+}
+
+function valuePath(node) {
+  if (node?.type === "Identifier") return [node.name];
+  if (node?.type === "MemberExpression") {
+    const left = valuePath(node.object);
+    const right = staticMemberName(node);
+    return left && right !== null ? [...left, right] : null;
+  }
+  return null;
+}
+
+function samePath(left, right) {
+  return (
+    left &&
+    right &&
+    left.length === right.length &&
+    left.every((segment, index) => segment === right[index])
+  );
+}
+
+function assertionType(annotation, sourceCode) {
+  if (
+    annotation.type !== "TSTypeReference" ||
+    annotation.typeName.type !== "Identifier" ||
+    annotation.typeArguments
+  )
+    return annotation;
+  const variable = resolveVariable(sourceCode, annotation.typeName);
+  const declaration = variable?.defs.length === 1 ? variable.defs[0].node : null;
+  if (declaration?.type !== "TSTypeAliasDeclaration" || declaration.typeParameters)
+    return annotation;
+  // One non-generic, same-file alias is a local proof. Chained aliases and
+  // imported type names need type resolution that this rule does not own.
+  return declaration.typeAnnotation.type === "TSTypeReference"
+    ? annotation
+    : declaration.typeAnnotation;
+}
+
+function preservedCalleeCast(node, target, sourceCode) {
+  if (node.type !== "TSAsExpression" && node.type !== "TSTypeAssertion") return false;
+  const annotation = assertionType(node.typeAnnotation, sourceCode);
+  return (
+    samePath(valuePath(node.expression), valuePath(target)) &&
+    annotation.type === "TSTypeQuery" &&
+    samePath(typeQueryPath(annotation.exprName), valuePath(target)) &&
+    resolveVariable(sourceCode, pathRoot(annotation.exprName)) ===
+      resolveVariable(sourceCode, pathRoot(target)) &&
+    !annotation.typeArguments
+  );
+}
+
+function resultCastPreserved(node, target, sourceCode) {
+  const castType = assertionType(node.typeAnnotation, sourceCode).type;
+  return (
+    (node.type === "TSAsExpression" || node.type === "TSTypeAssertion") &&
+    target.callable &&
+    // The binding annotation can expose a wider contract than the initializer.
+    !target.annotation &&
+    !wrapperHasOverloads(target.callable, sourceCode) &&
+    !target.callable.typeParameters &&
+    !target.callable.async &&
+    !target.callable.generator &&
+    target.callable?.returnType?.typeAnnotation.type === castType &&
+    [
+      "TSVoidKeyword",
+      "TSUndefinedKeyword",
+      "TSNullKeyword",
+      "TSStringKeyword",
+      "TSNumberKeyword",
+      "TSBooleanKeyword",
+      "TSBigIntKeyword",
+      "TSSymbolKeyword",
+    ].includes(castType)
+  );
+}
+
+function assertedContractPreserved(node, call, candidate, target, sourceCode) {
+  let result = node.body;
+  if (result.type === "BlockStatement") {
+    const statement = result.body[0];
+    result = statement.argument || statement.expression;
+  }
+  while (result !== call) {
+    if (!result) return false;
+    if (["TSAsExpression", "TSTypeAssertion"].includes(result.type)) {
+      if (!resultCastPreserved(result, target, sourceCode)) return false;
+      result = result.expression;
+    } else if (result.type === "ChainExpression" || result.type === "TSNonNullExpression") {
+      if (result.type === "TSNonNullExpression") return false;
+      result = result.expression;
+    } else return false; // Async wrappers were rejected before this walk.
+  }
+  let callee = call.callee;
+  while (callee && callee !== candidate.target) {
+    if (["TSAsExpression", "TSTypeAssertion"].includes(callee.type)) {
+      if (!preservedCalleeCast(callee, candidate.target, sourceCode)) return false;
+      callee = callee.expression;
+    } else if (callee.type === "ChainExpression") {
+      callee = callee.expression;
+    } else if (callee.type === "MemberExpression") {
+      callee = callee.object;
+    } else return false;
+  }
+  return callee === candidate.target && unassertedPath(candidate.target);
+}
+
+function wrapperHasOverloads(node, sourceCode) {
+  if (node.type !== "FunctionDeclaration") return false;
+  return sourceCode
+    .getDeclaredVariables(node)
+    .some((variable) =>
+      variable.defs.some(
+        (definition) => definition.type === "FunctionName" && definition.node !== node,
+      ),
+    );
+}
+
+module.exports = { unassertedPath, assertedContractPreserved, wrapperHasOverloads };

package/src/rules/ts-no-function-aliases-contract.js

@@ -2,28 +2,16 @@
 
 const { staticMemberName } = require("./ts-no-function-aliases-ast");
 const { resolveVariable } = require("./ts-no-function-aliases-self");
-
-function unassertedPath(expression) {
-  let current = expression;
-  while (["ChainExpression", "MemberExpression", "AwaitExpression"].includes(current.type)) {
-    if (current.type === "ChainExpression") current = current.expression;
-    else current = current.type === "AwaitExpression" ? current.argument : current.object;
-  }
-  return !current.type.startsWith("TS");
-}
-
-function unassertedResult(node) {
-  let result = node.body;
-  if (result.type === "BlockStatement") {
-    const statement = result.body[0];
-    result = statement.argument || statement.expression;
-  }
-  return unassertedPath(result);
-}
+const {
+  unassertedPath,
+  assertedContractPreserved,
+  wrapperHasOverloads,
+} = require("./ts-no-function-aliases-cast-proof");
 
 function unassertedCall(node, call) {
   if (call.typeArguments || call.typeParameters) return false;
-  if (!unassertedResult(node) || !unassertedPath(call.callee)) return false;
+  // Assertions are checked against the reachable target after candidate
+  // selection. This guard still rejects casts on an explicit receiver.
   const callee = call.callee.type === "ChainExpression" ? call.callee.expression : call.callee;
   const method = callee.type === "MemberExpression" ? staticMemberName(callee) : null;
   return (
@@ -31,17 +19,6 @@ function unassertedCall(node, call) {
   );
 }
 
-function wrapperHasOverloads(node, sourceCode) {
-  if (node.type !== "FunctionDeclaration") return false;
-  return sourceCode
-    .getDeclaredVariables(node)
-    .some((variable) =>
-      variable.defs.some(
-        (definition) => definition.type === "FunctionName" && definition.node !== node,
-      ),
-    );
-}
-
 function directIntrinsic(target, sourceCode) {
   if (target.type !== "MemberExpression") return false;
   const name = staticMemberName(target);
@@ -86,6 +63,7 @@ function documentedSignature(node, sourceCode) {
 
 module.exports = {
   unassertedCall,
+  assertedContractPreserved,
   wrapperHasOverloads,
   directIntrinsic,
   documentedSignature,

package/src/rules/ts-no-function-aliases.js

@@ -12,6 +12,7 @@ const { legacyIdentifierCall } = require("./ts-no-function-aliases-legacy");
 const { exportedDeclarations, reachableTarget } = require("./ts-no-function-aliases-reachable");
 const {
   unassertedCall,
+  assertedContractPreserved,
   wrapperHasOverloads,
   directIntrinsic,
   documentedSignature,
@@ -63,7 +64,12 @@ function reportIfAlias(node, context, suppressed, declarations) {
     if (!candidate) continue;
     if (!isSameArgumentList(node.params, candidate.args)) continue;
     const reachable = reachableTarget(candidate.target, sourceCode, declarations);
-    if (!reachable || !signaturePreserved(node, reachable)) continue;
+    if (
+      !reachable ||
+      !signaturePreserved(node, reachable) ||
+      !assertedContractPreserved(node, call, candidate, reachable, sourceCode)
+    )
+      continue;
     context.report({ node, messageId: "alias" });
     return;
   }