@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.20

package/src/findings/emitters.ts

@@ -1,7 +1,6 @@
-import type { Confidence } from "../config.ts";
+import type { Confidence } from "../contract/contract.generated.ts";
 import { evaluateEdges, type EdgeEvaluation } from "../edges.ts";
 import type { CompletedFinding } from "../finding.ts";
-import { liveFilesAt } from "../matrix.ts";
 import { declarationKey } from "../ref.ts";
 import { ledgerOf, type Dials, type Ledger, type SuppressionRecord } from "../suppress.ts";
 import { insideSkipped } from "../type-errors.ts";
@@ -11,12 +10,12 @@ import type { Emitter, EmitterInput, Emitters } from "./emitter.ts";
 import { interfaces } from "./interfaces.ts";
 import { intraFunction } from "./intra-function.ts";
 import { nonCodeArtifacts } from "./non-code-artifacts.ts";
-import { readsAndWrites } from "./reads-and-writes.ts";
+import { fallingWithWrites, readsAndWrites } from "./reads-and-writes.ts";
 import { selfCheck } from "./self-check.ts";
 import { fallenMembers, unusedDeclarations } from "./unused-declarations.ts";
 import { visibilityNarrowing } from "./visibility-narrowing.ts";
 
-/** Every kind family this analyzer reports, each by its emitter, in code order. */
+/** Every emitter this analyzer runs, by the name its tests select it by. */
 export const EMITTERS: Emitters = new Map<string, Emitter>([
   ["unused-declarations", unusedDeclarations],
   ["visibility-narrowing", visibilityNarrowing],
@@ -28,42 +27,19 @@ export const EMITTERS: Emitters = new Map<string, Emitter>([
   ["intra-function", intraFunction],
 ]);
 
-/**
- * The keys of every declaration an unanswered question could have kept live, which the run
- * reports nothing about: a finding about one would be computed from the gap.
- */
-function heldKeys(input: EmitterInput): ReadonlySet<string> {
-  const held = new Set(input.swept.heldByUnanswered);
-  if (held.size === 0) {
-    return held;
-  }
+/** The keys of the declarations the identifiers name, as {@link findingKey} keys a finding. */
+function keysOf(input: EmitterInput, ids: Iterable<string>): ReadonlySet<string> {
+  const named = new Set(ids);
   return new Set(
     input.swept.matrix.union.symbols
-      .filter((symbol) => held.has(symbol.id))
+      .filter((symbol) => named.has(symbol.id))
       .map((symbol) => declarationKey(symbol.ref, symbol.position.path)),
   );
 }
 
-/**
- * The keys of every top-level declaration of a live component file. The file's
- * markup may use each of them, which no analysis of the markup can rule out, so the run
- * reports nothing about one while the file is live.
- */
-function markupKeys(input: EmitterInput): ReadonlySet<string> {
-  const { swept } = input;
-  if (swept.componentFiles.length === 0) {
-    return new Set();
-  }
-  const live = new Set(
-    liveFilesAt(swept.matrix, swept.sweep, new Set(swept.componentFiles)).map(
-      (symbol) => symbol.id,
-    ),
-  );
-  return new Set(
-    swept.matrix.union.symbols
-      .filter((symbol) => live.has(symbol.parent))
-      .map((symbol) => declarationKey(symbol.ref, symbol.position.path)),
-  );
+/** The key of the declaration a finding is about, or of the one holding the part it is about. */
+function findingKey(finding: CompletedFinding): string {
+  return declarationKey(finding.symbol.holder ?? finding.symbol.ref, finding.position.path);
 }
 
 /** What the suppressions of a run swept under their marks are decided against. */
@@ -76,7 +52,7 @@ interface Suppressed {
 
 /** What the emitter table answers about one run. */
 interface DecidedFindings {
-  /** Every finding the run reports, each family's in table order. */
+  /** Every finding the run reports, each emitter's in table order. */
   readonly findings: readonly CompletedFinding[];
   /** One evaluation per declared edge side of this language, ordered by edge, then by side. */
   readonly evaluations: readonly EdgeEvaluation<CompletedFinding>[];
@@ -91,15 +67,20 @@ interface DecidedFindings {
 /** How many findings the minimum confidence withheld at each confidence. */
 export type Withheld = Readonly<Record<Confidence, number>>;
 
-/** Every family's findings over one sweep, and those of any further emitter, completed by one step. */
+/**
+ * Every emitter's findings over one sweep, and those of any further emitter, completed by
+ * one step, but none about a declaration that falls with a write-only subject: that
+ * subject's finding names it, so no finding about it exists for a record to match.
+ */
 function completedOver(
   input: EmitterInput,
   ...more: readonly Emitter[]
 ): readonly CompletedFinding[] {
+  const falls = keysOf(input, fallingWithWrites(input));
   return completed(
     input,
     [...EMITTERS.values(), ...more].flatMap((emit) => emit(input)),
-  );
+  ).filter((finding) => !falls.has(findingKey(finding)));
 }
 
 /**
@@ -124,8 +105,8 @@ function dialsOver(
 
 /**
  * Every finding of one run swept under its suppressions' marks, decided in one pass: each
- * family's findings completed by one step, so every component number is minted once, the
- * finding each record claims withheld, the rest withheld by the dials, so a root one family
+ * emitter's findings completed by one step, so every component number is minted once, the
+ * finding each record claims withheld, the rest withheld by the dials, so a root one emitter
  * reports withholds what another reports in its component, and every declared edge
  * evaluated over what remains, so a pending finding is in its evaluation alone.
  */
@@ -145,7 +126,7 @@ function atPossible(input: EmitterInput): EmitterInput {
   const { config } = input;
   return {
     ...input,
-    config: { ...config, analysis: { ...config.analysis, minConfidence: "possible" } },
+    config: { ...config, analysis: { ...config.analysis, min_confidence: "possible" } },
   };
 }
 
@@ -161,18 +142,23 @@ function dialledOver(
   unmarked: readonly CompletedFinding[],
 ): Omit<DecidedFindings, "would"> {
   const would = [...unmarked, ...found];
-  const ledger = ledgerOf(suppressed.records, would, dialsOver(input, found, suppressed, unmarked));
-  const unanswered = heldKeys(input);
-  const markup = markupKeys(input);
-  const candidates = found.filter((finding) => {
-    const key = declarationKey(finding.symbol.holder ?? finding.symbol.ref, finding.position.path);
-    return (
-      !ledger.withheld(finding) &&
-      !unanswered.has(key) &&
-      !markup.has(key) &&
-      !insideSkipped(input.swept.skipped, finding.position)
-    );
-  });
+  const { sweep } = input.swept;
+  // A hold is a gap of the analysis, which leaves a record it touches dormant; a live
+  // component file's markup is no gap, so a record on one of its bindings stays in effect.
+  const unanswered = keysOf(input, sweep.held);
+  const markup = keysOf(input, sweep.bindings);
+  const heldIds = new Set(sweep.held);
+  const held = (finding: CompletedFinding): boolean =>
+    unanswered.has(findingKey(finding)) || insideSkipped(input.swept.skipped, finding.position);
+  const ledger = ledgerOf(
+    suppressed.records,
+    would,
+    dialsOver(input, found, suppressed, unmarked),
+    { withholds: held, holdsRecord: (record) => heldIds.has(record.bound) },
+  );
+  const candidates = found.filter(
+    (finding) => !ledger.withheld(finding) && !held(finding) && !markup.has(findingKey(finding)),
+  );
   const kept = reportable(input, candidates);
   const evaluated = evaluateEdges(kept, input.boundary.edges, input.swept.matrix.union.symbols);
   return {

package/src/{implementations.ts → findings/implementations.ts}

@@ -15,10 +15,10 @@ import {
   type Node,
 } from "@typescript/native/ast";
 import { SymbolFlags, type Symbol as TSSymbol, type Type } from "@typescript/native/sync";
-import { aliasChains } from "./alias-chain.ts";
-import { nodeKey, type Inventory } from "./inventory.ts";
-import { must, Unanswerable } from "./query.ts";
-import type { ProjectView } from "./session.ts";
+import { aliasChains } from "../alias-chain.ts";
+import { nodeKey, type Inventory } from "../inventory.ts";
+import { must, Unanswerable } from "../query.ts";
+import type { ProjectView } from "../session.ts";
 
 /** What one run knows about how its interfaces are implemented. */
 export interface Implementations {

package/src/{in-operands.ts → findings/in-operands.ts}

@@ -11,8 +11,9 @@ import {
   SyntaxKind,
   type Node,
 } from "@typescript/native/ast";
-import type { ProjectView } from "./session.ts";
-import { sourceFilesOf } from "./source-files.ts";
+import type { ProjectView } from "../session.ts";
+import { sourceFilesOf } from "../source-files.ts";
+import { bytewise } from "../text/compare.ts";
 
 /**
  * The text of each string literal, or template literal with no substitution, written as
@@ -41,5 +42,5 @@ export function inOperandNames<Brand>(
       file.forEachChild(visit);
     }
   }
-  return [...found].sort();
+  return [...found].sort(bytewise);
 }

package/src/findings/interfaces.ts

@@ -1,12 +1,10 @@
+import { CODE } from "../contract/contract.generated.ts";
 import type { Finding, FindingPosition, PositionedSymbol } from "../finding.ts";
 import type { InventorySymbol } from "../inventory.ts";
 import { byPosition } from "../position.ts";
-import type { MatrixCandidate } from "../matrix.ts";
+import type { Candidate } from "../liveness/sweep.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
 
-const UNUSED_INTERFACE = "DS1201";
-const UNCALLED_INTERFACE_METHOD = "DS1203";
-
 /** What each finding says, by what the sweep found about the subject's references. */
 const UNUSED_MESSAGE = "nothing in the target names the interface as a type";
 const UNUSED_DEAD_MESSAGE =
@@ -23,7 +21,7 @@ function positionOf(symbol: InventorySymbol): FindingPosition {
 function indexed(input: EmitterInput): {
   readonly symbolOf: (id: string) => InventorySymbol | undefined;
   readonly inTest: (id: string) => boolean;
-  readonly candidateOf: (id: string) => MatrixCandidate | undefined;
+  readonly candidateOf: (id: string) => Candidate | undefined;
   readonly implementationsOf: (id: string) => readonly PositionedSymbol[];
 } {
   const union = input.swept.matrix.union;
@@ -69,7 +67,7 @@ function findingOf(
 
 /**
  * The findings of the interfaces family, `DS1200` to `DS1299`: `DS1201`, a dead
- * interface, whose members fall with it unreported; and `DS1203`, a method of a live
+ * interface, whose members fall with it unreported; and `DS1202`, a method of a live
  * interface no reference names, unless it is a marker, a method whose every
  * implementation has an empty body. A test file's declaration is neither kind's subject,
  * because a production sweep counts none of the references it can have, save an interface
@@ -86,7 +84,7 @@ export const interfaces: Emitter = (input) => {
     if (symbol.kind === "interface") {
       found.push(
         findingOf(
-          UNUSED_INTERFACE,
+          CODE.unusedInterface,
           symbol,
           unusedMessage(candidate),
           run.implementationsOf(candidate.id),
@@ -104,7 +102,7 @@ export const interfaces: Emitter = (input) => {
     }
     found.push(
       findingOf(
-        UNCALLED_INTERFACE_METHOD,
+        CODE.uncalledInterfaceMethod,
         symbol,
         UNCALLED_MESSAGE,
         run.implementationsOf(symbol.parent),
@@ -115,7 +113,7 @@ export const interfaces: Emitter = (input) => {
 };
 
 /** What one unused interface's finding says, by the references the sweep counted. */
-function unusedMessage(candidate: MatrixCandidate): string {
+function unusedMessage(candidate: Candidate): string {
   if (candidate.relation === "reachability") {
     return UNUSED_DEAD_MESSAGE;
   }

package/src/findings/intra-function.ts

@@ -1,9 +1,9 @@
-import type { Confidence } from "../config.ts";
+import { CODE, type Confidence } from "../contract/contract.generated.ts";
 import type { Finding } from "../finding.ts";
 import { KINDS } from "../kinds.ts";
 import { parameterRef } from "../ref.ts";
-import { UNUSED_PARAMETER, UNUSED_RESULT, type PartFact } from "../intra-function-parts.ts";
-import { reachedWithTheTests } from "../sweep.ts";
+import { type PartFact } from "../intra-function-parts.ts";
+import { reachedWithTheTests } from "../liveness/sweep.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
 
 /** A list of rules as a sentence names them. */
@@ -42,7 +42,8 @@ type ParameterVerdict =
  * caller may pass a function used as a value more arguments than it declares, so there one
  * a read parameter follows is renamed to an underscore name, which the compilers read as
  * declared unread, and one no read parameter follows is deleted: kept where the call's
- * inference may read its annotation, at `probable` where nothing reads the annotation.
+ * inference may read its annotation, at `probable` where nothing reads the annotation or
+ * where it is a name a contextually typed object pattern binds.
  */
 function parameterVerdict(
   part: PartFact,
@@ -63,7 +64,8 @@ function parameterVerdict(
   if (place?.annotated === "steers") {
     return undefined;
   }
-  return { fix: "delete", confidence: place?.annotated === "free" ? "probable" : "certain" };
+  const unseen = place?.annotated === "free" || place?.contextualPattern === true;
+  return { fix: "delete", confidence: unseen ? "probable" : "certain" };
 }
 
 /**
@@ -83,9 +85,9 @@ function reported(
   }
   const { free, freeButValued, discardedEverywhere } = input.intraFunction;
   switch (part.code) {
-    case UNUSED_PARAMETER:
+    case CODE.unusedParameter:
       return parameterVerdict(part, free, freeButValued) !== undefined;
-    case UNUSED_RESULT:
+    case CODE.unusedResult:
       return (
         free.has(part.declaration) &&
         discardedEverywhere.has(part.declaration) &&
@@ -97,7 +99,7 @@ function reported(
 }
 
 /**
- * The findings of the intra-function family, `DS1800` to `DS1899`, each about a part of
+ * The findings of the inside-functions family, `DS1401` to `DS1406`, each about a part of
  * the declaration its reference names, at the part's own position, whatever the sweep
  * decided about a production declaration. A part of test code is reported only where the
  * run that counts test references reaches its declaration and that is no test of dead
@@ -107,8 +109,8 @@ export const intraFunction: Emitter = (input) => {
   const union = input.swept.matrix.union;
   const byId = new Map(union.symbols.map((symbol) => [symbol.id, symbol]));
   const reached = reachedWithTheTests(union, [
-    ...input.swept.exempt.map((record) => record.id),
-    ...input.swept.heldByUnanswered,
+    ...input.swept.sweep.exempt.map((record) => record.id),
+    ...input.swept.sweep.held,
   ]);
   const testsOfDeadCode = new Set(
     input.swept.sweep.candidates.filter((one) => one.testOfDeadCode).map((one) => one.id),
@@ -125,7 +127,7 @@ export const intraFunction: Emitter = (input) => {
     }),
   );
   const { declared, loaded } = input.boundary.consumers;
-  const closed = input.config.consumersComplete && declared.every((id) => loaded.includes(id));
+  const closed = input.config.consumers.complete && declared.every((id) => loaded.includes(id));
   const published = (id: string): boolean => {
     const symbol = byId.get(id);
     return (
@@ -144,12 +146,12 @@ export const intraFunction: Emitter = (input) => {
   const found: Finding[] = [];
   for (const part of input.intraFunction.parts) {
     const declaration = byId.get(part.declaration);
-    const overlap = KINDS.get(part.code)?.overlap ?? [];
+    const overlap = KINDS.get(part.code)?.overlap?.ts ?? [];
     if (declaration === undefined || !judged(declaration.id) || !reported(input, part, unknown)) {
       continue;
     }
     const verdict =
-      part.code === UNUSED_PARAMETER
+      part.code === CODE.unusedParameter
         ? parameterVerdict(part, input.intraFunction.free, input.intraFunction.freeButValued)
         : undefined;
     const message =
@@ -160,7 +162,7 @@ export const intraFunction: Emitter = (input) => {
       code: part.code,
       position: part.position,
       symbol: {
-        ...(part.code === UNUSED_PARAMETER
+        ...(part.code === CODE.unusedParameter
           ? { ref: parameterRef(declaration.ref, part.name), holder: declaration.ref }
           : { ref: declaration.ref }),
         kind: part.kind,

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

@@ -1,10 +1,8 @@
-import type { Config } from "../config.ts";
+import { CODE } from "../contract/contract.generated.ts";
+import type { ResolvedConfig } from "../config.ts";
 import type { Finding } from "../finding.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
 
-const FILE_NEVER_BUILT = "DS1501";
-const FILE_NEVER_IMPORTED = "DS1502";
-
 /** The subject kind of a finding about a source file, from the finding schema's vocabulary. */
 const FILE_SUBJECT = "file";
 
@@ -17,10 +15,10 @@ const FILE_START = 1;
  * completeness and listing no project declares it of a matrix the run derived, and a
  * derived matrix is never complete.
  */
-function completeMatrix(config: Config): boolean {
+function completeMatrix(config: ResolvedConfig): boolean {
   return (
-    config.analysis.matrixComplete &&
-    config.analysis.configurations.some((entry) => entry.shape === "project")
+    config.analysis.matrix.complete &&
+    config.analysis.configurations.some((entry) => "project" in entry)
   );
 }
 
@@ -57,7 +55,7 @@ function fileNeverBuilt({ config, swept, files }: EmitterInput): readonly Findin
   const message = `no project of the build matrix includes this file (${swept.matrix.configurations.join(", ")})`;
   return files.tree
     .filter((file) => !built.has(file.path))
-    .map((file) => fileFinding(FILE_NEVER_BUILT, file, message));
+    .map((file) => fileFinding(CODE.fileNeverBuilt, file, message));
 }
 
 /** The files of the run, each with whether a reference written in another file reaches it. */
@@ -152,22 +150,33 @@ function fileNeverImported(input: EmitterInput): readonly Finding[] {
       return referenced.has(symbol.position.path)
         ? {
             ...fileFinding(
-              FILE_NEVER_IMPORTED,
+              CODE.fileNeverImported,
               file,
               "only code that is itself dead imports this file, and no root names it or a declaration in it",
             ),
             unreachableOnly: true as const,
           }
         : fileFinding(
-            FILE_NEVER_IMPORTED,
+            CODE.fileNeverImported,
             file,
             "no import reaches this file and no root names it or a declaration in it",
           );
     });
 }
 
-/** The findings of the non-code-artifacts family, `DS1500` to `DS1599`. */
-export const nonCodeArtifacts: Emitter = (input) => [
-  ...fileNeverBuilt(input),
-  ...fileNeverImported(input),
-];
+/**
+ * The findings of the files family, `DS1600` to `DS1699`, each at the class `possible` in a
+ * package a command of which may run a file whose path no word of it writes, since that
+ * command may run the file (confidence.35).
+ */
+export const nonCodeArtifacts: Emitter = (input) => {
+  const unwritten = [...(input.files.unwrittenRuns ?? [])];
+  return [...fileNeverBuilt(input), ...fileNeverImported(input)].map((finding) =>
+    unwritten.some(
+      (dir) =>
+        dir === "." || finding.position.path === dir || finding.position.path.startsWith(`${dir}/`),
+    )
+      ? { ...finding, reachabilityClass: "possible" as const }
+      : finding,
+  );
+};