@cplieger/deadset-ts 3.12.0 → 3.13.0

package/src/value-reach.ts

@@ -1,9 +1,11 @@
 /**
- * The classes of the target a value of one type carries, as a serializer walking the
- * value reaches them: through union and intersection constituents, array and tuple
- * elements, and the data members of the target's classes and of object types the
- * target writes. The walk stops at `any`, `unknown`, a type parameter, a function and
- * an interface or class of another program, so an instance held only there is missed.
+ * The classes of the target a value of one type carries, and the members of the other
+ * object types the target writes that it carries, as a serializer walking the value
+ * reaches them: through union and intersection constituents, array and tuple elements,
+ * and the data members and index signatures of the target's classes and of the
+ * interfaces and object types the target writes. The walk stops at `any`, `unknown`, a
+ * type parameter, a function and an interface or class of another program, so an
+ * instance held only there is missed.
  */
 
 import {
@@ -23,12 +25,25 @@ const WRITTEN = ObjectFlags.ObjectLiteral | ObjectFlags.Mapped;
 /** The symbols of an anonymous object type the target writes as a type. */
 const LITERAL_SYMBOLS = SymbolFlags.TypeLiteral | SymbolFlags.ObjectLiteral;
 
-/** The classes a type's values carry, each asked of the checker once. */
+/** What a value of one type carries that the target declares. */
+export interface Reached {
+  /** The identifiers of the target's classes. */
+  readonly classes: ReadonlySet<string>;
+  /**
+   * The members of the interfaces and object types the target writes, other than its
+   * classes: each data member, and each method named `toJSON` or `toString`.
+   */
+  readonly members: readonly TSSymbol[];
+}
+
+/** What each type's values carry, each type asked of the checker once. */
 export interface ValueReach {
-  /** The identifiers of the target's classes a value of `type` carries. */
-  classesOf(type: Type): ReadonlySet<string>;
+  reachedFrom(type: Type): Reached;
 }
 
+/** The two conversion methods a serializer or a formatter resolves on a value's own shape. */
+const CONVERSION_NAMES: ReadonlySet<string> = new Set(["toJSON", "toString"]);
+
 /** The global array types, whose element type is what an array value carries. */
 function arrayTargets<Brand>(project: ProjectView<Brand>): ReadonlySet<number> {
   const checker = project.checker;
@@ -105,6 +120,29 @@ export function valueReach<Brand>(project: ProjectView<Brand>, held: Inventory):
     ];
   };
 
+  /** Whether the walk reads one type's members because the target writes the type, not as a class. */
+  const writtenObject = (type: Type): boolean => {
+    if (!type.isObjectType() || classOf(type) !== undefined) {
+      return false;
+    }
+    const target = targetOf(type);
+    const isList =
+      type.isTypeReference() &&
+      (arrays.has(target.id) ||
+        (target.isObjectType() && (target.objectFlags & ObjectFlags.Tuple) !== 0));
+    return !isList && isWritten(type);
+  };
+
+  /** The data members and conversion methods of one written object type. */
+  const carried = (type: Type): readonly TSSymbol[] =>
+    checker
+      .getPropertiesOfType(type)
+      .filter(
+        (property) =>
+          (property.flags & SymbolFlags.Property) !== 0 ||
+          ((property.flags & SymbolFlags.Method) !== 0 && CONVERSION_NAMES.has(property.name)),
+      );
+
   /** The types a value of one type holds, read once per type. */
   const childrenOf = (type: Type): readonly Type[] => {
     const known = children.get(type.id);
@@ -131,8 +169,9 @@ export function valueReach<Brand>(project: ProjectView<Brand>, held: Inventory):
   };
 
   return {
-    classesOf: (type) => {
-      const found = new Set<string>();
+    reachedFrom: (type) => {
+      const classes = new Set<string>();
+      const members: TSSymbol[] = [];
       const seen = new Set<number>();
       const pending: Type[] = [type];
       for (let next = pending.pop(); next !== undefined; next = pending.pop()) {
@@ -142,11 +181,13 @@ export function valueReach<Brand>(project: ProjectView<Brand>, held: Inventory):
         seen.add(next.id);
         const owner = classOf(next);
         if (owner !== undefined) {
-          found.add(owner);
+          classes.add(owner);
+        } else if (writtenObject(next)) {
+          members.push(...carried(next));
         }
         pending.push(...childrenOf(next));
       }
-      return found;
+      return { classes, members };
     },
   };
 }

