test-inventory 0.8.0 → 0.9.0

package/dist/frameworks/mocha.js

@@ -0,0 +1,306 @@
+import { isFunctionNode, propertyName, unwrap } from "../ast.js";
+import { snippet } from "../source.js";
+import { requiredModule } from "./bindings.js";
+import { atLeast, hookFunction, namedFunction, problem, readChain, readCount, readTitle, refused, text, } from "./common.js";
+import { SuiteAdapter } from "./test-functions.js";
+const SOURCE = 'mocha';
+const MISMATCHED = new Set(['@playwright/test', 'playwright/test', 'vitest', '@jest/globals']);
+const MODIFIERS = new Set(['only', 'skip']);
+/** Which of `test` and `describe` each global is, and the modifier it carries, by interface. */
+const STARTS = {
+    bdd: [
+        ['describe', 'describe', []],
+        ['context', 'describe', []],
+        ['xdescribe', 'describe', ['skip']],
+        ['xcontext', 'describe', ['skip']],
+        ['it', 'test', []],
+        ['specify', 'test', []],
+        ['xit', 'test', ['skip']],
+        ['xspecify', 'test', ['skip']],
+    ],
+    tdd: [
+        ['suite', 'describe', []],
+        ['test', 'test', []],
+    ],
+};
+const HOOKS = {
+    bdd: [
+        ['before', 'beforeAll'],
+        ['after', 'afterAll'],
+        ['beforeEach', 'beforeEach'],
+        ['afterEach', 'afterEach'],
+    ],
+    tdd: [
+        ['suiteSetup', 'beforeAll'],
+        ['suiteTeardown', 'afterAll'],
+        ['setup', 'beforeEach'],
+        ['teardown', 'afterEach'],
+    ],
+};
+export function dialect(ui) {
+    return {
+        name: 'Mocha',
+        source: SOURCE,
+        mismatched: MISMATCHED,
+        starts: new Map(STARTS[ui].map(([name, kind, links]) => [name, { kind, links }])),
+        hooks: new Map(HOOKS[ui]),
+        derivations: new Set(),
+        modifiers: MODIFIERS,
+        carriesKinds: false,
+        isModule: (expression) => requiredModule(expression) === SOURCE,
+        // `import mocha from 'mocha'` gives the module's exports, `describe` and `it` among them.
+        defaultImport: null,
+        required: null,
+    };
+}
+/** Mocha's `ms` strings for a timeout, as `'2s'`; a bare number is milliseconds. */
+const DURATION = /^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d|w|y)?$/;
+const UNITS = {
+    ms: 1,
+    s: 1000,
+    m: 60_000,
+    h: 3_600_000,
+    d: 86_400_000,
+    w: 604_800_000,
+    y: 31_557_600_000,
+};
+export class MochaAdapter extends SuiteAdapter {
+    /**
+     * Whether `this.timeout()` and `this.retries()` set the tests' settings, as in Mocha. Cypress reads neither, and its
+     * `retries()` throws.
+     */
+    readsContextSettings = true;
+    /** What the runner does with a call it refuses while it loads the file, as the end of a sentence. */
+    refusedEffect = 'Mocha stops before it runs any test';
+    /** Whether a number after a test's function is a retry count, as WebdriverIO reads it. */
+    trailingRetries = false;
+    constructor(parsed, file, readModule, ui = 'bdd', runner = dialect(ui)) {
+        super(parsed, file, readModule, runner, MODIFIERS);
+    }
+    /** A declaration's function, and the options written before it; Mocha takes none. */
+    splitArguments(args) {
+        return { body: args.at(1), options: null };
+    }
+    classify(call, context) {
+        return (this.contextCall(call, context) ??
+            this.chainedSetting(call, context) ??
+            this.hookCall(call, context) ??
+            this.chainCall(call, context));
+    }
+    isAliasLink(_kind, link) {
+        return MODIFIERS.has(link.name);
+    }
+    hook(call, name, context) {
+        const fn = hookFunction(this.file, context.scopes, call.arguments);
+        // Mocha refuses `this.skip()` in an `after` hook, so the tests stay as they ran.
+        const testContext = name === 'afterAll' ? null : ownThis(fn);
+        return { kind: 'hook', name, fn, testContext, fixtures: [], takesAllFixtures: false };
+    }
+    /**
+     * `this.timeout(n)`, `this.retries(n)` and `this.skip()` where `this` is Mocha's context: in a describe written as a
+     * `function`, they set its tests' timeout and retries; in a test, its own; `this.skip()` in a test or hook skips the
+     * tests it runs for. In a hook, `this.timeout()` sets the hook's own timeout, which no test record holds.
+     */
+    contextCall(call, context) {
+        const callee = unwrap(call.callee);
+        if (callee.type !== 'MemberExpression' || unwrap(callee.object).type !== 'ThisExpression')
+            return null;
+        const name = propertyName(callee);
+        // `this` is Mocha's only directly in the test's, hook's or describe's own function, not in a function inside it.
+        const own = innermostFunction(context.scopes);
+        const inTestOrHook = context.inBody && own !== null && own === context.testContext;
+        const inDescribe = !context.inBody && own !== null && own === context.passedDown;
+        if (!inTestOrHook && !inDescribe)
+            return null;
+        if (name === 'skip') {
+            if (!inTestOrHook)
+                return { kind: 'other' };
+            return {
+                kind: 'modifier',
+                state: 'skip',
+                condition: { applies: 'always', text: null },
+                reason: null,
+                hasDynamicReason: false,
+                problems: [],
+            };
+        }
+        if (name !== 'timeout' && name !== 'retries')
+            return null;
+        if (!this.readsContextSettings) {
+            // In a test or hook, the throw fails that test or hook only, when it runs.
+            if (name === 'timeout' || inTestOrHook)
+                return { kind: 'other' };
+            const source = snippet(text(this.file, call));
+            const message = `${source} throws in ${this.dialect.name}, which takes retries in a describe's config, as describe(title, { retries: 2 }, fn), so ${this.refusedEffect}.`;
+            return { kind: 'invalid', problem: problem('describe-throws', call, message, source) };
+        }
+        const argument = call.arguments.at(0);
+        // Without an argument, `this.timeout()` only reads the timeout.
+        if (!argument || (context.inBody && !context.inTest))
+            return { kind: 'other' };
+        const problems = [];
+        const settings = this.setting(name, argument, context, problems) ?? {};
+        return { kind: 'run', settings, argument: snippet(text(this.file, argument)), problems };
+    }
+    /**
+     * `it(title, fn).timeout(n)` and `.retries(n)`, which Mocha's `it` and `describe` return their test or suite for: the
+     * declaration with the setting. A describe's tests are added before the call, and take its retries when they are
+     * added, so `describe(...).retries(n)` reaches none of them; its timeout reaches them from Mocha 12, which reads it as
+     * each test runs (checked with 10.8.2, 11.7.5 and 12.0.3).
+     */
+    chainedSetting(call, context) {
+        const callee = unwrap(call.callee);
+        if (callee.type !== 'MemberExpression')
+            return null;
+        const name = propertyName(callee);
+        if (name !== 'timeout' && name !== 'retries')
+            return null;
+        if (!this.readsContextSettings && name === 'timeout')
+            return null;
+        const target = unwrap(callee.object);
+        if (target.type !== 'CallExpression')
+            return null;
+        const declared = this.classify(target, context);
+        if (declared?.kind !== 'test' && declared?.kind !== 'describe')
+            return null;
+        if (!this.readsContextSettings) {
+            if (context.inBody)
+                return declared;
+            const source = snippet(text(this.file, callee));
+            const message = `${source}() throws in ${this.dialect.name}, which takes retries in the config before the function, as it(title, { retries: 2 }, fn), so ${this.refusedEffect}.`;
+            return { kind: 'invalid', problem: problem('invalid-chain', call, message, source), declaration: declared };
+        }
+        if (declared.kind === 'describe' && (name === 'retries' || !atLeast(this.file.version, 12, 0)))
+            return declared;
+        const argument = call.arguments.at(0);
+        const settings = argument ? this.setting(name, argument, context, declared.problems) : null;
+        if (settings === null)
+            return declared;
+        return { ...declared, details: { ...declared.details, run: { ...declared.details.run, ...settings } } };
+    }
+    /** A timeout or a retry count from its argument; null, with a warning, when it can't be worked out. */
+    setting(name, argument, context, problems) {
+        const resolved = argument.type === 'SpreadElement' ? null : this.file.values.resolve(argument, context.scopes);
+        const value = resolved?.ok ? durationOf(resolved.value, name) : null;
+        if (value === null) {
+            const source = snippet(text(this.file, argument));
+            const message = `The ${name} ${source} could not be worked out; it is not applied.`;
+            problems.push(problem('unresolved-option', argument, message, source));
+            return null;
+        }
+        return name === 'timeout' ? { timeout: value } : { retry: { count: value, delay: null, condition: null } };
+    }
+    chainCall(call, context) {
+        const chain = readChain(call.callee);
+        const resolved = chain ? this.resolve(chain, call.arguments, context) : null;
+        if (!resolved)
+            return null;
+        const { kind, links } = resolved;
+        const valid = links.length <= 1 && links.every((link) => MODIFIERS.has(link.name) && !link.args && !link.template);
+        if (valid)
+            return this.declaration(call, kind, links, context);
+        const callee = snippet(text(this.file, call.callee));
+        const refusal = problem('invalid-chain', call, `${callee} is not part of ${this.dialect.name}'s API; the call throws, and ${this.refusedEffect}.`, callee);
+        return refused(call, refusal, context, () => this.declaration(call, kind, [], context));
+    }
+    declaration(call, kind, links, context) {
+        const args = call.arguments;
+        if (args.length === 0) {
+            const callee = snippet(text(this.file, call.callee));
+            const message = `${callee}() has no title, so ${this.refusedEffect}.`;
+            return { kind: 'invalid', problem: problem('test-without-body', call, message, callee) };
+        }
+        const flags = new Set(links.map((link) => link.name));
+        const problems = [];
+        const { title, problem: titleProblem } = readTitle(this.file, context.scopes, args[0], {
+            stripTags: false,
+            functionNames: false,
+        });
+        if (titleProblem)
+            problems.push(titleProblem);
+        const { body, options } = this.splitArguments(args);
+        const fn = isFunctionNode(body) ? body : null;
+        const hashed = fn ?? namedFunction(this.file, context.scopes, body);
+        const line = this.file.source.line(call.start);
+        // A test without a function is pending, which Mocha reports as skipped.
+        const isSkipped = flags.has('skip') || (kind === 'test' && body === undefined);
+        const base = {
+            title,
+            states: isSkipped
+                ? [{ state: 'skip', condition: null, reason: null, hasDynamicReason: false, line }]
+                : [],
+            isOnly: flags.has('only'),
+            mode: null,
+            details: { tags: [], annotations: [], locks: [], meta: null, run: {} },
+            fn,
+            hashed,
+            isParameterized: false,
+            caseCount: null,
+            cases: null,
+            problems,
+        };
+        if (kind === 'test') {
+            const test = {
+                kind: 'test',
+                ...base,
+                testContext: ownThis(hashed),
+                fixtures: [],
+                takesAllFixtures: false,
+                usesBench: false,
+            };
+            // WebdriverIO retries the function that many times inside each of Mocha's attempts, so 0 leaves Mocha's retries.
+            // `it.only` and `it.skip` pass Mocha only the title and function, so the count is dropped.
+            const retries = this.trailingRetries && flags.size === 0 && args.length >= 3 ? args.at(-1) : undefined;
+            if (retries && retries.type !== 'SpreadElement') {
+                const option = { node: retries, resolved: this.file.values.resolve(retries, context.scopes) };
+                const count = readCount(this.file, 'retries', option, problems);
+                if (count)
+                    test.details.run = { retry: { count, delay: null, condition: null } };
+            }
+            if (options)
+                this.withOptions?.(test, options, context);
+            return test;
+        }
+        const declared = { kind: 'describe', ...base, isShuffled: false, passesDown: ownThis(hashed) };
+        if (options)
+            this.withOptions?.(declared, options, context);
+        if (body !== undefined || flags.has('skip'))
+            return declared;
+        const callee = snippet(text(this.file, call.callee));
+        const refusal = problem('test-without-body', call, `${callee}() has no function, so ${this.refusedEffect}.`, callee);
+        return refused(call, refusal, context, () => declared);
+    }
+}
+/**
+ * A test's, hook's or describe's function written with `function`, whose `this` is Mocha's context while it runs; null
+ * for an arrow function, whose `this` is whatever is around it.
+ */
+function ownThis(fn) {
+    return fn && fn.type !== 'ArrowFunctionExpression' ? fn : null;
+}
+/** The innermost function around a call that has its own `this`: one not written as an arrow. */
+function innermostFunction(scopes) {
+    return (scopes.findLast((scope) => scope.type === 'FunctionExpression' || scope.type === 'FunctionDeclaration') ?? null);
+}
+/** The largest timeout Mocha keeps; it takes this one and any larger as no timeout, 0. */
+const LONGEST = 2 ** 31 - 1;
+/** A timeout in milliseconds or a retry count as Mocha reads it; null for a value it doesn't take. */
+export function durationOf(value, name) {
+    if (name === 'retries')
+        return typeof value === 'number' && Number.isInteger(value) && value >= 0 ? value : null;
+    let ms = null;
+    if (typeof value === 'number') {
+        ms = value;
+    }
+    else if (typeof value === 'string') {
+        const match = DURATION.exec(value.trim());
+        // An optional group that matched nothing is undefined, though the type says it is a string.
+        if (match)
+            ms = Number(match[1]) * UNITS[match[2] ?? 'ms'];
+    }
+    if (ms === null || Number.isNaN(ms))
+        return null;
+    if (ms <= 0 || ms >= LONGEST)
+        return 0;
+    return Number.isInteger(ms) ? ms : null;
+}

