@cplieger/deadset-ts 5.0.0 → 5.1.1

package/dist/src/references.js

@@ -1,12 +1,15 @@
-import { isArrayLiteralExpression, isBinaryExpression, isCallExpression, isDecorator, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isExpressionStatement, isExternalModuleReference, isForInStatement, isForOfStatement, isForStatement, isImportDeclaration, isImportEqualsDeclaration, isNamespaceExport, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, isVoidExpression, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isDecorator, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isExpressionStatement, isExternalModuleReference, isForInStatement, isForOfStatement, isForStatement, isImportDeclaration, isImportEqualsDeclaration, isNamespaceExport, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, isVoidExpression, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { aliasChains } from "./alias-chain.js";
+import { contextualUses } from "./contextual-uses.js";
 import { destructuring, propertyReadsOf } from "./destructuring.js";
 import { globExpression } from "./glob.js";
 import { declarationsByName, nodeKey } from "./inventory.js";
-import { relativePath } from "./paths.js";
+import { overrideReferences } from "./overrides.js";
+import { dirnamePath, queriedModulePath, relativePath, resolvePath } from "./paths.js";
 import { byPosition, isComponentFile, renderPosition } from "./position.js";
-import { DEFAULT_BATCH_CAP, UNANSWERED } from "./query.js";
+import { DEFAULT_BATCH_CAP, propertyTables, UNANSWERED } from "./query.js";
 import { typeQueryAliases } from "./type-query-alias.js";
+import { handedOn, valuesOf } from "./value-flow.js";
 /**
  * The operators whose left side one assignment stores into. A compound assignment is
  * among them: where its value is discarded it reads its target only to write the result
@@ -94,7 +97,11 @@ function markWrite(target, writes) {
         return;
     }
     if (isElementAccessExpression(held)) {
-        markWrite(held.expression, writes);
+        // A store through a member's value lands in storage every holder of the value
+        // reads, so it reads the member; a variable only ever stored into stays written.
+        if (!isPropertyAccessExpression(unparenthesized(held.expression))) {
+            markWrite(held.expression, writes);
+        }
         return;
     }
     if (isArrayLiteralExpression(held)) {
@@ -194,6 +201,19 @@ function evaluatedBy(node) {
     }
     return undefined;
 }
+/**
+ * The own file a module specifier with a query evaluates ({@link queriedModulePath}): the
+ * checker resolves the whole specifier to whatever module declaration matches it.
+ */
+function queriedFile(file, specifier, fileIdByName) {
+    if (!isStringLiteral(specifier) && !isNoSubstitutionTemplateLiteral(specifier)) {
+        return undefined;
+    }
+    const path = queriedModulePath(specifier.text);
+    return path === undefined
+        ? undefined
+        : fileIdByName.get(resolvePath(dirnamePath(file.fileName), path));
+}
 /**
  * The re-exports one node writes, if it is an export declaration. A specifier and a
  * namespace export are declarations whose names are where they are written, so no use is
@@ -232,6 +252,27 @@ function linksOf(file, node, declarations, enclosing) {
     }
     return found;
 }
+/**
+ * Whether one object literal is a destructuring target, written on the left of an
+ * assignment or as a `for` loop's initializer, through the literals and spreads it nests in.
+ */
+function isAssignmentPattern(node) {
+    let child = node;
+    let parent = node.parent;
+    while (isParenthesizedExpression(parent) ||
+        isArrayLiteralExpression(parent) ||
+        isObjectLiteralExpression(parent) ||
+        isSpreadElement(parent) ||
+        isSpreadAssignment(parent) ||
+        (isPropertyAssignment(parent) && parent.initializer === child)) {
+        child = parent;
+        parent = parent.parent;
+    }
+    if (isBinaryExpression(parent)) {
+        return parent.operatorToken.kind === SyntaxKind.EqualsToken && parent.left === child;
+    }
+    return (isForInStatement(parent) || isForOfStatement(parent)) && parent.initializer === child;
+}
 /**
  * Every name node one file holds that is a use rather than a declaration, in source
  * order, each with its enclosing declaration and its use, and every re-export the file
@@ -246,6 +287,8 @@ function sitesOf(file, declarations, fileId, unread) {
     const links = [];
     const evaluations = [];
     const decorated = [];
+    const literals = [];
+    const flows = [];
     const writes = new Set();
     const alsoRead = new Set();
     const declared = new Set();
@@ -286,6 +329,13 @@ function sitesOf(file, declarations, fileId, unread) {
         }
         markNames(node);
         markStores(node, writes, alsoRead);
+        if (isObjectLiteralExpression(node) && !isAssignmentPattern(node)) {
+            literals.push({ literal: node, from: enclosing });
+        }
+        // An assertion needs only comparability, so no member of its operand is read by it.
+        for (const written of isAsExpression(node) ? [] : handedOn(node)) {
+            flows.push(...valuesOf(written).map((value) => ({ value, from: enclosing })));
+        }
         for (const read of propertyReadsOf(node)) {
             reads.push({ ...read, from: enclosing });
         }
@@ -308,8 +358,16 @@ function sitesOf(file, declarations, fileId, unread) {
         enclosing = outer;
     };
     file.forEachChild(visit);
-    return { uses: found, reads, links, evaluations, decorated };
+    return { uses: found, literals, flows, reads, links, evaluations, decorated };
 }
+/** The declaration kinds of a property an object literal declares. */
+const LITERAL_PROPERTY_KINDS = new Set([
+    SyntaxKind.PropertyAssignment,
+    SyntaxKind.ShorthandPropertyAssignment,
+    SyntaxKind.MethodDeclaration,
+    SyntaxKind.GetAccessor,
+    SyntaxKind.SetAccessor,
+]);
 /** The rule a file the analysis classified as test-support code is counted under. */
 const TEST_SUPPORT_RULE = "test-support";
 /**
@@ -412,6 +470,59 @@ function importBindings(file) {
     }
     return found;
 }
+/** The value one assignment stores through the name it writes, where it is a plain assignment. */
+function storedValue(name) {
+    let target = name;
+    if (isPropertyAccessExpression(name.parent) && name.parent.name === name) {
+        target = name.parent;
+    }
+    while (isParenthesizedExpression(target.parent)) {
+        target = target.parent;
+    }
+    const parent = target.parent;
+    return isBinaryExpression(parent) &&
+        parent.operatorToken.kind === SyntaxKind.EqualsToken &&
+        parent.left === target
+        ? parent.right
+        : undefined;
+}
+/**
+ * The import bindings of one file that only the values written into one declaration
+ * use, for each write into it. A binding is named by an identifier that spells its
+ * local name and is not the member a property access names.
+ */
+function aloneIn(file, uses, writes, found) {
+    const bindings = new Set(importBindings(file).map((binding) => binding.node.getText()));
+    if (bindings.size === 0) {
+        return [];
+    }
+    const occurrences = new Map();
+    for (const site of uses) {
+        const text = site.node.getText();
+        const parent = site.node.parent;
+        if (!bindings.has(text) || (isPropertyAccessExpression(parent) && parent.name === site.node)) {
+            continue;
+        }
+        if (!occurrences.get(text)?.includes(site.node)) {
+            occurrences.set(text, [...(occurrences.get(text) ?? []), site.node]);
+        }
+    }
+    const inside = (node, value) => node.pos >= value.pos && node.end <= value.end;
+    const result = [];
+    for (const write of writes) {
+        const to = found[write.index]?.to;
+        const sameTarget = writes.filter((one) => found[one.index]?.to === to);
+        const names = [...occurrences]
+            .filter(([, nodes]) => nodes.some((node) => inside(node, write.value)) &&
+            nodes.every((node) => sameTarget.some((one) => inside(node, one.value))))
+            .map(([name]) => name)
+            .sort(compare);
+        if (names.length > 0) {
+            result.push({ index: write.index, names });
+        }
+    }
+    return result;
+}
 /** Two strings ordered bytewise, which is the order every set of a run is read in. */
 function compare(a, b) {
     if (a === b) {
@@ -442,7 +553,8 @@ export function references(project, held, targetRoot, options) {
     const found = [];
     const tests = [];
     const chains = aliasChains(project, held);
-    const destructured = destructuring(project, cap);
+    const tables = propertyTables(project.queries);
+    const destructured = destructuring(project, cap, tables);
     let batched = 0;
     let fileBatches = 0;
     let residueFallbacks = 0;
@@ -455,6 +567,7 @@ export function references(project, held, targetRoot, options) {
             .ownSourceFiles()
             .filter((file) => relativePath(consumer.root, file.fileName) !== undefined &&
             relativePath(targetRoot, file.fileName) === undefined);
+    const ownPaths = project.ownPaths();
     const fileIds = new Set(held.symbols.filter((symbol) => symbol.kind === "file").map((symbol) => symbol.id));
     let topLevel;
     /** The declarations one file's top level holds. */
@@ -551,14 +664,90 @@ export function references(project, held, targetRoot, options) {
         residueFallbacks += 1;
         return project.resolvedSymbolAt(project.handle(site.node));
     };
-    for (const file of files) {
+    const walked = files.map((file) => {
+        const fileId = declaredAt(file) ?? "";
+        return { file, fileId, ...sitesOf(file, declarations, fileId, unread) };
+    });
+    const fileIdByName = new Map(walked.filter((one) => fileIds.has(one.fileId)).map((one) => [one.file.fileName, one.fileId]));
+    const contextual = contextualUses(project, held, chains, walked.flatMap((one) => one.literals), walked.flatMap((one) => one.flows), cap, tables);
+    const writtenBy = new Map();
+    for (const write of contextual.writes) {
+        const property = write.at.parent;
+        writtenBy.set(nodeKey(property.getSourceFile(), property), write.ids);
+    }
+    const forwardedCache = new Map();
+    /**
+     * The members a literal property one symbol declares writes: a use of the property
+     * reaches them, because the literal's type carries the data the member describes.
+     */
+    const forwarded = (symbol) => {
+        const known = forwardedCache.get(symbol.id);
+        if (known !== undefined) {
+            return known;
+        }
+        const found = [];
+        if (writtenBy.size > 0) {
+            for (const handle of symbol.declarations) {
+                if (!LITERAL_PROPERTY_KINDS.has(handle.kind) || !ownPaths.has(handle.path)) {
+                    continue;
+                }
+                const node = project.declarationAt(handle)?.node;
+                const ids = node === undefined ? undefined : writtenBy.get(nodeKey(node.getSourceFile(), node));
+                for (const id of ids ?? []) {
+                    if (!found.some((target) => target.id === id)) {
+                        found.push({ id, stepped: true, guessed: false });
+                    }
+                }
+            }
+        }
+        forwardedCache.set(symbol.id, found);
+        return found;
+    };
+    /** One resolved symbol's declarations along its chain, and the members its literal properties write. */
+    const targetsOf = (symbol) => {
+        const through = forwarded(symbol);
+        return through.length === 0 ? chains.chainOf(symbol) : [...chains.chainOf(symbol), ...through];
+    };
+    const testFile = new Map();
+    for (const { file } of walked) {
         const path = renderPosition(file, root, 0).path;
         const test = patterns.some((pattern) => pattern.test(path));
+        testFile.set(file, test);
         if (test) {
             tests.push(path);
         }
-        const fileId = declaredAt(file) ?? "";
-        const { uses, reads, links, evaluations, decorated } = sitesOf(file, declarations, fileId, unread);
+    }
+    /** Each write reference's index in `found`, by its file, with the value it stores. */
+    const valued = new Map();
+    const holdsValue = (file, value) => {
+        if (value !== undefined) {
+            valued.set(file, [...(valued.get(file) ?? []), { index: found.length - 1, value }]);
+        }
+    };
+    for (const [use, sites] of [
+        ["write", contextual.writes],
+        ["read", contextual.reads],
+    ]) {
+        for (const site of sites) {
+            const file = site.at.getSourceFile();
+            const position = renderPosition(file, root, site.at.getStart());
+            for (const id of site.ids) {
+                found.push({
+                    from: site.from,
+                    to: id,
+                    position,
+                    use,
+                    resolution: "contextual",
+                    test: testFile.get(file) === true,
+                });
+                if (use === "write") {
+                    holdsValue(file, site.at.parent);
+                }
+            }
+        }
+    }
+    for (const { file, fileId, uses, reads, links, evaluations, decorated } of walked) {
+        const test = testFile.get(file) === true;
         // A component file's markup may use any binding its blocks declare at the top level.
         const markup = isComponentFile(file);
         const bindings = markup ? importBindings(file) : [];
@@ -622,6 +811,17 @@ export function references(project, held, targetRoot, options) {
             }
         }
         for (const evaluation of evaluations) {
+            const queried = queriedFile(file, evaluation.node, fileIdByName);
+            if (queried !== undefined) {
+                found.push({
+                    from: evaluation.from,
+                    to: queried,
+                    position: renderPosition(file, root, evaluation.node.getStart()),
+                    use: "evaluation",
+                    resolution: "syntax",
+                    test,
+                });
+            }
             const module = answered.get(evaluation.node);
             if (module === undefined) {
                 continue;
@@ -697,7 +897,7 @@ export function references(project, held, targetRoot, options) {
                     stepped: false,
                     guessed: true,
                 }))
-                : chains.chainOf(symbol);
+                : targetsOf(symbol);
             for (const target of targets) {
                 found.push({
                     from: read.from,
@@ -724,7 +924,7 @@ export function references(project, held, targetRoot, options) {
             // the use names every link of the chain its name stands at the head of.
             const targets = throughAliases(symbol === UNANSWERED
                 ? named(site.node).map((id) => ({ id, stepped: false, guessed: true }))
-                : chains.chainOf(symbol));
+                : targetsOf(symbol));
             for (const target of targets) {
                 found.push({
                     from: site.from,
@@ -734,9 +934,25 @@ export function references(project, held, targetRoot, options) {
                     resolution: target.guessed ? "by-name" : target.stepped ? "alias" : direct,
                     test,
                 });
+                if (site.use === "write") {
+                    holdsValue(file, storedValue(site.node));
+                }
             }
         }
     }
+    const usesOf = new Map(walked.map((one) => [one.file, one.uses]));
+    for (const [file, writes] of valued) {
+        const uses = usesOf.get(file) ?? [];
+        for (const { index, names } of aloneIn(file, uses, writes, found)) {
+            const reference = found[index];
+            if (reference !== undefined) {
+                found[index] = { ...reference, alone: names };
+            }
+        }
+    }
+    if (consumer === undefined) {
+        found.push(...overrideReferences(project, held, chains, new Set(tests)));
+    }
     found.sort((a, b) => byPosition(a.position, b.position) ||
         compare(a.to, b.to) ||
         compare(a.from, b.from) ||
@@ -755,6 +971,8 @@ export function references(project, held, targetRoot, options) {
             aliasSteps: chains.steps,
             patternBatches: destructured.cost.patternBatches,
             patternLookups: destructured.cost.patternLookups,
+            contextualBatches: contextual.batches,
+            contextualLookups: contextual.lookups,
         },
     };
 }

package/dist/src/resolve.js

@@ -133,18 +133,19 @@ function readStrings(parent, name, path, label, minItems, allowed) {
         throw malformed(label, path, `holds ${String(value.length)} entries, want at least ${String(minItems)}`);
     }
     const seen = new Set();
-    for (const entry of value) {
+    for (const [index, entry] of value.entries()) {
+        const at = `${path}[${String(index)}]`;
         if (typeof entry !== "string") {
-            throw malformed(label, path, "holds an entry that is not a string");
+            throw malformed(label, at, "is not a string");
         }
         if (entry === "") {
-            throw malformed(label, path, "holds an empty entry");
+            throw malformed(label, at, "is empty");
         }
         if (seen.has(entry)) {
-            throw malformed(label, path, `names ${JSON.stringify(entry)} twice`);
+            throw malformed(label, at, `names ${JSON.stringify(entry)} again`);
         }
         if (allowed !== undefined && !allowed.includes(entry)) {
-            throw malformed(label, path, `${JSON.stringify(entry)} is not one of ${spell(allowed)}`);
+            throw malformed(label, at, `${JSON.stringify(entry)} is not one of ${spell(allowed)}`);
         }
         seen.add(entry);
     }
@@ -154,9 +155,9 @@ function readStrings(parent, name, path, label, minItems, allowed) {
 const COMPONENT_EXTENSION = /^\.[A-Za-z0-9]+$/u;
 function readComponentExtensions(ts, label) {
     const extensions = readStrings(ts, "component_extensions", "ts.component_extensions", label, 0);
-    const wrong = extensions?.find((one) => !COMPONENT_EXTENSION.test(one));
-    if (wrong !== undefined) {
-        throw malformed(label, "ts.component_extensions", `${JSON.stringify(wrong)} is not a full stop followed by letters and digits`);
+    const wrong = extensions?.findIndex((one) => !COMPONENT_EXTENSION.test(one)) ?? -1;
+    if (extensions !== undefined && wrong !== -1) {
+        throw malformed(label, `ts.component_extensions[${String(wrong)}]`, `${JSON.stringify(extensions[wrong])} is not a full stop followed by letters and digits`);
     }
     return extensions;
 }
@@ -164,9 +165,9 @@ function readComponentExtensions(ts, label) {
 const CONVENTION_NAMES = new Set(CONVENTION_ROWS.map((row) => row.name));
 function readDisabledConventions(ts, label) {
     const names = readStrings(ts, "disabled_conventions", "ts.disabled_conventions", label, 0);
-    const unknown = names?.find((one) => !CONVENTION_NAMES.has(one));
-    if (unknown !== undefined) {
-        throw malformed(label, "ts.disabled_conventions", `${JSON.stringify(unknown)} names no convention row this analyzer carries`);
+    const unknown = names?.findIndex((one) => !CONVENTION_NAMES.has(one)) ?? -1;
+    if (names !== undefined && unknown !== -1) {
+        throw malformed(label, `ts.disabled_conventions[${String(unknown)}]`, `${JSON.stringify(names[unknown])} names no convention row this analyzer carries`);
     }
     return names;
 }

package/dist/src/roots.js

@@ -7,6 +7,7 @@
  * decides; the published API only supposes a consumer, so a published export is live
  * under reachability and still a candidate under reference counting.
  */
+import { isExpressionWithTypeArguments, isFunctionLikeDeclaration, isPropertyAccessExpression, isQualifiedName, isTypeQueryNode, isTypeReferenceNode, } from "@typescript/native/unstable/ast";
 import { aliasChains } from "./alias-chain.js";
 import { conventionEntries } from "./conventions.js";
 import { entryPoints } from "./entry-points.js";
@@ -131,7 +132,7 @@ export function roots(project, held, targetRoot, options) {
             publishes: entry.published &&
                 (options.manifest.declaresExports ? entry.member.startsWith("exports") : true),
         })),
-        ...(options.workspaceEntries ?? []).map((entry) => ({ entry, publishes: entry.published })),
+        ...(options.otherPackages ?? []).map((entry) => ({ entry, publishes: entry.published })),
     ];
     for (const { entry, publishes } of entries) {
         if (options.publishedAPI && publishes) {
@@ -158,7 +159,7 @@ export function roots(project, held, targetRoot, options) {
         : conventionEntries(options.conventions, files)) {
         enter(file, "convention", row, true);
     }
-    for (const point of entryPoints(project, files, options.testFiles, options.host, targetRoot)) {
+    for (const point of entryPoints(project, files, options.testFiles, options.host, targetRoot, options.parse)) {
         enter(point.file, point.rule, point.source, point.exports);
     }
     for (const file of files.byPath.values()) {
@@ -188,10 +189,11 @@ export function roots(project, held, targetRoot, options) {
             }
         }
     }
-    if (options.publishedAPI) {
-        for (const id of publishedAPI(published, exportsOf, held)) {
-            add(id, "published-api", "");
-        }
+    const api = options.publishedAPI
+        ? publishedAPI(project, published, exportsOf, held, files.byPath)
+        : { ids: [], guessed: [] };
+    for (const id of api.ids) {
+        add(id, "published-api", "");
     }
     const unmatched = configured(held, options.patterns, add);
     const sites = new Map(held.symbols.map((symbol) => [symbol.id, symbol.position]));
@@ -205,7 +207,7 @@ export function roots(project, held, targetRoot, options) {
         configFile: project.configFile,
         liveUnderReachability: ordered,
         unmatched,
-        unanswered: answered ? [] : held.symbols.map((symbol) => symbol.id),
+        unanswered: answered ? api.guessed : held.symbols.map((symbol) => symbol.id),
     };
 }
 /**
@@ -255,52 +257,134 @@ function exportTables(project, held, wanted) {
 /** The kinds of container whose export table, not its members' visibility, says what it publishes. */
 const EXPORTING_CONTAINERS = new Set(["file", "namespace"]);
 /**
- * Every declaration a consumer of the library can name: what the published files
- * export, and below each, the members a consumer reaches through it.
- *
- * The published files are the ones `exports` reaches where the manifest declares
- * one, because a package that declares `exports` has said exactly what a consumer may
- * import; where it declares none, they are the ones the members that preceded it
- * name. Below a published module or namespace the walk follows what its export table
- * names; below any other published declaration it follows every member a consumer
- * can write: a public one, and a protected one, which a consumer's subclass names. A
- * private member is not published, nor is anything below one, and a type parameter
- * is not published either, because a consumer supplies a type argument by position.
- *
- * A published file is not itself published. A consumer imports a module and names
- * what it exports; the file is a root because the manifest names it, which is a
- * different reason.
+ * Every declaration a consumer of the library can name: what the published files export
+ * and, below each, the members a consumer writes: a namespace's exported ones, any other
+ * declaration's public and protected ones, never a private one or a type parameter. A
+ * declaration a published one's type names is published too, exported or not. A type name
+ * the checker leaves unanswered publishes every declaration spelled as it is, and those are
+ * `guessed`. A published file is not itself published.
  */
-function publishedAPI(published, exportsOf, held) {
+function publishedAPI(project, published, exportsOf, held, byPath) {
     const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
     const children = childrenOf(held);
+    const nodes = declarationNodes(held, byPath);
+    const chains = aliasChains(project, held);
     const reached = new Set();
+    const guessed = new Set();
     const pending = [];
+    const reach = (id) => {
+        if (!reached.has(id) && byId.get(id)?.kind !== "file") {
+            reached.add(id);
+            pending.push(id);
+        }
+    };
     for (const file of published) {
         for (const id of exportsOf.get(file.fileName) ?? []) {
             if (byId.get(id)?.kind === "file") {
                 pending.push(id);
             }
-            else if (!reached.has(id)) {
-                reached.add(id);
-                pending.push(id);
+            else {
+                reach(id);
             }
         }
     }
-    for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
-        const exporting = EXPORTING_CONTAINERS.has(byId.get(next)?.kind ?? "");
-        for (const member of children.get(next) ?? []) {
-            const reachable = exporting
-                ? member.exported
-                : member.visibility !== "private" && member.visibility !== "private-name";
-            if (member.kind === "type-parameter" || reached.has(member.id) || !reachable) {
-                continue;
+    while (pending.length > 0) {
+        const round = [];
+        for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
+            round.push(next);
+            const exporting = EXPORTING_CONTAINERS.has(byId.get(next)?.kind ?? "");
+            for (const member of children.get(next) ?? []) {
+                const reachable = exporting
+                    ? member.exported
+                    : member.visibility !== "private" && member.visibility !== "private-name";
+                if (member.kind !== "type-parameter" && reachable) {
+                    reach(member.id);
+                }
             }
-            reached.add(member.id);
-            pending.push(member.id);
         }
+        const named = round.flatMap((id) => {
+            const symbol = byId.get(id);
+            return symbol === undefined || symbol.kind === "file" ? [] : nodes.typeNamesOf(symbol);
+        });
+        project.symbolsAt(named.map((node) => project.handle(node))).forEach((symbol, index) => {
+            if (symbol === UNANSWERED) {
+                for (const id of held.byName.get(named[index]?.getText() ?? "") ?? []) {
+                    guessed.add(id);
+                    reach(id);
+                }
+            }
+            else if (symbol !== undefined) {
+                for (const target of chains.chainOf(symbol)) {
+                    reach(target.id);
+                }
+            }
+        });
     }
-    return [...reached];
+    return { ids: [...reached], guessed: [...guessed] };
+}
+/** The type names declarations of the inventory write, each file walked once, when first asked. */
+function declarationNodes(held, byPath) {
+    const walked = new Map();
+    const nodesIn = (path) => {
+        const known = walked.get(path);
+        if (known !== undefined) {
+            return known;
+        }
+        const found = { byId: new Map(), nodes: new Set() };
+        const file = byPath.get(path);
+        if (file !== undefined) {
+            const visit = (node) => {
+                const id = held.declarations.get(nodeKey(file, node));
+                if (id !== undefined) {
+                    found.nodes.add(node);
+                    if (!found.byId.has(id)) {
+                        found.byId.set(id, node);
+                    }
+                }
+                node.forEachChild(visit);
+            };
+            visit(file);
+        }
+        walked.set(path, found);
+        return found;
+    };
+    return {
+        typeNamesOf: (symbol) => {
+            const { byId, nodes } = nodesIn(symbol.position.path);
+            const declaration = byId.get(symbol.id);
+            return declaration === undefined ? [] : typeNamesOf(declaration, nodes);
+        },
+    };
+}
+/**
+ * The names of types one declaration's own syntax writes: in a type reference, a
+ * heritage clause or a type query. A function body is not read, and neither is a
+ * declaration nested in this one, which `nested` holds and which is read on its own.
+ */
+function typeNamesOf(declaration, nested) {
+    const found = [];
+    const visit = (node) => {
+        if (node !== declaration && nested.has(node)) {
+            return;
+        }
+        if (isTypeReferenceNode(node)) {
+            found.push(isQualifiedName(node.typeName) ? node.typeName.right : node.typeName);
+        }
+        else if (isExpressionWithTypeArguments(node)) {
+            found.push(isPropertyAccessExpression(node.expression) ? node.expression.name : node.expression);
+        }
+        else if (isTypeQueryNode(node)) {
+            found.push(isQualifiedName(node.exprName) ? node.exprName.right : node.exprName);
+        }
+        const body = isFunctionLikeDeclaration(node) ? node.body : undefined;
+        node.forEachChild((child) => {
+            if (child !== body) {
+                visit(child);
+            }
+        });
+    };
+    visit(declaration);
+    return found;
 }
 /**
  * Keeps every declaration the configuration names and returns every string that

package/dist/src/session.js

@@ -225,10 +225,10 @@ function projectsOf(snapshot, built, written) {
  * snapshot of one client, and answers in their order. A configuration `programs` describes is
  * built as that program, or opened from the configuration it writes, instead of as a project.
  * One the snapshot holds nothing for ends the run under `"refuse"` and is named in the result
- * under `"record"`. The snapshot is disposed after the last visit and the client released
- * after it, whether the visit completed or threw.
+ * under `"record"`. `last` runs after the last visit while the client still answers; the
+ * snapshot is disposed and the client released after it, whether the visit completed or threw.
  */
-export function runSession(engine, configFiles, visit, unopened = "refuse", programs = new Map()) {
+export function runSession(engine, configFiles, visit, unopened = "refuse", programs = new Map(), last = () => undefined) {
     try {
         const built = [];
         const params = [];
@@ -262,6 +262,7 @@ export function runSession(engine, configFiles, visit, unopened = "refuse", prog
                 }
                 projects.push(visit(viewOf(project, configFile, engine, log)));
             }
+            last();
             return {
                 projects,
                 unopened: missing,

package/dist/src/stores.js

@@ -26,6 +26,9 @@ export function accessorsOf(project, held) {
 export function storesOf(per, exempt, mode) {
     return {
         references: per.flatMap((one) => one.references.filter((reference) => !mode.production || !reference.test)),
+        readInTests: new Set(per.flatMap((one) => one.references
+            .filter((reference) => reference.test && reference.use !== "write")
+            .map((reference) => reference.to))),
         accessors: new Set(per.flatMap((one) => one.accessors)),
         exempt: new Set(exempt.map((record) => record.id)),
     };