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

package/dist/src/sweep.js

@@ -1,234 +0,0 @@
-/**
- * Which declarations of one graph are dead, and under which liveness relation.
- * Reference counting holds a declaration live when any declaration references it,
- * whatever that one's own liveness, or when it is a root of a kind that names a caller;
- * reachability holds it live when a path of references reaches it from a root. So a
- * declaration only unreachable ones reference is live under the first, dead under the second.
- */
-import { namesACaller, OUTSIDE } from "./graph.js";
-import { edgeWithheldBy } from "./tests/file-class.js";
-/** The references to one declaration the mode counts: under `production` none test code made but those it classes as production. */
-function countedRefs(made, mode) {
-    if (made === undefined) {
-        return 0;
-    }
-    if (!mode.production) {
-        return made.production + made.test;
-    }
-    return made.production + (mode.consumerTestsProduction === true ? made.consumerTest : 0);
-}
-/** The references to one declaration, split as the mode classes them, whatever it counts. */
-export function splitRefs(made, mode) {
-    const moved = mode.consumerTestsProduction === true ? (made?.consumerTest ?? 0) : 0;
-    return { production: (made?.production ?? 0) + moved, test: (made?.test ?? 0) - moved };
-}
-/**
- * Answers which declarations of one graph are dead under the input's mode.
- *
- * The order is the order the answers depend on: the callers and the marks are live
- * before either relation runs, the candidate set is every judged declaration at least
- * one relation does not hold live and no exemption holds back, and the tests of dead
- * code join it.
- */
-export function sweep(graph, input) {
-    const marked = flagged(graph, input.marked);
-    const exempt = flagged(graph, [
-        ...(input.exempt ?? []).map((record) => record.id),
-        ...(input.unanswered ?? []),
-    ]);
-    const held = marked.map((mark, at) => mark || exempt[at] === true);
-    // Every root, every mark and every exemption seeds reachability. A root of a kind that
-    // names a caller, and a mark, are live under reference counting as well; a root that
-    // only supposes a caller is not, and neither is an exemption.
-    const called = graph.symbols.map(() => false);
-    for (const root of graph.rooted) {
-        if (namesACaller(root.kind)) {
-            called[root.at] = true;
-        }
-    }
-    const counted = (at) => countedRefs(graph.made[at], input.mode);
-    const reached = reachable(graph, held, input.mode);
-    const liveUnder = graph.symbols.map((_symbol, at) => {
-        const relations = [];
-        if (marked[at] === true || called[at] === true || counted(at) > 0) {
-            relations.push("reference-counting");
-        }
-        if (reached[at] === true) {
-            relations.push("reachability");
-        }
-        return relations;
-    });
-    const dead = graph.symbols.map((_symbol, at) => graph.subject[at] === true && exempt[at] !== true && (liveUnder[at]?.length ?? 0) < 2);
-    const testOfDeadCode = admitTestsOfDeadCode(graph, dead, held);
-    const candidates = [];
-    const live = new Map();
-    graph.symbols.forEach((symbol, at) => {
-        const relations = liveUnder[at] ?? [];
-        if (relations.length > 0) {
-            live.set(symbol.id, relations);
-        }
-        if (dead[at] !== true) {
-            return;
-        }
-        const split = splitRefs(graph.made[at], input.mode);
-        candidates.push({
-            id: symbol.id,
-            productionRefs: split.production,
-            testRefs: split.test,
-            relation: counted(at) === 0 ? "reference-counting" : "reachability",
-            testOfDeadCode: testOfDeadCode[at] === true,
-        });
-    });
-    return { liveUnder: live, candidates };
-}
-/**
- * The directory a test runner reads a manual mock from, whose exports it puts in place of
- * the module's: https://jestjs.io/docs/manual-mocks
- */
-const MANUAL_MOCKS = "__mocks__";
-/** Whether a test runner calls or reads one export of a test file: a function, or any export of a manual mock. */
-export function runnerCalls(symbol) {
-    return symbol.kind === "function" || symbol.position.path.split("/").includes(MANUAL_MOCKS);
-}
-/**
- * Per declaration of the graph, whether the run that counts test references reaches it.
- * That run's roots are the graph's own and, of each test file, its top level and every
- * function it exports, which a test runner may call, and every export of a manual mock,
- * which the runner reads; any other export of a test file, and test-support code, which
- * runs where a test imports it, are judged as any file's are. `held` seeds it as a mark
- * seeds a sweep; with `namespaces` false a file read reaches none of the file's exports.
- */
-export function reachedWithTheTests(graph, held, namespaces = true) {
-    const tests = graph.symbols.flatMap((symbol, at) => {
-        const exported = symbol.exported && graph.symbols[graph.parent[at] ?? OUTSIDE]?.kind === "file";
-        const called = exported && runnerCalls(symbol);
-        return graph.test[at] === true &&
-            graph.support[at] !== true &&
-            (symbol.kind === "file" || called)
-            ? [{ at, kind: "test-runner" }]
-            : [];
-    });
-    return reachable({ ...graph, rooted: [...graph.rooted, ...tests] }, flagged(graph, held), { production: false }, namespaces);
-}
-/**
- * The references a loaded consumer or an unheld file makes that the mode counts. A
- * production mode counts no test reference, but a loaded consumer's where the mode classes
- * a consumer's tests as production.
- */
-function callsOf(graph, mode) {
-    return graph.consumed.filter((edge) => !edgeWithheldBy(mode, edge));
-}
-/** Per declaration of the graph, whether one of the identifiers names it. */
-function flagged(graph, ids) {
-    const flags = graph.symbols.map(() => false);
-    for (const id of ids) {
-        const at = graph.at(id);
-        if (at !== OUTSIDE) {
-            flags[at] = true;
-        }
-    }
-    return flags;
-}
-/**
- * Per declaration, whether a seed reaches it. The two seeds reach through different
- * reference sets: a held declaration, marked or exempt, is live by a mechanism the
- * analysis cannot see, so no mode withholds a reference it makes, a test declaration's
- * included, while a root reaches through the references the mode counts. The held seed
- * runs first, so what it reaches is expanded under the wider rule.
- */
-function reachable(graph, held, mode, namespaces = true) {
-    const reached = graph.symbols.map(() => false);
-    const expanded = graph.symbols.map(() => false);
-    const queue = [];
-    // Reaching a file reaches its top level: the references written outside every
-    // declaration it holds. A reference that reads a file reads the module's namespace,
-    // which reaches what the module exports as well. An evaluation runs the top level
-    // and reads no export, and a root does not expand either: a file a runtime runs
-    // without reading its exports is a root by itself.
-    const enter = (at, expands) => {
-        if (!reached[at]) {
-            reached[at] = true;
-            queue.push(at);
-        }
-        if (!expands || expanded[at] === true) {
-            return;
-        }
-        expanded[at] = true;
-        for (const exported of graph.exportsOf[at] ?? []) {
-            enter(exported, false);
-        }
-    };
-    const walk = (holding) => {
-        for (let at = queue.pop(); at !== undefined; at = queue.pop()) {
-            for (const edge of graph.out[at] ?? []) {
-                if (!holding && edgeWithheldBy(mode, edge)) {
-                    continue;
-                }
-                enter(edge.to, namespaces && !edge.evaluation);
-            }
-        }
-    };
-    held.forEach((hold, at) => {
-        if (hold) {
-            enter(at, false);
-        }
-    });
-    walk(true);
-    for (const root of graph.rooted) {
-        enter(root.at, false);
-    }
-    // A consumer's reference reaches what it names as one of the target's own does.
-    for (const edge of callsOf(graph, mode)) {
-        enter(edge.to, namespaces && !edge.evaluation);
-    }
-    walk(false);
-    return reached;
-}
-/**
- * Admits every test declaration whose set of referenced production declarations is
- * non-empty and wholly dead, and returns which it admitted. An ambient declaration describes
- * code the target does not implement, so it is no production declaration here. The set is
- * read from every reference the test makes, which a production sweep does not count. A
- * test-support declaration a test referencing a live target also references is a live
- * target of every test referencing it. A marked or exempt test is never admitted.
- */
-function admitTestsOfDeadCode(graph, dead, held) {
-    const testCode = (at) => graph.test[at] === true || graph.support[at] === true;
-    const judged = graph.symbols.map((_symbol, at) => {
-        let targets = 0;
-        let live = 0;
-        if (testCode(at) && graph.subject[at] === true && held[at] !== true) {
-            for (const edge of graph.out[at] ?? []) {
-                if (testCode(edge.to) ||
-                    graph.subject[edge.to] !== true ||
-                    graph.ambient[edge.to] === true) {
-                    continue;
-                }
-                targets += 1;
-                if (dead[edge.to] !== true) {
-                    live += 1;
-                }
-            }
-        }
-        return { targets, live };
-    });
-    const shared = new Set();
-    judged.forEach(({ live }, at) => {
-        if (live > 0) {
-            for (const edge of graph.out[at] ?? []) {
-                if (graph.support[edge.to] === true) {
-                    shared.add(edge.to);
-                }
-            }
-        }
-    });
-    const admitted = graph.symbols.map(() => false);
-    judged.forEach(({ targets, live }, at) => {
-        const sharing = (graph.out[at] ?? []).some((edge) => shared.has(edge.to) && edge.to !== at);
-        if (targets > 0 && live === 0 && !sharing) {
-            dead[at] = true;
-            admitted[at] = true;
-        }
-    });
-    return admitted;
-}

