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

package/src/suppress-inline.ts

@@ -4,21 +4,24 @@
  * below it, or on its own line where it trails a token there.
  */
 
-import {
-  isConstructorDeclaration,
-  SyntaxKind,
-  type Node,
-  type SourceFile,
-} from "@typescript/native/ast";
+import { CODE } from "./contract/contract.generated.ts";
+import { SyntaxKind, type Node, type SourceFile } from "@typescript/native/ast";
 import { importBindings } from "./import-bindings.ts";
-import { isParameterProperty, nodeKey, type Inventory } from "./inventory.ts";
-import { byPosition, positionKey, renderPosition, type Position } from "./position.ts";
+import { nodeKey, type Inventory } from "./inventory.ts";
+import { relativePath } from "./paths.ts";
+import {
+  byPosition,
+  lineEnd,
+  positionKey,
+  renderPosition,
+  startLine,
+  tokenStart,
+  type Position,
+} from "./position.ts";
 import { importRef } from "./ref.ts";
 import type { ProjectView } from "./session.ts";
-import { signatureOf } from "./signatures.ts";
 import {
   isPartKind,
-  SUPPRESSION_WITHOUT_REASON,
   SuppressionError,
   siteText,
   type Refusal,
@@ -88,43 +91,6 @@ const LITERALS: ReadonlySet<SyntaxKind> = new Set([
   SyntaxKind.JsxText,
 ]);
 
-/** Whether one character ends a line, under the language's line terminators. */
-function endsLine(char: string | undefined): boolean {
-  return char === "\n" || char === "\r" || char === "\u2028" || char === "\u2029";
-}
-
-/** The offset where the line holding `from` ends. */
-function lineEnd(text: string, from: number): number {
-  let at = from;
-  while (at < text.length && !endsLine(text[at])) {
-    at += 1;
-  }
-  return at;
-}
-
-/**
- * The offset of the first token at or after `from`: whitespace, comments and a leading
- * hashbang are trivia.
- */
-export function tokenStart(text: string, from: number): number {
-  let at = from;
-  if (at === 0 && text.startsWith("#!")) {
-    at = lineEnd(text, 0);
-  }
-  for (;;) {
-    if (/\s/u.test(text[at] ?? "")) {
-      at += 1;
-    } else if (text.startsWith("//", at)) {
-      at = lineEnd(text, at);
-    } else if (text.startsWith("/*", at)) {
-      const close = text.indexOf("*/", at + 2);
-      at = close < 0 ? text.length : close + 2;
-    } else {
-      return at;
-    }
-  }
-}
-
 /**
  * Every `//` line comment of one file, in file order. The text between tokens is read as
  * the language reads it: a block comment holds no line comment, and the literal tokens the
@@ -191,63 +157,59 @@ function bindingKey(one: Binding): string {
   return `${one.declared?.id ?? ""}\u0000${one.part.id}`;
 }
 
+/** One declaration the inventory places, the declaration that holds its parts, and its lines. */
+interface Placed {
+  readonly one: Declared;
+  readonly holder: Declared;
+  readonly startLines: readonly number[];
+  readonly partLines: readonly number[];
+}
+
+/** The placed declarations of a project by the path of the file each is in. */
+function placedByPath(
+  held: Inventory,
+  symbols: ReadonlyMap<string, Declared>,
+): ReadonlyMap<string, readonly Placed[]> {
+  const byPath = new Map<string, Placed[]>();
+  for (const [id, placed] of held.placement) {
+    const one = symbols.get(id);
+    const holder = symbols.get(placed.holder);
+    if (one === undefined || holder === undefined) {
+      continue;
+    }
+    const at = byPath.get(one.position.path) ?? [];
+    at.push({ one, holder, startLines: placed.startLines, partLines: placed.partLines });
+    byPath.set(one.position.path, at);
+  }
+  return byPath;
+}
+
 /**
- * The declarations of one file by the line each begins on, the line of its first token: a
- * decorator, a modifier or the keyword. A variable's first token is its statement's
- * keyword, and a variable written on a later line of the statement also begins there. A
- * function also begins, for a directive, on the line of each of its parameters, and a
- * class, for a part kind, on the lines of its constructor and its constructor's parameters.
+ * The declarations of one file by the line a directive binds each on, as the inventory
+ * places them, and each import binding of the file on its statement's lines.
  */
 function declarationLines(
   file: SourceFile,
+  placed: readonly Placed[],
   held: Inventory,
-  symbols: ReadonlyMap<string, Declared>,
   targetRoot: string,
 ): ReadonlyMap<number, readonly Binding[]> {
   const below = new Map<number, Binding[]>();
-  const add = (offset: number, one: Binding): void => {
-    const line = file.getLineAndCharacterOfPosition(tokenStart(file.text, offset)).line + 1;
+  const add = (line: number, one: Binding): void => {
     const at = below.get(line) ?? [];
     if (!at.some((known) => bindingKey(known) === bindingKey(one))) {
       at.push(one);
     }
     below.set(line, at);
   };
-  const declaredAt = (node: Node): Declared | undefined => {
-    const id = held.declarations.get(nodeKey(file, node));
-    return id === undefined ? undefined : symbols.get(id);
-  };
-  const visit = (node: Node): void => {
-    const one = declaredAt(node);
-    const owner = isConstructorDeclaration(node) ? declaredAt(node.parent) : undefined;
-    if (owner !== undefined && isConstructorDeclaration(node)) {
-      for (const at of [node, ...node.parameters.filter((one) => !isParameterProperty(one))]) {
-        add(at.pos, { declared: undefined, part: owner });
-      }
+  for (const { one, holder, startLines, partLines } of placed) {
+    for (const line of startLines) {
+      add(line, { declared: one, part: holder });
     }
-    const holder =
-      one !== undefined && isParameterProperty(node) ? declaredAt(node.parent.parent) : one;
-    if (one !== undefined && holder !== undefined) {
-      add(node.pos, { declared: one, part: holder });
-    }
-    if (one !== undefined) {
-      // A parameter on a later line of a wrapped signature takes its directive on the
-      // line above it, inside the parameter list, and the directive binds the function.
-      for (const parameter of signatureOf(node)?.parameters ?? []) {
-        add(parameter.pos, { declared: one, part: one });
-      }
-      const list = node.parent;
-      if (
-        node.kind === SyntaxKind.VariableDeclaration &&
-        list.kind === SyntaxKind.VariableDeclarationList &&
-        list.parent.kind === SyntaxKind.VariableStatement
-      ) {
-        add(list.parent.pos, { declared: one, part: one });
-      }
+    for (const line of partLines) {
+      add(line, { declared: undefined, part: one });
     }
-    node.forEachChild(visit);
-  };
-  file.forEachChild(visit);
+  }
   // An import binding is a subject of its own, bound on its line as a declaration is.
   const fileId = held.declarations.get(nodeKey(file, file));
   const moduleRef = held.symbols.find((symbol) => symbol.id === fileId)?.ref ?? "";
@@ -259,7 +221,7 @@ function declarationLines(
       statement = statement.parent;
     }
     for (const at of [statement.pos, name.getStart()]) {
-      add(at, { declared: one, part: one });
+      add(startLine(file, at), { declared: one, part: one });
     }
   }
   return below;
@@ -296,13 +258,15 @@ export function inlineDirectives<Brand>(
       .filter((symbol) => symbol.kind !== "file")
       .map((symbol) => [symbol.id, { id: symbol.id, ref: symbol.ref, position: symbol.position }]),
   );
+  const placed = placedByPath(held, symbols);
   const found: InlineDirective[] = [];
   for (const file of project.ownSourceFiles()) {
     const comments = lineComments(file).filter((comment) => CANDIDATE.test(comment.text));
     if (comments.length === 0) {
       continue;
     }
-    const below = declarationLines(file, held, symbols, targetRoot);
+    const path = relativePath(targetRoot, file.fileName) ?? "";
+    const below = declarationLines(file, placed.get(path) ?? [], held, targetRoot);
     for (const comment of comments) {
       const site = renderPosition(file, targetRoot, comment.offset);
       const target = trails(file, comment.offset) ? site.line : site.line + 1;
@@ -354,7 +318,7 @@ export function inlineSuppressions(
       case "no-reason":
         for (const code of directive.codes) {
           refusals.push({
-            reported: SUPPRESSION_WITHOUT_REASON,
+            reported: CODE.suppressionWithoutReason,
             code,
             symbol: "",
             path: site.path,

package/src/suppress.ts

@@ -4,10 +4,17 @@
  * ignore entry or a baseline row. A bound record marks its declaration live before the
  * sweep, unless its code reports a part or a dependency row, and is in effect when it
  * withholds a finding its code would have produced there, dormant when the configuration
- * withholds every such finding anyway, and stale otherwise.
+ * or a hold withholds every such finding anyway, and stale otherwise.
  */
 
-import { ConfigError } from "./config.ts";
+import {
+  type CODE,
+  KIND_ROWS,
+  REMEDIES,
+  SYMBOL_SUBJECTS,
+  type Subject,
+} from "./contract/contract.generated.ts";
+import { UsageError } from "./usage.ts";
 import type { Finding } from "./finding.ts";
 import { positionKey, type Position } from "./position.ts";
 import { isRef } from "./ref.ts";
@@ -15,15 +22,6 @@ import { isRef } from "./ref.ts";
 /** Which document a suppression is written in, spelled as a finding carries it. */
 export type Mechanism = "inline" | "ignore" | "baseline";
 
-/** The code a suppression that carries no reason is reported under. */
-export const SUPPRESSION_WITHOUT_REASON = "DS1701";
-
-/** The code an ignore entry or a baseline row that names no path is reported under. */
-export const UNSCOPED_ENTRY = "DS1702";
-
-/** The code a suppression that withholds nothing is reported under. */
-export const STALE_SUPPRESSION = "DS1703";
-
 /**
  * One suppression record: one code bound to one site. A directive naming two codes is two
  * records with one reason, and a directive above a line that declares two symbols is one
@@ -49,7 +47,7 @@ export interface SuppressionRecord {
  * nothing, and its finding reports the suppression as written.
  */
 export interface Refusal {
-  readonly reported: typeof SUPPRESSION_WITHOUT_REASON | typeof UNSCOPED_ENTRY;
+  readonly reported: typeof CODE.suppressionWithoutReason | typeof CODE.unscopedIgnoreEntry;
   readonly code: string;
   /** The reference the entry names, empty for a directive. */
   readonly symbol: string;
@@ -71,9 +69,9 @@ export interface Suppressions {
  * instruction the analysis cannot carry out. It is a malformed input, so the command line
  * answers it with the usage code.
  */
-export class SuppressionError extends ConfigError {
+export class SuppressionError extends UsageError {
   constructor(mechanism: Mechanism, at: string, text: string, want: string) {
-    super("malformed", at, `${mechanism} ${at}: ${text}: want ${want}`);
+    super(`${mechanism} ${at}: ${text}: want ${want}`);
     this.name = "SuppressionError";
   }
 }
@@ -150,6 +148,20 @@ export interface Dials<F extends Finding = Finding> {
   readonly withholds: (finding: F) => boolean;
 }
 
+/**
+ * What the analysis holds because it cannot decide it, as the ledger reads it: a hold is a
+ * gap, not evidence that the code changed, so a record it touches is dormant.
+ */
+export interface Holds<F extends Finding = Finding> {
+  /** Whether a hold withholds one finding: a type error's skip, or a hold of its declaration. */
+  readonly withholds: (finding: F) => boolean;
+  /** Whether a hold keeps the declaration one record is bound to live, so no finding about it is computed. */
+  readonly holdsRecord: (record: SuppressionRecord) => boolean;
+}
+
+/** No hold. */
+const NO_HOLDS: Holds = { withholds: () => false, holdsRecord: () => false };
+
 /** What every record did, and the findings the records withhold. */
 export interface Ledger {
   /** One verdict per record, in reading order. */
@@ -158,83 +170,64 @@ export interface Ledger {
   readonly withheld: (finding: Finding) => boolean;
 }
 
-/**
- * The subject kinds that are a dependency row, each with the code that reports one. An
- * ignore entry or a baseline row naming the row's reference and file withholds its finding
- * and marks nothing, and an inline directive never binds one.
- */
-const DEPENDENCY_SUBJECTS: ReadonlyMap<string, readonly string[]> = new Map([
-  ["dependency", ["DS1601"]],
-  ["module-directive", ["DS1605"]],
-]);
+/** The subject of the kind each live code names. */
+const SUBJECT_OF_CODE: ReadonlyMap<string, Subject> = new Map(
+  KIND_ROWS.map((row): [string, Subject] => [row.code, row.subject]),
+);
 
-/**
- * The subject kinds that are a row of a document rather than a declaration of the program,
- * each with the codes that report one. Apart from a dependency row, nothing withholds a
- * finding about one.
- */
-const ROW_SUBJECTS: ReadonlyMap<string, readonly string[]> = new Map([
-  ["file", ["DS1501", "DS1502"]],
-  ...DEPENDENCY_SUBJECTS,
-  ["root", ["DS1704"]],
-  ["configured-declaration", ["DS1706"]],
-  ["suppression", ["DS1701", "DS1702", "DS1703"]],
-  ["edge", ["DS1705"]],
-]);
+/** The subject a finding about one symbol kind is about. */
+function subjectOf(kind: string): Subject | undefined {
+  return Object.hasOwn(SYMBOL_SUBJECTS, kind)
+    ? SYMBOL_SUBJECTS[kind as keyof typeof SYMBOL_SUBJECTS]
+    : undefined;
+}
 
-/** Whether a finding's subject is a row of a document rather than a declaration. */
-export function isRowSubject(kind: string): boolean {
-  return ROW_SUBJECTS.has(kind);
+/** Whether a subject is a row of a document rather than a declaration of the program. */
+function rowOf(subject: Subject | undefined): boolean {
+  return subject === "file" || subject === "dependency" || subject === "record";
 }
 
-/** Whether a code reports a row of a document. */
-export function isRowCode(code: string): boolean {
-  return [...ROW_SUBJECTS.values()].some((codes) => codes.includes(code));
+/** Whether a finding's subject is a row of a document rather than a declaration. */
+export function isRowSubject(kind: string): boolean {
+  return rowOf(subjectOf(kind));
 }
 
-/** Whether a finding's subject is a dependency row. */
-export function isDependencySubject(kind: string): boolean {
-  return DEPENDENCY_SUBJECTS.has(kind);
+/** The subject a code reports, which kinds.json's remedies table answers for. */
+export function subjectOfCode(code: string): Subject | undefined {
+  return SUBJECT_OF_CODE.get(code);
 }
 
-/** Whether a code reports a dependency row, which only an ignore entry or a baseline row names. */
-export function isDependencyCode(code: string): boolean {
-  return [...DEPENDENCY_SUBJECTS.values()].some((codes) => codes.includes(code));
+/**
+ * Whether a record of `mechanism` can name a finding about `subject`, as kinds.json's
+ * remedies table lists the suppressions of each subject. A subject the table does not
+ * know is a declaration's.
+ */
+export function names(subject: Subject | undefined, mechanism: Mechanism): boolean {
+  return (REMEDIES[subject ?? "declaration"].suppressions as readonly Mechanism[]).includes(
+    mechanism,
+  );
 }
 
-/** Whether a code reports a row of a document that no record of any mechanism can name. */
-export function isUnsuppressibleCode(code: string): boolean {
-  return isRowCode(code) && !isDependencyCode(code);
+/** Whether a finding about a symbol of `kind` is one a record of `mechanism` can name. */
+export function namesKind(kind: string, mechanism: Mechanism): boolean {
+  return names(subjectOf(kind), mechanism);
 }
 
 /**
- * The subject kinds that are a part of a declaration rather than a declaration: a part
+ * Whether a finding's subject is a part of the declaration its reference names: a part
  * has no reference of its own, so a finding about one names the declaration that holds
  * it, and the part is decided inside that declaration whatever uses it.
  */
-const PART_SUBJECTS: ReadonlySet<string> = new Set([
-  "parameter",
-  "receiver",
-  "result",
-  "statement",
-  "case",
-  "store",
-]);
-
-/** Whether a finding's subject is a part of the declaration its reference names. */
 export function isPartSubject(kind: string): boolean {
-  return PART_SUBJECTS.has(kind);
+  return subjectOf(kind) === "part";
 }
 
-/** The prefix of the codes of the part kinds, the intra-function range. */
-const PART_KIND_PREFIX = "DS18";
-
 /**
  * Whether a code is a part kind, whose record withholds its finding and marks nothing:
  * the record says the part is wanted, not that the declaration holding it is.
  */
 export function isPartKind(code: string): boolean {
-  return code.startsWith(PART_KIND_PREFIX);
+  return SUBJECT_OF_CODE.get(code) === "part";
 }
 
 /** One finding's identity: its code and the position of the thing it names. */
@@ -254,16 +247,13 @@ export function pairs(record: SuppressionRecord, finding: Finding): boolean {
   if (record.code !== finding.code) {
     return false;
   }
-  if (DEPENDENCY_SUBJECTS.has(finding.symbol.kind)) {
-    return (
-      record.mechanism !== "inline" &&
-      record.symbol === finding.symbol.ref &&
-      record.path === finding.position.path
-    );
-  }
-  if (ROW_SUBJECTS.has(finding.symbol.kind)) {
+  const subject = subjectOf(finding.symbol.kind);
+  if (!names(subject, record.mechanism)) {
     return false;
   }
+  if (subject === "dependency") {
+    return record.symbol === finding.symbol.ref && record.path === finding.position.path;
+  }
   if (record.bound !== "" && record.bound === positionKey(finding.position)) {
     return true;
   }
@@ -278,13 +268,14 @@ export function pairs(record: SuppressionRecord, finding: Finding): boolean {
  * there: swept with no mark for a liveness kind, and as swept otherwise. The first record
  * in reading order claims a finding, so a second naming it is stale; a part-kind record
  * claims every finding of its code about a part of its declaration. A record is dormant
- * when the dials withhold every finding it claims, read from those findings alone, or when
- * it claims none and its code's severity is `allow`.
+ * when the dials or `holds` withhold every finding it claims, or when it claims none and
+ * its code is at `allow` or a hold keeps its declaration live.
  */
 export function ledgerOf<F extends Finding>(
   records: readonly SuppressionRecord[],
   would: readonly F[],
   dials: Dials<F>,
+  holds: Holds<F> = NO_HOLDS,
 ): Ledger {
   const taken = new Set<string>();
   const verdicts: Verdict[] = [];
@@ -294,13 +285,21 @@ export function ledgerOf<F extends Finding>(
     const claimed =
       first === undefined ? [] : isPartKind(record.code) ? would.filter(open) : [first];
     if (claimed.length === 0) {
-      verdicts.push(record.bound !== "" && dials.allows(record.code) ? "dormant" : "stale");
+      verdicts.push(
+        record.bound !== "" && (dials.allows(record.code) || holds.holdsRecord(record))
+          ? "dormant"
+          : "stale",
+      );
       continue;
     }
     for (const finding of claimed) {
       taken.add(claimKey(finding));
     }
-    verdicts.push(claimed.every((finding) => dials.withholds(finding)) ? "dormant" : "in-effect");
+    verdicts.push(
+      claimed.every((finding) => dials.withholds(finding) || holds.withholds(finding))
+        ? "dormant"
+        : "in-effect",
+    );
   }
   return {
     verdicts,