test-inventory 0.2.1 → 0.3.0

package/dist/frameworks/bindings.js

@@ -1,10 +1,94 @@
-import { childNodes, propertyName, unwrap } from "../ast.js";
+import { childNodes, isFunctionNode, propertyName, returnValues, unwrap } from "../ast.js";
 import { parseFile } from "../parse.js";
 import { snippet } from "../source.js";
 import { problem, text } from "./common.js";
 export function exportName(name) {
     return name.type === 'Identifier' ? name.name : name.value;
 }
+/**
+ * The functions a module declares at its top level, by name, to tell whether one returns a test object: every value it
+ * returns is one, as `return base.extend({...})` is. An imported function is followed to its module. The function a
+ * module exports as its default, named or not, is also known as `default`.
+ */
+export class ModuleFunctions {
+    functions;
+    /** The functions being read, to end a function that returns what it returns itself. */
+    reading = new Set();
+    /** Whether each function returns a test object, read once however many calls and functions lead to it. */
+    read = new Map();
+    /** The values of variables the bindings left unbound, by name, which a call may make test objects. */
+    values = new Map();
+    /** Whether each of those holds a test object; null while that is being worked out, which ends a loop. */
+    built = new Map();
+    imported;
+    follow;
+    constructor(program, imported, follow) {
+        this.functions = topLevelFunctions(program);
+        this.imported = imported;
+        this.follow = follow;
+    }
+    /** Keeps the variables the bindings didn't bind without following calls, to be worked out when asked. */
+    keep(declarators) {
+        for (const { id, init } of declarators) {
+            if (id.type === 'Identifier' && init)
+                this.values.set(id.name, [...(this.values.get(id.name) ?? []), init]);
+        }
+    }
+    /**
+     * Whether a variable holds a test object built by a call, as `const test = defineBrokerTest()`. It is worked out
+     * only when asked, as following the call reads other modules.
+     */
+    holdsTestObject(name, isTestObject) {
+        const values = this.values.get(name);
+        if (!values)
+            return false;
+        if (!this.built.has(name)) {
+            this.built.set(name, null);
+            this.built.set(name, values.some(isTestObject));
+        }
+        return this.built.get(name) === true;
+    }
+    returnsTestObject(name, isTestObject) {
+        const fn = this.functions.get(name);
+        if (!fn) {
+            const from = this.imported.get(name);
+            return from !== undefined && this.follow(from.source, from.imported, 'function');
+        }
+        if (this.reading.has(fn))
+            return false;
+        if (!this.read.has(fn)) {
+            this.reading.add(fn);
+            this.read.set(fn, returnValues(fn)?.every(({ expression }) => isTestObject(expression)) ?? false);
+            this.reading.delete(fn);
+        }
+        return this.read.get(fn) === true;
+    }
+}
+/** The functions a module declares at its top level, by name; the one it exports as its default is also `default`. */
+function topLevelFunctions(program) {
+    const functions = new Map();
+    for (const statement of program.body) {
+        if (statement.type === 'ExportDefaultDeclaration') {
+            const value = statement.declaration;
+            if (value.type === 'FunctionDeclaration' || isFunctionNode(value))
+                functions.set('default', value);
+        }
+        const declaration = statement.type === 'ExportNamedDeclaration' || statement.type === 'ExportDefaultDeclaration'
+            ? statement.declaration
+            : statement;
+        if (declaration?.type === 'FunctionDeclaration' && declaration.id) {
+            functions.set(declaration.id.name, declaration);
+        }
+        else if (declaration?.type === 'VariableDeclaration') {
+            for (const { id, init } of declaration.declarations) {
+                const value = init ? unwrap(init) : null;
+                if (id.type === 'Identifier' && isFunctionNode(value))
+                    functions.set(id.name, value);
+            }
+        }
+    }
+    return functions;
+}
 export function topLevelDeclarators(program) {
     const declarators = [];
     for (const statement of program.body) {
@@ -79,22 +163,28 @@ export function bindAll(declarators, bind) {
         }
     }
 }