package/src/matrix.ts

@@ -1,466 +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, type Component, type Positional } from "./components.ts";
-import { graphOf, OUTSIDE, 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/root-set.ts";
-import { edgeWithheldBy } from "./tests/file-class.ts";
-import {
-  reachedWithTheTests,
-  splitRefs,
-  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 paths of the test-support files, which only test code imports. */
-  readonly supportFiles?: readonly string[] | undefined;
-  /** The paths of the files only tests reach that are no test-support file. */
-  readonly testUsedFiles?: readonly string[] | undefined;
-  /** The ids of the ambient declarations, which describe code the target does not implement. */
-  readonly ambient?: ReadonlySet<string> | undefined;
-  /**
-   * The paths of the workspace-package files the configuration holds but does not
-   * compile itself. Their declarations count in its graph and its verdict on them is no
-   * finding.
-   */
-  readonly referenceOnly?: readonly string[] | undefined;
-  /** Each declaration's dependents, by id, as the configuration's inventory states them. */
-  readonly dependents?: ReadonlyMap<string, readonly string[]> | undefined;
-}
-
-/** 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 a configuration
-   * holds in a file it does not hold only for its references, 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[])[];
-  /**
-   * Per declaration of {@link Matrix.union}, whether a file only tests reach that is no
-   * test-support file holds it in some configuration: production code only tests use.
-   */
-  readonly testUsed: readonly boolean[];
-  /** Each declaration's dependents, by id, as the first configuration holding it states them. */
-  readonly dependents: ReadonlyMap<string, 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[];
-  /**
-   * The declaration of test-support code that test code references, outside the
-   * test-of-dead-code rule, that is or contains this one, the outermost where two do.
-   * Such a declaration is not dead while test code references it, so neither it nor a
-   * declaration it contains is a member of a dead component.
-   */
-  readonly heldByTests: string | undefined;
-  /**
-   * Whether a test file declares it, no test of dead code, and the run that counts test
-   * references does not reach it: it is reported as a production declaration of its
-   * shape nothing references would be.
-   */
-  readonly unreferencedTest: boolean;
-  /**
-   * Whether it is dead only because code only tests use is: production code only tests
-   * use holds it and the run that counts test references reaches it, or such a
-   * declaration reaches it through dead declarations.
-   */
-  readonly testUsed: boolean;
-  /**
-   * Whether test code the run that counts test references reaches, and that is no test of
-   * dead code, references it: a test that stays keeps it.
-   */
-  readonly keptByTests: boolean;
-}
-
-/** 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[];
-}
-
-/**
- * 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: Reference): string {
-  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: readonly Configured[]): Matrix {
-  const symbols: InventorySymbol[] = [];
-  const holders = new Map<string, string[]>();
-  const references: Reference[] = [];
-  const firstSeen = new Map<string, number>();
-  const judged = new Set<string>();
-  const dependents = new Map<string, readonly string[]>();
-  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: 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 heldBy: (string | undefined)[] = 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): readonly Candidate[] | undefined => {
-    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 is 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: number): boolean =>
-    (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: number): boolean =>
-    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: MatrixCandidate[] = [];
-  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: Matrix,
-  dead: ReadonlySet<string>,
-  mode: SweepInput["mode"],
-): ReadonlySet<string> {
-  const kept = new Set<string>();
-  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: Graph,
-  seeds: readonly boolean[],
-  dead: readonly boolean[],
-): readonly boolean[] {
-  // 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: Graph,
-  reached: readonly boolean[],
-  admitted: (at: number) => boolean,
-): readonly boolean[] {
-  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: Matrix,
-  result: Pick<SweepResult, "liveUnder" | "candidates">,
-  files: ReadonlySet<number>,
-): readonly Component[] {
-  const union = matrix.union;
-  const byId = new Map(result.candidates.map((candidate) => [candidate.id, candidate]));
-  const candidateAt = (at: number): MatrixCandidate | undefined =>
-    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: Matrix,
-  result: SweepResult,
-  paths: ReadonlySet<string>,
-): readonly InventorySymbol[] {
-  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: Graph,
-  dependents: ReadonlyMap<string, readonly string[]>,
-  liveUnder: ReadonlyMap<string, readonly Relation[]>,
-): Positional {
-  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: 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;
-}