@cplieger/deadset-ts 3.0.0 → 3.1.0

package/README.md

@@ -8,7 +8,7 @@ deadset-ts is a command-line analyzer for TypeScript and JavaScript projects. It
 
 deadset-ts is report-only. It never edits source, and it refuses any `--fix` flag.
 
-**Status: pre-release.** This version implements contract 2.2.0 and ships the analyzer's foundation: one compiler session per run over the projects `analysis.configurations` declares, each a compiler configuration file below the target, or, where it declares none, every `tsconfig` project discovered under the target (the explicit scope, every `tsconfig*.json`, each project's `references`), a fail-closed read of every project's diagnostics, configuration decoding against the contract's closed key list with `print-config` and its provenance, `print-projects`, the report-only guard, the symbol inventory of every declaration a project's own files hold down to its class and type members, the one-pass reference resolution over that inventory, which resolves each file's identifiers in batches ([batch-cap calibration](docs/batch-cap-calibration.md) is the measurement behind the batch size), and the root set `print-roots` prints. A root is a declaration the analysis keeps live without a reference: what a file exports when the manifest names it through `main`, `module`, `types`, `bin` or `exports`, or when `ts.entry_files` matches it; a library target's published API; the configuration, setup and test files of Vitest, Stryker and Playwright, the flat configuration of ESLint, and a worker or service worker a call addresses by a string literal; and every declaration a `roots.patterns` entry names. An entry that names nothing is reported as `DS1704` and fails the run. The entry-point conventions of other tools are not read, and `DECLINED_CONVENTIONS` lists each one with the reason. The analysis is reached through the command, and through `run()` for a caller that runs the command in-process; no other verb reports findings yet, so `analyze`, `explain`, `print-retained` and `describe` exit with a usage message. The one runtime dependency is the `typescript` package at exactly 7.0.2, installed under the `@typescript/native` name until TypeScript 7.1 ships a compiler API the tooling can share.
+**Status: pre-release.** This version implements contract 2.2.0 and ships the analyzer's foundation: one compiler session per run over the projects `analysis.configurations` declares, in the order it lists them, each a compiler configuration file below the target, or, where it declares none, every `tsconfig` project discovered under the target (the explicit scope, every `tsconfig*.json`, each project's `references`), a fail-closed read of every project's diagnostics, configuration decoding against the contract's closed key list with `print-config` and its provenance, `print-projects`, the report-only guard, the symbol inventory of every declaration a project's own files hold down to its class and type members, the one-pass reference resolution over that inventory, which resolves each file's identifiers in batches ([batch-cap calibration](docs/batch-cap-calibration.md) is the measurement behind the batch size), and the root set `print-roots` prints. A root is a declaration the analysis keeps live without a reference: what a file exports when the manifest names it through `main`, `module`, `types`, `bin` or `exports`, or when `ts.entry_files` matches it; a library target's published API; the configuration, setup and test files of Vitest, Stryker and Playwright, the flat configuration of ESLint, and a worker or service worker a call addresses by a string literal; and every declaration a `roots.patterns` entry names. An entry that names nothing is reported as `DS1704` and fails the run. The entry-point conventions of other tools are not read, and `DECLINED_CONVENTIONS` lists each one with the reason. The analysis is reached through the command, and through `run()` for a caller that runs the command in-process; no other verb reports findings yet, so `analyze`, `explain`, `print-retained` and `describe` exit with a usage message. The one runtime dependency is the `typescript` package at exactly 7.0.2, installed under the `@typescript/native` name until TypeScript 7.1 ships a compiler API the tooling can share.
 
 ## Install
 

package/dist/src/alias-chain.js

