@cplieger/deadset-ts 7.0.0-dev.2 → 7.0.0-dev.4

package/src/suppress-file.ts

@@ -59,6 +59,13 @@ const BASELINE_SHAPE: Shape = {
   recordWant: "a row naming code, symbol, path and reason, each a string",
 };
 
+/**
+ * The reference scheme of this analyzer's language. A record of the other scheme is
+ * form-checked and then left to the analyzer of its language: it binds nothing here, counts
+ * in neither total and is reported under no code.
+ */
+const OWN_SCHEME = "ts://";
+
 /** The closed key list of one entry or row. */
 const RECORD_KEYS: ReadonlySet<string> = new Set(["code", "symbol", "path", "reason"]);
 
@@ -126,6 +133,9 @@ function readRecord(value: unknown, site: Position, byReference: ByReference, sh
   if (path !== undefined && path !== "" && !isEntryPath(path)) {
     return refuse(JSON.stringify(path), PATH_WANT);
   }
+  if (!symbol.startsWith(OWN_SCHEME)) {
+    return { records: [], refusals: [] };
+  }
 
   const written = {
     code,
@@ -284,15 +294,68 @@ export function rowReason(provenance: Provenance): string {
   return `recorded by ${provenance.analyzer} ${provenance.version}`;
 }
 
+/** A row of the other language's scheme a write keeps: the members the document held, and no other. */
+interface KeptRow {
+  readonly code: string;
+  readonly symbol: string;
+  readonly path?: string;
+  readonly reason?: string;
+}
+
+/**
+ * The rows of the other language's scheme that the baseline document `text` holds, in
+ * document order and as written, which a write keeps. A document that is not a baseline,
+ * or a row in a shape no record takes, is refused rather than dropped.
+ */
+export function otherSchemeRows(text: string): readonly KeptRow[] {
+  const refuse = (detail: string): never => {
+    throw new Error(
+      `${BASELINE_FILE} cannot be rewritten keeping the other language's rows: ${detail}`,
+    );
+  };
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error: unknown) {
+    return refuse(error instanceof Error ? error.message : String(error));
+  }
+  const held = isObject(parsed) ? parsed[BASELINE_SHAPE.array] : undefined;
+  if (!Array.isArray(held)) {
+    return refuse(BASELINE_SHAPE.documentWant);
+  }
+  return (held as readonly unknown[]).flatMap((value): KeptRow[] => {
+    try {
+      readRecord(value, documentSite(BASELINE_SHAPE), new Map(), BASELINE_SHAPE);
+    } catch (error: unknown) {
+      return refuse(error instanceof Error ? error.message : String(error));
+    }
+    // readRecord has checked every member is a string and the code and symbol are present.
+    const { code, symbol, path, reason } = value as Readonly<Record<string, string>>;
+    if (code === undefined || symbol === undefined || symbol.startsWith(OWN_SCHEME)) {
+      return [];
+    }
+    return [
+      {
+        code,
+        symbol,
+        ...(path === undefined ? {} : { path }),
+        ...(reason === undefined ? {} : { reason }),
+      },
+    ];
+  });
+}
+
 /**
- * A baseline holding one row per finding, in the order given, which is the report's. Every
- * row carries the provenance as its reason. A finding missing a value a row needs, and an
- * identity missing its name or version, are refused rather than written, because the
- * grammar requires a reason on every row.
+ * A baseline holding one row per finding, in the order given, which is the report's, after
+ * the other language's rows `kept`, so two analyzers writing one document in either order
+ * write the same bytes. Every recorded row carries the provenance as its reason. A finding
+ * missing a value a row needs, and an identity missing its name or version, are refused
+ * rather than written, because the grammar requires a reason on every row.
  */
 export function writeBaseline(
   findings: readonly Recorded[],
   provenance: Provenance,
+  kept: readonly KeptRow[] = [],
 ): Iterable<string> {
   if (provenance.analyzer === "" || provenance.version === "") {
     throw new Error(
@@ -308,5 +371,5 @@ export function writeBaseline(
     }
     return { code: found.code, symbol: found.symbol, path: found.path, reason };
   });
-  return jsonChunks({ description: BASELINE_DESCRIPTION, baseline }, 2);
+  return jsonChunks({ description: BASELINE_DESCRIPTION, baseline: [...kept, ...baseline] }, 2);
 }

package/src/suppress-inline.ts

@@ -1,10 +1,10 @@
 /**
  * The inline directive: `deadset:ignore`, the first token of a `//` line comment, naming
  * one or more codes and a reason, and binding to every declaration that begins on the line
- * below it.
+ * below it, or on its own line where it trails a token there.
  */
 
-import { SyntaxKind, type Node, type SourceFile } from "@typescript/native/unstable/ast";
+import { SyntaxKind, type Node, type SourceFile } from "@typescript/native/ast";
 import { nodeKey, type Inventory } from "./inventory.ts";
 import { byPosition, positionKey, renderPosition, type Position } from "./position.ts";
 import type { ProjectView } from "./session.ts";
@@ -211,6 +211,15 @@ function declarationLines(
   return below;
 }
 
+/**
+ * Whether the comment at `offset` follows a token on its own line, so it binds the
+ * declarations that begin on that line rather than on the next.
+ */
+function trails(file: SourceFile, offset: number): boolean {
+  const { line } = file.getLineAndCharacterOfPosition(offset);
+  return tokenStart(file.text, file.getPositionOfLineAndCharacter(line, 0)) < offset;
+}
+
 /** One comment in the namespace, what the grammar made of it, and what it bound. */
 export interface InlineDirective {
   readonly site: Position;
@@ -242,11 +251,12 @@ export function inlineDirectives<Brand>(
     const below = declarationLines(file, held, symbols);
     for (const comment of comments) {
       const site = renderPosition(file, targetRoot, comment.offset);
+      const target = trails(file, comment.offset) ? site.line : site.line + 1;
       found.push({
         site,
         text: comment.text,
         directive: classifyComment(comment.text),
-        bound: [...(below.get(site.line + 1) ?? [])],
+        bound: [...(below.get(target) ?? [])],
       });
     }
   }
@@ -254,8 +264,8 @@ export function inlineDirectives<Brand>(
 }
 
 /**
- * The inline directives of a run's projects, each bound to the declarations that begin on
- * the line below it, one directive binding the union of what each project holding its file
+ * The inline directives of a run's projects, each bound to the declarations the placement
+ * rule gives it, one directive binding the union of what each project holding its file
  * declares there. A directive that lacks only its reason is one {@link Refusal} per code;
  * any other malformed comment in the namespace ends the read with a
  * {@link SuppressionError} naming the first one written.

package/src/suppress.ts

@@ -2,8 +2,9 @@
  * The suppression grammar's records, and the ledger that decides what each one did. A
  * record is one code bound to one site with its reason, from an inline directive, an
  * ignore entry or a baseline row. A bound record marks its declaration live before the
- * sweep, and is in effect when it withholds the finding its code would have produced
- * there, dormant when the configuration withholds that finding anyway, and stale otherwise.
+ * 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.
  */
 
 import { ConfigError } from "./config.ts";
@@ -141,8 +142,8 @@ export type Verdict = "in-effect" | "dormant" | "stale";
  * them withholds is dormant.
  */
 export interface Dials<F extends Finding = Finding> {
-  /** Whether the configuration withholds every finding of one code from one declaration. */
-  readonly withholdsCode: (code: string, bound: string) => boolean;
+  /** Whether the configuration sets the severity of one code to `allow`. */
+  readonly allows: (code: string) => boolean;
   /** Whether it withholds one finding: by its severity, its confidence, or its component's root. */
   readonly withholds: (finding: F) => boolean;
 }
@@ -155,31 +156,55 @@ 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 kinds that are a row of a document rather than a declaration of the program,
- * each with the codes that report one. A record binds to a declaration, so nothing
- * withholds a finding about one.
+ * 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", ["DS1601"]],
-  ["module-directive", ["DS1605"]],
+  ...DEPENDENCY_SUBJECTS,
   ["root", ["DS1704"]],
   ["configured-declaration", ["DS1706"]],
   ["suppression", ["DS1701", "DS1702", "DS1703"]],
   ["edge", ["DS1705"]],
 ]);
 
