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

package/src/findings/completion.ts

@@ -4,39 +4,38 @@
  * together with every finding that falls with a root they withhold.
  */
 
+import {
+  CODE,
+  FAMILY_KEY_LENGTH,
+  type Confidence,
+  type Severity,
+  KIND_ROWS,
+  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 type { Cascade, Confidence, Severity } from "../config.ts";
+import type { Cascade } from "../config.ts";
 import type { CompletedFinding, Finding, FindingComponent, PositionedSymbol } from "../finding.ts";
 import { OUTSIDE, type Graph } from "../graph.ts";
 import type { SymbolKind } from "../inventory.ts";
-import { KINDS, type KindRow } from "../kinds.ts";
+import { KINDS } from "../kinds.ts";
 import { byPosition, positionKey } from "../position.ts";
 import { declarationKey } from "../ref.ts";
-import { FAMILY_KEY_LENGTH } from "../resolve.ts";
 import { isPartSubject, isRowSubject, type Dials } from "../suppress.ts";
 import type { Candidate } from "../sweep.ts";
 import type { Boundary } from "./boundary.ts";
 import type { EmitterInput } from "./emitter.ts";
 
-/** The unused-file code, whose deletion removes every use its file writes. */
-const FILE_NEVER_IMPORTED = "DS1502";
-
 /**
- * The codes whose subject the run that counts test references holds live, as
- * finding.schema.json lists them, so a test file's candidate reported under one carries
- * none of a dead declaration's sweep facts.
+ * The codes whose subject the run that counts test references holds live, so a test
+ * file's candidate reported under one carries none of a dead declaration's sweep facts.
  */
-const LIVE_SUBJECT: ReadonlySet<string> = new Set([
-  "DS1101",
-  "DS1102",
-  "DS1104",
-  "DS1204",
-  "DS1301",
-]);
+const LIVE_SUBJECT: ReadonlySet<string> = new Set(
+  KIND_ROWS.filter((row) => row.holdsLive).map((row) => row.code),
+);
 
-/** The fixability grammar/analysis.md "Fixability" gives a finding about a held declaration. */
+/** The fixability grammar/analysis/fixability.md gives a finding about a held declaration. */
 const MANUAL = "manual";
 
 /** The member kinds an object property can declare, which an `in` expression tests by name. */
@@ -66,10 +65,9 @@ function everyDeclaredLoaded(boundary: Boundary): boolean {
  * naming its family, else the code's default.
  */
 function severityOf(input: EmitterInput, code: string, fallback: Severity): Severity {
-  const { config } = input;
-  return (
-    config.severity.get(code) ?? config.severity.get(code.slice(0, FAMILY_KEY_LENGTH)) ?? fallback
-  );
+  const { severity } = input.config;
+  const key = [code, code.slice(0, FAMILY_KEY_LENGTH)].find((one) => Object.hasOwn(severity, one));
+  return key === undefined ? fallback : (severity[key] ?? fallback);
 }
 
 /**
@@ -112,10 +110,12 @@ 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 is `possible`.
+ * consumer set. A member an `in` expression tests by name, and one a function outside the
+ * analysis fills, is `possible`.
  */
 function reachabilityClasses(input: EmitterInput): (id: string) => Confidence {
   const tested = testedByIn(input);
+  const filled = input.boundary.filledOutside ?? new Set<string>();
   const published = publishedIds(input.swept.matrix.union);
   const { declared } = input.boundary.consumers;
   const outside: Confidence =
@@ -125,13 +125,41 @@ function reachabilityClasses(input: EmitterInput): (id: string) => Confidence {
         ? "certain"
         : "probable";
   return (id) => {
-    if (tested.has(id)) {
+    if (tested.has(id) || filled.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) => {
+    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,40 +173,59 @@ 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 `DS1602` 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 };
 }
 
 /**
  * The ceiling the roots the run found put on one dead subject: a subject other declarations
- * reference, found dead only because no root reaches them, is `probable` unless
- * the configuration declares the roots complete, because a root the analysis cannot see
- * would make it live; every other declaration has none below `certain`.
+ * reference, found dead only because no root reaches them, is `probable` unless the
+ * configuration declares the roots complete and no configuration holding the subject loads
+ * a module the analysis cannot resolve, because a root the analysis cannot see would make
+ * it live; every other declaration has none below `certain`.
  */
 function rootsCeiling(
   input: EmitterInput,
   finding: Finding,
   candidate: Candidate | undefined,
+  configurations: readonly string[],
 ): Confidence {
   const unreachable = candidate?.relation === "reachability" || finding.unreachableOnly === true;
-  return unreachable && !input.config.ts.rootsComplete ? "probable" : "certain";
+  const unseen = new Set((input.files.unseenLoads ?? []).map((load) => load.configuration));
+  const complete = input.config.ts.roots_complete && !configurations.some((one) => unseen.has(one));
+  return unreachable && !complete ? "probable" : "certain";
 }
 
 /**
@@ -196,9 +243,28 @@ function findingComponents(
       held.set(member, component);
     }
   }
+  const listed = membersListed(swept);
+  return (id) => {
+    const component = held.get(id);
+    return component === undefined
+      ? undefined
+      : {
+          id: component.id,
+          root: component.roots.includes(id),
+          symbolCount: component.members.length,
+          deletableLines: component.deletableLines,
+          ...(cascade === "full" ? { members: listed(component.members) } : {}),
+        };
+  };
+}
+
+/** The members of a component as the run lists them, positioned and in the canonical order. */
+function membersListed(
+  swept: RunSweep,
+): (members: readonly string[]) => readonly PositionedSymbol[] {
   const symbols = new Map(swept.matrix.union.symbols.map((symbol) => [symbol.id, symbol]));
-  const listed = (component: Component): readonly PositionedSymbol[] =>
-    component.members
+  return (members) =>
+    members
       .flatMap((member) => {
         const symbol = symbols.get(member);
         return symbol === undefined
@@ -215,22 +281,10 @@ function findingComponents(
             ];
       })
       .sort((a, b) => byPosition(a.position, b.position));
-  return (id) => {
-    const component = held.get(id);
-    return component === undefined
-      ? undefined
-      : {
-          id: component.id,
-          root: component.roots.includes(id),
-          symbolCount: component.members.length,
-          deletableLines: component.deletableLines,
-          ...(cascade === "full" ? { members: listed(component) } : {}),
-        };
-  };
 }
 
 /**
- * The run's dead components with each file a `DS1502` finding reports dead among them, so
+ * The run's dead components with each file a `DS1602` finding reports dead among them, so
  * the file's declarations fall with it, and with the components each subject that is no
  * declaration falls with joined into one.
  */
@@ -244,7 +298,7 @@ function runComponents(
 } {
   const union = swept.matrix.union;
   const reported = new Set(
-    findings.filter((one) => one.code === FILE_NEVER_IMPORTED).map((one) => one.position.path),
+    findings.filter((one) => one.code === CODE.fileNeverImported).map((one) => one.position.path),
   );
   const files = new Map(
     union.symbols.flatMap((symbol, at) =>
@@ -321,18 +375,20 @@ 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));
   // A join keeps its first component's identifier, so a minted one counts past every computed one.
   let minted = computed;
   const dead = new Set(components.map((component) => component.id));
-  const fallingWith = new Map<string, number>();
-  for (const { heldByTests } of swept.sweep.candidates) {
+  const fallingWith = new Map<string, string[]>();
+  for (const { id, heldByTests } of swept.sweep.candidates) {
     if (heldByTests !== undefined) {
-      fallingWith.set(heldByTests, (fallingWith.get(heldByTests) ?? 0) + 1);
+      fallingWith.set(heldByTests, [...(fallingWith.get(heldByTests) ?? []), id]);
     }
   }
+  const listed = membersListed(swept);
 
   const done = findings.map((finding): CompletedFinding => {
     const row = kinds.get(finding.code);
@@ -361,7 +417,7 @@ export function completed(
     const fallsWith = finding.fallsWith?.[0];
     const joined = fallsWith === undefined ? undefined : componentOf(fallsWith);
     const file =
-      finding.code === FILE_NEVER_IMPORTED ? files.get(finding.position.path) : undefined;
+      finding.code === CODE.fileNeverImported ? files.get(finding.position.path) : undefined;
     const found =
       joined !== undefined
         ? { ...joined, root: false }
@@ -383,19 +439,50 @@ export function completed(
     let component = found;
     if (component === undefined) {
       minted += 1;
+      const falling = symbol?.kind === "interface" ? fallingWith.get(symbol.id) : undefined;
       component = {
         id: componentId(minted),
         root: true,
-        symbolCount: symbol?.kind === "interface" ? (fallingWith.get(symbol.id) ?? 1) : 1,
+        symbolCount: falling?.length ?? 1,
         deletableLines: 0,
+        ...(input.config.reporters.cascade !== "full"
+          ? {}
+          : falling === undefined
+            ? {
+                members: [
+                  {
+                    ref: finding.symbol.ref,
+                    name: finding.symbol.name,
+                    position: finding.position,
+                  },
+                ],
+              }
+            : { members: listed(falling) }),
       };
     }
     const counts =
       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 === CODE.fileNeverImported && testUsed.files.has(finding.position.path);
+    const reachabilityClass = used && candidate?.testOfDeadCode !== true ? "possible" : ownClass;
+    const configurations =
+      candidate?.configurations ??
+      (judged === undefined && !part
+        ? swept.matrix.configurations
+        : (swept.matrix.heldIn[at] ?? swept.matrix.configurations));
+    const untested = capped(
+      capped(
+        capped(ownClass, row.maxClass),
+        rootsCeiling(input, finding, candidate, configurations),
+      ),
+      judged === undefined ? "certain" : ceilingOf(judged.id),
+    );
     const generated = input.files.generated?.has(finding.position.path) === true;
     const fixability = generated
       ? "none"
@@ -410,7 +497,7 @@ export function completed(
         ? undefined
         : candidate !== undefined
           ? input.dependencies.lastUses.get(candidate.id)
-          : finding.code === FILE_NEVER_IMPORTED
+          : finding.code === CODE.fileNeverImported
             ? input.dependencies.fileLastUses.get(finding.position.path)
             : undefined;
     return {
@@ -420,20 +507,14 @@ 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,
       component,
       retainedBy: [],
-      configurations:
-        candidate?.configurations ??
-        (judged === undefined && !part
-          ? swept.matrix.configurations
-          : (swept.matrix.heldIn[at] ?? swept.matrix.configurations)),
+      configurations,
       consumersLoaded: input.boundary.consumers.loaded,
       fixability,
       severity: severityOf(input, finding.code, row.defaultSeverity),
@@ -450,7 +531,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 +542,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">,
@@ -491,10 +584,14 @@ export function dialsOf(
   input: EmitterInput,
   findings: readonly CompletedFinding[],
 ): Dials<CompletedFinding> {
-  const minConfidence = input.config.analysis.minConfidence;
+  const minConfidence = input.config.analysis.min_confidence;
   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/dependencies-and-module-machinery.ts

@@ -1,13 +1,10 @@
+import { CODE } from "../contract/contract.generated.ts";
 import { declarationKey, type Dependencies } from "../dependencies.ts";
 import type { Finding } from "../finding.ts";
 import { renderRef, type DependencySection } from "../ref.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
 import { nonCodeArtifacts } from "./non-code-artifacts.ts";
 
-const UNUSED_DEPENDENCY = "DS1601";
-
-const FILE_NEVER_IMPORTED = "DS1502";
-
 const MESSAGES: Readonly<Record<DependencySection, string>> = {
   dependency: "no import in the target needs the declared dependency",
   "dev-dependency": "no import in the target needs the declared development dependency",
@@ -46,7 +43,7 @@ function deadCode(input: EmitterInput): DeadCode {
   );
   for (const finding of nonCodeArtifacts(input)) {
     const id = files.get(finding.position.path);
-    if (finding.code === FILE_NEVER_IMPORTED && id !== undefined) {
+    if (finding.code === CODE.fileNeverImported && id !== undefined) {
       dead.add(id);
       if (finding.unreachableOnly === true) {
         reachedOnly.add(id);
@@ -81,7 +78,7 @@ function unusedDependencies(input: EmitterInput, dependencies: Dependencies): Fi
     const atPossible = unbuilt || users?.some((id) => published.has(id)) === true;
     return [
       {
-        code: UNUSED_DEPENDENCY,
+        code: CODE.unusedDependency,
         position: dependency.position,
         symbol: {
           ref: renderRef(dependency.manifest, {
@@ -105,6 +102,6 @@ function unusedDependencies(input: EmitterInput, dependencies: Dependencies): Fi
   });
 }
 
-/** The findings of the dependencies-and-module-machinery family, `DS1600` to `DS1699`. */
+/** The findings of the dependencies family, `DS1700` to `DS1799`. */
 export const dependenciesAndModuleMachinery: Emitter = (input) =>
   unusedDependencies(input, input.dependencies);

package/src/findings/emitter.ts

@@ -1,5 +1,5 @@
 import type { RunSweep } from "../analysis.ts";
-import type { Config } from "../config.ts";
+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";
@@ -11,10 +11,10 @@ import type { SelfCheckFacts } from "./self-check.ts";
 
 /**
  * What every emitter reads: the configuration the run resolved, the run's sweep, and
- * the facts about the run each kind family reads beside the sweep.
+ * the facts about the run each emitter reads beside the sweep.
  */
 export interface EmitterInput {
-  readonly config: Config;
+  readonly config: ResolvedConfig;
   /** The production sweep a report is built from, beside the matrix it judged. */
   readonly swept: RunSweep;
   /** The declarations carrying the deprecation marker in any configuration of the run. */
@@ -29,18 +29,17 @@ export interface EmitterInput {
   readonly files: FileFacts;
   /** What can reach the target from outside it: consumers, declared edges, and `exports`. */
   readonly boundary: Boundary;
-  /** The run's suppression outcomes and configured roots, which the self-check family reports. */
+  /** The run's suppression outcomes and configured roots, which the configuration family reports. */
   readonly selfCheck: SelfCheckFacts;
-  /** The parts of the run's declarations, which the intra-function family reports. */
+  /** The parts of the run's declarations, which the inside-functions family reports. */
   readonly intraFunction: IntraFunctionFacts;
 }
 
 /**
- * One kind family's rule over one run: every finding of the codes in its family's range
- * of the Contract's code space, whatever severity and minimum confidence the
- * configuration sets, in no particular order.
+ * One emitter's rule over one run: every finding of the codes it reports, whatever
+ * severity and minimum confidence the configuration sets, in no particular order.
  */
 export type Emitter = (input: EmitterInput) => readonly Finding[];
 
-/** The emitter of each kind family, by the family's name in the Contract, in code order. */
+/** Every emitter this analyzer runs, by the name its tests select it by. */
 export type Emitters = ReadonlyMap<string, Emitter>;

package/src/findings/emitters.ts

@@ -1,4 +1,4 @@
-import type { Confidence } from "../config.ts";
+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";
@@ -16,7 +16,7 @@ import { selfCheck } from "./self-check.ts";
 import { fallenMembers, unusedDeclarations } from "./unused-declarations.ts";
 import { visibilityNarrowing } from "./visibility-narrowing.ts";
 
-/** Every kind family this analyzer reports, each by its emitter, in code order. */
+/** Every emitter this analyzer runs, by the name its tests select it by. */
 export const EMITTERS: Emitters = new Map<string, Emitter>([
   ["unused-declarations", unusedDeclarations],
   ["visibility-narrowing", visibilityNarrowing],
@@ -76,7 +76,7 @@ interface Suppressed {
 
 /** What the emitter table answers about one run. */
 interface DecidedFindings {
-  /** Every finding the run reports, each family's in table order. */
+  /** Every finding the run reports, each emitter's in table order. */
   readonly findings: readonly CompletedFinding[];
   /** One evaluation per declared edge side of this language, ordered by edge, then by side. */
   readonly evaluations: readonly EdgeEvaluation<CompletedFinding>[];
@@ -91,7 +91,7 @@ interface DecidedFindings {
 /** How many findings the minimum confidence withheld at each confidence. */
 export type Withheld = Readonly<Record<Confidence, number>>;
 
-/** Every family'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. */
 function completedOver(
   input: EmitterInput,
   ...more: readonly Emitter[]
@@ -124,8 +124,8 @@ function dialsOver(
 
 /**
  * Every finding of one run swept under its suppressions' marks, decided in one pass: each
- * family's findings completed by one step, so every component number is minted once, the
- * finding each record claims withheld, the rest withheld by the dials, so a root one family
+ * emitter's findings completed by one step, so every component number is minted once, the
+ * finding each record claims withheld, the rest withheld by the dials, so a root one emitter
  * reports withholds what another reports in its component, and every declared edge
  * evaluated over what remains, so a pending finding is in its evaluation alone.
  */
@@ -145,7 +145,7 @@ function atPossible(input: EmitterInput): EmitterInput {
   const { config } = input;
   return {
     ...input,
-    config: { ...config, analysis: { ...config.analysis, minConfidence: "possible" } },
+    config: { ...config, analysis: { ...config.analysis, min_confidence: "possible" } },
   };
 }
 

package/src/findings/interfaces.ts

@@ -1,12 +1,10 @@
+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 { Emitter, EmitterInput } from "./emitter.ts";
 
-const UNUSED_INTERFACE = "DS1201";
-const UNCALLED_INTERFACE_METHOD = "DS1203";
-
 /** What each finding says, by what the sweep found about the subject's references. */
 const UNUSED_MESSAGE = "nothing in the target names the interface as a type";
 const UNUSED_DEAD_MESSAGE =
@@ -69,7 +67,7 @@ function findingOf(
 
 /**
  * The findings of the interfaces family, `DS1200` to `DS1299`: `DS1201`, a dead
- * interface, whose members fall with it unreported; and `DS1203`, a method of a live
+ * interface, whose members fall with it unreported; and `DS1202`, a method of a live
  * interface no reference names, unless it is a marker, a method whose every
  * implementation has an empty body. A test file's declaration is neither kind's subject,
  * because a production sweep counts none of the references it can have, save an interface
@@ -86,7 +84,7 @@ export const interfaces: Emitter = (input) => {
     if (symbol.kind === "interface") {
       found.push(
         findingOf(
-          UNUSED_INTERFACE,
+          CODE.unusedInterface,
           symbol,
           unusedMessage(candidate),
           run.implementationsOf(candidate.id),
@@ -104,7 +102,7 @@ export const interfaces: Emitter = (input) => {
     }
     found.push(
       findingOf(
-        UNCALLED_INTERFACE_METHOD,
+        CODE.uncalledInterfaceMethod,
         symbol,
         UNCALLED_MESSAGE,
         run.implementationsOf(symbol.parent),