@cplieger/deadset-ts 7.0.0-dev.1 → 7.0.0-dev.3

package/src/findings/completion.ts

@@ -9,6 +9,7 @@ import { componentId, type Component } from "../components.ts";
 import type { Cascade, Confidence, Severity } from "../config.ts";
 import type { CompletedFinding, Finding, FindingComponent, PositionedSymbol } from "../finding.ts";
 import { OUTSIDE, type Graph } from "../graph.ts";
+import type { SymbolKind } from "../inventory.ts";
 import { KINDS, type KindRow } from "../kinds.ts";
 import { byPosition, positionKey } from "../position.ts";
 import { declarationKey } from "../ref.ts";
@@ -17,6 +18,17 @@ import { isPartSubject, isRowSubject, type Dials } from "../suppress.ts";
 import type { Boundary } from "./boundary.ts";
 import type { EmitterInput } from "./emitter.ts";
 
+/** The fixability grammar/analysis.md "Fixability" gives a finding about a held declaration. */
+const MANUAL = "manual";
+
+/** The member kinds an object property can declare, which an `in` expression tests by name. */
+const IN_TESTED: ReadonlySet<SymbolKind> = new Set([
+  "class-member",
+  "method",
+  "type-member",
+  "interface-method",
+]);
+
 /** The classes ranked by the claim each makes, the strongest highest. */
 const RANK: Readonly<Record<Confidence, number>> = { certain: 3, probable: 2, possible: 1 };
 
@@ -54,19 +66,43 @@ function publishedIds(union: Graph): ReadonlySet<string> {
   );
 }
 