-/** Whether a module exports `name` as a test object. */
-export function exportsTestObject(program, name, objects) {
+/** Whether a module exports `name` as a test object, or as a function that returns one. */
+export function exportsTestObject(program, name, objects, exported = 'test object') {
     const own = ownExport(program, name);
+    const local = (localName) => exported === 'function' ? objects.returnsTestObject(localName) : objects.isTestName(localName);
     switch (own?.kind) {
-        case 'default':
-            return objects.isTestObject(own.value);
+        case 'default': {
+            if (exported === 'test object')
+                return objects.isTestObject(own.value);
+            // `export default defineBrokerTest`, or a function written there, which the module's functions know as `default`.
+            const value = unwrap(own.value);
+            return objects.returnsTestObject(value.type === 'Identifier' ? value.name : 'default');
+        }
         case 'variable':
-            return objects.isTestName(name);
+            return local(name);
         case 'function':
-            return false;
+            return exported === 'function' && objects.returnsTestObject(name);
         case 'specifier':
-            return own.source === null ? objects.isTestName(own.local) : objects.reexports(own.source, own.local);
+            return own.source === null ? local(own.local) : objects.reexports(own.source, own.local, exported);
     }
     return program.body.some((statement) => {
         const source = starReexport(statement);
-        return source !== null && objects.reexports(source, name);
+        return source !== null && objects.reexports(source, name, exported);
     });
 }
 /**
@@ -135,35 +225,44 @@ function starReexport(statement) {
  * The module and name a module's export comes from when it re-exports it, as in `export { test } from './base'`, or
  * builds it from something imported, directly or through its own variables, as in `const test = base.extend({...})`.
  */
-function importOrigin(program, name, isFramework) {
+function importOrigin(program, name, isFramework, exported) {
     const imported = moduleImports(program, isFramework);
     const own = ownExport(program, name);
     if (own === null) {
         for (const statement of program.body) {
             const source = starReexport(statement);
             if (source !== null && !isFramework(source))
-                return { source, imported: name, how: 're-exports' };
+                return { source, imported: name, how: 're-exports', exported };
         }
     }
     else if (own.kind === 'specifier') {
         // `export { test } from './fixtures'`, or `import { test } from './fixtures'` and then `export { test }`.
         const from = own.source === null ? imported.get(own.local) : { source: own.source, imported: own.local };
-        if (from && !isFramework(from.source))
-            return { source: from.source, imported: from.imported, how: 're-exports' };
+        if (from && !isFramework(from.source)) {
+            return { source: from.source, imported: from.imported, how: 're-exports', exported };
+        }
     }
+    if (exported === 'function')
+        return null;
     const values = new Map();
     for (const declarator of topLevelDeclarators(program)) {
         if (declarator.id.type === 'Identifier' && declarator.init)
             values.set(declarator.id.name, declarator.init);
     }
+    const functions = topLevelFunctions(program);
     const seen = new Set();
-    // The import a local name is, or is built from: the object `extend` is called on, the test objects a call such as
-    // `mergeTests(a, b)` combines, either side of `?:`, or another local name. Values only passed along, such as a
-    // fixtures object in `base.extend(fixtures)`, are not what the test object is built on.
+    const from = (local, kind) => {
+        const found = imported.get(local);
+        return found ? { source: found.source, imported: found.imported, exported: kind } : null;
+    };
+    // The import a local name is, or is built from: the object `extend` is called on, an imported function that builds
+    // it, what a function the module writes returns, the test objects a call such as `mergeTests(a, b)` combines,
+    // either side of `?:`, or another local name. Values only passed along, such as a fixtures object in
+    // `base.extend(fixtures)`, are not what the test object is built on.
     const builtFrom = (local) => {
         const value = values.get(local);
         if (imported.has(local) || !value || seen.has(local))
-            return imported.get(local) ?? null;
+            return from(local, 'test object');
         seen.add(local);
         return builtOn(value);
     };
@@ -180,6 +279,17 @@ function importOrigin(program, name, isFramework) {
                 const callee = unwrap(expression.callee);
                 if (callee.type === 'MemberExpression' && propertyName(callee) === 'extend')
                     return builtOn(callee.object);
+                if (callee.type === 'Identifier' && imported.has(callee.name))
+                    return from(callee.name, 'function');
+                const fn = callee.type === 'Identifier' && !seen.has(callee.name) ? functions.get(callee.name) : undefined;
+                if (fn && callee.type === 'Identifier') {
+                    seen.add(callee.name);
+                    for (const { expression: value } of returnValues(fn) ?? []) {
+                        const found = builtOn(value);
+                        if (found)
+                            return found;
+                    }
+                }
                 for (const argument of expression.arguments) {
                     const found = argument.type === 'SpreadElement' ? null : builtOn(argument);
                     if (found)
@@ -198,9 +308,11 @@ function importOrigin(program, name, isFramework) {
     for (const local of [name, ...locals]) {
         const found = values.has(local) ? builtFrom(local) : null;
         if (found)
-            return { source: found.source, imported: found.imported, how: 'builds' };
+            return { ...found, how: 'builds' };
     }
-    return null;
+    // `export default defineBrokerTest()`, built where it is exported.
+    const found = own?.kind === 'default' ? builtOn(own.value) : null;
+    return found && { ...found, how: 'builds' };
 }
 /** Whether a module imports, re-exports or requires any of the given sources. */
 export function importsFrom(program, matches) {
@@ -232,39 +344,61 @@ const MAX_DEPTH = 16;
  * nothing to do with the framework, as when a call only looked like a test. Each module is followed once for a name,
  * however many imports lead to it, as fixtures files that build on several others share their bases.
  */
-export function followModule(source, name, readModule, framework, path = [], followed = new Map()) {
+export function followModule(source, name, readModule, framework, exported = 'test object', path = [], followed = new Map()) {
     // Without a reader, as in scanSource, nothing can be read.
     const module = readModule ? readModule(source) : { reason: 'could not be read' };
     if ('reason' in module)
         return { exported: false, reason: module.reason };
-    if (path.includes(module.relativeFilePath))
+    // A module may be followed again for another name, as a fixtures file that a function it imports builds on.
+    const key = `${module.relativeFilePath}\0${exported}\0${name}`;
+    if (path.includes(key))
         return { exported: false, reason: 'imports it back, in a cycle' };
     if (path.length >= MAX_DEPTH)
         return { exported: false, reason: `is more than ${MAX_DEPTH} modules deep` };
-    const key = `${module.relativeFilePath}\0${name}`;
     let result = followed.get(key);
     if (!result) {
-        result = followExports(module, name, framework, [...path, module.relativeFilePath], followed);
+        result = followExports(module, name, framework, exported, [...path, key], followed);
         followed.set(key, result);
     }
     return result;
 }
-/** Whether a module exports `name` as a test object; `within` is the chain of modules followed to it, itself last. */
-function followExports(module, name, framework, within, followed) {
-    const { program, error } = parseModule(module);
+/**
+ * Whether a module exports `name` as a test object; `within` is the chain of modules and names followed to it, itself
+ * last.
+ */
+function followExports(module, name, framework, exported, within, followed) {
+    const { program, error, source } = parseModule(module);
     if (error)
         return { exported: false, reason: 'could not be parsed' };
-    const followFrom = (from, imported) => followModule(from, imported, module.readModule, framework, within, followed);
-    const objects = framework.testObjects(program, (from, imported) => followFrom(from, imported).exported);
-    if (exportsTestObject(program, name, objects))
+    const followFrom = (from, imported, kind) => followModule(from, imported, module.readModule, framework, kind, within, followed);
+    const objects = framework.testObjects(program, (from, imported, kind = 'test object') => followFrom(from, imported, kind).exported);
+    if (exportsTestObject(program, name, objects, exported))
         return { exported: true, reason: null };
-    const unrecognized = `does not export a ${framework.name} test object that could be recognized`;
-    const origin = importOrigin(program, name, framework.isSource);
+    const unrecognized = (kind) => `does not export ${kind === 'function' ? 'a function that returns a test object' : `a ${framework.name} test object`} that could be recognized`;
+    const origin = importOrigin(program, name, framework.isSource, exported);
     if (origin) {
-        const end = followFrom(origin.source, origin.imported).reason ?? unrecognized;
+        const end = followFrom(origin.source, origin.imported, origin.exported).reason ?? unrecognized(origin.exported);
         return { exported: false, reason: `${origin.how} it from '${origin.source}', which ${end}` };
     }
-    return { exported: false, reason: importsFrom(program, framework.isSource) ? unrecognized : null };
+    if (importsFrom(program, framework.isSource))
+        return { exported: false, reason: unrecognized(exported) };
+    // A module that doesn't import the framework may still build the test object with a function, as in
+    // `export const test = defineBrokerTest()`; one the scan can't follow is worth an error, not silence.
+    const call = exported === 'test object' ? creatingCall(program, name, source) : null;
+    return { exported: false, reason: call ? `builds it with ${call}, which is not followed` : null };
+}
+/**
+ * The call that creates what the module exports as `name`, a variable or its default export, as `defineBrokerTest()`;
+ * null for other values.
+ */
+function creatingCall(program, name, source) {
+    const own = ownExport(program, name);
+    const local = own?.kind === 'variable' ? name : own?.kind === 'specifier' && own.source === null ? own.local : null;
+    const declarator = topLevelDeclarators(program).find((item) => item.id.type === 'Identifier' && item.id.name === local);
+    const written = own?.kind === 'default' ? own.value : declarator?.init;
+    const init = written ? unwrap(written) : null;
+    const value = init?.type === 'AwaitExpression' ? unwrap(init.argument) : init;
+    return value?.type === 'CallExpression' ? `${snippet(source.slice(value.callee.start, value.callee.end))}()` : null;
 }
 /** Follows the import of `name` in a test file, with the diagnostic to report when it isn't a test object. */
 export function followImport(name, imported, readModule, file, framework) {

package/dist/frameworks/common.d.ts

@@ -1,6 +1,6 @@
 import type { Argument, CallExpression, Expression, Node, StringLiteral, TemplateLiteral, VariableDeclarator } from 'oxc-parser';
 import { type FunctionNode } from '../ast.ts';
-import type { Condition, Problem, Returns, Span, Title } from '../model.ts';
+import type { ApiCall, CallContext, Condition, Problem, Returns, Span, Title } from '../model.ts';
 import { type SourceText } from '../source.ts';
 import type { DiagnosticCode } from '../types.ts';
 import { type Resolved, type Values } from '../values.ts';
@@ -61,6 +61,11 @@ export declare function returnedFunction<T>(returns: Returns, shared: (a: T | nu
  * so worth following to see if the name is a custom test object.
  */
 export declare function looksLikeDeclaration(args: readonly Argument[]): boolean;
+/**
+ * A call the runner refuses. Shaped like a declaration outside any test or hook, it is also declared, without what
+ * makes it fail, so that its tests, and those of a describe, are listed as not loaded rather than missing.
+ */
+export declare function refused(call: CallExpression, refusal: Problem, context: CallContext, declare: () => ApiCall): ApiCall;
 /**
  * Whether a call shaped like a test, through an import that can't be followed, is worth an error: the name reads like
  * a test function, or a member such as `.describe` follows it. Helpers such as `join('root', file)` and

package/dist/frameworks/common.js

@@ -93,11 +93,22 @@ export function returnedTestObject(file, call) {
  * `shared` combines two; null when it may return something else.
  */
 export function returnedFunction(returns, shared) {
-    if (!returns.values)
+    const { values } = returns;
+    // A function that returns what it returns itself, through others or not, ends the lookup.
+    if (!values || reading.has(returns))
         return null;
-    const found = returns.values.map(({ expression, scopes }) => returns.adapter.testFunction(expression, scopes));
-    return found.slice(1).reduce(shared, found[0]);
+    if (!read.has(returns)) {
+        reading.add(returns);
+        const found = values.map(({ expression, scopes }) => returns.adapter.testFunction(expression, scopes, returns.returnsOf));
+        reading.delete(returns);
+        read.set(returns, found.slice(1).reduce(shared, found[0]));
+    }
+    return read.get(returns);
 }
+/** The functions whose values are being read, each one returning what the next returns. */
+const reading = new Set();
+/** What each function returns, read once however many calls and functions use it. */
+const read = new WeakMap();
 /** A title written as a string, a template, or text joined to one, as in `'cycles through ' + venue`. */
 function isTitleShaped(node) {
     if (node?.type === 'BinaryExpression' && node.operator === '+') {
@@ -119,6 +130,17 @@ export function looksLikeDeclaration(args) {
         (args.length === 3 && isFunctionNode(args[1]));
     return isTitleShaped(args.at(0)) && args.length >= 2 && args.length <= 3 && body;
 }
+/**
+ * A call the runner refuses. Shaped like a declaration outside any test or hook, it is also declared, without what
+ * makes it fail, so that its tests, and those of a describe, are listed as not loaded rather than missing.
+ */
+export function refused(call, refusal, context, declare) {
+    const declared = context.inBody || !looksLikeDeclaration(call.arguments) ? null : declare();
+    // A declaration refused for a second reason as well, as for its options, is reported for the first.
+    const found = declared?.kind === 'invalid' ? declared.declaration : declared;
+    const declaration = found?.kind === 'test' || found?.kind === 'describe' ? found : undefined;
+    return { kind: 'invalid', problem: refusal, declaration };
+}
 /**
  * Whether a call shaped like a test, through an import that can't be followed, is worth an error: the name reads like
  * a test function, or a member such as `.describe` follows it. Helpers such as `join('root', file)` and

package/dist/frameworks/playwright.d.ts

@@ -28,7 +28,7 @@ export declare class PlaywrightAdapter implements Adapter {
      * When the function can't be found, a call named like a test object is read as one on trust, with a warning.
      */
     private returned;
-    testFunction(expression: Expression, scopes: readonly Node[]): string[] | null;
+    testFunction(expression: Expression, scopes: readonly Node[], returnsOf: CallContext['returnsOf']): string[] | null;
     /** Whether a local variable is read as a test object it could be; see `localTestObject`. */
     private assumeLocal;
     private looksLikeTest;
@@ -49,6 +49,7 @@ export declare class PlaywrightAdapter implements Adapter {
     private follow;
     /** Whether an argument is, or works out to, a string, as a title is. Spread arguments are handled before. */
     private isTitle;
+    /** A chain Playwright refuses; one that starts like a declaration also declares a plain test or describe. */
     private invalid;
     private testCall;
     private modifier;

package/dist/frameworks/playwright.js

@@ -1,7 +1,7 @@
 import { childNodes, isFunctionNode, propertyKey, propertyName, unwrap } from "../ast.js";
 import { snippet } from "../source.js";
-import { allDeclarators, bindAll, exportName, followImport, followModule, moduleImports, requiredModule, } from "./bindings.js";
-import { atLeast, findFunction, isTestName, isTitleLiteral, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, namedFunction, origin, problem, readChain, readCondition, readOptions, readReason, readStrings, readTitle, returnedFunction, returnedTestObject, text, unresolvedOption, unresolvedOptions, } from "./common.js";
+import { allDeclarators, bindAll, exportName, followImport, followModule, moduleImports, ModuleFunctions, requiredModule, } from "./bindings.js";
+import { atLeast, findFunction, isTestName, isTitleLiteral, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, namedFunction, origin, problem, readChain, readCondition, readOptions, readReason, readStrings, readTitle, refused, returnedFunction, returnedTestObject, text, unresolvedOption, unresolvedOptions, } from "./common.js";
 const MISMATCHED_SOURCES = new Set(['vitest', '@jest/globals']);
 // Maps rather than object literals, so names such as `constructor` don't match inherited properties.
 const DESCRIBES = new Map([
@@ -24,6 +24,8 @@ const STATES = new Map([
 ]);
 /** Members of `test` that are known but don't declare or modify tests. */
 const OTHER_MEMBERS = new Set(['use', 'slow', 'setTimeout', 'extend']);
+/** First members of chains that never declare a test, even when Playwright refuses the rest of the chain. */
+const NOT_DECLARING = new Set(['step', 'abort', ...HOOKS, ...OTHER_MEMBERS]);
 /** First members that show a name imported from a local file is used as Playwright's `test`. */
 const TEST_MEMBERS = new Set(['describe', 'only', 'skip', 'fixme', 'fail', 'step', ...HOOKS]);
 /** The members of `test` a value chosen at run time holds either way: those both have, if both are the same kind. */
@@ -57,9 +59,12 @@ class PlaywrightBindings {
     /** Names imported from other modules, which may be test objects there. */
     imported;
     follow;
+    /** The module's functions and the variables they may build test objects in; see `ModuleFunctions`. */
+    functions;
     constructor(program, follow) {
         this.imported = moduleImports(program, (source) => isPlaywrightSource(source) || MISMATCHED_SOURCES.has(source));
         this.follow = follow;
+        this.functions = new ModuleFunctions(program, this.imported, follow);
         for (const statement of program.body) {
             if (statement.type !== 'ImportDeclaration' || statement.importKind === 'type')
                 continue;
@@ -85,41 +90,59 @@ class PlaywrightBindings {
                 }
             }
         }
-        bindAll(allDeclarators(program), (declarator) => {
+        const declarators = allDeclarators(program);
+        bindAll(declarators, (declarator) => {
             const bound = this.bind(declarator);
             if (bound)
                 this.declarations.add(declarator);
             return bound;
         });
+        this.functions.keep(declarators.filter((declarator) => !this.declarations.has(declarator)));
     }
     isTestName(name) {
-        return this.testNames.has(name) || this.importsTestObject(name);
+        return this.testNames.has(name) || this.importsTestObject(name) || this.holdsTestObject(name);
     }
-    isTestObject(expression) {
+    /**
+     * `followsCalls` is cleared where a call is not followed to what it returns: while the names are bound, so that only
+     * a value asked about is followed, as following reads other modules, and in the scanned file, whose calls the walk
+     * follows in their scopes.
+     */
+    isTestObject(expression, followsCalls = true) {
         const node = unwrap(expression);
         switch (node.type) {
             case 'Identifier':
-                return this.testNames.has(node.name) || this.importsTestObject(node.name);
+                return (this.testNames.has(node.name) ||
+                    this.importsTestObject(node.name) ||
+                    (followsCalls && this.holdsTestObject(node.name)));
             case 'MemberExpression':
                 return propertyName(node) === 'test' && this.isModule(node.object);
             case 'ConditionalExpression':
                 // `process.env.CI ? ciTest : test` is a test object either way.
-                return this.isTestObject(node.consequent) || this.isTestObject(node.alternate);
+                return this.isTestObject(node.consequent, followsCalls) || this.isTestObject(node.alternate, followsCalls);
             case 'CallExpression': {
                 const callee = unwrap(node.callee);
                 if (callee.type === 'MemberExpression' && propertyName(callee) === 'extend') {
-                    return this.isTestObject(callee.object);
+                    return this.isTestObject(callee.object, followsCalls);
                 }
+                // `mergeTests(a, b)`, or `defineBrokerTest()`, a function that returns a test object.
                 return callee.type === 'Identifier'
-                    ? this.mergeTestsNames.has(callee.name)
+                    ? this.mergeTestsNames.has(callee.name) || (followsCalls && this.returnsTestObject(callee.name))
                     : callee.type === 'MemberExpression' && propertyName(callee) === 'mergeTests' && this.isModule(callee.object);
             }
             default:
                 return false;
         }
     }
-    reexports(source, imported) {
-        return isPlaywrightSource(source) ? imported === 'test' || imported === 'default' : this.follow(source, imported);
+    returnsTestObject(name) {
+        return this.functions.returnsTestObject(name, (expression) => this.isTestObject(expression));
+    }
+    holdsTestObject(name) {
+        return this.functions.holdsTestObject(name, (expression) => this.isTestObject(expression));
+    }
+    reexports(source, imported, exported) {
+        if (!isPlaywrightSource(source))
+            return this.follow(source, imported, exported);
+        return exported === 'test object' && (imported === 'test' || imported === 'default');
     }
     /** Whether a name is imported from another module that exports it as a test object, as `base` from './base'. */
     importsTestObject(name) {
@@ -148,7 +171,7 @@ class PlaywrightBindings {
                 }
                 return true;
             }
-            if (this.isTestObject(init)) {
+            if (this.isTestObject(init, false)) {
                 this.testNames.add(id.name);
                 return true;
             }
@@ -192,10 +215,11 @@ export class PlaywrightAdapter {
         // A test object the file builds from an imported one, as in `const test = base.extend({...})`, is followed
         // quietly: a call through the import itself is what reports an import that can't be followed.
         const followed = new Map();
-        this.bindings = new PlaywrightBindings(program, (source, imported) => {
-            const key = `${source}\0${imported}`;
-            if (!followed.has(key))
-                followed.set(key, followModule(source, imported, readModule, PLAYWRIGHT).exported);
+        this.bindings = new PlaywrightBindings(program, (source, imported, exported = 'test object') => {
+            const key = `${source}\0${exported}\0${imported}`;
+            if (!followed.has(key)) {
+                followed.set(key, followModule(source, imported, readModule, PLAYWRIGHT, exported).exported);
+            }
             return followed.get(key) === true;
         });
         this.problems = [...this.bindings.mismatches];
@@ -210,14 +234,15 @@ export class PlaywrightAdapter {
         const key = names.join('.');
         const addedIn = ADDED_IN.get(key);
         if (addedIn && !atLeast(this.file.version, ...addedIn)) {
-            return this.invalid(call, `needs Playwright ${addedIn.join('.')} or newer`);
+            return this.invalid(call, names, `needs Playwright ${addedIn.join('.')} or newer`, context);
         }
         if (names[0] === 'info')
             return this.annotationsPush(call, links, context);
         if (names[0] === 'expect' || names[0] === 'step' || key === 'abort')
             return { kind: 'other' };
-        if (links.some((link) => link.args ?? link.template))
-            return this.invalid(call, "is not part of Playwright's API");
+        if (links.some((link) => link.args ?? link.template)) {
+            return this.invalid(call, names, "is not part of Playwright's API", context);
+        }
         if (key === '' || key === 'only' || key === 'skip' || key === 'fixme' || key === 'fail' || key === 'fail.only') {
             return this.testCall(call, key, context);
         }
@@ -230,7 +255,7 @@ export class PlaywrightAdapter {
             return { kind: 'hook', fn: findFunction(call.arguments), testContext: null };
         if (OTHER_MEMBERS.has(key))
             return { kind: 'other' };
-        return this.invalid(call, "is not part of Playwright's API");
+        return this.invalid(call, names, "is not part of Playwright's API", context);
     }
     /**
      * The links after the `test` object, or null when the chain doesn't start from Playwright's `test`. An import that
@@ -283,7 +308,7 @@ export class PlaywrightAdapter {
      */
     returned(call, links, args, lookup) {
         const callee = unwrap(call.callee);
-        if (callee.type !== 'Identifier' || !lookup.returnsOf)
+        if (callee.type !== 'Identifier')
             return null;
         const returns = lookup.returnsOf(callee.name, lookup.scopes);
         if (returns)
@@ -296,8 +321,8 @@ export class PlaywrightAdapter {
         }
         return [];
     }
-    testFunction(expression, scopes) {
-        return this.members(expression, { scopes, inBody: false, returnsOf: null });
+    testFunction(expression, scopes, returnsOf) {
+        return this.members(expression, { scopes, inBody: false, returnsOf });
     }
     /** Whether a local variable is read as a test object it could be; see `localTestObject`. */
     assumeLocal(declaration, name, links, args) {
@@ -343,7 +368,7 @@ export class PlaywrightAdapter {
             // `IS_PLATFORM ? test.describe.serial : test.describe`: only the members both branches have apply.
             return sharedMembers(this.members(node.consequent, lookup), this.members(node.alternate, lookup));
         }
-        if (this.bindings.isTestObject(node))
+        if (this.bindings.isTestObject(node, false))
             return [];
         const chain = readChain(node);
         if (!chain || chain.links.some((link) => link.args ?? link.template))
@@ -376,9 +401,15 @@ export class PlaywrightAdapter {
         const resolved = this.file.values.resolve(node, context.scopes);
         return resolved.ok && typeof resolved.value === 'string';
     }
-    invalid(call, reason) {
+    /** A chain Playwright refuses; one that starts like a declaration also declares a plain test or describe. */
+    invalid(call, names, reason, context) {
         const callee = snippet(text(this.file, call.callee));
-        return { kind: 'invalid', problem: problem('invalid-chain', call, `${callee} ${reason}.`, callee) };
+        const refusal = problem('invalid-chain', call, `${callee} ${reason}.`, callee);
+        return refused(call, refusal, context, () => {
+            if (NOT_DECLARING.has(names[0]))
+                return { kind: 'other' };
+            return names.includes('describe') ? this.describeCall(call, {}, context) : this.testCall(call, '', context);
+        });
     }
     testCall(call, key, context) {
         const args = call.arguments;
@@ -479,6 +510,7 @@ export class PlaywrightAdapter {
             isOnly: kind.only === true,
             mode: kind.mode ?? null,
             isShuffled: false,
+            passesDown: null,
             details: this.details(!anonymous && args.length === 3 ? args[1] : undefined, context, problems, title?.text ?? ''),
             fn,
             hashed: fn,

package/dist/frameworks/vitest.d.ts

@@ -26,7 +26,7 @@ export declare class VitestAdapter implements Adapter {
     private warnedAboutTags;
     constructor(parsed: ParsedFile, file: FileContext, readModule: ModuleReader | null);
     classify(call: CallExpression, context: CallContext): ApiCall | null;
-    testFunction(expression: Expression, scopes: readonly Node[]): TestFunction | null;
+    testFunction(expression: Expression, scopes: readonly Node[], returnsOf: CallContext['returnsOf']): TestFunction | null;
     /** A call to `bench` imported from Vitest 5, which is undefined there, so the call throws. */
     private benchCall;
     private chainCall;