@cplieger/deadset-ts 8.0.0-dev.4 → 8.0.0-dev.6

package/src/convention-rows.ts

@@ -352,7 +352,7 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
   {
     name: "expo-router",
     package: "expo-router",
-    range: ">=3.0.0 <58.0.0",
+    range: ">=3.0.0 <59.0.0",
     entries: [`{,src/}app/**/*.${SCRIPT}`],
     moves: [],
   },

package/src/exempt-classes.ts

@@ -1,12 +1,4 @@
-/**
- * The exemption classes of the Contract's vocabulary, in its order: each class's name, its
- * languages and, for a TypeScript class, which private members it may retain. The rows are
- * written out, as the fixed severity codes are, and a test holds them equal to the Contract.
- * A class name is a type, so a table or a record naming a class outside the vocabulary, or
- * one of another language only, does not compile.
- */
-
-import type { Language } from "./config.ts";
+import { EXEMPTION_CLASSES, type Language } from "./contract/contract.generated.ts";
 
 /**
  * Whether a class may retain a member declared with the `private` modifier, and one
@@ -19,67 +11,6 @@ export interface TypeScriptVisibility {
   readonly privateName: boolean;
 }
 
-/** One class of the vocabulary. */
-interface ExemptionClassRow {
-  readonly class: string;
-  readonly languages: readonly Language[];
-  /** Present exactly on a class that runs on TypeScript. */
-  readonly typescriptVisibility?: TypeScriptVisibility;
-}
-
-/** Every class of the vocabulary, in the order the Contract lists them. */
-export const EXEMPTION_CLASSES = [
-  {
-    class: "interface-satisfaction",
-    languages: ["go", "ts"],
-    typescriptVisibility: { private: false, privateName: false },
-  },
-  { class: "encoding-reflection", languages: ["go"] },
-  { class: "format-verb-contract", languages: ["go"] },
-  { class: "errors-duck-typing", languages: ["go"] },
-  {
-    class: "enum-group",
-    languages: ["go", "ts"],
-    typescriptVisibility: { private: false, privateName: false },
-  },
-  {
-    class: "generated-file",
-    languages: ["go", "ts"],
-    typescriptVisibility: { private: true, privateName: false },
-  },
-  { class: "linkname-cgo-asm-plugin", languages: ["go"] },
-  {
-    class: "template-field",
-    languages: ["go", "ts"],
-    typescriptVisibility: { private: true, privateName: false },
-  },
-  {
-    class: "reflective-lookup",
-    languages: ["go", "ts"],
-    typescriptVisibility: { private: true, privateName: false },
-  },
-  {
-    class: "decorator",
-    languages: ["ts"],
-    typescriptVisibility: { private: true, privateName: false },
-  },
-  {
-    class: "injection-container",
-    languages: ["ts"],
-    typescriptVisibility: { private: true, privateName: false },
-  },
-  {
-    class: "framework-lifecycle",
-    languages: ["ts"],
-    typescriptVisibility: { private: true, privateName: false },
-  },
-  {
-    class: "serialization-contract",
-    languages: ["ts"],
-    typescriptVisibility: { private: true, privateName: false },
-  },
-] as const satisfies readonly ExemptionClassRow[];
-
 type Row = (typeof EXEMPTION_CLASSES)[number];
 
 /** The name of a class of the vocabulary. */

package/src/exempt.ts

@@ -7,10 +7,10 @@
  * hands it the table of the classes it has.
  */
 