@@ -0,0 +1,96 @@
+/**
+ * Where an import or export chain leads in one project: from one symbol to each
+ * declaration of the target it is, and along the chain of aliases it heads to each
+ * declaration every link of that chain is.
+ */
+import { SymbolFlags } from "@typescript/native/unstable/sync";
+import { nodeKey } from "./inventory.js";
+/**
+ * The chain walks over one project, against the declarations of `held`, the same
+ * project's inventory.
+ *
+ * A declaration handle carries the file it is in, so whether it is one of the
+ * project's own files is answered before the handle is resolved: a declaration of a
+ * library file is never fetched to find out that the inventory does not hold it.
+ */
+export function aliasChains(project, held) {
+    const ownFiles = new Set(project.ownSourceFiles().map((file) => file.fileName));
+    const steps = new Map();
+    const chains = new Map();
+    let asked = 0;
+    const declarationsOf = (symbol) => {
+        const ids = [];
+        for (const handle of symbol.declarations) {
+            if (!ownFiles.has(handle.path)) {
+                continue;
+            }
+            const node = project.declarationAt(handle)?.node;
+            const id = node === undefined ? undefined : held.declarations.get(nodeKey(node.getSourceFile(), node));
+            if (id !== undefined && !ids.includes(id)) {
+                ids.push(id);
+            }
+        }
+        return ids;
+    };
+    /**
+     * What one alias names, one link along. Only a symbol the binder flagged an alias is
+     * asked, which is the condition the step asserts on: a default export of an
+     * expression is written in an alias form and names nothing declared elsewhere, so its
+     * chain ends at itself.
+     */
+    const stepOf = (symbol) => {
+        if ((symbol.flags & SymbolFlags.Alias) === 0) {
+            return undefined;
+        }
+        if (steps.has(symbol.id)) {
+            return steps.get(symbol.id);
+        }
+        const next = project.aliasStepOf(symbol);
+        asked += 1;
+        steps.set(symbol.id, next);
+        return next;
+    };
+    const chainOf = (symbol) => {
+        const cached = chains.get(symbol.id);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const targets = [];
+        const walked = new Set();
+        let at = symbol;
+        let stepped = false;
+        while (at !== undefined && !walked.has(at.id)) {
+            walked.add(at.id);
+            for (const id of declarationsOf(at)) {
+                if (!targets.some((target) => target.id === id)) {
+                    targets.push({ id, stepped });
+                }
+            }
+            at = stepOf(at);
+            stepped = true;
+        }
+        chains.set(symbol.id, targets);
+        return targets;
+    };
+    const nextDeclared = (symbol) => {
+        const walked = new Set([symbol.id]);
+        let at = stepOf(symbol);
+        while (at !== undefined && !walked.has(at.id)) {
+            walked.add(at.id);
+            const ids = declarationsOf(at);
+            if (ids.length > 0) {
+                return ids;
+            }
+            at = stepOf(at);
+        }
+        return [];
+    };
+    return {
+        declarationsOf,
+        chainOf,
+        nextDeclared,
+        get steps() {
+            return asked;
+        },
+    };
+}

package/dist/src/analysis.js

@@ -8,15 +8,14 @@
  * project's checker, and that holds only for views the session itself hands out.
  */
 import { diagnosticErrors, discoverProjects, DiscoveryError } from "./discover.js";
-import { graphOf } from "./graph.js";
 import { inventory } from "./inventory.js";
 import { readManifest } from "./manifest.js";
+import { matrixOf, sweepMatrix } from "./matrix.js";
 import { relativePath, resolvePath } from "./paths.js";
 import { byPosition } from "./position.js";
 import { references } from "./references.js";
 import { roots, unmatchedEverywhere, unmatchedRoots } from "./roots.js";
 import { diagnosticsOf, runSession } from "./session.js";
-import { sweep } from "./sweep.js";
 /** The setting whose source decides where a finding about a configured root sits. */
 const ROOTS_SETTING = "roots.patterns";
 /**
@@ -66,9 +65,7 @@ function readProjects(engine, host, scope, config, stage) {
         }
         const held = inventory(project, host, targetRoot);
         const rooted = roots(project, held, targetRoot, options);
-        const configuration = ids.get(project.configFile) ??
-            relativePath(targetRoot, project.configFile) ??
-            project.configFile;
+        const configuration = ids.get(project.configFile) ?? project.configFile;
         return stage(project, { configuration, held, rooted });
     });
     if (failures.length > 0) {
@@ -121,22 +118,26 @@ export function runRoots(engine, host, scope, config, provenance) {
     };
 }
 /**
- * Sweeps every project of the run the scope and the configuration describe, one
- * configuration at a time, in discovery order. Each project's references are read
- * against its own inventory with the configured test-file patterns, and its graph is
- * swept under the input the caller decided once for the run.
+ * Sweeps the run the scope and the configuration describe. Each project's references
+ * are read against its own inventory with the configured test-file patterns while its
+ * view is open; the projects then merge into one matrix in discovery order, which is
+ * swept under the input the caller decided once for the run. A project that carries
+ * an error ends the run before any project is swept.
  */