package/dist/frameworks/node.d.ts

@@ -0,0 +1,30 @@
+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';
+import { SuiteAdapter, type Kind } from './test-functions.ts';
+/**
+ * Node.js's test runner, `node:test`. Its functions are imported, never globals; the module itself is `test`. A test
+ * takes `(name, options, fn)`, each part optional, and a test or `test()` called in a test's body is a subtest of it.
+ */
+export declare class NodeAdapter extends SuiteAdapter {
+    readonly nestsTests = true;
+    constructor(parsed: ParsedFile, file: FileContext, readModule: ModuleReader | null);
+    classify(call: CallExpression, context: CallContext): ApiCall | null;
+    protected isAliasLink(_kind: Kind, link: Link): boolean;
+    protected hook(call: CallExpression, name: keyof HookCounts, context: CallContext): ApiCall;
+    /**
+     * `t.skip(reason)` and `t.todo(reason)` on the test's context, which mark the test without stopping it, and
+     * `t.test()`, a subtest.
+     */
+    private contextCall;
+    private chainCall;
+    private declaration;
+    /**
+     * The options object: `skip` and `todo`, each `true` or a reason, `only`, `timeout`, `concurrency`, a number above 1
+     * or `true` running the tests inside in parallel, from Node.js 24.14 and 25.5 `expectFailure`, whose string is its
+     * label from 24.15 and 25.8, and from 24.19 and 26.2 `tags`.
+     */
+    private withOptions;
+}

