eslint-plugin-no-mistakes 0.53.2 → 0.54.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-no-mistakes",
-  "version": "0.53.2",
+  "version": "0.54.0",
   "description": "ESLint and Oxlint rules for deterministic no-mistakes code analysis",
   "license": "MIT",
   "repository": {
@@ -17,20 +17,20 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "test": "vitest run --coverage"
-  },
   "devDependencies": {
     "@typescript-eslint/parser": "^8.67.0",
-    "@vitest/coverage-v8": "^4.1.10",
-    "eslint": "^10.8.1",
-    "oxlint": "^1.78.0",
-    "vitest": "^4.1.6"
+    "@vitest/coverage-v8": "^4.1.11",
+    "eslint": "^10.9.0",
+    "oxlint": "^1.80.0",
+    "vitest": "^4.1.11"
   },
   "peerDependencies": {
     "eslint": ">=9"
   },
   "engines": {
     "node": "^20.19.0 || ^22.13.0 || >=24"
+  },
+  "scripts": {
+    "test": "vitest run --coverage"
   }
-}
+}

package/src/index.js

@@ -22,6 +22,8 @@ const rules = {
   "playwright-literals": require("./rules/playwright-literals"),
   "playwright-naming-convention": require("./rules/playwright-naming-convention"),
   "playwright-no-empty": require("./rules/playwright-no-empty"),
+  "playwright-no-hoisted-unique-token": require("./rules/playwright-no-hoisted-unique-token"),
+  "playwright-no-raw-scroll-pagination": require("./rules/playwright-no-raw-scroll-pagination"),
   "playwright-no-set-timeout": require("./rules/playwright-no-set-timeout"),
   "playwright-prefer-get-by-test-id": require("./rules/playwright-prefer-get-by-test-id"),
   "playwright-require-exported-component-attribute": require("./rules/playwright-require-exported-component-attribute"),

package/src/rules/playwright-no-hoisted-unique-token-events.js

@@ -0,0 +1,75 @@
+"use strict";
+
+const { childNodes } = require("./test-no-shared-state-helpers");
+const { resolveVariable } = require("./test-no-shared-state-aliases");
+
+// The TypeScript node types that wrap a runtime value expression rather than being purely
+// type-positioned; every other "TS"-prefixed node type is skipped entirely by `collectEvents`.
+const TS_VALUE_WRAPPER_TYPES = new Set([
+  "TSAsExpression",
+  "TSSatisfiesExpression",
+  "TSNonNullExpression",
+  "TSInstantiationExpression",
+  "TSTypeAssertion",
+]);
+
+// An Identifier assigned to (not read) by a plain `=` assignment is a write, not a hoisted-value
+// reference: a hook that reassigns the tracked variable before reading it is no longer reusing the
+// hoisted value.
+function isWriteTarget(node) {
+  const parent = node.parent;
+  return parent?.type === "AssignmentExpression" && parent.operator === "=" && parent.left === node;
+}
+
+const KEYED_MEMBER_TYPES = new Set(["MethodDefinition", "PropertyDefinition"]);
+
+// Skip Identifier positions that are names, not value references: the non-computed `.property`
+// of a member access, a non-computed, non-shorthand object-literal `.key`, a non-computed class
+// method/field `.key` (a class declared inside the hook can legally name a member after the
+// tracked variable without reading it), and a plain-assignment write target.
+function isReferenceIdentifier(node) {
+  const parent = node.parent;
+  if (!parent) return true;
+  if (parent.type === "MemberExpression" && !parent.computed && parent.property === node) {
+    return false;
+  }
+  if (parent.type === "Property" && !parent.computed && !parent.shorthand && parent.key === node) {
+    return false;
+  }
+  if (KEYED_MEMBER_TYPES.has(parent.type) && !parent.computed && parent.key === node) {
+    return false;
+  }
+  return !isWriteTarget(node);
+}
+
+// Collects every read and write of an Identifier reachable from `node`, in source order.
+// TypeScript type-only positions (`type X = typeof suffix`, `: typeof suffix` annotations, a
+// `TSInterfaceDeclaration` body, ...) are skipped entirely — the value-wrapper expressions above
+// recurse into their runtime `.expression` only, never a type operand.
+function collectEvents(node, results) {
+  if (!node || typeof node.type !== "string") return;
+  if (node.type.startsWith("TS")) {
+    if (TS_VALUE_WRAPPER_TYPES.has(node.type)) collectEvents(node.expression, results);
+    return;
+  }
+  if (node.type === "Identifier") {
+    if (isWriteTarget(node)) results.push({ node, isWrite: true });
+    else if (isReferenceIdentifier(node)) results.push({ node, isWrite: false });
+  }
+  for (const child of childNodes(node)) collectEvents(child, results);
+}
+
+// A write's own right-hand side evaluates in full before the assignment takes effect, so a
+// self-referential write (`suffix = suffix.trim()`) still observes the pre-write, potentially
+// stale value — the result carries the same collision hazard as the value it derives from and
+// must not be treated as a fresh refresh of the tracked declarator.
+function writeReusesTrackedValue(node, declarator, context) {
+  const rhsEvents = [];
+  collectEvents(node.parent.right, rhsEvents);
+  return rhsEvents.some((rhsEvent) => {
+    const variable = resolveVariable(rhsEvent.node, context);
+    return variable?.defs?.some((def) => def.node === declarator) ?? false;
+  });
+}
+
+module.exports = { collectEvents, writeReusesTrackedValue };

package/src/rules/playwright-no-hoisted-unique-token.js

@@ -0,0 +1,193 @@
+"use strict";
+
+const { rule } = require("../helpers");
+const { isFunctionNode } = require("./test-no-shared-state-helpers");
+const { hasProperty, resolveVariable } = require("./test-no-shared-state-aliases");
+const {
+  calleeName,
+  importSpecifierName,
+  setupCallbackKind,
+} = require("./test-no-shared-state-callees");
+const {
+  collectEvents,
+  writeReusesTrackedValue,
+} = require("./playwright-no-hoisted-unique-token-events");
+
+const PLAYWRIGHT_PATH_PATTERN =
+  /(?:^|[/\\])(?:e2e|playwright)(?:[/\\]|$)|(?:^|[/\\])e2e\.(?:spec|test)\.[cm]?[jt]sx?$|\.pw\.(?:spec|test)\.[cm]?[jt]sx?$/;
+
+const TEST_BODY_NAMES = new Set(["test", "it"]);
+
+function isPlaywrightPath(filename) {
+  return PLAYWRIGHT_PATH_PATTERN.test(filename.replace(/\\/g, "/"));
+}
+
+function nearestOwnFunction(node) {
+  for (let current = node.parent; current && current.type !== "Program"; current = current.parent) {
+    if (isFunctionNode(current)) return current;
+  }
+  return null;
+}
+
+// A declaration is already safely scoped to its own re-entry unit when the function it lives in
+// is passed straight into a setup hook (`beforeAll`/`beforeEach`/`afterEach`/`afterAll`, bare or
+// `test.`-qualified) or a test body (`test`/`it`, including `.only`/`.skip`-style modifiers) — but
+// NOT `describe` anywhere in the callee chain (e.g. `test.describe.only`), which registers once
+// and is exactly as re-entry-hazardous as module scope. `testCalleeNames` carries every local alias
+// of the imported `test`/`it`/`describe` bindings, so an aliased `import { test as pw } from
+// "@playwright/test"` is recognized the same as the bare names.
+function isSharedScopeShield(fn, testCalleeNames) {
+  const parent = fn.parent;
+  if (!parent || parent.type !== "CallExpression") return false;
+  if (setupCallbackKind(parent, testCalleeNames)) return true;
+  const callee = parent.callee;
+  if (callee.type === "Identifier") return TEST_BODY_NAMES.has(callee.name);
+  if (callee.type === "MemberExpression" && !callee.computed) {
+    return TEST_BODY_NAMES.has(calleeName(callee)) && !hasProperty(callee, "describe");
+  }
+  return false;
+}
+
+// A declaration nested arbitrarily deep inside a `beforeAll` callback — even inside a local helper
+// function the hook itself defines and invokes — is minted fresh on every hook re-entry, so it is
+// never a hoisting hazard regardless of how many function boundaries separate it from the hook.
+function isWithinBeforeAllCallback(node, testCalleeNames) {
+  for (let fn = nearestOwnFunction(node); fn; fn = nearestOwnFunction(fn)) {
+    const parent = fn.parent;
+    if (
+      parent?.type === "CallExpression" &&
+      setupCallbackKind(parent, testCalleeNames) === "before-once"
+    ) {
+      return true;
+    }
+  }
+  return false;
+}
+
+const BRANCHING_ANCESTOR_TYPES = new Set([
+  "IfStatement",
+  "ConditionalExpression",
+  "SwitchStatement",
+  "SwitchCase",
+  "TryStatement",
+  "CatchClause",
+  "LogicalExpression",
+  "ForStatement",
+  "ForInStatement",
+  "ForOfStatement",
+  "WhileStatement",
+  "DoWhileStatement",
+]);
+
+// `collectEvents` walks the callback body in source order, not control-flow order, so a write
+// nested inside a branch, loop, or logical short-circuit may never execute on a given re-entry —
+// it cannot "refresh" the tracked value just because it was visited earlier in the traversal. Only
+// a write with no branching ancestor between it and the callback body is unconditional.
+function isUnconditionalWrite(node, callback) {
+  for (let current = node.parent; current && current !== callback; current = current.parent) {
+    if (BRANCHING_ANCESTOR_TYPES.has(current.type)) return false;
+    // A write inside a function nested in the callback (a locally-defined helper) only runs if
+    // that function is itself called — never assume the enclosing callback executes it unconditionally.
+    if (isFunctionNode(current) && current !== callback) return false;
+  }
+  return true;
+}
+
+module.exports = rule(
+  {
+    type: "problem",
+    docs: {
+      description:
+        "disallow reading a module/describe-scope unique-token call inside a re-entrant beforeAll",
+      recommended: false,
+    },
+    schema: [
+      {
+        type: "object",
+        properties: { tokenFactories: { type: "array", items: { type: "string" } } },
+      },
+    ],
+    messages: {
+      hoisted:
+        "`{{name}}` is generated once by `{{factory}}()` at module/describe scope, but `beforeAll` can re-run in the same worker process with module state preserved — the hoisted value is reused unchanged on re-entry and collides with itself. Move the `{{factory}}()` call to the first statement inside this `beforeAll` instead.",
+    },
+  },
+  (context) => {
+    let isPlaywrightFile = isPlaywrightPath(context.filename);
+    const tokenFactories = context.options?.[0]?.tokenFactories;
+    if (!tokenFactories || tokenFactories.length === 0) return {};
+    const factoryNames = new Set(tokenFactories);
+
+    // declarator node -> factory name, for declarations not already shielded inside their own hook/test.
+    const candidates = new Map();
+    const beforeAllCallbacks = [];
+    // Local aliases of the imported `test`/`it`/`describe` bindings (e.g. `import { test as pw }`),
+    // so `pw.beforeAll(...)` is recognized the same as `test.beforeAll(...)`.
+    const testCalleeNames = new Set(["test", "it", "describe"]);
+
+    return {
+      ImportDeclaration(node) {
+        if (node.source.value !== "@playwright/test") return;
+        isPlaywrightFile = true;
+        for (const specifier of node.specifiers) {
+          if (specifier.type !== "ImportSpecifier") continue;
+          const imported = importSpecifierName(specifier);
+          if (["describe", "it", "test"].includes(imported) && specifier.local?.name) {
+            testCalleeNames.add(specifier.local.name);
+          }
+        }
+      },
+      VariableDeclarator(node) {
+        if (
+          node.id.type !== "Identifier" ||
+          node.init?.type !== "CallExpression" ||
+          node.init.callee.type !== "Identifier" ||
+          !factoryNames.has(node.init.callee.name)
+        ) {
+          return;
+        }
+        const fn = nearestOwnFunction(node);
+        if (
+          (!fn || !isSharedScopeShield(fn, testCalleeNames)) &&
+          !isWithinBeforeAllCallback(node, testCalleeNames)
+        ) {
+          candidates.set(node, node.init.callee.name);
+        }
+      },
+      CallExpression(node) {
+        if (setupCallbackKind(node, testCalleeNames) !== "before-once") return;
+        const callback = node.arguments.find((argument) => isFunctionNode(argument));
+        if (callback) beforeAllCallbacks.push(callback);
+      },
+      "Program:exit"() {
+        if (!isPlaywrightFile || candidates.size === 0) return;
+        for (const callback of beforeAllCallbacks) {
+          const events = [];
+          collectEvents(callback.body, events);
+          const refreshed = new Set();
+          for (const event of events) {
+            // A `var` redeclared in the same scope (`var suffix; var suffix = randomSuffix();`)
+            // is one Variable with multiple defs — the factory-call declarator may be any of
+            // them, not necessarily defs[0], so every def must be checked against `candidates`.
+            const variable = resolveVariable(event.node, context);
+            const declarator = variable?.defs?.find((def) => candidates.has(def.node))?.node;
+            if (!declarator) continue;
+            if (event.isWrite) {
+              const refreshes =
+                isUnconditionalWrite(event.node, callback) &&
+                !writeReusesTrackedValue(event.node, declarator, context);
+              if (refreshes) refreshed.add(declarator);
+              continue;
+            }
+            if (refreshed.has(declarator)) continue;
+            context.report({
+              node: event.node,
+              messageId: "hoisted",
+              data: { name: event.node.name, factory: candidates.get(declarator) },
+            });
+          }
+        }
+      },
+    };
+  },
+);

package/src/rules/playwright-no-raw-scroll-pagination.js

@@ -0,0 +1,236 @@
+"use strict";
+
+const { rule } = require("../helpers");
+const { childNodes } = require("./test-no-shared-state-helpers");
+const { resolveVariable } = require("./test-no-shared-state-aliases");
+
+const PLAYWRIGHT_PATH_PATTERN =
+  /(?:^|[/\\])(?:e2e|playwright)(?:[/\\]|$)|(?:^|[/\\])e2e\.(?:spec|test)\.[cm]?[jt]sx?$|\.pw\.(?:spec|test)\.[cm]?[jt]sx?$/;
+
+const CURSOR_WAIT_PROPERTIES = new Set(["waitForRequest", "waitForResponse"]);
+const RAW_SCROLL_NAMES = new Set(["scrollTo", "scrollBy", "scroll"]);
+const SEARCH_PARAMS_ACCESSORS = new Set(["has", "get", "getAll"]);
+
+// The TypeScript node types that wrap a runtime value expression rather than being purely
+// type-positioned; every other "TS"-prefixed node type is skipped by `collectLiteralStrings` — a
+// string literal appearing only inside a type alias or annotation is never evaluated at runtime
+// and must not be mistaken for an actual cursor-param check.
+const TS_VALUE_WRAPPER_TYPES = new Set([
+  "TSAsExpression",
+  "TSSatisfiesExpression",
+  "TSNonNullExpression",
+  "TSInstantiationExpression",
+  "TSTypeAssertion",
+]);
+
+function isPlaywrightPath(filename) {
+  return PLAYWRIGHT_PATH_PATTERN.test(filename.replace(/\\/g, "/"));
+}
+
+function propertyName(node) {
+  if (!node) return null;
+  return node.type === "Literal" ? String(node.value) : node.name;
+}
+
+// `page.waitForRequest(...)` / `page.waitForResponse(...)`, matched by property name only — the
+// object (page, frame, a locator, ...) doesn't matter, mirroring how `playwright-no-set-timeout`
+// matches `.waitForTimeout` regardless of receiver. A statically computed access
+// (`page["waitForRequest"]`) is just as unambiguous as dot access and is matched the same way.
+function isCursorWaitCall(node) {
+  return (
+    node.callee.type === "MemberExpression" &&
+    (!node.callee.computed || node.callee.property.type === "Literal") &&
+    CURSOR_WAIT_PROPERTIES.has(propertyName(node.callee.property))
+  );
+}
+
+// `window.scrollTo(...)`/`window.scroll(...)`, bare `scrollTo(...)`/`scroll(...)`, and the
+// `scrollBy` equivalents — the only imperative, position-based browser scroll APIs. A same-named
+// method on any other receiver (`map.scrollTo()`, an editor or page-object helper) is not a
+// browser scroll and is never matched. `scrollIntoView` is element-relative, not a pagination
+// driver, and is intentionally not matched. Both the bare call and the `window`-qualified call
+// only count when the receiver resolves to the global — a project's own locally-declared or
+// imported `scrollTo`/`scroll`/`scrollBy` helper, or a shadowing `window` parameter (as in
+// `page.evaluate((window) => window.scrollTo(...), safeScroller)`), is a different function and
+// must not be misflagged.
+function isRawScrollCall(node, context) {
+  const callee = node.callee;
+  if (callee.type === "Identifier") {
+    if (!RAW_SCROLL_NAMES.has(callee.name)) return false;
+    return !(resolveVariable(callee, context)?.defs?.length > 0);
+  }
+  if (
+    callee.type !== "MemberExpression" ||
+    (callee.computed && callee.property.type !== "Literal") ||
+    callee.object.type !== "Identifier" ||
+    callee.object.name !== "window" ||
+    !RAW_SCROLL_NAMES.has(propertyName(callee.property))
+  ) {
+    return false;
+  }
+  return !(resolveVariable(callee.object, context)?.defs?.length > 0);
+}
+
+// `<something>.searchParams.has("after")` / `.get("after")` / `.getAll("after")` — the cursor
+// param name is passed as a bare accessor argument, never appearing with a trailing `=` the way
+// it does in a raw query string, so it needs its own literal-collection path rather than the
+// boundary-matched one below.
+function isSearchParamsAccessorCall(node) {
+  return Boolean(
+    node.callee.type === "MemberExpression" &&
+    !node.callee.computed &&
+    SEARCH_PARAMS_ACCESSORS.has(propertyName(node.callee.property)) &&
+    node.callee.object.type === "MemberExpression" &&
+    !node.callee.object.computed &&
+    propertyName(node.callee.object.property) === "searchParams",
+  );
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// Regex-derived literals are matched as pattern *source text*, not executed, so a regex author's
+// own boundary syntax (`[?&]after=`, `(?:^|[?&])after=`) leaves a `]` or `)` immediately before
+// the param name instead of a literal `?`/`&`. Only these exact, known boundary constructs count
+// as a separator for a regex-derived literal — accepting an arbitrary `)`/`]` before the param
+// would also match an unrelated alternation like `(?:next|prev)cursor=`, which closes a group
+// that has nothing to do with a query-string separator. A bare `&`, an escaped `\?`, or a `^`
+// start anchor written directly (`/&after=/`, `/\?after=/`, `/^after=/`) is unambiguous — unlike
+// `)`/`]`, none of these three characters ever closes an unrelated construct — so they count too.
+const REGEX_BOUNDARY_SUFFIXES = [
+  "(?:^|[?&])",
+  "(?:^|[&?])",
+  "(?:^|\\?|&)",
+  "(?:^|&|\\?)",
+  "[?&]",
+  "[&?]",
+  "&",
+  "\\?",
+  "^",
+];
+
+// Requires the cursor param to appear as an actual query-key boundary (`?after=`, `&after=`, or
+// `after=` at the very start of the literal) rather than an unconstrained substring match, which
+// would false-positive on e.g. `category=after-hours` for a configured param of `after`.
+function hasQueryParamBoundary(literal, param, isRegex) {
+  const target = new RegExp(`${escapeRegExp(param)}=`, "g");
+  for (const match of literal.matchAll(target)) {
+    const prefix = literal.slice(0, match.index);
+    if (prefix.length === 0) return true;
+    if (isRegex) {
+      if (REGEX_BOUNDARY_SUFFIXES.some((suffix) => prefix.endsWith(suffix))) return true;
+    } else if (/[?&]$/.test(prefix)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// TypeScript type-only positions (a type alias, an interface body, a `: typeof x` annotation, ...)
+// are skipped entirely — a string literal type or template literal type is never evaluated at
+// runtime and must not be mistaken for an actual cursor-param check. The value-wrapper expressions
+// above recurse into their runtime `.expression` only, never a type operand.
+function collectLiteralStrings(node, results) {
+  if (!node) return;
+  if (node.type.startsWith("TS")) {
+    if (TS_VALUE_WRAPPER_TYPES.has(node.type)) collectLiteralStrings(node.expression, results);
+    return;
+  }
+  if (node.type === "Literal") {
+    if (typeof node.value === "string") results.push({ value: node.value, isRegex: false });
+    else if (node.regex) results.push({ value: node.regex.pattern, isRegex: true });
+  } else if (node.type === "TemplateElement") {
+    results.push({ value: node.value?.raw ?? "", isRegex: false });
+  }
+  for (const child of childNodes(node)) collectLiteralStrings(child, results);
+}
+
+// A `.searchParams.has()`/`.get()` argument is never boundary-matched (see above), so an
+// interpolation-free template literal (`` `cursor` ``) is just as statically knowable as a plain
+// string literal — only a template with actual `${...}` interpolation is genuinely dynamic.
+function staticStringValue(node) {
+  if (node?.type === "Literal" && typeof node.value === "string") return node.value;
+  if (node?.type === "TemplateLiteral" && node.expressions.length === 0) {
+    return node.quasis[0].value.raw;
+  }
+  return null;
+}
+
+function collectSearchParamsAccessorArgs(node, results) {
+  if (!node) return;
+  if (node.type === "CallExpression" && isSearchParamsAccessorCall(node)) {
+    const value = staticStringValue(node.arguments[0]);
+    if (value !== null) results.push(value);
+  }
+  for (const child of childNodes(node)) collectSearchParamsAccessorArgs(child, results);
+}
+
+function mentionsCursorParam(node, cursorParams) {
+  if (!node) return false;
+  const literals = [];
+  collectLiteralStrings(node, literals);
+  if (
+    literals.some(({ value, isRegex }) =>
+      cursorParams.some((param) => hasQueryParamBoundary(value, param, isRegex)),
+    )
+  ) {
+    return true;
+  }
+  const accessorArgs = [];
+  collectSearchParamsAccessorArgs(node, accessorArgs);
+  return accessorArgs.some((value) => cursorParams.includes(value));
+}
+
+module.exports = rule(
+  {
+    type: "problem",
+    docs: {
+      description:
+        "disallow driving cursor-paginated infinite scroll with a raw window.scrollTo/scroll/scrollBy",
+      recommended: false,
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          cursorParams: { type: "array", items: { type: "string" } },
+          scrollHelper: { type: "string" },
+        },
+      },
+    ],
+    messages: {
+      rawScroll:
+        "This file awaits a cursor-paginated request/response but drives scrolling with a raw scrollTo/scroll/scrollBy call — a single synthetic scroll can land before a deferred IntersectionObserver mounts and be lost forever, stalling the wait for its full timeout.{{helperHint}}",
+    },
+  },
+  (context) => {
+    let isPlaywrightFile = isPlaywrightPath(context.filename);
+    const options = context.options?.[0] ?? {};
+    const cursorParams = options.cursorParams ?? ["after", "cursor"];
+    const scrollHelper = options.scrollHelper ?? "";
+    const helperHint = scrollHelper
+      ? ` Use ${scrollHelper}, which scrolls repeatedly until the request fires, instead.`
+      : " Use a helper that scrolls repeatedly until the request fires instead of a single raw call.";
+    let hasCursorWait = false;
+    const scrollCandidates = [];
+
+    return {
+      ImportDeclaration(node) {
+        if (node.source.value === "@playwright/test") isPlaywrightFile = true;
+      },
+      CallExpression(node) {
+        if (isCursorWaitCall(node) && mentionsCursorParam(node.arguments[0], cursorParams)) {
+          hasCursorWait = true;
+        }
+        if (isRawScrollCall(node, context)) scrollCandidates.push(node);
+      },
+      "Program:exit"() {
+        if (!isPlaywrightFile || !hasCursorWait) return;
+        for (const node of scrollCandidates) {
+          context.report({ node, messageId: "rawScroll", data: { helperHint } });
+        }
+      },
+    };
+  },
+);

package/src/rules/test-no-shared-state-aliases.js

@@ -37,10 +37,7 @@ function createImportedTestAliases(context) {
       return Boolean(imported && resolveVariable(base, context) !== imported);
     },
     hasProperty(callee, name) {
-      if (hasOwnProperty(callee, name)) return true;
-      if (callee?.type === "MemberExpression") return this.hasProperty(callee.object, name);
-      if (callee?.type === "CallExpression") return this.hasProperty(callee.callee, name);
-      return false;
+      return hasProperty(callee, name);
     },
   };
 }
@@ -49,8 +46,18 @@ function hasOwnProperty(callee, name) {
   return callee?.type === "MemberExpression" && !callee.computed && callee.property?.name === name;
 }
 
+// Recursively checks the whole callee chain (member accesses and call results) for a
+// non-computed property named `name`, e.g. `hasProperty(test.describe.only, "describe")`.
+function hasProperty(callee, name) {
+  if (hasOwnProperty(callee, name)) return true;
+  if (callee?.type === "MemberExpression") return hasProperty(callee.object, name);
+  if (callee?.type === "CallExpression") return hasProperty(callee.callee, name);
+  return false;
+}
+
 module.exports = {
   createImportedTestAliases,
   hasOwnProperty,
+  hasProperty,
   resolveVariable,
 };