test-inventory 0.4.0 → 0.5.0

package/dist/records.js

@@ -2,6 +2,7 @@ import { REJECTS_FILE, toDiagnostic } from "./diagnostics.js";
 import { anySlow, eitherCondition, noHooks, } from "./extract.js";
 import { problem } from "./frameworks/common.js";
 import { hashNodes, shortHash } from "./hash.js";
+import { snippet } from "./source.js";
 /**
  * The state the runner applies, from the candidates nearest the test first. An unconditional skip, fixme or todo wins
  * over an unconditional expected failure, since the test doesn't run, and one set while the file loads wins over one
@@ -12,6 +13,65 @@ function chooseState(candidates) {
     const stops = always.filter((candidate) => candidate.setting.state !== 'expectedToFail');
     return (stops.find((candidate) => !candidate.setting.afterLoad) ?? stops.at(0) ?? always.at(0) ?? candidates.at(0) ?? null);
 }
+/**
+ * The first use of each tag the Vitest config doesn't define, by `strictTags` an error that fails the file while it
+ * loads, in the order Vitest meets them: the `@module-tag` comments, the describes' `tags` as the describes are called,
+ * then the tests'. A use in a function or under a condition only fails the file if that code runs.
+ */
+function undefinedTags(extraction, tags) {
+    const defined = new Set(tags.definitions.map(({ name }) => name));
+    const declared = (items) => items
+        .flatMap(({ declaration, site, call, isInCondition, isInFunction }) => declaration.details.tags.map((name) => ({ name, span: site ?? call, isSure: !isInCondition && !isInFunction })))
+        .sort((a, b) => a.span.start - b.span.start);
+    const uses = [
+        ...extraction.fileTags.map((tag) => ({ ...tag, isSure: true })),
+        ...declared(extraction.suites),
+        ...declared(extraction.tests),
+    ].filter(({ name }) => !defined.has(name));
+    // Each tag is reported once: at its first use that surely runs, else at its first use.
+    const first = new Map();
+    for (const use of uses) {
+        const known = first.get(use.name);
+        if (!known || (!known.isSure && use.isSure))
+            first.set(use.name, use);
+    }
+    const reported = [...first.values()].sort((a, b) => uses.indexOf(a) - uses.indexOf(b));
+    return reported.map(({ name, span, isSure }) => {
+        const consequence = isSure
+            ? 'Vitest fails the file while it loads, and none of its tests run'
+            : 'Vitest fails the file if this code runs while it loads';
+        const message = `The Vitest config doesn't define the tag "${name}", so with strictTags ${consequence}.`;
+        return { problem: problem('undefined-tag', span, message), isSure };
+    });
+}
+const FLAG_ORDER = ['skip', 'todo', 'expectedToFail'];
+const ALWAYS = { condition: null, reason: null, hasDynamicReason: false };
+/**
+ * The states of a test's declaration with those of its Vitest tags. Vitest merges the options and then takes `only`
+ * over `skip` over `todo`, so a `.only` on either side drops the skip and todo of both.
+ */
+function declaredStates(declared, options, { isOnly, skipPassedDown }) {
+    const own = declared.map((setting) => ({ setting, source: 'test' }));
+    if (options === null)
+        return own;
+    // A describe's `skip` option is merged in too, where the scan otherwise leaves it to the describe's own state; the
+    // test's own skip, when it has one, sorts first.
+    const passed = skipPassedDown === undefined
+        ? []
+        : [{ setting: { ...ALWAYS, state: 'skip', line: skipPassedDown }, source: 'suite' }];
+    const all = [...own, ...passed, ...tagStates(options).map((setting) => ({ setting, source: 'config' }))];
+    const kept = isOnly || options.only ? all.filter(({ setting }) => setting.state === 'expectedToFail') : all;
+    return kept.sort((a, b) => FLAG_ORDER.indexOf(a.setting.state) - FLAG_ORDER.indexOf(b.setting.state));
+}
+/** The states the options of a test's Vitest tags set. */
+function tagStates(options) {
+    const states = [
+        [options.skip, 'skip'],
+        [options.todo, 'todo'],
+        [options.fails, 'expectedToFail'],
+    ];
+    return states.filter(([isSet]) => isSet === true).map(([, state]) => ({ ...ALWAYS, state, line: null }));
+}
 /** The scope and the scopes around it, innermost first. */
 function outward(scope) {
     const scopes = [];
@@ -30,6 +90,10 @@ function bodyNodes(fn) {
     const body = fn.body;
     return body.type === 'BlockStatement' ? body.body : [body];
 }
+/** Where a run setting of a scope is written, for a test in it: the file, or a describe. */
+function placeOf(scope) {
+    return scope.kind === 'file' ? 'file' : 'suite';
+}
 function addHooks(scopes) {
     const total = noHooks();
     for (const scope of scopes) {
@@ -56,11 +120,47 @@ function runKeys(places) {
         repeats: first('repeats') ?? null,
     };
 }
+/** A test's run settings from the file, and where each comes from: the nearest place that sets it. */
+function testRun(places) {
+    const from = (key) => places.find((place) => place.run[key] !== undefined)?.source ?? null;
+    return {
+        ...runKeys(places.map((place) => place.run)),
+        timeoutSource: from('timeout'),
+        retriesSource: from('retry'),
+        repeatsSource: from('repeats'),
+        timeoutConfigText: null,
+        retriesConfigText: null,
+        repeatsConfigText: null,
+    };
+}
+/** A test's run settings, with what the config sets where the file sets nothing. */
+function withConfig(fromFile, config) {
+    const run = { ...fromFile };
+    if (run.timeoutSource === null && config?.timeout !== undefined) {
+        run.timeout = config.timeout;
+        run.timeoutSource = 'config';
+        run.timeoutConfigText = config.timeoutText;
+    }
+    if (run.retriesSource === null && config?.retry !== undefined) {
+        run.retries = config.retry?.count ?? null;
+        run.retryDelay = config.retry?.delay ?? null;
+        run.retryCondition = config.retry?.condition ?? null;
+        run.retriesSource = 'config';
+        run.retriesConfigText = config.retryText;
+    }
+    if (run.repeatsSource === null && config?.repeats !== undefined) {
+        run.repeats = config.repeats;
+        run.repeatsSource = 'config';
+        run.repeatsConfigText = config.repeatsText;
+    }
+    return run;
+}
 /** The record of a scanned file, from its records and the hooks at its top level. */
 export function fileRecord(relativeFilePath, hooks, records) {
     return {
         relativeFilePath,
         fileName: relativeFilePath.slice(relativeFilePath.lastIndexOf('/') + 1),
+        config: null,
         hooks,
         suiteCount: records.suites.length,
         testCount: records.tests.length,
@@ -94,19 +194,28 @@ class RecordBuilder {
     }
     build(extraction) {
         const duplicates = this.duplicates(extraction.tests);
-        const rejecting = [
-            ...extraction.problems,
-            ...extraction.tests.flatMap((test) => test.problems),
-            ...duplicates.map((item) => item.problem),
-        ].filter((item) => REJECTS_FILE[this.options.framework].has(item.code) && item.afterLoad !== true);
-        // Each of these problems points at the code that causes it.
-        const lines = rejecting.map((item) => this.parsed.source.line(item.node.start));
+        const tags = this.options.framework === 'vitest' ? (this.options.config?.tags ?? null) : null;
+        const testProblems = extraction.tests.flatMap((test) => test.problems);
+        // With the config's tags known, what they do is in the records, unless a tag can't be worked out.
+        const isTagMissing = [...extraction.problems, ...testProblems].some((item) => item.code === 'unresolved-tag');
+        const undefinedUses = tags?.isStrict ? undefinedTags(extraction, tags) : [];
+        const problems = [
+            ...extraction.problems.filter((item) => tags === null || isTagMissing || item.code !== 'config-may-change-state'),
+            ...undefinedUses.map((use) => use.problem),
+        ];
+        const rejecting = [...problems, ...testProblems, ...duplicates.map((item) => item.problem)].filter((item) => REJECTS_FILE[this.options.framework].has(item.code) && item.code !== 'undefined-tag' && item.afterLoad !== true);
+        // Each of these problems points at the code that causes it. Vitest meets the tags in the order they are listed.
+        const firstTag = undefinedUses.find((use) => use.isSure)?.problem;
+        const lines = [...rejecting, ...(firstTag ? [firstTag] : [])].map((item) => this.parsed.source.line(item.node.start));
         if (lines.length > 0)
             this.rejectedAt = Math.min(...lines);
         const suites = extraction.suites.map((suite) => this.suite(suite));
-        const tests = extraction.tests.map((test) => this.test(test));
-        for (const item of extraction.problems)
-            this.diagnostics.push(this.diagnostic(item));
+        const tests = extraction.tests.map((test) => this.test(test, suites));
+        for (const item of problems) {
+            const found = this.diagnostic(item);
+            const isSure = undefinedUses.find((use) => use.problem === item)?.isSure ?? true;
+            this.diagnostics.push(isSure ? found : { ...found, level: 'warning' });
+        }
         for (const { index, problem: item } of duplicates) {
             this.diagnostics.push(this.diagnostic(item, tests[index].id));
         }
@@ -144,8 +253,25 @@ class RecordBuilder {
         this.ordinals.set(key, ordinal + 1);
         return shortHash(JSON.stringify([this.options.relativeFilePath, ...parts, ordinal]));
     }
+    /**
+     * Reports a `.only` that the config's `forbidOnly` makes fail the run, at `located`; one under a condition is a
+     * warning. `call` is the `.only` call when it is in this file, whose callee the diagnostic shows.
+     */
+    forbidOnly(located, call) {
+        const forbid = this.options.config?.forbidOnly ?? false;
+        if (forbid === false)
+            return;
+        const message = forbid === true
+            ? 'The config sets forbidOnly, so this .only fails the run before any test runs.'
+            : `The config sets forbidOnly when ${forbid}, so then this .only fails the run before any test runs.`;
+        const callee = call && snippet(this.parsed.source.text.slice(call.callee.start, call.callee.end));
+        const found = problem('forbidden-only', located, message, callee);
+        this.diagnostics.push(this.diagnostic(forbid === true ? found : { ...found, level: 'warning' }));
+    }
     suite(pending) {
         const { scope, declaration, call } = pending;
+        if (declaration.isOnly)
+            this.forbidOnly(pending.site ?? call, pending.site ? null : call);
         const parents = outward(scope).slice(1, -1).reverse();
         const title = declaration.title;
         // Suite ids are marked so that a describe and a test with the same title in the same place differ.
@@ -187,7 +313,26 @@ class RecordBuilder {
             ...runKeys([scope.details.run]),
         };
     }
-    test(pending) {
+    /** What the config's Vitest tags set on a test with `tags`, merged as Vitest merges them; null when none applies. */
+    tagOptions(tags) {
+        const definitions = this.options.config?.tags?.definitions ?? [];
+        const applied = tags.flatMap((name) => definitions.filter((definition) => definition.name === name));
+        if (applied.length === 0)
+            return null;
+        // Vitest applies the tags from the highest number to the lowest, so the lowest wins; a tag without one goes first.
+        const rank = ({ priority }) => priority ?? Infinity;
+        applied.sort((a, b) => rank(b) - rank(a));
+        const merged = { run: {} };
+        for (const { options } of applied) {
+            const { run, meta, ...flags } = options;
+            Object.assign(merged, flags);
+            Object.assign(merged.run, run);
+            if (meta)
+                merged.meta = { ...merged.meta, ...meta };
+        }
+        return merged;
+    }
+    test(pending, suites) {
         const { declaration } = pending;
         // A test from an imported helper is placed at the call in this file that registers it.
         const located = pending.site ?? pending.call;
@@ -195,8 +340,19 @@ class RecordBuilder {
         const describes = scopes.filter((scope) => scope.kind === 'describe').reverse();
         const title = declaration.title;
         const id = this.id([this.describeTitles(describes), title.withoutTags]);
+        const fileScope = scopes[scopes.length - 1];
+        const tags = unique([
+            ...fileScope.details.tags,
+            ...describes.flatMap((scope) => scope.details.tags),
+            ...declaration.details.tags,
+        ]);
+        const fromTags = this.tagOptions(tags);
+        // In Vitest 5 the options of a test's tags win over those the describes pass down; before, the describes' win.
+        const tagsFirst = this.options.config?.tags?.beatsDescribes ?? true;
+        const tagged = (own, tag, around) => tagsFirst ? [...own, ...tag, ...around] : [...own, ...around, ...tag];
         const chosen = chooseState([
-            ...pending.states.map((setting) => ({ setting, source: 'test' })),
+            ...declaredStates(pending.states.slice(0, declaration.states.length), fromTags, declaration),
+            ...pending.states.slice(declaration.states.length).map((setting) => ({ setting, source: 'test' })),
             ...scopes.flatMap((scope) => scope.states.map((setting) => ({
                 setting,
                 source: scope.kind === 'file' ? 'file' : 'suite',
@@ -207,13 +363,14 @@ class RecordBuilder {
         const state = rejected ? 'notLoaded' : (chosen?.setting.state ?? 'active');
         const setting = rejected ? null : (chosen?.setting ?? null);
         const suitePath = describes.flatMap((scope) => suiteOf(scope).declaration.title?.text ?? []);
-        const fileScope = scopes[scopes.length - 1];
-        const mode = declaration.mode ?? scopes.find((scope) => scope.mode !== null)?.mode ?? null;
+        const tagConcurrent = this.options.config?.tags?.concurrentBeatsTags ? undefined : fromTags?.concurrent;
+        const tagMode = tagConcurrent === undefined ? null : tagConcurrent ? 'parallel' : 'default';
+        const [mode = null] = tagged([declaration.mode], [tagMode], scopes.map((scope) => scope.mode)).filter((item) => item !== null);
         const meta = {};
-        for (const values of [...describes.map((scope) => scope.details.meta), declaration.details.meta]) {
+        for (const values of [fromTags?.meta, ...describes.map((scope) => scope.details.meta), declaration.details.meta]) {
             Object.assign(meta, values);
         }
-        const isOnly = declaration.isOnly || scopes.some((scope) => scope.isOnly);
+        const isOnly = declaration.isOnly || scopes.some((scope) => scope.isOnly) || fromTags?.only === true;
         const comments = this.options.comments === 'all' || (this.options.comments === 'non-active' && state !== 'active')
             ? pending.comments
             : [];
@@ -225,13 +382,18 @@ class RecordBuilder {
             const message = 'The test uses the bench fixture, which Vitest only provides in benchmark files such as *.bench.ts; elsewhere the test fails.';
             this.diagnostics.push(this.diagnostic(problem('bench-outside-benchmark-file', located, message), id));
         }
+        if (declaration.isOnly)
+            this.forbidOnly(located, pending.site ? null : pending.call);
         if (pending.isInLoop) {
             this.diagnostics.push(this.diagnostic(problem('test-in-loop', located, 'The test is declared in a loop; it is listed once, while the runner creates one test per iteration.'), id));
         }
-        if (declaration.isOnly && chosen && chosen.source !== 'test' && chosen.setting.state === 'skip') {
+        if ((declaration.isOnly || fromTags?.only === true) &&
+            chosen &&
+            chosen.source !== 'test' &&
+            chosen.setting.state === 'skip') {
             this.diagnostics.push(this.diagnostic(problem('only-in-skipped-describe', located, 'The test uses .only, but a describe around it is skipped, so it is skipped too.'), id));
         }
-        return {
+        const record = {
             id,
             bodyHash: declaration.hashed ? hashNodes([declaration.hashed]) : null,
             suiteId: describes.length > 0 ? this.suiteIds.get(describes[describes.length - 1]) : null,
@@ -261,11 +423,7 @@ class RecordBuilder {
             stateLine: rejected ? this.rejectedAt : (setting?.line ?? null),
             isParallel: mode === 'parallel',
             isSerial: mode === 'serial',
-            tags: unique([
-                ...fileScope.details.tags,
-                ...describes.flatMap((scope) => scope.details.tags),
-                ...declaration.details.tags,
-            ]),
+            tags,
             annotations: [...describes.flatMap((scope) => scope.details.annotations), ...pending.annotations],
             comments,
             locks: unique([
@@ -276,11 +434,10 @@ class RecordBuilder {
             meta: Object.keys(meta).length > 0 ? meta : null,
             hooks: addHooks(scopes),
             // Calls in the body and in `beforeEach` hooks run last, so they win over what the describes set.
-            ...runKeys([
-                pending.run,
-                ...scopes.map((scope) => scope.hookRun),
-                declaration.details.run,
-                ...scopes.map((scope) => scope.details.run),
+            ...testRun([
+                { run: pending.run, source: 'test' },
+                ...scopes.map((scope) => ({ run: scope.hookRun, source: placeOf(scope) })),
+                ...tagged([{ run: declaration.details.run, source: 'test' }], [{ run: fromTags?.run ?? {}, source: 'config' }], scopes.map((scope) => ({ run: scope.details.run, source: placeOf(scope) }))),
             ]),
             fixtures: unique([...declaration.fixtures, ...[...scopes].reverse().flatMap((scope) => scope.hookFixtures)]),
             expectCount: pending.expectCount,
@@ -294,6 +451,13 @@ class RecordBuilder {
             isInLoop: pending.isInLoop,
             isInCondition: pending.isInCondition,
             isInFunction: pending.isInFunction,
+            projects: null,
+        };
+        const { projects, defaults } = this.options.config?.forTest(record, suites) ?? { projects: null, defaults: null };
+        return {
+            ...withConfig(record, defaults),
+            isParallel: record.isParallel || (mode === null && defaults?.parallel === true),
+            projects,
         };
     }
     /**

package/dist/resolve.js

@@ -180,7 +180,7 @@ function aliasFiles(specifier, options) {
     const match = options.paths ? matchPattern(Object.keys(options.paths), specifier) : null;
     if (!match || !options.paths)
         return null;
-    return targetStrings(options.paths[match.key]).map((target) => path.resolve(options.pathsBase, target.replaceAll('${configDir}', options.configDir).replace('*', match.star)));
+    return targetStrings(options.paths[match.key]).map((target) => path.resolve(options.pathsBase, target.replaceAll('${configDir}', options.configDir).replaceAll('*', match.star)));
 }
 /** Files a `#name` import may stand for, from `imports` in the nearest package.json. */
 function subpathImportFiles(specifier, directory) {
@@ -191,7 +191,7 @@ function subpathImportFiles(specifier, directory) {
             const match = imports ? matchPattern(Object.keys(imports), specifier) : null;
             if (!match || !imports)
                 return [];
-            return targetStrings(imports[match.key]).map((target) => path.resolve(folder, target.replace('*', match.star)));
+            return targetStrings(imports[match.key]).map((target) => path.resolve(folder, target.replaceAll('*', match.star)));
         }
         if (path.dirname(folder) === folder)
             return [];
@@ -223,7 +223,7 @@ function packageEntry(folder, subpath) {
     let targets;
     if (isSubpathMap) {
         const match = matchPattern(Object.keys(map), subpath);
-        targets = match ? targetStrings(map[match.key]).map((target) => target.replace('*', match.star)) : [];
+        targets = match ? targetStrings(map[match.key]).map((target) => target.replaceAll('*', match.star)) : [];
     }
     else {
         targets = subpath === '.' ? targetStrings(exports) : [];

package/dist/scan-file.d.ts

@@ -1,5 +1,5 @@
 import type { ModuleReader } from './model.ts';
-import { type CommentsMode, type FileRecords } from './records.ts';
+import { type CommentsMode, type FileConfig, type FileRecords } from './records.ts';
 import type { Framework } from './types.ts';
 export interface FileSettings {
     framework: Framework;
@@ -9,6 +9,10 @@ export interface FileSettings {
     readModule: ModuleReader | null;
     /** The project root, left out of error messages so that the output has no absolute paths. */
     root: string | null;
+    /** Whether the config runs the file as a benchmark; null takes it from the file's name, as Vitest 5's default does. */
+    isBenchmarkFile?: boolean | null;
+    /** What the config the file uses sets for its tests; null without a config. */
+    config?: FileConfig | null;
 }
 export interface FileResult extends FileRecords {
     usesGlobals: boolean;

package/dist/scan-file.js

@@ -44,8 +44,11 @@ export function scanFile(code, relativeFilePath, settings) {
             framework: settings.framework,
             comments: settings.comments,
             isTypeTest: settings.framework === 'vitest' && TYPE_TEST.test(relativeFilePath),
-            // Vitest 5's default `benchmark.include`.
-            isBenchmarkFile: settings.framework === 'vitest' && atLeast(settings.version, 5, 0) && BENCHMARK.test(relativeFilePath),
+            // Vitest 5's default `benchmark.include`, when no config says.
+            isBenchmarkFile: settings.framework === 'vitest' &&
+                atLeast(settings.version, 5, 0) &&
+                (settings.isBenchmarkFile ?? BENCHMARK.test(relativeFilePath)),
+            config: settings.config ?? null,
         });
         return {
             ...records,

package/dist/scan-source.js

@@ -22,5 +22,5 @@ export function scanSource(options) {
         readModule: null,
         root: null,
     });
-    return createInventory(framework, frameworkVersion, 1, [result], []);
+    return createInventory(framework, frameworkVersion, 1, [result], [], []);
 }

package/dist/scan.d.ts

@@ -1,7 +1,8 @@
 import { type ScanOptions } from './options.ts';
 import type { Inventory } from './types.ts';
 /**
- * Scans the test files that match `patterns` under `root`, one file at a time.
+ * Scans the test files that match `patterns` under `root`, or without patterns those the configs run, one file at a
+ * time.
  *
  * Throws a `TypeError` for invalid options. Problems with files and code are reported as diagnostics.
  */

package/dist/scan.js

@@ -1,6 +1,8 @@
 import { existsSync, statSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
+import { ConfigRuns, fileConfig } from "./config-runs.js";
+import { Configs } from "./config.js";
 import { fileDiagnostic } from "./diagnostics.js";
 import { findFiles, normalizePattern, readFailure } from "./files.js";
 import { detectFrameworkVersion, OLDEST } from "./framework-version.js";
@@ -39,17 +41,36 @@ function folderHint(root, patterns, framework) {
     });
     if (folder === undefined)
         return '';
-    const example = `${folder.replace(/[\\/]+$/, '')}/**/*.${framework === 'playwright' ? 'spec' : 'test'}.ts`;
+    // A loop, as a regular expression for trailing slashes takes quadratic time on a long run of slashes.
+    let end = folder.length;
+    while (end > 0 && '/\\'.includes(folder[end - 1]))
+        end -= 1;
+    const example = `${folder.slice(0, end)}/**/*.${framework === 'playwright' ? 'spec' : 'test'}.ts`;
     return ` "${folder}" is a folder; to scan the test files in it, use a pattern such as "${example}".`;
 }
+/** The JavaScript and TypeScript files the runners read, which the configs choose the test files from. */
+const SCRIPT_FILES = '**/*.{js,jsx,ts,tsx,mjs,mjsx,mts,mtsx,cjs,cjsx,cts,ctsx}';
+/** Why a scan found no test files: what the patterns matched, or whether there is a config to find them from. */
+function noFiles(root, patterns, framework, placements) {
+    if (patterns) {
+        const list = patterns.map((pattern) => `"${pattern}"`).join(', ');
+        return `No test files match ${list} in the root.${folderHint(root, patterns, framework)}`;
+    }
+    if ([...placements.values()].some((placement) => placement.config)) {
+        return 'No test files were found from the configs in the root.';
+    }
+    const name = framework === 'playwright' ? 'Playwright' : 'Vitest';
+    return `No patterns were given, and no ${name} config is in the root or a folder below it, so there are no test files to find.`;
+}
 /**
- * Scans the test files that match `patterns` under `root`, one file at a time.
+ * Scans the test files that match `patterns` under `root`, or without patterns those the configs run, one file at a
+ * time.
  *
  * Throws a `TypeError` for invalid options. Problems with files and code are reported as diagnostics.
  */
 export async function scan(options) {
     const checked = checkObject(options, 'options');
-    const patterns = checkStrings(checked.patterns, 'options.patterns', true);
+    const patterns = checked.patterns === undefined ? null : checkStrings(checked.patterns, 'options.patterns', true);
     const framework = checkFramework(checked.framework, 'options.framework');
     const ignore = checkStrings(checked.ignore, 'options.ignore', false);
     const comments = checkComments(checked.comments, 'options.comments');
@@ -69,24 +90,31 @@ export async function scan(options) {
         : majorMinor(frameworkVersion);
     const source = override === null ? (detected?.source ?? 'package.json') : '.';
     const projectDiagnostics = versionDiagnostics(framework, frameworkVersion, source, range);
-    const found = await findFiles(root, patterns, ignore, framework);
+    // Without patterns, the configs choose among all JavaScript and TypeScript files.
+    const found = await findFiles(root, patterns ?? [SCRIPT_FILES], ignore, framework);
     projectDiagnostics.push(...found.diagnostics);
-    if (found.files.length === 0) {
-        const list = patterns.map((pattern) => `"${pattern}"`).join(', ');
-        const message = `No test files match ${list} in the root.${folderHint(root, patterns, framework)}`;
-        projectDiagnostics.push(fileDiagnostic('no-files-matched', '.', message));
-    }
     const readerFor = moduleResolver(root);
+    const configs = new Configs(root, framework, readerFor, rules);
+    const runs = new ConfigRuns(configs, framework, rules, patterns === null);
+    const placements = new Map(found.files.map((file) => [file.absolutePath, runs.placementOf(file.absolutePath)]));
+    const files = patterns ? found.files : found.files.filter((file) => placements.get(file.absolutePath)?.runs);
+    const notRun = [];
     const results = [];
     const globalsFiles = [];
-    for (const { absolutePath, relativeFilePath } of found.files) {
+    for (const { absolutePath, relativeFilePath } of files) {
+        const placement = placements.get(absolutePath);
+        if (placement.config)
+            configs.use(placement.config);
+        const config = placement.config?.record.relativeFilePath ?? null;
         let code;
         try {
             code = await readFile(absolutePath, 'utf8');
         }
         catch (error) {
+            const records = noRecords(relativeFilePath);
             results.push({
-                ...noRecords(relativeFilePath),
+                ...records,
+                file: { ...records.file, config },
                 diagnostics: [
                     fileDiagnostic('read-error', relativeFilePath, `The file could not be read: ${readFailure(error)}.`),
                 ],
@@ -99,15 +127,33 @@ export async function scan(options) {
             comments,
             readModule: readerFor(absolutePath),
             root,
+            isBenchmarkFile: placement.runs === null ? null : placement.runs === 'benchmark',
+            config: fileConfig(placement, framework, rules, absolutePath),
         });
         if (result.usesGlobals)
             globalsFiles.push({ absolutePath, relativeFilePath });
-        results.push(result);
+        // A file without tests that no config runs, such as a source file a broad pattern matches, misses nothing.
+        if (placement.runs === false && result.tests.length > 0) {
+            const message = `The file has tests, but no config in its folder or above runs it, so the runner doesn't collect them; the nearest config is ${config}.`;
+            notRun.push(fileDiagnostic('file-not-run', relativeFilePath, message));
+        }
+        results.push({ ...result, file: { ...result.file, config } });
+    }
+    const missingGlobals = globalsCheck(root, configs, (file) => placements.get(file));
+    let globals = null;
+    for (const { absolutePath, relativeFilePath } of globalsFiles) {
+        const message = missingGlobals(absolutePath);
+        if (message === null)
+            continue;
+        globals = fileDiagnostic('globals-not-enabled', relativeFilePath, message);
+        break;
     }
-    const enabled = globalsCheck(root);
-    const globalsFile = globalsFiles.find((file) => !enabled(file.absolutePath))?.relativeFilePath;
-    if (globalsFile !== undefined) {
-        projectDiagnostics.push(fileDiagnostic('globals-not-enabled', globalsFile, "The file uses Vitest's global test functions, but no Vitest or Vite config with globals: true and no tsconfig with vitest/globals was found."));
+    projectDiagnostics.push(...configs.diagnostics, ...notRun, ...(globals ? [globals] : []));
+    // After the config warnings, which may say why no file was found.
+    if (files.length === 0) {
+        projectDiagnostics.push(fileDiagnostic('no-files-matched', '.', noFiles(root, patterns, framework, placements)));
     }
-    return createInventory(framework, frameworkVersion, found.files.length, results, projectDiagnostics);
+    const fileCount = files.length;
+    const records = configs.records((config) => runs.projectsIn(config));
+    return createInventory(framework, frameworkVersion, fileCount, results, projectDiagnostics, records);
 }