package/dist/frameworks/node.js

@@ -0,0 +1,268 @@
+import { isFunctionNode, propertyName, unwrap } from "../ast.js";
+import { snippet } from "../source.js";
+import { requiredModule } from "./bindings.js";
+import { hookFunction, namedFunction, problem, readChain, readCount, readOptions, readReason, readStrings, readTitle, refused, text, unresolvedOptions, } from "./common.js";
+import { SuiteAdapter } from "./test-functions.js";
+const MODIFIERS = new Set(['skip', 'todo', 'only', 'expectFailure']);
+const PRECEDENCE = ['skip', 'todo', 'expectedToFail'];
+const TEST = { kind: 'test', links: [] };
+const NODE = {
+    name: 'node:test',
+    source: 'node:test',
+    mismatched: new Set(['@playwright/test', 'playwright/test', 'vitest', '@jest/globals', 'mocha']),
+    starts: new Map([
+        ['test', TEST],
+        ['it', TEST],
+        ['describe', { kind: 'describe', links: [] }],
+        ['suite', { kind: 'describe', links: [] }],
+        // `test`'s own members, which node:test also exports by name.
+        ...['skip', 'todo', 'only', 'expectFailure'].map((name) => [
+            name,
+            { kind: 'test', links: [name] },
+        ]),
+    ]),
+    hooks: new Map([
+        ['before', 'beforeAll'],
+        ['after', 'afterAll'],
+        ['beforeEach', 'beforeEach'],
+        ['afterEach', 'afterEach'],
+    ]),
+    derivations: new Set(),
+    modifiers: MODIFIERS,
+    carriesKinds: false,
+    isModule: (expression) => requiredModule(expression) === 'node:test',
+    defaultImport: null,
+    required: null,
+    callable: TEST,
+    // Every other export of node:test on Node.js 26; the hooks are read as hooks.
+    others: new Set([
+        'after',
+        'afterEach',
+        'assert',
+        'before',
+        'beforeEach',
+        'default',
+        'getTestContext',
+        'mock',
+        'run',
+        'snapshot',
+    ]),
+    importOnly: true,
+};
+/**
+ * Node.js's test runner, `node:test`. Its functions are imported, never globals; the module itself is `test`. A test
+ * takes `(name, options, fn)`, each part optional, and a test or `test()` called in a test's body is a subtest of it.
+ */
+export class NodeAdapter extends SuiteAdapter {
+    nestsTests = true;
+    constructor(parsed, file, readModule) {
+        super(parsed, file, readModule, NODE, []);
+    }
+    classify(call, context) {
+        return this.contextCall(call, context) ?? this.hookCall(call, context) ?? this.chainCall(call, context);
+    }
+    isAliasLink(_kind, link) {
+        return MODIFIERS.has(link.name);
+    }
+    hook(call, name, context) {
+        const fn = hookFunction(this.file, context.scopes, call.arguments);
+        return { kind: 'hook', name, fn, testContext: null, fixtures: [], takesAllFixtures: false };
+    }
+    /**
+     * `t.skip(reason)` and `t.todo(reason)` on the test's context, which mark the test without stopping it, and
+     * `t.test()`, a subtest.
+     */
+    contextCall(call, context) {
+        const callee = unwrap(call.callee);
+        if (callee.type !== 'MemberExpression' || context.testContext === null || !context.inTest)
+            return null;
+        const object = unwrap(callee.object);
+        if (object.type !== 'Identifier' || object.name !== context.testContext)
+            return null;
+        const name = propertyName(callee);
+        if (name === 'test')
+            return this.declaration(call, 'test', [], context);
+        if (name !== 'skip' && name !== 'todo')
+            return null;
+        const reason = readReason(this.file, context.scopes, call.arguments.at(0));
+        return {
+            kind: 'modifier',
+            state: name,
+            condition: { applies: 'always', text: null },
+            reason: reason.reason,
+            hasDynamicReason: reason.isDynamic,
+            problems: reason.problem ? [reason.problem] : [],
+        };
+    }
+    chainCall(call, context) {
+        const chain = readChain(call.callee);
+        const resolved = chain ? this.resolve(chain, call.arguments, context) : null;
+        if (!resolved)
+            return null;
+        const { kind, links } = resolved;
+        const valid = links.length <= 1 &&
+            links.every((link) => MODIFIERS.has(link.name) &&
+                !link.args &&
+                !link.template &&
+                (link.name !== 'expectFailure' || expectsFailure(this.file.version)));
+        if (valid)
+            return this.declaration(call, kind, links, context);
+        const callee = snippet(text(this.file, call.callee));
+        const message = `${callee} is not part of node:test's API; the call throws, and Node.js fails the file and runs none of its tests.`;
+        return refused(call, problem('invalid-chain', call, message, callee), context, () => this.declaration(call, kind, [], context));
+    }
+    declaration(call, kind, links, context) {
+        const { name, options, body } = splitArguments(call.arguments);
+        const problems = [];
+        const fn = isFunctionNode(body) ? body : null;
+        let title = { text: '<anonymous>', withoutTags: '<anonymous>', isDynamic: false };
+        if (name) {
+            const read = readTitle(this.file, context.scopes, name, { stripTags: false, functionNames: false });
+            title = read.title;
+            if (read.problem)
+                problems.push(read.problem);
+        }
+        else if (fn?.id) {
+            // Without a name, Node.js names the test after its function.
+            title = { text: fn.id.name, withoutTags: fn.id.name, isDynamic: false };
+        }
+        const line = this.file.source.line(call.start);
+        const states = links
+            .filter((link) => link.name !== 'only')
+            .map((link) => ({
+            state: link.name === 'expectFailure' ? 'expectedToFail' : link.name,
+            condition: null,
+            reason: null,
+            hasDynamicReason: false,
+            line,
+        }));
+        const base = {
+            title,
+            states,
+            isOnly: links.some((link) => link.name === 'only'),
+            mode: null,
+            details: { tags: [], annotations: [], locks: [], meta: null, run: {} },
+            fn,
+            hashed: fn ?? namedFunction(this.file, context.scopes, body),
+            isParameterized: false,
+            caseCount: null,
+            cases: null,
+            problems,
+        };
+        if (options)
+            this.withOptions(base, options, line, context);
+        // `skip` wins over `todo`, and both over `expectFailure`, however they are written.
+        base.states.sort((a, b) => PRECEDENCE.indexOf(a.state) - PRECEDENCE.indexOf(b.state));
+        if (kind === 'describe')
+            return { kind: 'describe', ...base, isShuffled: false, passesDown: null };
+        return {
+            kind: 'test',
+            ...base,
+            testContext: contextName(fn),
+            fixtures: [],
+            takesAllFixtures: false,
+            usesBench: false,
+        };
+    }
+    /**
+     * The options object: `skip` and `todo`, each `true` or a reason, `only`, `timeout`, `concurrency`, a number above 1
+     * or `true` running the tests inside in parallel, from Node.js 24.14 and 25.5 `expectFailure`, whose string is its
+     * label from 24.15 and 25.8, and from 24.19 and 26.2 `tags`.
+     */
+    withOptions(declared, node, line, context) {
+        const options = readOptions(this.file, context.scopes, node);
+        const { problems } = declared;
+        problems.push(...unresolvedOptions(this.file, options, 'its states, timeout and tags are missing'));
+        const states = [
+            ['skip', 'skip'],
+            ['todo', 'todo'],
+        ];
+        if (expectsFailure(this.file.version))
+            states.push(['expectedToFail', 'expectFailure']);
+        for (const [state, key] of states) {
+            const option = options.values.get(key);
+            if (!option)
+                continue;
+            const setting = stateFrom(this.file, state, option, line, state !== 'expectedToFail' || labelsFailure(this.file.version));
+            if (setting)
+                declared.states.push(setting);
+        }
+        const only = options.values.get('only');
+        if (only?.resolved.ok && only.resolved.value)
+            declared.isOnly = true;
+        const timeout = options.values.get('timeout');
+        if (timeout) {
+            const value = readCount(this.file, 'timeout', timeout, problems);
+            if (value !== null)
+                declared.details.run.timeout = value;
+        }
+        const concurrency = options.values.get('concurrency');
+        if (concurrency?.resolved.ok) {
+            const { value } = concurrency.resolved;
+            declared.mode = value === true || (typeof value === 'number' && value > 1) ? 'parallel' : 'default';
+        }
+        const tags = options.values.get('tags');
+        if (tags && readsTags(this.file.version)) {
+            declared.details.tags.push(...readStrings(this.file, context.scopes, tags).values);
+        }
+    }
+}
+/** Whether a version is at least the given release of its line, or of a later line. */
+function since(version, releases, from) {
+    if (version === null)
+        return true;
+    const [major, minor] = version;
+    return major >= from || (major in releases && minor >= releases[major]);
+}
+/** `expectFailure`: from Node.js 24.14 and 25.5. */
+function expectsFailure(version) {
+    return since(version, { 24: 14, 25: 5 }, 26);
+}
+/** A string `expectFailure` as the failure's label: from 24.15 and 25.8. */
+function labelsFailure(version) {
+    return since(version, { 24: 15, 25: 8 }, 26);
+}
+/** `tags`: from 24.19 and 26.2; Node.js 25 doesn't have them. */
+function readsTags(version) {
+    return since(version, { 24: 19, 26: 2 }, 27);
+}
+/**
+ * A state an option sets: any value but `false` and `undefined` sets it, as Node.js only checks for those two, with a
+ * non-empty string as its reason; a value the scan can't work out sets it under its source text.
+ */
+function stateFrom(file, state, option, line, takesReason) {
+    const source = snippet(text(file, option.node));
+    if (!option.resolved.ok) {
+        return { state, condition: source, reason: null, hasDynamicReason: false, line };
+    }
+    const { value } = option.resolved;
+    if (value === undefined || value === false)
+        return null;
+    const reason = typeof value === 'string' && value !== '' && takesReason ? value : null;
+    return { state, condition: null, reason, hasDynamicReason: false, line };
+}
+/**
+ * The name, options and function of a call, as Node.js reads `test([name][, options][, fn])`: a function first is the
+ * test's function, an object first its options.
+ */
+function splitArguments(args) {
+    const [first, second, third] = args;
+    if (first && isFunctionLike(first))
+        return { name: undefined, options: undefined, body: first };
+    if (first && isObjectLike(first))
+        return { name: undefined, options: first, body: second };
+    if (second && isFunctionLike(second))
+        return { name: first, options: undefined, body: second };
+    return { name: first, options: second, body: third };
+}
+function isFunctionLike(node) {
+    return node.type !== 'SpreadElement' && isFunctionNode(unwrap(node));
+}
+function isObjectLike(node) {
+    return node.type !== 'SpreadElement' && unwrap(node).type === 'ObjectExpression';
+}
+/** The name the test's function gives its context, `t` in `(t) => {}`; null without one. */
+function contextName(fn) {
+    const param = fn?.params.at(0);
+    return param?.type === 'Identifier' ? param.name : null;
+}

