eslint-plugin-no-mistakes 0.90.0 → 0.91.0

package/package.json

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

package/src/rules/playwright-timeout-carriers.js

@@ -2,28 +2,38 @@
 const { unwrapExpression, isFunction } = require("./async-ast");
 const { resolveVariable, isReassigned } = require("./async-target-bindings");
 function createCarriers(context, evaluate, check, max, fixtureMax) {
-  function field(value, node, name = "timeout", cap = max) {
+  const option = context.options[0] ?? {};
+  function configCheck(value, ...args) {
+    const unresolved = value.kind !== "number" || value.runtimeFunction;
+    if (unresolved && option.configUnknownValues === "defer-to-runner") return;
+    check(value, ...args);
+  }
+  function field(value, node, name = "timeout", cap = max, inspect = check) {
     if (value.kind !== "object") {
-      check({ kind: "unknown" }, node, name, cap);
+      inspect({ kind: "unknown" }, node, name, cap);
       return undefined;
     }
     const entry = value.properties.get("timeout");
-    if (entry) check(entry.value, entry.origin, name, cap);
-    else if (value.unknown) check({ kind: "unknown" }, node, name, cap);
+    if (entry) inspect(entry.value, entry.origin, name, cap);
+    else if (value.unknown) inspect({ kind: "unknown" }, node, name, cap);
     return entry?.value;
   }
   function config(value, node) {
     if (value.kind !== "object") {
-      check({ kind: "unknown" }, node, "config carrier");
+      configCheck({ kind: "unknown" }, node, "config carrier");
       return;
     }
-    field(value, node, "project timeout");
+    field(value, node, "project timeout", max, configCheck);
     const projects = value.properties.get("projects");
     if (projects) {
       if (projects.value.kind !== "array")
-        check({ kind: "unknown" }, projects.origin, "projects carrier");
-      else for (const entry of projects.value.entries) config(entry.value, entry.origin);
-    } else if (value.unknown) check({ kind: "unknown" }, node, "projects carrier");
+        configCheck({ kind: "unknown" }, projects.origin, "projects carrier");
+      else {
+        if (!projects.value.lengthKnown)
+          configCheck({ kind: "unknown" }, projects.origin, "projects carrier");
+        for (const entry of projects.value.entries) config(entry.value, entry.origin);
+      }
+    } else if (value.unknown) configCheck({ kind: "unknown" }, node, "projects carrier");
   }
   function fixtures(node) {
     const value = evaluate(node);
@@ -33,15 +43,26 @@ function createCarriers(context, evaluate, check, max, fixtureMax) {
     }
     if (value.unknown) check({ kind: "unknown" }, node, "fixture carrier", fixtureMax);
     for (const entry of value.properties.values()) {
-      // Only SDK fixture tuples carry a separate deadline. Ordinary fixture data is not options.
-      if (entry.value.kind === "array" && entry.value.entries.length === 2)
-        field(
-          entry.value.entries[1].value,
-          entry.value.entries[1].origin,
-          "fixture timeout",
-          fixtureMax,
-        );
-      else if (entry.value.kind === "unknown" && !isFunction(unwrapExpression(entry.origin.value)))
+      // Playwright inspects runtime index 1, irrespective of extra tail elements.
+      if (entry.value.kind === "array" && !entry.value.runtimeFunction) {
+        const tuple = entry.value;
+        if (tuple.knownPrefixLength < 2) {
+          if (tuple.entries.length >= 2 || !tuple.lengthKnown)
+            check({ kind: "unknown" }, entry.origin, "fixture tuple position", fixtureMax);
+          continue;
+        }
+        const options = tuple.entries[1];
+        if (options.value.runtimeFunction) continue;
+        if (
+          options.value.kind === "number" ||
+          ["string", "boolean", "bigint", "undefined"].includes(options.value.runtimeType)
+        )
+          continue;
+        field(options.value, options.origin, "fixture timeout", fixtureMax);
+      } else if (
+        entry.value.kind === "unknown" &&
+        !isFunction(unwrapExpression(entry.origin.value))
+      )
         check({ kind: "unknown" }, entry.origin, "fixture entry carrier", fixtureMax);
     }
   }
@@ -78,7 +99,7 @@ function createCarriers(context, evaluate, check, max, fixtureMax) {
       if (api?.kind === "defineConfig") {
         checkedConfigs.add(node);
         if (node.arguments.length === 1) config(evaluate(node.arguments[0]), node.arguments[0]);
-        else check({ kind: "unknown" }, node, "merged config carrier");
+        else configCheck({ kind: "unknown" }, node, "merged config carrier");
       } else if (
         (option.configFiles ?? []).some(
           (file) =>
@@ -91,7 +112,7 @@ function createCarriers(context, evaluate, check, max, fixtureMax) {
       if (checkedConfigs.has(node) || bindings.resolve(node.callee)?.kind !== "defineConfig")
         continue;
       if (node.arguments.length === 1) config(evaluate(node.arguments[0]), node.arguments[0]);
-      else check({ kind: "unknown" }, node, "merged config carrier");
+      else configCheck({ kind: "unknown" }, node, "merged config carrier");
     }
   }
   return { field, configRoots, fixtures, slowCondition };

package/src/rules/playwright-timeout-meta.js

@@ -9,6 +9,7 @@ module.exports = {
         max: { type: "number", minimum: 0, exclusiveMinimum: true },
         fixtureMax: { type: "number", minimum: 0, exclusiveMinimum: true },
         unknownValues: { enum: ["ignore", "finding"] },
+        configUnknownValues: { enum: ["inherit", "defer-to-runner"] },
         registrationPackages: { type: "array", items: { type: "string" }, uniqueItems: true },
         exportRoles: {
           type: "object",

package/src/rules/vitest-timeout-array-values.js

@@ -0,0 +1,42 @@
+"use strict";
+
+function arrayValue(node, evaluate) {
+  const entries = [];
+  let knownPrefixLength = 0;
+  let positionsKnown = true;
+  for (const element of node.elements) {
+    if (!element) {
+      entries.push({ value: { kind: "unknown", runtimeType: "undefined" }, origin: node });
+      if (positionsKnown) knownPrefixLength++;
+    } else if (element.type === "SpreadElement") {
+      const spread = evaluate(element.argument);
+      if (spread.kind === "array" && !spread.runtimeFunction) {
+        entries.push(...spread.entries.map((entry) => ({ ...entry, origin: element })));
+        if (positionsKnown) {
+          knownPrefixLength += spread.knownPrefixLength;
+          positionsKnown = spread.lengthKnown;
+        }
+      } else {
+        entries.push({ value: { kind: "unknown" }, origin: element });
+        positionsKnown = false;
+      }
+    } else {
+      entries.push({ value: evaluate(element), origin: element });
+      if (positionsKnown) knownPrefixLength++;
+    }
+  }
+  return { kind: "array", entries, knownPrefixLength, lengthKnown: positionsKnown };
+}
+
+function concatenateArrays(left, right) {
+  return {
+    kind: "array",
+    entries: [...left.entries, ...right.entries],
+    knownPrefixLength: left.lengthKnown
+      ? left.entries.length + right.knownPrefixLength
+      : left.knownPrefixLength,
+    lengthKnown: left.lengthKnown && right.lengthKnown,
+  };
+}
+
+module.exports = { arrayValue, concatenateArrays };

package/src/rules/vitest-timeout-cap.js

@@ -27,6 +27,7 @@ module.exports = rule(
           defaultMax: { type: "number", minimum: 0, exclusiveMinimum: true },
           overrideMax: { type: "number", minimum: 0, exclusiveMinimum: true },
           unknownValues: { enum: ["ignore", "finding"] },
+          configUnknownValues: { enum: ["inherit", "defer-to-runner"] },
           configRoot: { type: "boolean" },
         },
         additionalProperties: false,
@@ -109,10 +110,11 @@ module.exports = rule(
         for (const original of overrides) {
           const kind = overrideCall(original, context);
           if (!kind) continue;
-          const node = { ...original, arguments: invocationArguments(original, context) };
+          const node = original;
+          const callArguments = invocationArguments(original, context);
           const max = option.overrideMax ?? 30000;
           if (kind === "test" || kind === "hook")
-            for (const argument of node.arguments)
+            for (const argument of callArguments)
               if (opaqueCallback(argument, context))
                 check(
                   { value: { kind: "unknown" }, origin: argument },
@@ -126,14 +128,14 @@ module.exports = rule(
           }
           if (kind === "runtime") {
             properties(
-              evaluate(node.arguments[0]),
+              evaluate(callArguments[0]),
               ["testTimeout", "hookTimeout"],
               max,
-              node.arguments[0] || node,
+              callArguments[0] || node,
             );
             continue;
           }
-          const args = kind === "hook" ? node.arguments.slice(1) : node.arguments.slice(1, 3);
+          const args = kind === "hook" ? callArguments.slice(1) : callArguments.slice(1, 3);
           for (const argument of args) {
             if (callback(argument)) continue;
             const value = evaluate(argument);
@@ -148,17 +150,17 @@ module.exports = rule(
               );
             else if (
               kind === "test" &&
-              node.arguments.length >= 3 &&
-              argument !== node.arguments.at(-1) &&
+              callArguments.length >= 3 &&
+              argument !== callArguments.at(-1) &&
               value.kind === "unknown"
             )
               properties(value, ["timeout"], max, argument);
           }
-          const last = node.arguments.at(-1);
+          const last = callArguments.at(-1);
           const minimum = kind === "hook" ? 2 : 3;
-          if (!last || node.arguments.length < minimum || callback(last)) continue;
+          if (!last || callArguments.length < minimum || callback(last)) continue;
           // An options object followed by a callback is not a trailing timeout.
-          if (evaluate(node.arguments.at(-2)).kind === "object") continue;
+          if (evaluate(callArguments.at(-2)).kind === "object") continue;
           const value = evaluate(last);
           if (value.kind !== "object") check({ value, origin: last }, "timeout", max);
         }

package/src/rules/vitest-timeout-carriers.js

@@ -1,5 +1,10 @@
 "use strict";
 function createCarriers(option, check) {
+  function configCheck(entry, ...args) {
+    const unresolved = entry.value.kind !== "number" || entry.value.runtimeFunction;
+    if (unresolved && option.configUnknownValues === "defer-to-runner") return;
+    check(entry, ...args);
+  }
   function properties(
     value,
     names,
@@ -7,30 +12,31 @@ function createCarriers(option, check) {
     origin,
     carrier = "timeout options",
     carrierOrigin = origin,
+    inspect = check,
   ) {
     if (value.kind !== "object") {
-      check({ value: { kind: "unknown" }, origin }, carrier, max, origin);
+      inspect({ value: { kind: "unknown" }, origin }, carrier, max, origin);
       return;
     }
     let unresolvedKeys = false;
     for (const name of names) {
       const entry = value.properties.get(name);
-      if (entry) check(entry, name, max, origin);
+      if (entry) inspect(entry, name, max, origin);
       else if (value.unknown) unresolvedKeys = true;
     }
     if (unresolvedKeys)
-      check({ value: { kind: "unknown" }, origin: carrierOrigin }, carrier, max, carrierOrigin);
+      inspect({ value: { kind: "unknown" }, origin: carrierOrigin }, carrier, max, carrierOrigin);
   }
   function defaults(value, project, origin = project) {
     const max = option.defaultMax ?? 5000;
     if (value.kind !== "object") {
-      check({ value: { kind: "unknown" }, origin }, "config carrier", max, origin);
+      configCheck({ value: { kind: "unknown" }, origin }, "config carrier", max, origin);
       return;
     }
     const testEntry = value.properties.get("test");
     if (!testEntry) {
       if (value.unknown)
-        check({ value: { kind: "unknown" }, origin }, "config carrier", max, origin);
+        configCheck({ value: { kind: "unknown" }, origin }, "config carrier", max, origin);
       return;
     }
     const test = testEntry.value;
@@ -42,22 +48,30 @@ function createCarriers(option, check) {
       test.kind === "object" ? project : testOrigin,
       "test options carrier",
       testOrigin,
+      configCheck,
     );
     if (test.kind !== "object") return;
     const projects = test.properties.get("projects");
     if (projects) {
-      if (projects.value.kind === "array")
+      if (projects.value.kind === "array") {
+        if (!projects.value.lengthKnown)
+          configCheck(
+            { value: { kind: "unknown" }, origin: projects.origin },
+            "projects carrier",
+            max,
+            projects.origin,
+          );
         for (const entry of projects.value.entries)
           defaults(entry.value, entry.origin, entry.origin);
-      else
-        check(
+      } else
+        configCheck(
           { value: { kind: "unknown" }, origin: projects.origin },
           "projects carrier",
           max,
           projects.origin,
         );
     } else if (test.unknown && !project)
-      check(
+      configCheck(
         { value: { kind: "unknown" }, origin: testOrigin },
         "projects carrier",
         max,

package/src/rules/vitest-timeout-values.js

@@ -5,6 +5,7 @@ const { createPrimitiveMemberRead } = require("./vitest-timeout-primitive-reads"
 const { createValueStability } = require("./vitest-timeout-value-stability");
 const { createScalarCopyWrite } = require("./vitest-timeout-copy-scalars");
 const { configCall, staticPropertyName } = require("./vitest-timeout-bindings");
+const { arrayValue, concatenateArrays } = require("./vitest-timeout-array-values");
 const UNKNOWN = { kind: "unknown" };
 function taint(value) {
   if (value.kind === "object")
@@ -22,6 +23,8 @@ function taint(value) {
     return {
       ...value,
       entries: value.entries.map((entry) => ({ ...entry, value: taint(entry.value) })),
+      knownPrefixLength: 0,
+      lengthKnown: false,
     };
   return UNKNOWN;
 }
@@ -38,7 +41,7 @@ function merge(left, right) {
     if (previous?.value.kind === "object" && value.kind === "object")
       value = merge(previous.value, value);
     if (previous?.value.kind === "array" && value.kind === "array")
-      value = { kind: "array", entries: [...previous.value.entries, ...value.entries] };
+      value = concatenateArrays(previous.value, value);
     properties.set(name, { ...entry, value });
   }
   return { kind: "object", properties, unknown: Boolean(left.unknown || right.unknown) };
@@ -64,8 +67,14 @@ function createEvaluator(context, consumed) {
   }
   function resolve(node) {
     if (node.type === "Literal" && node.value === null) return { kind: "null" };
-    if (node.type === "Literal")
-      return typeof node.value === "number" ? { kind: "number", value: node.value } : UNKNOWN;
+    if (node.type === "Literal") {
+      if (typeof node.value === "number") return { kind: "number", value: node.value };
+      return ["string", "boolean", "bigint"].includes(typeof node.value)
+        ? { kind: "unknown", runtimeType: typeof node.value }
+        : UNKNOWN;
+    }
+    if (node.type === "UnaryExpression" && node.operator === "void")
+      return { kind: "unknown", runtimeType: "undefined" };
     if (node.type === "UnaryExpression" && (node.operator === "-" || node.operator === "+")) {
       const value = evaluate(node.argument);
       return value.kind === "number"
@@ -154,20 +163,7 @@ function createEvaluator(context, consumed) {
       }
       return { kind: "object", properties, unknown };
     }
-    if (node.type === "ArrayExpression")
-      return {
-        kind: "array",
-        entries: node.elements.flatMap((origin) => {
-          if (!origin) return [];
-          if (origin.type === "SpreadElement") {
-            const value = evaluate(origin.argument);
-            return value.kind === "array"
-              ? value.entries.map((entry) => ({ ...entry, origin }))
-              : [{ value: UNKNOWN, origin }];
-          }
-          return [{ value: evaluate(origin), origin }];
-        }),
-      };
+    if (node.type === "ArrayExpression") return arrayValue(node, evaluate);
     if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") {
       const statements = node.body.type === "BlockStatement" ? node.body.body : null;
       const value = statements