-export function runSweeps(engine, host, scope, config, input) {
+export function runSweep(engine, host, scope, config, input) {
     const targetRoot = scope.target.path;
-    return readProjects(engine, host, scope, config, (project, read) => {
+    const configured = readProjects(engine, host, scope, config, (project, read) => {
         const resolved = references(project, read.held, targetRoot, {
             testFiles: config.ts.testFiles,
         });
-        const graph = graphOf(read.held.symbols, resolved.references, read.rooted.liveUnderReachability, resolved.testFilePaths);
         return {
             configuration: read.configuration,
             symbols: read.held.symbols,
-            sweep: sweep(graph, input),
+            references: resolved.references,
+            roots: read.rooted.liveUnderReachability,
+            testFiles: resolved.testFilePaths,
         };
     });
+    const matrix = matrixOf(configured);
+    return { matrix, sweep: sweepMatrix(matrix, input) };
 }

package/dist/src/graph.js

@@ -85,7 +85,11 @@ export function graphOf(symbols, references, roots, testFiles) {
                 counts.production += 1;
             }
         }
-        out[at(reference.from)]?.push({ to, test: reference.test });
+        out[at(reference.from)]?.push({
+            to,
+            test: reference.test,
+            evaluation: reference.use === "evaluation",
+        });
     }
     const parent = symbols.map((symbol) => at(symbol.parent));
     const exportsOf = symbols.map(() => []);

package/dist/src/matrix.js

@@ -0,0 +1,138 @@
+/**
+ * One run's projects as one matrix: every declaration any project holds, keyed by its
+ * position and carrying the configurations that hold it, swept once per configuration
+ * and intersected, with the dead components computed once over every configuration.
+ */
+import { componentsOf } from "./components.js";
+import { graphOf } from "./graph.js";
+import { byPosition } from "./position.js";
+import { sweep } from "./sweep.js";
+/** Two strings ordered bytewise. */
+function compare(a, b) {
+    if (a === b) {
+        return 0;
+    }
+    return a < b ? -1 : 1;
+}
+/** What makes one reference one reference, whichever configuration made it. */
+function referenceKey(reference) {
+    const { path, line, column } = reference.position;
+    return [reference.from, reference.to, path, String(line), String(column), reference.use].join("\u0000");
+}
+/**
+ * Indexes what the passes answered for each configuration of one run, in the run's order.
+ *
+ * A declaration is keyed across configurations by its identifier, which is its rendered
+ * position and so is the same in every configuration that compiles its file; the fields
+ * of the first configuration that holds it are the ones kept. A declaration one
+ * configuration alone holds is in the union with that one configuration, so it is
+ * judged where it exists rather than skipped.
+ *
+ * One reference written at one position of a file several configurations compile is seen
+ * once per configuration and is one reference, so the union holds it once; two references
+ * one configuration makes at one position are two.
+ */
+export function matrixOf(per) {
+    const symbols = [];
+    const holders = new Map();
+    const references = [];
+    const firstSeen = new Map();
+    per.forEach((one, index) => {
+        for (const symbol of one.symbols) {
+            const held = holders.get(symbol.id);
+            if (held === undefined) {
+                holders.set(symbol.id, [one.configuration]);
+                symbols.push(symbol);
+            }
+            else if (!held.includes(one.configuration)) {
+                held.push(one.configuration);
+            }
+        }
+        for (const reference of one.references) {
+            const key = referenceKey(reference);
+            const seen = firstSeen.get(key);
+            if (seen === undefined) {
+                firstSeen.set(key, index);
+            }
+            else if (seen !== index) {
+                continue;
+            }
+            references.push(reference);
+        }
+    });
+    symbols.sort((a, b) => byPosition(a.position, b.position) || compare(a.ref, b.ref));
+    return {
+        configurations: per.map((one) => one.configuration),
+        graphs: per.map((one) => graphOf(one.symbols, one.references, one.roots, one.testFiles)),
+        union: graphOf(symbols, references, per.flatMap((one) => one.roots), [...new Set(per.flatMap((one) => one.testFiles))]),
+        heldIn: symbols.map((symbol) => holders.get(symbol.id) ?? []),
+    };
+}
+/**
+ * Answers which declarations of the run are dead in every configuration that holds them.
+ *
+ * Liveness is a question about one configuration, because a file another configuration
+ * does not compile makes no reference there and a root it does not hold seeds nothing
+ * there, so each configuration is swept on its own graph under the run's input. A
+ * declaration is a candidate when every configuration holding it judged it one: a
+ * reference under one configuration is a reference, so what one project uses is never
+ * reported, and a configuration that does not hold a declaration says nothing about it.
+ * The candidate's relation is reference counting where every configuration found it so,
+ * and reachability otherwise; its counts are the union's, one per reference.
+ *
+ * The components are computed once, over the union and the intersected dead set, so one
+ * dead component is one entry of the run with one identifier.
+ */
+export function sweepMatrix(matrix, input) {
+    const per = matrix.graphs.map((graph) => sweep(graph, input));
+    const byConfiguration = new Map(matrix.configurations.map((configuration, index) => [
+        configuration,
+        new Map((per[index]?.candidates ?? []).map((candidate) => [candidate.id, candidate])),
+    ]));
+    const union = matrix.union;
+    const dead = union.symbols.map(() => false);
+    const testOfDeadCode = union.symbols.map(() => false);
+    const candidates = [];
+    union.symbols.forEach((symbol, at) => {
+        const held = matrix.heldIn[at] ?? [];
+        const found = held.map((configuration) => byConfiguration.get(configuration)?.get(symbol.id));
+        if (held.length === 0 || found.some((candidate) => candidate === undefined)) {
+            return;
+        }
+        const all = found.filter((candidate) => candidate !== undefined);
+        const admitted = all.every((candidate) => candidate.testOfDeadCode);
+        dead[at] = true;
+        testOfDeadCode[at] = admitted;
+        candidates.push({
+            id: symbol.id,
+            productionRefs: union.made[at]?.production ?? 0,
+            testRefs: union.made[at]?.test ?? 0,
+            relation: all.every((candidate) => candidate.relation === "reference-counting")
+                ? "reference-counting"
+                : "reachability",
+            testOfDeadCode: admitted,
+            configurations: held,
+        });
+    });
+    return {
+        liveUnder: liveAnywhere(union.symbols, per),
+        candidates,
+        components: componentsOf(union, dead, testOfDeadCode),
+    };
+}
+/** The relations in the order a declaration's entry lists them. */
+const RELATIONS = ["reference-counting", "reachability"];
+/**
+ * Per declaration, in site order, every relation that holds it live in at least one
+ * configuration.
+ */
+function liveAnywhere(symbols, per) {
+    const live = new Map();
+    for (const symbol of symbols) {
+        const relations = RELATIONS.filter((relation) => per.some((liveness) => (liveness.liveUnder.get(symbol.id) ?? []).includes(relation)));
+        if (relations.length > 0) {
+            live.set(symbol.id, relations);
+        }
+    }
+    return live;
+}

package/dist/src/references.js

@@ -1,5 +1,5 @@
-import { isArrayLiteralExpression, isBinaryExpression, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isForInStatement, isForOfStatement, isNamespaceExport, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, SyntaxKind, } from "@typescript/native/unstable/ast";
-import { SymbolFlags } from "@typescript/native/unstable/sync";
+import { isArrayLiteralExpression, isBinaryExpression, isCallExpression, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isExternalModuleReference, isForInStatement, isForOfStatement, isImportDeclaration, isImportEqualsDeclaration, isNamespaceExport, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { aliasChains } from "./alias-chain.js";
 import { globExpression } from "./glob.js";
 import { nodeKey } from "./inventory.js";
 import { byPosition, renderPosition } from "./position.js";
@@ -126,6 +126,38 @@ function markStores(node, writes) {
         }
     }
 }