package/dist/frameworks/playwright.d.ts

@@ -12,6 +12,7 @@ export declare class PlaywrightAdapter implements Adapter {
     private readonly imports;
     private readonly followed;
     private readonly reported;
+    private readonly refusedRests;
     /** Variables and names of functions read as test objects on trust, each reported once. */
     private readonly assumed;
     private readonly aliases;
@@ -55,6 +56,18 @@ export declare class PlaywrightAdapter implements Adapter {
     /** A chain Playwright refuses; one that starts like a declaration also declares a plain test or describe. */
     private invalid;
     private testCall;
+    /**
+     * Playwright reads which fixtures a function takes from its source, and refuses a rest property among them, as
+     * `({ page, ...fixtures })`, failing the whole run. A nested one, as `({ page: { mouse, ...rest } })`, is allowed.
+     */
+    private checkFixtureArguments;
+    /** The fixture functions of `test.extend({ ... })`, each given as a function or as `[function, options]`. */
+    private checkExtendFixtures;
+    /**
+     * An object of fixtures, written in place or held in a constant, with the objects it spreads; `seen` ends a constant
+     * that spreads itself, which throws at run time.
+     */
+    private checkFixtureObject;
     /** `test.step(title, body)` in a test body; a title that can't be worked out is kept as source text. */
     private step;
     private modifier;