test-inventory 0.1.1 → 0.2.0

package/dist/frameworks/bindings.d.ts

@@ -1,5 +1,6 @@
 import type { Expression, ModuleExportName, Node, Program, VariableDeclarator } from 'oxc-parser';
-import type { ModuleReader, Problem } from '../model.ts';
+import type { ModuleReader, ModuleSource, Problem } from '../model.ts';
+import { type ParsedFile } from '../parse.ts';
 import { type FileContext } from './common.ts';
 /** A name imported from a module other than the framework, which may be a custom `test` object in a fixtures file. */
 export interface ModuleImport {
@@ -26,26 +27,33 @@ export declare function requiredModule(expression: Expression): string | null;
 export declare function bindAll(declarators: VariableDeclarator[], bind: (declarator: VariableDeclarator) => boolean): void;
 /** Whether a module exports `name` as a test object. */
 export declare function exportsTestObject(program: Program, name: string, objects: TestObjects): boolean;
-/** Whether a module re-exports `name` from another module, which the scan does not follow. */
-export declare function reexportsFromModule(program: Program, name: string, isFramework: (source: string) => boolean): boolean;
-/**
- * Whether a module exports `name` as a value built from something imported from another module, directly or through
- * its own variables, as in `const test = baseTest.extend({...})` and then `export const browserTest = test`.
- */
-export declare function buildsFromModule(program: Program, name: string, isFramework: (source: string) => boolean): boolean;
-/** Whether a module imports or requires any of the given sources. */
+/** Whether a module imports, re-exports or requires any of the given sources. */
 export declare function importsFrom(program: Program, matches: (source: string) => boolean): boolean;
+/** Whether a name a module imports from another module is a test object there, which follows that module in turn. */
+export type FollowImport = (source: string, imported: string) => boolean;
 /** How a framework recognizes the modules and test objects of a followed file. */
 export interface Framework {
     name: string;
     isSource: (source: string) => boolean;
-    testObjects: (program: Program) => TestObjects;
+    /** The test objects of a followed module, which uses `follow` for the names it imports from other modules. */
+    testObjects: (program: Program, follow: FollowImport) => TestObjects;
 }
+/** Shared with the walk of imported helpers, so that a module both read and walked is parsed once. */
+export declare function parseModule(module: ModuleSource): ParsedFile;
 /**
- * Follows one import to see whether the module exports a test object. Only one level is followed. A module that has
- * nothing to do with the framework is not reported: the call only looked like a test.
+ * Whether `name` from `source` is a test object, following the module through the modules it re-exports from or builds
+ * on, as deep as it takes. When it isn't, the reason says where the chain ends; it is null for a module that has
+ * 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 declare function followModule(source: string, name: string, readModule: ModuleReader | null, framework: Framework, path?: readonly string[], followed?: Map<string, Followed>): Followed;
+interface Followed {
+    exported: boolean;
+    reason: string | null;
+}
+/** Follows the import of `name` in a test file, with the diagnostic to report when it isn't a test object. */
 export declare function followImport(name: string, imported: ModuleImport, readModule: ModuleReader | null, file: FileContext, framework: Framework): {
     exported: boolean;
     problem: Problem | null;
 };
+export {};

package/dist/frameworks/bindings.js

@@ -116,60 +116,102 @@ export function exportsTestObject(program, name, objects) {
     }
     return false;
 }
-/** Whether a module re-exports `name` from another module, which the scan does not follow. */
-export function reexportsFromModule(program, name, isFramework) {
-    const imported = moduleImports(program, isFramework);
-    return program.body.some((statement) => {
-        const required = commonJsReexport(statement);
-        if (required !== null)
-            return !isFramework(required);
-        if (statement.type === 'ExportAllDeclaration')
-            return !statement.exported && !isFramework(statement.source.value);
-        if (statement.type !== 'ExportNamedDeclaration')
-            return false;
-        // `export { test } from './fixtures'`, or `import { test } from './fixtures'` and then `export { test }`.
-        const fromModule = (local) => statement.source ? !isFramework(statement.source.value) : imported.has(local);
-        return statement.specifiers.some((specifier) => exportName(specifier.exported) === name && fromModule(exportName(specifier.local)));
-    });
-}
 /**
- * Whether a module exports `name` as a value built from something imported from another module, directly or through
- * its own variables, as in `const test = baseTest.extend({...})` and then `export const browserTest = test`.
+ * 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({...})`.
  */
