@cplieger/deadset-ts 3.0.0 → 3.2.0

package/src/matrix.ts

@@ -0,0 +1,212 @@
+/**
+ * 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, type Component } from "./components.ts";
+import { graphOf, type Graph } from "./graph.ts";
+import type { InventorySymbol } from "./inventory.ts";
+import { byPosition } from "./position.ts";
+import type { Reference } from "./references.ts";
+import type { Root } from "./roots.ts";
+import { sweep, type Candidate, type Liveness, type Relation, type SweepInput } from "./sweep.ts";
+
+/** What the passes answered for one configuration of the run. */
+export interface Configured {
+  /** The name discovery gives the configuration's project. */
+  readonly configuration: string;
+  readonly symbols: readonly InventorySymbol[];
+  readonly references: readonly Reference[];
+  readonly roots: readonly Root[];
+  /** The paths the reference pass classified as test files. */
+  readonly testFiles: readonly string[];
+}
+
+/** The run's configurations, indexed for the sweep. */
+export interface Matrix {
+  /** The configurations, in the run's order. */
+  readonly configurations: readonly string[];
+  /** Per configuration, in the same order, the graph of what that configuration holds. */
+  readonly graphs: readonly Graph[];
+  /**
+   * The graph over every configuration at once: every declaration any configuration
+   * holds, once per position and in site order, and every reference any configuration
+   * makes, a reference several configurations make at one position counted once.
+   */
+  readonly union: Graph;
+  /**
+   * Per declaration of {@link Matrix.union}, at its position there, the configurations
+   * whose project holds it, in the run's order.
+   */
+  readonly heldIn: readonly (readonly string[])[];
+}
+
+/** One declaration dead in every configuration that holds it. */
+export interface MatrixCandidate extends Candidate {
+  /** The configurations the declaration is dead in, which are every one that holds it. */
+  readonly configurations: readonly string[];
+}
+
+/** One run's sweep. */
+export interface SweepResult {
+  /**
+   * Per declaration, the relations that hold it live in at least one configuration,
+   * reference counting first. A declaration no relation holds live anywhere has no entry.
+   */
+  readonly liveUnder: ReadonlyMap<string, readonly Relation[]>;
+  /** The declarations dead in every configuration that holds them, in site order. */
+  readonly candidates: readonly MatrixCandidate[];
+  /** The dead components, each before every component it reaches, each identifier once per run. */
+  readonly components: readonly Component[];
+}
+
+/** Two strings ordered bytewise. */
+function compare(a: string, b: string): number {
+  if (a === b) {
+    return 0;
+  }
+  return a < b ? -1 : 1;
+}
+
+/** What makes one reference one reference, whichever configuration made it. */
+function referenceKey(reference: Reference): string {
+  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: readonly Configured[]): Matrix {
+  const symbols: InventorySymbol[] = [];
+  const holders = new Map<string, string[]>();
+  const references: Reference[] = [];
+  const firstSeen = new Map<string, number>();
+  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: Matrix, input: SweepInput): SweepResult {
+  const per = matrix.graphs.map((graph) => sweep(graph, input));
+  const byConfiguration = new Map<string, ReadonlyMap<string, Candidate>>(
+    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: MatrixCandidate[] = [];
+  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 is 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: readonly Relation[] = ["reference-counting", "reachability"];
+
+/**
+ * Per declaration, in site order, every relation that holds it live in at least one
+ * configuration.
+ */
+function liveAnywhere(
+  symbols: readonly InventorySymbol[],
+  per: readonly Liveness[],
+): ReadonlyMap<string, readonly Relation[]> {
+  const live = new Map<string, readonly Relation[]>();
+  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/src/references.ts

@@ -1,12 +1,17 @@
 import {
   isArrayLiteralExpression,
   isBinaryExpression,
+  isCallExpression,
   isDeleteExpression,
   isElementAccessExpression,
   isExportDeclaration,
+  isExternalModuleReference,
   isForInStatement,
   isForOfStatement,
+  isImportDeclaration,
+  isImportEqualsDeclaration,
   isNamespaceExport,
+  isNoSubstitutionTemplateLiteral,
   isObjectLiteralExpression,
   isParenthesizedExpression,
   isPostfixUnaryExpression,
@@ -16,11 +21,13 @@ import {
   isShorthandPropertyAssignment,
   isSpreadAssignment,
   isSpreadElement,
+  isStringLiteral,
   SyntaxKind,
   type Node,
   type SourceFile,
 } from "@typescript/native/unstable/ast";
-import { SymbolFlags, type Symbol as TSSymbol } from "@typescript/native/unstable/sync";
+import type { Symbol as TSSymbol } from "@typescript/native/unstable/sync";
+import { aliasChains } from "./alias-chain.ts";
 import { globExpression } from "./glob.ts";
 import { nodeKey, type Inventory } from "./inventory.ts";
 import { byPosition, renderPosition, type Position } from "./position.ts";
@@ -37,13 +44,18 @@ import type { ProjectView } from "./session.ts";
  *
  * What the pass records and what it does not: a reference carries its use, its
  * position, the declaration that encloses it and the classification of the file that
- * made it. It carries no mode. Which of the references a run counts is the reading the
- * sweep makes of this set, so the mode is one value the run decides once and this pass
- * never sees it.
+ * made it, and every place that imports one of the project's own modules is an
+ * evaluation of that module's file. It carries no mode. Which of the references a run
+ * counts is the reading the sweep makes of this set, so the mode is one value the run
+ * decides once and this pass never sees it.
  */
 
-/** How one reference uses the declaration it names. */
-export type Use = "read" | "write";
+/**
+ * How one reference uses the declaration it names. An `evaluation` names a file: the
+ * place it is written imports the module, which runs the module's top level and reads
+ * none of what it exports. A `read` of a file reads the module's namespace.
+ */
+export type Use = "read" | "write" | "evaluation";
 
 /**
  * Which accessor answered for one reference, so that the cost of a run is attributable
@@ -299,10 +311,52 @@ interface Link {
   readonly alias: boolean;
 }
 
+/** One place the walk found that evaluates a module, and the declaration that holds it. */
+interface Evaluation {
+  /** The module specifier, whose symbol is the module evaluated. */
+  readonly node: Node;
+  readonly from: string;
+}
+
 /** Everything one file's walk found to resolve. */
 interface FileSites {
   readonly uses: readonly Site[];
   readonly links: readonly Link[];
+  readonly evaluations: readonly Evaluation[];
+}
+
+/** Whether one node is a string literal or a template literal with no substitution. */
+function isLiteralText(node: Node | undefined): node is 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: Node): Node | undefined {
+  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;
 }
 
 /**
@@ -363,6 +417,7 @@ function sitesOf(
 ): FileSites {
   const found: Site[] = [];
   const links: Link[] = [];
+  const evaluations: Evaluation[] = [];
   const writes = new Set<number>();
   const declared = new Set<number>();
   const shorthands = new Map<number, Node>();
@@ -401,6 +456,10 @@ function sitesOf(
     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) {
@@ -411,7 +470,7 @@ function sitesOf(
   };
 
   file.forEachChild(visit);
-  return { uses: found, links };
+  return { uses: found, links, evaluations };
 }
 
 /**
@@ -431,12 +490,6 @@ function compare(a: string, b: string): number {
   return a < b ? -1 : 1;
 }
 
-/** One declaration one symbol reaches, and whether a step along an alias reached it. */
-interface Target {
-  readonly id: string;
-  readonly stepped: boolean;
-}
-
 /**
  * Every reference one project's own files make to the project's own declarations, in
  * position order, and the test-file rules that classified those files.
@@ -448,7 +501,8 @@ interface Target {
  * 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<Brand>(
   project: ProjectView<Brand>,
@@ -462,92 +516,21 @@ export function references<Brand>(
   const matched = options.testFiles.map(() => 0);
   const found: Reference[] = [];
   const tests: string[] = [];
-  const reached = new Map<number, readonly Target[]>();
-  const steps = new Map<number, TSSymbol | undefined>();
+  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: Node): string | undefined =>
     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: TSSymbol): string[] => {
-    const ids: string[] = [];
-    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: TSSymbol): TSSymbol | undefined => {
-    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: TSSymbol): readonly Target[] => {
-    const cached = reached.get(symbol.id);
-    if (cached !== undefined) {
-      return cached;
-    }
-    const targets: Target[] = [];
-    const walked = new Set<number>();
-    let at: TSSymbol | undefined = 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
@@ -555,22 +538,8 @@ export function references<Brand>(
    * 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: Link, symbol: TSSymbol): readonly string[] => {
-    if (!link.alias) {
-      return declarationsOf(symbol);
-    }
-    const walked = new Set<number>([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: Link, symbol: TSSymbol): readonly string[] =>
+    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: Site, answered: ReadonlyMap<Node, TSSymbol>): TSSymbol | undefined => {
@@ -598,15 +567,19 @@ export function references<Brand>(
     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<Node, TSSymbol>();
     batched += batching.length;
@@ -640,6 +613,26 @@ export function references<Brand>(
       }
     }
 
+    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: Resolution =
         site.shorthand !== undefined
@@ -652,7 +645,9 @@ export function references<Brand>(
         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,
@@ -680,6 +675,6 @@ export function references<Brand>(
       .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 },
   };
 }

package/src/roots.ts

@@ -2,15 +2,15 @@
  * The root set of one project: every declaration the analysis keeps live without a
  * reference, and why.
  *
- * A root makes its declaration live under REACHABILITY and plays no part in
- * reference counting, which asks only whether some declaration of the loaded graph
- * names it. The two relations are different sets, so an exported declaration that
- * something outside the program reaches is live under the first and still a
- * candidate under the second.
+ * Every root seeds REACHABILITY, and no root counts as a reference. A root of a kind
+ * that names a caller is live under reference counting as well, which the sweep
+ * decides; a root that only supposes a consumer is not, so an exported declaration
+ * something outside the program reaches is live under reachability and still a
+ * candidate under reference counting.
  */
 
 import type { SourceFile } from "@typescript/native/unstable/ast";
-import type { Symbol as TSSymbol } from "@typescript/native/unstable/sync";
+import { aliasChains } from "./alias-chain.ts";
 import { REPOSITORY_DOCUMENT } from "./config.ts";
 import { entryPoints, type EntryRule } from "./entry-points.ts";
 import type { Finding } from "./finding.ts";
@@ -63,7 +63,8 @@ export interface Roots {
    * reason it is live.
    *
    * The member says which relation the set feeds: every declaration here is live
-   * under reachability, and nothing here is live under reference counting.
+   * under reachability. A root of a kind that names a caller is also live under
+   * reference counting, which the sweep decides.
    */
   readonly liveUnderReachability: readonly Root[];
   /**
@@ -230,12 +231,10 @@ export function roots<Brand>(
     enter(point.file, point.rule, point.source, point.exports);
   }
 
-  const exportsOf = exportTables(
-    project,
-    held,
-    [...entered.filter((entry) => entry.exports).map((entry) => entry.file), ...published],
-    files.byName,
-  );
+  const exportsOf = exportTables(project, held, [
+    ...entered.filter((entry) => entry.exports).map((entry) => entry.file),
+    ...published,
+  ]);
   for (const entry of entered) {
     const id = fileIds.get(entry.file.fileName);
     if (id === undefined) {
@@ -282,7 +281,6 @@ function exportTables<Brand>(
   project: ProjectView<Brand>,
   held: Inventory,
   wanted: readonly SourceFile[],
-  ownFiles: ReadonlyMap<string, SourceFile>,
 ): ReadonlyMap<string, readonly string[]> {
   const unique = [...new Map(wanted.map((file) => [file.fileName, file])).values()];
   const tables = new Map<string, readonly string[]>();
@@ -290,36 +288,7 @@ function exportTables<Brand>(
     return tables;
   }
   const modules = project.symbolsAt(unique.map((file) => project.handle(file)));
-  const chains = new Map<number, readonly string[]>();
-
-  const chainOf = (symbol: TSSymbol): readonly string[] => {
-    const cached = chains.get(symbol.id);
-    if (cached !== undefined) {
-      return cached;
-    }
-    const ids: string[] = [];
-    const walked = new Set<number>();
-    let at: TSSymbol | undefined = symbol;
-    while (at !== undefined && !walked.has(at.id)) {
-      walked.add(at.id);
-      for (const handle of at.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);
-        }
-      }
-      at = project.aliasStepOf(at);
-    }
-    chains.set(symbol.id, ids);
-    return ids;
-  };
+  const chains = aliasChains(project, held);
 
   unique.forEach((file, index) => {
     const module = modules[index];
@@ -329,8 +298,8 @@ function exportTables<Brand>(
     }
     const ids = new Set<string>();
     for (const exported of project.checker.getExportsOfModule(module)) {
-      for (const id of chainOf(exported)) {
-        ids.add(id);
+      for (const target of chains.chainOf(exported)) {
+        ids.add(target.id);
       }
     }
     tables.set(file.fileName, [...ids]);