package/src/verbs/analyze.ts

@@ -1,8 +1,8 @@
-import { runAnalysis, type RunProject } from "../analysis.ts";
+import { runAnalysis, runBaselineWrite, type RunAnalysis, type RunProject } from "../analysis.ts";
 import { ConfigError, type Format } from "../config.ts";
 import { CONFORMANCE, DECLARED_GAPS } from "../conformance.ts";
 import { moduleIdentity } from "../consumers.ts";
-import { analyzerProvenance, recordedFindings, verdictOf } from "../findings-pass.ts";
+import { analyzerProvenance, verdictOf } from "../findings-pass.ts";
 import { joinPath, normalizePath, relativePath, resolvePath } from "../paths.ts";
 import type { Host } from "../host.ts";
 import {
@@ -16,7 +16,7 @@ import { json } from "../reporters/json.ts";
 import { RENDERINGS } from "../reporters/reporters.ts";
 import { parseTemplate, TemplateError, type Template } from "../reporters/template.ts";
 import { resolve } from "../resolve.ts";
-import { writeBaseline, type Recorded } from "../suppress-file.ts";
+import { rowReason, writeBaseline, type Recorded } from "../suppress-file.ts";
 import { CONTRACT_VERSION } from "../version.ts";
 import { EXIT_CLEAN, EXIT_FAILURE, type Verb, type VerbOptions } from "./verb.ts";
 
@@ -153,8 +153,9 @@ interface Documents {
 /**
  * Analyzes the scope under the configuration and writes the JSON report to the path
  * `--report` names, each rendering `--format` names beside it at the report's path with the
- * format's suffix appended, and a baseline of every finding where `--baseline-write` names a
- * path. The template format renders the template `--template` names. Nothing is written to
+ * format's suffix appended, and where `--baseline-write` names a path the baseline a fixpoint
+ * over the analysis records, the report then being its first round, which reads no
+ * baseline. The template format renders the template `--template` names. Nothing is written to
  * the output stream; diagnostics go to the error stream and the verdict is the exit code, or 0
  * under `--exit-code=off`, and a rendering that cannot be written ends the run with 3.
  */
@@ -204,9 +205,26 @@ export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option
   let verdict: number;
   try {
     const root = runRelative(invoked, targetRoot);
-    const { result, run } = runAnalysis(openClient(false), host, scoped, config, provenance, {
-      production: true,
-    });
+    const mode = { production: true };
+    let analysis: RunAnalysis;
+    if (documents.baseline === undefined) {
+      analysis = runAnalysis(openClient(false), host, scoped, config, provenance, mode);
+      recorded = [];
+    } else {
+      const reason = rowReason(analyzerProvenance(version));
+      const write = runBaselineWrite(
+        openClient(false),
+        host,
+        scoped,
+        config,
+        provenance,
+        mode,
+        reason,
+      );
+      analysis = write.first;
+      recorded = write.rows;
+    }
+    const { result, run } = analysis;
     const built = buildReport({
       contractVersion: CONTRACT_VERSION,
       version,
@@ -222,9 +240,6 @@ export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option
       result,
       testFileRules: run.testFileRules,
     });
-    // The baseline records every finding, so its rows are taken before the cap bounds what
-    // a rendering prints: a baseline missing a reported finding fails the next run on it.
-    recorded = recordedFindings(result);
     report = capFindings(sortFindings(built, config.reporters.sort), config.reporters.maxFindings);
     verdict = verdictOf(result, config);
   } catch (error: unknown) {

package/src/verbs/describe.ts

@@ -1,25 +1,29 @@
 import { CONFORMANCE, type Conformance } from "../conformance.ts";
-import { ANALYZER_NAME, LANGUAGE, SCHEMA_VERSION } from "../report.ts";
+import { ANALYZER_NAME, LANGUAGE, SCHEMA_VERSIONS_ACCEPTED } from "../report.ts";
 import { CONTRACT_VERSION } from "../version.ts";
 import { EXIT_CLEAN, EXIT_FAILURE, EXIT_USAGE, type Verb } from "./verb.ts";
 
 /**
  * The document `describe` writes: the analyzer, the Contract version it implements, the
  * report schema versions it reads, the languages it claims, and its recorded result over
- * the conformance corpus.
+ * the conformance corpus, a member the document omits where no run is recorded.
  */
-export function describeDocument(version: string, recorded: Conformance): string {
+export function describeDocument(version: string, recorded: Conformance | undefined): string {
   const document = {
     name: ANALYZER_NAME,
     version,
     contract_version: CONTRACT_VERSION,
-    schema_versions_accepted: [SCHEMA_VERSION],
+    schema_versions_accepted: SCHEMA_VERSIONS_ACCEPTED,
     languages: [LANGUAGE],
-    conformance: {
-      corpus_version: recorded.corpusVersion,
-      result: recorded.result,
-      digest: recorded.digest,
-    },
+    ...(recorded === undefined
+      ? {}
+      : {
+          conformance: {
+            corpus_version: recorded.corpusVersion,
+            result: recorded.result,
+            digest: recorded.digest,
+          },
+        }),
   };
   return `${JSON.stringify(document, null, 2)}\n`;
 }

package/src/version.ts

@@ -4,4 +4,4 @@
  * independently of the analyzer's own version, which is the one the host answers
  * from the package the analyzer was installed from.
  */
-export const CONTRACT_VERSION = "3.2.0";
+export const CONTRACT_VERSION = "4.0.0";

package/dist/src/reporters/rules.js

@@ -1,178 +0,0 @@
-/**
- * The text of every live issue kind this analyzer's language carries, which a SARIF rule
- * describes the kind with, written out rather than read at run time. A test compares this
- * table against the Contract release the analyzer is written against.
- */
-/** Every live issue kind whose languages include this analyzer's, by code, in ascending order. */
-export const RULE_TEXTS = new Map([
-    [
-        "DS1001",
-        {
-            rule: "An exported symbol with no reference in the target and no reference from any loaded consumer. A symbol referenced only from its own declaration site counts as unreferenced.",
-        },
-    ],
-    [
-        "DS1002",
-        {
-            rule: "An unexported symbol with no reference in the target. A symbol referenced only from its own declaration site counts as unreferenced.",
-        },
-    ],
-    [
-        "DS1003",
-        {
-            rule: "A struct field, class member or type member with no reference, a private member included. A member referenced only from its own declaration site counts as unreferenced.",
-        },
-    ],
-    [
-        "DS1004",
-        {
-            rule: "A symbol with zero production references and at least one test reference: an unused-exported or unused-unexported candidate whose test reference count is not zero, reported once under this code. A reference from a consumer's test files is a test reference unless the configuration counts consumer tests as production.",
-        },
-    ],
-    [
-        "DS1005",
-        {
-            rule: "A test symbol whose set of referenced target symbols is non-empty and every member of that set is reported dead. A test that references at least one live target symbol is never reported, no notion of a test's subject and no name matching enters the rule, and the message states the rule. The test joins the dead component of the symbols it references.",
-        },
-    ],
-    [
-        "DS1006",
-        {
-            rule: "A symbol carrying a deprecation marker and no production reference: an unused-exported, unused-unexported or unused-member candidate whose symbol is deprecated, reported once under this code. Go identifies the marker by the convention the standard tools recognize, TypeScript by the documentation tag its tools recognize.",
-        },
-    ],
-    [
-        "DS1101",
-        {
-            rule: "An exported symbol whose every reference is inside the symbol's own package or module, reported as a candidate for unexporting. The subject is a package-level declaration or a method, and three subjects are excluded: an interface method, whose exportedness is the contract of the interface that declares it; a struct field, which an encoder reads by name; and a method that satisfies an interface some symbol uses as a type, which cannot be unexported without its type ceasing to satisfy that interface. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference; where the edge's other side is unknown to the analyzer the finding is emitted pending.",
-            precondition: "Closed world only. Reported always for a main package and an internal/ directory tree, and for a published package only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API.",
-        },
-    ],
-    [
-        "DS1103",
-        {
-            rule: "An unused exported symbol in a package or file no external code can import: an unused-exported candidate whose enclosing package or file is unimportable from outside, reported once under this code at the certain class, because unimportability is a property of the package graph rather than of the consumer set.",
-        },
-    ],
-    [
-        "DS1104",
-        {
-            rule: "An exported declaration used only inside its own file, reported as a candidate for removing the export keyword. The finding names the narrower visibility the references support.",
-            precondition: "Closed world only. Reported in a file that is not an entry file and that either belongs to a project whose consumer set the configuration declares complete or is reached by no manifest export. A declared cross-language edge counts as a reference from outside the file; where the edge's other side is unknown to the analyzer the finding is emitted pending.",
-        },
-    ],
-    [
-        "DS1201",
-        {
-            rule: "An interface no symbol uses as a type, counting uses from every loaded module. The finding names the concrete implementations and their positions, and the interface's members join its dead component rather than being reported as independent unused declarations.",
-        },
-    ],
-    [
-        "DS1203",
-        {
-            rule: "An interface method that no call site invokes or selects through the interface, whatever the number of implementations. The finding names the concrete implementations and their positions.",
-            precondition: "Exempt: every method of an interface that declares an unexported method, the sum-type shape whose method set exists to restrict the implementors; and every marker method, an interface method whose every implementation carries an empty body.",
-        },
-    ],
-    [
-        "DS1301",
-        {
-            rule: "A package-level or module-level variable, struct field, class member or collection that production code writes and never reads. In production mode a read from a test file counts as no read. A comparison of struct values reads every field of the type: in Go, a value of a struct type used as an operand of `==` or `!=`, as a map key, or as a `switch` tag or `case` expression is a read of every field of that type, transitively through the fields of every struct type it holds, recorded at the comparison, because equality reads every field and a field that decides equality carries information. In TypeScript a comparison of two object references reads no member, because `===` compares identity and never a member. The finding names each write position, so the deletion set is visible.",
-        },
-    ],
-    [
-        "DS1302",
-        {
-            rule: "An enumerated member that no symbol names, at the reachability class derived for the member and with no confidence ceiling below it. Every member of a type that carries a string, text or binary conversion method, or that a conversion from an integer or a wire value produces, is retained by the enum-group exemption first, so a member reached only by value is never a candidate.",
-        },
-    ],
-    [
-        "DS1303",
-        {
-            rule: "A type parameter of a function or method that no part of the declaration's signature and no part of the declaration's body names, at the certain class. The deletion is local to the declaration and the explicit instantiations the reference set already lists.",
-            precondition: "Function and method type parameters only. A type parameter of a type declaration is never reported, because a phantom type parameter such as `type ID[T any] int` makes two instantiations distinct types while naming the parameter nowhere, so deleting it changes the program.",
-        },
-    ],
-    [
-        "DS1501",
-        {
-            rule: "A source file no configuration in the build matrix builds. On the Go side the finding names the build constraint that excluded the file. A file whose build constraint is the ignore tag is never reported: the toolchain applies no build constraint to a file named on its own command line, so that tag is the toolchain's convention for a file built by hand. A file any other custom tag excludes is reported under a matrix the configuration declares complete, because completeness is the maintainer's assertion that the listed configurations are every one the target builds, and a configuration the maintainer builds by hand belongs in that list.",
-            precondition: 'Reported only when the configuration declares the build matrix complete, and never for a file the toolchain ignored solely because it imports "C" under a build with cgo disabled; such a file is recorded as excluded by cgo rather than as never built.',
-        },
-    ],
-    [
-        "DS1502",
-        {
-            rule: "A source file that no import reaches, that no root names, and in which no declared cross-language edge names a declaration. An edge's side names a declaration as a root names one, so a file holding a declaration an edge names is evaluated with the edge rather than reported: whether that declaration is dead is the edge evaluation's to say, and the merge resolves it against the paired side.",
-        },
-    ],
-    [
-        "DS1601",
-        {
-            rule: "A directly declared dependency that no import in the target needs. On the Go side, a direct require whose module provides no package any target package or test variant imports. On the TypeScript side, a manifest dependency, development dependency or peer dependency the project's import closure does not need. A deletion finding whose fix would remove the last use of a dependency names that dependency.",
-            precondition: "On the Go side the rule is the semantics of `go mod tidy -diff` exactly: a requirement marked indirect is never reported, because it exists to pin a transitive version and removing it changes the build list.",
-        },
-    ],
-    [
-        "DS1701",
-        {
-            rule: "A suppression that carries no reason, in any of the three documents: an inline directive, an ignore-file entry or a baseline row. For the ignore file and the baseline, an entry or a row whose reason field is absent, empty or whitespace only is refused and reported rather than matched.",
-        },
-    ],
-    [
-        "DS1702",
-        {
-            rule: "An ignore-file entry or a baseline row that names a symbol and no file path. The entry is reported rather than matched, so a bare name cannot mask a match anywhere else in the project; the inline directive is scoped by its position and cannot be unscoped.",
-        },
-    ],
-    [
-        "DS1703",
-        {
-            rule: "A suppression that matches no current finding, at either mechanism and in the baseline alike. The run exits with the findings code when at least one is reported. The kind is fixed on at deny: no flag, no severity setting and no per-mechanism exception reduces it below a finding, and a configuration naming this code under a severity key is an unimplemented key.",
-        },
-    ],
-    [
-        "DS1704",
-        {
-            rule: "A configured root that matches no symbol, or a configured root pattern that matches no symbol. A root set nobody checks silently changes every result, so a stale one is a finding. The kind is fixed on at deny: no flag, no severity setting and no exception reduces it below a finding, and a configuration naming this code under a severity key is an unimplemented key.",
-        },
-    ],
-    [
-        "DS1705",
-        {
-            rule: "A declared cross-language edge with a side that at least one analyzer evaluated and every evaluation of that side reports absent, so no analyzer that ran enumerates that side's symbol. Emitted by the merge, once per edge, never by an analyzer, so a stale edge is visible rather than silently inert. A dead side paired with an absent side drops its pending finding, and the edge is the reported defect: a misspelled reference must not turn a live pairing into a deletion.",
-        },
-    ],
-    [
-        "DS1801",
-        {
-            rule: "A parameter with no reference inside its function body, on a function whose signature is free to change.",
-            precondition: "The signature must be free, defined as follows: the function is not a method retained by interface satisfaction, is not used as a value, is not a go:linkname or cgo target, and is not a stub whose body is empty or only panics. A parameter its body never names is dead whatever the callers, so a published declaration of a library is reported too, with the fixability the vocabulary gives the kind: the signature change is a breaking change.",
-        },
-    ],
-    [
-        "DS1803",
-        {
-            rule: "A result value that no call site of the function uses, on a function whose signature is free to change.",
-            precondition: "The same free-signature rule as unused-parameter, plus a closed-world condition: every call site of the function must be in the loaded graph, because an unknown caller may consume the result, so the kind reports only for a function whose callers are all visible.",
-        },
-    ],
-    [
-        "DS1805",
-        {
-            rule: "A statement that control flow cannot reach, at the precision the language's compiler applies to the same construct.",
-        },
-    ],
-    [
-        "DS1807",
-        {
-            rule: "A write to a local variable with no read before the next write to it or the end of its scope, computed on the same read-and-write classification the write-only-symbol kind uses. The finding names the write position.",
-        },
-    ],
-    [
-        "DS1809",
-        {
-            rule: "A switch case whose type or value an earlier case in the same switch already covers.",
-        },
-    ],
-]);

package/src/reporters/rules.ts

@@ -1,195 +0,0 @@
-/**
- * The text of every live issue kind this analyzer's language carries, which a SARIF rule
- * describes the kind with, written out rather than read at run time. A test compares this
- * table against the Contract release the analyzer is written against.
- */
-
-/** The text one rule is described with. */
-interface RuleText {
-  /** The kind's rule, whole. */
-  readonly rule: string;
-  /** The condition the kind reports under, where it declares one. */
-  readonly precondition?: string;
-}
-
-/** Every live issue kind whose languages include this analyzer's, by code, in ascending order. */
-export const RULE_TEXTS: ReadonlyMap<string, RuleText> = new Map<string, RuleText>([
-  [
-    "DS1001",
-    {
-      rule: "An exported symbol with no reference in the target and no reference from any loaded consumer. A symbol referenced only from its own declaration site counts as unreferenced.",
-    },
-  ],
-  [
-    "DS1002",
-    {
-      rule: "An unexported symbol with no reference in the target. A symbol referenced only from its own declaration site counts as unreferenced.",
-    },
-  ],
-  [
-    "DS1003",
-    {
-      rule: "A struct field, class member or type member with no reference, a private member included. A member referenced only from its own declaration site counts as unreferenced.",
-    },
-  ],
-  [
-    "DS1004",
-    {
-      rule: "A symbol with zero production references and at least one test reference: an unused-exported or unused-unexported candidate whose test reference count is not zero, reported once under this code. A reference from a consumer's test files is a test reference unless the configuration counts consumer tests as production.",
-    },
-  ],
-  [
-    "DS1005",
-    {
-      rule: "A test symbol whose set of referenced target symbols is non-empty and every member of that set is reported dead. A test that references at least one live target symbol is never reported, no notion of a test's subject and no name matching enters the rule, and the message states the rule. The test joins the dead component of the symbols it references.",
-    },
-  ],
-  [
-    "DS1006",
-    {
-      rule: "A symbol carrying a deprecation marker and no production reference: an unused-exported, unused-unexported or unused-member candidate whose symbol is deprecated, reported once under this code. Go identifies the marker by the convention the standard tools recognize, TypeScript by the documentation tag its tools recognize.",
-    },
-  ],
-  [
-    "DS1101",
-    {
-      rule: "An exported symbol whose every reference is inside the symbol's own package or module, reported as a candidate for unexporting. The subject is a package-level declaration or a method, and three subjects are excluded: an interface method, whose exportedness is the contract of the interface that declares it; a struct field, which an encoder reads by name; and a method that satisfies an interface some symbol uses as a type, which cannot be unexported without its type ceasing to satisfy that interface. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference; where the edge's other side is unknown to the analyzer the finding is emitted pending.",
-      precondition:
-        "Closed world only. Reported always for a main package and an internal/ directory tree, and for a published package only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API.",
-    },
-  ],
-  [
-    "DS1103",
-    {
-      rule: "An unused exported symbol in a package or file no external code can import: an unused-exported candidate whose enclosing package or file is unimportable from outside, reported once under this code at the certain class, because unimportability is a property of the package graph rather than of the consumer set.",
-    },
-  ],
-  [
-    "DS1104",
-    {
-      rule: "An exported declaration used only inside its own file, reported as a candidate for removing the export keyword. The finding names the narrower visibility the references support.",
-      precondition:
-        "Closed world only. Reported in a file that is not an entry file and that either belongs to a project whose consumer set the configuration declares complete or is reached by no manifest export. A declared cross-language edge counts as a reference from outside the file; where the edge's other side is unknown to the analyzer the finding is emitted pending.",
-    },
-  ],
-  [
-    "DS1201",
-    {
-      rule: "An interface no symbol uses as a type, counting uses from every loaded module. The finding names the concrete implementations and their positions, and the interface's members join its dead component rather than being reported as independent unused declarations.",
-    },
-  ],
-  [
-    "DS1203",
-    {
-      rule: "An interface method that no call site invokes or selects through the interface, whatever the number of implementations. The finding names the concrete implementations and their positions.",
-      precondition:
-        "Exempt: every method of an interface that declares an unexported method, the sum-type shape whose method set exists to restrict the implementors; and every marker method, an interface method whose every implementation carries an empty body.",
-    },
-  ],
-  [
-    "DS1301",
-    {
-      rule: "A package-level or module-level variable, struct field, class member or collection that production code writes and never reads. In production mode a read from a test file counts as no read. A comparison of struct values reads every field of the type: in Go, a value of a struct type used as an operand of `==` or `!=`, as a map key, or as a `switch` tag or `case` expression is a read of every field of that type, transitively through the fields of every struct type it holds, recorded at the comparison, because equality reads every field and a field that decides equality carries information. In TypeScript a comparison of two object references reads no member, because `===` compares identity and never a member. The finding names each write position, so the deletion set is visible.",
-    },
-  ],
-  [
-    "DS1302",
-    {
-      rule: "An enumerated member that no symbol names, at the reachability class derived for the member and with no confidence ceiling below it. Every member of a type that carries a string, text or binary conversion method, or that a conversion from an integer or a wire value produces, is retained by the enum-group exemption first, so a member reached only by value is never a candidate.",
-    },
-  ],
-  [
-    "DS1303",
-    {
-      rule: "A type parameter of a function or method that no part of the declaration's signature and no part of the declaration's body names, at the certain class. The deletion is local to the declaration and the explicit instantiations the reference set already lists.",
-      precondition:
-        "Function and method type parameters only. A type parameter of a type declaration is never reported, because a phantom type parameter such as `type ID[T any] int` makes two instantiations distinct types while naming the parameter nowhere, so deleting it changes the program.",
-    },
-  ],
-  [
-    "DS1501",
-    {
-      rule: "A source file no configuration in the build matrix builds. On the Go side the finding names the build constraint that excluded the file. A file whose build constraint is the ignore tag is never reported: the toolchain applies no build constraint to a file named on its own command line, so that tag is the toolchain's convention for a file built by hand. A file any other custom tag excludes is reported under a matrix the configuration declares complete, because completeness is the maintainer's assertion that the listed configurations are every one the target builds, and a configuration the maintainer builds by hand belongs in that list.",
-      precondition:
-        'Reported only when the configuration declares the build matrix complete, and never for a file the toolchain ignored solely because it imports "C" under a build with cgo disabled; such a file is recorded as excluded by cgo rather than as never built.',
-    },
-  ],
-  [
-    "DS1502",
-    {
-      rule: "A source file that no import reaches, that no root names, and in which no declared cross-language edge names a declaration. An edge's side names a declaration as a root names one, so a file holding a declaration an edge names is evaluated with the edge rather than reported: whether that declaration is dead is the edge evaluation's to say, and the merge resolves it against the paired side.",
-    },
-  ],
-  [
-    "DS1601",
-    {
-      rule: "A directly declared dependency that no import in the target needs. On the Go side, a direct require whose module provides no package any target package or test variant imports. On the TypeScript side, a manifest dependency, development dependency or peer dependency the project's import closure does not need. A deletion finding whose fix would remove the last use of a dependency names that dependency.",
-      precondition:
-        "On the Go side the rule is the semantics of `go mod tidy -diff` exactly: a requirement marked indirect is never reported, because it exists to pin a transitive version and removing it changes the build list.",
-    },
-  ],
-  [
-    "DS1701",
-    {
-      rule: "A suppression that carries no reason, in any of the three documents: an inline directive, an ignore-file entry or a baseline row. For the ignore file and the baseline, an entry or a row whose reason field is absent, empty or whitespace only is refused and reported rather than matched.",
-    },
-  ],
-  [
-    "DS1702",
-    {
-      rule: "An ignore-file entry or a baseline row that names a symbol and no file path. The entry is reported rather than matched, so a bare name cannot mask a match anywhere else in the project; the inline directive is scoped by its position and cannot be unscoped.",
-    },
-  ],
-  [
-    "DS1703",
-    {
-      rule: "A suppression that matches no current finding, at either mechanism and in the baseline alike. The run exits with the findings code when at least one is reported. The kind is fixed on at deny: no flag, no severity setting and no per-mechanism exception reduces it below a finding, and a configuration naming this code under a severity key is an unimplemented key.",
-    },
-  ],
-  [
-    "DS1704",
-    {
-      rule: "A configured root that matches no symbol, or a configured root pattern that matches no symbol. A root set nobody checks silently changes every result, so a stale one is a finding. The kind is fixed on at deny: no flag, no severity setting and no exception reduces it below a finding, and a configuration naming this code under a severity key is an unimplemented key.",
-    },
-  ],
-  [
-    "DS1705",
-    {
-      rule: "A declared cross-language edge with a side that at least one analyzer evaluated and every evaluation of that side reports absent, so no analyzer that ran enumerates that side's symbol. Emitted by the merge, once per edge, never by an analyzer, so a stale edge is visible rather than silently inert. A dead side paired with an absent side drops its pending finding, and the edge is the reported defect: a misspelled reference must not turn a live pairing into a deletion.",
-    },
-  ],
-  [
-    "DS1801",
-    {
-      rule: "A parameter with no reference inside its function body, on a function whose signature is free to change.",
-      precondition:
-        "The signature must be free, defined as follows: the function is not a method retained by interface satisfaction, is not used as a value, is not a go:linkname or cgo target, and is not a stub whose body is empty or only panics. A parameter its body never names is dead whatever the callers, so a published declaration of a library is reported too, with the fixability the vocabulary gives the kind: the signature change is a breaking change.",
-    },
-  ],
-  [
-    "DS1803",
-    {
-      rule: "A result value that no call site of the function uses, on a function whose signature is free to change.",
-      precondition:
-        "The same free-signature rule as unused-parameter, plus a closed-world condition: every call site of the function must be in the loaded graph, because an unknown caller may consume the result, so the kind reports only for a function whose callers are all visible.",
-    },
-  ],
-  [
-    "DS1805",
-    {
-      rule: "A statement that control flow cannot reach, at the precision the language's compiler applies to the same construct.",
-    },
-  ],
-  [
-    "DS1807",
-    {
-      rule: "A write to a local variable with no read before the next write to it or the end of its scope, computed on the same read-and-write classification the write-only-symbol kind uses. The finding names the write position.",
-    },
-  ],
-  [
-    "DS1809",
-    {
-      rule: "A switch case whose type or value an earlier case in the same switch already covers.",
-    },
-  ],
-]);