@cplieger/deadset-ts 7.0.0-dev.2 → 7.0.0-dev.4

package/src/analysis.ts

@@ -1,11 +1,9 @@
 /**
- * One run's passes, composed: the projects discovery names, opened in one snapshot
- * of one client, each read through the stages in the order they depend on each
- * other, and the per-project answers merged into the answer for the run.
- *
- * The stages take a project's view, which only this composition makes: a view
- * carries a project's identity in its type so a handle cannot cross to another
- * project's checker, and that holds only for views the session itself hands out.
+ * One run's passes, composed: the projects discovery names, opened in one snapshot of one
+ * client, each read through the stages in dependency order, and the per-project answers
+ * merged into the run's. The stages take a project's view, which only this composition
+ * makes: a view carries a project's identity in its type so a handle cannot cross to
+ * another project's checker, which holds only for views the session hands out.
  */
 
 import { lineOf, readComponent } from "./component-files.ts";
@@ -40,10 +38,12 @@ import {
   readConventions,
   type AppliedConvention,
   type ConventionManifest,
+  type Conventions,
 } from "./conventions.ts";
 import { readEdgeSides } from "./edges.ts";
 import { enumGroup } from "./enum-group.ts";
 import { generatedFile, generatedFilesOf } from "./generated-file.ts";
