eslint-plugin-no-mistakes 0.84.2 → 0.86.0

package/package.json

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

@@ -20,6 +20,7 @@ const rules = {
   "playwright-consistent-attribute": require("./rules/playwright-consistent-attribute"),
   "playwright-defaults": require("./rules/playwright-defaults"),
   "playwright-assertion-timeout-cap": require("./rules/playwright-assertion-timeout-cap"),
+  "playwright-test-timeout-cap": require("./rules/playwright-test-timeout-cap"),
   "playwright-literals": require("./rules/playwright-literals"),
   "playwright-naming-convention": require("./rules/playwright-naming-convention"),
   "playwright-no-empty": require("./rules/playwright-no-empty"),

package/src/rules/playwright-test-timeout-bindings.js

@@ -0,0 +1,202 @@
+"use strict";
+const { unwrapExpression, isFunction } = require("./async-ast");
+const {
+  resolveVariable,
+  isReassigned,
+  recordObjectPatternBindings,
+} = require("./async-target-bindings");
+const { literalString } = require("./module-mock-helpers");
+const HOOKS = new Set(["beforeAll", "beforeEach", "afterAll", "afterEach"]);
+const CHAINS = new Set(["only", "skip", "fixme", "fail", "describe", "parallel", "serial"]);
+
+function createBindings(context, modules, exportRoles = {}, calls = []) {
+  const active = new Set();
+  function callback(node, seen = new Set(), allowPartial = false) {
+    node = unwrapExpression(node);
+    if (isFunction(node)) return node;
+    if (
+      node?.type === "CallExpression" &&
+      node.callee.type === "MemberExpression" &&
+      member(node.callee) === "bind"
+    ) {
+      const partial =
+        node.arguments.length > 1 || node.arguments.some((arg) => arg.type === "SpreadElement");
+      return partial && !allowPartial ? null : callback(node.callee.object, seen, allowPartial);
+    }
+    if (node?.type !== "Identifier") return null;
+    const variable = resolveVariable(node, context),
+      def = variable?.defs[0];
+    if (seen.has(variable)) return null;
+    if (def?.type === "FunctionName")
+      return variable.references.some((ref) => ref.isWrite() && !ref.init) ? null : def.node;
+    if (isReassigned(node, context)) return null;
+    if (def?.type !== "Variable" || def.parent.kind !== "const") return null;
+    return callback(def.node.init, new Set([...seen, variable]), allowPartial);
+  }
+  function registrationFor(fn) {
+    return calls.filter(
+      (call) =>
+        call.arguments.some((arg) => callback(arg) === fn) && registration(resolve(call.callee)),
+    );
+  }
+  function name(node, seen = new Set()) {
+    node = unwrapExpression(node);
+    if (!node) return null;
+    const literal = literalString(node);
+    if (literal !== null) return literal;
+    if (node.type === "BinaryExpression" && node.operator === "+") {
+      const left = name(node.left, seen),
+        right = name(node.right, seen);
+      return left === null || right === null ? null : left + right;
+    }
+    if (node.type !== "Identifier") return null;
+    const variable = resolveVariable(node, context),
+      def = variable?.defs[0];
+    if (
+      seen.has(variable) ||
+      def?.type !== "Variable" ||
+      def.parent.kind !== "const" ||
+      isReassigned(node, context)
+    )
+      return null;
+    return name(def.node.init, new Set([...seen, variable]));
+  }
+  const member = (node) => (node.computed ? name(node.property) : node.property.name);
+  function property(owner, key) {
+    if (!owner) return null;
+    if (owner.kind === "opaque") return owner;
+    if (owner.kind === "namespace") {
+      const role =
+        owner.source === "@playwright/test" || ["test", "defineConfig", "mergeTests"].includes(key)
+          ? undefined
+          : exportRoles[owner.source]?.[key];
+      if (role === "assertion" || role === "ordinary") return null;
+      if (role === "opaque") return { kind: "opaque", root: owner.root };
+      if (key === "test" || (key === "default" && owner.source === "@playwright/test"))
+        return { kind: "test", root: owner.root, path: [] };
+      if (key === "defineConfig" || key === "mergeTests") return { kind: key, root: owner.root };
+      return owner.source !== "@playwright/test" ? { kind: "opaque", root: owner.root } : null;
+    }
+    if (owner.kind === "test") return { kind: "method", owner, key };
+    if (owner.kind === "method" && CHAINS.has(owner.key))
+      return property(
+        { kind: "test", root: owner.owner.root, path: [...owner.owner.path, owner.key] },
+        key,
+      );
+    if (owner.kind === "info" && (key === "setTimeout" || key === "slow" || key === null))
+      return { kind: "method", owner, key };
+    return null;
+  }
+  function registration(api) {
+    return (
+      api?.kind === "test" ||
+      (api?.kind === "method" && (CHAINS.has(api.key) || HOOKS.has(api.key)))
+    );
+  }
+  function resolve(node) {
+    node = unwrapExpression(node);
+    if (!node) return null;
+    if (node.type === "MemberExpression") return property(resolve(node.object), member(node));
+    if (node.type === "CallExpression") {
+      const callee = unwrapExpression(node.callee);
+      if (callee.type === "MemberExpression" && member(callee) === "bind") {
+        const target = resolve(callee.object),
+          receiver = resolve(node.arguments[0]);
+        if (target?.kind !== "method") return null;
+        if (
+          receiver?.kind !== target.owner.kind ||
+          receiver.root !== target.owner.root ||
+          JSON.stringify(receiver.path) !== JSON.stringify(target.owner.path)
+        )
+          return {
+            kind: "partial",
+            target,
+            receiverUnresolved: true,
+            boundArguments: node.arguments.slice(1),
+          };
+        // Pre-bound arguments precede later call arguments. Never check the later value as effective.
+        return node.arguments.length > 1
+          ? { kind: "partial", target, boundArguments: node.arguments.slice(1) }
+          : target;
+      }
+      const api = resolve(callee);
+      if (api?.kind === "method" && api.owner.kind === "test") {
+        if (api.key === "info") return { kind: "info", root: api.owner.root };
+        if (api.key === "extend") return { kind: "test", root: node, path: [] };
+      }
+      if (api?.kind === "opaque") return api;
+      if (api?.kind === "mergeTests")
+        return node.arguments.length && node.arguments.every((arg) => resolve(arg)?.kind === "test")
+          ? { kind: "test", root: node, path: [] }
+          : { kind: "opaque", root: node };
+      return null;
+    }
+    if (node.type !== "Identifier") return null;
+    const variable = resolveVariable(node, context);
+    if (!variable || active.has(variable)) return null;
+    active.add(variable);
+    try {
+      const def = variable.defs[0];
+      if (def?.type === "ImportBinding" && modules.has(def.parent.source.value)) {
+        if (def.node.type === "ImportNamespaceSpecifier")
+          return { kind: "namespace", root: variable, source: def.parent.source.value };
+        const imported = def.node.imported?.name ?? def.node.imported?.value;
+        const key =
+          def.parent.source.value === "@playwright/test" &&
+          (def.node.type === "ImportDefaultSpecifier" || imported === "default")
+            ? "test"
+            : imported;
+        const role =
+          def.parent.source.value === "@playwright/test" ||
+          ["test", "defineConfig", "mergeTests"].includes(key)
+            ? undefined
+            : exportRoles[def.parent.source.value]?.[key];
+        if (role === "assertion" || role === "ordinary") return null;
+        if (role === "opaque") return { kind: "opaque", root: variable };
+        if (key === "test") return { kind: "test", root: variable, path: [] };
+        if (key === "defineConfig" || key === "mergeTests") return { kind: key, root: variable };
+        if (def.parent.source.value !== "@playwright/test")
+          return { kind: "opaque", root: variable };
+      }
+      if (def?.type === "Parameter") {
+        const fn = def.node;
+        if (!isFunction(fn)) return null;
+        const registrations = registrationFor(fn);
+        if (!registrations.length) return null;
+        const param = fn.params[1];
+        if (
+          registrations.some((call) => {
+            const api = resolve(call.callee);
+            return (
+              api?.kind === "method" &&
+              (api.key === "describe" || api.owner.path?.includes("describe"))
+            );
+          })
+        )
+          return null;
+        const info = { kind: "info", root: fn };
+        if (param?.type === "Identifier" && param.name === node.name) return info;
+        let result = null;
+        if (param?.type === "ObjectPattern")
+          recordObjectPatternBindings(param, info, (id, source, key) => {
+            if (id?.name === node.name) result = property(source, key);
+          });
+        return result;
+      }
+      if (def?.type !== "Variable" || def.parent.kind !== "const" || isReassigned(node, context))
+        return null;
+      if (def.node.id.type === "Identifier") return resolve(def.node.init);
+      let result = null;
+      if (def.node.id.type === "ObjectPattern")
+        recordObjectPatternBindings(def.node.id, resolve(def.node.init), (id, source, key) => {
+          if (id?.name === node.name) result = property(source, key);
+        });
+      return result;
+    } finally {
+      active.delete(variable);
+    }
+  }
+  const opaqueCallback = (node) => !callback(node) && Boolean(callback(node, new Set(), true));
+  return { resolve, registration, registrationFor, opaqueCallback, member, hooks: HOOKS };
+}
+module.exports = { createBindings };

package/src/rules/playwright-test-timeout-cap.js

@@ -0,0 +1,192 @@
+"use strict";
+const { rule, options } = require("../helpers");
+const { ruleSuppression } = require("../rule-suppression");
+const { findContainingFunction, isUnconditionalBeforeReturn } = require("./async-ast");
+const { createEvaluator } = require("./vitest-timeout-values");
+const { createBindings } = require("./playwright-test-timeout-bindings");
+const { createCarriers } = require("./playwright-timeout-carriers");
+
+module.exports = rule(require("./playwright-timeout-meta"), (context) => {
+  const option = options(context),
+    max = option.max ?? 30000,
+    fixtureMax = option.fixtureMax ?? max;
+  for (const [key, value] of [
+    ["max", max],
+    ["fixtureMax", fixtureMax],
+  ])
+    if (!Number.isFinite(value) || value <= 0)
+      throw new Error(`playwright-test-timeout-cap ${key} must be positive and finite`);
+  for (const [source, roles] of Object.entries(option.exportRoles ?? {})) {
+    if (source === "@playwright/test" && Object.keys(roles).length)
+      throw new Error(
+        "playwright-test-timeout-cap exportRoles cannot override builtin SDK exports",
+      );
+    if (["test", "defineConfig", "mergeTests"].some((key) => Object.hasOwn(roles, key)))
+      throw new Error(
+        "playwright-test-timeout-cap exportRoles cannot override recognized registrar exports",
+      );
+  }
+  const suppressed = ruleSuppression(context, "playwright-test-timeout-cap");
+  const calls = [],
+    exports = [],
+    states = new Map();
+  const bindings = createBindings(
+    context,
+    new Set(["@playwright/test", ...(option.registrationPackages ?? [])]),
+    option.exportRoles,
+    calls,
+  );
+  const evaluate = createEvaluator(context, new Set());
+  function report(node, messageId, name, cap = max) {
+    if (!suppressed(node)) context.report({ node, messageId, data: { name, max: cap } });
+  }
+  function check(value, node, name, cap = max) {
+    if (value.kind !== "number" || value.runtimeFunction) {
+      if (option.unknownValues === "finding") report(node, "unknown", name, cap);
+    } else if (!Number.isFinite(value.value) || value.value <= 0)
+      report(node, "invalid", name, cap);
+    else if (value.value > cap) report(node, "timeout", name, cap);
+  }
+  const { field, configRoots, fixtures, slowCondition } = createCarriers(
+    context,
+    evaluate,
+    check,
+    max,
+    fixtureMax,
+  );
+  function branchFree(node, fn) {
+    return fn?.body.type === "BlockStatement" && isUnconditionalBeforeReturn(node, fn.body);
+  }
+  return {
+    CallExpression(node) {
+      calls.push(node);
+    },
+    ExportDefaultDeclaration(node) {
+      exports.push(node.declaration);
+    },
+    "Program:exit"() {
+      configRoots(option, exports, calls, bindings);
+      const priorSlowMayExist = calls.some((node) => {
+        const api = bindings.resolve(node.callee);
+        if (api?.kind !== "method") return false;
+        if (bindings.hooks.has(api.key) || api.key === "use" || api.key === null) return true;
+        const fn = findContainingFunction(node),
+          parentApi =
+            fn?.parent?.type === "CallExpression" ? bindings.resolve(fn.parent.callee) : null;
+        return (
+          api.key === "slow" &&
+          (!fn || parentApi?.key === "describe" || parentApi?.owner?.path?.includes("describe"))
+        );
+      });
+      function initialState(fn) {
+        const registrations = fn ? bindings.registrationFor(fn) : [];
+        const api = registrations.length === 1 ? bindings.resolve(registrations[0].callee) : null;
+        const root = api?.kind === "test" ? api.root : api?.owner?.root;
+        const directSdk = root?.defs?.some(
+          (def) => def.type === "ImportBinding" && def.parent.source.value === "@playwright/test",
+        );
+        return {
+          timeout: { kind: "unknown" },
+          slow: directSdk && !priorSlowMayExist ? false : null,
+        };
+      }
+      for (const node of calls.sort((a, b) => a.range[0] - b.range[0])) {
+        const api = bindings.resolve(node.callee);
+        if (bindings.registration(api) && option.unknownValues === "finding")
+          report(node, "effectiveSlot", "inherited effective deadline");
+        if (bindings.registration(api))
+          for (const argument of node.arguments)
+            if (bindings.opaqueCallback(argument))
+              check({ kind: "unknown" }, argument, "bound callback parameter carrier");
+        if (api?.kind === "mergeTests") {
+          for (const argument of node.arguments)
+            if (bindings.resolve(argument)?.kind !== "test")
+              check({ kind: "unknown" }, argument, "merged registrar carrier");
+          continue;
+        }
+
+        if (api?.kind === "opaque") {
+          check({ kind: "unknown" }, node, "admitted registrar carrier");
+          continue;
+        }
+        if (api?.kind === "partial") {
+          check({ kind: "unknown" }, node, "partially bound framework deadline");
+          const state = states.get(findContainingFunction(node));
+          if (state) {
+            state.timeout = { kind: "unknown" };
+            state.slow = null;
+          }
+          continue;
+        }
+        if (api?.kind !== "method") {
+          // A helper call may mutate the active slot or slow latch. Do not invent effects.
+          const state = states.get(findContainingFunction(node));
+          if (state) {
+            state.timeout = { kind: "unknown" };
+            state.slow = null;
+          }
+          continue;
+        }
+        const owner = api.owner;
+        if (api.key === null) {
+          check({ kind: "unknown" }, node, "dynamic framework API");
+          continue;
+        }
+        if (owner.kind === "test" && api.key === "extend") {
+          fixtures(node.arguments[0]);
+          continue;
+        }
+        if (owner.kind === "test" && api.key === "configure" && owner.path.includes("describe")) {
+          field(evaluate(node.arguments[0]), node.arguments[0], "suite timeout");
+          continue;
+        }
+        if (api.key !== "setTimeout" && api.key !== "slow") {
+          // SDK info retrieves TestInfo; step titles/locations do not replace the test slot.
+          if (
+            owner.kind === "test" &&
+            !bindings.registration(api) &&
+            !["info", "step"].includes(api.key)
+          )
+            check({ kind: "unknown" }, node, "admitted framework API carrier");
+          continue;
+        }
+        const fn = findContainingFunction(node);
+        const admitted = fn && bindings.registrationFor(fn).length === 1;
+        const state = states.get(fn) ?? initialState(fn);
+        const ordered = admitted && branchFree(node, fn);
+        if (api.key === "setTimeout") {
+          const value = evaluate(node.arguments[0]);
+          check(value, node.arguments[0] ?? node, "runtime timeout");
+          if (ordered && !value.runtimeFunction) state.timeout = value;
+          else state.timeout = { kind: "unknown" };
+        } else {
+          const condition = slowCondition(node);
+          if (condition === false) continue;
+          if (condition === null || !ordered) {
+            check({ kind: "unknown" }, node, "slow effective timeout");
+            state.timeout = { kind: "unknown" };
+            state.slow = null;
+          } else if (state.slow === null) {
+            // Unknown inherited latch: multiplication is a safe upper bound, not proof it happened.
+            const upper = state.timeout.kind === "number" ? state.timeout.value * 3 : null;
+            if (!(upper > 0 && Number.isFinite(upper) && upper <= max))
+              check({ kind: "unknown" }, node, "slow effective timeout");
+            state.timeout =
+              upper > 0 && Number.isFinite(upper) && upper <= max
+                ? { kind: "number", value: upper }
+                : { kind: "unknown" };
+            state.slow = true;
+          } else if (!state.slow) {
+            state.timeout =
+              state.timeout.kind === "number"
+                ? { kind: "number", value: state.timeout.value * 3 }
+                : { kind: "unknown" };
+            check(state.timeout, node, "slow effective timeout");
+            state.slow = true;
+          }
+        }
+        states.set(fn, state);
+      }
+    },
+  };
+});

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

@@ -0,0 +1,99 @@
+"use strict";
+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) {
+    if (value.kind !== "object") {
+      check({ 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);
+    return entry?.value;
+  }
+  function config(value, node) {
+    if (value.kind !== "object") {
+      check({ kind: "unknown" }, node, "config carrier");
+      return;
+    }
+    field(value, node, "project timeout");
+    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");
+  }
+  function fixtures(node) {
+    const value = evaluate(node);
+    if (value.kind !== "object") {
+      check({ kind: "unknown" }, node, "fixture carrier", fixtureMax);
+      return;
+    }
+    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)))
+        check({ kind: "unknown" }, entry.origin, "fixture entry carrier", fixtureMax);
+    }
+  }
+  function booleanValue(node, seen = new Set()) {
+    node = unwrapExpression(node);
+    if (!node) return null;
+    if (node.type === "Literal" && typeof node.value === "boolean") return node.value;
+    if (node.type === "UnaryExpression" && node.operator === "!") {
+      const value = booleanValue(node.argument, seen);
+      return value === null ? null : !value;
+    }
+    if (node.type !== "Identifier") return null;
+    const variable = resolveVariable(node, context),
+      def = variable?.defs[0];
+    if (
+      seen.has(variable) ||
+      def?.type !== "Variable" ||
+      def.parent.kind !== "const" ||
+      isReassigned(node, context)
+    )
+      return null;
+    return booleanValue(def.node.init, new Set([...seen, variable]));
+  }
+  function slowCondition(node) {
+    if (!node.arguments.length) return true;
+
+    // A fixture callback is not evaluated as a config callback: its runtime condition is unknown.
+    return booleanValue(node.arguments[0]);
+  }
+  function configRoots(option, exports, calls, bindings) {
+    const checkedConfigs = new Set();
+    for (const node of exports) {
+      const api = node.type === "CallExpression" ? bindings.resolve(node.callee) : null;
+      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 if (
+        (option.configFiles ?? []).some(
+          (file) =>
+            context.filename.replace(/\\/g, "/").endsWith("/" + file) || context.filename === file,
+        )
+      )
+        config(evaluate(node), node);
+    }
+    for (const node of calls) {
+      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");
+    }
+  }
+  return { field, configRoots, fixtures, slowCondition };
+}
+module.exports = { createCarriers };

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

