@cplieger/deadset-ts 3.6.0 → 3.7.0

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

@@ -1,72 +1,20 @@
-import type { Confidence, Severity } from "../config.ts";
-import type { Finding, FindingPosition } from "../finding.ts";
+import type { Finding, FindingDetails, FindingPosition } from "../finding.ts";
 import type { InventorySymbol } from "../inventory.ts";
 import type { MatrixCandidate } from "../matrix.ts";
 import { positionKey } from "../position.ts";
-import type { Relation } from "../sweep.ts";
-import {
-  findingComponents,
-  RANK,
-  reachabilityClasses,
-  severityOf,
-  type FindingComponent,
-} from "./completion.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
 
 /** The codes of this family. */
-export type ReadsAndWritesCode = "DS1301" | "DS1302" | "DS1303";
-
-/**
- * Each code's severity where the configuration sets none, as the issue-kind vocabulary
- * states it.
- */
-export const DEFAULT_SEVERITY: Readonly<Record<ReadsAndWritesCode, Severity>> = {
-  DS1301: "deny",
-  DS1302: "deny",
-  DS1303: "deny",
-};
-
-/** What only some codes carry. */
-export interface ReadsAndWritesDetails {
-  /** Every position the subject is written at, on `DS1301` alone. */
-  readonly writePositions?: readonly FindingPosition[];
-}
-
-/** One finding of this family, with every member the family decides. */
-export interface ReadsAndWritesFinding extends Finding {
-  readonly code: ReadsAndWritesCode;
-  readonly reachabilityClass: Confidence;
-  readonly confidence: Confidence;
-  /** The relation that decided the subject, absent on `DS1301`, whose subject is live. */
-  readonly livenessRelation?: Relation;
-  /** Whether every reference the run counts to the subject comes from a test file. */
-  readonly testOnly: boolean;
-  /**
-   * The dead component the subject belongs to, absent where it belongs to none: a live
-   * subject falls with nothing, and the report gives it a component of its own.
-   */
-  readonly component?: FindingComponent;
-  /** The configurations the finding holds in, in the run's order. */
-  readonly configurations: readonly string[];
-  readonly severity: Severity;
-  readonly details: ReadsAndWritesDetails;
-}
+type ReadsAndWritesCode = "DS1301" | "DS1302" | "DS1303";
 
 /** The containers whose type parameters `DS1303` reports: a function and a class method. */
 const SIGNATURES: ReadonlySet<string> = new Set(["function", "method"]);
 
-/** The severity the configuration gives one code of the family. */
-function severityIn(input: EmitterInput, code: ReadsAndWritesCode): Severity {
-  return severityOf(input.config, code, DEFAULT_SEVERITY[code]);
-}
-
 /** What the family reads of one run, indexed by declaration. */
 interface Run {
   readonly input: EmitterInput;
   readonly symbols: ReadonlyMap<string, InventorySymbol>;
   readonly candidates: ReadonlyMap<string, MatrixCandidate>;
-  readonly componentOf: (id: string) => FindingComponent | undefined;
-  readonly classOf: (id: string) => Confidence;
 }
 
 function indexed(input: EmitterInput): Run {
@@ -75,8 +23,6 @@ function indexed(input: EmitterInput): Run {
     input,
     symbols: new Map(matrix.union.symbols.map((symbol) => [symbol.id, symbol])),
     candidates: new Map(sweep.candidates.map((candidate) => [candidate.id, candidate])),
-    componentOf: findingComponents(input.swept),
-    classOf: reachabilityClasses(input.swept),
   };
 }
 
@@ -90,22 +36,14 @@ function positionOf(symbol: InventorySymbol): FindingPosition {
   };
 }
 
