@cplieger/deadset-ts 8.0.0-dev.17 → 8.0.0-dev.19

package/src/verbs/explain.ts

@@ -1,19 +1,17 @@
 import { EXIT_CLEAN, EXIT_USAGE } from "../contract/contract.generated.ts";
 import { productionMode, runAnalysis, type RunAnalysis } from "../analysis.ts";
-import { listing } from "../components.ts";
+import { listing } from "../liveness/components.ts";
 import type { Cascade } from "../config.ts";
 import type { CompletedFinding } from "../finding.ts";
-import { OUTSIDE, swept as judged } from "../graph.ts";
+import { swept as judged, type Edge, type Graph } from "../liveness/graph.ts";
+import type { Origin } from "../liveness/sweep.ts";
 import type { InventorySymbol } from "../inventory.ts";
-import { referenceKey, type Configured } from "../matrix.ts";
 import { partialNotes } from "../partial.ts";
 import { resolvePath } from "../paths.ts";
 import { positionKey } from "../position.ts";
 import type { Reference } from "../references.ts";
-import type { Mode } from "../sweep.ts";
-import { madeByTestCode, withheldBy } from "../tests/file-class.ts";
+import { madeByTestCode } from "../tests/file-class.ts";
 import { resolve } from "../resolve.ts";
-import type { Root } from "../roots/root-set.ts";
 import { type Verb, type VerbOptions } from "./verb.ts";
 import { UsageError } from "../usage.ts";
 import { bytewise } from "../text/compare.ts";
@@ -106,160 +104,27 @@ function subjectOf(
   return { candidates: partial.slice(0, MAX_PARTIAL_MATCHES) };
 }
 
