test-inventory 0.7.0 → 0.9.0

package/dist/frameworks/test-functions.js

@@ -0,0 +1,534 @@
+import { propertyKey, propertyName, unwrap } from "../ast.js";
+import { bindingNames } from "../values.js";
+import { allDeclarators, bindAll, exportName, followImport, followModule, moduleImports, ModuleFunctions, ownExport, requiredModule, topLevelDeclarators, } from "./bindings.js";
+import { boundMembers, isTestName, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, problem, readChain, returnedFunction, returnedTestObject, } 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. */
+export 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) };
+}
+function links(names) {
+    return names.map((name) => ({ name, args: null, template: null }));
+}
+const TEST = { kind: 'test', links: [] };
+/** The names a file binds to the framework's test functions, hooks, other exports and module. */
+export class SuiteBindings {
+    starts = new Map();
+    hooks = new Map();
+    namespaces = new Set();
+    /** Other names imported from the framework, by their exported name, such as Vitest's `bench` or Jest's `jest`. */
+    members = new Map();
+    /** The import specifiers and declarators that bind those names, to tell them from local names that shadow them. */
+    declarations = new Set();
+    problems = [];
+    dialect;
+    /** 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;
+    program;
+    /** Names the module declares or imports at its top level, which hide the framework's globals. */
+    declared;
+    /** Whether the module is one a scanned file imports from, where no walk reads its globals and chains. */
+    isFollowed;
+    constructor(program, dialect, follow, isFollowed = false) {
+        this.dialect = dialect;
+        this.program = program;
+        this.isFollowed = isFollowed;
+        this.declared = topLevelNames(program);
+        this.imported = moduleImports(program, (source) => isOwnModule(dialect, source) || dialect.mismatched.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 (dialect.mismatched.has(source)) {
+                this.problems.push(problem('framework-mismatch', statement, `The file imports '${source}', but the scan is for ${dialect.name}.`));
+            }
+            if (!isOwnModule(dialect, source))
+                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') {
+                    if (dialect.defaultImport === null)
+                        this.bindModule(specifier.local.name);
+                    else
+                        this.problems.push(problem('invalid-import', specifier, dialect.defaultImport));
+                }
+                else {
+                    this.bindMember(exportName(specifier.imported), specifier.local.name);
+                }
+            }
+        }
+        const declarators = allDeclarators(program);
+        if (dialect.required !== null) {
+            for (const declarator of declarators) {
+                if (declarator.init && isOwnModule(dialect, requiredModule(declarator.init))) {
+                    this.problems.push(problem('invalid-import', declarator, dialect.required));
+                }
+            }
+        }
+        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.starts.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.boundStart(node)?.kind === 'test' ||
+                this.importsTestObject(name) ||
+                (followsCalls && this.holdsTestObject(name)));
+        }
+        if (node.type === 'MemberExpression')
+            return this.boundStart(node)?.kind === 'test';
+        // `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' &&
+            this.dialect.derivations.has(propertyName(callee) ?? '') &&
+            this.isTestObject(callee.object, followsCalls));
+    }
+    returnsTestObject(name) {
+        return this.functions.returnsTestObject(name, (expression) => this.isTestObject(expression));
+    }
+    /**
+     * What a name or chain stands for: one bound from the framework, a global the module doesn't hide, a member of the
+     * module, or one of those with modifiers, as `it.skip`; null otherwise.
+     */
+    startOf(expression) {
+        const node = unwrap(expression);
+        if (node.type === 'Identifier') {
+            const global = this.declared.has(node.name) || this.dialect.importOnly ? undefined : this.dialect.starts.get(node.name);
+            return this.starts.get(node.name) ?? global ?? null;
+        }
+        if (node.type !== 'MemberExpression')
+            return null;
+        const name = propertyName(node);
+        if (name === null)
+            return null;
+        if (this.isNamespace(node.object))
+            return this.dialect.starts.get(name) ?? null;
+        const base = this.startOf(node.object);
+        return base && this.dialect.modifiers.has(name) ? { kind: base.kind, links: [...base.links, name] } : null;
+    }
+    /**
+     * What a value stands for when the file binds it: in a scanned file, a name bound from the framework or a member of
+     * its module, as the walk reads globals and chains itself; in a followed module, also globals and chains.
+     */
+    boundStart(expression) {
+        if (this.isFollowed)
+            return this.startOf(expression);
+        const node = unwrap(expression);
+        if (node.type === 'Identifier')
+            return this.starts.get(node.name) ?? null;
+        if (node.type !== 'MemberExpression' || !this.isNamespace(node.object))
+            return null;
+        const name = propertyName(node) ?? '';
+        return this.dialect.starts.get(name) ?? null;
+    }
+    /** A name the module is bound to: its namespace, and its `test` too when the module can be called. */
+    bindModule(name) {
+        this.namespaces.add(name);
+        if (this.dialect.callable)
+            this.starts.set(name, this.dialect.callable);
+    }
+    exportedStart(name) {
+        const own = ownExport(this.program, name);
+        if (own?.kind === 'default')
+            return this.startOf(own.value);
+        const local = own?.kind === 'specifier' ? own.local : name;
+        return this.starts.get(local) ?? null;
+    }
+    holdsTestObject(name) {
+        return this.functions.holdsTestObject(name, (expression) => this.isTestObject(expression));
+    }
+    reexports(source, imported, exported) {
+        if (!isOwnModule(this.dialect, source))
+            return this.follow(source, imported, exported);
+        return exported === 'test object' && this.dialect.starts.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);
+    }
+    /** Whether an expression is the framework's module: a namespace import, or the module itself. */
+    isNamespace(expression) {
+        const node = unwrap(expression);
+        return (node.type === 'Identifier' && this.namespaces.has(node.name)) || this.dialect.isModule(node);
+    }
+    bindMember(imported, local) {
+        const start = this.dialect.starts.get(imported);
+        const hook = this.dialect.hooks.get(imported);
+        if (start)
+            this.starts.set(local, start);
+        else if (hook)
+            this.hooks.set(local, hook);
+        else
+            this.members.set(local, imported);
+    }
+    bind(declarator) {
+        const { id, init } = declarator;
+        if (!init)
+            return false;
+        if (id.type === 'Identifier' && this.isTestObject(init, false)) {
+            // `const later = xit` or `= globals.xit` keeps the skip that `xit` stands for.
+            this.starts.set(id.name, this.boundStart(init) ?? TEST);
+            return true;
+        }
+        if (!this.dialect.isModule(init))
+            return false;
+        if (id.type === 'Identifier') {
+            this.bindModule(id.name);
+            return true;
+        }
+        if (id.type !== 'ObjectPattern')
+            return false;
+        // `const { it, describe } = import.meta.vitest`, or `= require('@jest/globals')`.
+        for (const property of id.properties) {
+            if (property.type === 'RestElement' || property.value.type !== 'Identifier')
+                continue;
+            const key = propertyKey(property);
+            if (key !== null)
+                this.bindMember(key, property.value.name);
+        }
+        return true;
+    }
+}
+/** Whether a module is the framework's own, or one it reads as its own. */
+function isOwnModule(dialect, source) {
+    return source !== null && (source === dialect.source || (dialect.aliases?.has(source) ?? false));
+}
+/**
+ * What Vitest's and Jest's adapters share: how a call's chain is followed to the test or describe function it starts
+ * from, through imports, variables, helper functions and globals.
+ */
+export class SuiteAdapter {
+    problems;
+    fileTags = [];
+    fileTagSpans = [];
+    usesGlobals = false;
+    file;
+    bindings;
+    dialect;
+    /** Describe callbacks and the name of their first parameter, which Vitest calls with its `test`. */
+    suiteParameters = new Map();
+    readModule;
+    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();
+    /** First members that show a name imported from a local file is used as the framework's `test`. */
+    testMembers;
+    constructor(parsed, file, readModule, dialect, testMembers) {
+        this.file = file;
+        this.readModule = readModule;
+        this.dialect = dialect;
+        this.testMembers = new Set([...testMembers, ...dialect.starts.keys()]);
+        // 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 SuiteBindings(parsed.program, dialect, (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];
+        this.imports = moduleImports(parsed.program, (source) => isOwnModule(dialect, source) || dialect.mismatched.has(source));
+    }
+    testFunction(expression, scopes, returnsOf) {
+        return this.aliasOf(expression, { scopes, inBody: false, returnsOf });
+    }
+    /**
+     * The function a chain calls and the links after it, or null when it isn't the framework'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) => this.dialect.derivations.has(link.name) && link.args !== null) + 1);
+        // Vitest's test object also carries `describe` and `suite`, and they carry `test` and `it`.
+        while (this.dialect.carriesKinds && links.length > 0 && !links[0].args) {
+            const carried = this.dialect.starts.get(links[0].name);
+            if (!carried)
+                break;
+            kind = carried.kind;
+            links = links.slice(1);
+        }
+        return { kind, links };
+    }
+    start(chain, args, lookup) {
+        const { base, links: chainLinks } = chain;
+        const { scopes, inBody } = lookup;
+        // `require('@jest/globals').test(...)`: the module itself, called in place.
+        if (base.type === 'CallExpression' && this.dialect.isModule(base))
+            return this.member(chainLinks);
+        if (base.type === 'CallExpression') {
+            const returned = this.returned(base, chainLinks, 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 the framework's globals; a local variable or parameter with the same
+        // name, such as `(test) => test.result()`, is not the framework's.
+        const declaration = this.file.values.declarationOf(base.name, scopes);
+        if (declaration === null) {
+            const global = this.dialect.importOnly ? undefined : this.dialect.starts.get(base.name);
+            if (!global)
+                return null;
+            this.usesGlobals = true;
+            return { kind: global.kind, index: 0, modifiers: links(global.links) };
+        }
+        // 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, chainLinks, args) &&
+            this.follow(base.name, !inBody && mayDeclareTests(base.name, chainLinks));
+        if (!followed && !this.bindings.declarations.has(declaration)) {
+            const alias = declaration.type === 'VariableDeclarator' ? this.alias(declaration, base.name, lookup) : null;
+            if (alias)
+                return { kind: alias.kind, index: 0, modifiers: alias.links };
+            return this.assumeLocal(declaration, base.name, chainLinks, args)
+                ? { kind: this.dialect.starts.get(base.name)?.kind ?? 'test', index: 0 }
+                : null;
+        }
+        if (this.bindings.namespaces.has(base.name))
+            return this.member(chainLinks);
+        const start = this.bindings.starts.get(base.name);
+        return start ? { kind: start.kind, index: 0, modifiers: links(start.links) } : null;
+    }
+    /**
+     * What a chain on the framework's module starts with: the member it names, or for a module that can be called, as
+     * `node:test`'s, the module itself, as in `test.skip(...)`.
+     */
+    member(chainLinks) {
+        const start = this.dialect.starts.get(chainLinks.at(0)?.name ?? '');
+        if (start)
+            return { kind: start.kind, index: 1, modifiers: links(start.links) };
+        const { callable } = this.dialect;
+        // The module's other members, as `test.mock.fn()`, are not tests; one it doesn't have is refused as a chain.
+        if (!callable || this.dialect.others?.has(chainLinks.at(0)?.name ?? ''))
+            return null;
+        return { kind: callable.kind, index: 0, modifiers: links(callable.links) };
+    }
+    /**
+     * The member a name is destructured from a test or describe function as, with that function's kind and the
+     * expression it is taken from: `each`, `test` and `test` in `const { each } = test`; null for any other name.
+     */
+    destructuredMember(name, lookup) {
+        const declaration = this.file.values.declarationOf(name, lookup.scopes);
+        if (declaration?.type !== 'VariableDeclarator')
+            return null;
+        const member = boundMembers(declaration.id, name)?.at(-1);
+        if (member === undefined)
+            return null;
+        const alias = this.alias(declaration, name, lookup);
+        // A variable holds a test function only through its value, so there is one.
+        return alias && { kind: alias.kind, member, from: declaration.init };
+    }
+    /**
+     * The function and modifiers a variable holds, as in `const skipOnCi = test.skipIf(isCI)`, with the member `name`
+     * takes when it is destructured, as in `const { beforeEach } = test`. The members Vitest reads through `this`, such as
+     * `each` and `skipIf`, return a test function only when called, so their calls are never read through a variable.
+     */
+    alias(declarator, name, lookup) {
+        const destructured = boundMembers(declarator.id, name);
+        if (!destructured)
+            return null;
+        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 && { kind: alias.kind, links: [...alias.links, ...links(destructured)] };
+    }
+    aliasOf(expression, lookup) {
+        const functions = this.choices(expression, lookup)?.functions ?? [];
+        if (functions.length === 0)
+            return null;
+        // Only the modifiers every choice has apply.
+        return functions.slice(1).reduce((common, item) => shared(common, item), functions[0]);
+    }
+    /**
+     * The test functions a value may hold, and whether it may also hold something else, as `process.env.CI` may. A test
+     * function is never falsy, so `test.skip || test` and `test.skip ?? test` hold `test.skip`, while
+     * `process.env.CI && test.skip || test` may hold either. Both branches of `?:` have to be test functions.
+     */
+    choices(expression, lookup) {
+        const node = unwrap(expression);
+        if (node.type === 'ConditionalExpression') {
+            const [yes, no] = [this.choices(node.consequent, lookup), this.choices(node.alternate, lookup)];
+            if (!yes || !no)
+                return null;
+            return { functions: [...yes.functions, ...no.functions], mayBeOther: yes.mayBeOther || no.mayBeOther };
+        }
+        if (node.type === 'LogicalExpression') {
+            const [left, right] = [this.choices(node.left, lookup), this.choices(node.right, lookup)];
+            const isFunction = left !== null && !left.mayBeOther;
+            if (node.operator === '&&')
+                return isFunction ? right : { functions: right?.functions ?? [], mayBeOther: true };
+            if (isFunction)
+                return left;
+            return {
+                functions: [...(left?.functions ?? []), ...(right?.functions ?? [])],
+                mayBeOther: right?.mayBeOther ?? true,
+            };
+        }
+        const chain = readChain(node);
+        const resolved = chain ? this.resolve(chain, [], lookup) : null;
+        const isAlias = resolved?.links.every((link) => this.isAliasLink(resolved.kind, link));
+        return resolved && isAlias ? { functions: [resolved], mayBeOther: false } : 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, chainLinks, 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(chainLinks, args))
+            return null;
+        if (!this.assumed.has(callee.name)) {
+            this.assumed.add(callee.name);
+            this.problems.push(returnedTestObject(this.file, call));
+        }
+        return { kind: this.dialect.starts.get(callee.name)?.kind ?? 'test', links: [] };
+    }
+    /** Whether a local variable is read as a test object it could be; see `localTestObject`. */
+    assumeLocal(declaration, name, chainLinks, args) {
+        if (declaration.type !== 'VariableDeclarator' || !mayHoldTestObject(declaration) || !isTestName(name))
+            return false;
+        if (!this.looksLikeTest(chainLinks, args))
+            return false;
+        if (!this.assumed.has(declaration)) {
+            this.assumed.add(declaration);
+            this.problems.push(localTestObject(this.file, name, declaration));
+        }
+        return true;
+    }
+    looksLikeTest(chainLinks, args) {
+        return chainLinks.length === 0 ? looksLikeDeclaration(args) : this.testMembers.has(chainLinks[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, chainLinks, args) {
+        return this.looksLikeTest(chainLinks, args) || (isTestName(name) && looksLikeDeclaration(args));
+    }
+    /** The framework as followed modules are read. */
+    framework() {
+        const { dialect } = this;
+        return {
+            name: dialect.name,
+            isSource: (source) => isOwnModule(dialect, source),
+            testObjects: (program, follow) => new SuiteBindings(program, dialect, follow, true),
+        };
+    }
+    /** 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) {
+                const start = result.start ?? this.dialect.starts.get(imported.imported) ?? TEST;
+                this.bindings.starts.set(name, start);
+                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 the framework or used as a global. */
+    hookCall(call, context) {
+        const callee = unwrap(call.callee);
+        // A hook on the module, as `test.beforeEach()` on `node:test`'s default export.
+        if (callee.type === 'MemberExpression' && this.bindings.isNamespace(callee.object)) {
+            const hook = this.dialect.hooks.get(propertyName(callee) ?? '');
+            return hook ? this.hook(call, hook, context) : null;
+        }
+        if (callee.type !== 'Identifier')
+            return null;
+        const declaration = this.file.values.declarationOf(callee.name, context.scopes);
+        const hook = declaration === null
+            ? this.dialect.hooks.get(callee.name)
+            : this.bindings.declarations.has(declaration) && this.bindings.hooks.get(callee.name);
+        return hook ? this.hook(call, hook, context) : null;
+    }
+    /** The number of items of a table, also when not all its values are known; see `Values.lengthOf`. */
+    arrayLength(node, context) {
+        if (node === undefined || node.type === 'SpreadElement')
+            return null;
+        return this.file.values.lengthOf(node, context.scopes);
+    }
+}
+/** The names a module declares or imports at its top level, destructured ones too. */
+function topLevelNames(program) {
+    const names = new Set();
+    for (const declarator of topLevelDeclarators(program))
+        for (const name of bindingNames(declarator.id))
+            names.add(name);
+    for (const statement of program.body) {
+        const declaration = statement.type === 'ExportNamedDeclaration' ? statement.declaration : statement;
+        if ((declaration?.type === 'FunctionDeclaration' || declaration?.type === 'ClassDeclaration') && declaration.id) {
+            names.add(declaration.id.name);
+        }
+        if (statement.type === 'ImportDeclaration')
+            for (const specifier of statement.specifiers)
+                names.add(specifier.local.name);
+    }
+    return names;
+}

package/dist/frameworks/vitest.d.ts

@@ -1,71 +1,26 @@
-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);
+    /** The length a value in a case title is shortened to, as the config sets it. */
+    private readonly titleTruncate;
+    constructor(parsed: ParsedFile, file: FileContext, readModule: ModuleReader | null, titleTruncate?: number);
+    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.
+     * A call of a member Vitest calls on its test or describe function, destructured from it, as `each` in
+     * `const { each } = test`: the member reads the function it is called on, which a plain call doesn't give it, so the
+     * call throws while the file loads. Which members do that depends on the version.
      */
-    private resolve;
-    private start;
-    /**
-     * The function and modifiers a variable holds, as in `const skipOnCi = test.skipIf(isCI)`, with the member `name`
-     * takes when it is destructured, as in `const { beforeEach } = test`. The members Vitest reads through `this`, such as
-     * `each` and `skipIf`, return a test function only when called, so their calls are never read through a variable.
-     */
-    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;
+    private unboundCall;
+    private chainCall;
+    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
@@ -89,7 +44,5 @@ export declare class VitestAdapter implements Adapter {
      * gives one object per row, keyed by the names in its first line.
      */
     private tableCases;
-    private arrayLength;
     private tagsUsed;
 }
-export {};