test-inventory 0.6.0 → 0.7.0

package/dist/config-runs.js

@@ -101,8 +101,8 @@ export class ConfigRuns {
     projects = new Map();
     ignoreRules = new Map();
     folderStates = new Map();
-    /** The Vitest configs whose projects are being found, to stop at one whose projects name itself. */
-    expanding = new Set();
+    /** The Vitest configs whose projects are being found, with their names, to stop at one whose projects name itself. */
+    expanding = new Map();
     constructor(configs, framework, version, findsFiles) {
         this.configs = configs;
         this.framework = framework;
@@ -115,6 +115,10 @@ export class ConfigRuns {
      * nearest config.
      */
     placementOf(file) {
+        const placement = this.place(file);
+        return { ...placement, tags: this.configTags(placement.config) };
+    }
+    place(file) {
         const around = this.configs.around(file);
         for (const config of around) {
             const running = this.projectsOf(config).flatMap((project) => {
@@ -140,6 +144,29 @@ export class ConfigRuns {
             projects: nearest ? [] : null,
         };
     }
+    /**
+     * Playwright's config `tag`, from 1.57, which it gives every test before its own tags; null when the scan can't work
+     * it out. That is reported where the config writes `tag`; a config whose settings come from code the scan can't
+     * follow is reported there already, as its projects can't be worked out either.
+     */
+    configTags(config) {
+        if (config === null || this.framework !== 'playwright' || !atLeast(this.version, 1, 57))
+            return [];
+        const setting = settingAt(config.settings, ['tag']);
+        if (setting === null || isUnset(setting))
+            return [];
+        const tags = [];
+        for (const item of setting.kind === 'list' ? setting.items : [setting]) {
+            if (item.kind !== 'value' || typeof item.value !== 'string') {
+                if (config.settings.kind === 'object' && config.settings.keys.has('tag')) {
+                    this.configs.reportUnknown(unknownAt(item), 'tag', "the tests' tags leave it out");
+                }
+                return null;
+            }
+            tags.push(item.value);
+        }
+        return tags;
+    }
     /** The projects of a config the output lists; null when the scan can't work them out. */
     projectsIn(config) {
         const projects = this.projectsOf(config);
@@ -183,6 +210,7 @@ export class ConfigRuns {
             config,
             grep: null,
             grepRoot: '',
+            runsByDefault: true,
             defaults: NO_DEFAULTS,
         };
         return { config, settings: setting, about, runs: null, unknown: { setting, key } };
@@ -192,10 +220,68 @@ export class ConfigRuns {
         if (list?.kind === 'unknown')
             return [this.unknownProject(config, list, 'projects')];
         const items = list?.kind === 'list' ? list.items : [emptySettings()];
-        return items.map((project) => this.playwrightProject(config, project));
+        const running = this.runsByDefault(config, items);
+        return items.map((project) => this.playwrightProject(config, project, running.get(project)));
+    }
+    /**
+     * Whether Playwright runs each project without `--project`: from 1.64, not with `default: false`, unless a project it
+     * runs lists it in `dependencies` or `teardown`, directly or through others. Null when the scan can't tell.
+     */
+    runsByDefault(config, projects) {
+        const isRead = atLeast(this.version, 1, 64);
+        const runs = new Map(projects.map((project) => [project, !isRead]));
+        const names = projects.map((project) => playwrightName(config, project));
+        const visit = (project, value) => {
+            const current = runs.get(project);
+            if (current === true || current === value)
+                return;
+            runs.set(project, value);
+            const teardown = settingAt(project, ['teardown']);
+            const dependencies = settingAt(project, ['dependencies']);
+            const needed = strings(dependencies);
+            if (teardown?.kind === 'value' && typeof teardown.value === 'string')
+                needed.push(teardown.value);
+            // A list the scan can't work out may name any project, which then may run.
+            const unknowns = [teardown, dependencies, ...(dependencies?.kind === 'list' ? dependencies.items : [])].filter((setting) => setting?.kind === 'unknown');
+            for (const unknown of unknowns) {
+                this.configs.reportUnknown(unknown, 'projects dependencies', "the scan can't tell which projects run the tests");
+            }
+            for (const [index, other] of projects.entries()) {
+                if (needed.includes(names[index]))
+                    visit(other, value);
+                else if (unknowns.length > 0)
+                    visit(other, null);
+            }
+        };
+        // The projects that surely run go first, so that what they pull in is sure to run too.
+        for (const value of isRead ? [true, null] : []) {
+            for (const project of projects) {
+                const setting = settingAt(project, ['default']);
+                const seed = setting?.kind === 'unknown' ? null : !(setting?.kind === 'value' && setting.value === false);
+                if (seed !== value)
+                    continue;
+                if (seed === null && project.kind !== 'unknown') {
+                    this.configs.reportUnknown(setting, 'projects default', "the scan can't tell which projects run the tests");
+                }
+                visit(project, value);
+            }
+        }
+        return runs;
+    }
+    /** The name of a project a Vitest config lists, with a warning when its `test.name` can't be worked out. */
+    listedName(settings, fallback, container) {
+        const name = settingAt(settings, ['test', 'name']);
+        const label = name?.kind === 'object' ? settingAt(name, ['label']) : name;
+        // Only a name written in a config the scan reads; a config it can't read is reported as a whole.
+        const holder = name?.kind === 'object' ? name : settingAt(settings, ['test']);
+        const isWritten = holder?.kind === 'object' && [...holder.keys.values()].includes(label);
+        if (label?.kind === 'unknown' && isWritten) {
+            this.configs.reportUnknown(label, 'test.name', 'the project is named after its folder or its place in the list');
+        }
+        return vitestName(settings, fallback, container);
     }
     /** A Playwright project: its own settings, else the config's, else Playwright's defaults. */
-    playwrightProject(config, project) {
+    playwrightProject(config, project, runsByDefault) {
         if (project.kind === 'unknown')
             return this.unknownProject(config, project, 'projects');
         const take = (key) => {
@@ -249,12 +335,11 @@ export class ConfigRuns {
             greps.push((title) => expressions.some((expression) => matches(expression, title)));
         }
         const [isGrepped, isInverted] = greps;
-        const name = take('name');
         const dependencies = settingAt(project, ['dependencies']);
         // Playwright's root folder: the config's testDir, the start of each test's grep title.
         const configDir = settingAt(config.settings, ['testDir']);
         const about = {
-            name: name?.setting.kind === 'value' && typeof name.setting.value === 'string' ? name.setting.value : '',
+            name: playwrightName(config, project),
             testDir: root,
             dependencies: strings(dependencies),
             // A project's own keys, as `snapshotPathTemplate`; the config's apply to every project, and are read there.
@@ -268,6 +353,7 @@ export class ConfigRuns {
             grepRoot: configDir?.kind === 'value' && typeof configDir.value === 'string'
                 ? path.resolve(folder, configDir.value)
                 : folder,
+            runsByDefault,
             defaults: {
                 timeout: take('timeout')?.setting ?? null,
                 retry: take('retries')?.setting ?? null,
@@ -283,7 +369,7 @@ export class ConfigRuns {
             about,
             unknown: null,
             runs: (file) => {
-                if (!isInside(root, file))
+                if (runsByDefault === false || !isInside(root, file))
                     return false;
                 if (isIgnored(file) || !isMatch(file))
                     return false;
@@ -343,7 +429,11 @@ export class ConfigRuns {
         }
         return rules;
     }
-    vitestProjects(config) {
+    /**
+     * The projects of a Vitest config, the one the runner starts with or, in Vitest 5, a config another lists, whose name
+     * then goes around the names of its projects.
+     */
+    vitestProjects(config, container = null) {
         const folder = path.dirname(config.file);
         const list = settingAt(config.settings, ['test', 'projects']);
         const isVitest3 = this.version !== null && this.version[0] < 4;
@@ -354,12 +444,15 @@ export class ConfigRuns {
             // Vitest 3 takes its projects from a workspace file, which the scan doesn't read.
             return [this.unknownProject(config, { kind: 'unknown', where: null }, 'test.projects')];
         }
+        const name = container ?? vitestName(config.settings, '', null);
         if (list === null)
-            return this.vitestProject(config, config.settings, folder, null);
+            return this.vitestProject(config, config.settings, folder, null, name);
         if (list.kind !== 'list')
             return [this.unknownProject(config, unknownAt(list), 'test.projects')];
-        this.expanding.add(config);
+        this.expanding.set(config, name);
         const globs = [];
+        // Vitest names an inline project without a name after its place among the entries that aren't paths.
+        let index = 0;
         const projects = list.items.flatMap((item) => {
             if (item.kind === 'value' && typeof item.value === 'string') {
                 // `<rootDir>` is the config's folder, written with / as globs are.
@@ -368,10 +461,10 @@ export class ConfigRuns {
                 if (pattern.startsWith('!') || picomatch.scan(pattern).isGlob)
                     globs.push(pattern);
                 else
-                    return this.vitestPath(config, path.resolve(folder, pattern));
+                    return this.vitestPath(config, path.resolve(folder, pattern), container);
                 return [];
             }
-            return this.vitestEntry(config, item, folder);
+            return this.vitestEntry(config, item, folder, String(index++), container);
         });
         const matches = globs.length
             ? globSync(globs, {
@@ -383,12 +476,15 @@ export class ConfigRuns {
                 ignore: ['**/node_modules/**'],
             })
             : [];
-        projects.push(...matches.flatMap((match) => this.vitestPath(config, path.resolve(match))));
+        projects.push(...matches.flatMap((match) => this.vitestPath(config, path.resolve(match), container)));
         this.expanding.delete(config);
         return projects;
     }
-    /** A project written in `test.projects`, which inherits the root config as each version of Vitest decides. */
-    vitestEntry(config, entry, folder) {
+    /**
+     * A project written in `test.projects`, which inherits the root config as each version of Vitest decides, named
+     * after `index` when it has no name of its own.
+     */
+    vitestEntry(config, entry, folder, index, container) {
         if (entry.kind !== 'object') {
             // A function or a promise, read by running the config, or a setting of the wrong type.
             return [this.unknownProject(config, unknownAt(entry), 'test.projects')];
@@ -401,31 +497,40 @@ export class ConfigRuns {
         else if (extended?.kind === 'value' ? extended.value === true : this.version === null || this.version[0] >= 5) {
             base = withoutProjects(config.settings);
         }
-        // Vitest 5 takes a project's own tags in place of those it extends.
-        const ownTags = atLeast(this.version, 5, 0) ? settingAt(entry, ['test', 'tags']) : null;
-        return this.vitestProject(config, mergeDeep(base, entry), folder, ownTags);
+        const isVitest5 = atLeast(this.version, 5, 0);
+        // Vitest 5 takes a project's own tags in place of those it extends, and doesn't pass on the name.
+        const ownTags = isVitest5 ? settingAt(entry, ['test', 'tags']) : null;
+        const settings = mergeDeep(base, entry);
+        const name = this.listedName(isVitest5 ? entry : settings, index, container);
+        return this.vitestProject(config, settings, folder, ownTags, name);
     }
     /**
      * The projects of a config file or folder `test.projects` names: the config's own, also the projects it lists in
-     * Vitest 5, or a project with Vitest's defaults for a folder without a config.
+     * Vitest 5, or a project with Vitest's defaults for a folder without a config. Without a name, a project is named
+     * after the package.json in its folder, else the folder.
      */
-    vitestPath(config, target) {
+    vitestPath(config, target, container) {
         const nested = VITEST_CONFIG.test(path.basename(target)) ? this.configs.at(target) : this.configs.inFolder(target);
+        const folder = nested ? path.dirname(nested.file) : target;
+        // A config that lists itself also runs as a project, under its own name.
+        const listing = nested && this.expanding.get(nested);
+        const fallback = packageName(folder) ?? path.basename(folder);
+        const name = listing ?? this.listedName(nested?.settings ?? emptySettings(), fallback, container);
         if (!nested)
-            return this.vitestProject(config, emptySettings(), target, null);
-        const isContainer = (this.version === null || this.version[0] >= 5) && !this.expanding.has(nested);
+            return this.vitestProject(config, emptySettings(), target, null, name);
+        const isContainer = (this.version === null || this.version[0] >= 5) && listing === undefined;
         const projects = isContainer && settingAt(nested.settings, ['test', 'projects'])
-            ? this.vitestProjects(nested)
-            : this.vitestProject(nested, nested.settings, path.dirname(nested.file), null);
+            ? this.vitestProjects(nested, name)
+            : this.vitestProject(nested, nested.settings, folder, null, name);
         // The outermost config lists the others, so it is set last.
         return projects.map((project) => ({ ...project, about: { ...project.about, container: config } }));
     }
     /**
-     * A Vitest project: its files are found from `test.dir`, else `test.root` or `root`, else its folder. With browser
-     * mode on, each of `browser.instances` is a project of its own, named as Vitest names it.
+     * A Vitest project, with the name Vitest gives it: its files are found from `test.dir`, else `test.root` or `root`,
+     * else its folder. With browser mode on, each of `browser.instances` is a project of its own, named as Vitest names it.
      */
-    vitestProject(config, settings, folder, ownTags) {
-        const project = this.vitestFiles(config, settings, folder, ownTags);
+    vitestProject(config, settings, folder, ownTags, name) {
+        const project = this.vitestFiles(config, settings, folder, ownTags, name);
         if (project.unknown)
             return [project];
         const enabled = settingAt(settings, ['test', 'browser', 'enabled']);
@@ -448,7 +553,7 @@ export class ConfigRuns {
         });
     }
     /** The files a Vitest project runs and its settings; `ownTags`, when set, in place of the tags in `settings`. */
-    vitestFiles(config, settings, folder, ownTags) {
+    vitestFiles(config, settings, folder, ownTags, name) {
         let root = folder;
         let dir = null;
         let hasTestRoot = false;
@@ -500,10 +605,8 @@ export class ConfigRuns {
             flags.push(setting?.kind === 'value' && setting.value === true);
         }
         const [checksTypes, onlyTypes] = flags;
-        const name = settingAt(settings, ['test', 'name']);
-        const label = name?.kind === 'object' ? settingAt(name, ['label']) : name;
         const about = {
-            name: label?.kind === 'value' && typeof label.value === 'string' ? label.value : '',
+            name,
             testDir: base,
             dependencies: [],
             settings,
@@ -512,6 +615,7 @@ export class ConfigRuns {
             config,
             grep: null,
             grepRoot: base,
+            runsByDefault: true,
             defaults: {
                 timeout: settingAt(settings, ['test', 'testTimeout']),
                 retry: this.vitestRetry(settingAt(settings, ['test', 'retry'])),
@@ -548,12 +652,41 @@ function matches(expression, text) {
     expression.lastIndex = 0;
     return expression.test(text);
 }
+/** A Playwright project's name: its own, else the config's, else empty. */
+function playwrightName(config, project) {
+    for (const setting of [settingAt(project, ['name']), settingAt(config.settings, ['name'])]) {
+        if (setting && !isUnset(setting)) {
+            return setting.kind === 'value' && typeof setting.value === 'string' ? setting.value : '';
+        }
+    }
+    return '';
+}
 /** The strings of a list setting, such as Playwright's `dependencies`; none for anything else. */
+/**
+ * A Vitest project's name: its `test.name`, or the name's `label`, else `fallback`; in Vitest 5, inside the name of the
+ * config that lists it, as `web (unit)`.
+ */
+function vitestName(settings, fallback, container) {
+    const name = settingAt(settings, ['test', 'name']);
+    const label = name?.kind === 'object' ? settingAt(name, ['label']) : name;
+    const own = (label?.kind === 'value' && typeof label.value === 'string' && label.value) || fallback;
+    return container === null ? own : `${container} (${own})`;
+}
 function strings(setting) {
     if (setting?.kind !== 'list')
         return [];
     return setting.items.flatMap((item) => (item.kind === 'value' && typeof item.value === 'string' ? [item.value] : []));
 }
+/** The `name` of the package.json in a folder; null without one, or when it has none. */
+function packageName(folder) {
+    try {
+        const { name } = JSON.parse(readFileSync(path.join(folder, 'package.json'), 'utf8'));
+        return typeof name === 'string' && name !== '' ? name : null;
+    }
+    catch {
+        return null;
+    }
+}
 /** A setting written as `undefined`, which the runners take as not set. */
 function isUnset(setting) {
     return setting.kind === 'value' && setting.value === undefined;
@@ -603,20 +736,26 @@ function folders(relative) {
  * The projects that run a test: those that run its file, less those whose Playwright `grep` or `grepInvert` leaves its
  * title out, matched as Playwright matches it, against the project's name, the file's path from the config's root
  * folder, the titles of the describes and the test and their tags. Null when a `grep` meets a title the scan can't work
- * out.
+ * out, or the test is in a project the scan can't tell runs.
  */
-function projectsRunning(projects, test, suites, file) {
+function projectsRunning(projects, test, suites, file, configTags) {
     const titles = [...test.suitePath, test.title];
-    const isDynamic = test.hasDynamicTitle || suites.some((suite) => suite.hasDynamicTitle && test.suitePath.includes(suite.title));
-    // Tags written into a title are in its text already; Playwright adds the others after it.
-    const tags = test.tags.filter((tag) => !titles.some((title) => title.includes(tag)));
+    const isDynamic = test.hasDynamicTitle ||
+        configTags === null ||
+        suites.some((suite) => suite.hasDynamicTitle && test.suitePath.includes(suite.title));
+    // Tags written into a title are in its text already; Playwright adds the config's after the file, the others after it.
+    const tags = test.tags.filter((tag) => !configTags?.includes(tag) && !titles.some((title) => title.includes(tag)));
     const running = [];
     for (const project of projects) {
         const { name, grep, grepRoot } = project;
         if (grep && isDynamic)
             return null;
-        if (!grep || grep([name, path.relative(grepRoot, file), ...titles, ...tags].join(' ')))
-            running.push(project);
+        const text = [name, path.relative(grepRoot, file), ...(configTags ?? []), ...titles, ...tags].join(' ');
+        if (grep && !grep(text))
+            continue;
+        if (project.runsByDefault === null)
+            return null;
+        running.push(project);
     }
     return running;
 }
@@ -782,7 +921,7 @@ export function fileConfig(placement, framework, version, file) {
     if (config === null) {
         // Without a config, Vitest defines no tags and keeps strictTags on.
         const tags = vitestTags(null, null, null, atLeast(version, 5, 0));
-        return framework === 'vitest' ? { forbidOnly: false, forTest: () => NO_CONFIG, tags } : null;
+        return framework === 'vitest' ? { forbidOnly: false, forTest: () => NO_CONFIG, tags, configTags: [] } : null;
     }
     const forbidOnly = framework === 'playwright' ? settingAt(config.settings, ['forbidOnly']) : null;
     return {
@@ -792,11 +931,12 @@ export function fileConfig(placement, framework, version, file) {
         forTest(test, suites) {
             if (projects === null)
                 return { projects: null, defaults: UNKNOWN_DEFAULTS };
-            const running = projectsRunning(projects, test, suites, file);
+            const running = projectsRunning(projects, test, suites, file, placement.tags);
             // A grep the scan can't match leaves the projects that run the file, which may still agree.
             return { projects: running?.map(({ name }) => name) ?? null, defaults: configDefaults(running ?? projects) };
         },
         tags: agreedTags(projects),
+        configTags: placement.tags ?? [],
     };
 }
 /** The tags the projects that run a file define, when they all define the same; null otherwise. */

package/dist/config.js

@@ -140,6 +140,68 @@ function spread(base, over, at) {
         return { kind: 'object', keys: new Map(over.keys), rest: over.rest };
     return { kind: 'object', keys: new Map([...base.keys, ...over.keys]), rest: base.rest };
 }
+/** `{ ...a, ...b }` of two objects either of which may be unset, as Playwright merges `use` and `expect`. */
+function assign(a, b, at) {
+    return [a, b].reduce((merged, over) => (over ? spread(merged, over, at) : merged), emptyObject());
+}
+/**
+ * Playwright's `defineConfig(base, over)`: `over`'s keys replace `base`'s, but `expect`, `use` and `build` merge key by
+ * key, and `projects` by name. `webServer`, whose lists Playwright joins, isn't read.
+ */
+function playwrightMerge(base, over, at) {
+    const merged = spread(base, over, at);
+    if (over.kind !== 'object' || over.rest)
+        return merged;
+    for (const key of ['expect', 'use', 'build']) {
+        if (merged.keys.has(key))
+            merged.keys.set(key, assign(child(base, key), child(over, key), at));
+    }
+    const overrides = child(over, 'projects');
+    // Without projects of its own, `over` keeps those of `base`; with `projects: undefined`, it drops them.
+    if (overrides === null || isNullish(overrides))
+        return merged;
+    const projects = child(base, 'projects');
+    const items = projects === null || isNullish(projects) ? [] : projects.kind === 'list' ? projects.items : null;
+    const isKnown = items !== null && overrides.kind === 'list';
+    merged.keys.set('projects', isKnown ? mergeProjects(items, overrides.items, at) : unknown(at));
+    return merged;
+}
+/**
+ * Playwright's projects of a config with those of a config over it merged in by name, with their `use` key by key; the
+ * others are added after, the last of each name. Unknown when the scan can't tell a project's name.
+ */
+function mergeProjects(base, overrides, at) {
+    const byName = new Map();
+    for (const project of overrides) {
+        const name = projectName(project);
+        if (name === null)
+            return unknown(at);
+        byName.set(name, project);
+    }
+    const projects = [];
+    for (const project of base) {
+        const name = projectName(project);
+        if (name === null)
+            return unknown(at);
+        const override = byName.get(name);
+        byName.delete(name);
+        if (!override) {
+            projects.push(project);
+            continue;
+        }
+        const merged = spread(spread(emptyObject(), project, at), override, at);
+        merged.keys.set('use', assign(child(project, 'use'), child(override, 'use'), at));
+        projects.push(merged);
+    }
+    return { kind: 'list', items: [...projects, ...byName.values()] };
+}
+/** The name Playwright merges a project by: undefined when unset, null when the scan can't tell. */
+function projectName(project) {
+    const name = child(project, 'name');
+    if (name === null || (name.kind === 'value' && name.value === undefined))
+        return undefined;
+    return name.kind === 'value' && typeof name.value === 'string' ? name.value : null;
+}
 /**
  * One of two settings, as the two sides of a condition: what both agree on is known, and the rest is unknown at `at`,
  * where the condition is written. Null is a setting neither side sets.
@@ -479,9 +541,9 @@ class ConfigCode {
             // Vitest's defineConfig() and defineProject() return the config they are given, or the one a function returns.
             return isFunctionNode(args[0]) ? this.returned(args[0], frame, scopes) : this.evaluate(args[0], frame, scopes);
         }
-        // Playwright's defineConfig() merges the configs it is given, each over the ones before it. It also merges their
-        // `use`, `expect`, `build`, `webServer` and `projects`, which the scan doesn't read yet.
-        return args.reduce((merged, arg) => spread(merged, this.evaluate(arg, frame, scopes), { frame, node: arg }), emptyObject());
+        // Playwright's defineConfig() merges the configs it is given, each over the ones before it.
+        const [first, ...others] = args;
+        return others.reduce((merged, arg) => playwrightMerge(merged, this.evaluate(arg, frame, scopes), { frame, node: arg }), spread(emptyObject(), this.evaluate(first, frame, scopes), { frame, node: first }));
     }
     /**
      * Where a function a config calls comes from: `name` of `import { name } from 'module'` or

package/dist/dependency-hash.d.ts

@@ -2,17 +2,20 @@ import { type Node } from 'oxc-parser';
 import type { ConfigGap, RunsWith } from './config-dependencies.ts';
 import type { Extraction, Frame, PendingTest } from './extract.ts';
 import type { ModuleReader, ModuleSource, Problem, Span } from './model.ts';
-import type { ParsedFile } from './parse.ts';
+import { type ParsedFile } from './parse.ts';
 import { type SourceText } from './source.ts';
 import type { Framework } from './types.ts';
 import { Values } from './values.ts';
 /** A file whose code a test can run: the scanned file, a module it imports, or a data file such as JSON. */
 interface Module {
     relativeFilePath: string;
-    /** Null for a file that isn't JavaScript or TypeScript, which is taken by its text. */
+    /** Null for a file that isn't JavaScript or TypeScript, which is taken by its text; for a component, its scripts. */
     parsed: ParsedFile | null;
-    /** The file's text with line endings read as `\n`, for a file that isn't code. */
-    text: string | null;
+    /**
+     * The file's text with line endings read as `\n`, for a file that isn't code or a component; its bytes when it isn't
+     * UTF-8 text, such as an image.
+     */
+    text: string | Uint8Array | null;
     values: Values;
     readModule: ModuleReader | null;
     /** Its top-level code that runs when it is imported, and the modules it imports, which run then too. */
@@ -191,6 +194,11 @@ export declare class DependencyGraph {
      * takes the whole module, so that nothing it may run is left out.
      */
     private exported;
+    /**
+     * A name a module passes on from another, as `export { quote } from './nasdaq'` does, with the re-export itself: which
+     * module the name comes from is code too, so the barrel is among the files a change to which affects the test.
+     */
+    private passedOn;
     /** What `export * from source` gives for a name; null when the module behind it doesn't export it. */
     private reexported;
     /**