+import { EXEMPTION_CLASSES } from "./contract/contract.generated.ts";
 import type { Config, TSSection } from "./config.ts";
 import { ConfigError } from "./config.ts";
 import {
-  EXEMPTION_CLASSES,
   isExemptionClass,
   TS_EXEMPTION_CLASSES,
   typescriptVisibilityOf,
@@ -18,7 +18,7 @@ import {
   type TSExemptionClass,
   type TypeScriptVisibility,
 } from "./exempt-classes.ts";
-import type { Inventory, InventorySymbol, SymbolKind, Visibility } from "./inventory.ts";
+import type { Inventory, InventorySymbol, Visibility } from "./inventory.ts";
 import type { Matrix } from "./matrix.ts";
 import { byPosition, positionKey, type Position } from "./position.ts";
 import { Unanswerable } from "./query.ts";
@@ -107,20 +107,12 @@ function retainable(allowed: TypeScriptVisibility, visibility: Visibility | unde
   return true;
 }
 
-/**
- * The kinds of declaration each class can hold back, which a detector that stops holds
- * back whole. A class with no row here holds back every declaration but a file.
- */
-const RETAINABLE: ReadonlyMap<TSExemptionClass, ReadonlySet<SymbolKind>> = new Map([
-  ["interface-satisfaction", new Set<SymbolKind>(["method", "class-member"])],
-  ["enum-group", new Set<SymbolKind>(["enum-member"])],
-  ["injection-container", new Set<SymbolKind>(["method", "class-member"])],
-  ["framework-lifecycle", new Set<SymbolKind>(["method", "class-member"])],
-  [
-    "serialization-contract",
-    new Set<SymbolKind>(["method", "class-member", "interface-method", "type-member"]),
-  ],
-]);
+/** The kinds of declaration each class can hold back, which a detector that stops holds back whole. */
+const RETAINABLE: ReadonlyMap<string, ReadonlySet<string>> = new Map(
+  EXEMPTION_CLASSES.flatMap((row) =>
+    "ts" in row.retainsKinds ? [[row.class, new Set<string>(row.retainsKinds.ts)] as const] : [],
+  ),
+);
 
 /** The detail of a record a detector that could not finish holds. */
 const UNANSWERED_DETAIL = "kept live by a question the checker did not answer";
@@ -149,7 +141,7 @@ function detected<Brand>(
     }
     const kinds = RETAINABLE.get(exemptionClass);
     return input.held.symbols
-      .filter((symbol) => (kinds === undefined ? symbol.kind !== "file" : kinds.has(symbol.kind)))
+      .filter((symbol) => kinds?.has(symbol.kind) === true)
       .map((symbol) => ({ id: symbol.id, detail: UNANSWERED_DETAIL, site: symbol.position }));
   }
 }
@@ -316,8 +308,8 @@ export function retainedIn(
 }
 
 /**
- * One line per held-back declaration, in site order: its reference, then each record's
- * class, site and detail, all separated by tabs.
+ * One line per held-back declaration, in site order: its reference and position, then
+ * each record's class, site and detail, all separated by tabs.
  */
 export function retainedLines(
   symbols: readonly InventorySymbol[],
@@ -334,6 +326,6 @@ export function retainedLines(
       positionKey(record.site),
       record.detail,
     ]);
-    return [[symbol.ref, ...fields].join("\t")];
+    return [[symbol.ref, positionKey(symbol.position), ...fields].join("\t")];
   });
 }

package/src/finding.ts

@@ -1,8 +1,8 @@
-import type { Confidence, Severity } from "./config.ts";
-import type { Fixability } from "./kinds.ts";
+import type { Fixability, Confidence, Severity } from "./contract/contract.generated.ts";
 import type { DependencySection } from "./ref.ts";
 import type { Mechanism } from "./suppress.ts";
 import type { Relation } from "./sweep.ts";
+import type { FindingSymbol } from "./contract/report.generated.ts";
 
 /**
  * The finding: what an emitter decides about one subject, and every member the
@@ -29,7 +29,7 @@ interface FindingSubject {
   /** The stable symbol reference, or for a configured root the root as written. */
   readonly ref: string;
   /** The subject kind, from the closed vocabulary of the finding schema. */
-  readonly kind: string;
+  readonly kind: FindingSymbol["kind"];
   /** The display name a text line renders. */
   readonly name: string;
   /** The number of source lines the subject spans. */