+/**
+ * The members whose name an `in` expression of a production file tests by a literal: a
+ * value narrowed that way is read back by the name, which no type links to the member.
+ */
+function testedByIn(input: EmitterInput): ReadonlySet<string> {
+  const names = input.files.inOperands ?? new Set<string>();
+  const union = input.swept.matrix.union;
+  if (names.size === 0) {
+    return names;
+  }
+  return new Set(
+    union.symbols.flatMap((symbol, at) => {
+      const parent = union.symbols[union.parent[at] ?? OUTSIDE];
+      return IN_TESTED.has(symbol.kind) &&
+        parent !== undefined &&
+        symbol.name.startsWith(`${parent.name}.`) &&
+        names.has(symbol.name.slice(parent.name.length + 1))
+        ? [symbol.id]
+        : [];
+    }),
+  );
+}
+
 /**
  * The reachability class of one declaration of the run. A declaration of a library's
  * published API, a public member of a published type included, is `certain` where the
  * run loaded every consumer the scope declared and declared one, `probable` where one did
  * not load, and `possible` where it declared none, whatever the configuration says of the
- * consumer set. A declaration of test-support code that test code references, outside the
- * test-of-dead-code rule, is `possible`. Every other declaration is `certain`.
+ * consumer set. Test-support code test code references, outside the test-of-dead-code
+ * rule, what it contains, and a member an `in` expression tests by name are `possible`.
  */
 function reachabilityClasses(input: EmitterInput): (id: string) => Confidence {
+  const tested = testedByIn(input);
   const published = publishedIds(input.swept.matrix.union);
   const usedByTests = new Set(
     input.swept.sweep.candidates
-      .filter((candidate) => candidate.heldByTests === candidate.id)
+      .filter((candidate) => candidate.heldByTests !== undefined)
       .map((candidate) => candidate.id),
   );
   const { declared } = input.boundary.consumers;
@@ -77,13 +113,42 @@ function reachabilityClasses(input: EmitterInput): (id: string) => Confidence {
         ? "certain"
         : "probable";
   return (id) => {
-    if (usedByTests.has(id)) {
+    if (usedByTests.has(id) || tested.has(id)) {
       return "possible";
     }
     return published.has(id) ? outside : "certain";
   };
 }
 
+/**
+ * The confidence ceiling of a test of dead code: the lowest reachability class among the
+ * target symbols it references, because its deadness is theirs, whether or not they share
+ * its component. Every other declaration has none below `certain`.
+ */
+function testCeilings(
+  input: EmitterInput,
+  classOf: (id: string) => Confidence,
+): (id: string) => Confidence {
+  const union = input.swept.matrix.union;
+  const tests = new Set(
+    input.swept.sweep.candidates.filter((one) => one.testOfDeadCode).map((one) => one.id),
+  );
+  return (id) => {
+    let lowest: Confidence = "certain";
+    if (!tests.has(id)) {
+      return lowest;
+    }
+    for (const edge of union.out[union.at(id)] ?? []) {
+      const target = union.symbols[edge.to];
+      const testCode = union.test[edge.to] === true || union.support[edge.to] === true;
+      if (target !== undefined && !testCode && union.subject[edge.to] === true) {
+        lowest = capped(lowest, classOf(target.id));
+      }
+    }
+    return lowest;
+  };
+}
+
 /**
  * The component each dead declaration of the run falls in, and none for a live one, with
  * its members listed in the canonical order where the run lists a component in full.
@@ -154,7 +219,11 @@ export function completed(
   );
   const candidates = new Map(swept.sweep.candidates.map((candidate) => [candidate.id, candidate]));
   const classOf = reachabilityClasses(input);
+  const ceilingOf = testCeilings(input, classOf);
   const componentOf = findingComponents(swept, input.config.reporters.cascade);
+  const held = new Set(
+    swept.sweep.components.filter((one) => one.held).flatMap((one) => one.members),
+  );
   let minted = swept.sweep.components.length;
   const dead = new Set(swept.sweep.components.map((component) => component.id));
   const fallingWith = new Map<string, number>();
@@ -212,6 +281,18 @@ export function completed(
     const reachabilityClass =
       judged === undefined ? (finding.reachabilityClass ?? "certain") : classOf(judged.id);
     const generated = input.files.generated?.has(finding.position.path) === true;
+    const fixability = generated
+      ? "none"
+      : found !== undefined &&
+          symbol !== undefined &&
+          held.has(symbol.id) &&
+          row.findingFixabilities?.includes(MANUAL) === true
+        ? MANUAL
+        : row.fixability;
+    const lastUses =
+      fixability === "deletable" && candidate !== undefined
+        ? input.dependencies.lastUses.get(candidate.id)
+        : undefined;
     return {
       code: finding.code,
       kind: row.name,
@@ -219,7 +300,10 @@ export function completed(
       position: finding.position,
       symbol: finding.symbol,
       reachabilityClass,
-      confidence: capped(reachabilityClass, row.maxClass),
+      confidence: capped(
+        capped(reachabilityClass, row.maxClass),
+        judged === undefined ? "certain" : ceilingOf(judged.id),
+      ),
       ...(candidate === undefined ? {} : { livenessRelation: candidate.relation }),
       testOnly: judged !== undefined && counts?.production === 0 && counts.test > 0,
       generated,
@@ -231,10 +315,13 @@ export function completed(
           ? swept.matrix.configurations
           : (swept.matrix.heldIn[at] ?? swept.matrix.configurations)),
       consumersLoaded: input.boundary.consumers.loaded,
-      fixability: generated ? "none" : row.fixability,
+      fixability,
       severity: severityOf(input, finding.code, row.defaultSeverity),
       message: finding.message,
-      details: finding.details ?? {},
+      details:
+        lastUses === undefined
+          ? (finding.details ?? {})
+          : { ...finding.details, removesLastUseOf: lastUses },
     };
   });
   return componentCapped(done, dead);
@@ -278,33 +365,22 @@ function dialed(
  * below the minimum confidence is withheld, and so is every finding of the component of a
  * root the dials withhold, because a symbol that falls with a root is dead only through it
  * and its deletion does not compile while the root stays. A withheld finding that is no
- * root withholds itself alone. A code is withheld from a declaration when the finding it
- * would report there, completed, is withheld by its own severity or confidence.
+ * root withholds itself alone.
  */
 export function dialsOf(
   input: EmitterInput,
   findings: readonly CompletedFinding[],
 ): Dials<CompletedFinding> {
   const minConfidence = input.config.analysis.minConfidence;
-  const classOf = reachabilityClasses(input);
   const components = new Set(
     findings
       .filter((finding) => finding.component.root && dialed(finding, minConfidence))
       .map((finding) => finding.component.id),
   );
   return {
-    withholdsCode: (code, id) => {
+    allows: (code) => {
       const row = KINDS.get(code);
-      return (
-        row !== undefined &&
-        dialed(
-          {
-            severity: severityOf(input, code, row.defaultSeverity),
-            confidence: capped(classOf(id), row.maxClass),
-          },
-          minConfidence,
-        )
-      );
+      return row !== undefined && severityOf(input, code, row.defaultSeverity) === "allow";
     },
     withholds: (finding) => dialed(finding, minConfidence) || components.has(finding.component.id),
   };

package/src/findings/dependencies-and-module-machinery.ts

@@ -19,7 +19,7 @@ function unusedDependencies(dependencies: Dependencies): Finding[] {
   return dependencies.declared
     .filter(
       (dependency) =>
-        !dependencies.needed.has(dependency.name) &&
+        !dependencies.needed.has(declarationKey(dependency)) &&
         !dependencies.ran.has(declarationKey(dependency)),
     )
     .map((dependency) => ({

package/src/findings/emitters.ts

@@ -67,7 +67,7 @@ function markupKeys(input: EmitterInput): ReadonlySet<string> {
 }
 
 /** What the suppressions of a run swept under their marks are decided against. */
-export interface Suppressed {
+interface Suppressed {
   /** The same run swept with no mark, which is where a kind about liveness reports a marked declaration. */
   readonly unmarked: EmitterInput;
   /** The run's suppression records, in reading order. */
@@ -75,13 +75,13 @@ export interface Suppressed {
 }
 
 /** What the emitter table answers about one run. */
-export interface DecidedFindings {
+interface DecidedFindings {
   /** Every finding the run reports, each family'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>[];
   /** What every suppression record did, in reading order. */
-  readonly ledger: Ledger<CompletedFinding>;
+  readonly ledger: Ledger;
   /** Every finding a record could name: the run's with no mark, then the run's as swept. */
   readonly would: readonly CompletedFinding[];
   /** The findings the minimum confidence withheld, by confidence. */
@@ -116,7 +116,7 @@ function dialsOver(
   const before = dialsOf(suppressed.unmarked, unmarked);
   const fromUnmarked = new Set(unmarked);
   return {
-    withholdsCode: marked.withholdsCode,
+    allows: marked.allows,
     withholds: (finding) =>
       fromUnmarked.has(finding) ? before.withholds(finding) : marked.withholds(finding),
   };
@@ -198,8 +198,3 @@ function withheldOf(input: EmitterInput, candidates: readonly CompletedFinding[]
   }
   return counts;
 }
-
-/** Every finding the run reports, each family's in table order. */
-export function findingsOf(input: EmitterInput): readonly CompletedFinding[] {
-  return decidedFindings(input).findings;
-}

package/src/findings/self-check.ts

@@ -1,8 +1,11 @@
 import { REPOSITORY_DOCUMENT } from "../config.ts";
 import type { Finding, FindingDetails, SuppressionEntry } from "../finding.ts";
 import type { InventorySymbol } from "../inventory.ts";
+import { FIXED_SEVERITY_CODES } from "../kinds.ts";
 import type { Position } from "../position.ts";
 import {
+  isDependencyCode,
+  isUnsuppressibleCode,
   STALE_SUPPRESSION,
   SUPPRESSION_WITHOUT_REASON,
   type Mechanism,
@@ -58,14 +61,6 @@ interface UnmatchedDeclaration {
   readonly document: string;
 }
 
-/** A run with nothing for the self-check family to report. */
-export const NO_SELF_CHECK: SelfCheckFacts = {
-  refusals: [],
-  unmatchedRoots: [],
-  rootsDocument: "",
-  unmatchedDeclarations: [],
-};
-
 /** The words a message names a mechanism by. */
 const WRITTEN: Readonly<Record<Mechanism, string>> = {
   inline: "inline directive",
@@ -122,7 +117,7 @@ function writtenEntry(refused: Refusal): SuppressionEntry {
 }
 
 /** Each file of the run by its path, as the reference of the file it is. */
-export type FileRefs = (path: string) => string | undefined;
+type FileRefs = (path: string) => string | undefined;
 
 /**
  * The reference a finding about a suppression names: the symbol it names or bound, else
@@ -133,10 +128,7 @@ function suppressionRef(symbol: string, path: string, files: FileRefs): string {
 }
 
 /** One finding per refused suppression: the grammar's reason refusal and its scope refusal. */
-export function refusedSuppressions(
-  refusals: readonly Refusal[],
-  files: FileRefs,
-): readonly Finding[] {
+function refusedSuppressions(refusals: readonly Refusal[], files: FileRefs): readonly Finding[] {
   return refusals.map((refused) =>
     aboutSuppression(
       refused.reported,
@@ -190,7 +182,32 @@ export function staleSuppressions(
     const reports = [...new Set(records.flatMap((one) => one.reports))]
       .filter((code) => !codes.includes(code))
       .sort();
-    const instead = reports.length === 0 ? "" : `, and its declaration reports ${spelled(reports)}`;
+    const rows = codes.filter(isUnsuppressibleCode);
+    const dependencies = first.mechanism === "inline" ? codes.filter(isDependencyCode) : [];
+    const settable = rows.filter((code) => !FIXED_SEVERITY_CODES.includes(code));
+    const remedy =
+      settable.length === 0
+        ? "fix what the finding names instead"
+        : `fix what the finding names or set the severity of ${spelled(settable)} instead`;
+    const declared = reports.length === 0 ? "" : `its declaration reports ${spelled(reports)}`;
+    const because = [
+      ...(rows.length > 0
+        ? [
+            `${spelled(rows)} ${rows.length === 1 ? "reports a row" : "report rows"} of a document, which no suppression can name; ${remedy}`,
+          ]
+        : []),
+      ...(dependencies.length > 0
+        ? [
+            `${spelled(dependencies)} ${dependencies.length === 1 ? "reports a dependency row" : "report dependency rows"}, which only an ignore entry or a baseline row can name`,
+          ]
+        : []),
+    ];
+    const instead =
+      because.length > 0
+        ? `, because ${because.join("; ")}${declared === "" ? "" : `; ${declared}`}`
+        : declared === ""
+          ? ""
+          : `, and ${declared}`;
     return {
       code: STALE_SUPPRESSION,
       mechanism: first.mechanism,

package/src/findings-pass.ts

@@ -15,12 +15,18 @@ import {
   type StaleRecord,
   type StaleSuppression,
 } from "./findings/self-check.ts";
-import { isRowSubject, pairs, suppressionCounts, type Ledger } from "./suppress.ts";
+import {
+  isDependencySubject,
+  isRowSubject,
+  pairs,
+  suppressionCounts,
+  type Ledger,
+} from "./suppress.ts";
 import type { Provenance, Recorded } from "./suppress-file.ts";
 import { EXIT_CLEAN, EXIT_FINDINGS } from "./verbs/verb.ts";
 
 /** The counts a report's totals carry beside its findings. */
-export interface PassTotals {
+interface PassTotals {
   readonly suppressionsInEffect: number;
   readonly reasonsRecorded: number;
   readonly staleSuppressions: number;
@@ -40,7 +46,7 @@ export interface PassResult {
   readonly edgeEvaluations: readonly EdgeEvaluation<CompletedFinding>[];
   readonly totals: PassTotals;
   /** What every suppression record did, in reading order. */
-  readonly ledger: Ledger<CompletedFinding>;
+  readonly ledger: Ledger;
 }
 
 /** The exit code of a report holding at least one pending finding. */
@@ -134,14 +140,15 @@ export interface RecordableFinding {
 
 /**
  * The rows one round of a baseline write records from its findings, in their order. A
- * finding about a row of a document is not recorded: no record withholds one, so a row
- * recording it would be stale on the first read back. Two findings that would record the
- * same row, two parts of one declaration under one code, record it once.
+ * finding about a row of a document other than a dependency row is not recorded: no record
+ * withholds one, so a row recording it would be stale on the first read back. Two findings
+ * that would record the same row, two parts of one declaration under one code, record it
+ * once.
  */
 export function recordedFindings(findings: readonly RecordableFinding[]): readonly Recorded[] {
   const rows = new Map<string, Recorded>();
   for (const finding of findings) {
-    if (isRowSubject(finding.symbol.kind)) {
+    if (isRowSubject(finding.symbol.kind) && !isDependencySubject(finding.symbol.kind)) {
       continue;
     }
     const row = { code: finding.code, symbol: finding.symbol.ref, path: finding.position.path };

package/src/graph.ts

@@ -87,13 +87,13 @@ export interface Edge {
 }
 
 /** How many references one declaration carries, split by the classification of the file that made each. */
-export interface Counts {
+interface Counts {
   readonly production: number;
   readonly test: number;
 }
 
 /** One root the inventory holds, at the position of the declaration it names. */
-export interface Rooted {
+interface Rooted {
   readonly at: number;
   readonly kind: RootKind;
 }

package/src/html-entries.ts

@@ -16,7 +16,7 @@ import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.ts";
 import type { SourceFiles } from "./source-files.ts";
 
 /** One file a script loads, and the value or specifier that named it. */
-export interface HTMLEntry {
+interface HTMLEntry {
   readonly file: SourceFile;
   readonly source: string;
 }

package/src/in-operands.ts

@@ -0,0 +1,45 @@
+/**
+ * The property names `in` tests in a project's production files. A value narrowed by
+ * `"name" in value` is read back by that name, often through `unknown`, where no type
+ * links the read to a declaration, so only a text match can tell which member it reads.
+ */
+
+import {
+  isBinaryExpression,
+  isNoSubstitutionTemplateLiteral,
+  isStringLiteral,
+  SyntaxKind,
+  type Node,
+} from "@typescript/native/unstable/ast";
+import type { ProjectView } from "./session.ts";
+import { sourceFilesOf } from "./source-files.ts";
+
+/**
+ * The text of each string literal, or template literal with no substitution, written as
+ * the left operand of an `in` expression in a file of the project that is no test file.
+ * `testFiles` holds the test files by their path below the target root.
+ */
+export function inOperandNames<Brand>(
+  project: ProjectView<Brand>,
+  targetRoot: string,
+  testFiles: readonly string[],
+): readonly string[] {
+  const tests = new Set(testFiles);
+  const found = new Set<string>();
+  const visit = (node: Node): void => {
+    if (
+      isBinaryExpression(node) &&
+      node.operatorToken.kind === SyntaxKind.InKeyword &&
+      (isStringLiteral(node.left) || isNoSubstitutionTemplateLiteral(node.left))
+    ) {
+      found.add(node.left.text);
+    }
+    node.forEachChild(visit);
+  };
+  for (const [path, file] of sourceFilesOf(project, targetRoot).byPath) {
+    if (!tests.has(path)) {
+      file.forEachChild(visit);
+    }
+  }
+  return [...found].sort();
+}