@@ -0,0 +1,34 @@
+"use strict";
+module.exports = {
+  type: "problem",
+  docs: { description: "require bounded positive Playwright test deadlines", recommended: false },
+  schema: [
+    {
+      type: "object",
+      properties: {
+        max: { type: "number", minimum: 0, exclusiveMinimum: true },
+        fixtureMax: { type: "number", minimum: 0, exclusiveMinimum: true },
+        unknownValues: { enum: ["ignore", "finding"] },
+        registrationPackages: { type: "array", items: { type: "string" }, uniqueItems: true },
+        exportRoles: {
+          type: "object",
+          additionalProperties: {
+            type: "object",
+            additionalProperties: { enum: ["assertion", "ordinary", "opaque"] },
+          },
+        },
+        configFiles: { type: "array", items: { type: "string" }, uniqueItems: true },
+      },
+      additionalProperties: false,
+    },
+  ],
+  messages: {
+    effectiveSlot:
+      "Playwright registration inherits an unresolved effective deadline/latch; prove its configured owner and helper slots against {{max}} ms.",
+    invalid: "Playwright {{name}} must be positive and finite; zero disables the deadline.",
+    timeout:
+      "Playwright {{name}} exceeds {{max}} ms. Fix the stalled work rather than increasing the deadline.",
+    unknown:
+      "Playwright {{name}} cannot be resolved against {{max}} ms; keep admitted timeout carriers explicit.",
+  },
+};