@@ -55,19 +55,19 @@ export interface PositionedSymbol {
  */
 export interface FindingDetails {
   /**
-   * On `DS1101` and `DS1104`: the widest scope that holds every reference to the
+   * On `DS1501` and `DS1503`: the widest scope that holds every reference to the
    * subject, which is the visibility its references support.
    */
   readonly narrowerVisibility?: "file" | "package";
-  /** On `DS1201` and `DS1203`: the classes implementing the interface, in site order. */
+  /** On `DS1201` and `DS1202`: the classes implementing the interface, in site order. */
   readonly implementations?: readonly PositionedSymbol[];
-  /** On `DS1301` and `DS1807`: every position the subject is written at, in site order. */
+  /** On `DS1301` and `DS1404`: every position the subject is written at, in site order. */
   readonly writePositions?: readonly FindingPosition[];
-  /** On `DS1601`: the manifest section that declares the dependency. */
+  /** On `DS1701`: the manifest section that declares the dependency. */
   readonly dependencyClass?: DependencySection;
-  /** On `DS1701` and `DS1702`: the document that holds the refused suppression. */
+  /** On `DS9001` and `DS9002`: the document that holds the refused suppression. */
   readonly mechanism?: Mechanism;
-  /** On `DS1701` and `DS1702`: the refused suppression as written, a member absent where it lacks one. */
+  /** On `DS9001` and `DS9002`: the refused suppression as written, a member absent where it lacks one. */
   readonly entry?: SuppressionEntry;
   /** On the intra-function kinds: the external rules that report the same kind, as the vocabulary lists them. */
   readonly overlap?: readonly string[];

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. */
@@ -186,7 +185,7 @@ function testCeilings(
 
 /**
  * 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
+ * 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.
  */
@@ -286,7 +285,7 @@ function membersListed(
 }
 
 /**
- * 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.
  */
@@ -300,7 +299,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) =>
@@ -419,7 +418,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 }
@@ -471,7 +470,7 @@ export function completed(
     const used =
       judged !== undefined
         ? candidate !== undefined && testUsed.declarations.has(judged.id)
-        : finding.code === FILE_NEVER_IMPORTED && testUsed.files.has(finding.position.path);
+        : finding.code === CODE.fileNeverImported && testUsed.files.has(finding.position.path);
     const reachabilityClass = used && candidate?.testOfDeadCode !== true ? "possible" : ownClass;
     const configurations =
       candidate?.configurations ??
@@ -499,7 +498,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 {

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

@@ -11,7 +11,7 @@ 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;
@@ -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.
  */

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),

package/src/findings/intra-function.ts

@@ -1,8 +1,8 @@
-import type { Confidence } from "../config.ts";
+import { CODE, type Confidence } from "../contract/contract.generated.ts";
 import type { Finding } from "../finding.ts";
 import { KINDS } from "../kinds.ts";
 import { parameterRef } from "../ref.ts";
-import { UNUSED_PARAMETER, UNUSED_RESULT, type PartFact } from "../intra-function-parts.ts";
+import { type PartFact } from "../intra-function-parts.ts";
 import { reachedWithTheTests } from "../sweep.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
 
@@ -85,9 +85,9 @@ function reported(
   }
   const { free, freeButValued, discardedEverywhere } = input.intraFunction;
   switch (part.code) {
-    case UNUSED_PARAMETER:
+    case CODE.unusedParameter:
       return parameterVerdict(part, free, freeButValued) !== undefined;
-    case UNUSED_RESULT:
+    case CODE.unusedResult:
       return (
         free.has(part.declaration) &&
         discardedEverywhere.has(part.declaration) &&
@@ -99,7 +99,7 @@ function reported(
 }
 
 /**
- * The findings of the intra-function family, `DS1800` to `DS1899`, each about a part of
+ * The findings of the inside-functions family, `DS1401` to `DS1406`, each about a part of
  * the declaration its reference names, at the part's own position, whatever the sweep
  * decided about a production declaration. A part of test code is reported only where the
  * run that counts test references reaches its declaration and that is no test of dead
@@ -146,12 +146,12 @@ export const intraFunction: Emitter = (input) => {
   const found: Finding[] = [];
   for (const part of input.intraFunction.parts) {
     const declaration = byId.get(part.declaration);
-    const overlap = KINDS.get(part.code)?.overlap ?? [];
+    const overlap = KINDS.get(part.code)?.overlap?.ts ?? [];
     if (declaration === undefined || !judged(declaration.id) || !reported(input, part, unknown)) {
       continue;
     }
     const verdict =
-      part.code === UNUSED_PARAMETER
+      part.code === CODE.unusedParameter
         ? parameterVerdict(part, input.intraFunction.free, input.intraFunction.freeButValued)
         : undefined;
     const message =
@@ -162,7 +162,7 @@ export const intraFunction: Emitter = (input) => {
       code: part.code,
       position: part.position,
       symbol: {
-        ...(part.code === UNUSED_PARAMETER
+        ...(part.code === CODE.unusedParameter
           ? { ref: parameterRef(declaration.ref, part.name), holder: declaration.ref }
           : { ref: declaration.ref }),
         kind: part.kind,

package/src/findings/non-code-artifacts.ts

@@ -1,10 +1,8 @@
+import { CODE } from "../contract/contract.generated.ts";
 import type { Config } from "../config.ts";
 import type { Finding } from "../finding.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
 
-const FILE_NEVER_BUILT = "DS1501";
-const FILE_NEVER_IMPORTED = "DS1502";
-
 /** The subject kind of a finding about a source file, from the finding schema's vocabulary. */
 const FILE_SUBJECT = "file";
 
@@ -57,7 +55,7 @@ function fileNeverBuilt({ config, swept, files }: EmitterInput): readonly Findin
   const message = `no project of the build matrix includes this file (${swept.matrix.configurations.join(", ")})`;
   return files.tree
     .filter((file) => !built.has(file.path))
-    .map((file) => fileFinding(FILE_NEVER_BUILT, file, message));
+    .map((file) => fileFinding(CODE.fileNeverBuilt, file, message));
 }
 
 /** The files of the run, each with whether a reference written in another file reaches it. */
@@ -152,21 +150,21 @@ function fileNeverImported(input: EmitterInput): readonly Finding[] {
       return referenced.has(symbol.position.path)
         ? {
             ...fileFinding(
-              FILE_NEVER_IMPORTED,
+              CODE.fileNeverImported,
               file,
               "only code that is itself dead imports this file, and no root names it or a declaration in it",
             ),
             unreachableOnly: true as const,
           }
         : fileFinding(
-            FILE_NEVER_IMPORTED,
+            CODE.fileNeverImported,
             file,
             "no import reaches this file and no root names it or a declaration in it",
           );
     });
 }
 
-/** The findings of the non-code-artifacts family, `DS1500` to `DS1599`. */
+/** The findings of the files family, `DS1600` to `DS1699`. */
 export const nonCodeArtifacts: Emitter = (input) => [
   ...fileNeverBuilt(input),
   ...fileNeverImported(input),

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

@@ -1,3 +1,4 @@
+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";
@@ -5,13 +6,14 @@ import { positionKey } from "../position.ts";
 import { declarationKey } from "../ref.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
 
-/** The codes of this family. */
-type ReadsAndWritesCode = "DS1301" | "DS1302" | "DS1303";
+/** The codes this emitter reports. */
+type ReadsAndWritesCode =
+  typeof CODE.writeOnlySymbol | typeof CODE.unusedEnumMember | typeof CODE.unusedTypeParameter;
 
-/** The containers whose type parameters `DS1303` reports: a function, a class method and a type alias. */
+/** 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 the family reads of one run, indexed by declaration. */
+/** What this emitter reads of one run, indexed by declaration. */
 interface Run {
   readonly input: EmitterInput;
   readonly symbols: ReadonlyMap<string, InventorySymbol>;
@@ -185,7 +187,7 @@ function writeOnlySymbols(run: Run): readonly Finding[] {
       continue;
     }
     found.push(
-      findingAbout(symbol, "DS1301", writeOnlyMessage(run, namedBy, symbol, held), {
+      findingAbout(symbol, CODE.writeOnlySymbol, writeOnlyMessage(run, namedBy, symbol, held), {
         writePositions: held.writes,
       }),
     );
@@ -214,18 +216,18 @@ 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, a class method or a type alias that neither
+ * `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
@@ -237,7 +239,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`,
       ),
     );
@@ -257,8 +259,8 @@ export function writeOnlyDeclarations(input: EmitterInput): ReadonlySet<string>
 }
 
 /**
- * The findings of the reads-and-writes family, `DS1300` to `DS1399`, in code order and
- * each code's in site order.
+ * 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);