@cplieger/deadset-ts 8.0.0-dev.1 → 8.0.0-dev.2

package/src/analysis.ts

@@ -977,7 +977,7 @@ function readRun<Extra>(
   }));
   // Test-support code is code only test code imports in any configuration of the run: a
   // configuration that holds no test file says nothing about what the tests import.
-  const support = testSupportFiles(
+  const { support, testUsed } = testSupportFiles(
     withOutside.flatMap((one) => one.projectRead.held.symbols),
     withOutside.flatMap((one) => one.references),
     withOutside.flatMap((one) => one.projectRead.rooted.liveUnderReachability),
@@ -999,6 +999,7 @@ function readRun<Extra>(
     const made = supportReferences([...one.references, ...(satisfied?.references ?? [])], support);
     const held = new Set(projectRead.held.symbols.map((symbol) => symbol.position.path));
     const supportFiles = [...support].filter((path) => held.has(path)).sort();
+    const testUsedFiles = [...testUsed].filter((path) => held.has(path)).sort();
     const configured: Configured = {
       configuration: projectRead.configuration,
       symbols: projectRead.held.symbols,
@@ -1006,6 +1007,7 @@ function readRun<Extra>(
       roots: projectRead.rooted.liveUnderReachability,
       testFiles: [...one.testFiles, ...supportFiles],
       ...(supportFiles.length === 0 ? {} : { supportFiles }),
+      ...(testUsedFiles.length === 0 ? {} : { testUsedFiles }),
       ...(projectRead.held.ambient.size === 0 ? {} : { ambient: projectRead.held.ambient }),
       ...(projectRead.referenceOnly.length === 0
         ? {}

package/src/augmentations.ts

@@ -26,25 +26,24 @@ function isGlobalBlock(
 }
 
 /**
- * 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.
+ * Per declaration, the interfaces and namespaces between it and the augmentation block or
+ * the file in `scripts` that holds it, with the block itself, or none where no such block
+ * or file holds it; and whether that holder is the global scope rather than a module
+ * declaration. `scripts` holds the files that are no module, by identifier.
  */
-export function augmentationReferences(
+function holdersOf(
   held: Inventory,
-  found: readonly Reference[],
-  scripts: ReadonlySet<string> = new Set(),
-): readonly Reference[] {
+  scripts: ReadonlySet<string>,
+): ((id: string) => { readonly ids: readonly string[]; readonly global: boolean }) | undefined {
   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 && scripts.size === 0) {
-    return [];
+    return undefined;
   }
   const byId = new Map(held.symbols.map((one) => [one.id, one]));
-  const holders = (id: string): string[] => {
+  return (id) => {
     const ids: string[] = [];
     for (
       let at = byId.get(byId.get(id)?.parent ?? "");
@@ -52,29 +51,73 @@ export function augmentationReferences(
       at = byId.get(at.parent)
     ) {
       if (globals.has(at.id) || held.modules.has(at.id)) {
-        return [...ids, at.id];
+        return { ids: [...ids, at.id], global: globals.has(at.id) };
       }
       if (scripts.has(at.id)) {
-        return ids;
+        return { ids, global: true };
       }
       if (at.kind === "interface" || at.kind === "namespace") {
         ids.push(at.id);
       }
     }
-    return [];
+    return { ids: [], global: false };
   };
+}
+
+/**
+ * The ambient interfaces of the global scope among `interfaces`: each one a declaration
+ * file or a `declare` holds that a `declare global` block, or the top level of a file in
+ * `scripts`, declares, directly or inside a namespace there.
+ */
+export function ambientGlobalInterfaces(
+  held: Inventory,
+  interfaces: readonly string[],
+  scripts: ReadonlySet<string>,
+): readonly string[] {
+  const holders = holdersOf(held, scripts);
+  return holders === undefined
+    ? []
+    : interfaces.filter((id) => held.ambient.has(id) && holders(id).global);
+}
+
+/**
+ * For each reference to a declaration an augmentation block, or the global scope of a
+ * file in `scripts` (the files that are no module), 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. A read through an interface of `merged`, an ambient global interface merging
+ * into a language or library one, is a production read whoever writes it: it types a
+ * value the runtime provides, so a test reading a member needs it as code does.
+ */
+export function augmentationReferences(
+  held: Inventory,
+  found: readonly Reference[],
+  scripts: ReadonlySet<string> = new Set(),
+  merged: ReadonlySet<string> = new Set(),
+): readonly Reference[] {
+  const holders = holdersOf(held, scripts);
+  if (holders === undefined) {
+    return [];
+  }
+  const fileOf = new Map(
+    held.symbols.filter((one) => one.kind === "file").map((one) => [one.position.path, one.id]),
+  );
   // Two uses at one place of declarations one block holds read the block once there.
   const made = new Set(found.map(referenceKey));
   const reads = new Map<string, Reference>();
   for (const reference of found) {
-    for (const to of holders(reference.to)) {
+    const { ids } = holders(reference.to);
+    // A test's read through such an interface is held by the test file, which the test
+    // runner loads whichever of its declarations runs.
+    const typed = reference.test && ids.some((id) => merged.has(id));
+    const from = typed ? (fileOf.get(reference.position.path) ?? reference.from) : reference.from;
+    for (const to of ids) {
       const read: Reference = {
-        from: reference.from,
+        from,
         to,
         position: reference.position,
         use: "read",
         resolution: reference.resolution,
-        test: reference.test,
+        test: reference.test && !typed,
       };
       const key = referenceKey(read);
       if (!made.has(key) && !reads.has(key)) {

package/src/conformance-record.ts

@@ -4,7 +4,7 @@ export const RECORD = {
   conformance: {
     corpusVersion: "6.0.0",
     result: "pass",
-    digest: "sha256:76c07ac14bda6e302444918d832b01844bac6f29b6f22a742d538804480c0769",
+    digest: "sha256:d65daae4b7c95050c07896b166d0250d233cca71f97de75a6086c1d80fe76232",
   },
   gaps: [],
 } as const;

package/src/convention-rows.ts

@@ -209,6 +209,31 @@ const ANGULAR_PACKAGE_KEYS: readonly PackageKey[] = [
   "scripts",
 ].map((key) => ({ key, files: ["angular.json"] }));
 
+/**
+ * The test runners and the assertion, mock and runner libraries whose import is test
+ * evidence beside each runner a row reads test files for. Each applies whether or not a
+ * manifest declares it, so none is a row.
+ */
+export const TEST_LIBRARIES: readonly string[] = [
+  "@jest/globals",
+  "@playwright/test",
+  "ava",
+  "chai",
+  "expect",
+  "jasmine",
+  "jest",
+  "mocha",
+  "msw",
+  "nock",
+  "node:test",
+  "sinon",
+  "tap",
+  "uvu",
+];
+
+/** The scopes every package of which is a test library. */
+export const TEST_LIBRARY_SCOPES: readonly string[] = ["@testing-library/"];
+
 /** Every row, ordered by name and then by range. */
 export const CONVENTION_ROWS: readonly ConventionRow[] = [
   {

package/src/finding.ts

@@ -119,6 +119,11 @@ export interface CompletedFinding extends Finding {
   readonly reachabilityClass: Confidence;
   /** The reachability class capped by the code's ceiling. */
   readonly confidence: Confidence;
+  /**
+   * Where test-used code alone lowers the confidence, the one the finding would carry
+   * otherwise, which its component's cap and the dials read.
+   */
+  readonly componentConfidence?: Confidence;
   /**
    * The relation that decided the subject: present on a declaration the sweep judged
    * dead, absent on a live one and on a subject that is no declaration.

package/src/findings/completion.ts

@@ -132,6 +132,20 @@ function reachabilityClasses(input: EmitterInput): (id: string) => Confidence {
   };
 }
 
+/** The target symbols one test of dead code references, by id: production declarations the sweep judges. */
+function testTargets(union: Graph, id: string): readonly string[] {
+  return (union.out[union.at(id)] ?? []).flatMap((edge) => {
+    const target = union.symbols[edge.to];
+    const testCode = union.test[edge.to] === true || union.support[edge.to] === true;
+    return target !== undefined &&
+      !testCode &&
+      union.ambient[edge.to] !== true &&
+      union.subject[edge.to] === true
+      ? [target.id]
+      : [];
+  });
+}
+
 /**
  * The confidence ceiling of a test of dead code: the lowest reachability class among the
  * target symbols it references, because its deadness is theirs, whether or not they share
@@ -145,25 +159,40 @@ function testCeilings(
   const tests = new Set(
     input.swept.sweep.candidates.filter((one) => one.testOfDeadCode).map((one) => one.id),
   );
-  return (id) => {
-    let lowest: Confidence = "certain";
-    if (!tests.has(id)) {
-      return lowest;
-    }
-    for (const edge of union.out[union.at(id)] ?? []) {
-      const target = union.symbols[edge.to];
-      const testCode = union.test[edge.to] === true || union.support[edge.to] === true;
-      if (
-        target !== undefined &&
-        !testCode &&
-        union.ambient[edge.to] !== true &&
-        union.subject[edge.to] === true
-      ) {
-        lowest = capped(lowest, classOf(target.id));
-      }
+  return (id) =>
+    tests.has(id)
+      ? testTargets(union, id).reduce<Confidence>(
+          (lowest, target) => capped(lowest, classOf(target)),
+          "certain",
+        )
+      : "certain";
+}
+
+/**
+ * The subjects dead only because production code only tests use is: each declaration the
+ * sweep marks test-used, each `DS1502` file of such code, and each test of dead code every
+ * target of which is one. Nothing they hold references a dead declaration outside them, so
+ * the rest of a component they share is reported without them.
+ */
+function testUsedSubjects(input: EmitterInput): {
+  readonly declarations: ReadonlySet<string>;
+  readonly files: ReadonlySet<string>;
+} {
+  const { matrix, sweep } = input.swept;
+  const union = matrix.union;
+  const used = new Set(sweep.candidates.filter((one) => one.testUsed).map((one) => one.id));
+  for (const test of sweep.candidates.filter((one) => one.testOfDeadCode)) {
+    const targets = testTargets(union, test.id);
+    if (targets.length > 0 && targets.every((target) => used.has(target))) {
+      used.add(test.id);
     }
-    return lowest;
-  };
+  }
+  const files = new Set(
+    union.symbols.flatMap((symbol, at) =>
+      matrix.testUsed[at] === true ? [symbol.position.path] : [],
+    ),
+  );
+  return { declarations: used, files };
 }
 
 /**
@@ -321,6 +350,7 @@ export function completed(
   const candidates = new Map(swept.sweep.candidates.map((candidate) => [candidate.id, candidate]));
   const classOf = reachabilityClasses(input);
   const ceilingOf = testCeilings(input, classOf);
+  const testUsed = testUsedSubjects(input);
   const { components, computed, files } = runComponents(swept, findings);
   const componentOf = findingComponents(swept, components, input.config.reporters.cascade);
   const held = new Set(components.filter((one) => one.held).flatMap((one) => one.members));
@@ -394,8 +424,17 @@ export function completed(
       candidate === undefined
         ? union.made[at]
         : { production: candidate.productionRefs, test: candidate.testRefs };
-    const reachabilityClass =
+    const ownClass =
       judged === undefined ? (finding.reachabilityClass ?? "certain") : classOf(judged.id);
+    const used =
+      judged !== undefined
+        ? candidate !== undefined && testUsed.declarations.has(judged.id)
+        : finding.code === FILE_NEVER_IMPORTED && testUsed.files.has(finding.position.path);
+    const reachabilityClass = used && candidate?.testOfDeadCode !== true ? "possible" : ownClass;
+    const untested = capped(
+      capped(capped(ownClass, row.maxClass), rootsCeiling(input, finding, candidate)),
+      judged === undefined ? "certain" : ceilingOf(judged.id),
+    );
     const generated = input.files.generated?.has(finding.position.path) === true;
     const fixability = generated
       ? "none"
@@ -420,10 +459,8 @@ export function completed(
       position: finding.position,
       symbol: finding.symbol,
       reachabilityClass,
-      confidence: capped(
-        capped(capped(reachabilityClass, row.maxClass), rootsCeiling(input, finding, candidate)),
-        judged === undefined ? "certain" : ceilingOf(judged.id),
-      ),
+      confidence: used ? "possible" : untested,
+      ...(used ? { componentConfidence: untested } : {}),
       ...(candidate === undefined ? {} : { livenessRelation: candidate.relation }),
       testOnly: judged !== undefined && counts?.production === 0 && counts.test > 0,
       generated,
@@ -450,7 +487,7 @@ export function completed(
 /**
  * The findings with every finding of a dead component capped by the lowest confidence
  * among the component's root members, so the minimum confidence reports or withholds a
- * component whole.
+ * component whole but for the findings test-used code lowers on their own.
  */
 function componentCapped(
   findings: readonly CompletedFinding[],
@@ -461,17 +498,29 @@ function componentCapped(
     const { id, root } = finding.component;
     if (root && dead.has(id)) {
       const held = lowest.get(id);
-      lowest.set(id, held === undefined ? finding.confidence : capped(held, finding.confidence));
+      const own = componentConfidenceOf(finding);
+      lowest.set(id, held === undefined ? own : capped(held, own));
     }
   }
   return findings.map((finding) => {
     const cap = lowest.get(finding.component.id);
-    return cap === undefined || RANK[cap] >= RANK[finding.confidence]
-      ? finding
-      : { ...finding, confidence: cap };
+    if (cap === undefined) {
+      return finding;
+    }
+    const own = finding.componentConfidence;
+    return {
+      ...finding,
+      confidence: capped(finding.confidence, cap),
+      ...(own === undefined ? {} : { componentConfidence: capped(own, cap) }),
+    };
   });
 }
 
+/** The confidence a finding gives its component's cap and the dials. */
+function componentConfidenceOf(finding: CompletedFinding): Confidence {
+  return finding.componentConfidence ?? finding.confidence;
+}
+
 /** Whether the dials withhold a finding by its own severity or confidence. */
 function dialed(
   finding: Pick<CompletedFinding, "severity" | "confidence">,
@@ -494,7 +543,11 @@ export function dialsOf(
   const minConfidence = input.config.analysis.minConfidence;
   const components = new Set(
     findings
-      .filter((finding) => finding.component.root && dialed(finding, minConfidence))
+      .filter(
+        (finding) =>
+          finding.component.root &&
+          dialed({ ...finding, confidence: componentConfidenceOf(finding) }, minConfidence),
+      )
       .map((finding) => finding.component.id),
   );
   return {

package/src/findings/unused-declarations.ts

@@ -61,8 +61,9 @@ interface Judged {
  * The code one candidate is reported under, or none, each symbol once under the most
  * specific code: a test of dead code first; no other test-file declaration or enum
  * member nothing names; a test-support declaration test code references as test-only
- * use; then deprecation, a test reference, and the unreferenced codes, an unimportable
- * unused export being the unreachable kind's.
+ * use; then deprecation, a test reference, or only dead production references beside a
+ * test that stays, and the unreferenced codes, an unimportable unused export being the
+ * unreachable kind's.
  */
 function codeOf(judged: Judged): string | undefined {
   const { candidate, symbol } = judged;
@@ -85,7 +86,11 @@ function codeOf(judged: Judged): string | undefined {
   if (candidate.productionRefs === 0 && judged.deprecated) {
     return "DS1006";
   }
-  if (candidate.productionRefs === 0 && candidate.testRefs > 0) {
+  if (
+    candidate.testRefs > 0 &&
+    (candidate.productionRefs === 0 ||
+      (candidate.relation === "reachability" && candidate.keptByTests))
+  ) {
     return "DS1004";
   }
   if (MEMBERS.has(symbol.kind)) {
@@ -132,7 +137,9 @@ function messageOf(code: string, judged: Judged): string {
     case "DS1006":
       return `deprecated ${word} has no production reference`;
     case "DS1004":
-      return `${word} is referenced only from test files and never from production code`;
+      return candidate.productionRefs === 0
+        ? `${word} is referenced only from test files and never from production code`
+        : `${word} is referenced only from test files and from declarations that are themselves dead`;
   }
   const subject =
     code === "DS1003"

package/src/findings/visibility-narrowing.ts

@@ -63,6 +63,12 @@ function entersByName(kinds: ReadonlySet<RootKind> | undefined): boolean {
   return [...(kinds ?? [])].some((kind) => !PUBLISHING.has(kind) && !RUN_ONLY.has(kind));
 }
 
+/**
+ * The root kinds whose root of a file enters no export by name: a document's import roots
+ * each export it imports, so an export it does not import is judged as in any file.
+ */
+const PER_NAME: ReadonlySet<RootKind> = new Set<RootKind>(["document-import"]);
+
 /**
  * Whether the roots of a declaration's file enter it by name: a test runner's root
  * enters only an export the runner calls, so another export of a test file is judged.
@@ -72,7 +78,7 @@ function fileEntersByName(
   symbol: InventorySymbol,
 ): boolean {
   const entering = [...(kinds ?? [])].filter(
-    (kind) => !PUBLISHING.has(kind) && !RUN_ONLY.has(kind),
+    (kind) => !PUBLISHING.has(kind) && !RUN_ONLY.has(kind) && !PER_NAME.has(kind),
   );
   return (
     entering.some((kind) => kind !== "test-runner") || (entering.length > 0 && runnerCalls(symbol))
@@ -222,7 +228,7 @@ function narrowing(
  * export no code outside the target can import, because the manifest declares
  * `exports` and no root reaches it. Each arm yields to a more specific kind, so one
  * declaration is reported once: a test whose every subject is dead, an interface, a
- * declaration only a test file references, and a deprecated one.
+ * declaration only a test file references or a test that stays keeps, and a deprecated one.
  */
 function unreachable(
   facts: Facts,
@@ -237,7 +243,7 @@ function unreachable(
     (facts.rootedBy[at]?.size ?? 0) > 0 ||
     candidate.testOfDeadCode ||
     symbol.kind === "interface" ||
-    (candidate.productionRefs === 0 && candidate.testRefs > 0) ||
+    (candidate.testRefs > 0 && (candidate.productionRefs === 0 || candidate.keptByTests)) ||
     (candidate.productionRefs === 0 && input.deprecated.has(symbol.id))
   ) {
     return undefined;

package/src/kinds.ts

@@ -76,7 +76,7 @@ const ROWS: readonly KindRow[] = [
     code: "DS1004",
     name: "test-only-use",
     languages: ["go", "ts"],
-    rule: "A symbol with zero production references and at least one test reference: an unused-exported, unused-unexported or unused-member candidate whose test reference count is not zero, reported once under this code. A reference from a consumer's test files is a test reference unless the configuration counts consumer tests as production. A reference from test-support code, a package or file that only tests reach and that carries test evidence of its own language, is a test reference. A declaration of test-support code is test code and is no subject of this code, as grammar/analysis.md states. An interface method whose only calls and selections through the interface are in test code, and that DS1203's precondition does not exempt, is reported under this code. The methods implementing it are not reported with it, because the test reaches them through it.",
+    rule: "A symbol with zero production references and at least one test reference: an unused-exported, unused-unexported or unused-member candidate whose test reference count is not zero, reported once under this code. A reference from a consumer's test files is a test reference unless the configuration counts consumer tests as production. A reference from test-support code, a package or file that only tests reach and that carries test evidence of its own language, is a test reference. A declaration of test-support code is test code and is no subject of this code, as grammar/analysis.md states. An interface method whose only calls and selections through the interface are in test code, and that DS1203's precondition does not exempt, is reported under this code. The methods implementing it are not reported with it, because the test reaches them through it. A candidate found dead under reachability, every production reference to which is made by a declaration itself dead, is reported under this code as well where test code that is no test of dead code, and that the run counting test references reaches, references it, because that test keeps it, and the finding's message names both kinds of reference.",
     defaultSeverity: "deny",
     maxClass: "certain",
     fixability: "deletable",
@@ -146,7 +146,7 @@ const ROWS: readonly KindRow[] = [
     languages: ["ts"],
     rule: "An exported declaration used only inside its own file, reported as a candidate for removing the export keyword. The finding names the narrower visibility the references support.",
     precondition:
-      'Closed world only. Reported in a file that is not an entry file, a file only a configuration string or a script token names being none, because each runs the file and reads no name it exports, and a test file being one only for the exports its test runner calls, as grammar/analysis.md "Test code" states, and that either belongs to a project whose consumer set the configuration declares complete or is reached by no manifest export. A declared cross-language edge counts as a reference from outside the file. Where the edge\'s other side is unknown to the analyzer, the finding is emitted pending. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first.',
+      'Closed world only. Reported in a file that is not an entry file, a file only a configuration string or a script token names being none, because each runs the file and reads no name it exports, and a test file being one only for the exports its test runner calls, as grammar/analysis.md "Test code" states, and a file a Markdown or MDX document imports one only for the exports the import reads, as grammar/analysis.md "Markdown and MDX documents" states, and that either belongs to a project whose consumer set the configuration declares complete or is reached by no manifest export. A declared cross-language edge counts as a reference from outside the file. Where the edge\'s other side is unknown to the analyzer, the finding is emitted pending. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first.',
     defaultSeverity: "warn",
     maxClass: "certain",
     fixability: "narrowable",

package/src/matrix.ts

@@ -30,6 +30,8 @@ export interface Configured {
   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;
   /**
@@ -60,6 +62,11 @@ export interface Matrix {
    * 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[]>;
 }
@@ -81,6 +88,17 @@ export interface MatrixCandidate extends Candidate {
    * 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. */
@@ -158,6 +176,7 @@ export function matrixOf(per: readonly Configured[]): Matrix {
     }
   });
   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),
@@ -173,6 +192,7 @@ export function matrixOf(per: readonly Configured[]): Matrix {
       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,
   };
 }
@@ -227,6 +247,14 @@ export function sweepMatrix(matrix: Matrix, input: SweepInput): SweepResult {
         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 && testReached[at] === true),
+    judged.map((one) => one !== undefined),
+  );
   const candidates: MatrixCandidate[] = [];
   union.symbols.forEach((symbol, at) => {
     const all = judged[at];
@@ -234,7 +262,7 @@ export function sweepMatrix(matrix: Matrix, input: SweepInput): SweepResult {
       return;
     }
     const held = matrix.heldIn[at] ?? [];
-    const admitted = all.every((candidate) => candidate.testOfDeadCode) && subjectsDead(at);
+    const admitted = admittedAt(at);
     const testRefs = union.made[at]?.test ?? 0;
     const heldByTests =
       heldBy[union.parent[at] ?? OUTSIDE] ??
@@ -255,6 +283,8 @@ export function sweepMatrix(matrix: Matrix, input: SweepInput): SweepResult {
       configurations: held,
       heldByTests,
       unreferencedTest: unreferenced,
+      testUsed: testUsed[at] === true,
+      keptByTests: kept[at] === true,
     });
   });
 
@@ -266,6 +296,47 @@ export function sweepMatrix(matrix: Matrix, input: SweepInput): SweepResult {
   };
 }
 
+/** 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