@cplieger/deadset-ts 5.0.0 → 5.1.1

package/src/findings/completion.ts

@@ -146,8 +146,9 @@ export function completed(
   const classOf = reachabilityClasses(input);
   const componentOf = findingComponents(swept, input.config.reporters.cascade);
   let minted = swept.sweep.components.length;
+  const dead = new Set(swept.sweep.components.map((component) => component.id));
 
-  return findings.map((finding): CompletedFinding => {
+  const done = findings.map((finding): CompletedFinding => {
     const row = kinds.get(finding.code);
     if (row === undefined) {
       throw new Error(`${finding.code} names no live row of the issue-kind vocabulary`);
@@ -183,6 +184,7 @@ export function completed(
         ? union.made[at]
         : { production: candidate.productionRefs, test: candidate.testRefs };
     const reachabilityClass = judged === undefined ? "certain" : classOf(judged.id);
+    const generated = input.files.generated?.has(finding.position.path) === true;
     return {
       code: finding.code,
       kind: row.name,
@@ -193,7 +195,7 @@ export function completed(
       confidence: capped(reachabilityClass, row.maxClass),
       ...(candidate === undefined ? {} : { livenessRelation: candidate.relation }),
       testOnly: judged !== undefined && counts?.production === 0 && counts.test > 0,
-      generated: false,
+      generated,
       component,
       retainedBy: [],
       configurations:
@@ -202,12 +204,38 @@ export function completed(
           ? swept.matrix.configurations
           : (swept.matrix.heldIn[at] ?? swept.matrix.configurations)),
       consumersLoaded: input.boundary.consumers.loaded,
-      fixability: row.fixability,
+      fixability: generated ? "none" : row.fixability,
       severity: severityOf(input, finding.code, row.defaultSeverity),
       message: finding.message,
       details: finding.details ?? {},
     };
   });
+  return componentCapped(done, dead);
+}
+
+/**
+ * The findings with every finding of a dead component capped by the lowest confidence
+ * among the component's root members, so the minimum confidence reports or withholds a
+ * component whole.
+ */
+function componentCapped(
+  findings: readonly CompletedFinding[],
+  dead: ReadonlySet<string>,
+): readonly CompletedFinding[] {
+  const lowest = new Map<string, Confidence>();
+  for (const finding of findings) {
+    const { id, root } = finding.component;
+    if (root && dead.has(id)) {
+      const held = lowest.get(id);
+      lowest.set(id, held === undefined ? finding.confidence : capped(held, finding.confidence));
+    }
+  }
+  return findings.map((finding) => {
+    const cap = lowest.get(finding.component.id);
+    return cap === undefined || RANK[cap] >= RANK[finding.confidence]
+      ? finding
+      : { ...finding, confidence: cap };
+  });
 }
 
 /** Whether the dials withhold a finding by its own severity or confidence. */

package/src/findings/interfaces.ts

@@ -31,6 +31,7 @@ function compare(a: string, b: string): number {
 function indexed(input: EmitterInput): {
   readonly symbolOf: (id: string) => InventorySymbol | undefined;
   readonly inTest: (id: string) => boolean;
+  readonly inSupport: (id: string) => boolean;
   readonly candidateOf: (id: string) => Candidate | undefined;
   readonly implementationsOf: (id: string) => readonly PositionedSymbol[];
 } {
@@ -43,6 +44,7 @@ function indexed(input: EmitterInput): {
   return {
     symbolOf,
     inTest: (id) => union.test[union.at(id)] === true,
+    inSupport: (id) => union.support[union.at(id)] === true,
     candidateOf: (id) => candidates.get(id),
     implementationsOf: (id) =>
       [...(input.implementations.classes.get(id) ?? [])]
@@ -80,14 +82,19 @@ function findingOf(
  * interface, whose members fall with it unreported; and `DS1203`, 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.
+ * subject, because a production sweep counts none of the references it can have, and
+ * neither is a test-support declaration test code references, which that code keeps live.
  */
 export const interfaces: Emitter = (input) => {
   const run = indexed(input);
   const found: Finding[] = [];
   for (const candidate of input.swept.sweep.candidates) {
     const symbol = run.symbolOf(candidate.id);
-    if (symbol === undefined || run.inTest(candidate.id)) {
+    if (
+      symbol === undefined ||
+      run.inTest(candidate.id) ||
+      (run.inSupport(candidate.id) && candidate.testRefs > 0)
+    ) {
       continue;
     }
     if (symbol.kind === "interface") {

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

@@ -142,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);
 
@@ -157,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) {
@@ -179,7 +226,10 @@ function familyFindings(input: EmitterInput, fallen: boolean): Finding[] {
       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

@@ -122,9 +122,9 @@ export interface Graph {
   /** Every root naming a declaration the inventory holds, in the order the root set gives them. */
   readonly rooted: readonly Rooted[];
   /**
-   * Every reference a loaded consumer makes to a declaration the inventory holds, in the
-   * order given. A consumer is a caller the analysis read, so the sweep holds what it
-   * names live under both relations and reaches on from there.
+   * Every reference a loaded consumer or an unheld file makes to a declaration the
+   * inventory holds, in the order given. Such a file is a caller the analysis read, so the
+   * sweep holds what it names live under both relations and reaches on from there.
    */
   readonly consumed: readonly Edge[];
   /** The position of the declaration one identifier names, or {@link OUTSIDE}. */
@@ -167,7 +167,7 @@ export function graphOf(
       }
     }
     const edge = { to, test: reference.test, evaluation: reference.use === "evaluation" };
-    if (reference.consumer !== undefined) {
+    if (reference.consumer !== undefined || reference.unheld === true) {
       consumed.push(edge);
       continue;
     }

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

@@ -303,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 ?? [];
   }
@@ -467,7 +470,20 @@ function nameNodeOf(node: Node): Node | undefined {
  * needs the declaration this enumeration made for it.
  */
 export function nodeKey(file: SourceFile, node: Node): string {
-  return `${file.fileName}:${String(node.pos)}:${String(node.end)}`;
+  return `${file.fileName}:${String(node.pos)}:${String(node.end)}:${String(node.kind)}`;
+}
+
+/** `export default`, up to the keyword that stands where an unnamed default export's name would. */
+const DEFAULT_EXPORT = /^export\s+(?=default\b)/u;
+
+/**
+ * Where an unnamed declaration is placed: at `default` when it is the default export, so it
+ * never shares the file's own position, else at its first token.
+ */
+function unnamedStart(node: Node): number {
+  const start = node.getStart();
+  const prefix = DEFAULT_EXPORT.exec(node.getText());
+  return prefix === null ? start : start + prefix[0].length;
 }
 
 /** The kind a class element takes: a method, or a property or accessor. */
@@ -562,12 +578,11 @@ export function inventory<Brand>(
     name: Node | undefined,
     named: { readonly component: Component; readonly localName: string | undefined },
   ): Building {
-    const at = name ?? node;
     const record = keep({
       file: owner.file,
       node,
       module: owner.module,
-      position: renderPosition(owner.file, targetRoot, at.getStart()),
+      position: renderPosition(owner.file, targetRoot, name?.getStart() ?? unnamedStart(node)),
       endLine: renderPosition(owner.file, targetRoot, Math.max(node.end - 1, 0)).line,
       kind,
       parentChain: owner.kind === "file" ? [] : chainOf(owner),

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",
@@ -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",

package/src/manifest.ts

@@ -1,13 +1,12 @@
 /**
  * The entry points a package manifest names, which are roots because something
  * outside the analyzed program reaches them: a consumer importing the package, or a
- * shell running its command or one of its scripts.
- *
- * One call reads one manifest, the one in the directory it is given.
+ * shell running its command or one of its scripts. {@link readManifest} reads one
+ * directory's manifest, {@link packageEntries} those of the packages below the target root.
  */
 
 import type { Host } from "./host.ts";
-import { isAbsolutePath, joinPath, resolvePath } from "./paths.ts";
+import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.ts";
 
 /** The manifest's own name. */
 const MANIFEST = "package.json";
@@ -205,3 +204,40 @@ export function readManifest(host: Host, targetRoot: string): Manifest {
     declaresExports: manifest["exports"] !== undefined,
   };
 }
+
+/**
+ * The entry points every package manifest between the target root and each compiler
+ * configuration names: each directory holding a `package.json` that a configuration sits
+ * in or below, the target root and `known` excluded, whose manifests the run reads
+ * otherwise. Each entry is spelled under its manifest's path below the target root, and
+ * is published by its own manifest's rule, as the target's own entries are.
+ */
+export function packageEntries(
+  host: Host,
+  targetRoot: string,
+  configFiles: readonly string[],
+  known: ReadonlySet<string>,
+): readonly ManifestEntry[] {
+  const dirs = new Set<string>();
+  for (const configFile of configFiles) {
+    for (
+      let dir = dirnamePath(resolvePath(targetRoot, configFile));
+      dir !== targetRoot && relativePath(targetRoot, dir) !== undefined;
+      dir = dirnamePath(dir)
+    ) {
+      if (!known.has(dir) && host.kindOf(joinPath(dir, MANIFEST)) === "file") {
+        dirs.add(dir);
+      }
+    }
+  }
+  return [...dirs].sort().flatMap((dir) => {
+    const manifest = readManifest(host, dir);
+    const where = `${relativePath(targetRoot, dir) ?? dir}/${MANIFEST}`;
+    return manifest.entries.map((entry) => ({
+      ...entry,
+      member: `${where} ${entry.member}`,
+      published:
+        entry.published && (!manifest.declaresExports || entry.member.startsWith("exports")),
+    }));
+  });
+}