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

package/src/findings/completion.ts

@@ -13,17 +13,17 @@ import {
   type KindRow,
 } from "../contract/contract.generated.ts";
 import type { RunSweep } from "../analysis.ts";
-import { componentId, type Component } from "../components.ts";
-import { deadComponents } from "../matrix.ts";
+import { componentId, type Component } from "../liveness/components.ts";
+import { deadComponents } from "../liveness/sweep.ts";
 import type { Cascade } from "../config.ts";
 import type { CompletedFinding, Finding, FindingComponent, PositionedSymbol } from "../finding.ts";
-import { OUTSIDE, type Graph } from "../graph.ts";
+import { OUTSIDE, type Graph } from "../liveness/graph.ts";
 import type { SymbolKind } from "../inventory.ts";
 import { KINDS } from "../kinds.ts";
 import { byPosition, positionKey } from "../position.ts";
 import { declarationKey } from "../ref.ts";
 import { isPartSubject, isRowSubject, type Dials } from "../suppress.ts";
-import type { Candidate } from "../sweep.ts";
+import type { Candidate } from "../liveness/sweep.ts";
 import type { Boundary } from "./boundary.ts";
 import type { EmitterInput } from "./emitter.ts";
 
@@ -110,12 +110,13 @@ function testedByIn(input: EmitterInput): ReadonlySet<string> {
  * published API, a public member of a published type included, is `certain` where the
  * run loaded every consumer the scope declared and declared one, `probable` where one did
  * not load, and `possible` where it declared none, whatever the configuration says of the
- * consumer set. A member an `in` expression tests by name, and one a function outside the
- * analysis fills, is `possible`.
+ * consumer set. A member an `in` expression tests by name, one a function outside the
+ * analysis fills, and one {@link possiblyLoaded} names, is `possible`.
  */
-function reachabilityClasses(input: EmitterInput): (id: string) => Confidence {
+export function reachabilityClasses(input: EmitterInput): (id: string) => Confidence {
   const tested = testedByIn(input);
   const filled = input.boundary.filledOutside ?? new Set<string>();
+  const possible = possiblyLoaded(input);
   const published = publishedIds(input.swept.matrix.union);
   const { declared } = input.boundary.consumers;
   const outside: Confidence =
@@ -125,27 +126,13 @@ function reachabilityClasses(input: EmitterInput): (id: string) => Confidence {
         ? "certain"
         : "probable";
   return (id) => {
-    if (tested.has(id) || filled.has(id)) {
+    if (tested.has(id) || filled.has(id) || possible.has(id)) {
       return "possible";
     }
     return published.has(id) ? outside : "certain";
   };
 }
 
-/**
- * Whether one test of dead code references a target symbol that is published API of a run
- * that declares no consumer, which outside programs the run cannot see may use, so the
- * target counts as live for the test and the test is no test of dead code.
- */
-export function testsUnseenAPI(input: EmitterInput): (id: string) => boolean {
-  if (input.boundary.consumers.declared.length > 0) {
-    return () => false;
-  }
-  const union = input.swept.matrix.union;
-  const published = publishedIds(union);
-  return (id) => testTargets(union, id).some((target) => published.has(target));
-}
-
 /** 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) => {
@@ -182,6 +169,36 @@ function testCeilings(
       : "certain";
 }
 
+/**
+ * What only a bundler's retry of an import Node leaves unresolved names (program.38), and each
+ * dead declaration that reaches through dead declarations, as confidence.20 reads what only
+ * tests reach: each is dead only while no loader the analysis does not see loads the file.
+ */
+function possiblyLoaded(input: EmitterInput): ReadonlySet<string> {
+  const seeds = input.boundary.possiblyLoaded ?? new Set<string>();
+  if (seeds.size === 0) {
+    return seeds;
+  }
+  const union = input.swept.matrix.union;
+  const dead = new Set(input.swept.sweep.candidates.map((one) => one.id));
+  const reached = new Set<string>();
+  const pending = union.symbols.flatMap((symbol, at) => (seeds.has(symbol.id) ? [at] : []));
+  for (let at = pending.pop(); at !== undefined; at = pending.pop()) {
+    const symbol = union.symbols[at];
+    if (symbol === undefined || reached.has(symbol.id)) {
+      continue;
+    }
+    reached.add(symbol.id);
+    for (const edge of union.out[at] ?? []) {
+      const to = union.symbols[edge.to];
+      if (to !== undefined && dead.has(to.id)) {
+        pending.push(edge.to);
+      }
+    }
+  }
+  return reached;
+}
+
 /**
  * The subjects dead only because production code only tests use is: each declaration the
  * sweep marks test-used, each `DS1602` file of such code, and each test of dead code every
@@ -373,6 +390,9 @@ export function completed(
     union.symbols.map((symbol, at) => [declarationKey(symbol.ref, symbol.position.path), at]),
   );
   const candidates = new Map(swept.sweep.candidates.map((candidate) => [candidate.id, candidate]));
+  const fileIds = new Map(
+    union.symbols.flatMap((one) => (one.kind === "file" ? [[one.position.path, one.id]] : [])),
+  );
   const classOf = reachabilityClasses(input);
   const ceilingOf = testCeilings(input, classOf);
   const testUsed = testUsedSubjects(input);
@@ -465,7 +485,12 @@ export function completed(
         ? union.made[at]
         : { production: candidate.productionRefs, test: candidate.testRefs };
     const ownClass =
-      judged === undefined ? (finding.reachabilityClass ?? "certain") : classOf(judged.id);
+      judged !== undefined
+        ? classOf(judged.id)
+        : (finding.reachabilityClass ??
+          (finding.code === CODE.fileNeverImported
+            ? classOf(fileIds.get(finding.position.path) ?? "")
+            : "certain"));
     const used =
       judged !== undefined
         ? candidate !== undefined && testUsed.declarations.has(judged.id)

package/src/findings/emitter.ts

@@ -3,7 +3,7 @@ import type { ResolvedConfig } from "../config.ts";
 import type { Dependencies } from "../dependencies.ts";
 import type { FileFacts } from "../file-facts.ts";
 import type { Finding } from "../finding.ts";
-import type { Implementations } from "../implementations.ts";
+import type { Implementations } from "./implementations.ts";
 import type { IntraFunctionFacts } from "../intra-function-parts.ts";
 import type { Stores } from "../stores.ts";
 import type { Boundary } from "./boundary.ts";

package/src/findings/emitters.ts

@@ -1,7 +1,6 @@
 import type { Confidence } from "../contract/contract.generated.ts";
 import { evaluateEdges, type EdgeEvaluation } from "../edges.ts";
 import type { CompletedFinding } from "../finding.ts";
-import { liveFilesAt } from "../matrix.ts";
 import { declarationKey } from "../ref.ts";
 import { ledgerOf, type Dials, type Ledger, type SuppressionRecord } from "../suppress.ts";
 import { insideSkipped } from "../type-errors.ts";
@@ -11,7 +10,7 @@ import type { Emitter, EmitterInput, Emitters } from "./emitter.ts";
 import { interfaces } from "./interfaces.ts";
 import { intraFunction } from "./intra-function.ts";
 import { nonCodeArtifacts } from "./non-code-artifacts.ts";
-import { readsAndWrites } from "./reads-and-writes.ts";
+import { fallingWithWrites, readsAndWrites } from "./reads-and-writes.ts";
 import { selfCheck } from "./self-check.ts";
 import { fallenMembers, unusedDeclarations } from "./unused-declarations.ts";
 import { visibilityNarrowing } from "./visibility-narrowing.ts";
@@ -28,42 +27,19 @@ export const EMITTERS: Emitters = new Map<string, Emitter>([
   ["intra-function", intraFunction],
 ]);
 
-/**
- * The keys of every declaration an unanswered question could have kept live, which the run
- * reports nothing about: a finding about one would be computed from the gap.
- */
-function heldKeys(input: EmitterInput): ReadonlySet<string> {
-  const held = new Set(input.swept.heldByUnanswered);
-  if (held.size === 0) {
-    return held;
-  }
+/** The keys of the declarations the identifiers name, as {@link findingKey} keys a finding. */
+function keysOf(input: EmitterInput, ids: Iterable<string>): ReadonlySet<string> {
+  const named = new Set(ids);
   return new Set(
     input.swept.matrix.union.symbols
-      .filter((symbol) => held.has(symbol.id))
+      .filter((symbol) => named.has(symbol.id))
       .map((symbol) => declarationKey(symbol.ref, symbol.position.path)),
   );
 }
 
-/**
- * The keys of every top-level declaration of a live component file. The file's
- * markup may use each of them, which no analysis of the markup can rule out, so the run
- * reports nothing about one while the file is live.
- */
-function markupKeys(input: EmitterInput): ReadonlySet<string> {
-  const { swept } = input;
-  if (swept.componentFiles.length === 0) {
-    return new Set();
-  }
-  const live = new Set(
-    liveFilesAt(swept.matrix, swept.sweep, new Set(swept.componentFiles)).map(
-      (symbol) => symbol.id,
-    ),
-  );
-  return new Set(
-    swept.matrix.union.symbols
-      .filter((symbol) => live.has(symbol.parent))
-      .map((symbol) => declarationKey(symbol.ref, symbol.position.path)),
-  );
+/** The key of the declaration a finding is about, or of the one holding the part it is about. */
+function findingKey(finding: CompletedFinding): string {
+  return declarationKey(finding.symbol.holder ?? finding.symbol.ref, finding.position.path);
 }
 
 /** What the suppressions of a run swept under their marks are decided against. */
@@ -91,15 +67,20 @@ interface DecidedFindings {
 /** How many findings the minimum confidence withheld at each confidence. */
 export type Withheld = Readonly<Record<Confidence, number>>;
 
-/** Every emitter's findings over one sweep, and those of any further emitter, completed by one step. */
+/**
+ * Every emitter's findings over one sweep, and those of any further emitter, completed by
+ * one step, but none about a declaration that falls with a write-only subject: that
+ * subject's finding names it, so no finding about it exists for a record to match.
+ */
 function completedOver(
   input: EmitterInput,
   ...more: readonly Emitter[]
 ): readonly CompletedFinding[] {
+  const falls = keysOf(input, fallingWithWrites(input));
   return completed(
     input,
     [...EMITTERS.values(), ...more].flatMap((emit) => emit(input)),
-  );
+  ).filter((finding) => !falls.has(findingKey(finding)));
 }
 
 /**
@@ -161,21 +142,22 @@ function dialledOver(
   unmarked: readonly CompletedFinding[],
 ): Omit<DecidedFindings, "would"> {
   const would = [...unmarked, ...found];
-  const unanswered = heldKeys(input);
-  const heldIds = new Set(input.swept.heldByUnanswered);
-  const keyOf = (finding: CompletedFinding): string =>
-    declarationKey(finding.symbol.holder ?? finding.symbol.ref, finding.position.path);
+  const { sweep } = input.swept;
+  // A hold is a gap of the analysis, which leaves a record it touches dormant; a live
+  // component file's markup is no gap, so a record on one of its bindings stays in effect.
+  const unanswered = keysOf(input, sweep.held);
+  const markup = keysOf(input, sweep.bindings);
+  const heldIds = new Set(sweep.held);
   const held = (finding: CompletedFinding): boolean =>
-    unanswered.has(keyOf(finding)) || insideSkipped(input.swept.skipped, finding.position);
+    unanswered.has(findingKey(finding)) || insideSkipped(input.swept.skipped, finding.position);
   const ledger = ledgerOf(
     suppressed.records,
     would,
     dialsOver(input, found, suppressed, unmarked),
     { withholds: held, holdsRecord: (record) => heldIds.has(record.bound) },
   );
-  const markup = markupKeys(input);
   const candidates = found.filter(
-    (finding) => !ledger.withheld(finding) && !held(finding) && !markup.has(keyOf(finding)),
+    (finding) => !ledger.withheld(finding) && !held(finding) && !markup.has(findingKey(finding)),
   );
   const kept = reportable(input, candidates);
   const evaluated = evaluateEdges(kept, input.boundary.edges, input.swept.matrix.union.symbols);

package/src/{implementations.ts → findings/implementations.ts}

@@ -15,10 +15,10 @@ import {
   type Node,
 } from "@typescript/native/ast";
 import { SymbolFlags, type Symbol as TSSymbol, type Type } from "@typescript/native/sync";
-import { aliasChains } from "./alias-chain.ts";
-import { nodeKey, type Inventory } from "./inventory.ts";
-import { must, Unanswerable } from "./query.ts";
-import type { ProjectView } from "./session.ts";
+import { aliasChains } from "../alias-chain.ts";
+import { nodeKey, type Inventory } from "../inventory.ts";
+import { must, Unanswerable } from "../query.ts";
+import type { ProjectView } from "../session.ts";
 
 /** What one run knows about how its interfaces are implemented. */
 export interface Implementations {

package/src/{in-operands.ts → findings/in-operands.ts}

@@ -11,9 +11,9 @@ import {
   SyntaxKind,
   type Node,
 } from "@typescript/native/ast";
-import type { ProjectView } from "./session.ts";
-import { sourceFilesOf } from "./source-files.ts";
-import { bytewise } from "./text/compare.ts";
+import type { ProjectView } from "../session.ts";
+import { sourceFilesOf } from "../source-files.ts";
+import { bytewise } from "../text/compare.ts";
 
 /**
  * The text of each string literal, or template literal with no substitution, written as

package/src/findings/interfaces.ts

@@ -2,7 +2,7 @@ import { CODE } from "../contract/contract.generated.ts";
 import type { Finding, FindingPosition, PositionedSymbol } from "../finding.ts";
 import type { InventorySymbol } from "../inventory.ts";
 import { byPosition } from "../position.ts";
-import type { MatrixCandidate } from "../matrix.ts";
+import type { Candidate } from "../liveness/sweep.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
 
 /** What each finding says, by what the sweep found about the subject's references. */
@@ -21,7 +21,7 @@ function positionOf(symbol: InventorySymbol): FindingPosition {
 function indexed(input: EmitterInput): {
   readonly symbolOf: (id: string) => InventorySymbol | undefined;
   readonly inTest: (id: string) => boolean;
-  readonly candidateOf: (id: string) => MatrixCandidate | undefined;
+  readonly candidateOf: (id: string) => Candidate | undefined;
   readonly implementationsOf: (id: string) => readonly PositionedSymbol[];
 } {
   const union = input.swept.matrix.union;
@@ -113,7 +113,7 @@ export const interfaces: Emitter = (input) => {
 };
 
 /** What one unused interface's finding says, by the references the sweep counted. */
-function unusedMessage(candidate: MatrixCandidate): string {
+function unusedMessage(candidate: Candidate): string {
   if (candidate.relation === "reachability") {
     return UNUSED_DEAD_MESSAGE;
   }

package/src/findings/intra-function.ts

@@ -3,7 +3,7 @@ import type { Finding } from "../finding.ts";
 import { KINDS } from "../kinds.ts";
 import { parameterRef } from "../ref.ts";
 import { type PartFact } from "../intra-function-parts.ts";
-import { reachedWithTheTests } from "../sweep.ts";
+import { reachedWithTheTests } from "../liveness/sweep.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
 
 /** A list of rules as a sentence names them. */
@@ -109,8 +109,8 @@ export const intraFunction: Emitter = (input) => {
   const union = input.swept.matrix.union;
   const byId = new Map(union.symbols.map((symbol) => [symbol.id, symbol]));
   const reached = reachedWithTheTests(union, [
-    ...input.swept.exempt.map((record) => record.id),
-    ...input.swept.heldByUnanswered,
+    ...input.swept.sweep.exempt.map((record) => record.id),
+    ...input.swept.sweep.held,
   ]);
   const testsOfDeadCode = new Set(
     input.swept.sweep.candidates.filter((one) => one.testOfDeadCode).map((one) => one.id),

package/src/findings/reads-and-writes.ts

@@ -1,10 +1,12 @@
 import { CODE } from "../contract/contract.generated.ts";
 import type { Finding, FindingDetails, FindingPosition } from "../finding.ts";
-import type { InventorySymbol } from "../inventory.ts";
-import type { MatrixCandidate } from "../matrix.ts";
+import { WORDS, type InventorySymbol } from "../inventory.ts";
+import type { Candidate } from "../liveness/sweep.ts";
 import { positionKey } from "../position.ts";
 import { declarationKey } from "../ref.ts";
+import { reachabilityClasses } from "./completion.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
+
 import { bytewise } from "../text/compare.ts";
 
 /** The codes this emitter reports. */
@@ -18,7 +20,7 @@ const SIGNATURES: ReadonlySet<string> = new Set(["function", "method", "type"]);
 interface Run {
   readonly input: EmitterInput;
   readonly symbols: ReadonlyMap<string, InventorySymbol>;
-  readonly candidates: ReadonlyMap<string, MatrixCandidate>;
+  readonly candidates: ReadonlyMap<string, Candidate>;
 }
 
 function indexed(input: EmitterInput): Run {
@@ -112,19 +114,16 @@ function parametersOnlyNamedBy(
 }
 
 /** What one write-only finding says, the declarations its deletion takes with it included. */
-function writeOnlyMessage(
-  run: Run,
-  namedBy: ReadonlyMap<string, ReadonlySet<string>>,
-  symbol: InventorySymbol,
-  held: Uses,
-): string {
+function writeOnlyMessage(run: Run, written: Written, subject: Subject): string {
+  const { symbol, held } = subject;
   const writes = held.writes.length === 1 ? "once" : `at ${String(held.writes.length)} positions`;
   const read = run.input.stores.readInTests.has(symbol.id)
     ? "read only from test files"
     : "never read";
   const cascade = [
-    ...parametersOnlyNamedBy(run, namedBy, symbol).map((name) => `type parameter ${name}`),
+    ...parametersOnlyNamedBy(run, written.namedBy, symbol).map((name) => `type parameter ${name}`),
     ...[...held.alone].sort(bytewise).map((name) => `import ${name}`),
+    ...(written.named.get(symbol.id) ?? []),
   ];
   const word = SUBJECT_WORDS[symbol.kind] ?? "member";
   const message = `${word} ${symbol.name} is written ${writes} and ${read}`;
@@ -133,17 +132,55 @@ function writeOnlyMessage(
     : `${message}, and deleting it with its writes deletes ${cascade.join(" and ")} too`;
 }
 
+/** One declaration the write-only kind reports, with its uses. */
+interface Subject {
+  readonly symbol: InventorySymbol;
+  readonly held: Uses;
+}
+
 /**
- * `DS1301`: a module-level variable, a type member or a class member the counted
- * references store into and never read, named with every position written.
+ * What the write-only kind answers of one run: its subjects in site order, and the
+ * declarations that fall with them, each named under the innermost subject of every chain
+ * of carriers its references hold.
+ */
+interface Written {
+  readonly subjects: readonly Subject[];
+  readonly namedBy: ReadonlyMap<string, ReadonlySet<string>>;
+  readonly named: ReadonlyMap<string, readonly string[]>;
+  readonly falls: ReadonlySet<string>;
+}
+
+/**
+ * The kinds of declaration that fall with a write-only subject: a declaration of its own.
+ * A member falls with its container, and a type parameter is the type-parameter clause's.
+ */
+const FALLING: ReadonlySet<InventorySymbol["kind"]> = new Set([
+  "function",
+  "class",
+  "interface",
+  "type",
+  "enum",
+  "namespace",
+  "variable",
+]);
+
+const WRITTEN = new WeakMap<EmitterInput, Written>();
+
+/**
+ * `DS1301`'s subjects: a module-level variable, a type member or a class member the
+ * counted references store into and never read.
  *
  * The subject is a live declaration: a store is a reference, so the sweep holds a
  * written one live and its candidates are never this kind's. Every reference that is
  * not a store reads, and so does an exemption record naming the declaration.
  */
-function writeOnlySymbols(run: Run): readonly Finding[] {
+function writtenOf(run: Run): Written {
+  const known = WRITTEN.get(run.input);
+  if (known !== undefined) {
+    return known;
+  }
   const { stores } = run.input;
-  const { matrix } = run.input.swept;
+  const { matrix, sweep } = run.input.swept;
   const uses = new Map<string, Uses>();
   for (const reference of stores.references) {
     let held = uses.get(reference.to);
@@ -174,26 +211,54 @@ function writeOnlySymbols(run: Run): readonly Finding[] {
     }
   }
 
-  const found: Finding[] = [];
-  for (const symbol of matrix.union.symbols) {
+  const subjects = matrix.union.symbols.flatMap((symbol): Subject[] => {
     const held = uses.get(symbol.id);
-    if (
-      held === undefined ||
+    return held === undefined ||
       held.writes.length === 0 ||
       held.reads > 0 ||
       !writable(run, symbol) ||
       stores.exempt.has(symbol.id) ||
       run.candidates.has(symbol.id)
+      ? []
+      : [{ symbol, held }];
+  });
+  const subjectIds = new Set(subjects.map((subject) => subject.symbol.id));
+  const classOf = reachabilityClasses(run.input);
+  const named = new Map<string, string[]>();
+  const falls = new Set<string>();
+  for (const symbol of matrix.union.symbols) {
+    const chains = sweep.carried.get(symbol.id);
+    if (
+      chains === undefined ||
+      subjectIds.has(symbol.id) ||
+      !FALLING.has(symbol.kind) ||
+      classOf(symbol.id) !== "certain"
     ) {
       continue;
     }
-    found.push(
-      findingAbout(symbol, CODE.writeOnlySymbol, writeOnlyMessage(run, namedBy, symbol, held), {
-        writePositions: held.writes,
-      }),
-    );
+    const innermost = chains.map((chain) => chain.find((id) => subjectIds.has(id)));
+    if (innermost.includes(undefined)) {
+      continue;
+    }
+    falls.add(symbol.id);
+    for (const subject of new Set(innermost)) {
+      const name = `${WORDS[symbol.kind]} ${symbol.name}`;
+      named.set(subject ?? "", [...(named.get(subject ?? "") ?? []), name]);
+    }
   }
-  return found;
+  const written = { subjects, namedBy, named, falls };
+  WRITTEN.set(run.input, written);
+  return written;
+}
+
+/** `DS1301`: each subject, named with every position written and what falls with it. */
+function writeOnlySymbols(run: Run): readonly Finding[] {
+  const written = writtenOf(run);
+  return written.subjects.map((subject) =>
+    findingAbout(subject.symbol, CODE.writeOnlySymbol, writeOnlyMessage(run, written, subject), {
+      writePositions: subject.held.writes,
+    }),
+  );
 }
 
 /**
@@ -253,12 +318,20 @@ function unusedTypeParameters(run: Run): readonly Finding[] {
  */
 export function writeOnlyDeclarations(input: EmitterInput): ReadonlySet<string> {
   return new Set(
-    writeOnlySymbols(indexed(input)).map((finding) =>
-      declarationKey(finding.symbol.ref, finding.position.path),
+    writtenOf(indexed(input)).subjects.map(({ symbol }) =>
+      declarationKey(symbol.ref, symbol.position.path),
     ),
   );
 }
 
+/**
+ * The declarations that fall with a write-only subject, whatever the severity: a finding
+ * about one would name code its subject's deletion already deletes.
+ */
+export function fallingWithWrites(input: EmitterInput): ReadonlySet<string> {
+  return writtenOf(indexed(input)).falls;
+}
+
 /**
  * The findings of the reads-and-writes kinds, `DS1301`, `DS1005` and `DS1006`, in that
  * order and each code's in site order.

package/src/findings/unused-declarations.ts

@@ -1,9 +1,8 @@
 import { CODE } from "../contract/contract.generated.ts";
 import type { Finding } from "../finding.ts";
-import type { InventorySymbol, SymbolKind } from "../inventory.ts";
-import type { MatrixCandidate } from "../matrix.ts";
+import { WORDS, type InventorySymbol, type SymbolKind } from "../inventory.ts";
+import type { Candidate } from "../liveness/sweep.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
-import { testsUnseenAPI } from "./completion.ts";
 import { unreachableExports } from "./visibility-narrowing.ts";
 
 /** The kinds of declaration that are members of a class, an interface, a type or an enum. */
@@ -26,39 +25,18 @@ const NOT_REPORTED_HERE: ReadonlySet<SymbolKind> = new Set([
   "type-parameter",
 ]);
 
-/** The reader's word for each kind of declaration a finding of this emitter names. */
-const WORDS: Readonly<Record<SymbolKind, string>> = {
-  file: "file",
-  function: "function",
-  class: "class",
-  interface: "interface",
-  type: "type alias",
-  enum: "enum",
-  namespace: "namespace",
-  variable: "variable",
-  "export-alias": "re-export",
-  method: "method",
-  "class-member": "class member",
-  "interface-method": "interface method",
-  "type-member": "type member",
-  "enum-member": "enum member",
-  "type-parameter": "type parameter",
-};
-
 /** What the test-of-dead-code kind says, which states the rule it applies. */
 const TEST_OF_DEAD_CODE = "every target symbol this test references is reported dead";
 
 /** What the run holds about one candidate that decides its code. */
 interface Judged {
-  readonly candidate: MatrixCandidate;
+  readonly candidate: Candidate;
   readonly symbol: InventorySymbol;
   /** Whether a test file declares it. */
   readonly test: boolean;
   readonly deprecated: boolean;
   /** Whether the unreachable-export kind reports it. */
   readonly unreachable: boolean;
-  /** Whether it is a test with a target that is published API no declared consumer judges. */
-  readonly testsUnseenAPI: boolean;
 }
 
 /**
@@ -72,7 +50,7 @@ interface Judged {
 function codeOf(judged: Judged): string | undefined {
   const { candidate, symbol } = judged;
   if (candidate.testOfDeadCode) {
-    return judged.testsUnseenAPI ? undefined : CODE.testOfDeadCode;
+    return CODE.testOfDeadCode;
   }
   if ((judged.test && !candidate.unreferencedTest) || NOT_REPORTED_HERE.has(symbol.kind)) {
     return undefined;
@@ -245,7 +223,6 @@ function emitterFindings(input: EmitterInput, fallen: boolean): Finding[] {
   const union = input.swept.matrix.union;
   const dead = new Set(input.swept.sweep.candidates.map((candidate) => candidate.id));
   const unreachable = unreachableExports(input);
-  const unseenAPI = testsUnseenAPI(input);
   let brands: ReadonlySet<string> | undefined;
 
   const found: Finding[] = [];
@@ -265,7 +242,6 @@ function emitterFindings(input: EmitterInput, fallen: boolean): Finding[] {
       test: union.test[at] === true,
       deprecated: input.deprecated.has(symbol.id),
       unreachable: unreachable.has(symbol.id),
-      testsUnseenAPI: candidate.testOfDeadCode && unseenAPI(candidate.id),
     };
     const code = codeOf(judged);
     if (