+import { inOperandNames } from "./in-operands.ts";
 import { sourceFilesOf } from "./source-files.ts";
 import {
   evidenceRecords,
@@ -94,13 +94,26 @@ import {
 } from "./type-errors.ts";
 import { reflectiveLookup } from "./reflective-lookup.ts";
 import { references, testFileRulesOf, type Reference, type TestFileRule } from "./references.ts";
-import { roots, unmatchedEverywhere, type RootKind, type Roots } from "./roots.ts";
+import {
+  roots,
+  unmatchedEverywhere,
+  type RootKind,
+  type RootOptions,
+  type Roots,
+} from "./roots.ts";
 import type { Scope } from "./scope.ts";
 import { serializationContract } from "./serialization-contract.ts";
 import { outsideTestReferences, testFilesAt, type OutsideTest } from "./outside-tests.ts";
 import { joinedTestFiles, withJoinedTests } from "./test-joins.ts";
 import { supportReferences, testSupportFiles } from "./test-support.ts";
-import { diagnosticsOf, ownedAs, runSession, type Engine, type ProjectView } from "./session.ts";
+import {
+  diagnosticsOf,
+  ownedAs,
+  runSession,
+  type Engine,
+  type OpenedFiles,
+  type ProjectView,
+} from "./session.ts";
 import { accessorsOf, storesOf } from "./stores.ts";
 import { isPartKind, type SuppressionRecord, type Suppressions, type Verdict } from "./suppress.ts";
 import { bindRows, readBaseline, readIgnoreFile, type Recorded } from "./suppress-file.ts";
@@ -225,32 +238,73 @@ interface ReadProjects<Answer> {
   readonly conventionUses: readonly string[];
   /** The directory of every workspace member, absolute. */
   readonly memberDirs: readonly string[];
+  /** The directory of every nested package, absolute. */
+  readonly nestedDirs: readonly string[];
   /** The test files below the target root no project the run reads holds, parsed. */
   readonly outsideTests: readonly OutsideTest[];
 }
 
 /**
  * The manifests the analysis reads, each once: the target's own, then every workspace
- * member's below the target root.
+ * member's and every nested package's below the target root.
  */
 function conventionManifests(
   host: Host,
   targetRoot: string,
   memberDirs: readonly string[],
+  nestedDirs: readonly string[],
 ): readonly ConventionManifest[] {
   const found = new Map<string, ConventionManifest>();
   if (host.kindOf(joinPath(targetRoot, "package.json")) === "file") {
     found.set(targetRoot, { dir: targetRoot, path: "package.json" });
   }
-  for (const dir of memberDirs) {
-    const below = relativePath(targetRoot, dir);
-    if (below !== undefined && !found.has(dir)) {
-      found.set(dir, { dir, path: `${below}/package.json` });
+  for (const [dirs, nested] of [
+    [memberDirs, false],
+    [nestedDirs, true],
+  ] as const) {
+    for (const dir of dirs) {
+      const below = relativePath(targetRoot, dir);
+      if (below !== undefined && !found.has(dir)) {
+        found.set(dir, { dir, path: `${below}/package.json`, nested });
+      }
     }
   }
   return [...found.values()];
 }
 
+/**
+ * The nested packages of a run: each directory below the target root, in no `node_modules`
+ * directory and none of `known`, that holds a `package.json` and lies at or above one of
+ * `files`, the program's source files and the compiler configuration files, in path order.
+ */
+function nestedPackageDirs(
+  host: Host,
+  targetRoot: string,
+  files: Iterable<string>,
+  known: ReadonlySet<string>,
+): readonly string[] {
+  const seen = new Set<string>();
+  const found: string[] = [];
+  for (const file of files) {
+    for (
+      let dir = dirnamePath(file);
+      dir !== targetRoot && !seen.has(dir) && relativePath(targetRoot, dir) !== undefined;
+      dir = dirnamePath(dir)
+    ) {
+      seen.add(dir);
+      const below = relativePath(targetRoot, dir) ?? "";
+      if (
+        !below.split("/").includes("node_modules") &&
+        !known.has(dir) &&
+        host.kindOf(joinPath(dir, "package.json")) === "file"
+      ) {
+        found.push(dir);
+      }
+    }
+  }
+  return found.sort(compare);
+}
+
 /**
  * Reads every project the scope discovers, and each declared consumer's, in one snapshot,
  * each checked for errors first. `stage` is handed a target project and enumerates and roots
@@ -268,6 +322,12 @@ function readProjects<Answer>(
 ): ReadProjects<Answer> {
   const targetRoot = scope.target.path;
   const discovered = discoverProjects(engine, host, scope, config.analysis.configurations);
+  if (discovered.configFiles.length === 0 && discovered.notBuilt.length === 0) {
+    throw new DiscoveryError(
+      `${targetRoot} holds no compiler configuration, so the run holds no program`,
+      [],
+    );
+  }
   const ids = new Map(discovered.projects.map((project) => [project.configFile, project.id]));
   const loads = consumerLoads(engine, host, scope, discovered.configFiles);
   const consumerOf = new Map(
@@ -283,33 +343,45 @@ function readProjects<Answer>(
     discovered.configFiles,
     readManifest(host, targetRoot),
   );
-  const conventions = readConventions(
-    host,
-    (fileName, text) => engine.parseSourceFile(fileName, text),
-    conventionManifests(host, absoluteRoot, workspace?.memberDirs ?? []),
-    config.ts.disabledConventions,
-  );
-  const options = {
-    host,
-    manifest: workspace?.manifest ?? readManifest(host, targetRoot),
-    otherPackages: [
-      ...(workspace?.entries ?? []),
-      ...packageEntries(
-        host,
-        normalizePath(absoluteRoot),
-        discovered.configFiles,
-        new Set(workspace?.memberDirs ?? []),
+  const parse = (fileName: string, text: string) => engine.parseSourceFile(fileName, text);
+  const memberDirs = workspace?.memberDirs ?? [];
+  // The nested packages are known only once every program is open, and every visit reads
+  // the conventions and options they decide, so both are set in the session's first step.
+  let nestedDirs: readonly string[] = [];
+  let conventions = readConventions(host, parse, [], config.ts.disabledConventions);
+  let options: RootOptions & { readonly parse: typeof parse; readonly conventions: Conventions };
+  const readManifests = (opened: readonly OpenedFiles[]): void => {
+    nestedDirs = nestedPackageDirs(
+      host,
+      normalizePath(absoluteRoot),
+      opened
+        .filter((one) => !consumerOf.has(one.configFile))
+        .flatMap((one) => [one.configFile, ...one.fileNames()]),
+      new Set(memberDirs),
+    );
+    conventions = readConventions(
+      host,
+      parse,
+      conventionManifests(host, absoluteRoot, memberDirs, nestedDirs),
+      config.ts.disabledConventions,
+    );
+    options = {
+      host,
+      manifest: workspace?.manifest ?? readManifest(host, targetRoot),
+      otherPackages: [
+        ...(workspace?.entries ?? []),
+        ...packageEntries(host, normalizePath(absoluteRoot), nestedDirs),
+      ],
+      patterns: config.rootPatterns,
+      entryFiles: config.ts.entryFiles,
+      conventions,
+      testFiles: config.ts.testFiles,
+      parse,
+      publishedAPI: config.targetKind === "library",
+      publishedMembers: new Set(
+        (workspace?.entries ?? []).filter((entry) => entry.published).map((entry) => entry.dir),
       ),
-    ],
-    patterns: config.rootPatterns,
-    entryFiles: config.ts.entryFiles,
-    conventions,
-    testFiles: config.ts.testFiles,
-    parse: (fileName: string, text: string) => engine.parseSourceFile(fileName, text),
-    publishedAPI: config.targetKind === "library",
-    publishedMembers: new Set(
-      (workspace?.entries ?? []).filter((entry) => entry.published).map((entry) => entry.dir),
-    ),
+    };
   };
   const notBuilt: NotBuilt[] = [...discovered.notBuilt];
   const dropped = (configFile: string, error: string): void => {
@@ -477,9 +549,10 @@ function readProjects<Answer>(
         sourcePaths(host, targetRoot).filter(
           (path) => !heldFiles.has(path) && testPatterns.some((pattern) => pattern.test(path)),
         ),
-        options.parse,
+        parse,
       );
     },
+    readManifests,
   );
   for (const configFile of session.unopened) {
     if (consumerOf.has(configFile) || !isGuess(discovered, configFile)) {
@@ -518,7 +591,8 @@ function readProjects<Answer>(
     componentsUnread: workspace?.componentsUnread ?? [],
     conventionsApplied: conventions.applied,
     conventionUses: conventions.uses,
-    memberDirs: workspace?.memberDirs ?? [],
+    memberDirs,
+    nestedDirs,
     outsideTests,
   };
 }
@@ -707,6 +781,8 @@ interface ReadRun<Extra> {
   readonly conventionUses: readonly string[];
   /** The directory of every workspace member, absolute. */
   readonly memberDirs: readonly string[];
+  /** The directory of every nested package, absolute. */
+  readonly nestedDirs: readonly string[];
 }
 
 /**
@@ -726,6 +802,7 @@ function readRun<Extra>(
     project: ProjectView<Brand>,
     read: ProjectRead,
     references: readonly Reference[],
+    testFiles: readonly string[],
   ) => Extra,
 ): ReadRun<Extra> {
   const targetRoot = scope.target.path;
@@ -771,7 +848,7 @@ function readRun<Extra>(
           reason: warning.reason,
         })),
       ),
-      extra: extra(project, projectRead, resolved.references),
+      extra: extra(project, projectRead, resolved.references, resolved.testFilePaths),
     };
   });
   const outsidePaths = read.outsideTests.map((one) => one.path);
@@ -816,6 +893,9 @@ function readRun<Extra>(
       ...(projectRead.referenceOnly.length === 0
         ? {}
         : { referenceOnly: projectRead.referenceOnly }),
+      ...(projectRead.held.dependents.size === 0
+        ? {}
+        : { dependents: projectRead.held.dependents }),
     };
     return {
       configFile: projectRead.configFile,
@@ -865,6 +945,7 @@ function readRun<Extra>(
     conventionsApplied: read.conventionsApplied,
     conventionUses: read.conventionUses,
     memberDirs: read.memberDirs,
+    nestedDirs: read.nestedDirs,
   };
 }
 
@@ -1010,14 +1091,12 @@ function sweptOf<Extra>(
 }
 
 /**
- * Sweeps the run the scope and the configuration describe. Each project's references
- * and exemptions are read against its own inventory while its view is open; the
- * projects then merge into one matrix in the run's order, which is swept under the
- * caller's marks and mode with the exemptions every project found. A record found in
- * one configuration holds in every configuration that holds its declaration, because
- * an exemption is evidence of a use the analysis cannot see and a use in one
- * configuration is a use. A project that carries an error ends the run before any
- * project is swept.
+ * Sweeps the run the scope and the configuration describe. Each project's references and
+ * exemptions are read against its own inventory while its view is open; the projects then
+ * merge into one matrix in run order, swept under the caller's marks and mode with every
+ * project's exemptions. A record found in one configuration holds in every configuration
+ * that holds its declaration, because an exemption evidences a use the analysis cannot see.
+ * A project that carries an error ends the run before any project is swept.
  */
 export function runSweep(
   engine: Engine,
@@ -1041,6 +1120,7 @@ interface EmitterExtra {
   readonly implementations: ReturnType<typeof implementations>;
   readonly heldByInclusion: readonly string[];
   readonly generated: readonly string[];
+  readonly inOperands: readonly string[];
   readonly rooted: Roots;
   readonly directives: readonly InlineDirective[];
   readonly declarationsNamed: readonly boolean[];
@@ -1064,7 +1144,7 @@ export function readEmitterRun(
     config,
     mode,
     detectors,
-    (project, read, references) => ({
+    (project, read, references, testFiles) => ({
       deprecation: deprecatedDeclarations(project, read.held),
       accessors: accessorsOf(project, read.held),
       needs: projectNeeds(project, read.held, host, targetRoot, (fileName, text) =>
@@ -1073,6 +1153,7 @@ export function readEmitterRun(
       implementations: implementations(project, read.held),
       heldByInclusion: heldByInclusion(project, targetRoot),
       generated: [...read.generated.keys()],
+      inOperands: inOperandNames(project, targetRoot, testFiles),
       rooted: read.rooted,
       directives: inlineDirectives(project, read.held, targetRoot).filter(
         (directive) => !read.referenceOnly.includes(directive.site.path),
@@ -1165,12 +1246,14 @@ export function emitterInputOver(
       swept.sweep.candidates.map((candidate) => candidate.id),
       members.read,
       members.unbuilt,
+      read.nestedDirs,
     ),
     implementations: mergeImplementations(projects.map((one) => one.extra.implementations)),
     files: {
       tree: sourceTree(host, targetRoot),
       heldByInclusion: new Set(projects.flatMap((one) => one.extra.heldByInclusion)),
       generated: new Set(projects.flatMap((one) => one.extra.generated)),
+      inOperands: new Set(projects.flatMap((one) => one.extra.inOperands)),
     },
     boundary: {
       consumers: {

package/src/augmentations.ts

@@ -1,9 +1,10 @@
 /**
- * The references a use of an augmentation's declaration makes to what holds it. No name
- * spells a `declare global` block, so a use of a declaration it holds is a use of the
- * block. An interface or namespace an augmentation block holds merges with the one of its
- * name, which the language or a library may type a value by where the target never names
- * it, as it types `import.meta` or `process.env`, so a use of its member is a use of it.
+ * The references a use of an augmentation's declaration makes to what holds it. A use of
+ * a declaration a `declare global` block or a module declaration holds is a use of the
+ * block, which no name spells or no import may name. An interface or namespace such a
+ * block, or the top level of a file that is no module, holds merges with the one of its
+ * name, which the language or a library types values by where the target never names it,
+ * as `import.meta` or `process.env`, so a use of its member is a use of it.
  */
 
 import type { Inventory, InventorySymbol } from "./inventory.ts";
@@ -24,19 +25,21 @@ function isGlobalBlock(
 }
 
 /**
- * For each reference to a declaration an augmentation block holds, a read at the same place
- * of every interface and namespace between it and the block, and of a `declare global` block
- * itself.
+ * For each reference to a declaration an augmentation block, or the global scope of a
+ * file in `scripts`, holds, a read at the same place of every interface and namespace
+ * between it and the block or the file, and of the block itself. `scripts` holds the
+ * files that are no module, by identifier.
  */
 export function augmentationReferences(
   held: Inventory,
   found: readonly Reference[],
+  scripts: ReadonlySet<string> = new Set(),
 ): readonly Reference[] {
   const files = new Set(held.symbols.filter((one) => one.kind === "file").map((one) => one.id));
   const globals = new Set(
     held.symbols.filter((one) => isGlobalBlock(one, held, files)).map((one) => one.id),
   );
-  if (globals.size === 0 && held.modules.size === 0) {
+  if (globals.size === 0 && held.modules.size === 0 && scripts.size === 0) {
     return [];
   }
   const byId = new Map(held.symbols.map((one) => [one.id, one]));
@@ -47,10 +50,10 @@ export function augmentationReferences(
       at !== undefined;
       at = byId.get(at.parent)
     ) {
-      if (globals.has(at.id)) {
+      if (globals.has(at.id) || held.modules.has(at.id)) {
         return [...ids, at.id];
       }
-      if (held.modules.has(at.id)) {
+      if (scripts.has(at.id)) {
         return ids;
       }
       if (at.kind === "interface" || at.kind === "namespace") {

package/src/calls.ts

@@ -22,8 +22,8 @@ import {
   type Decorator,
   type Expression,
   type Node,
-} from "@typescript/native/unstable/ast";
-import { SymbolFlags, type Symbol as TSSymbol } from "@typescript/native/unstable/sync";
+} from "@typescript/native/ast";
+import { SymbolFlags, type Symbol as TSSymbol } from "@typescript/native/sync";
 import type { AliasChains } from "./alias-chain.ts";
 import { nodeKey, type Inventory } from "./inventory.ts";
 import { must } from "./query.ts";

package/src/class-members.ts

@@ -4,8 +4,8 @@
  * that extends it and a member a subclass overrides is the subclass's own.
  */
 
-import { isClassDeclaration, isClassExpression, type Node } from "@typescript/native/unstable/ast";
-import type { Symbol as TSSymbol, SymbolFlags, Type } from "@typescript/native/unstable/sync";
+import { isClassDeclaration, isClassExpression, type Node } from "@typescript/native/ast";
+import type { Symbol as TSSymbol, SymbolFlags, Type } from "@typescript/native/sync";
 import { nodeKey, type Inventory, type InventorySymbol } from "./inventory.ts";
 import { must } from "./query.ts";
 import type { ProjectView } from "./session.ts";

package/src/component-layer.ts

@@ -6,7 +6,7 @@
  * `node_modules` beside each configuration, to a directory holding only its manifest.
  */
 
-import type { CreateSnapshotParams } from "@typescript/native/unstable/sync";
+import type { CreateSnapshotParams } from "@typescript/native/sync";
 import type { Host } from "./host.ts";
 import { dirnamePath, joinPath } from "./paths.ts";
 

package/src/components.ts

@@ -37,8 +37,27 @@ export interface Component {
    * cycle with a live container is one, so a component has at least one.
    */
   readonly roots: readonly string[];
-  /** The source lines one deletion of the component removes: the distinct lines its members span. */
+  /**
+   * The source lines one deletion of the component removes: the distinct lines its
+   * members span, and none for a component of held declarations.
+   */
   readonly deletableLines: number;
+  /**
+   * Whether its members are held declarations, which no mechanical edit deletes: a dead
+   * declaration whose deletion changes a live declaration's value, and every dead
+   * declaration such a one references or whose deletion would change its value.
+   */
+  readonly held: boolean;
+}
+
+/**
+ * What the held-declaration rule reads of a graph, by place: the places of the later
+ * declarations whose value each one's deletion changes, and whether reachability holds
+ * each one live in some configuration.
+ */
+export interface Positional {
+  readonly dependents: readonly (readonly number[])[];
+  readonly live: readonly boolean[];
 }
 
 /** What a report carries for one dead component under one cascade mode. */
@@ -63,41 +82,97 @@ export function listing(component: Component, cascade: Cascade): Listing {
 /**
  * Groups the declarations `dead` marks into components, ordered by their first member's
  * site; `dead`, `testOfDeadCode` and `unreferencedTest` hold one flag per declaration of
- * the graph. Root members sit on the cycles no other cycle references. A cycle two roots
- * both reach is dead only through both, so a component is a weakly connected part of the
- * dead subgraph: no dead declaration of one references a declaration of another.
+ * the graph. Root members sit on the cycles no other cycle references. A component is a
+ * weakly connected part of the dead subgraph, because a cycle two roots reach is dead only
+ * through both. The held declarations `positional` decides form components of their own,
+ * and a dead declaration that is not held shares one with each of its dead dependents.
  */
 export function componentsOf(
   graph: Graph,
   dead: readonly boolean[],
   testOfDeadCode: readonly boolean[],
   unreferencedTest: readonly boolean[] = [],
+  positional: Positional = { dependents: [], live: [] },
 ): readonly Component[] {
-  const { at, adjacent } = deadSubgraph(graph, dead, testOfDeadCode, unreferencedTest);
+  const { at, position, adjacent, references } = deadSubgraph(
+    graph,
+    dead,
+    testOfDeadCode,
+    unreferencedTest,
+  );
   if (at.length === 0) {
     return [];
   }
-  const { componentOf, members } = connected(adjacent);
-  const referenced = referencedCycles(adjacent, componentOf, members.length);
-  const groups = joined(adjacent);
-  const idOf = (position: number): string => graph.symbols[at[position] ?? 0]?.id ?? "";
+  const dependents = at.map((index) =>
+    (positional.dependents[index] ?? []).map((to) => ({
+      to: position[to] ?? UNVISITED,
+      live: positional.live[to] === true,
+    })),
+  );
+  const held = heldSet(dependents, references);
+  const kept = adjacent.map((targets, from) => targets.filter((to) => held[to] === held[from]));
+  const { componentOf, members } = connected(kept);
+  const referenced = referencedCycles(kept, componentOf, members.length);
+  const groups = joined(
+    kept.map((targets, from) => [
+      ...targets,
+      ...(held[from] === true
+        ? []
+        : (dependents[from] ?? []).flatMap(({ to }) =>
+            to === UNVISITED || held[to] === true ? [] : [to],
+          )),
+    ]),
+  );
+  const idOf = (place: number): string => graph.symbols[at[place] ?? 0]?.id ?? "";
 
   return groups.map((group, place) => {
-    const roots = group.filter((position) => {
+    const roots = group.filter((one) => {
       // A dead member's dead container is on the member's own cycle, and the container
       // is where the deletion starts.
-      const container = graph.parent[at[position] ?? 0] ?? OUTSIDE;
-      return referenced[componentOf[position] ?? 0] !== true && dead[container] !== true;
+      const container = graph.parent[at[one] ?? 0] ?? OUTSIDE;
+      return referenced[componentOf[one] ?? 0] !== true && dead[container] !== true;
     });
+    const isHeld = group.every((one) => held[one] === true);
     return {
       id: componentId(place + 1),
       members: group.map(idOf),
       roots: roots.map(idOf),
-      deletableLines: linesSpanned(group.map((position) => graph.symbols[at[position] ?? 0])),
+      deletableLines: isHeld ? 0 : linesSpanned(group.map((one) => graph.symbols[at[one] ?? 0])),
+      held: isHeld,
     };
   });
 }
 
+/**
+ * Per place of the dead subgraph, whether the declaration is held: one with a live
+ * dependent, and each dead declaration a held one references or has as a dependent,
+ * until no further one joins.
+ */
+function heldSet(
+  dependents: readonly (readonly { readonly to: number; readonly live: boolean }[])[],
+  references: readonly (readonly number[])[],
+): readonly boolean[] {
+  const held = dependents.map((after) => after.some((one) => one.live));
+  const before: number[][] = dependents.map(() => []);
+  dependents.forEach((after, from) => {
+    for (const { to } of after) {
+      if (to !== UNVISITED) {
+        before[to]?.push(from);
+      }
+    }
+  });
+  const pending = held.flatMap((one, place) => (one ? [place] : []));
+  for (let next = pending.pop(); next !== undefined; next = pending.pop()) {
+    for (const reached of [...(references[next] ?? []), ...(before[next] ?? [])]) {
+      if (held[reached] !== true) {
+        held[reached] = true;
+        pending.push(reached);
+      }
+    }
+  }
+  return held;
+}
+
 /**
  * The distinct source lines a set of declarations spans, each declaration at least the
  * line it starts on. A member written inside its container's span adds no line, because
@@ -133,19 +208,24 @@ function linesSpanned(symbols: readonly (InventorySymbol | undefined)[]): number
 }
 
 /**
- * The dead declarations by their place in the subgraph, a test file's declaration only
- * where it is a test of dead code or nothing the tests reach, and the edges between them:
- * each reference one makes to another, except an unreferenced test-file declaration's
- * reference to production code, which decides nothing of its target, an edge each way
- * between a dead member and its dead container, and an edge back from each production
- * target of an admitted test, which puts the test in its subject's component.
+ * The dead declarations by subgraph place (`at`, and `position` per graph declaration),
+ * a test file's only where it tests dead code or nothing the tests reach. `adjacent` holds
+ * each reference one makes to another, except an unreferenced test-file declaration's to
+ * production code, which decides nothing of its target; an edge each way between a dead
+ * member and its dead container; and one back from each production target of an admitted
+ * test, which puts the test in its subject's component. `references` holds the first alone.
  */
 function deadSubgraph(
   graph: Graph,
   dead: readonly boolean[],
   testOfDeadCode: readonly boolean[],
   unreferencedTest: readonly boolean[],
-): { readonly at: readonly number[]; readonly adjacent: readonly (readonly number[])[] } {
+): {
+  readonly at: readonly number[];
+  readonly position: readonly number[];
+  readonly adjacent: readonly (readonly number[])[];
+  readonly references: readonly (readonly number[])[];
+} {
   const at: number[] = [];
   const position = graph.symbols.map((_symbol, index) => {
     const judged = testOfDeadCode[index] === true || unreferencedTest[index] === true;
@@ -156,6 +236,7 @@ function deadSubgraph(
     return at.length - 1;
   });
   const adjacent: number[][] = at.map(() => []);
+  const references: number[][] = at.map(() => []);
   at.forEach((index, from) => {
     for (const edge of graph.out[index] ?? []) {
       const to = position[edge.to] ?? UNVISITED;
@@ -163,6 +244,7 @@ function deadSubgraph(
         continue;
       }
       adjacent[from]?.push(to);
+      references[from]?.push(to);
       if (
         testOfDeadCode[index] === true &&
         graph.test[edge.to] !== true &&
@@ -177,7 +259,7 @@ function deadSubgraph(
       adjacent[container]?.push(from);
     }
   });
-  return { at, adjacent };
+  return { at, position, adjacent, references };
 }
 
 /** One frame of the component walk: a declaration, and the next of its edges to follow. */