+/** Whether one node is a string literal or a template literal with no substitution. */
+function isLiteralText(node) {
+    return node !== undefined && (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node));
+}
+/**
+ * The module specifier of the module one node evaluates, if it evaluates one: an import
+ * declaration, an import-equals declaration of an external module, an export
+ * declaration that names a module, and an `import()` call whose argument is literal
+ * text. A type-only form evaluates nothing. An `import()` of a computed argument names
+ * no module this pass can know.
+ */
+function evaluatedBy(node) {
+    if (isImportDeclaration(node)) {
+        return node.importClause?.phaseModifier === SyntaxKind.TypeKeyword
+            ? undefined
+            : node.moduleSpecifier;
+    }
+    if (isExportDeclaration(node)) {
+        return node.isTypeOnly ? undefined : node.moduleSpecifier;
+    }
+    if (isImportEqualsDeclaration(node)) {
+        const reference = node.moduleReference;
+        return !node.isTypeOnly && isExternalModuleReference(reference)
+            ? reference.expression
+            : undefined;
+    }
+    if (isCallExpression(node) && node.expression.kind === SyntaxKind.ImportKeyword) {
+        const [argument] = node.arguments;
+        return isLiteralText(argument) ? argument : undefined;
+    }
+    return undefined;
+}
 /**
  * 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
@@ -174,6 +206,7 @@ function linksOf(file, node, declarations, enclosing) {
 function sitesOf(file, declarations, fileId) {
     const found = [];
     const links = [];
+    const evaluations = [];
     const writes = new Set();
     const declared = new Set();
     const shorthands = new Map();
@@ -210,6 +243,10 @@ function sitesOf(file, declarations, fileId) {
         markNames(node);
         markStores(node, writes);
         links.push(...linksOf(file, node, declarations, enclosing));
+        const evaluated = evaluatedBy(node);
+        if (evaluated !== undefined) {
+            evaluations.push({ node: evaluated, from: enclosing });
+        }
         const held = declarations.get(nodeKey(file, node));
         const outer = enclosing;
         if (held !== undefined) {
@@ -219,7 +256,7 @@ function sitesOf(file, declarations, fileId) {
         enclosing = outer;
     };
     file.forEachChild(visit);
-    return { uses: found, links };
+    return { uses: found, links, evaluations };
 }
 /**
  * The name one test-file rule takes. A rule's name is a word list the report's own
@@ -247,7 +284,8 @@ function compare(a, b) {
  * The order is by the referencing position, then by the declaration named, the
  * declaration referencing it and the use. That is a total order because one name
  * references one declaration once from one declaration, while a chain of aliases reaches
- * several declarations at one position.
+ * several declarations at one position and a bare star re-export's specifier both reads
+ * and evaluates the module it names.
  */
 export function references(project, held, targetRoot, options) {
     const cap = options.batchCap ?? DEFAULT_BATCH_CAP;
@@ -256,85 +294,15 @@ export function references(project, held, targetRoot, options) {
     const matched = options.testFiles.map(() => 0);
     const found = [];
     const tests = [];
-    const reached = new Map();
-    const steps = new Map();
+    const chains = aliasChains(project, held);
     let batched = 0;
     let fileBatches = 0;
     let residueFallbacks = 0;
     let shorthandLookups = 0;
-    let aliasSteps = 0;
     const files = project.ownSourceFiles();
-    const ownFiles = new Set(files.map((file) => file.fileName));
+    const fileIds = new Set(held.symbols.filter((symbol) => symbol.kind === "file").map((symbol) => symbol.id));
     /** The identifier of the declaration one node of this program is, where it is one. */
     const declaredAt = (node) => declarations.get(nodeKey(node.getSourceFile(), node));
-    /**
-     * The declarations of the inventory one symbol is.
-     *
-     * A declaration handle carries the file it is in, so the question is answered before
-     * the handle is resolved: a declaration outside the project's own files belongs to
-     * another program and is never read, which is what keeps the pass from fetching a
-     * library file to discover that the inventory does not hold what is in it.
-     */
-    const declarationsOf = (symbol) => {
-        const ids = [];
-        for (const handle of symbol.declarations) {
-            if (!ownFiles.has(handle.path)) {
-                continue;
-            }
-            const node = project.declarationAt(handle)?.node;
-            const id = node === undefined ? undefined : declaredAt(node);
-            if (id !== undefined && !ids.includes(id)) {
-                ids.push(id);
-            }
-        }
-        return ids;
-    };
-    /**
-     * What one alias names, one link along, asked once per alias whatever the number of
-     * chains it is a link of. Only a symbol the binder flagged an alias is asked, which is
-     * the condition the step asserts on: a default export of an expression is written in
-     * an alias form and names nothing declared elsewhere, so its chain ends at itself.
-     */
-    const stepOf = (symbol) => {
-        if ((symbol.flags & SymbolFlags.Alias) === 0) {
-            return undefined;
-        }
-        if (steps.has(symbol.id)) {
-            return steps.get(symbol.id);
-        }
-        const next = project.aliasStepOf(symbol);
-        aliasSteps += 1;
-        steps.set(symbol.id, next);
-        return next;
-    };
-    /**
-     * The declarations one symbol names: the declaration it is, and every link of the
-     * alias chain it stands at the head of. A re-export something imports is used and so
-     * is the declaration behind it, so both are named; a link this project does not
-     * declare is stepped over rather than recorded.
-     */
-    const targetsOf = (symbol) => {
-        const cached = reached.get(symbol.id);
-        if (cached !== undefined) {
-            return cached;
-        }
-        const targets = [];
-        const walked = new Set();
-        let at = symbol;
-        let stepped = false;
-        while (at !== undefined && !walked.has(at.id)) {
-            walked.add(at.id);
-            for (const id of declarationsOf(at)) {
-                if (!targets.some((target) => target.id === id)) {
-                    targets.push({ id, stepped });
-                }
-            }
-            at = stepOf(at);
-            stepped = true;
-        }
-        reached.set(symbol.id, targets);
-        return targets;
-    };
     /**
      * The declarations one re-export carries forward: for an alias, the first link along
      * its chain that the inventory declares, stepping over the links it does not, such as
@@ -342,22 +310,7 @@ export function references(project, held, targetRoot, options) {
      * Each later link is a declaration of its own that references the next, so one link
      * per re-export is what lets a chain be followed one declaration at a time.
      */
-    const carriedBy = (link, symbol) => {
-        if (!link.alias) {
-            return declarationsOf(symbol);
-        }
-        const walked = new Set([symbol.id]);
-        let at = stepOf(symbol);
-        while (at !== undefined && !walked.has(at.id)) {
-            walked.add(at.id);
-            const ids = declarationsOf(at);
-            if (ids.length > 0) {
-                return ids;
-            }
-            at = stepOf(at);
-        }
-        return [];
-    };
+    const carriedBy = (link, symbol) => link.alias ? chains.nextDeclared(symbol) : chains.declarationsOf(symbol);
     /** The symbol one site resolves to, asking only the accessor the site's form names. */
     const symbolFor = (site, answered) => {
         if (site.shorthand !== undefined) {
@@ -383,14 +336,18 @@ export function references(project, held, targetRoot, options) {
         if (test) {
             tests.push(path);
         }
-        const { uses, links } = sitesOf(file, declarations, declaredAt(file) ?? "");
+        const { uses, links, evaluations } = sitesOf(file, declarations, declaredAt(file) ?? "");
         // One batch per capped run of the file's name nodes, the re-exports' nodes after
-        // the uses. A shorthand is left out of the batch: its name resolves to the property
-        // the literal declares, so the batch's answer for it would name something this
-        // project's inventory never holds.
+        // the uses and the evaluated modules' specifiers last, each node once: a bare star
+        // re-export's specifier is a link and an evaluation both. A shorthand is left out
+        // of the batch: its name resolves to the property the literal declares, so the
+        // batch's answer for it would name something this project's inventory never holds.
         const batching = [
-            ...uses.filter((site) => site.shorthand === undefined).map((site) => site.node),
-            ...links.map((link) => link.node),
+            ...new Set([
+                ...uses.filter((site) => site.shorthand === undefined).map((site) => site.node),
+                ...links.map((link) => link.node),
+                ...evaluations.map((evaluation) => evaluation.node),
+            ]),
         ];
         const answered = new Map();
         batched += batching.length;
@@ -422,6 +379,25 @@ export function references(project, held, targetRoot, options) {
                 });
             }
         }
+        for (const evaluation of evaluations) {
+            const module = answered.get(evaluation.node);
+            if (module === undefined) {
+                continue;
+            }
+            const position = renderPosition(file, targetRoot, evaluation.node.getStart());
+            for (const id of chains.declarationsOf(module)) {
+                if (fileIds.has(id)) {
+                    found.push({
+                        from: evaluation.from,
+                        to: id,
+                        position,
+                        use: "evaluation",
+                        resolution: "batch",
+                        test,
+                    });
+                }
+            }
+        }
         for (const site of uses) {
             const direct = site.shorthand !== undefined
                 ? "shorthand"
@@ -433,7 +409,9 @@ export function references(project, held, targetRoot, options) {
                 continue;
             }
             const position = renderPosition(file, targetRoot, site.node.getStart());
-            for (const target of targetsOf(symbol)) {
+            // A re-export something imports is used and so is the declaration behind it, so
+            // the use names every link of the chain its name stands at the head of.
+            for (const target of chains.chainOf(symbol)) {
                 found.push({
                     from: site.from,
                     to: target.id,
@@ -456,6 +434,6 @@ export function references(project, held, targetRoot, options) {
             .map((_pattern, index) => ({ rule: patternRule(index), matched: matched[index] ?? 0 }))
             .sort((a, b) => compare(a.rule, b.rule)),
         testFilePaths: tests.sort(compare),
-        cost: { batched, fileBatches, residueFallbacks, shorthandLookups, aliasSteps },
+        cost: { batched, fileBatches, residueFallbacks, shorthandLookups, aliasSteps: chains.steps },
     };
 }