-export function buildsFromModule(program, name, isFramework) {
+function importOrigin(program, name, isFramework) {
     const imported = moduleImports(program, isFramework);
+    for (const statement of program.body) {
+        const required = commonJsReexport(statement);
+        if (required !== null && !isFramework(required))
+            return { source: required, imported: name, how: 're-exports' };
+        if (statement.type === 'ExportAllDeclaration' && !statement.exported && !isFramework(statement.source.value)) {
+            return { source: statement.source.value, imported: name, how: 're-exports' };
+        }
+        if (statement.type !== 'ExportNamedDeclaration')
+            continue;
+        for (const specifier of statement.specifiers) {
+            if (exportName(specifier.exported) !== name)
+                continue;
+            const local = exportName(specifier.local);
+            // `export { test } from './fixtures'`, or `import { test } from './fixtures'` and then `export { test }`.
+            if (statement.source) {
+                if (isFramework(statement.source.value))
+                    continue;
+                return { source: statement.source.value, imported: local, how: 're-exports' };
+            }
+            const from = imported.get(local);
+            if (from)
+                return { source: from.source, imported: from.imported, how: 're-exports' };
+        }
+    }
     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 seen = new Set();
-    const builtFromImport = (local) => {
+    // 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 builtFrom = (local) => {
         const value = values.get(local);
-        if (!value || seen.has(local))
-            return false;
+        if (imported.has(local) || !value || seen.has(local))
+            return imported.get(local) ?? null;
         seen.add(local);
-        return usesImport(value);
+        return builtOn(value);
+    };
+    const builtOn = (node) => {
+        const expression = unwrap(node);
+        switch (expression.type) {
+            case 'Identifier':
+                return builtFrom(expression.name);
+            case 'MemberExpression':
+                return builtOn(expression.object);
+            case 'ConditionalExpression':
+                return builtOn(expression.consequent) ?? builtOn(expression.alternate);
+            case 'CallExpression': {
+                const callee = unwrap(expression.callee);
+                if (callee.type === 'MemberExpression' && propertyName(callee) === 'extend')
+                    return builtOn(callee.object);
+                for (const argument of expression.arguments) {
+                    const found = argument.type === 'SpreadElement' ? null : builtOn(argument);
+                    if (found)
+                        return found;
+                }
+                return null;
+            }
+            default:
+                return null;
+        }
     };
-    const usesImport = (node) => (node.type === 'Identifier' && (imported.has(node.name) || builtFromImport(node.name))) ||
-        childNodes(node).some(usesImport);
     // `export { test as browserTest }` exports a variable under another name.
     const locals = program.body.flatMap((statement) => statement.type === 'ExportNamedDeclaration' && !statement.source
         ? statement.specifiers.filter((item) => exportName(item.exported) === name).map((item) => exportName(item.local))
         : []);
-    return [name, ...locals].some(builtFromImport);
+    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 null;
 }
-/** Whether a module imports or requires any of the given sources. */
+/** Whether a module imports, re-exports or requires any of the given sources. */
 export function importsFrom(program, matches) {
     const requires = (node) => {
         const source = node.type === 'CallExpression' ? requiredModule(node) : null;
         return (source !== null && matches(source)) || childNodes(node).some(requires);
     };
-    return program.body.some((statement) => (statement.type === 'ImportDeclaration' && matches(statement.source.value)) || requires(statement));
+    return program.body.some((statement) => ((statement.type === 'ImportDeclaration' || statement.type === 'ExportAllDeclaration') &&
+        matches(statement.source.value)) ||
+        (statement.type === 'ExportNamedDeclaration' && statement.source !== null && matches(statement.source.value)) ||
+        requires(statement));
 }
 /** Parsed modules, kept while their source is, so that a fixtures file many tests import is parsed once. */
 const parsedModules = new WeakMap();
-function parseModule(module) {
+/** Shared with the walk of imported helpers, so that a module both read and walked is parsed once. */
+export function parseModule(module) {
     let parsed = parsedModules.get(module);
     if (!parsed) {
         parsed = parseFile(module.relativeFilePath, module.code);
@@ -177,31 +219,53 @@ function parseModule(module) {
     }
     return parsed;
 }
+/** How many modules deep an import is followed, far more than real fixture chains need. */
+const MAX_DEPTH = 16;
 /**
- * Follows one import to see whether the module exports a test object. Only one level is followed. A module that has
- * nothing to do with the framework is not reported: the call only looked like a test.
+ * Whether `name` from `source` is a test object, following the module through the modules it re-exports from or builds
+ * on, as deep as it takes. When it isn't, the reason says where the chain ends; it is null for a module that has
+ * 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 followImport(name, imported, readModule, file, framework) {
-    const unresolved = (reason) => problem('unresolved-test-import', imported.node, `'${name}' is imported from '${imported.source}', which ${reason}; tests that use it are missing.`, snippet(text(file, imported.node)));
+export function followModule(source, name, readModule, framework, path = [], followed = new Map()) {
     // Without a reader, as in scanSource, nothing can be read.
-    const module = readModule ? readModule(imported.source) : { reason: 'could not be read' };
+    const module = readModule ? readModule(source) : { reason: 'could not be read' };
     if ('reason' in module)
-        return { exported: false, problem: unresolved(module.reason) };
+        return { exported: false, reason: module.reason };
+    if (path.includes(module.relativeFilePath))
+        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);
+        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);
     if (error)
-        return { exported: false, problem: unresolved('could not be parsed') };
-    if (exportsTestObject(program, imported.imported, framework.testObjects(program))) {
-        return { exported: true, problem: null };
-    }
-    let reason = null;
-    if (reexportsFromModule(program, imported.imported, framework.isSource)) {
-        reason = 're-exports it from another module, which is not followed';
-    }
-    else if (buildsFromModule(program, imported.imported, framework.isSource)) {
-        reason = 'builds it from another module, which is not followed';
+        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))
+        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);
+    if (origin) {
+        const end = followFrom(origin.source, origin.imported).reason ?? unrecognized;
+        return { exported: false, reason: `${origin.how} it from '${origin.source}', which ${end}` };
     }
-    else if (importsFrom(program, framework.isSource)) {
-        reason = `does not export a ${framework.name} test object that could be recognized`;
-    }
-    return { exported: false, problem: reason ? unresolved(reason) : null };
+    return { exported: false, reason: importsFrom(program, framework.isSource) ? unrecognized : 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) {
+    const { exported, reason } = followModule(imported.source, imported.imported, readModule, framework);
+    const problemFound = reason
+        ? problem('unresolved-test-import', imported.node, `'${name}' is imported from '${imported.source}', which ${reason}; tests that use it are missing.`, snippet(text(file, imported.node)))
+        : null;
+    return { exported, problem: problemFound };
 }

package/dist/frameworks/playwright.js

@@ -1,6 +1,6 @@
 import { childNodes, isFunctionNode, propertyKey, propertyName, unwrap } from "../ast.js";
 import { snippet } from "../source.js";
-import { allDeclarators, bindAll, exportName, followImport, moduleImports, requiredModule, } from "./bindings.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, 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.
@@ -33,7 +33,11 @@ const ADDED_IN = new Map([
     ['abort', [1, 60]],
 ]);
 function isPlaywrightSource(source) {
-    return (source === '@playwright/test' || source === 'playwright/test' || source.startsWith('@playwright/experimental-ct-'));
+    return (source === '@playwright/test' ||
+        source === 'playwright/test' ||
+        source.startsWith('@playwright/experimental-ct-') ||
+        // Files generated from Gherkin features import Playwright's `test` from playwright-bdd, which extends it.
+        source === 'playwright-bdd');
 }
 /** The names a file binds to Playwright's `test`, its namespace and `mergeTests`. */
 class PlaywrightBindings {
@@ -43,7 +47,12 @@ class PlaywrightBindings {
     /** The import specifiers and declarators that bind those names, to tell them from local names that shadow them. */
     declarations = new Set();
     mismatches = [];
-    constructor(program) {
+    /** Names imported from other modules, which may be test objects there. */
+    imported;
+    follow;
+    constructor(program, follow) {
+        this.imported = moduleImports(program, (source) => isPlaywrightSource(source) || MISMATCHED_SOURCES.has(source));
+        this.follow = follow;
         for (const statement of program.body) {
             if (statement.type !== 'ImportDeclaration' || statement.importKind === 'type')
                 continue;
@@ -77,13 +86,13 @@ class PlaywrightBindings {
         });
     }
     isTestName(name) {
-        return this.testNames.has(name);
+        return this.testNames.has(name) || this.importsTestObject(name);
     }
     isTestObject(expression) {
         const node = unwrap(expression);
         switch (node.type) {
             case 'Identifier':
-                return this.testNames.has(node.name);
+                return this.testNames.has(node.name) || this.importsTestObject(node.name);
             case 'MemberExpression':
                 return propertyName(node) === 'test' && this.isModule(node.object);
             case 'ConditionalExpression':
@@ -103,7 +112,12 @@ class PlaywrightBindings {
         }
     }
     reexports(source, imported) {
-        return isPlaywrightSource(source) && (imported === 'test' || imported === 'default');
+        return isPlaywrightSource(source) ? imported === 'test' || imported === 'default' : this.follow(source, imported);
+    }
+    /** Whether a name is imported from another module that exports it as a test object, as `base` from './base'. */
+    importsTestObject(name) {
+        const from = this.imported.get(name);
+        return from !== undefined && this.follow(from.source, from.imported);
     }
     /** Whether an expression is the Playwright module object, from a namespace import or `require`. */
     isModule(expression) {
@@ -147,6 +161,11 @@ class PlaywrightBindings {
         return true;
     }
 }
+const PLAYWRIGHT = {
+    name: 'Playwright',
+    isSource: isPlaywrightSource,
+    testObjects: (program, follow) => new PlaywrightBindings(program, follow),
+};
 export class PlaywrightAdapter {
     problems;
     fileTags = [];
@@ -162,7 +181,15 @@ export class PlaywrightAdapter {
     constructor(program, file, readModule) {
         this.file = file;
         this.readModule = readModule;
-        this.bindings = new PlaywrightBindings(program);
+        // 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);
+            return followed.get(key) === true;
+        });
         this.problems = [...this.bindings.mismatches];
         this.imports = moduleImports(program, (source) => isPlaywrightSource(source) || MISMATCHED_SOURCES.has(source));
     }
@@ -292,11 +319,7 @@ export class PlaywrightAdapter {
         const imported = this.imports.get(name);
         let result = this.followed.get(name);
         if (!result) {
-            result = followImport(name, imported, this.readModule, this.file, {
-                name: 'Playwright',
-                isSource: isPlaywrightSource,
-                testObjects: (program) => new PlaywrightBindings(program),
-            });
+            result = followImport(name, imported, this.readModule, this.file, PLAYWRIGHT);
             this.followed.set(name, result);
             if (result.exported) {
                 this.bindings.testNames.add(name);
@@ -429,17 +452,31 @@ export class PlaywrightAdapter {
     }
     configure(call, context) {
         const options = call.arguments[0] ? readOptions(this.file, context.scopes, call.arguments[0]) : null;
-        const mode = options?.values.get('mode');
-        if (mode?.resolved.ok && ['parallel', 'serial', 'default'].includes(mode.resolved.value)) {
-            return { kind: 'mode', mode: mode.resolved.value };
+        const option = options?.values.get('mode');
+        const mode = option?.resolved.ok && ['parallel', 'serial', 'default'].includes(option.resolved.value)
+            ? option.resolved.value
+            : null;
+        const problems = mode
+            ? []
+            : [
+                ...(options ? unresolvedOptions(this.file, options, 'the mode is unknown') : []),
+                ...(option && !option.resolved.ok
+                    ? [unresolvedOption(this.file, 'mode', option.node, option.resolved.importedFrom, 'the mode is unknown')]
+                    : []),
+            ];
+        const locks = [];
+        const lock = options?.values.get('lock');
+        if (lock && atLeast(this.file.version, 1, 64)) {
+            const strings = readStrings(this.file, context.scopes, lock);
+            locks.push(...strings.values);
+            for (const { node: unresolved, importedFrom } of strings.unresolved) {
+                problems.push(unresolvedOption(this.file, 'lock', unresolved, importedFrom, 'the lock is missing'));
+            }
+        }
+        if (!mode && locks.length === 0) {
+            return problems.length > 0 ? { kind: 'invalid', problem: problems[0] } : { kind: 'other' };
         }
-        const problems = [
-            ...(options ? unresolvedOptions(this.file, options, 'the mode is unknown') : []),
-            ...(mode && !mode.resolved.ok
-                ? [unresolvedOption(this.file, 'mode', mode.node, mode.resolved.importedFrom, 'the mode is unknown')]
-                : []),
-        ];
-        return problems.length > 0 ? { kind: 'invalid', problem: problems[0] } : { kind: 'other' };
+        return { kind: 'configure', mode, locks, problems };
     }
     /** `test.info().annotations.push(...)` inside a test body. */
     annotationsPush(call, links, context) {

package/dist/frameworks/vitest.d.ts

@@ -34,6 +34,8 @@ export declare class VitestAdapter implements Adapter {
     /** Whether a local variable is read as a test object it could be; see `localTestObject`. */
     private assumeLocal;
     private looksLikeTest;
+    /** Vitest as followed modules are read, with the rules of the scanned version. */
+    private framework;
     /** Follows the import of `name` once, and reports it once when it can't be followed and `report` is set. */
     private follow;
     /** Hooks called directly, such as `beforeEach(...)` imported from Vitest or used as a global. */

package/dist/frameworks/vitest.js

@@ -1,6 +1,6 @@
-import { isFunctionNode, isImportMetaVitest, propertyKey, propertyName, unwrap } from "../ast.js";
+import { childNodes, isFunctionNode, isImportMetaVitest, propertyKey, propertyName, unwrap, } from "../ast.js";
 import { snippet } from "../source.js";
-import { allDeclarators, bindAll, exportName, followImport, moduleImports, requiredModule, } from "./bindings.js";
+import { allDeclarators, bindAll, exportName, followImport, followModule, moduleImports, requiredModule, } from "./bindings.js";
 import { atLeast, findFunction, isTestName, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, origin, problem, readChain, readCondition, readOptions, readStrings, isTitleLiteral, readReason, namedFunction, unresolvedOption, unresolvedOptions, readTitle, text, } from "./common.js";
 // Maps rather than object literals, so names such as `constructor` don't match inherited properties.
 const KINDS = new Map([
@@ -28,6 +28,56 @@ const HOOKS = new Map([
 ]);
 /** First members that show a name imported from a local file is used as Vitest's `test`. */
 const TEST_MEMBERS = new Set([...MODIFIERS.test, ...MODIFIERS.describe, ...TABLES, ...CONDITIONS, ...KINDS.keys()]);
+/** Calls Vitest moves to the top of the file before running it: `vi.mock`, `vi.unmock` and `vi.hoisted`. */
+const HOISTED_OBJECTS = new Set(['vi', 'vitest']);
+const HOISTED_METHODS = new Set(['mock', 'unmock', 'hoisted']);
+/**
+ * The hoisted calls that are not written at the top level of the file, where Vitest moves them. Vitest 5 fails such a
+ * file while it loads it. As in Vitest, `const value = vi.hoisted(...)` and `await vi.hoisted(...)` count as top
+ * level, and a file with in-source tests is never checked.
+ */
+function nestedHoistedCalls(program) {
+    if (hasInSourceTests(program))
+        return [];
+    const topLevel = new Set(program.body);
+    for (const statement of program.body) {
+        if (statement.type === 'ExpressionStatement')
+            topLevel.add(statement.expression);
+    }
+    const found = [];
+    const parents = [];
+    const visit = (node) => {
+        if (node.type === 'CallExpression' && node.callee.type === 'MemberExpression') {
+            const { object, property } = node.callee;
+            const method = !node.callee.computed && property.type === 'Identifier' ? property.name : '';
+            if (object.type === 'Identifier' && HOISTED_OBJECTS.has(object.name) && HOISTED_METHODS.has(method)) {
+                if (!topLevel.has(method === 'hoisted' ? hoistedValue(node, parents) : node))
+                    found.push(node);
+            }
+        }
+        parents.push(node);
+        for (const child of childNodes(node))
+            visit(child);
+        parents.pop();
+    };
+    visit(program);
+    return found;
+}
+/** Whether the file has in-source tests, which read `import.meta.vitest`. */
+function hasInSourceTests(node) {
+    return (node.type === 'MemberExpression' && isImportMetaVitest(node)) || childNodes(node).some(hasInSourceTests);
+}
+/** What Vitest moves for a `vi.hoisted` call: the declaration it initializes, the `await` around it, or the call. */
+function hoistedValue(call, parents) {
+    const declaration = parents.findLast((node) => node.type === 'VariableDeclaration');
+    const init = declaration?.type === 'VariableDeclaration' ? declaration.declarations[0]?.init : null;
+    const value = init ? unwrap(init) : null;
+    if (declaration && (value === call || (value?.type === 'AwaitExpression' && unwrap(value.argument) === call))) {
+        return declaration;
+    }
+    const parent = parents.at(-1);
+    return parent?.type === 'AwaitExpression' ? parent : call;
+}
 /** The names a file binds to Vitest's `test`, `describe`, hooks and namespace. */
 class VitestBindings {
     kinds = new Map();
@@ -38,7 +88,12 @@ class VitestBindings {
     /** The import specifiers and declarators that bind those names, to tell them from local names that shadow them. */
     declarations = new Set();
     problems = [];
-    constructor(program, version) {
+    /** Names imported from other modules, which may be test objects there. */
+    imported;
+    follow;
+    constructor(program, version, follow) {
+        this.imported = moduleImports(program, (source) => source === 'vitest' || MISMATCHED_SOURCES.has(source));
+        this.follow = follow;
         for (const statement of program.body) {
             if (statement.type !== 'ImportDeclaration' || statement.importKind === 'type')
                 continue;
@@ -75,12 +130,12 @@ class VitestBindings {
         });
     }
     isTestName(name) {
-        return this.kinds.has(name);
+        return this.kinds.has(name) || this.importsTestObject(name);
     }
     isTestObject(expression) {
         const node = unwrap(expression);
         if (node.type === 'Identifier')
-            return this.kinds.get(node.name) === 'test';
+            return this.kinds.get(node.name) === 'test' || this.importsTestObject(node.name);
         if (node.type === 'MemberExpression') {
             return KINDS.get(propertyName(node) ?? '') === 'test' && this.isNamespace(node.object);
         }
@@ -96,7 +151,12 @@ class VitestBindings {
             this.isTestObject(callee.object));
     }
     reexports(source, imported) {
-        return source === 'vitest' && KINDS.has(imported);
+        return source === 'vitest' ? KINDS.has(imported) : this.follow(source, imported);
+    }
+    /** Whether a name is imported from another module that exports it as a test object, as `base` from './base'. */
+    importsTestObject(name) {
+        const from = this.imported.get(name);
+        return from !== undefined && this.follow(from.source, from.imported);
     }
     isNamespace(expression) {
         const node = unwrap(expression);
@@ -156,8 +216,22 @@ export class VitestAdapter {
     constructor(parsed, file, readModule) {
         this.file = file;
         this.readModule = readModule;
-        this.bindings = new VitestBindings(parsed.program, file.version);
+        // A test object the file builds from an imported one, as in `const it = 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 VitestBindings(parsed.program, file.version, (source, imported) => {
+            const key = `${source}\0${imported}`;
+            if (!followed.has(key))
+                followed.set(key, followModule(source, imported, readModule, this.framework()).exported);
+            return followed.get(key) === true;
+        });
         this.problems = [...this.bindings.problems];
+        if (atLeast(file.version, 5, 0)) {
+            for (const call of nestedHoistedCalls(parsed.program)) {
+                const callee = snippet(text(this.file, call.callee));
+                this.problems.push(problem('removed-api', call, `Vitest 5 fails a file that calls ${callee}(...) anywhere but its top level, because the call is hoisted there.`, callee));
+            }
+        }
         this.imports = moduleImports(parsed.program, (source) => source === 'vitest' || MISMATCHED_SOURCES.has(source));
         if (atLeast(file.version, 4, 1)) {
             // Vitest's own pattern, over the whole text as Vitest reads it, so the same tags come out.
@@ -325,16 +399,21 @@ export class VitestAdapter {
     looksLikeTest(links, args) {
         return links.length === 0 ? looksLikeDeclaration(args) : TEST_MEMBERS.has(links[0].name);
     }
+    /** Vitest as followed modules are read, with the rules of the scanned version. */
+    framework() {
+        const version = this.file.version;
+        return {
+            name: 'Vitest',
+            isSource: (source) => source === 'vitest',
+            testObjects: (program, follow) => new VitestBindings(program, version, follow),
+        };
+    }
     /** Follows the import of `name` once, and reports it once when it can't be followed and `report` is set. */
     follow(name, report) {
         const imported = this.imports.get(name);
         let result = this.followed.get(name);
         if (!result) {
-            result = followImport(name, imported, this.readModule, this.file, {
-                name: 'Vitest',
-                isSource: (source) => source === 'vitest',
-                testObjects: (program) => new VitestBindings(program, this.file.version),
-            });
+            result = followImport(name, imported, this.readModule, this.file, this.framework());
             this.followed.set(name, result);
             if (result.exported) {
                 this.bindings.kinds.set(name, KINDS.get(imported.imported) ?? 'test');

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { scan } from './scan.ts';
 export { scanSource } from './scan-source.ts';
 export type { CommentsMode, ScanOptions, ScanSourceOptions } from './options.ts';
-export type { Annotation, Diagnostic, DiagnosticCode, DiagnosticLevel, Framework, Inventory, MetaValue, StateSource, SuiteRecord, Summary, TestRecord, TestState, Tool, } from './types.ts';
+export type { Annotation, DeclaredAt, Diagnostic, DiagnosticCode, DiagnosticLevel, Framework, Inventory, MetaValue, StateSource, SuiteRecord, Summary, TestRecord, TestState, Tool, } from './types.ts';

package/dist/model.d.ts

@@ -77,9 +77,13 @@ export type ApiCall = TestDeclaration | SuiteDeclaration | {
     reason: string | null;
     hasDynamicReason: boolean;
     problems: Problem[];
-} | {
-    kind: 'mode';
-    mode: Mode;
+}
+/** `test.describe.configure()`: a mode, locks (Playwright 1.64), or both. */
+ | {
+    kind: 'configure';
+    mode: Mode | null;
+    locks: string[];
+    problems: Problem[];
 } | {
     kind: 'hook';
     fn: FunctionNode | null;
@@ -106,6 +110,8 @@ export interface CallContext {
 export interface ModuleSource {
     code: string;
     relativeFilePath: string;
+    /** Reads the modules this module imports in turn. */
+    readModule: ModuleReader;
 }
 /** Reads the module an import refers to, or says why it can't, as in "could not be read". */
 export type ModuleReader = (specifier: string) => ModuleSource | {

package/dist/options.d.ts

@@ -1,6 +1,7 @@
 import type { CommentsMode } from './records.ts';
 import type { Framework } from './types.ts';
 export type { CommentsMode };
+/** @inline */
 export interface ScanOptions {
     /** Glob patterns for the test files, relative to `root`. */
     patterns: string[];
@@ -14,6 +15,7 @@ export interface ScanOptions {
     /** Which tests get the comments above them. Defaults to `non-active`. */
     comments?: CommentsMode;
 }
+/** @inline */
 export interface ScanSourceOptions {
     code: string;
     /** Path of the file from the project root, used in the output and in ids. */

package/dist/records.d.ts

@@ -1,6 +1,7 @@
 import type { Extraction } from './extract.ts';
 import type { ParsedFile } from './parse.ts';
 import type { Diagnostic, Framework, SuiteRecord, TestRecord } from './types.ts';
+/** @inline */
 export type CommentsMode = 'all' | 'non-active' | 'none';
 export interface FileRecords {
     suites: SuiteRecord[];