-/** The finding about one declaration, every member the family decides filled in. */
+/** The finding one code makes about one declaration. */
 function findingAbout(
-  run: Run,
   symbol: InventorySymbol,
   code: ReadsAndWritesCode,
   message: string,
-  facts: {
-    readonly livenessRelation?: Relation;
-    readonly testOnly: boolean;
-    readonly configurations: readonly string[];
-    readonly details: ReadsAndWritesDetails;
-  },
-): ReadsAndWritesFinding {
+  details?: FindingDetails,
+): Finding {
   const position = positionOf(symbol);
-  const reachabilityClass = run.classOf(symbol.id);
-  const component = run.componentOf(symbol.id);
   return {
     code,
     position,
@@ -116,14 +54,7 @@ function findingAbout(
       sizeLines: position.endLine - position.line + 1,
     },
     message,
-    reachabilityClass,
-    confidence: reachabilityClass,
-    ...(facts.livenessRelation === undefined ? {} : { livenessRelation: facts.livenessRelation }),
-    testOnly: facts.testOnly,
-    ...(component === undefined ? {} : { component }),
-    configurations: facts.configurations,
-    severity: severityIn(run.input, code),
-    details: facts.details,
+    ...(details === undefined ? {} : { details }),
   };
 }
 
@@ -131,8 +62,6 @@ function findingAbout(
 interface Uses {
   readonly writes: FindingPosition[];
   reads: number;
-  production: number;
-  test: number;
 }
 
 /**
@@ -155,21 +84,16 @@ function writable(run: Run, symbol: InventorySymbol): boolean {
  * written one live and its candidates are never this kind's. Every reference that is
  * not a store reads, and so does an exemption record naming the declaration.
  */
-function writeOnlySymbols(run: Run): readonly ReadsAndWritesFinding[] {
+function writeOnlySymbols(run: Run): readonly Finding[] {
   const { stores } = run.input;
   const { matrix } = run.input.swept;
   const uses = new Map<string, Uses>();
   for (const reference of stores.references) {
     let held = uses.get(reference.to);
     if (held === undefined) {
-      held = { writes: [], reads: 0, production: 0, test: 0 };
+      held = { writes: [], reads: 0 };
       uses.set(reference.to, held);
     }
-    if (reference.test) {
-      held.test += 1;
-    } else {
-      held.production += 1;
-    }
     if (reference.use !== "write") {
       held.reads += 1;
       continue;
@@ -181,8 +105,8 @@ function writeOnlySymbols(run: Run): readonly ReadsAndWritesFinding[] {
     }
   }
 
-  const found: ReadsAndWritesFinding[] = [];
-  matrix.union.symbols.forEach((symbol, at) => {
+  const found: Finding[] = [];
+  for (const symbol of matrix.union.symbols) {
     const held = uses.get(symbol.id);
     if (
       held === undefined ||
@@ -192,24 +116,16 @@ function writeOnlySymbols(run: Run): readonly ReadsAndWritesFinding[] {
       stores.exempt.has(symbol.id) ||
       run.candidates.has(symbol.id)
     ) {
-      return;
+      continue;
     }
     const writes = held.writes.length === 1 ? "once" : `at ${String(held.writes.length)} positions`;
     const word = symbol.kind === "variable" ? "variable" : "member";
     found.push(
-      findingAbout(
-        run,
-        symbol,
-        "DS1301",
-        `${word} ${symbol.name} is written ${writes} and never read`,
-        {
-          testOnly: held.production === 0 && held.test > 0,
-          configurations: matrix.heldIn[at] ?? [],
-          details: { writePositions: held.writes },
-        },
-      ),
+      findingAbout(symbol, "DS1301", `${word} ${symbol.name} is written ${writes} and never read`, {
+        writePositions: held.writes,
+      }),
     );
-  });
+  }
   return found;
 }
 
@@ -218,24 +134,19 @@ function writeOnlySymbols(run: Run): readonly ReadsAndWritesFinding[] {
  * one kind. A reference from a test file alone leaves a candidate to the test-only kind,
  * and a member of a dead container falls with it and is reported inside its component.
  */
-function unnamed(
-  run: Run,
-  kind: InventorySymbol["kind"],
-): readonly [MatrixCandidate, InventorySymbol][] {
-  return run.input.swept.sweep.candidates.flatMap(
-    (candidate): [MatrixCandidate, InventorySymbol][] => {
-      const symbol = run.symbols.get(candidate.id);
-      if (
-        symbol?.kind !== kind ||
-        candidate.productionRefs > 0 ||
-        candidate.testRefs > 0 ||
-        run.candidates.has(symbol.parent)
-      ) {
-        return [];
-      }
-      return [[candidate, symbol]];
-    },
-  );
+function unnamed(run: Run, kind: InventorySymbol["kind"]): readonly InventorySymbol[] {
+  return run.input.swept.sweep.candidates.flatMap((candidate): InventorySymbol[] => {
+    const symbol = run.symbols.get(candidate.id);
+    if (
+      symbol?.kind !== kind ||
+      candidate.productionRefs > 0 ||
+      candidate.testRefs > 0 ||
+      run.candidates.has(symbol.parent)
+    ) {
+      return [];
+    }
+    return [symbol];
+  });
 }
 
 /**
@@ -243,14 +154,9 @@ function unnamed(
  * record holds back is no candidate, so a member a conversion can produce never reaches
  * this kind.
  */
-function unusedEnumMembers(run: Run): readonly ReadsAndWritesFinding[] {
-  return unnamed(run, "enum-member").map(([candidate, symbol]) =>
-    findingAbout(run, symbol, "DS1302", `enum member ${symbol.name} is named nowhere`, {
-      livenessRelation: candidate.relation,
-      testOnly: false,
-      configurations: candidate.configurations,
-      details: {},
-    }),
+function unusedEnumMembers(run: Run): readonly Finding[] {
+  return unnamed(run, "enum-member").map((symbol) =>
+    findingAbout(symbol, "DS1302", `enum member ${symbol.name} is named nowhere`),
   );
 }
 
@@ -260,21 +166,14 @@ function unusedEnumMembers(run: Run): readonly ReadsAndWritesFinding[] {
  * a type alias or a method signature belongs to a type declaration and is never
  * reported, because a phantom parameter makes two instantiations distinct types.
  */
-function unusedTypeParameters(run: Run): readonly ReadsAndWritesFinding[] {
+function unusedTypeParameters(run: Run): readonly Finding[] {
   return unnamed(run, "type-parameter")
-    .filter(([, symbol]) => SIGNATURES.has(run.symbols.get(symbol.parent)?.kind ?? ""))
-    .map(([candidate, symbol]) =>
+    .filter((symbol) => SIGNATURES.has(run.symbols.get(symbol.parent)?.kind ?? ""))
+    .map((symbol) =>
       findingAbout(
-        run,
         symbol,
         "DS1303",
         `type parameter ${symbol.name} is named in neither its signature nor its body`,
-        {
-          livenessRelation: candidate.relation,
-          testOnly: false,
-          configurations: candidate.configurations,
-          details: {},
-        },
       ),
     );
 }
@@ -288,24 +187,11 @@ export function writeOnlyDeclarations(input: EmitterInput): ReadonlySet<string>
   return new Set(writeOnlySymbols(indexed(input)).map((finding) => finding.symbol.ref));
 }
 
-/** Each code's rule, in code order. */
-const RULES: readonly [ReadsAndWritesCode, (run: Run) => readonly ReadsAndWritesFinding[]][] = [
-  ["DS1301", writeOnlySymbols],
-  ["DS1302", unusedEnumMembers],
-  ["DS1303", unusedTypeParameters],
-];
-
 /**
- * The findings of the reads-and-writes family, `DS1300` to `DS1399`, each code's in site
- * order. A code the configuration sets to `allow` reports nothing, and a finding whose
- * confidence is below the configured minimum is withheld.
+ * The findings of the reads-and-writes family, `DS1300` to `DS1399`, in code order and
+ * each code's in site order.
  */
 export const readsAndWrites: Emitter = (input) => {
   const run = indexed(input);
-  const least = RANK[input.config.analysis.minConfidence];
-  return RULES.flatMap(([code, rule]) =>
-    severityIn(input, code) === "allow"
-      ? []
-      : rule(run).filter((finding) => RANK[finding.confidence] >= least),
-  );
+  return [...writeOnlySymbols(run), ...unusedEnumMembers(run), ...unusedTypeParameters(run)];
 };

package/src/findings/unused-declarations.ts

@@ -1,33 +1,9 @@
-import type { Confidence, Severity } from "../config.ts";
+import type { Finding } from "../finding.ts";
 import type { InventorySymbol, SymbolKind } from "../inventory.ts";
 import type { MatrixCandidate } from "../matrix.ts";
-import {
-  capped,
-  findingComponents,
-  reachabilityClasses,
-  reportable,
-  severityOf,
-  type CompletedFinding,
-} from "./completion.ts";
-import type { Emitter, EmitterInput } from "./emitter.ts";
+import type { Emitter } from "./emitter.ts";
 import { unreachableExports } from "./visibility-narrowing.ts";
 
-/** What the issue-kind vocabulary states about one code of the family. */
-interface KindRow {
-  readonly defaultSeverity: Severity;
-  readonly maxClass: Confidence;
-}
-
-/** The codes of the unused-declarations family, each by its row of the vocabulary. */
-export const UNUSED_DECLARATION_KINDS: ReadonlyMap<string, KindRow> = new Map([
-  ["DS1001", { defaultSeverity: "deny", maxClass: "certain" }],
-  ["DS1002", { defaultSeverity: "deny", maxClass: "certain" }],
-  ["DS1003", { defaultSeverity: "deny", maxClass: "certain" }],
-  ["DS1004", { defaultSeverity: "deny", maxClass: "certain" }],
-  ["DS1005", { defaultSeverity: "deny", maxClass: "certain" }],
-  ["DS1006", { defaultSeverity: "deny", maxClass: "certain" }],
-]);
-
 /** The kinds of declaration that are members of a class, an interface, a type or an enum. */
 const MEMBERS: ReadonlySet<SymbolKind> = new Set([
   "method",
@@ -160,20 +136,14 @@ function messageOf(code: string, judged: Judged): string {
   return `${subject} has no reference in the target`;
 }
 
-/**
- * The findings of the unused-declarations family, `DS1000` to `DS1099`, completed and
- * with what the dials withhold left out.
- */
-export function unusedDeclarationFindings(input: EmitterInput): readonly CompletedFinding[] {
-  const { config, swept } = input;
-  const union = swept.matrix.union;
-  const dead = new Set(swept.sweep.candidates.map((candidate) => candidate.id));
-  const classOf = reachabilityClasses(swept);
-  const componentOf = findingComponents(swept);
+/** The findings of the unused-declarations family, `DS1000` to `DS1099`. */
+export const unusedDeclarations: Emitter = (input) => {
+  const union = input.swept.matrix.union;
+  const dead = new Set(input.swept.sweep.candidates.map((candidate) => candidate.id));
   const unreachable = unreachableExports(input);
 
-  const found: CompletedFinding[] = [];
-  for (const candidate of swept.sweep.candidates) {
+  const found: Finding[] = [];
+  for (const candidate of input.swept.sweep.candidates) {
     const at = union.at(candidate.id);
     const symbol = union.symbols[at];
     if (symbol === undefined) {
@@ -188,16 +158,10 @@ export function unusedDeclarationFindings(input: EmitterInput): readonly Complet
       unreachable: unreachable.has(symbol.id),
     };
     const code = codeOf(judged);
-    const row = code === undefined ? undefined : UNUSED_DECLARATION_KINDS.get(code);
-    if (code === undefined || row === undefined) {
+    if (code === undefined) {
       continue;
     }
-    const component = componentOf(symbol.id);
-    if (component === undefined) {
-      throw new Error(`${symbol.id} is reported dead and falls in no dead component`);
-    }
     const endLine = Math.max(symbol.position.line, symbol.endLine);
-    const reachabilityClass = classOf(symbol.id);
     found.push({
       code,
       position: { ...symbol.position, endLine },
@@ -208,18 +172,7 @@ export function unusedDeclarationFindings(input: EmitterInput): readonly Complet
         sizeLines: endLine - symbol.position.line + 1,
       },
       message: messageOf(code, judged),
-      reachabilityClass,
-      confidence: capped(reachabilityClass, row.maxClass),
-      livenessRelation: candidate.relation,
-      testOnly: candidate.productionRefs === 0 && candidate.testRefs > 0,
-      component,
-      configurations: candidate.configurations,
-      severity: severityOf(config, code, row.defaultSeverity),
-      details: {},
     });
   }
-  return reportable(found, config.analysis.minConfidence);
-}
-
-/** The findings of the unused-declarations family, `DS1000` to `DS1099`. */
-export const unusedDeclarations: Emitter = unusedDeclarationFindings;
+  return found;
+};

package/src/findings/visibility-narrowing.ts

@@ -126,18 +126,13 @@ function wordOf(symbol: InventorySymbol): string {
   return WORDS[symbol.kind] ?? symbol.kind;
 }
 
-/** A finding of this family, with the visibility a narrowing would give its subject. */
-interface NarrowingFinding extends Finding {
-  readonly details: { readonly narrowerVisibility?: "file" | "package" };
-}
-
 /** The visibility each narrowing code names, which only the narrowing codes carry. */
 const NARROWER: Readonly<Record<string, "file" | "package">> = {
   [REDUNDANT_EXPORT_KEYWORD]: "file",
   [UNNECESSARY_EXPORT]: "package",
 };
 
-function findingOf(symbol: InventorySymbol, code: string, message: string): NarrowingFinding {
+function findingOf(symbol: InventorySymbol, code: string, message: string): Finding {
   const { path, line, column } = symbol.position;
   const narrower = Object.hasOwn(NARROWER, code) ? NARROWER[code] : undefined;
   const endLine = Math.max(line, symbol.endLine);

package/src/kinds.ts

@@ -1,53 +1,87 @@
+import type { Confidence, Severity } from "./config.ts";
+
+/** What a mechanical edit may do with a finding of one kind. */
+export type Fixability = "deletable" | "narrowable" | "manual" | "none";
+
+/** One live row of the issue-kind vocabulary, as far as an analyzer reads it. */
+export interface KindRow {
+  readonly code: string;
+  /** The kind's name, which a finding carries as its `kind`. */
+  readonly name: string;
+  /** The severity a finding carries where no severity key names its code or its family. */
+  readonly defaultSeverity: Severity;
+  /** The highest confidence a finding of the kind carries. */
+  readonly maxClass: Confidence;
+  readonly fixability: Fixability;
+  /**
+   * Whether the Contract fixes the kind on at its default severity, so a severity key
+   * naming the code, or a family prefix whose range holds it, is an unimplemented key.
+   */
+  readonly fixed: boolean;
+}
+
 /**
- * The issue-kind codes whose severity the Contract fixes. A severity key naming
- * one, or a family prefix whose range holds one, is an unimplemented key rather
- * than a setting.
- *
- * The codes are written out rather than read from the Contract at run time: the
- * Contract is data a reader outside this program consults, and a product that
- * read it while running would need it installed beside itself. A test compares
- * this list against the Contract release the analyzer is written against, so a
- * code the Contract fixes arrives here as a failing test.
+ * Every live row of the issue-kind vocabulary, in ascending code order, written out
+ * rather than read at run time, because a product that read the Contract while running
+ * would need it installed beside itself. A test compares this table against the
+ * Contract release the analyzer is written against.
  */
-export const FIXED_SEVERITY_CODES: readonly string[] = ["DS1703", "DS1704"];
+const ROWS: readonly KindRow[] = [
+  row("DS1001", "unused-exported", "deny", "deletable"),
+  row("DS1002", "unused-unexported", "deny", "deletable"),
+  row("DS1003", "unused-member", "deny", "deletable"),
+  row("DS1004", "test-only-use", "deny", "deletable"),
+  row("DS1005", "test-of-dead-code", "deny", "deletable"),
+  row("DS1006", "deprecated-unused", "deny", "deletable"),
+  row("DS1101", "unnecessary-export", "warn", "narrowable"),
+  row("DS1102", "unnecessary-exposure", "warn", "narrowable"),
+  row("DS1103", "unreachable-export", "deny", "deletable"),
+  row("DS1104", "redundant-export-keyword", "warn", "narrowable"),
+  row("DS1201", "unused-interface", "deny", "deletable"),
+  row("DS1203", "uncalled-interface-method", "warn", "manual"),
+  row("DS1204", "unused-satisfaction-assertion", "deny", "deletable"),
+  row("DS1301", "write-only-symbol", "deny", "deletable"),
+  row("DS1302", "unused-enum-member", "deny", "deletable"),
+  row("DS1303", "unused-type-parameter", "deny", "deletable"),
+  row("DS1501", "file-never-built", "deny", "deletable"),
+  row("DS1502", "file-never-imported", "deny", "deletable"),
+  row("DS1601", "unused-dependency", "deny", "manual"),
+  row("DS1605", "unused-module-directive", "warn", "deletable"),
+  row("DS1701", "suppression-without-reason", "deny", "none"),
+  row("DS1702", "unscoped-ignore-entry", "deny", "none"),
+  { ...row("DS1703", "stale-suppression", "deny", "none"), fixed: true },
+  { ...row("DS1704", "unmatched-root", "deny", "none"), fixed: true },
+  row("DS1705", "stale-cross-language-edge", "deny", "none"),
+  row("DS1801", "unused-parameter", "warn", "manual"),
+  row("DS1802", "unused-receiver", "warn", "deletable"),
+  row("DS1803", "unused-result", "warn", "manual"),
+  row("DS1805", "unreachable-statement", "deny", "deletable"),
+  row("DS1807", "dead-store", "deny", "deletable"),
+  row("DS1809", "unreachable-case", "deny", "deletable"),
+];
+
+/** A row at the `certain` ceiling whose severity a configuration may set. */
+function row(
+  code: string,
+  name: string,
+  defaultSeverity: Severity,
+  fixability: Fixability,
+): KindRow {
+  return { code, name, defaultSeverity, maxClass: "certain", fixability, fixed: false };
+}
+
+/** Every live row of the issue-kind vocabulary, by its code, in ascending code order. */
+export const KINDS: ReadonlyMap<string, KindRow> = new Map(ROWS.map((one) => [one.code, one]));
 
 /**
  * The code of every live issue kind, in ascending order. A severity key names one of
  * them or a family prefix whose range holds one; a key naming a retired code, an
  * unassigned code or a range holding no live kind is an unimplemented key, so every
- * severity a configuration sets is one some analyzer reports under. A test compares
- * this list against the Contract release the analyzer is written against.
+ * severity a configuration sets is one some analyzer reports under.
  */
-export const LIVE_CODES: readonly string[] = [
-  "DS1001",
-  "DS1002",
-  "DS1003",
-  "DS1004",
-  "DS1005",
-  "DS1006",
-  "DS1101",
-  "DS1102",
-  "DS1103",
-  "DS1104",
-  "DS1201",
-  "DS1203",
-  "DS1204",
-  "DS1301",
-  "DS1302",
-  "DS1303",
-  "DS1501",
-  "DS1502",
-  "DS1601",
-  "DS1605",
-  "DS1701",
-  "DS1702",
-  "DS1703",
-  "DS1704",
-  "DS1705",
-  "DS1801",
-  "DS1802",
-  "DS1803",
-  "DS1805",
-  "DS1807",
-  "DS1809",
-];
+export const LIVE_CODES: readonly string[] = ROWS.map((one) => one.code);
+
+/** The issue-kind codes whose severity the Contract fixes, in ascending order. */
+export const FIXED_SEVERITY_CODES: readonly string[] = ROWS.filter((one) => one.fixed).map(
+  (one) => one.code,
+);