package/src/rules/timeout-callback-bindings.js

@@ -0,0 +1,52 @@
+"use strict";
+const { resolveVariable, isReassigned } = require("./async-target-bindings");
+const { unwrapExpression, isFunction } = require("./async-ast");
+const { literalString } = require("./module-mock-helpers");
+function createCallbackBindings(context) {
+  function callback(node, seen = new Set(), allowPartial = false) {
+    node = unwrapExpression(node);
+    if (isFunction(node)) return node;
+    if (
+      node?.type === "CallExpression" &&
+      node.callee.type === "MemberExpression" &&
+      member(node.callee) === "bind"
+    ) {
+      const partial =
+        node.arguments.length > 1 || node.arguments.some((arg) => arg.type === "SpreadElement");
+      return partial && !allowPartial ? null : callback(node.callee.object, seen, allowPartial);
+    }
+    if (node?.type !== "Identifier") return null;
+    const variable = resolveVariable(node, context),
+      def = variable?.defs[0];
+    if (seen.has(variable)) return null;
+    if (def?.type === "FunctionName")
+      return variable.references.some((ref) => ref.isWrite() && !ref.init) ? null : def.node;
+    if (isReassigned(node, context)) return null;
+    if (def?.type !== "Variable" || def.parent.kind !== "const") return null;
+    return callback(def.node.init, new Set([...seen, variable]), allowPartial);
+  }
+  function staticName(node, seen = new Set()) {
+    node = unwrapExpression(node);
+    const literal = literalString(node);
+    if (literal !== null) return literal;
+    if (node?.type === "BinaryExpression" && node.operator === "+") {
+      const left = staticName(node.left, seen),
+        right = staticName(node.right, seen);
+      return left === null || right === null ? null : left + right;
+    }
+    if (node?.type !== "Identifier") return null;
+    const variable = resolveVariable(node, context),
+      def = variable?.defs[0];
+    if (
+      seen.has(variable) ||
+      def?.type !== "Variable" ||
+      def.parent.kind !== "const" ||
+      isReassigned(node, context)
+    )
+      return null;
+    return staticName(def.node.init, new Set([...seen, variable]));
+  }
+  const member = (node) => (node.computed ? staticName(node.property) : node.property.name);
+  return { callback, staticName, member };
+}
+module.exports = { createCallbackBindings };

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

