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

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

@@ -1,21 +1,26 @@
+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";
 
-/** The codes of this family. */
-type ReadsAndWritesCode = "DS1301" | "DS1302" | "DS1303";
+import { bytewise } from "../text/compare.ts";
 
-/** The containers whose type parameters `DS1303` reports: a function and a class method. */
-const SIGNATURES: ReadonlySet<string> = new Set(["function", "method"]);
+/** The codes this emitter reports. */
+type ReadsAndWritesCode =
+  typeof CODE.writeOnlySymbol | typeof CODE.unusedEnumMember | typeof CODE.unusedTypeParameter;
 
-/** What the family reads of one run, indexed by declaration. */
+/** The containers whose type parameters `DS1006` reports: a function, a class method and a type alias. */
+const SIGNATURES: ReadonlySet<string> = new Set(["function", "method", "type"]);
+
+/** What this emitter reads of one run, indexed by declaration. */
 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 {
@@ -109,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}`),
-    ...[...held.alone].sort().map((name) => `import ${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}`;
@@ -130,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);
@@ -171,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, "DS1301", 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,
+    }),
+  );
 }
 
 /**
@@ -214,21 +282,22 @@ function unnamed(run: Run, kind: InventorySymbol["kind"]): readonly InventorySym
 }
 
 /**
- * `DS1302`: a member of an enum declaration that nothing names. A member an enum-group
+ * `DS1005`: a member of an enum declaration that nothing names. A member an enum-group
  * record holds back is no candidate, so a member a conversion can produce never reaches
  * this kind.
  */
 function unusedEnumMembers(run: Run): readonly Finding[] {
   return unnamed(run, "enum-member").map((symbol) =>
-    findingAbout(symbol, "DS1302", `enum member ${symbol.name} is named nowhere`),
+    findingAbout(symbol, CODE.unusedEnumMember, `enum member ${symbol.name} is named nowhere`),
   );
 }
 
 /**
- * `DS1303`: a type parameter of a function or a class method that neither the
- * declaration's signature nor its body names. A type parameter of a class, an interface,
- * a type alias or a method signature belongs to a type declaration and is never
- * reported, because a phantom parameter makes two instantiations distinct types.
+ * `DS1006`: a type parameter of a function, a class method or a type alias that neither
+ * the declaration's signature nor its body names. An alias names no type of its own, so
+ * a parameter its type never names makes no two instantiations distinct. One of a class,
+ * an interface or a method signature is never reported: a class or an interface merges
+ * only with declarations of the same parameters.
  */
 function unusedTypeParameters(run: Run): readonly Finding[] {
   return unnamed(run, "type-parameter")
@@ -236,7 +305,7 @@ function unusedTypeParameters(run: Run): readonly Finding[] {
     .map((symbol) =>
       findingAbout(
         symbol,
-        "DS1303",
+        CODE.unusedTypeParameter,
         `type parameter ${symbol.name} is named in neither its signature nor its body`,
       ),
     );
@@ -249,15 +318,23 @@ 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 findings of the reads-and-writes family, `DS1300` to `DS1399`, in code order and
- * each code's in site order.
+ * 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.
  */
 export const readsAndWrites: Emitter = (input) => {
   const run = indexed(input);

package/src/findings/self-check.ts

@@ -1,24 +1,18 @@
+import { CODE, REMEDIES, type Subject } from "../contract/contract.generated.ts";
 import { REPOSITORY_DOCUMENT } from "../config.ts";
 import type { Finding, FindingDetails, SuppressionEntry } from "../finding.ts";
 import type { InventorySymbol } from "../inventory.ts";
 import { FIXED_SEVERITY_CODES } from "../kinds.ts";
 import type { Position } from "../position.ts";
 import {
-  isDependencyCode,
-  isUnsuppressibleCode,
-  STALE_SUPPRESSION,
-  SUPPRESSION_WITHOUT_REASON,
+  names,
+  subjectOfCode,
   type Mechanism,
   type Refusal,
   type SuppressionRecord,
 } from "../suppress.ts";
 import type { Emitter } from "./emitter.ts";
-
-/** The code a configured root that matches nothing is reported under. */
-const UNMATCHED_ROOT = "DS1704";
-
-/** The code a configured declaration that names nothing is reported under. */
-const UNMATCHED_DECLARATION = "DS1706";
+import { bytewise } from "../text/compare.ts";
 
 /** The subject kind of a finding about a configured declaration. */
 const DECLARATION_SUBJECT = "configured-declaration";
@@ -39,7 +33,7 @@ export interface StaleRecord {
   readonly reports: readonly string[];
 }
 
-/** What the self-check family reads: the run's refused suppressions and its configured roots. */
+/** What the configuration family reads: the run's refused suppressions and its configured roots. */
 export interface SelfCheckFacts {
   /** The suppressions the grammar refused with a finding, in reading order. */
   readonly refusals: readonly Refusal[];
@@ -78,6 +72,43 @@ export function fileRefsOf(symbols: readonly InventorySymbol[]): FileRefs {
   return (path) => byPath.get(path);
 }
 
+/**
+ * Why a record of `mechanism` naming `codes` can match nothing, one clause per subject whose
+ * findings kinds.json's remedies table lets no record of that mechanism name, in subject order.
+ */
+function unnameable(codes: readonly string[], mechanism: Mechanism): readonly string[] {
+  return (Object.keys(REMEDIES) as Subject[]).flatMap((subject) => {
+    const named = codes.filter((code) => subjectOfCode(code) === subject);
+    if (named.length === 0 || names(subject, mechanism)) {
+      return [];
+    }
+    const { names: what, suppressions } = REMEDIES[subject];
+    const reports = `${spelled(named)} ${named.length === 1 ? "reports" : "each report"} ${what}`;
+    if (suppressions.length > 0) {
+      const records = suppressions.map((one) => articled(WRITTEN[one]));
+      return [`${reports}, which only ${spelledOr(records)} can name`];
+    }
+    const settable = named.filter((code) => !FIXED_SEVERITY_CODES.includes(code));
+    const remedy =
+      settable.length === 0
+        ? "fix what the finding names instead"
+        : `fix what the finding names or set the severity of ${spelled(settable)} instead`;
+    return [`${reports}, which no suppression can name; ${remedy}`];
+  });
+}
+
+/** A record's written name with its indefinite article. */
+function articled(name: string): string {
+  return `${/^[aeiou]/u.test(name) ? "an" : "a"} ${name}`;
+}
+
+/** A list as a sentence names alternatives. */
+function spelledOr(items: readonly string[]): string {
+  return items.length < 2
+    ? items.join("")
+    : `${items.slice(0, -1).join(", ")} or ${items.at(-1) ?? ""}`;
+}
+
 /** A list of codes as a sentence names them. */
 function spelled(codes: readonly string[]): string {
   if (codes.length < 2) {
@@ -135,7 +166,7 @@ function refusedSuppressions(refusals: readonly Refusal[], files: FileRefs): rea
       suppressionRef(refused.symbol, refused.path, files),
       refused.site,
       `${WRITTEN[refused.mechanism]} for ${refused.code} ${
-        refused.reported === SUPPRESSION_WITHOUT_REASON
+        refused.reported === CODE.suppressionWithoutReason
           ? "carries no reason"
           : "names a symbol and no path"
       }`,
@@ -146,7 +177,7 @@ function refusedSuppressions(refusals: readonly Refusal[], files: FileRefs): rea
 
 /** One stale suppression as the report's stale-suppression record carries it. */
 export interface StaleSuppression {
-  readonly code: typeof STALE_SUPPRESSION;
+  readonly code: typeof CODE.staleSuppression;
   readonly mechanism: Mechanism;
   readonly entry: {
     readonly code: string;
@@ -178,30 +209,12 @@ export function staleSuppressions(
     bySite.set(key, held);
   }
   return [...bySite.values()].map(({ first, records }) => {
-    const codes = [...new Set(records.map((one) => one.record.code))].sort();
+    const codes = [...new Set(records.map((one) => one.record.code))].sort(bytewise);
     const reports = [...new Set(records.flatMap((one) => one.reports))]
       .filter((code) => !codes.includes(code))
-      .sort();
-    const rows = codes.filter(isUnsuppressibleCode);
-    const dependencies = first.mechanism === "inline" ? codes.filter(isDependencyCode) : [];
-    const settable = rows.filter((code) => !FIXED_SEVERITY_CODES.includes(code));
-    const remedy =
-      settable.length === 0
-        ? "fix what the finding names instead"
-        : `fix what the finding names or set the severity of ${spelled(settable)} instead`;
+      .sort(bytewise);
     const declared = reports.length === 0 ? "" : `its declaration reports ${spelled(reports)}`;
-    const because = [
-      ...(rows.length > 0
-        ? [
-            `${spelled(rows)} ${rows.length === 1 ? "reports a row" : "report rows"} of a document, which no suppression can name; ${remedy}`,
-          ]
-        : []),
-      ...(dependencies.length > 0
-        ? [
-            `${spelled(dependencies)} ${dependencies.length === 1 ? "reports a dependency row" : "report dependency rows"}, which only an ignore entry or a baseline row can name`,
-          ]
-        : []),
-    ];
+    const because = unnameable(codes, first.mechanism);
     const instead =
       because.length > 0
         ? `, because ${because.join("; ")}${declared === "" ? "" : `; ${declared}`}`
@@ -209,7 +222,7 @@ export function staleSuppressions(
           ? ""
           : `, and ${declared}`;
     return {
-      code: STALE_SUPPRESSION,
+      code: CODE.staleSuppression,
       mechanism: first.mechanism,
       entry: {
         code: first.code,
@@ -242,7 +255,7 @@ function unmatchedDeclarationFindings(
   unmatched: readonly UnmatchedDeclaration[],
 ): readonly Finding[] {
   return unmatched.map((one) => ({
-    code: UNMATCHED_DECLARATION,
+    code: CODE.unmatchedConfiguredDeclaration,
     position: documentPosition(one.document),
     symbol: { ref: one.ref, kind: DECLARATION_SUBJECT, name: one.ref, sizeLines: 1 },
     message: `${one.key} entry names no declaration in any project`,
@@ -262,7 +275,7 @@ export function unmatchedRootFindings(
 ): readonly Finding[] {
   const position = documentPosition(document);
   return sources.map((source) => ({
-    code: UNMATCHED_ROOT,
+    code: CODE.unmatchedRoot,
     position,
     symbol: { ref: source, kind: ROOT_SUBJECT, name: source, sizeLines: 1 },
     message:
@@ -273,7 +286,7 @@ export function unmatchedRootFindings(
 }
 
 /**
- * The findings of the self-check family, `DS1700` to `DS1799`: a suppression refused for
+ * The findings of the configuration family, `DS9000` to `DS9099`: a suppression refused for
  * carrying no reason or naming no path, and a configured root or declaration that named
  * nothing. A
  * suppression that matched nothing is a record of the report's stale suppressions, which

package/src/findings/unused-declarations.ts

@@ -1,6 +1,7 @@
+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 { unreachableExports } from "./visibility-narrowing.ts";
 
@@ -13,42 +14,23 @@ const MEMBERS: ReadonlySet<SymbolKind> = new Set([
 ]);
 
 /**
- * The kinds of declaration no code of this family reports: an interface and a method an
+ * The kinds of declaration no code of this emitter reports: an interface and a method an
  * interface declares are the interface kinds' subjects, and a type parameter is the
  * subject of the unused-type-parameter kind or of none.
  */
-const NOT_THIS_FAMILY: ReadonlySet<SymbolKind> = new Set([
+const NOT_REPORTED_HERE: ReadonlySet<SymbolKind> = new Set([
   "file",
   "interface",
   "interface-method",
   "type-parameter",
 ]);
 
-/** The reader's word for each kind of declaration a finding of the family 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;
@@ -68,9 +50,9 @@ interface Judged {
 function codeOf(judged: Judged): string | undefined {
   const { candidate, symbol } = judged;
   if (candidate.testOfDeadCode) {
-    return "DS1005";
+    return CODE.testOfDeadCode;
   }
-  if ((judged.test && !candidate.unreferencedTest) || NOT_THIS_FAMILY.has(symbol.kind)) {
+  if ((judged.test && !candidate.unreferencedTest) || NOT_REPORTED_HERE.has(symbol.kind)) {
     return undefined;
   }
   const referenced = candidate.productionRefs + candidate.testRefs > 0;
@@ -81,33 +63,33 @@ function codeOf(judged: Judged): string | undefined {
     return unreferencedCode(symbol);
   }
   if (candidate.heldByTests === candidate.id) {
-    return "DS1004";
+    return CODE.testOnlyUse;
   }
   if (candidate.productionRefs === 0 && judged.deprecated) {
-    return "DS1006";
+    return CODE.deprecatedUnused;
   }
   if (
     candidate.testRefs > 0 &&
     (candidate.productionRefs === 0 ||
       (candidate.relation === "reachability" && candidate.keptByTests))
   ) {
-    return "DS1004";
+    return CODE.testOnlyUse;
   }
   if (MEMBERS.has(symbol.kind)) {
-    return "DS1003";
+    return CODE.unusedMember;
   }
   if (!symbol.exported) {
-    return "DS1002";
+    return CODE.unusedUnexported;
   }
-  return judged.unreachable ? undefined : "DS1001";
+  return judged.unreachable ? undefined : CODE.unusedExported;
 }
 
 /** The code a declaration nothing references carries, by its shape and its visibility. */
 function unreferencedCode(symbol: InventorySymbol): string {
   if (MEMBERS.has(symbol.kind)) {
-    return "DS1003";
+    return CODE.unusedMember;
   }
-  return symbol.exported ? "DS1001" : "DS1002";
+  return symbol.exported ? CODE.unusedExported : CODE.unusedUnexported;
 }
 
 /** The visibility a member's message names, where it narrows the member's reach. */
@@ -132,17 +114,17 @@ function messageOf(code: string, judged: Judged): string {
   const { candidate, symbol } = judged;
   const word = WORDS[symbol.kind];
   switch (code) {
-    case "DS1005":
+    case CODE.testOfDeadCode:
       return TEST_OF_DEAD_CODE;
-    case "DS1006":
+    case CODE.deprecatedUnused:
       return `deprecated ${word} has no production reference`;
-    case "DS1004":
+    case CODE.testOnlyUse:
       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"
+    code === CODE.unusedMember
       ? `${visibilityWord(symbol)}${word}`
       : symbol.kind === "export-alias"
         ? word
@@ -150,7 +132,7 @@ function messageOf(code: string, judged: Judged): string {
   if (candidate.relation === "reachability") {
     return `${subject} is referenced only from declarations that are themselves dead`;
   }
-  if (code === "DS1001") {
+  if (code === CODE.unusedExported) {
     return `${subject} has no reference in the target and none from any loaded consumer`;
   }
   return `${subject} has no reference in the target`;
@@ -202,25 +184,25 @@ function brandMembers(input: EmitterInput): ReadonlySet<string> {
 /** The kinds of member a brand is: a data member of a type or of a class. */
 const BRANDS: ReadonlySet<SymbolKind> = new Set(["type-member", "class-member"]);
 
-/** The findings of the unused-declarations family, `DS1000` to `DS1099`. */
+/** The findings of the unused-declaration kinds, `DS1001` to `DS1004` and `DS1102` to `DS1104`. */
 export const unusedDeclarations: Emitter = (input) => [
-  ...familyFindings(input, false),
+  ...emitterFindings(input, false),
   ...unusedImports(input),
 ];
 
 /**
- * The import bindings their file never reads, under the unexported code. A generated
- * file's are the generator's to remove unless the run includes generated files.
+ * The import bindings their file never reads. A generated file's are the generator's to
+ * remove unless the run includes generated files.
  */
 function unusedImports(input: EmitterInput): Finding[] {
   const generated =
-    input.config.analysis.generatedFiles === "include" ? undefined : input.files.generated;
+    input.config.analysis.generated_files === "include" ? undefined : input.files.generated;
   return input.intraFunction.imports.flatMap((binding) =>
     binding.used || generated?.has(binding.position.path) === true
       ? []
       : [
           {
-            code: "DS1002",
+            code: CODE.unusedImport,
             position: binding.position,
             symbol: { ref: binding.ref, kind: "import", name: binding.name, sizeLines: 1 },
             message: `import binding ${binding.name} is never read in its file`,
@@ -234,10 +216,10 @@ function unusedImports(input: EmitterInput): Finding[] {
  * a record on such a member is matched against, since the report carries the container's
  * finding rather than one of the member's own.
  */
-export const fallenMembers: Emitter = (input) => familyFindings(input, true);
+export const fallenMembers: Emitter = (input) => emitterFindings(input, true);
 
-/** The family's findings, or, where `fallen` is set, its dead containers' members' alone. */
-function familyFindings(input: EmitterInput, fallen: boolean): Finding[] {
+/** This emitter's findings, or, where `fallen` is set, its dead containers' members' alone. */
+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);
@@ -264,7 +246,7 @@ function familyFindings(input: EmitterInput, fallen: boolean): Finding[] {
     const code = codeOf(judged);
     if (
       code === undefined ||
-      (code === "DS1003" && (brands ??= brandMembers(input)).has(symbol.id))
+      (code === CODE.unusedMember && (brands ??= brandMembers(input)).has(symbol.id))
     ) {
       continue;
     }