test-inventory 0.6.1 → 0.8.0

package/dist/frameworks/vitest.d.ts

@@ -1,67 +1,18 @@
-import type { CallExpression, Expression, Node } from 'oxc-parser';
-import type { Adapter, ApiCall, CallContext, ModuleReader, Problem, Span } from '../model.ts';
+import type { CallExpression } from 'oxc-parser';
+import type { ApiCall, CallContext, ModuleReader } from '../model.ts';
 import type { ParsedFile } from '../parse.ts';
+import type { HookCounts } from '../types.ts';
 import { type FileContext, type Link } from './common.ts';
-type Kind = 'test' | 'describe';
-/** A test or describe function and the links after it, as in `test.skipIf(isCI)`. */
-interface TestFunction {
-    kind: Kind;
-    links: Link[];
-}
-export declare class VitestAdapter implements Adapter {
-    readonly problems: Problem[];
-    readonly fileTags: string[];
-    readonly fileTagSpans: Span[];
-    usesGlobals: boolean;
-    private readonly file;
-    private readonly readModule;
-    private readonly bindings;
-    private readonly imports;
-    private readonly followed;
-    private readonly reported;
-    /** Variables and names of functions read as test objects on trust, each reported once. */
-    private readonly assumed;
-    private readonly aliases;
-    /** Describe callbacks and the name of their first parameter, which Vitest calls with its `test`. */
-    private readonly suiteParameters;
+import { SuiteAdapter, type Kind } from './test-functions.ts';
+export declare class VitestAdapter extends SuiteAdapter {
     private warnedAboutTags;
     constructor(parsed: ParsedFile, file: FileContext, readModule: ModuleReader | null);
+    protected isAliasLink(kind: Kind, link: Link): boolean;
     classify(call: CallExpression, context: CallContext): ApiCall | 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;
-    /**
-     * The function a chain calls and the links after it, or null when it isn't one of Vitest's. An import that can't be
-     * followed is reported only outside test and hook bodies, where a call can declare tests.
-     */
-    private resolve;
-    private start;
-    /** The function and modifiers a variable holds, as in `const skipOnCi = test.skipIf(isCI)`. */
-    private alias;
-    private aliasOf;
-    /**
-     * The function a call returns, as `conditionalTest({ min: 22 })` returns `it` or `it.skip`: what all the values the
-     * function returns have in common, as for a variable chosen by a condition. When the function can't be found, a call
-     * named like a test object is read as one on trust, with a warning; see `returnedTestObject`.
-     */
-    private returned;
-    /** Whether a local variable is read as a test object it could be; see `localTestObject`. */
-    private assumeLocal;
-    private looksLikeTest;
-    /**
-     * Whether a call through an imported name is worth following to the module: shaped like a test, or any call with a
-     * title and a body through a name that reads like a test function, as `it.effect('title', fn)` on a test object that
-     * a package extends.
-     */
-    private worthFollowing;
-    /** 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. */
-    private hookCall;
-    private hook;
+    protected hook(call: CallExpression, name: keyof HookCounts, context: CallContext): ApiCall;
     private contextSkip;
     /**
      * `annotate(message, type?)` from the test context (3.2), as an annotation of type `notice` when no type is given; the
@@ -79,7 +30,11 @@ export declare class VitestAdapter implements Adapter {
     private retry;
     private meta;
     private caseCount;
-    private arrayLength;
+    /**
+     * The cases of a table whose values the scan can work out, as Vitest passes them: `.each` spreads a case that is an
+     * array into the callback's arguments when every case is one, and `.for` passes each case whole. A tagged template
+     * gives one object per row, keyed by the names in its first line.
+     */
+    private tableCases;
     private tagsUsed;
 }
-export {};

package/dist/frameworks/vitest.js

@@ -1,26 +1,8 @@
 import { childNodes, isFunctionNode, isImportMetaVitest, propertyKey, propertyName, unwrap, } from "../ast.js";
 import { snippet } from "../source.js";
-import { allDeclarators, bindAll, exportName, followImport, followModule, moduleImports, ModuleFunctions, requiredModule, } from "./bindings.js";
-import { atLeast, hookFunction, isTestName, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, origin, problem, readChain, readCondition, returnedFunction, returnedTestObject, destructuredNames, takesWhole, readCount, readOptions, readStrings, isTitleLiteral, readReason, namedFunction, unresolvedOption, unresolvedOptions, readTitle, refused, text, } from "./common.js";
-/** What a test function chosen at run time, as in `isCI ? it.skip : it`, is either way: only the links both have. */
-function shared(a, b) {
-    if (!a || a.kind !== b?.kind)
-        return null;
-    const same = (link, index) => {
-        const other = b.links.at(index);
-        return other?.name === link.name && !link.args && !link.template && !other.args && !other.template;
-    };
-    const differs = a.links.findIndex((link, index) => !same(link, index));
-    return { kind: a.kind, links: differs === -1 ? a.links : a.links.slice(0, differs) };
-}
-// Maps rather than object literals, so names such as `constructor` don't match inherited properties.
-const KINDS = new Map([
-    ['test', 'test'],
-    ['it', 'test'],
-    ['describe', 'describe'],
-    ['suite', 'describe'],
-]);
-const MISMATCHED_SOURCES = new Set(['@playwright/test', 'playwright/test', '@jest/globals']);
+import { vitestCaseTitle } from "../case-titles.js";
+import { atLeast, hookFunction, problem, readChain, readCondition, destructuredNames, takesWhole, readCount, readOptions, readStrings, isTitleLiteral, readReason, namedFunction, origin, unresolvedOption, unresolvedOptions, readTitle, refused, text, } from "./common.js";
+import { SuiteAdapter } from "./test-functions.js";
 const MODIFIERS = {
     test: new Set(['concurrent', 'sequential', 'only', 'skip', 'todo', 'fails']),
     describe: new Set(['concurrent', 'sequential', 'shuffle', 'skip', 'only', 'todo']),
@@ -44,7 +26,25 @@ function isHook(name) {
 /** First members of chains that never declare a test, even when Vitest refuses the rest of the chain. */
 const NOT_DECLARING = new Set([...HOOKS.keys(), ...DERIVATIONS]);
 /** 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()]);
+const TEST_MEMBERS = [...MODIFIERS.test, ...MODIFIERS.describe, ...TABLES, ...CONDITIONS];
+const VITEST = {
+    name: 'Vitest',
+    source: 'vitest',
+    mismatched: new Set(['@playwright/test', 'playwright/test', '@jest/globals']),
+    starts: new Map([
+        ['test', { kind: 'test', links: [] }],
+        ['it', { kind: 'test', links: [] }],
+        ['describe', { kind: 'describe', links: [] }],
+        ['suite', { kind: 'describe', links: [] }],
+    ]),
+    hooks: new Set(HOOKS.keys()),
+    derivations: DERIVATIONS,
+    modifiers: new Set([...MODIFIERS.test, ...MODIFIERS.describe]),
+    carriesKinds: true,
+    isModule: isImportMetaVitest,
+    defaultImport: "Vitest has no default export; import { test, describe } from 'vitest' instead.",
+    required: 'Vitest cannot be loaded with require(); tests that use it are missing.',
+};
 /** 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']);
@@ -112,186 +112,16 @@ function fixturesOf(fn, index, version) {
         return !since || !atLeast(version, ...since);
     });
 }
-/** The names a file binds to Vitest's `test`, `describe`, hooks and namespace. */
-class VitestBindings {
-    kinds = new Map();
-    hooks = new Map();
-    namespaces = new Set();
-    /** Names `bench` is imported as from Vitest 5, which no longer exports it. */
-    benches = new Set();
-    /** The import specifiers and declarators that bind those names, to tell them from local names that shadow them. */
-    declarations = new Set();
-    problems = [];
-    /** 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, version, follow) {
-        this.imported = moduleImports(program, (source) => source === 'vitest' || 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;
-            const source = statement.source.value;
-            if (MISMATCHED_SOURCES.has(source)) {
-                this.problems.push(problem('framework-mismatch', statement, `The file imports '${source}', but the scan is for Vitest.`));
-            }
-            if (source !== 'vitest')
-                continue;
-            for (const specifier of statement.specifiers) {
-                this.declarations.add(specifier);
-                if (specifier.type === 'ImportNamespaceSpecifier') {
-                    this.namespaces.add(specifier.local.name);
-                }
-                else if (specifier.type === 'ImportDefaultSpecifier') {
-                    this.problems.push(problem('invalid-import', specifier, "Vitest has no default export; import { test, describe } from 'vitest' instead."));
-                }
-                else {
-                    this.bindImported(exportName(specifier.imported), specifier.local.name, version);
-                }
-            }
-        }
-        const declarators = allDeclarators(program);
-        for (const declarator of declarators) {
-            if (declarator.init && requiredModule(declarator.init) === 'vitest') {
-                this.problems.push(problem('invalid-import', declarator, 'Vitest cannot be loaded with require(); tests that use it are missing.'));
-            }
-        }
-        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.kinds.has(name) || this.importsTestObject(name) || this.holdsTestObject(name);
-    }
-    /**
-     * `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);
-        if (node.type === 'Identifier') {
-            const { name } = node;
-            return (this.kinds.get(name) === 'test' || this.importsTestObject(name) || (followsCalls && this.holdsTestObject(name)));
-        }
-        if (node.type === 'MemberExpression') {
-            return KINDS.get(propertyName(node) ?? '') === 'test' && this.isNamespace(node.object);
-        }
-        // `process.env.CI ? vitestTest : skippedTest` is a test object either way.
-        if (node.type === 'ConditionalExpression') {
-            return this.isTestObject(node.consequent, followsCalls) || this.isTestObject(node.alternate, followsCalls);
-        }
-        if (node.type !== 'CallExpression')
-            return false;
-        const callee = unwrap(node.callee);
-        // `defineBrokerTest()`, a function that returns a test object.
-        if (callee.type === 'Identifier')
-            return followsCalls && this.returnsTestObject(callee.name);
-        return (callee.type === 'MemberExpression' &&
-            DERIVATIONS.has(propertyName(callee) ?? '') &&
-            this.isTestObject(callee.object, followsCalls));
-    }
-    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 (source !== 'vitest')
-            return this.follow(source, imported, exported);
-        return exported === 'test object' && KINDS.has(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);
-        return node.type === 'Identifier' && this.namespaces.has(node.name);
-    }
-    bindImported(imported, local, version) {
-        const kind = KINDS.get(imported);
-        if (kind) {
-            this.kinds.set(local, kind);
-        }
-        else if (isHook(imported)) {
-            this.hooks.set(local, imported);
-        }
-        else if (imported === 'bench' && atLeast(version, 5, 0)) {
-            this.benches.add(local);
-        }
-    }
-    bind(declarator) {
-        const { id, init } = declarator;
-        if (!init)
-            return false;
-        if (id.type === 'Identifier' && this.isTestObject(init, false)) {
-            this.kinds.set(id.name, 'test');
-            return true;
-        }
-        if (id.type !== 'ObjectPattern' || !isImportMetaVitest(init))
-            return false;
-        // In-source tests: const { it, describe } = import.meta.vitest
-        for (const property of id.properties) {
-            if (property.type === 'RestElement' || property.value.type !== 'Identifier')
-                continue;
-            const key = propertyKey(property);
-            const kind = KINDS.get(key ?? '');
-            if (kind)
-                this.kinds.set(property.value.name, kind);
-            if (key !== null && isHook(key))
-                this.hooks.set(property.value.name, key);
-        }
-        return true;
-    }
-}
-export class VitestAdapter {
-    problems;
-    fileTags = [];
-    fileTagSpans = [];
-    usesGlobals = false;
-    file;
-    readModule;
-    bindings;
-    imports;
-    followed = new Map();
-    reported = new Set();
-    /** Variables and names of functions read as test objects on trust, each reported once. */
-    assumed = new Set();
-    aliases = new Map();
-    /** Describe callbacks and the name of their first parameter, which Vitest calls with its `test`. */
-    suiteParameters = new Map();
+export class VitestAdapter extends SuiteAdapter {
     warnedAboutTags = false;
     constructor(parsed, file, readModule) {
-        this.file = file;
-        this.readModule = readModule;
-        // 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, exported = 'test object') => {
-            const key = `${source}\0${exported}\0${imported}`;
-            if (!followed.has(key)) {
-                followed.set(key, followModule(source, imported, readModule, this.framework(), exported).exported);
-            }
-            return followed.get(key) === true;
-        });
-        this.problems = [...this.bindings.problems];
+        super(parsed, file, readModule, VITEST, TEST_MEMBERS);
         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.
             for (const match of parsed.source.text.matchAll(/(\/\/|\*)\s*@module-tag\s+([\w\-/]+)\b/g)) {
@@ -302,19 +132,21 @@ export class VitestAdapter {
             }
         }
     }
+    isAliasLink(kind, link) {
+        return MODIFIERS[kind].has(link.name) || TABLES.has(link.name) || CONDITIONS.has(link.name);
+    }
     classify(call, context) {
         return (this.benchCall(call, context) ??
             this.hookCall(call, context) ??
             this.contextSkip(call, context) ??
             this.chainCall(call, context));
     }
-    testFunction(expression, scopes, returnsOf) {
-        return this.aliasOf(expression, { scopes, inBody: false, returnsOf });
-    }
     /** A call to `bench` imported from Vitest 5, which is undefined there, so the call throws. */
     benchCall(call, context) {
         const base = readChain(call.callee)?.base;
-        if (base?.type !== 'Identifier' || !this.bindings.benches.has(base.name))
+        if (base?.type !== 'Identifier' || this.bindings.members.get(base.name) !== 'bench')
+            return null;
+        if (!atLeast(this.file.version, 5, 0))
             return null;
         const declaration = this.file.values.declarationOf(base.name, context.scopes);
         if (declaration === null || !this.bindings.declarations.has(declaration))
@@ -358,168 +190,6 @@ export class VitestAdapter {
         // Which of its parts the chain means is not known, so it declares a plain test or describe.
         return refused(call, refusal, context, () => this.declaration(call, kind, [], context));
     }
-    /**
-     * The function a chain calls and the links after it, or null when it isn't one of Vitest's. An import that can't be
-     * followed is reported only outside test and hook bodies, where a call can declare tests.
-     */
-    resolve(chain, args, lookup) {
-        const start = this.start(chain, args, lookup);
-        if (!start)
-            return null;
-        let kind = start.kind;
-        let links = [...(start.modifiers ?? []), ...chain.links.slice(start.index)];
-        // A test object derived inline, as in `test.extend({ ... }).skip(...)`.
-        links = links.slice(links.findLastIndex((link) => DERIVATIONS.has(link.name) && link.args !== null) + 1);
-        // Vitest's test object also carries `describe` and `suite`, and they carry `test` and `it`.
-        while (links.length > 0 && KINDS.has(links[0].name) && !links[0].args) {
-            kind = KINDS.get(links[0].name);
-            links = links.slice(1);
-        }
-        return { kind, links };
-    }
-    start(chain, args, lookup) {
-        const { base, links } = chain;
-        const { scopes, inBody } = lookup;
-        if (base.type === 'CallExpression') {
-            const returned = this.returned(base, links, args, lookup);
-            return returned && { kind: returned.kind, index: 0, modifiers: returned.links };
-        }
-        if (base.type !== 'Identifier')
-            return null;
-        // A name the file doesn't declare is one of Vitest's globals; a local variable or parameter with the same name,
-        // such as `(test) => test.result()`, is not Vitest's.
-        const declaration = this.file.values.declarationOf(base.name, scopes);
-        if (declaration === null) {
-            const global = KINDS.get(base.name);
-            if (global)
-                this.usesGlobals = true;
-            return global ? { kind: global, index: 0 } : null;
-        }
-        // A parameter's declaration is its function: `describe('market orders', (test) => { test(...) })`.
-        if (this.suiteParameters.get(declaration) === base.name)
-            return { kind: 'test', index: 0 };
-        const followed = this.imports.get(base.name)?.node === declaration &&
-            this.worthFollowing(base.name, links, args) &&
-            this.follow(base.name, !inBody && mayDeclareTests(base.name, links));
-        if (!followed && !this.bindings.declarations.has(declaration)) {
-            const alias = declaration.type === 'VariableDeclarator' ? this.alias(declaration, lookup) : null;
-            if (alias)
-                return { kind: alias.kind, index: 0, modifiers: alias.links };
-            return this.assumeLocal(declaration, base.name, links, args)
-                ? { kind: KINDS.get(base.name) ?? 'test', index: 0 }
-                : null;
-        }
-        if (this.bindings.namespaces.has(base.name)) {
-            const kind = KINDS.get(links.at(0)?.name ?? '');
-            return kind ? { kind, index: 1 } : null;
-        }
-        const kind = this.bindings.kinds.get(base.name);
-        return kind ? { kind, index: 0 } : null;
-    }
-    /** The function and modifiers a variable holds, as in `const skipOnCi = test.skipIf(isCI)`. */
-    alias(declarator, lookup) {
-        let alias = this.aliases.get(declarator);
-        if (alias === undefined) {
-            // Set first, so a variable defined through itself ends the lookup.
-            this.aliases.set(declarator, null);
-            alias = declarator.init ? this.aliasOf(declarator.init, lookup) : null;
-            this.aliases.set(declarator, alias);
-        }
-        return alias;
-    }
-    aliasOf(expression, lookup) {
-        const node = unwrap(expression);
-        if (node.type === 'ConditionalExpression') {
-            // `isCI ? describe.concurrent : describe`: only the modifiers both branches have apply.
-            return shared(this.aliasOf(node.consequent, lookup), this.aliasOf(node.alternate, lookup));
-        }
-        const chain = readChain(node);
-        const resolved = chain ? this.resolve(chain, [], lookup) : null;
-        const allowed = (link) => resolved !== null &&
-            (MODIFIERS[resolved.kind].has(link.name) || TABLES.has(link.name) || CONDITIONS.has(link.name));
-        return resolved?.links.every(allowed) ? resolved : null;
-    }
-    /**
-     * The function a call returns, as `conditionalTest({ min: 22 })` returns `it` or `it.skip`: what all the values the
-     * function returns have in common, as for a variable chosen by a condition. When the function can't be found, a call
-     * named like a test object is read as one on trust, with a warning; see `returnedTestObject`.
-     */
-    returned(call, links, args, lookup) {
-        const callee = unwrap(call.callee);
-        if (callee.type !== 'Identifier')
-            return null;
-        const returns = lookup.returnsOf(callee.name, lookup.scopes);
-        if (returns)
-            return returnedFunction(returns, shared);
-        if (!isTestName(callee.name) || !this.looksLikeTest(links, args))
-            return null;
-        if (!this.assumed.has(callee.name)) {
-            this.assumed.add(callee.name);
-            this.problems.push(returnedTestObject(this.file, call));
-        }
-        return { kind: KINDS.get(callee.name) ?? 'test', links: [] };
-    }
-    /** Whether a local variable is read as a test object it could be; see `localTestObject`. */
-    assumeLocal(declaration, name, links, args) {
-        if (declaration.type !== 'VariableDeclarator' || !mayHoldTestObject(declaration) || !isTestName(name))
-            return false;
-        if (!this.looksLikeTest(links, args))
-            return false;
-        if (!this.assumed.has(declaration)) {
-            this.assumed.add(declaration);
-            this.problems.push(localTestObject(this.file, name, declaration));
-        }
-        return true;
-    }
-    looksLikeTest(links, args) {
-        return links.length === 0 ? looksLikeDeclaration(args) : TEST_MEMBERS.has(links[0].name);
-    }
-    /**
-     * Whether a call through an imported name is worth following to the module: shaped like a test, or any call with a
-     * title and a body through a name that reads like a test function, as `it.effect('title', fn)` on a test object that
-     * a package extends.
-     */
-    worthFollowing(name, links, args) {
-        return this.looksLikeTest(links, args) || (isTestName(name) && looksLikeDeclaration(args));
-    }
-    /** 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, this.framework());
-            this.followed.set(name, result);
-            if (result.exported) {
-                this.bindings.kinds.set(name, KINDS.get(imported.imported) ?? 'test');
-                this.bindings.declarations.add(imported.node);
-            }
-        }
-        if (report && result.problem && !this.reported.has(name)) {
-            this.reported.add(name);
-            this.problems.push(result.problem);
-        }
-        return result.exported;
-    }
-    /** Hooks called directly, such as `beforeEach(...)` imported from Vitest or used as a global. */
-    hookCall(call, context) {
-        const callee = unwrap(call.callee);
-        if (callee.type !== 'Identifier')
-            return null;
-        const declaration = this.file.values.declarationOf(callee.name, context.scopes);
-        const hook = declaration === null
-            ? isHook(callee.name) && callee.name
-            : this.bindings.declarations.has(declaration) && this.bindings.hooks.get(callee.name);
-        return hook ? this.hook(call, hook, context) : null;
-    }
     hook(call, name, context) {
         const fn = hookFunction(this.file, context.scopes, call.arguments);
         const index = HOOKS.get(name);
@@ -695,6 +365,7 @@ export class VitestAdapter {
             hashed: fn ?? namedFunction(this.file, context.scopes, body),
             isParameterized: table !== null,
             caseCount: table ? this.caseCount(call, table, context, problems) : null,
+            cases: table ? this.tableCases(table, title, context) : null,
             problems,
         };
         let declared;
@@ -887,19 +558,43 @@ export class VitestAdapter {
         }
         return count;
     }
-    arrayLength(node, context) {
-        if (node === undefined || node.type === 'SpreadElement')
-            return null;
-        const resolved = this.file.values.resolve(node, context.scopes);
-        if (resolved.ok && Array.isArray(resolved.value))
-            return resolved.value.length;
-        const expression = unwrap(node);
-        // The cases may hold values that can't be worked out, such as functions, while the list itself is written out.
-        if (expression.type === 'ArrayExpression' &&
-            expression.elements.every((element) => element?.type !== 'SpreadElement')) {
-            return expression.elements.length;
+    /**
+     * The cases of a table whose values the scan can work out, as Vitest passes them: `.each` spreads a case that is an
+     * array into the callback's arguments when every case is one, and `.for` passes each case whole. A tagged template
+     * gives one object per row, keyed by the names in its first line.
+     */
+    tableCases(table, title, context) {
+        let cases;
+        if (table.template) {
+            const values = table.template.expressions.map((item) => this.file.values.resolve(item, context.scopes));
+            if (!values.every((item) => item.ok))
+                return null;
+            const header = templateHeader(table.template);
+            // Without values, Vitest passes the template's strings as the table.
+            cases =
+                values.length === 0
+                    ? table.template.quasis.map((quasi) => quasi.value.cooked ?? undefined)
+                    : Array.from({ length: Math.floor(values.length / header.length) }, (_, row) => Object.fromEntries(header.map((name, column) => [name, values[row * header.length + column].value])));
         }
-        return null;
+        else {
+            const first = table.args.at(0);
+            const resolved = first && first.type !== 'SpreadElement' ? this.file.values.resolve(first, context.scopes) : null;
+            if (!resolved?.ok || !Array.isArray(resolved.value))
+                return null;
+            cases = resolved.value;
+        }
+        const caseTitle = (items, index) => title.isDynamic ? null : vitestCaseTitle(title.text, items, index, this.file.version);
+        if (table.name === 'for') {
+            return cases.map((item, index) => ({
+                title: caseTitle(item === null || item === undefined ? [] : Array.isArray(item) ? item : [item], index),
+                args: [item],
+            }));
+        }
+        const arraysOnly = cases.every((item) => Array.isArray(item));
+        return cases.map((item, index) => {
+            const items = Array.isArray(item) ? item : [item];
+            return { title: caseTitle(items, index), args: arraysOnly ? items : [item] };
+        });
     }
     tagsUsed(node) {
         if (this.warnedAboutTags)
@@ -908,13 +603,24 @@ export class VitestAdapter {
         this.problems.push(problem('config-may-change-state', node, "The file uses Vitest tags, and tags defined in the Vitest config can skip tests or change how they run; the scan can't work out the config's tags."));
     }
 }
-/** Rows in a tagged-template table such as ``each`a | b ${1} | ${2}` ``: values divided by header columns. */
+/**
+ * The column names of a tagged-template table such as ``each`side | qty ${'buy'} | ${100}` ``, as Vitest's
+ * `formatTemplateString` reads them: the text of the template with its spaces taken out, its first line split at `|`.
+ * Outer pipes, as in `| side | qty |`, give empty names too.
+ */
+function templateHeader(template) {
+    // A string with an invalid escape, as in `\xZZ`, has no cooked value, which joins as nothing.
+    const strings = template.quasis.map((quasi) => quasi.value.cooked ?? '');
+    return strings.join('').trim().replace(/ /g, '').split('\n')[0].split('|');
+}
+/**
+ * Rows of a tagged-template table: as many as the values fill, an incomplete last row left out, as Vitest does. A
+ * template without values isn't split, so its text is the one case.
+ */
 function templateRows(template) {
-    const header = (template.quasis[0].value.cooked ?? template.quasis[0].value.raw).trim().split('\n')[0];
-    const columns = header.split('|').filter((column) => column.trim() !== '').length;
-    if (columns === 0 || template.expressions.length % columns !== 0)
-        return null;
-    return template.expressions.length / columns;
+    if (template.expressions.length === 0)
+        return 1;
+    return Math.floor(template.expressions.length / templateHeader(template).length);
 }
 function isMetaValue(value) {
     return value !== undefined;

package/dist/imported-values.d.ts

@@ -0,0 +1,22 @@
+import type { ModuleReader } from './model.ts';
+import { type ImportReader } from './values.ts';
+/**
+ * Works out the values project modules export, for the files of one scan: each module is parsed once and each of its
+ * exports worked out once, however many test files import it. Installed packages are never read, since the reader
+ * only gives project files.
+ */
+export declare class ExportedValues {
+    private readonly modules;
+    private readonly done;
+    /** Results of the current lookup, also those that `done` can't keep, so that each module is read once in it. */
+    private readonly current;
+    private readonly pending;
+    /** How many times a lookup was cut short by a cycle or the depth limit. */
+    private cutShort;
+    /** What a file that reads its imports with `readModule` gets for `import { name } from source`. */
+    reader(readModule: ModuleReader | null): ImportReader | null;
+    /** What `module` exports under `name`; null when it doesn't export it. */
+    private exported;
+    private read;
+    private open;
+}