@cplieger/deadset-ts 5.1.0 → 5.1.1

package/README.md

@@ -90,7 +90,7 @@ A TypeScript caller that imports the source sets `allowImportingTsExtensions`, b
 
 ## Related projects
 
-deadset-ts implements the [deadset Contract](https://github.com/cplieger/deadset-spec), which fixes the issue codes, the report schema and the exit codes. It passes every fixture of the Contract's conformance corpus except one reflective-lookup fixture, the gap [`conformance.json`](conformance.json) declares.
+deadset-ts implements the [deadset Contract](https://github.com/cplieger/deadset-spec), which fixes the issue codes, the report schema and the exit codes. It passes every fixture of the Contract's conformance corpus.
 
 - [deadset-go](https://github.com/cplieger/deadset-go) is the same analysis for Go modules.
 - [deadset](https://github.com/cplieger/deadset) runs both analyzers as one command and merges their reports, resolving the edges between Go and TypeScript code.

package/dist/src/analysis.js

@@ -19,8 +19,9 @@ import { readEdgeSides } from "./edges.js";
 import { enumGroup } from "./enum-group.js";
 import { generatedFile } from "./generated-file.js";
 import { sourceFilesOf } from "./source-files.js";
-import { detectExemptions, disabledClasses, exemptionsOf, holdingWhile, isUnansweredRecord, retainedIn, } from "./exempt.js";
-import { heldByInclusion, sourceTree } from "./file-facts.js";
+import { evidenceRecords, heldRecords, disabledClasses, exemptionsOf, holdingWhile, isUnansweredRecord, retainedIn, } from "./exempt.js";
+import { heldByInclusion, sourcePaths, sourceTree } from "./file-facts.js";
+import { globExpression } from "./glob.js";
 import { findingsPass, recordedFindings, rowKey } from "./findings-pass.js";
 import { NO_SELF_CHECK, unmatchedRootFindings, } from "./findings/self-check.js";
 import { frameworkLifecycle } from "./framework-lifecycle.js";
@@ -29,9 +30,9 @@ import { injectionContainer } from "./injection-container.js";
 import { interfaceSatisfaction } from "./interface-satisfaction.js";
 import { intraFunctionFacts, projectParts } from "./intra-function-parts.js";
 import { inventory } from "./inventory.js";
-import { readManifest } from "./manifest.js";
+import { packageEntries, readManifest } from "./manifest.js";
 import { liveFilesAt, matrixOf, referenceKey, sweepMatrix, } from "./matrix.js";
-import { joinPath, relativePath, resolvePath } from "./paths.js";
+import { joinPath, normalizePath, relativePath, resolvePath } from "./paths.js";
 import { byPosition, isComponentFile } from "./position.js";
 import { SetupError, setupLine } from "./setup-failure.js";
 import { pathsOf, readErrors, skippedRoots, skippedUnits, } from "./type-errors.js";
@@ -39,6 +40,7 @@ import { reflectiveLookup } from "./reflective-lookup.js";
 import { references, testFileRulesOf } from "./references.js";
 import { roots, unmatchedEverywhere } from "./roots.js";
 import { serializationContract } from "./serialization-contract.js";
+import { outsideTestReferences, testFilesAt } from "./outside-tests.js";
 import { supportReferences, testSupportFiles } from "./test-support.js";
 import { diagnosticsOf, ownedAs, runSession } from "./session.js";
 import { accessorsOf, storesOf } from "./stores.js";
@@ -107,7 +109,10 @@ function readProjects(engine, host, scope, config, stage) {
     const options = {
         host,
         manifest: workspace?.manifest ?? readManifest(host, targetRoot),
-        workspaceEntries: workspace?.entries,
+        otherPackages: [
+            ...(workspace?.entries ?? []),
+            ...packageEntries(host, normalizePath(absoluteRoot), discovered.configFiles, new Set(workspace?.memberDirs ?? [])),
+        ],
         patterns: config.rootPatterns,
         entryFiles: config.ts.entryFiles,
         conventions,
@@ -127,6 +132,8 @@ function readProjects(engine, host, scope, config, stage) {
     const unbuildable = [];
     const setupDropped = [];
     const consumed = new Map();
+    const heldFiles = new Set();
+    let outsideTests = [];
     const setupMet = (configFile, met) => {
         const [first] = met;
         if (first !== undefined && isGuess(discovered, configFile)) {
@@ -231,8 +238,14 @@ function readProjects(engine, host, scope, config, stage) {
                 generated: generatedFiles(conventions, sourceFilesOf(project, targetRoot)),
             };
         };
+        for (const file of project.ownSourceFiles()) {
+            heldFiles.add(relativePath(absoluteRoot, file.fileName) ?? file.fileName);
+        }
         return stage(project, { configuration, read });
-    }, discovered.derived ? "record" : "refuse", workspace?.programs);
+    }, discovered.derived ? "record" : "refuse", workspace?.programs, () => {
+        const patterns = config.ts.testFiles.map(globExpression);
+        outsideTests = testFilesAt(host, targetRoot, sourcePaths(host, targetRoot).filter((path) => !heldFiles.has(path) && patterns.some((pattern) => pattern.test(path))), options.parse);
+    });
     for (const configFile of session.unopened) {
         if (consumerOf.has(configFile) || !isGuess(discovered, configFile)) {
             throw new DiscoveryError(`${configFile} opened no project`, []);
@@ -263,6 +276,7 @@ function readProjects(engine, host, scope, config, stage) {
         unanswered: session.unanswered,
         componentsUnread: workspace?.componentsUnread ?? [],
         conventionsApplied: conventions.applied,
+        outsideTests,
     };
 }
 /**
@@ -351,8 +365,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         const resolved = references(project, projectRead.held, targetRoot, {
             testFiles: config.ts.testFiles,
         });
-        const support = testSupportFiles(projectRead.held.symbols, resolved.references, projectRead.rooted.liveUnderReachability, resolved.testFilePaths);
-        const detected = detectExemptions({
+        const evidence = evidenceRecords({
             project,
             held: projectRead.held,
             targetRoot,
@@ -362,52 +375,78 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
             ...(config.analysis.generatedFiles === "include"
                 ? {}
                 : { generated: projectRead.generated }),
-        }, detectors, {
+        }, detectors, disabled);
+        const components = project.ownSourceFiles().filter(isComponentFile);
+        const pathOf = (file) => relativePath(targetRoot, file.fileName) ?? file.fileName;
+        return {
+            projectRead,
+            references: resolved.references,
+            testFiles: resolved.testFilePaths,
+            evidence,
+            componentFiles: components.map(pathOf),
+            componentWarnings: components.flatMap((file) => readComponent(file.originalText).warnings.map((warning) => ({
+                path: pathOf(file),
+                line: lineOf(file.originalText, warning.offset),
+                reason: warning.reason,
+            }))),
+            extra: extra(project, projectRead, resolved.references),
+        };
+    });
+    const outsidePaths = read.outsideTests.map((one) => one.path);
+    const withOutside = read.answers.map((one) => ({
+        ...one,
+        references: [
+            ...one.references,
+            ...outsideTestReferences(read.outsideTests, one.projectRead.held, targetRoot),
+        ],
+        testFiles: [...one.testFiles, ...outsidePaths],
+    }));
+    // Test-support code is code only test code imports in any configuration of the run: a
+    // configuration that holds no test file says nothing about what the tests import.
+    const support = testSupportFiles(withOutside.flatMap((one) => one.projectRead.held.symbols), withOutside.flatMap((one) => one.references), withOutside.flatMap((one) => one.projectRead.rooted.liveUnderReachability), withOutside.flatMap((one) => one.testFiles));
+    const answers = withOutside.map((one) => {
+        const { projectRead } = one;
+        const detected = heldRecords(one.evidence, {
             disabled,
             mode,
-            testFiles: new Set([...resolved.testFilePaths, ...support]),
+            testFiles: new Set([...one.testFiles, ...support]),
         });
         const exempt = detected.records;
-        const made = supportReferences(resolved.references, support);
+        const made = supportReferences(one.references, support);
+        const held = new Set(projectRead.held.symbols.map((symbol) => symbol.position.path));
+        const supportFiles = [...support].filter((path) => held.has(path)).sort();
         const configured = {
             configuration: projectRead.configuration,
             symbols: projectRead.held.symbols,
             references: [...made, ...evidenceReferences(projectRead.held.symbols, detected.inTestFiles)],
             roots: projectRead.rooted.liveUnderReachability,
-            testFiles: resolved.testFilePaths,
-            ...(support.size === 0 ? {} : { supportFiles: [...support].sort() }),
+            testFiles: one.testFiles,
+            ...(supportFiles.length === 0 ? {} : { supportFiles }),
             ...(projectRead.referenceOnly.length === 0
                 ? {}
                 : { referenceOnly: projectRead.referenceOnly }),
         };
-        const unanswered = [
-            ...projectRead.held.unanswered,
-            ...projectRead.rooted.unanswered,
-            ...made
-                .filter((reference) => reference.resolution === "by-name")
-                .map((reference) => reference.to),
-            ...exempt.filter(isUnansweredRecord).map((record) => record.id),
-        ];
-        const components = project.ownSourceFiles().filter(isComponentFile);
-        const pathOf = (file) => relativePath(targetRoot, file.fileName) ?? file.fileName;
         return {
             configFile: projectRead.configFile,
             configured,
             exempt,
-            unanswered,
+            unanswered: [
+                ...projectRead.held.unanswered,
+                ...projectRead.rooted.unanswered,
+                ...made
+                    .filter((reference) => reference.resolution === "by-name")
+                    .map((reference) => reference.to),
+                ...exempt.filter(isUnansweredRecord).map((record) => record.id),
+            ],
             typeErrorSkips: projectRead.typeErrorSkips,
             skipped: projectRead.skipped,
-            componentFiles: components.map(pathOf),
-            componentWarnings: components.flatMap((file) => readComponent(file.originalText).warnings.map((warning) => ({
-                path: pathOf(file),
-                line: lineOf(file.originalText, warning.offset),
-                reason: warning.reason,
-            }))),
-            extra: extra(project, projectRead, made),
+            componentFiles: one.componentFiles,
+            componentWarnings: one.componentWarnings,
+            extra: one.extra,
         };
     });
     const consumed = read.consumers.references;
-    const projects = read.answers.map((one) => consumed.length === 0
+    const projects = answers.map((one) => consumed.length === 0
         ? one
         : {
             ...one,
@@ -421,7 +460,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         exempt: exemptionsOf(projects.flatMap((one) => one.exempt)),
         unansweredHeld: [
             ...new Set([
-                ...read.answers.flatMap((one) => one.unanswered),
+                ...answers.flatMap((one) => one.unanswered),
                 ...consumed.filter((one) => one.resolution === "by-name").map((one) => one.to),
             ]),
         ],

package/dist/src/configuration-files.js

@@ -39,7 +39,7 @@ const COUNTERPARTS = [
 /** The extensions appended to a relative specifier from a configuration file, in order. */
 const APPENDED = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
 /** The extensions the program's module resolution appends to a specifier written without one. */
-const RESOLVED_EXTENSIONS = [
+export const RESOLVED_EXTENSIONS = [
     ".ts",
     ".tsx",
     ".d.ts",

package/dist/src/contextual-uses.js

@@ -32,8 +32,6 @@ function propertyName(property) {
     }
     return undefined;
 }
-/** How many element and signature steps the structural walk takes below a value's own type. */
-const MAX_DEPTH = 3;
 /**
  * The contextual uses of one project's literals and values, asked in batches: one
  * contextual type per literal and per value whose type carries a member of the target,
@@ -154,14 +152,15 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
      * Each object type a value of `source` is checked as against the object types of
      * `target`: the value's own, and through array elements and through a function's
      * parameters, checked the other way, and its result. A source that is one of the
-     * target's own object types matches it as it stands.
+     * target's own object types matches it as it stands. Each pair is compared once, which
+     * ends the walk over a recursive type.
      */
-    const compared = (source, target, depth, into, seen) => {
+    const compared = (source, target, into, seen) => {
         const key = `${String(source?.id)}>${String(target?.id)}`;
         if (source === undefined || target === undefined || source.id === target.id) {
             return;
         }
-        if (depth > MAX_DEPTH || seen.has(key)) {
+        if (seen.has(key)) {
             return;
         }
         seen.add(key);
@@ -175,7 +174,7 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
             const called = element === undefined ? callOf(one) : undefined;
             for (const part of targets) {
                 if (element !== undefined) {
-                    compared(element, elementOf(part), depth + 1, into, seen);
+                    compared(element, elementOf(part), into, seen);
                     continue;
                 }
                 const other = called === undefined ? undefined : callOf(part);
@@ -183,27 +182,35 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
                     continue;
                 }
                 other.parameters.forEach((parameter, index) => {
-                    compared(parameter, called.parameters[index], depth + 1, into, seen);
+                    compared(parameter, called.parameters[index], into, seen);
                 });
-                compared(called.result, other.result, depth + 1, into, seen);
+                compared(called.result, other.result, into, seen);
             }
         }
     };
-    /** Whether a value of one type may carry a member a position reads, at any depth the walk takes. */
-    const mayCarry = (type, depth) => depth <= MAX_DEPTH &&
-        partsOf(type).some((part) => {
+    /**
+     * Whether a value of one type may carry a member a position reads, at any depth the
+     * walk takes. A type met again on the way adds nothing its first visit did not.
+     */
+    const mayCarry = (type, seen = new Set()) => {
+        if (seen.has(type.id)) {
+            return false;
+        }
+        seen.add(type.id);
+        return partsOf(type).some((part) => {
             if (carries(part)) {
                 return true;
             }
             const element = elementOf(part);
             if (element !== undefined) {
-                return mayCarry(element, depth + 1);
+                return mayCarry(element, seen);
             }
             return callOf(part) !== undefined;
         });
+    };
     const sourced = carried.flatMap((flow, index) => {
         const type = types[index];
-        return type === undefined || !isAnswered(type) || !mayCarry(type, 0) ? [] : [{ flow, type }];
+        return type === undefined || !isAnswered(type) || !mayCarry(type) ? [] : [{ flow, type }];
     });
     batches += batchesOf(sourced.length);
     const positions = queries.contextualTypes(sourced.map((one) => one.flow.value), cap);
@@ -214,7 +221,7 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
             return;
         }
         const checked = [];
-        compared(type, position, 0, checked, new Set());
+        compared(type, position, checked, new Set());
         const ids = new Set();
         for (const { source, targets } of checked) {
             const tables = targets.map(membersOf);

package/dist/src/exempt.js

@@ -92,12 +92,18 @@ export function computeExemptions(input, detectors, holding) {
 }
 /** The records of {@link computeExemptions}, beside the test-file evidence it set aside. */
 export function detectExemptions(input, detectors, holding) {
+    return heldRecords(evidenceRecords(input, detectors, holding.disabled), holding);
+}
+/**
+ * Every record one project's detectors found, one per piece of evidence, before the
+ * mode decides which of them hold: what {@link heldRecords} reads.
+ */
+export function evidenceRecords(input, detectors, disabled) {
     const visibility = new Map(input.held.symbols.map((symbol) => [symbol.id, symbol.visibility]));
     const found = [];
-    const inTestFiles = [];
     for (const exemptionClass of TS_EXEMPTION_CLASSES) {
         const detect = detectors.get(exemptionClass);
-        if (detect === undefined || holding.disabled.has(exemptionClass)) {
+        if (detect === undefined || disabled.has(exemptionClass)) {
             continue;
         }
         const allowed = typescriptVisibilityOf(exemptionClass);
@@ -105,17 +111,26 @@ export function detectExemptions(input, detectors, holding) {
             if (!retainable(allowed, visibility.get(evidence.id))) {
                 continue;
             }
-            const record = {
+            found.push({
                 id: evidence.id,
                 class: exemptionClass,
                 detail: evidence.detail,
                 site: evidence.site,
                 ...(evidence.whileLive === undefined ? {} : { whileLive: evidence.whileLive }),
-            };
-            if (holding.mode.production && holding.testFiles.has(evidence.site.path)) {
-                inTestFiles.push(record);
-                continue;
-            }
+            });
+        }
+    }
+    return found;
+}
+/** The records that hold under one mode, beside the evidence a production mode found in a test file. */
+export function heldRecords(records, holding) {
+    const found = [];
+    const inTestFiles = [];
+    for (const record of records) {
+        if (holding.mode.production && holding.testFiles.has(record.site.path)) {
+            inTestFiles.push(record);
+        }
+        else {
             found.push(record);
         }
     }

package/dist/src/file-facts.js

@@ -26,12 +26,10 @@ function lastLine(text) {
     return line;
 }
 /**
- * Every source file below the target root, in path order. A directory that cannot be
- * read is skipped, as discovery skips it, and a file that cannot be read is skipped
- * with it: a tree the analysis may not enter holds no file it can report.
+ * The path below the target root of every source file there, in path order. A directory
+ * that cannot be read is skipped, as discovery skips it.
  */
-export function sourceTree(host, targetRoot) {
-    const scopeOf = packageScope(host, targetRoot);
+export function sourcePaths(host, targetRoot) {
     const found = [];
     const pending = [""];
     for (let dir = pending.pop(); dir !== undefined; dir = pending.pop()) {
@@ -50,24 +48,29 @@ export function sourceTree(host, targetRoot) {
                 }
                 continue;
             }
-            if (!SOURCE_FILE.test(entry.name) || DECLARATION_FILE.test(entry.name)) {
-                continue;
-            }
-            let text;
-            try {
-                text = host.readFile(joinPath(targetRoot, path));
+            if (SOURCE_FILE.test(entry.name) && !DECLARATION_FILE.test(entry.name)) {
+                found.push(path);
             }
-            catch {
-                continue;
-            }
-            found.push({
-                path,
-                ref: renderRef(scopeOf(path), { of: "module" }),
-                endLine: lastLine(text),
-            });
         }
     }
-    return found.sort((a, b) => (a.path < b.path ? -1 : 1));
+    return found.sort((a, b) => (a < b ? -1 : 1));
+}
+/**
+ * Every source file below the target root, in path order. A file that cannot be read is
+ * skipped: a tree the analysis may not enter holds no file it can report.
+ */
+export function sourceTree(host, targetRoot) {
+    const scopeOf = packageScope(host, targetRoot);
+    return sourcePaths(host, targetRoot).flatMap((path) => {
+        let text;
+        try {
+            text = host.readFile(joinPath(targetRoot, path));
+        }
+        catch {
+            return [];
+        }
+        return [{ path, ref: renderRef(scopeOf(path), { of: "module" }), endLine: lastLine(text) }];
+    });
 }
 /** Whether one file changes what the program sees by being included in it. */
 function actsByInclusion(file) {

package/dist/src/graph.js

@@ -94,7 +94,7 @@ export function graphOf(symbols, references, roots, testFiles, supportFiles = []
             }
         }
         const edge = { to, test: reference.test, evaluation: reference.use === "evaluation" };
-        if (reference.consumer !== undefined) {
+        if (reference.consumer !== undefined || reference.unheld === true) {
             consumed.push(edge);
             continue;
         }

package/dist/src/inventory.js

@@ -213,7 +213,18 @@ function nameNodeOf(node) {
  * needs the declaration this enumeration made for it.
  */
 export function nodeKey(file, node) {
-    return `${file.fileName}:${String(node.pos)}:${String(node.end)}`;
+    return `${file.fileName}:${String(node.pos)}:${String(node.end)}:${String(node.kind)}`;
+}
+/** `export default`, up to the keyword that stands where an unnamed default export's name would. */
+const DEFAULT_EXPORT = /^export\s+(?=default\b)/u;
+/**
+ * Where an unnamed declaration is placed: at `default` when it is the default export, so it
+ * never shares the file's own position, else at its first token.
+ */
+function unnamedStart(node) {
+    const start = node.getStart();
+    const prefix = DEFAULT_EXPORT.exec(node.getText());
+    return prefix === null ? start : start + prefix[0].length;
 }
 /** The kind a class element takes: a method, or a property or accessor. */
 function classMemberKind(node) {
@@ -287,12 +298,11 @@ export function inventory(project, host, targetRoot) {
         }
     }
     function declare(node, owner, kind, name, named) {
-        const at = name ?? node;
         const record = keep({
             file: owner.file,
             node,
             module: owner.module,
-            position: renderPosition(owner.file, targetRoot, at.getStart()),
+            position: renderPosition(owner.file, targetRoot, name?.getStart() ?? unnamedStart(node)),
             endLine: renderPosition(owner.file, targetRoot, Math.max(node.end - 1, 0)).line,
             kind,
             parentChain: owner.kind === "file" ? [] : chainOf(owner),

package/dist/src/manifest.js

@@ -1,11 +1,10 @@
 /**
  * The entry points a package manifest names, which are roots because something
  * outside the analyzed program reaches them: a consumer importing the package, or a
- * shell running its command or one of its scripts.
- *
- * One call reads one manifest, the one in the directory it is given.
+ * shell running its command or one of its scripts. {@link readManifest} reads one
+ * directory's manifest, {@link packageEntries} those of the packages below the target root.
  */
-import { isAbsolutePath, joinPath, resolvePath } from "./paths.js";
+import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
 /** The manifest's own name. */
 const MANIFEST = "package.json";
 /** The three members that name an entry point beside `exports` and `bin`. */
@@ -144,3 +143,29 @@ export function readManifest(host, targetRoot) {
         declaresExports: manifest["exports"] !== undefined,
     };
 }
+/**
+ * The entry points every package manifest between the target root and each compiler
+ * configuration names: each directory holding a `package.json` that a configuration sits
+ * in or below, the target root and `known` excluded, whose manifests the run reads
+ * otherwise. Each entry is spelled under its manifest's path below the target root, and
+ * is published by its own manifest's rule, as the target's own entries are.
+ */
+export function packageEntries(host, targetRoot, configFiles, known) {
+    const dirs = new Set();
+    for (const configFile of configFiles) {
+        for (let dir = dirnamePath(resolvePath(targetRoot, configFile)); dir !== targetRoot && relativePath(targetRoot, dir) !== undefined; dir = dirnamePath(dir)) {
+            if (!known.has(dir) && host.kindOf(joinPath(dir, MANIFEST)) === "file") {
+                dirs.add(dir);
+            }
+        }
+    }
+    return [...dirs].sort().flatMap((dir) => {
+        const manifest = readManifest(host, dir);
+        const where = `${relativePath(targetRoot, dir) ?? dir}/${MANIFEST}`;
+        return manifest.entries.map((entry) => ({
+            ...entry,
+            member: `${where} ${entry.member}`,
+            published: entry.published && (!manifest.declaresExports || entry.member.startsWith("exports")),
+        }));
+    });
+}

package/dist/src/outside-tests.js

@@ -0,0 +1,139 @@
+/**
+ * The test files no compiler configuration of a run holds. The runner executes them all
+ * the same, so each module one names is a test reference: the own file a relative
+ * specifier names, and the declarations that file exports under the names read from it.
+ * Such a file is read without a program, so what its body references beyond the modules
+ * it names is not known.
+ */
+import { isCallExpression, isExportDeclaration, isImportDeclaration, isNamespaceExport, isNamespaceImport, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { RESOLVED_EXTENSIONS } from "./configuration-files.js";
+import { emittedFrom } from "./emit-map.js";
+import { dirnamePath, joinPath, normalizePath, queriedModulePath } from "./paths.js";
+import { renderPosition } from "./position.js";
+import { nameComponent } from "./ref.js";
+/** The paths below the target root one relative specifier may name, written path first. */
+function candidates(dir, specifier) {
+    if (!specifier.startsWith("./") && !specifier.startsWith("../")) {
+        return [];
+    }
+    const path = normalizePath(dir === "" ? specifier : `${dir}/${specifier}`);
+    return [
+        path,
+        ...emittedFrom(path, { sourceDirs: [] }),
+        ...RESOLVED_EXTENSIONS.map((extension) => path + extension),
+        ...RESOLVED_EXTENSIONS.map((extension) => `${path}/index${extension}`),
+    ];
+}
+/** The text of a specifier written as literal text, or undefined for any other expression. */
+function literalText(node) {
+    return node !== undefined && (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node))
+        ? node.text
+        : undefined;
+}
+/**
+ * Every module one file names: an import declaration, a re-export, and an `import()` call
+ * of literal text anywhere in the file. A namespace form, a star re-export, a bare import
+ * and an `import()` evaluate the module.
+ */
+function modulesNamed(file) {
+    const found = [];
+    const name = (specifier, names, evaluates) => {
+        const text = literalText(specifier);
+        if (text !== undefined) {
+            found.push({ specifier, text, names, evaluates });
+        }
+    };
+    for (const statement of file.statements) {
+        if (isImportDeclaration(statement)) {
+            const clause = statement.importClause;
+            const bindings = clause?.namedBindings;
+            name(statement.moduleSpecifier, [
+                ...(clause?.name === undefined ? [] : ["default"]),
+                ...(bindings === undefined || isNamespaceImport(bindings)
+                    ? []
+                    : bindings.elements.map((one) => (one.propertyName ?? one.name).text)),
+            ], bindings === undefined ? clause?.name === undefined : isNamespaceImport(bindings));
+        }
+        else if (isExportDeclaration(statement) && statement.moduleSpecifier !== undefined) {
+            const clause = statement.exportClause;
+            const star = clause === undefined || isNamespaceExport(clause);
+            name(statement.moduleSpecifier, star ? [] : clause.elements.map((one) => (one.propertyName ?? one.name).text), star);
+        }
+    }
+    const visit = (node) => {
+        if (isCallExpression(node) && node.expression.kind === SyntaxKind.ImportKeyword) {
+            const [argument] = node.arguments;
+            if (argument !== undefined) {
+                name(argument, [], true);
+            }
+        }
+        node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+    return found;
+}
+/** Each of the given paths below the target root, parsed; one that cannot be read is skipped. */
+export function testFilesAt(host, targetRoot, paths, parse) {
+    return paths.flatMap((path) => {
+        const fileName = joinPath(targetRoot, path);
+        let text;
+        try {
+            text = host.readFile(fileName);
+        }
+        catch {
+            return [];
+        }
+        return [{ path, file: parse(fileName, text) }];
+    });
+}
+/**
+ * The references the given test files make to one project's own files through the
+ * modules they name ({@link modulesNamed}). A name read from a module references each
+ * top-level declaration the file exports under it; an evaluating form references the
+ * file. A query after the path names the file as {@link queriedModulePath} reads it.
+ */
+export function outsideTestReferences(tests, held, targetRoot) {
+    const fileAt = new Map(held.symbols
+        .filter((symbol) => symbol.kind === "file")
+        .map((symbol) => [symbol.position.path, symbol.id]));
+    // Keyed on the reference's fragment, which spells the export name where the display
+    // name of a default export is its declared name.
+    const exported = new Map();
+    for (const symbol of held.symbols) {
+        if (symbol.exported) {
+            const fragment = symbol.ref.slice(symbol.ref.lastIndexOf("#") + 1).replace(/:alias$/u, "");
+            const key = `${symbol.parent}\u0000${fragment}`;
+            exported.set(key, [...(exported.get(key) ?? []), symbol.id]);
+        }
+    }
+    const found = [];
+    for (const { path, file } of tests) {
+        const from = `${path}#`;
+        const dir = dirnamePath(path) === "." ? "" : dirnamePath(path);
+        for (const named of modulesNamed(file)) {
+            const written = named.text.includes("?") ? queriedModulePath(named.text) : named.text;
+            if (written === undefined) {
+                continue;
+            }
+            const fileId = candidates(dir, written)
+                .map((one) => fileAt.get(one))
+                .find((one) => one !== undefined);
+            if (fileId === undefined) {
+                continue;
+            }
+            const position = renderPosition(file, targetRoot, named.specifier.getStart());
+            const read = (to, use) => {
+                found.push({ from, to, position, use, resolution: "syntax", test: true, unheld: true });
+            };
+            if (named.evaluates) {
+                read(fileId, "evaluation");
+            }
+            for (const name of named.names) {
+                for (const id of exported.get(`${fileId}\u0000${nameComponent(name)}`) ?? []) {
+                    read(id, "read");
+                }
+            }
+        }
+    }
+    return found;
+}