@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.10

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" } },
   };
 }
 
@@ -165,7 +165,7 @@ function dialledOver(
   const unanswered = heldKeys(input);
   const markup = markupKeys(input);
   const candidates = found.filter((finding) => {
-    const key = declarationKey(finding.symbol.ref, finding.position.path);
+    const key = declarationKey(finding.symbol.holder ?? finding.symbol.ref, finding.position.path);
     return (
       !ledger.withheld(finding) &&
       !unanswered.has(key) &&

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,6 +1,8 @@
+import { CODE, type Confidence } from "../contract/contract.generated.ts";
 import type { Finding } from "../finding.ts";
 import { KINDS } from "../kinds.ts";
-import { UNUSED_PARAMETER, UNUSED_RESULT, type PartFact } from "../intra-function-parts.ts";
+import { parameterRef } from "../ref.ts";
+import { type PartFact } from "../intra-function-parts.ts";
 import { reachedWithTheTests } from "../sweep.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
 
@@ -12,29 +14,58 @@ function spelled(rules: readonly string[]): string {
   return `${rules.slice(0, -1).join(", ")} and ${rules.at(-1) ?? ""}`;
 }
 
-/** The clause a message ends with: the other rules that report the kind, or that none is known. */
-function overlapClause(overlap: readonly string[]): string {
-  return overlap.length === 1 && overlap[0] === "none known"
+/** The compiler's rule of the parameter kind's overlap list, which reports only in a file it checks. */
+const COMPILER_PARAMETER_RULE = "tsc --noUnusedParameters";
+
+/**
+ * The clause a message ends with: the other rules that report the part, or that none is
+ * known. A parameter of a file the compiler does not check is no report of the compiler's.
+ */
+function overlapClause(overlap: readonly string[], part: PartFact): string {
+  const rules =
+    part.parameter?.checked === false
+      ? overlap.filter((rule) => rule !== COMPILER_PARAMETER_RULE)
+      : overlap;
+  return rules.length === 1 && rules[0] === "none known"
     ? "no other rule is known to report it"
-    : `also reported by ${spelled(overlap)}`;
+    : `also reported by ${spelled(rules)}`;
 }
 
+/** What a parameter's finding asks: its deletion, or, where a read parameter follows it, its rename. */
+type ParameterVerdict =
+  | { readonly fix: "delete"; readonly confidence: Confidence }
+  | { readonly fix: "rename" }
+  | undefined;
+
 /**
- * Whether one parameter's name is reported: every unread one of a function whose
- * signature is free, and of a function used as a value only one no read parameter follows,
- * because a caller may pass such a function more arguments than it declares.
+ * Whether one unread parameter is reported, and how. Of a free signature it is deleted. A
+ * caller may pass a function used as a value more arguments than it declares, so there one
+ * a read parameter follows is renamed to an underscore name, which the compilers read as
+ * declared unread, and one no read parameter follows is deleted: kept where the call's
+ * inference may read its annotation, at `probable` where nothing reads the annotation or
+ * where it is a name a contextually typed object pattern binds.
  */
-function parameterReported(
+function parameterVerdict(
   part: PartFact,
   free: ReadonlySet<string>,
   freeButValued: ReadonlySet<string>,
-): boolean {
+): ParameterVerdict {
   const place = part.parameter;
   if (place?.inValue !== true && free.has(part.declaration)) {
-    return true;
+    return place?.annotated === undefined ? { fix: "delete", confidence: "certain" } : undefined;
   }
   const valued = place?.inValue === true || freeButValued.has(part.declaration);
-  return valued && place?.beforeARead !== true;
+  if (!valued) {
+    return undefined;
+  }
+  if (place?.beforeARead === true) {
+    return { fix: "rename" };
+  }
+  if (place?.annotated === "steers") {
+    return undefined;
+  }
+  const unseen = place?.annotated === "free" || place?.contextualPattern === true;
+  return { fix: "delete", confidence: unseen ? "probable" : "certain" };
 }
 
 /**
@@ -54,9 +85,9 @@ function reported(
   }
   const { free, freeButValued, discardedEverywhere } = input.intraFunction;
   switch (part.code) {
-    case UNUSED_PARAMETER:
-      return parameterReported(part, free, freeButValued);
-    case UNUSED_RESULT:
+    case CODE.unusedParameter:
+      return parameterVerdict(part, free, freeButValued) !== undefined;
+    case CODE.unusedResult:
       return (
         free.has(part.declaration) &&
         discardedEverywhere.has(part.declaration) &&
@@ -68,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
@@ -96,7 +127,7 @@ export const intraFunction: Emitter = (input) => {
     }),
   );
   const { declared, loaded } = input.boundary.consumers;
-  const closed = input.config.consumersComplete && declared.every((id) => loaded.includes(id));
+  const closed = input.config.consumers.complete && declared.every((id) => loaded.includes(id));
   const published = (id: string): boolean => {
     const symbol = byId.get(id);
     return (
@@ -115,24 +146,37 @@ 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 === CODE.unusedParameter
+        ? parameterVerdict(part, input.intraFunction.free, input.intraFunction.freeButValued)
+        : undefined;
+    const message =
+      verdict?.fix === "rename"
+        ? `${part.message}, and a read parameter follows it, so rename it to _${part.name}`
+        : part.message;
     found.push({
       code: part.code,
       position: part.position,
       symbol: {
-        ref: declaration.ref,
+        ...(part.code === CODE.unusedParameter
+          ? { ref: parameterRef(declaration.ref, part.name), holder: declaration.ref }
+          : { ref: declaration.ref }),
         kind: part.kind,
         name: part.name,
         sizeLines: part.position.endLine - part.position.line + 1,
       },
-      message: `${part.message}; ${overlapClause(overlap)}`,
+      message: `${message}; ${overlapClause(overlap, part)}`,
       details: {
         ...(part.kind === "store" ? { writePositions: [part.position] } : {}),
         overlap,
       },
+      ...(verdict?.fix === "delete" && verdict.confidence !== "certain"
+        ? { reachabilityClass: verdict.confidence }
+        : {}),
     });
   }
   return found;

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

@@ -1,11 +1,8 @@
-import type { Config } from "../config.ts";
+import { CODE } from "../contract/contract.generated.ts";
+import type { ResolvedConfig } from "../config.ts";
 import type { Finding } from "../finding.ts";
-import type { Graph } from "../graph.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";
 
@@ -18,10 +15,10 @@ const FILE_START = 1;
  * completeness and listing no project declares it of a matrix the run derived, and a
  * derived matrix is never complete.
  */
-function completeMatrix(config: Config): boolean {
+function completeMatrix(config: ResolvedConfig): boolean {
   return (
-    config.analysis.matrixComplete &&
-    config.analysis.configurations.some((entry) => entry.shape === "project")
+    config.analysis.matrix.complete &&
+    config.analysis.configurations.some((entry) => "project" in entry)
   );
 }
 
@@ -58,46 +55,37 @@ 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 paths of every file a reference written in another file reaches, naming the
- * file or a declaration in it, a loaded consumer's file included. An import is such a
- * reference, so an import from any file reaches what it names, whatever reaches the
- * importing file.
- */
-function reachedFromOutside(union: Graph): ReadonlySet<string> {
-  const reached = new Set<string>();
-  for (const edge of union.consumed) {
-    const to = union.symbols[edge.to];
-    if (to !== undefined) {
-      reached.add(to.position.path);
-    }
-  }
-  union.out.forEach((edges, from) => {
-    const fromPath = union.symbols[from]?.position.path;
-    for (const edge of edges) {
-      const to = union.symbols[edge.to];
-      if (to !== undefined && to.position.path !== fromPath) {
-        reached.add(to.position.path);
-      }
-    }
-  });
-  return reached;
+/** The files of the run, each with whether a reference written in another file reaches it. */
+interface KeptFiles {
+  /** The files kept: reached from a live file, or named by a root, an edge or a program. */
+  readonly kept: ReadonlySet<string>;
+  /** The files a reference written in another file reaches, whatever holds that file. */
+  readonly referenced: ReadonlySet<string>;
 }
 
 /**
- * The paths of the files an import reaches, a root names, or a declared edge names a
- * declaration in. A file holding a declaration the sweep judged live is kept whatever
- * held it live, and so is a file a program holds by inclusion, which acts on every
- * file of the program without an import naming it.
+ * The paths of the files a reference from a live declaration of another file reaches, a
+ * loaded consumer's file included, a root names, or a declared edge names a declaration in,
+ * and of every file a reference written anywhere reaches. A file holding a declaration the
+ * sweep judged live is kept whatever held it live, and so is a file a program holds by
+ * inclusion, which acts on every file of the program without an import naming it. A
+ * reference from a file's top level counts once the file is kept.
  */
-function keptFiles({ swept, files, boundary }: EmitterInput): ReadonlySet<string> {
+function keptFiles({ swept, files, boundary }: EmitterInput): KeptFiles {
   const union = swept.matrix.union;
   const edgeNamed = new Set(boundary.edges.map((side) => side.symbol));
   const dead = new Set(swept.sweep.candidates.map((candidate) => candidate.id));
-  const kept = new Set([...reachedFromOutside(union), ...files.heldByInclusion]);
+  const kept = new Set(files.heldByInclusion);
+  const referenced = new Set<string>();
+  for (const edge of union.consumed) {
+    const to = union.symbols[edge.to];
+    if (to !== undefined) {
+      kept.add(to.position.path);
+    }
+  }
   for (const root of union.rooted) {
     const named = union.symbols[root.at];
     if (named !== undefined) {
@@ -109,24 +97,74 @@ function keptFiles({ swept, files, boundary }: EmitterInput): ReadonlySet<string
       kept.add(symbol.position.path);
     }
   }
-  return kept;
+  const fromTopLevel = new Map<string, string[]>();
+  const pending: string[] = [];
+  const keep = (path: string): void => {
+    if (!kept.has(path)) {
+      kept.add(path);
+      pending.push(path);
+    }
+  };
+  union.out.forEach((edges, from) => {
+    const source = union.symbols[from];
+    if (source === undefined) {
+      return;
+    }
+    for (const edge of edges) {
+      const to = union.symbols[edge.to]?.position.path;
+      if (to === undefined || to === source.position.path) {
+        continue;
+      }
+      referenced.add(to);
+      if (source.kind === FILE_SUBJECT) {
+        fromTopLevel.set(source.position.path, [
+          ...(fromTopLevel.get(source.position.path) ?? []),
+          to,
+        ]);
+      } else if (!dead.has(source.id)) {
+        pending.push(to);
+      }
+    }
+  });
+  pending.push(...kept);
+  for (let path = pending.pop(); path !== undefined; path = pending.pop()) {
+    kept.add(path);
+    for (const to of fromTopLevel.get(path) ?? []) {
+      keep(to);
+    }
+    fromTopLevel.delete(path);
+  }
+  return { kept, referenced };
 }
 
-/** Every file of the run that no import reaches and no root or edge names. */
+/**
+ * Every file of the run that no reference from live code reaches and no root or edge
+ * names. A file only dead code imports is found dead under reachability alone.
+ */
 function fileNeverImported(input: EmitterInput): readonly Finding[] {
-  const kept = keptFiles(input);
+  const { kept, referenced } = keptFiles(input);
   return input.swept.matrix.union.symbols
     .filter((symbol) => symbol.kind === FILE_SUBJECT && !kept.has(symbol.position.path))
-    .map((symbol) =>
-      fileFinding(
-        FILE_NEVER_IMPORTED,
-        { path: symbol.position.path, ref: symbol.ref, endLine: symbol.endLine },
-        "no import reaches this file and no root names it or a declaration in it",
-      ),
-    );
+    .map((symbol) => {
+      const file = { path: symbol.position.path, ref: symbol.ref, endLine: symbol.endLine };
+      return referenced.has(symbol.position.path)
+        ? {
+            ...fileFinding(
+              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(
+            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,17 +1,20 @@
+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 { positionKey } from "../position.ts";
 import { declarationKey } from "../ref.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
+import { bytewise } from "../text/compare.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 and a class method. */
-const SIGNATURES: ReadonlySet<string> = new Set(["function", "method"]);
+/** 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>;
@@ -121,7 +124,7 @@ function writeOnlyMessage(
     : "never read";
   const cascade = [
     ...parametersOnlyNamedBy(run, namedBy, symbol).map((name) => `type parameter ${name}`),
-    ...[...held.alone].sort().map((name) => `import ${name}`),
+    ...[...held.alone].sort(bytewise).map((name) => `import ${name}`),
   ];
   const word = SUBJECT_WORDS[symbol.kind] ?? "member";
   const message = `${word} ${symbol.name} is written ${writes} and ${read}`;
@@ -185,7 +188,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,21 +217,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 +240,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`,
       ),
     );
@@ -256,8 +260,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);