@cplieger/deadset-ts 4.0.1 → 5.1.0

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

@@ -62,23 +62,76 @@ function findingAbout(
 interface Uses {
   readonly writes: FindingPosition[];
   reads: number;
+  /** The import bindings only the writes use. */
+  readonly alone: Set<string>;
 }
 
 /**
  * Whether one declaration is a subject of the write-only kind: a module-level variable,
- * or a class member that is state rather than code. A getter or a setter is code, so a
- * store into one runs it.
+ * a member of an object type, or a class member that is state rather than code. A getter
+ * or a setter is code, so a store into one runs it.
  */
 function writable(run: Run, symbol: InventorySymbol): boolean {
-  if (symbol.kind === "variable") {
+  if (symbol.kind === "variable" || symbol.kind === "type-member") {
     return true;
   }
   return symbol.kind === "class-member" && !run.input.stores.accessors.has(symbol.id);
 }
 
+/** The reader's word for each kind of the write-only kind's subject. */
+const SUBJECT_WORDS: Readonly<Partial<Record<InventorySymbol["kind"], string>>> = {
+  variable: "variable",
+  "class-member": "member",
+  "type-member": "type member",
+};
+
+/**
+ * The type parameters of one member's declaring type that only the member names, which
+ * deleting the member leaves unused.
+ */
+function parametersOnlyNamedBy(
+  run: Run,
+  namedBy: ReadonlyMap<string, ReadonlySet<string>>,
+  member: InventorySymbol,
+): readonly string[] {
+  return [...run.symbols.values()]
+    .filter((symbol) => {
+      const from = namedBy.get(symbol.id);
+      return (
+        symbol.kind === "type-parameter" &&
+        symbol.parent === member.parent &&
+        from?.size === 1 &&
+        from.has(member.id)
+      );
+    })
+    .map((symbol) => symbol.name);
+}
+
+/** What one write-only finding says, the declarations its deletion takes with it included. */
+function writeOnlyMessage(
+  run: Run,
+  namedBy: ReadonlyMap<string, ReadonlySet<string>>,
+  symbol: InventorySymbol,
+  held: Uses,
+): string {
+  const writes = held.writes.length === 1 ? "once" : `at ${String(held.writes.length)} positions`;
+  const read = run.input.stores.readInTests.has(symbol.id)
+    ? "read only from test files"
+    : "never read";
+  const cascade = [
+    ...parametersOnlyNamedBy(run, namedBy, symbol).map((name) => `type parameter ${name}`),
+    ...[...held.alone].sort().map((name) => `import ${name}`),
+  ];
+  const word = SUBJECT_WORDS[symbol.kind] ?? "member";
+  const message = `${word} ${symbol.name} is written ${writes} and ${read}`;
+  return cascade.length === 0
+    ? message
+    : `${message}, and deleting it with its writes deletes ${cascade.join(" and ")} too`;
+}
+
 /**
- * `DS1301`: a module-level variable or a class member the counted references store into
- * and never read, named with every position written.
+ * `DS1301`: a module-level variable, a type member or a class member the counted
+ * references store into and never read, named with every position written.
  *
  * The subject is a live declaration: a store is a reference, so the sweep holds a
  * written one live and its candidates are never this kind's. Every reference that is
@@ -91,7 +144,7 @@ function writeOnlySymbols(run: Run): readonly Finding[] {
   for (const reference of stores.references) {
     let held = uses.get(reference.to);
     if (held === undefined) {
-      held = { writes: [], reads: 0 };
+      held = { writes: [], reads: 0, alone: new Set() };
       uses.set(reference.to, held);
     }
     // A consumer's store is written at a position no report of the target can name, so
@@ -100,6 +153,9 @@ function writeOnlySymbols(run: Run): readonly Finding[] {
       held.reads += 1;
       continue;
     }
+    for (const name of reference.alone ?? []) {
+      held.alone.add(name);
+    }
     const at = reference.position;
     const key = positionKey(at);
     if (!held.writes.some((written) => positionKey(written) === key)) {
@@ -107,6 +163,13 @@ function writeOnlySymbols(run: Run): readonly Finding[] {
     }
   }
 
+  const namedBy = new Map<string, Set<string>>();
+  for (const reference of stores.references) {
+    if (run.symbols.get(reference.to)?.kind === "type-parameter") {
+      namedBy.set(reference.to, (namedBy.get(reference.to) ?? new Set()).add(reference.from));
+    }
+  }
+
   const found: Finding[] = [];
   for (const symbol of matrix.union.symbols) {
     const held = uses.get(symbol.id);
@@ -120,10 +183,8 @@ function writeOnlySymbols(run: Run): readonly Finding[] {
     ) {
       continue;
     }
-    const writes = held.writes.length === 1 ? "once" : `at ${String(held.writes.length)} positions`;
-    const word = symbol.kind === "variable" ? "variable" : "member";
     found.push(
-      findingAbout(symbol, "DS1301", `${word} ${symbol.name} is written ${writes} and never read`, {
+      findingAbout(symbol, "DS1301", writeOnlyMessage(run, namedBy, symbol, held), {
         writePositions: held.writes,
       }),
     );

package/src/findings/unused-declarations.ts

@@ -52,6 +52,8 @@ interface Judged {
   readonly symbol: InventorySymbol;
   /** Whether a test file declares it. */
   readonly test: boolean;
+  /** Whether a test-support file declares it, which test code keeps live. */
+  readonly support: boolean;
   /** Whether its container is itself dead, so it falls with the container. */
   readonly containerDead: boolean;
   readonly deprecated: boolean;
@@ -62,8 +64,9 @@ interface Judged {
 /**
  * The code one candidate is reported under, or none, each symbol once under the most
  * specific code: a test of dead code first; no other test-file declaration, member of a
- * dead container or enum member nothing names; then deprecation, a test reference, and
- * the unreferenced codes, an unimportable unused export being the unreachable kind's.
+ * dead container or enum member nothing names, nor a test-support declaration test code
+ * references; then deprecation, a test reference, and the unreferenced codes, an
+ * unimportable unused export being the unreachable kind's.
  */
 function codeOf(judged: Judged): string | undefined {
   const { candidate, symbol } = judged;
@@ -77,6 +80,9 @@ function codeOf(judged: Judged): string | undefined {
   if (symbol.kind === "enum-member" && !referenced) {
     return undefined;
   }
+  if (judged.support && candidate.testRefs > 0) {
+    return undefined;
+  }
   if (candidate.productionRefs === 0 && judged.deprecated) {
     return "DS1006";
   }
@@ -136,6 +142,52 @@ function messageOf(code: string, judged: Judged): string {
   return `${subject} has no reference in the target`;
 }
 
+/**
+ * The members nothing writes or reads that are brands: each names a type parameter of
+ * its declaring type that no other part of the declaration names, other than another
+ * such member. They are what make two instantiations of the type distinct types, so
+ * deleting them would let one instantiation stand for another.
+ */
+function brandMembers(input: EmitterInput): ReadonlySet<string> {
+  const union = input.swept.matrix.union;
+  const unreferenced = new Map(
+    input.swept.sweep.candidates
+      .filter((candidate) => candidate.productionRefs + candidate.testRefs === 0)
+      .map((candidate) => [candidate.id, candidate]),
+  );
+  const namedBy = new Map<string, Set<string>>();
+  for (const reference of input.stores.references) {
+    const to = union.symbols[union.at(reference.to)];
+    if (to?.kind === "type-parameter") {
+      namedBy.set(to.id, (namedBy.get(to.id) ?? new Set()).add(reference.from));
+    }
+  }
+  const brands = new Set<string>();
+  for (const [parameter, from] of namedBy) {
+    const owner = union.symbols[union.at(parameter)]?.parent;
+    const members = [...from].map((id) => union.symbols[union.at(id)]);
+    if (
+      members.every(
+        (member) =>
+          member !== undefined &&
+          member.parent === owner &&
+          BRANDS.has(member.kind) &&
+          unreferenced.has(member.id),
+      )
+    ) {
+      for (const member of members) {
+        if (member !== undefined) {
+          brands.add(member.id);
+        }
+      }
+    }
+  }
+  return brands;
+}
+
+/** The kinds of member a brand is: a data member of a type or of a class. */
+const BRANDS: ReadonlySet<SymbolKind> = new Set(["type-member", "class-member"]);
+
 /** The findings of the unused-declarations family, `DS1000` to `DS1099`. */
 export const unusedDeclarations: Emitter = (input) => familyFindings(input, false);
 
@@ -151,6 +203,7 @@ function familyFindings(input: EmitterInput, fallen: boolean): Finding[] {
   const union = input.swept.matrix.union;
   const dead = new Set(input.swept.sweep.candidates.map((candidate) => candidate.id));
   const unreachable = unreachableExports(input);
+  let brands: ReadonlySet<string> | undefined;
 
   const found: Finding[] = [];
   for (const candidate of input.swept.sweep.candidates) {
@@ -167,12 +220,16 @@ function familyFindings(input: EmitterInput, fallen: boolean): Finding[] {
       candidate,
       symbol,
       test: union.test[at] === true,
+      support: union.support[at] === true,
       containerDead: containerDead && !fallen,
       deprecated: input.deprecated.has(symbol.id),
       unreachable: unreachable.has(symbol.id),
     };
     const code = codeOf(judged);
-    if (code === undefined) {
+    if (
+      code === undefined ||
+      (code === "DS1003" && (brands ??= brandMembers(input)).has(symbol.id))
+    ) {
       continue;
     }
     const endLine = Math.max(symbol.position.line, symbol.endLine);

package/src/generated-file.ts

@@ -0,0 +1,27 @@
+/**
+ * The generated-file class on TypeScript: every declaration in a file below a directory
+ * an applied convention row names as generated is retained, because the framework owns
+ * the file and a deletion there is undone at the next generation.
+ */
+
+import type { DetectorInput, Evidence } from "./exempt.ts";
+
+/** The generated-file detector, recording each file's first line. */
+export function generatedFile<Brand>(input: DetectorInput<Brand>): readonly Evidence[] {
+  const generated = input.generated;
+  if (generated === undefined || generated.size === 0) {
+    return [];
+  }
+  return input.held.symbols.flatMap((symbol): Evidence[] => {
+    const row = generated.get(symbol.position.path);
+    return symbol.kind === "file" || row === undefined
+      ? []
+      : [
+          {
+            id: symbol.id,
+            detail: `generated below a directory the convention row ${row} names`,
+            site: { path: symbol.position.path, line: 1, column: 1 },
+          },
+        ];
+  });
+}

package/src/graph.ts

@@ -39,20 +39,26 @@ const SWEPT: Readonly<Record<SymbolKind, boolean>> = {
 
 /**
  * Whether a root of each kind names a caller, which holds it live under both relations: a
- * tool reads the configuration it loads, a runtime runs a test file, a setup file, a
- * worker and a command, the manifest names what enters the package, and an entry file, a
- * configured root and a pattern assert a caller. A library's published API only supposes
+ * tool reads the configuration it loads and the files its strings name, a runtime runs a
+ * test file, a setup file, a worker, a command and a script, the manifest names what
+ * enters the package, an alias global stands for the export it names, and an entry file,
+ * a configured root and a pattern assert a caller. A library's published API only supposes
  * a consumer the run may not see, so it is live under reachability alone.
  */
 const NAMES_A_CALLER: Readonly<Record<RootKind, boolean>> = {
   "entry-file": true,
+  convention: true,
   "manifest-entry": true,
   "manifest-binary": true,
+  script: true,
   "published-api": false,
   configured: true,
   pattern: true,
+  "type-error": true,
+  "type-query-alias": true,
+  "configuration-file": true,
+  "configuration-string": true,
   "test-runner": true,
-  "lint-configuration": true,
   "mutation-testing": true,
   "browser-tests": true,
   worker: true,
@@ -103,6 +109,8 @@ export interface Graph {
   readonly parent: readonly number[];
   /** Per declaration, whether a test file holds it. */
   readonly test: readonly boolean[];
+  /** Per declaration, whether a test-support file holds it. */
+  readonly support: readonly boolean[];
   /** Per declaration, whether the sweep judges its liveness. */
   readonly subject: readonly boolean[];
   /**
@@ -135,7 +143,9 @@ export function graphOf(
   references: readonly Reference[],
   roots: readonly Root[],
   testFiles: readonly string[],
+  supportFiles: readonly string[] = [],
 ): Graph {
+  const supports = new Set(supportFiles);
   const index = new Map(symbols.map((symbol, at) => [symbol.id, at]));
   const at = (id: string): number => index.get(id) ?? OUTSIDE;
   const tests = new Set(testFiles);
@@ -187,6 +197,7 @@ export function graphOf(
     made,
     parent,
     test: symbols.map((symbol) => tests.has(symbol.position.path)),
+    support: symbols.map((symbol) => supports.has(symbol.position.path)),
     subject: symbols.map((symbol) => swept(symbol.kind)),
     exportsOf,
     rooted,

package/src/host.ts

@@ -27,6 +27,12 @@ export interface Host {
   readDirectory(path: string): readonly DirectoryEntry[];
   /** What one path names, `"absent"` where nothing is there. */
   kindOf(path: string): PathKind;
+  /**
+   * The path one path names once every symbolic link along it is followed, or a throw
+   * naming why it cannot be: a package manager links an installed workspace package
+   * into `node_modules`, and the link's target is what says which package it is.
+   */
+  realPath(path: string): string;
   /**
    * The version of the package this analyzer was installed from, or a throw
    * naming why it cannot be known. It is a method rather than a value because
@@ -41,4 +47,21 @@ export interface Host {
    * never a part of it.
    */
   writeDocument(path: string, pieces: Iterable<string>): void;
+  /**
+   * A new empty directory of its own, outside every tree the run reads, or a throw naming
+   * why it cannot be made. The run removes it before it ends.
+   */
+  temporaryDirectory(): TemporaryDirectory;
+  /**
+   * The command that runs this analyzer's mapper for component files, under the runtime
+   * the analyzer itself runs under. The compiler starts it to read a component file.
+   */
+  componentMapperCommand(): readonly string[];
+}
+
+/** One directory a run made for itself. */
+export interface TemporaryDirectory {
+  readonly path: string;
+  /** Removes the directory and everything in it; removing it twice removes it once. */
+  remove(): void;
 }

package/src/index.ts

@@ -1,5 +1,5 @@
 export { run, SETTING_OPTIONS, type Writer } from "./run.ts";
-export type { DirectoryEntry, Host, PathKind } from "./host.ts";
+export type { DirectoryEntry, Host, PathKind, TemporaryDirectory } from "./host.ts";
 export { DECLINED_CONVENTIONS, type DeclinedConvention } from "./entry-point-gaps.ts";
 export {
   byPosition,

package/src/interface-satisfaction.ts

@@ -14,33 +14,16 @@
  */
 
 import {
-  isArrayLiteralExpression,
-  isArrowFunction,
-  isAsExpression,
-  isBinaryExpression,
-  isCallExpression,
   isClassDeclaration,
   isClassExpression,
   isClassStaticBlockDeclaration,
-  isConditionalExpression,
   isFunctionDeclaration,
   isFunctionExpression,
   isGetAccessorDeclaration,
   isHeritageClause,
-  isIdentifier,
   isMethodDeclaration,
-  isNewExpression,
   isObjectLiteralExpression,
-  isParameterDeclaration,
-  isParenthesizedExpression,
-  isPropertyAssignment,
-  isPropertyDeclaration,
-  isReturnStatement,
-  isSatisfiesExpression,
   isSetAccessorDeclaration,
-  isShorthandPropertyAssignment,
-  isSpreadElement,
-  isVariableDeclaration,
   ModifierFlags,
   SyntaxKind,
   type Expression,
@@ -53,6 +36,7 @@ import type { DetectorInput, Evidence } from "./exempt.ts";
 import { nodeKey } from "./inventory.ts";
 import { renderPosition } from "./position.ts";
 import { must } from "./query.ts";
+import { handedOn, valuesOf } from "./value-flow.ts";
 
 /** One class the inventory holds, by its declaration. */
 interface ClassAt {
@@ -85,14 +69,6 @@ interface Pair {
   readonly sites: Node[];
 }
 
-/** The operators of an assignment whose right side is stored into the left side's type. */
-const STORES: ReadonlySet<SyntaxKind> = new Set([
-  SyntaxKind.EqualsToken,
-  SyntaxKind.QuestionQuestionEqualsToken,
-  SyntaxKind.BarBarEqualsToken,
-  SyntaxKind.AmpersandAmpersandEqualsToken,
-]);
-
 /** Whether one node declares a static member, whose `this` is the class itself. */
 function isStatic(node: Node): boolean {
   const flags = (node as { readonly modifierFlags?: number }).modifierFlags ?? 0;
@@ -109,73 +85,6 @@ function isObjectLiteralMethod(node: Node): boolean {
   );
 }
 
-/** Whether a declaration writes its type, so its initializer is read in that type's context. */
-function writesType(node: Node): boolean {
-  return (node as { readonly type?: Node }).type !== undefined;
-}
-
-/**
- * The values one written expression hands on: the expression itself, or what it
- * evaluates to through parentheses, a conditional and the operators whose result is
- * one of their operands.
- */
-function valuesOf(expression: Expression): readonly Expression[] {
-  if (isParenthesizedExpression(expression)) {
-    return valuesOf(expression.expression);
-  }
-  if (isConditionalExpression(expression)) {
-    return [...valuesOf(expression.whenTrue), ...valuesOf(expression.whenFalse)];
-  }
-  if (isBinaryExpression(expression)) {
-    const operator = expression.operatorToken.kind;
-    if (operator === SyntaxKind.QuestionQuestionToken || operator === SyntaxKind.BarBarToken) {
-      return [...valuesOf(expression.left), ...valuesOf(expression.right)];
-    }
-    if (operator === SyntaxKind.AmpersandAmpersandToken || operator === SyntaxKind.CommaToken) {
-      return valuesOf(expression.right);
-    }
-  }
-  return [expression];
-}
-
-/** The expressions one node hands to a position typed by its context. */
-function handedOn(node: Node): readonly Expression[] {
-  if (
-    (isVariableDeclaration(node) || isPropertyDeclaration(node) || isParameterDeclaration(node)) &&
-    node.initializer !== undefined &&
-    writesType(node)
-  ) {
-    return [node.initializer];
-  }
-  if (isBinaryExpression(node) && STORES.has(node.operatorToken.kind)) {
-    return [node.right];
-  }
-  if (isCallExpression(node) || isNewExpression(node)) {
-    return (node.arguments ?? []).filter((argument) => !isSpreadElement(argument));
-  }
-  if (isReturnStatement(node)) {
-    return node.expression === undefined ? [] : [node.expression];
-  }
-  if (isArrowFunction(node)) {
-    return node.body.kind === SyntaxKind.Block ? [] : [node.body];
-  }
-  if (isArrayLiteralExpression(node)) {
-    return node.elements.filter(
-      (element) => !isSpreadElement(element) && element.kind !== SyntaxKind.OmittedExpression,
-    );
-  }
-  if (isPropertyAssignment(node)) {
-    return [node.initializer];
-  }
-  if (isShorthandPropertyAssignment(node)) {
-    return isIdentifier(node.name) ? [node.name] : [];
-  }
-  if (isAsExpression(node) || isSatisfiesExpression(node)) {
-    return [node.expression];
-  }
-  return [];
-}
-
 /** What one project's walk found to resolve. */
 interface Walked {
   readonly classes: readonly ClassAt[];

package/src/inventory.ts

@@ -31,7 +31,13 @@ import {
 import type { Symbol as TSSymbol } from "@typescript/native/unstable/sync";
 import type { Host } from "./host.ts";
 import { dirnamePath, joinPath, relativePath } from "./paths.ts";
-import { byPosition, positionKey, renderPosition, type Position } from "./position.ts";
+import {
+  byPosition,
+  positionKey,
+  renderPosition,
+  writtenLength,
+  type Position,
+} from "./position.ts";
 import { computedComponent, nameComponent, renderRef, type Component, type Module } from "./ref.ts";
 import { isAnswered, UNANSWERED } from "./query.ts";
 import type { Handle, ProjectView } from "./session.ts";
@@ -297,7 +303,10 @@ function typeParametersOf(node: Node): readonly Node[] {
   if (
     isFunctionDeclaration(node) ||
     isMethodDeclaration(node) ||
-    isMethodSignatureDeclaration(node)
+    isMethodSignatureDeclaration(node) ||
+    isClassDeclaration(node) ||
+    isInterfaceDeclaration(node) ||
+    isTypeAliasDeclaration(node)
   ) {
     return node.typeParameters ?? [];
   }
@@ -534,7 +543,12 @@ export function inventory<Brand>(
       typeParameter: undefined,
     });
     exportScopes.push({ owner: fileRecord, nameNode: file });
-    walkStatements(file.statements, fileRecord);
+    // A statement a component file's module appends is not written in the file.
+    const written = writtenLength(file);
+    walkStatements(
+      file.statements.filter((statement) => statement.end <= written),
+      fileRecord,
+    );
   }
 
   /** One declaration of a module, a namespace or a container body. */

package/src/kinds.ts

@@ -60,6 +60,8 @@ const ROWS: readonly KindRow[] = [
     name: "unused-member",
     languages: ["go", "ts"],
     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.",
+    precondition:
+      "A TypeScript member that no value writes and nothing reads, whose type names a type parameter of its declaring interface, class or type alias, is not reported when every part of that declaration that names the type parameter is a member no value writes and nothing reads. TypeScript compares object types by their members, so such members are what make two instantiations of their type distinct types, and deleting them leaves the type parameter phantom and lets one instantiation stand for another. A member a value writes is decided by the rule of DS1301 instead, whatever its type names.",
     defaultSeverity: "deny",
     maxClass: "certain",
     fixability: "deletable",
@@ -69,7 +71,7 @@ const ROWS: readonly KindRow[] = [
     code: "DS1004",
     name: "test-only-use",
     languages: ["go", "ts"],
-    rule: "A symbol with zero production references and at least one test reference: an unused-exported, unused-unexported or unused-member 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.",
+    rule: "A symbol with zero production references and at least one test reference: an unused-exported, unused-unexported or unused-member 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. A reference from test-support code, a package or file that only test code imports, is a test reference, and a declaration of test-support code is never reported under this code.",
     defaultSeverity: "deny",
     maxClass: "certain",
     fixability: "deletable",
@@ -101,7 +103,7 @@ const ROWS: readonly KindRow[] = [
     languages: ["go", "ts"],
     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. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first.",
+      "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. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type that a parameter or a result of an exported function or method of its own package names is not reported when a reference from outside the package references that function or method, because the caller holds values of the type, and unexporting it would leave an exported signature naming a type its callers cannot name.",
     defaultSeverity: "warn",
     maxClass: "certain",
     fixability: "narrowable",
@@ -113,7 +115,7 @@ const ROWS: readonly KindRow[] = [
     languages: ["go"],
     rule: "An exported symbol of a non-internal package whose every reference is inside the target module, reported as a candidate for relocation behind an internal boundary. 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. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first.",
+      "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. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type that a parameter or a result of an exported function or method of its own package names is not reported when a reference from outside the target module references that function or method, because the caller holds values of the type, and moving it behind an internal boundary would leave an exported signature naming a type its callers cannot name.",
     defaultSeverity: "warn",
     maxClass: "certain",
     fixability: "narrowable",
@@ -177,7 +179,7 @@ const ROWS: readonly KindRow[] = [
     code: "DS1301",
     name: "write-only-symbol",
     languages: ["go", "ts"],
-    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.",
+    rule: "A package-level or module-level variable, struct field, class member, type 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. In TypeScript a property of an object literal writes the member of the same name that the literal's contextual type declares, whether or not the compiler checks the literal for excess properties. Where that contextual type is a union or an intersection, the property writes the member of that name on each constituent that declares one. So a literal that a declaration annotates, a function returns, a call passes or a `satisfies` expression checks writes the members of the type it is given. A store through the value a field or a member holds reads that field or member rather than writing it, because the store lands in storage every other holder of the value reads. In Go that store is an assignment, an increment, a compound assignment or a `delete` whose target is reached through a struct field holding a map, a slice or a pointer. Examples are `s.f[k] = v`, `s.f.x = v` and `delete(s.f, k)`. The same store through a field holding an array or a struct is a store into the field itself. TypeScript holds every object by reference, so an element or property store through a member's value reads the member. The finding names each write position, so the deletion set is visible. Deleting the subject and its writes also deletes every declaration whose only uses they hold. Such a declaration is a type parameter of the subject's declaring type that the subject's type alone names, or an import binding the writes alone use. The finding's message names each such declaration.",
     defaultSeverity: "deny",
     maxClass: "certain",
     fixability: "deletable",
@@ -317,7 +319,7 @@ const ROWS: readonly KindRow[] = [
     languages: ["go", "ts"],
     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.",
+      "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, is not a function the Go test driver runs (a test, benchmark or fuzz test of a test file, or TestMain), 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.",
     defaultSeverity: "warn",
     maxClass: "certain",
     fixability: "manual",