test-inventory 0.1.2 → 0.2.1

package/dist/frameworks/playwright.js

@@ -1,7 +1,7 @@
 import { childNodes, isFunctionNode, propertyKey, propertyName, unwrap } from "../ast.js";
 import { snippet } from "../source.js";
-import { allDeclarators, bindAll, exportName, followImport, moduleImports, requiredModule, } from "./bindings.js";
-import { atLeast, findFunction, isTestName, isTitleLiteral, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, namedFunction, origin, problem, readChain, readCondition, readOptions, readReason, readStrings, readTitle, text, unresolvedOption, unresolvedOptions, } from "./common.js";
+import { allDeclarators, bindAll, exportName, followImport, followModule, moduleImports, requiredModule, } from "./bindings.js";
+import { atLeast, findFunction, isTestName, isTitleLiteral, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, namedFunction, origin, problem, readChain, readCondition, readOptions, readReason, readStrings, readTitle, returnedFunction, returnedTestObject, text, unresolvedOption, unresolvedOptions, } from "./common.js";
 const MISMATCHED_SOURCES = new Set(['vitest', '@jest/globals']);
 // Maps rather than object literals, so names such as `constructor` don't match inherited properties.
 const DESCRIBES = new Map([
@@ -26,6 +26,13 @@ const STATES = new Map([
 const OTHER_MEMBERS = new Set(['use', 'slow', 'setTimeout', 'extend']);
 /** First members that show a name imported from a local file is used as Playwright's `test`. */
 const TEST_MEMBERS = new Set(['describe', 'only', 'skip', 'fixme', 'fail', 'step', ...HOOKS]);
+/** The members of `test` a value chosen at run time holds either way: those both have, if both are the same kind. */
+function sharedMembers(a, b) {
+    if (!a || !b || (a[0] === 'describe') !== (b[0] === 'describe'))
+        return null;
+    const differs = a.findIndex((name, index) => b[index] !== name);
+    return differs === -1 ? a : a.slice(0, differs);
+}
 /** Calls that need a newer Playwright than the oldest supported one. */
 const ADDED_IN = new Map([
     ['fail.only', [1, 49]],
@@ -33,7 +40,11 @@ const ADDED_IN = new Map([
     ['abort', [1, 60]],
 ]);
 function isPlaywrightSource(source) {
-    return (source === '@playwright/test' || source === 'playwright/test' || source.startsWith('@playwright/experimental-ct-'));
+    return (source === '@playwright/test' ||
+        source === 'playwright/test' ||
+        source.startsWith('@playwright/experimental-ct-') ||
+        // Files generated from Gherkin features import Playwright's `test` from playwright-bdd, which extends it.
+        source === 'playwright-bdd');
 }
 /** The names a file binds to Playwright's `test`, its namespace and `mergeTests`. */
 class PlaywrightBindings {
@@ -43,7 +54,12 @@ class PlaywrightBindings {
     /** The import specifiers and declarators that bind those names, to tell them from local names that shadow them. */
     declarations = new Set();
     mismatches = [];
-    constructor(program) {
+    /** Names imported from other modules, which may be test objects there. */
+    imported;
+    follow;
+    constructor(program, follow) {
+        this.imported = moduleImports(program, (source) => isPlaywrightSource(source) || MISMATCHED_SOURCES.has(source));
+        this.follow = follow;
         for (const statement of program.body) {
             if (statement.type !== 'ImportDeclaration' || statement.importKind === 'type')
                 continue;
@@ -77,13 +93,13 @@ class PlaywrightBindings {
         });
     }
     isTestName(name) {
-        return this.testNames.has(name);
+        return this.testNames.has(name) || this.importsTestObject(name);
     }
     isTestObject(expression) {
         const node = unwrap(expression);
         switch (node.type) {
             case 'Identifier':
-                return this.testNames.has(node.name);
+                return this.testNames.has(node.name) || this.importsTestObject(node.name);
             case 'MemberExpression':
                 return propertyName(node) === 'test' && this.isModule(node.object);
             case 'ConditionalExpression':
@@ -103,7 +119,12 @@ class PlaywrightBindings {
         }
     }
     reexports(source, imported) {
-        return isPlaywrightSource(source) && (imported === 'test' || imported === 'default');
+        return isPlaywrightSource(source) ? imported === 'test' || imported === 'default' : this.follow(source, imported);
+    }
+    /** Whether a name is imported from another module that exports it as a test object, as `base` from './base'. */
+    importsTestObject(name) {
+        const from = this.imported.get(name);
+        return from !== undefined && this.follow(from.source, from.imported);
     }
     /** Whether an expression is the Playwright module object, from a namespace import or `require`. */
     isModule(expression) {
@@ -147,6 +168,11 @@ class PlaywrightBindings {
         return true;
     }
 }
+const PLAYWRIGHT = {
+    name: 'Playwright',
+    isSource: isPlaywrightSource,
+    testObjects: (program, follow) => new PlaywrightBindings(program, follow),
+};
 export class PlaywrightAdapter {
     problems;
     fileTags = [];
@@ -157,18 +183,27 @@ export class PlaywrightAdapter {
     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();
     constructor(program, file, readModule) {
         this.file = file;
         this.readModule = readModule;
-        this.bindings = new PlaywrightBindings(program);
+        // A test object the file builds from an imported one, as in `const test = base.extend({...})`, is followed
+        // quietly: a call through the import itself is what reports an import that can't be followed.
+        const followed = new Map();
+        this.bindings = new PlaywrightBindings(program, (source, imported) => {
+            const key = `${source}\0${imported}`;
+            if (!followed.has(key))
+                followed.set(key, followModule(source, imported, readModule, PLAYWRIGHT).exported);
+            return followed.get(key) === true;
+        });
         this.problems = [...this.bindings.mismatches];
         this.imports = moduleImports(program, (source) => isPlaywrightSource(source) || MISMATCHED_SOURCES.has(source));
     }
     classify(call, context) {
         const chain = readChain(call.callee);
-        const links = chain ? this.testLinks(chain, call.arguments, context.scopes, context.inBody) : null;
+        const links = chain ? this.testLinks(chain, call.arguments, context) : null;
         if (!links)
             return null;
         const names = links.map((link) => link.name);
@@ -201,48 +236,68 @@ export class PlaywrightAdapter {
      * The links after the `test` object, or null when the chain doesn't start from Playwright's `test`. An import that
      * can't be followed is reported only outside test and hook bodies, where a call can declare tests.
      */
-    testLinks(chain, args, scopes, inBody) {
+    testLinks(chain, args, lookup) {
+        const links = this.linksFromTest(chain, args, lookup);
+        if (!links)
+            return null;
+        // A test object derived inline, as in `base.extend({ ... }).describe(...)`.
+        return links.slice(links.findLastIndex((link) => link.name === 'extend' && link.args) + 1);
+    }
+    linksFromTest(chain, args, lookup) {
         const { base, links } = chain;
-        let start;
+        const { scopes, inBody } = lookup;
+        const withMembers = (members) => [
+            ...members.map((name) => ({ name, args: null, template: null })),
+            ...links,
+        ];
         if (base.type === 'Identifier') {
             // A local variable or parameter with the same name, such as `(test) => test.result()`, is not Playwright's.
             const declaration = this.file.values.declarationOf(base.name, scopes);
             const bound = declaration !== null && this.bindings.declarations.has(declaration);
             const local = declaration !== null && this.imports.get(base.name)?.node === declaration;
-            const alias = declaration?.type === 'VariableDeclarator' && !bound && !local
-                ? this.describeAlias(declaration, scopes, inBody)
-                : null;
+            const alias = declaration?.type === 'VariableDeclarator' && !bound && !local ? this.alias(declaration, lookup) : null;
             // The module from `require()` is both the namespace and `test`, so `pw.test(...)` reads as the namespace.
             if (bound && this.bindings.namespaces.has(base.name) && links[0]?.name === 'test' && !links[0].args) {
-                start = 1;
+                return links.slice(1);
             }
-            else if (bound && this.bindings.testNames.has(base.name)) {
-                start = 0;
-            }
-            else if (alias) {
-                return [...alias.map((name) => ({ name, args: null, template: null })), ...links];
-            }
-            else if (local &&
-                this.looksLikeTest(links, args) &&
+            if (bound && this.bindings.testNames.has(base.name))
+                return links;
+            if (alias)
+                return withMembers(alias);
+            if (local &&
+                this.worthFollowing(base.name, links, args) &&
                 this.follow(base.name, !inBody && mayDeclareTests(base.name, links))) {
-                start = 0;
-            }
-            else if (declaration !== null && !bound && this.assumeLocal(declaration, base.name, links, args)) {
-                start = 0;
+                return links;
             }
-            else {
-                return null;
-            }
-        }
-        else if (this.bindings.isModule(base) && links[0]?.name === 'test' && !links[0].args) {
-            start = 1;
+            return declaration !== null && !bound && this.assumeLocal(declaration, base.name, links, args) ? links : null;
         }
-        else {
+        if (this.bindings.isModule(base) && links[0]?.name === 'test' && !links[0].args)
+            return links.slice(1);
+        const members = base.type === 'CallExpression' ? this.returned(base, links, args, lookup) : null;
+        return members && withMembers(members);
+    }
+    /**
+     * The members of `test` a call returns: none for a test object, as `conditionalTest({ min: 22 })` may return, or
+     * those of a describe function. As for a variable chosen by a condition, only the members all its values have apply.
+     * When the function can't be found, a call named like a test object is read as one on trust, with a warning.
+     */
+    returned(call, links, args, lookup) {
+        const callee = unwrap(call.callee);
+        if (callee.type !== 'Identifier' || !lookup.returnsOf)
+            return null;
+        const returns = lookup.returnsOf(callee.name, lookup.scopes);
+        if (returns)
+            return returnedFunction(returns, sharedMembers);
+        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));
         }
-        // A test object derived inline, as in `base.extend({ ... }).describe(...)`.
-        const derived = links.findLastIndex((link) => link.name === 'extend' && link.args);
-        return links.slice(Math.max(start, derived + 1));
+        return [];
+    }
+    testFunction(expression, scopes) {
+        return this.members(expression, { scopes, inBody: false, returnsOf: null });
     }
     /** Whether a local variable is read as a test object it could be; see `localTestObject`. */
     assumeLocal(declaration, name, links, args) {
@@ -259,44 +314,49 @@ export class PlaywrightAdapter {
     looksLikeTest(links, args) {
         return links.length === 0 ? looksLikeDeclaration(args) : TEST_MEMBERS.has(links[0].name);
     }
-    /** The members of `test` a variable holds a describe function from, as in `const serialDescribe = test.describe.serial`. */
-    describeAlias(declarator, scopes, inBody) {
+    /**
+     * 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));
+    }
+    /**
+     * The members of `test` a variable holds: those of a describe function, as in `const serialDescribe =
+     * test.describe.serial`, or none for a test object a function returns.
+     */
+    alias(declarator, lookup) {
         let members = this.aliases.get(declarator);
         if (members === undefined) {
             // Set first, so a variable defined through itself ends the lookup.
             this.aliases.set(declarator, null);
-            members = declarator.init ? this.describeMembers(declarator.init, scopes, inBody) : null;
+            members = declarator.init ? this.members(declarator.init, lookup) : null;
             this.aliases.set(declarator, members);
         }
         return members;
     }
-    describeMembers(expression, scopes, inBody) {
+    /** The members of `test` a value holds: none for a test object, or those of a describe function. */
+    members(expression, lookup) {
         const node = unwrap(expression);
         if (node.type === 'ConditionalExpression') {
             // `IS_PLATFORM ? test.describe.serial : test.describe`: only the members both branches have apply.
-            const consequent = this.describeMembers(node.consequent, scopes, inBody);
-            const alternate = this.describeMembers(node.alternate, scopes, inBody);
-            if (!consequent || !alternate)
-                return null;
-            const shared = consequent.findIndex((name, index) => alternate[index] !== name);
-            return shared === -1 ? consequent : consequent.slice(0, shared);
+            return sharedMembers(this.members(node.consequent, lookup), this.members(node.alternate, lookup));
         }
+        if (this.bindings.isTestObject(node))
+            return [];
         const chain = readChain(node);
         if (!chain || chain.links.some((link) => link.args ?? link.template))
             return null;
-        const members = this.testLinks(chain, [], scopes, inBody)?.map((link) => link.name);
-        return members && DESCRIBES.has(members.join('.')) ? members : null;
+        const members = this.testLinks(chain, [], lookup)?.map((link) => link.name);
+        return members && (members.length === 0 || DESCRIBES.has(members.join('.'))) ? members : null;
     }
     /** Follows the import of `name` once, and reports it once when it can't be followed and `report` is set. */
     follow(name, report) {
         const imported = this.imports.get(name);
         let result = this.followed.get(name);
         if (!result) {
-            result = followImport(name, imported, this.readModule, this.file, {
-                name: 'Playwright',
-                isSource: isPlaywrightSource,
-                testObjects: (program) => new PlaywrightBindings(program),
-            });
+            result = followImport(name, imported, this.readModule, this.file, PLAYWRIGHT);
             this.followed.set(name, result);
             if (result.exported) {
                 this.bindings.testNames.add(name);

package/dist/frameworks/vitest.d.ts

@@ -1,7 +1,13 @@
-import type { CallExpression } from 'oxc-parser';
+import type { CallExpression, Expression, Node } from 'oxc-parser';
 import type { Adapter, ApiCall, CallContext, ModuleReader, Problem } from '../model.ts';
 import type { ParsedFile } from '../parse.ts';
-import { type FileContext } from './common.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[];
@@ -12,6 +18,7 @@ export declare class VitestAdapter implements Adapter {
     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`. */
@@ -19,6 +26,7 @@ export declare class VitestAdapter implements Adapter {
     private warnedAboutTags;
     constructor(parsed: ParsedFile, file: FileContext, readModule: ModuleReader | null);
     classify(call: CallExpression, context: CallContext): ApiCall | null;
+    testFunction(expression: Expression, scopes: readonly Node[]): TestFunction | null;
     /** A call to `bench` imported from Vitest 5, which is undefined there, so the call throws. */
     private benchCall;
     private chainCall;
@@ -31,9 +39,23 @@ export declare class VitestAdapter implements Adapter {
     /** 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. */
@@ -52,3 +74,4 @@ export declare class VitestAdapter implements Adapter {
     private arrayLength;
     private tagsUsed;
 }
+export {};

package/dist/frameworks/vitest.js

@@ -1,7 +1,18 @@
 import { childNodes, isFunctionNode, isImportMetaVitest, propertyKey, propertyName, unwrap, } from "../ast.js";
 import { snippet } from "../source.js";
-import { allDeclarators, bindAll, exportName, followImport, moduleImports, requiredModule, } from "./bindings.js";
-import { atLeast, findFunction, isTestName, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, origin, problem, readChain, readCondition, readOptions, readStrings, isTitleLiteral, readReason, namedFunction, unresolvedOption, unresolvedOptions, readTitle, text, } from "./common.js";
+import { allDeclarators, bindAll, exportName, followImport, followModule, moduleImports, requiredModule, } from "./bindings.js";
+import { atLeast, findFunction, isTestName, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, origin, problem, readChain, readCondition, returnedFunction, returnedTestObject, readOptions, readStrings, isTitleLiteral, readReason, namedFunction, unresolvedOption, unresolvedOptions, readTitle, 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'],
@@ -88,7 +99,12 @@ class VitestBindings {
     /** The import specifiers and declarators that bind those names, to tell them from local names that shadow them. */
     declarations = new Set();
     problems = [];
-    constructor(program, version) {
+    /** Names imported from other modules, which may be test objects there. */
+    imported;
+    follow;
+    constructor(program, version, follow) {
+        this.imported = moduleImports(program, (source) => source === 'vitest' || MISMATCHED_SOURCES.has(source));
+        this.follow = follow;
         for (const statement of program.body) {
             if (statement.type !== 'ImportDeclaration' || statement.importKind === 'type')
                 continue;
@@ -125,12 +141,12 @@ class VitestBindings {
         });
     }
     isTestName(name) {
-        return this.kinds.has(name);
+        return this.kinds.has(name) || this.importsTestObject(name);
     }
     isTestObject(expression) {
         const node = unwrap(expression);
         if (node.type === 'Identifier')
-            return this.kinds.get(node.name) === 'test';
+            return this.kinds.get(node.name) === 'test' || this.importsTestObject(node.name);
         if (node.type === 'MemberExpression') {
             return KINDS.get(propertyName(node) ?? '') === 'test' && this.isNamespace(node.object);
         }
@@ -146,7 +162,12 @@ class VitestBindings {
             this.isTestObject(callee.object));
     }
     reexports(source, imported) {
-        return source === 'vitest' && KINDS.has(imported);
+        return source === 'vitest' ? KINDS.has(imported) : this.follow(source, imported);
+    }
+    /** Whether a name is imported from another module that exports it as a test object, as `base` from './base'. */
+    importsTestObject(name) {
+        const from = this.imported.get(name);
+        return from !== undefined && this.follow(from.source, from.imported);
     }
     isNamespace(expression) {
         const node = unwrap(expression);
@@ -198,6 +219,7 @@ export class VitestAdapter {
     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`. */
@@ -206,7 +228,15 @@ export class VitestAdapter {
     constructor(parsed, file, readModule) {
         this.file = file;
         this.readModule = readModule;
-        this.bindings = new VitestBindings(parsed.program, file.version);
+        // A test object the file builds from an imported one, as in `const it = base.extend({...})`, is followed quietly:
+        // a call through the import itself is what reports an import that can't be followed.
+        const followed = new Map();
+        this.bindings = new VitestBindings(parsed.program, file.version, (source, imported) => {
+            const key = `${source}\0${imported}`;
+            if (!followed.has(key))
+                followed.set(key, followModule(source, imported, readModule, this.framework()).exported);
+            return followed.get(key) === true;
+        });
         this.problems = [...this.bindings.problems];
         if (atLeast(file.version, 5, 0)) {
             for (const call of nestedHoistedCalls(parsed.program)) {
@@ -229,6 +259,9 @@ export class VitestAdapter {
             this.contextSkip(call, context) ??
             this.chainCall(call, context));
     }
+    testFunction(expression, scopes) {
+        return this.aliasOf(expression, { scopes, inBody: false, returnsOf: null });
+    }
     /** 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;
@@ -245,7 +278,7 @@ export class VitestAdapter {
     }
     chainCall(call, context) {
         const chain = readChain(call.callee);
-        const resolved = chain ? this.resolve(chain, call.arguments, context.scopes, context.inBody) : null;
+        const resolved = chain ? this.resolve(chain, call.arguments, context) : null;
         if (!resolved)
             return null;
         const { kind, links } = resolved;
@@ -285,8 +318,8 @@ export class VitestAdapter {
      * 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, scopes, inBody) {
-        const start = this.start(chain, args, scopes, inBody);
+    resolve(chain, args, lookup) {
+        const start = this.start(chain, args, lookup);
         if (!start)
             return null;
         let kind = start.kind;
@@ -300,8 +333,13 @@ export class VitestAdapter {
         }
         return { kind, links };
     }
-    start(chain, args, scopes, inBody) {
+    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,
@@ -317,10 +355,10 @@ export class VitestAdapter {
         if (this.suiteParameters.get(declaration) === base.name)
             return { kind: 'test', index: 0 };
         const followed = this.imports.get(base.name)?.node === declaration &&
-            this.looksLikeTest(links, args) &&
+            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, scopes, inBody) : null;
+            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)
@@ -335,37 +373,48 @@ export class VitestAdapter {
         return kind ? { kind, index: 0 } : null;
     }
     /** The function and modifiers a variable holds, as in `const skipOnCi = test.skipIf(isCI)`. */
-    alias(declarator, scopes, inBody) {
+    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, scopes, inBody) : null;
+            alias = declarator.init ? this.aliasOf(declarator.init, lookup) : null;
             this.aliases.set(declarator, alias);
         }
         return alias;
     }
-    aliasOf(expression, scopes, inBody) {
+    aliasOf(expression, lookup) {
         const node = unwrap(expression);
         if (node.type === 'ConditionalExpression') {
             // `isCI ? describe.concurrent : describe`: only the modifiers both branches have apply.
-            const consequent = this.aliasOf(node.consequent, scopes, inBody);
-            const alternate = this.aliasOf(node.alternate, scopes, inBody);
-            if (!consequent || consequent.kind !== alternate?.kind)
-                return null;
-            const same = (link, index) => {
-                const other = alternate.links.at(index);
-                return other?.name === link.name && !link.args && !link.template && !other.args && !other.template;
-            };
-            const shared = consequent.links.findIndex((link, index) => !same(link, index));
-            return { kind: consequent.kind, links: shared === -1 ? consequent.links : consequent.links.slice(0, shared) };
+            return shared(this.aliasOf(node.consequent, lookup), this.aliasOf(node.alternate, lookup));
         }
         const chain = readChain(node);
-        const resolved = chain ? this.resolve(chain, [], scopes, inBody) : null;
+        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' || !lookup.returnsOf)
+            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))
@@ -381,16 +430,29 @@ export class VitestAdapter {
     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, {
-                name: 'Vitest',
-                isSource: (source) => source === 'vitest',
-                testObjects: (program) => new VitestBindings(program, this.file.version),
-            });
+            result = followImport(name, imported, this.readModule, this.file, this.framework());
             this.followed.set(name, result);
             if (result.exported) {
                 this.bindings.kinds.set(name, KINDS.get(imported.imported) ?? 'test');

package/dist/index.d.ts

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

package/dist/model.d.ts

@@ -1,4 +1,4 @@
-import type { CallExpression, Node } from 'oxc-parser';
+import type { CallExpression, Expression, Node } from 'oxc-parser';
 import type { FunctionNode } from './ast.ts';
 import type { Annotation, DiagnosticCode, DiagnosticLevel, MetaValue } from './types.ts';
 export type State = 'skip' | 'fixme' | 'todo' | 'expectedToFail';
@@ -105,11 +105,27 @@ export interface CallContext {
     inTest: boolean;
     /** Inside a test or hook body, where calls don't declare tests. */
     inBody: boolean;
+    /**
+     * What a function declared in the file, or imported from a local module, returns, for a call on its result such as
+     * `conditionalTest({ min: 22 })('title', fn)`; null when the name is not a function the scan can find.
+     */
+    returnsOf(name: string, scopes: readonly Node[]): Returns | null;
+}
+/** The values a function returns, read by the adapter of the file that writes the function. */
+export interface Returns {
+    adapter: Adapter;
+    /** Each value with the scopes around it; null when the function may return no value, or returns a promise. */
+    values: {
+        expression: Expression;
+        scopes: readonly Node[];
+    }[] | null;
 }
 /** A module read to see whether it exports a custom `test` object. */
 export interface ModuleSource {
     code: string;
     relativeFilePath: string;
+    /** Reads the modules this module imports in turn. */
+    readModule: ModuleReader;
 }
 /** Reads the module an import refers to, or says why it can't, as in "could not be read". */
 export type ModuleReader = (specifier: string) => ModuleSource | {
@@ -122,5 +138,10 @@ export interface Adapter {
     fileTags: string[];
     usesGlobals: boolean;
     classify(call: CallExpression, context: CallContext): ApiCall | null;
+    /**
+     * The test or describe function a value holds, in the adapter's own terms, as `it.skip` in `return it.skip`; null
+     * when it holds none. A function the value calls is not followed to what it returns.
+     */
+    testFunction(expression: Expression, scopes: readonly Node[]): unknown;
 }
 export {};

package/dist/options.d.ts

@@ -3,12 +3,15 @@ import type { Framework } from './types.ts';
 export type { CommentsMode };
 /** @inline */
 export interface ScanOptions {
-    /** Glob patterns for the test files, relative to `root`. */
+    /**
+     * Glob patterns for the test files, relative to `root`. As in Playwright and Vitest, they match names that start with
+     * a dot too.
+     */
     patterns: string[];
     framework: Framework;
     /** The project root. Paths in the output are relative to it. Defaults to the current directory. */
     root?: string;
-    /** Glob patterns to leave out, in addition to `node_modules`. */
+    /** Glob patterns to leave out, in addition to `node_modules` and `.git`. */
     ignore?: string[];
     /** The framework version whose rules apply, instead of the one read from the project. */
     frameworkVersion?: string;