-/** Every reference of the run once, a reference several configurations make counted once. */
-function referencesOf(configured: readonly Configured[]): readonly Reference[] {
-  const seen = new Set<string>();
-  const held: Reference[] = [];
-  for (const reference of configured.flatMap((one) => one.references)) {
-    const key = referenceKey(reference);
-    if (!seen.has(key)) {
-      seen.add(key);
-      held.push(reference);
-    }
-  }
-  return held;
-}
-
-/** Every root of the run once per reason, in the order the projects name them. */
-function rootsOf(configured: readonly Configured[]): readonly Root[] {
-  const seen = new Set<string>();
-  return configured
-    .flatMap((one) => one.roots)
-    .filter((root) => {
-      const key = [root.id, root.kind, root.source].join("\u0000");
-      if (seen.has(key)) {
-        return false;
-      }
-      seen.add(key);
-      return true;
-    });
-}
-
-/**
- * One step of a path: a reference, or a reference that reads a module and so reaches a
- * declaration the module exports.
- */
-type Hop =
-  | { readonly k: "reference"; readonly reference: Reference }
-  | { readonly k: "export"; readonly reference: Reference; readonly to: string };
-
-/**
- * Where a path starts: a root of the run, or a reference a loaded consumer or a test file no
- * project holds makes.
- */
-type Origin =
-  | { readonly k: "root"; readonly root: Root }
-  | { readonly k: "consumer"; readonly consumer: string }
-  | { readonly k: "unheld"; readonly file: string };
-
-/**
- * The shortest path from a root, a loaded consumer or a test file no project holds to one
- * declaration, walked breadth first from every root at once in the order the run names them,
- * a reference of a consumer or of such a file being the first hop of a path of its own, as
- * the sweep seeds them, and following the references the sweep follows: a
- * reference that reads a module reaches what the module exports, and an evaluation or a root
- * reaches the module alone. Under `production` no reference a test file made is followed,
- * which is the set the report's sweep counts.
- */
-function shortestPath(
-  analysis: RunAnalysis,
-  to: string,
-  mode: Mode,
-  support: ReadonlySet<string>,
-): { readonly origin: Origin; readonly path: readonly Hop[] } | undefined {
-  const graph = analysis.swept.matrix.union;
-  const out = new Map<string, Reference[]>();
-  const consumed: { readonly reference: Reference; readonly origin: Origin }[] = [];
-  for (const reference of referencesOf(analysis.configured)) {
-    if (withheldBy(mode, reference, support)) {
-      continue;
-    }
-    const { consumer } = reference;
-    if (consumer !== undefined) {
-      consumed.push({ reference, origin: { k: "consumer", consumer } });
-      continue;
-    }
-    if (reference.unheld === true) {
-      consumed.push({
-        reference,
-        origin: { k: "unheld", file: reference.from.replace(/#$/u, "") },
-      });
-      continue;
-    }
-    const held = out.get(reference.from);
-    if (held === undefined) {
-      out.set(reference.from, [reference]);
-    } else {
-      held.push(reference);
-    }
-  }
-  interface Step {
-    readonly at: string;
-    readonly hop: Hop | undefined;
-    readonly previous: number;
-    readonly origin: Origin;
-  }
-  const steps: Step[] = [];
-  const seen = new Set<string>();
-  const expanded = new Set<string>();
-  const enter = (step: Step): void => {
-    if (!seen.has(step.at)) {
-      seen.add(step.at);
-      steps.push(step);
-    }
-  };
-  const follow = (reference: Reference, previous: number, origin: Origin): void => {
-    enter({ at: reference.to, hop: { k: "reference", reference }, previous, origin });
-    const target = graph.at(reference.to);
-    if (reference.use === "evaluation" || target === OUTSIDE || expanded.has(reference.to)) {
-      return;
-    }
-    expanded.add(reference.to);
-    for (const exported of graph.exportsOf[target] ?? []) {
-      const id = graph.symbols[exported]?.id;
-      if (id !== undefined) {
-        enter({ at: id, hop: { k: "export", reference, to: id }, previous, origin });
-      }
-    }
-  };
-  for (const root of rootsOf(analysis.configured)) {
-    enter({ at: root.id, hop: undefined, previous: -1, origin: { k: "root", root } });
-  }
-  // A consumed reference is one hop long, so it joins the walk where the roots' first hops do.
-  const firstHops = steps.length;
-  for (let head = 0; ; head += 1) {
-    if (head === firstHops) {
-      for (const { reference, origin } of consumed) {
-        follow(reference, -1, origin);
-      }
-    }
-    const step = steps[head];
-    if (step === undefined) {
-      break;
-    }
-    if (step.at === to) {
-      const path: Hop[] = [];
-      for (let at: Step | undefined = step; at?.hop !== undefined; at = steps[at.previous]) {
-        path.unshift(at.hop);
-      }
-      return { origin: step.origin, path };
-    }
-    for (const reference of out.get(step.at) ?? []) {
-      follow(reference, head, step.origin);
-    }
-  }
-  return undefined;
-}
-
 /** Where a path starts, as a line names it. */
-function originText(origin: Origin): string {
+function originText(origin: Origin, graph: Graph): string {
+  const id = (at: number): string => graph.symbols[at]?.id ?? "";
   switch (origin.k) {
     case "root":
-      return `root ${origin.root.kind} ${origin.root.id}`;
-    case "consumer":
-      return `consumer ${origin.consumer}`;
-    case "unheld":
-      return `test file no project holds ${origin.file}`;
+      return `root ${origin.rooted.kind} ${id(origin.rooted.at)}`;
+    case "consumed": {
+      const reference = graph.references[origin.edge.reference];
+      if (reference?.consumer !== undefined) {
+        return `consumer ${reference.consumer}`;
+      }
+      return reference?.unheld === true
+        ? `test file no project holds ${reference.from.replace(/#$/u, "")}`
+        : `declaration no configuration judges ${reference?.from ?? ""}`;
+    }
+    case "exemption":
+      return `exemption ${origin.record.class} ${positionKey(origin.record.site)}`;
+    case "mark":
+      return `suppression of ${id(origin.at)}`;
+    case "unanswered":
+      return `unanswered question about ${id(origin.at)}`;
   }
 }
 
@@ -268,52 +133,74 @@ function madeBy(reference: Reference): string {
   return reference.consumer === undefined ? reference.from : `consumer ${reference.consumer}`;
 }
 
-/** One reference of an answer, marked where test code made it, a test-support file's included. */
-function referenceLine(reference: Reference, tail: string, support: ReadonlySet<string>): string {
-  return `  reference: ${positionKey(reference.position)}\t${reference.use}\t${tail}${madeByTestCode(reference, support) ? "\tfrom a test file" : ""}\n`;
+/**
+ * One reference of an answer, marked where test code made it, a test-support file's included,
+ * and naming the configurations that make it where they are not every one of the run.
+ */
+function referenceLine(
+  reference: Reference,
+  tail: string,
+  support: ReadonlySet<string>,
+  configurations: { readonly making: readonly string[]; readonly run: readonly string[] },
+): string {
+  const partial = configurations.making.length < configurations.run.length;
+  return `  reference: ${positionKey(reference.position)}\t${reference.use}\t${tail}${madeByTestCode(reference, support) ? "\tfrom a test file" : ""}${partial ? `\tmade in ${configurations.making.join(" ")}` : ""}\n`;
 }
 
 /** Why a declaration no finding names and no exemption held back is live, or how it fell. */
-function liveness(
-  analysis: RunAnalysis,
-  subject: InventorySymbol,
-  cascade: Cascade,
-  mode: Mode,
-): string {
-  const { sweep } = analysis.swept;
+function liveness(analysis: RunAnalysis, subject: InventorySymbol, cascade: Cascade): string {
+  const { matrix, sweep } = analysis.swept;
+  const graph = matrix.union;
   const candidate = sweep.candidates.find((one) => one.id === subject.id);
   if (candidate === undefined && !judged(subject.kind)) {
     return `answer: unjudged\n  unjudged: neither liveness relation judges a ${subject.kind}\n`;
   }
   let text = `answer: ${candidate === undefined ? "live" : "dead"}\n`;
   text += `  live under: ${listed(sweep.liveUnder.get(subject.id) ?? [])}\n`;
-  for (const root of rootsOf(analysis.configured).filter((one) => one.id === subject.id)) {
-    text += `  root: ${root.kind}${root.source === "" ? "" : `\tnamed by ${root.source}`}\n`;
+  const at = graph.at(subject.id);
+  const seen = new Set<string>();
+  for (const root of graph.rooted.filter((one) => one.at === at)) {
+    const key = `${root.kind}\u0000${root.source}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      text += `  root: ${root.kind}${root.source === "" ? "" : `\tnamed by ${root.source}`}\n`;
+    }
   }
   const support = new Set(analysis.configured.flatMap((one) => one.supportFiles ?? []));
-  const found =
-    shortestPath(analysis, subject.id, mode, support) ??
-    shortestPath(analysis, subject.id, { production: false }, support);
-  if (found !== undefined && found.path.length > 0) {
-    const { origin } = found;
-    text += `  reached from: ${originText(origin)}\n`;
-    for (const hop of found.path) {
-      text += referenceLine(
-        hop.reference,
-        `${madeBy(hop.reference)} -> ${hop.reference.to}`,
-        support,
-      );
+  const line = (edge: Edge, tail: (reference: Reference) => string): string => {
+    const reference = graph.references[edge.reference];
+    return reference === undefined
+      ? ""
+      : referenceLine(reference, tail(reference), support, {
+          making: graph.configurations[edge.reference] ?? [],
+          run: matrix.configurations,
+        });
+  };
+  const found = sweep.path(subject.id);
+  if (found !== undefined && found.hops.length > 0) {
+    text += `  reached from: ${originText(found.origin, graph)}\n`;
+    for (const hop of found.hops) {
+      text += line(hop.edge, (reference) => `${madeBy(reference)} -> ${reference.to}`);
       if (hop.k === "export") {
-        text += `  export: ${hop.reference.to} -> ${hop.to}\n`;
+        const reference = graph.references[hop.edge.reference];
+        text += `  export: ${reference?.to ?? ""} -> ${graph.symbols[hop.to]?.id ?? ""}\n`;
       }
     }
   } else if (found === undefined) {
-    const references = referencesOf(analysis.configured).filter((one) => one.to === subject.id);
+    const references = graph.references.flatMap((one, place) =>
+      one.to === subject.id ? [place] : [],
+    );
     text +=
       "  unreachable: no path of references reaches it from a root, a loaded consumer or a test file no project holds\n";
     text += `  references: ${String(references.length)}\n`;
-    for (const reference of references) {
-      text += referenceLine(reference, `from ${madeBy(reference)}`, support);
+    for (const place of references) {
+      const reference = graph.references[place];
+      if (reference !== undefined) {
+        text += referenceLine(reference, `from ${madeBy(reference)}`, support, {
+          making: graph.configurations[place] ?? [],
+          run: matrix.configurations,
+        });
+      }
     }
   }
   if (candidate !== undefined) {
@@ -371,12 +258,7 @@ function namedElsewhere(findings: readonly CompletedFinding[], subject: Inventor
 }
 
 /** The one explanation that applies to a declaration, built whole before it is written. */
-function explanation(
-  analysis: RunAnalysis,
-  subject: InventorySymbol,
-  cascade: Cascade,
-  mode: Mode,
-): string {
+function explanation(analysis: RunAnalysis, subject: InventorySymbol, cascade: Cascade): string {
   const graph = analysis.swept.matrix.union;
   const at = graph.at(subject.id);
   let text = `symbol: ${subject.ref}\n`;
@@ -384,7 +266,7 @@ function explanation(
   text += `position: ${subject.id}\n`;
   text += `configurations: ${listed(analysis.swept.matrix.heldIn[at] ?? [])}\n`;
   const found = analysis.result.findings.find((one) => positionKey(one.position) === subject.id);
-  const retained = analysis.swept.retained.filter((one) => one.id === subject.id);
+  const retained = analysis.swept.sweep.retained.filter((one) => one.id === subject.id);
   if (found !== undefined) {
     text += reported(found);
   } else if (retained.length > 0) {
@@ -392,11 +274,11 @@ function explanation(
     for (const one of retained) {
       text += `  class: ${one.class}\t${positionKey(one.site)}\t${one.detail}\n`;
     }
-  } else if (analysis.swept.heldByUnanswered.includes(subject.id)) {
+  } else if (analysis.swept.sweep.held.includes(subject.id)) {
     text +=
       "answer: held\n  held by: a question the checker did not answer, which could have kept it live, so no finding names it\n";
   } else {
-    text += liveness(analysis, subject, cascade, mode);
+    text += liveness(analysis, subject, cascade);
   }
   return text + namedElsewhere(analysis.result.findings, subject);
 }
@@ -404,10 +286,10 @@ function explanation(
 /**
  * Explains one symbol from the analysis the report is built from: why a reported symbol is
  * reported, which exemption classes held a retained one back, that an unanswered question held
- * a held one, and for any other declaration the relations that hold it live and the shortest
- * path from a root, a loaded consumer or a test file no project holds, or the references it
- * has where no path reaches it. A request naming no one declaration exits with the usage
- * code and names what partially matches it. Where the analysis was partial, the error stream says so.
+ * a held one, and for any other declaration the relations that hold it live and the path the
+ * sweep's strongest tier reaching it follows, or the references it has where no path reaches
+ * it. A request naming no one declaration exits with the usage code and names what partially
+ * matches it. Where the analysis was partial, the error stream says so.
  */
 export const explainVerb: Verb = ({ out, err, host, inputs, scope, openClient, option }) => {
   const named = namedSymbol(option);
@@ -430,7 +312,7 @@ export const explainVerb: Verb = ({ out, err, host, inputs, scope, openClient, o
       err.write("  no symbol of the target partially matches it either\n");
     }
   } else {
-    out.write(explanation(analysis, subject, config.reporters.cascade, mode));
+    out.write(explanation(analysis, subject, config.reporters.cascade));
   }
   for (const note of notes) {
     diagnose(err, note);

package/src/verbs/print-retained.ts

@@ -21,7 +21,7 @@ export const printRetainedVerb: Verb = ({ out, err, host, inputs, scope, openCli
     marked: [],
     mode: productionMode(config),
   });
-  for (const line of retainedLines(swept.matrix.union.symbols, swept.retained)) {
+  for (const line of retainedLines(swept.matrix.union.symbols, swept.sweep.retained)) {
     out.write(`${line}\n`);
   }
   for (const note of partialNotes({

package/dist/src/matrix.js

@@ -1,275 +0,0 @@
-/**
- * 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, OUTSIDE } from "./graph.js";
-import { byPosition } from "./position.js";
-import { edgeWithheldBy } from "./tests/file-class.js";
-import { reachedWithTheTests, splitRefs, sweep, } from "./sweep.js";
-/**
- * What makes one reference one reference, whichever configuration made it. A consumer's
- * position is rendered against its own root, so the consumer is part of what it names.
- */
-export function referenceKey(reference) {
-    const { path, line, column } = reference.position;
-    return [
-        reference.consumer ?? "",
-        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 by its rendered position, with the fields of the first
- * configuration that judges it; one in a file every holder holds only for its references
- * is judged by none and is not in the union. One reference at one position of a file
- * several configurations compile is one reference; two one configuration makes are two.
- */
-export function matrixOf(per) {
-    const symbols = [];
-    const holders = new Map();
-    const references = [];
-    const firstSeen = new Map();
-    const judged = new Set();
-    const dependents = new Map();
-    per.forEach((one, index) => {
-        for (const [id, after] of one.dependents ?? []) {
-            if (!dependents.has(id)) {
-                dependents.set(id, after);
-            }
-        }
-        const referenceOnly = new Set(one.referenceOnly);
-        for (const symbol of one.symbols) {
-            const held = holders.get(symbol.id);
-            if (held === undefined) {
-                holders.set(symbol.id, [one.configuration]);
-            }
-            else if (!held.includes(one.configuration)) {
-                held.push(one.configuration);
-            }
-            if (!referenceOnly.has(symbol.position.path) && !judged.has(symbol.id)) {
-                judged.add(symbol.id);
-                symbols.push(symbol);
-            }
-        }
-        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));
-    const testUsed = new Set(per.flatMap((one) => one.testUsedFiles ?? []));
-    return {
-        configurations: per.map((one) => one.configuration),
-        graphs: per.map((one) => graphOf(one.symbols, one.references, one.roots, one.testFiles, one.supportFiles, one.ambient)),
-        union: graphOf(symbols, references, per.flatMap((one) => one.roots), [...new Set(per.flatMap((one) => one.testFiles))], [...new Set(per.flatMap((one) => one.supportFiles ?? []))], new Set(per.flatMap((one) => [...(one.ambient ?? [])]))),
-        heldIn: symbols.map((symbol) => holders.get(symbol.id) ?? []),
-        testUsed: symbols.map((symbol) => testUsed.has(symbol.position.path)),
-        dependents,
-    };
-}
-/**
- * Which declarations of the run are dead in every configuration that holds them. Each
- * configuration is swept on its own graph, since a file it does not compile references nothing
- * there and a root it does not hold seeds nothing. A declaration is a candidate when every
- * configuration holding it judged it one; its relation is reference counting where every one
- * found it so, else reachability, and its counts are the union's. Components are computed once,
- * over the union and the intersected dead set, so one dead component has 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 heldBy = union.symbols.map(() => undefined);
-    const held = [
-        ...input.marked,
-        ...(input.exempt ?? []).map((record) => record.id),
-        ...(input.unanswered ?? []),
-    ];
-    const testReached = reachedWithTheTests(union, held);
-    // A test uses what it names: a file a test reads through a star re-export or a
-    // namespace keeps the exports nothing names at their own class.
-    const testNamed = reachedWithTheTests(union, held, false);
-    const everywhere = union.symbols.map((symbol, at) => {
-        const held = matrix.heldIn[at] ?? [];
-        const found = held.map((configuration) => byConfiguration.get(configuration)?.get(symbol.id));
-        return held.length === 0 || found.some((candidate) => candidate === undefined)
-            ? undefined
-            : found.filter((candidate) => candidate !== undefined);
-    });
-    const compiled = compiledReferences(matrix, new Set(union.symbols.flatMap((symbol, at) => (everywhere[at] === undefined ? [] : [symbol.id]))), input.mode);
-    const judged = everywhere.map((found, at) => compiled.has(union.symbols[at]?.id ?? "") ? undefined : found);
-    // A configuration that does not hold a test's subject's caller finds the subject dead,
-    // so a test is of dead code only where every production subject it names is dead in
-    // every configuration that holds it.
-    const subjectsDead = (at) => (union.out[at] ?? []).every((edge) => union.test[edge.to] === true ||
-        union.support[edge.to] === true ||
-        union.ambient[edge.to] === true ||
-        union.subject[edge.to] !== true ||
-        judged[edge.to] !== undefined);
-    const admittedAt = (at) => judged[at]?.every((candidate) => candidate.testOfDeadCode) === true && subjectsDead(at);
-    const kept = keptByTests(union, testReached, admittedAt);
-    const testUsed = testUsedReach(union, union.symbols.map((_symbol, at) => matrix.testUsed[at] === true && testNamed[at] === true), judged.map((one) => one !== undefined));
-    const candidates = [];
-    union.symbols.forEach((symbol, at) => {
-        const all = judged[at];
-        if (all === undefined) {
-            return;
-        }
-        const held = matrix.heldIn[at] ?? [];
-        const admitted = admittedAt(at);
-        const split = splitRefs(union.made[at], input.mode);
-        const testRefs = split.test;
-        const heldByTests = heldBy[union.parent[at] ?? OUTSIDE] ??
-            (union.support[at] === true && testRefs > 0 && !admitted ? symbol.id : undefined);
-        const unreferenced = union.test[at] === true && !admitted && testReached[at] !== true;
-        heldBy[at] = heldByTests;
-        const productionRefs = split.production;
-        const counted = all.every((candidate) => candidate.relation === "reference-counting");
-        candidates.push({
-            id: symbol.id,
-            productionRefs,
-            testRefs,
-            // The run that judges a test-file declaration counts its test references.
-            relation: (unreferenced ? productionRefs + testRefs === 0 : counted)
-                ? "reference-counting"
-                : "reachability",
-            testOfDeadCode: admitted,
-            configurations: held,
-            heldByTests,
-            unreferencedTest: unreferenced,
-            testUsed: testUsed[at] === true,
-            keptByTests: kept[at] === true,
-        });
-    });
-    const liveUnder = liveAnywhere(union.symbols, per);
-    return {
-        liveUnder,
-        candidates,
-        components: deadComponents(matrix, { liveUnder, candidates }, new Set()),
-    };
-}
-/**
- * Every declaration of `dead`, those dead in every configuration that holds them, that a
- * configuration's graph references from a judged declaration outside `dead` or already
- * kept, until none joins: deleting one would break that configuration's compile. A
- * production run counts no reference a test file made.
- */
-function compiledReferences(matrix, dead, mode) {
-    const kept = new Set();
-    for (let changed = true; changed;) {
-        changed = false;
-        for (const graph of matrix.graphs) {
-            graph.out.forEach((edges, from) => {
-                const id = graph.symbols[from]?.id ?? "";
-                if (graph.subject[from] !== true || (dead.has(id) && !kept.has(id))) {
-                    return;
-                }
-                for (const edge of edges) {
-                    const to = graph.symbols[edge.to]?.id ?? "";
-                    if (!edgeWithheldBy(mode, edge) && dead.has(to) && !kept.has(to)) {
-                        kept.add(to);
-                        changed = true;
-                    }
-                }
-            });
-        }
-    }
-    return kept;
-}
-/** Per declaration of the union, whether one of `seeds` is it or reaches it through `dead` declarations. */
-function testUsedReach(union, seeds, dead) {
-    // A file is no candidate, and its top level is what reaches what it alone calls.
-    const reached = seeds.map((seed, at) => seed && dead[at] === true);
-    const queue = seeds.flatMap((one, at) => (one ? [at] : []));
-    for (let at = queue.pop(); at !== undefined; at = queue.pop()) {
-        for (const edge of union.out[at] ?? []) {
-            if (dead[edge.to] === true && reached[edge.to] !== true) {
-                reached[edge.to] = true;
-                queue.push(edge.to);
-            }
-        }
-    }
-    return reached;
-}
-/** Per declaration of the union, whether test code `reached` holds and `admitted` rejects references it. */
-function keptByTests(union, reached, admitted) {
-    const kept = union.symbols.map(() => false);
-    union.out.forEach((edges, from) => {
-        const testCode = union.test[from] === true || union.support[from] === true;
-        if (!testCode || reached[from] !== true || admitted(from)) {
-            return;
-        }
-        for (const edge of edges) {
-            if (edge.test) {
-                kept[edge.to] = true;
-            }
-        }
-    });
-    return kept;
-}
-/**
- * The dead components of one sweep over the union, with the file declarations at `files`
- * dead as well: a file that is deleted whole takes the declarations it holds and every
- * dead declaration only its top level references with it.
- */
-export function deadComponents(matrix, result, files) {
-    const union = matrix.union;
-    const byId = new Map(result.candidates.map((candidate) => [candidate.id, candidate]));
-    const candidateAt = (at) => byId.get(union.symbols[at]?.id ?? "");
-    return componentsOf(union, union.symbols.map((_symbol, at) => {
-        const candidate = candidateAt(at);
-        return files.has(at) || (candidate !== undefined && candidate.heldByTests === undefined);
-    }), union.symbols.map((_symbol, at) => candidateAt(at)?.testOfDeadCode === true), union.symbols.map((_symbol, at) => candidateAt(at)?.unreferencedTest === true), positionsOf(union, matrix.dependents, result.liveUnder));
-}
-/**
- * The file declarations at `paths`, below the target root, that one sweep holds live
- * under both relations, the rule a judged declaration is live by.
- */
-export function liveFilesAt(matrix, result, paths) {
-    return matrix.union.symbols.filter((symbol) => symbol.kind === "file" &&
-        paths.has(symbol.position.path) &&
-        (result.liveUnder.get(symbol.id)?.length ?? 0) === RELATIONS.length);
-}
-/**
- * Each declaration's dependents by its place in the union, and per place whether the
- * declaration is live under reachability in some configuration.
- */
-function positionsOf(union, dependents, liveUnder) {
-    return {
-        dependents: union.symbols.map((symbol) => (dependents.get(symbol.id) ?? []).map((id) => union.at(id)).filter((at) => at !== OUTSIDE)),
-        live: union.symbols.map((symbol) => liveUnder.get(symbol.id)?.includes("reachability") === true),
-    };
-}
-/** 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;
-}