-/** Whether a finding's subject is a row of a document, which no record can withhold. */
+/** 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 code reports a row of a document, so no record naming it can match. */
+/** 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 dependency row. */
+export function isDependencySubject(kind: string): boolean {
+  return DEPENDENCY_SUBJECTS.has(kind);
+}
+
+/** 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 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);
+}
+
 /**
  * The subject kinds that are a part of a declaration rather than a declaration: a part
  * has no reference of its own, so a finding about one names the declaration that holds
@@ -219,10 +244,21 @@ function claimKey(finding: Finding): string {
  * Whether one record names one finding. A record reaches a finding in two ways: it bound
  * the declaration at the finding's position, or it names the finding's reference and the
  * file the finding is reported in, each exactly. The second is how an entry copied from a
- * finding about a part of a declaration reaches the part.
+ * finding about a part of a declaration reaches the part, and the only way any record
+ * reaches a dependency row.
  */
 export function pairs(record: SuppressionRecord, finding: Finding): boolean {
-  if (record.code !== finding.code || ROW_SUBJECTS.has(finding.symbol.kind)) {
+  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)) {
     return false;
   }
   if (record.bound !== "" && record.bound === positionKey(finding.position)) {
@@ -233,11 +269,11 @@ export function pairs(record: SuppressionRecord, finding: Finding): boolean {
 
 /**
  * Decides every record against `would`, the findings the run would produce were no record
- * there: swept with no mark, where a kind about liveness reports the marked declaration,
- * and as swept, where a kind whose subject the sweep holds live reports it. The first
- * record in reading order claims a finding, so a second naming it is stale. A record whose
- * code the dials withhold from its declaration, or whose claimed finding they withhold, is
- * dormant.
+ * 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`.
  */
 export function ledgerOf<F extends Finding>(
   records: readonly SuppressionRecord[],
@@ -247,23 +283,22 @@ export function ledgerOf<F extends Finding>(
   const taken = new Set<string>();
   const verdicts: Verdict[] = [];
   for (const record of records) {
-    if (record.bound !== "" && dials.withholdsCode(record.code, record.bound)) {
-      verdicts.push("dormant");
+    const open = (finding: F): boolean => !taken.has(claimKey(finding)) && pairs(record, finding);
+    const first = would.find(open);
+    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");
       continue;
     }
-    const claimed = would.find(
-      (finding) => !taken.has(claimKey(finding)) && pairs(record, finding),
-    );
-    if (claimed === undefined) {
-      verdicts.push("stale");
-      continue;
+    for (const finding of claimed) {
+      taken.add(claimKey(finding));
     }
-    taken.add(claimKey(claimed));
-    verdicts.push(dials.withholds(claimed) ? "dormant" : "in-effect");
+    verdicts.push(claimed.every((finding) => dials.withholds(finding)) ? "dormant" : "in-effect");
   }
   return {
     verdicts,
-    withheld: (finding) => taken.has(claimKey(finding)) && !ROW_SUBJECTS.has(finding.symbol.kind),
+    withheld: (finding) => taken.has(claimKey(finding)),
   };
 }
 

package/src/symbol-keys.ts

@@ -15,8 +15,8 @@ import {
   isStringLiteral,
   type ElementAccessExpression,
   type Node,
-} from "@typescript/native/unstable/ast";
-import type { Symbol as TSSymbol, Type } from "@typescript/native/unstable/sync";
+} from "@typescript/native/ast";
+import type { Symbol as TSSymbol, Type } from "@typescript/native/sync";
 import type { AliasChains } from "./alias-chain.ts";
 import type { InventorySymbol } from "./inventory.ts";
 import { isAnswered, type PropertyTables } from "./query.ts";

package/src/type-errors.ts

@@ -14,8 +14,8 @@ import {
   type Node,
   type PropertyAccessExpression,
   type SourceFile,
-} from "@typescript/native/unstable/ast";
-import type { Symbol as TSSymbol, Type } from "@typescript/native/unstable/sync";
+} from "@typescript/native/ast";
+import type { Symbol as TSSymbol, Type } from "@typescript/native/sync";
 import { packageOfSpecifier } from "./dependencies.ts";
 import type { LocatedDiagnostic } from "./discover.ts";
 import type { Host } from "./host.ts";

package/src/type-query-alias.ts

@@ -17,7 +17,7 @@ import {
   SyntaxKind,
   type Node,
   type SourceFile,
-} from "@typescript/native/unstable/ast";
+} from "@typescript/native/ast";
 
 /** One global that aliases a module's export. */
 interface TypeQueryAlias {