@@ -0,0 +1,56 @@
+"use strict";
+const { unwrapExpression, unwrapTransparentParent } = require("./async-ast");
+const { resolveVariable } = require("./async-target-bindings");
+
+function initializer(variable) {
+  const def = variable?.defs[0];
+  return variable?.defs.length === 1 &&
+    def.type === "Variable" &&
+    def.parent.kind === "const" &&
+    def.node.id.type === "Identifier" &&
+    !["ExportNamedDeclaration", "ExportDefaultDeclaration"].includes(def.parent.parent?.type)
+    ? def.node.init
+    : null;
+}
+function immutableArray(variable, context, active = new Set()) {
+  if (!initializer(variable) || active.has(variable)) return false;
+  active.add(variable);
+  const result = variable.references.every((reference) => {
+    if (reference.init) return true;
+    if (reference.isWrite()) return false;
+    const node = unwrapTransparentParent(reference.identifier),
+      parent = node.parent;
+    // Spreads consume array elements, without exposing the array receiver.
+    if (parent?.type === "SpreadElement")
+      return ["ArrayExpression", "ObjectExpression"].includes(parent.parent.type);
+    return (
+      parent?.type === "VariableDeclarator" &&
+      parent.init === node &&
+      parent.id.type === "Identifier" &&
+      immutableArray(resolveVariable(parent.id, context), context, active)
+    );
+  });
+  active.delete(variable);
+  return result;
+}
+function arrayLength(expression, context, active = new Set()) {
+  const node = unwrapExpression(expression);
+  if (node?.type === "Identifier") {
+    const variable = resolveVariable(node, context);
+    if (!immutableArray(variable, context) || active.has(variable)) return null;
+    active.add(variable);
+    const length = arrayLength(initializer(variable), context, active);
+    active.delete(variable);
+    return length;
+  }
+  if (node?.type !== "ArrayExpression") return null;
+  let length = 0;
+  for (const element of node.elements) {
+    const added =
+      element?.type === "SpreadElement" ? arrayLength(element.argument, context, active) : 1;
+    if (added === null) return null;
+    length += added;
+  }
+  return length;
+}
+module.exports = { arrayLength };