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

package/src/exempt.ts

@@ -7,24 +7,53 @@
  * hands it the table of the classes it has.
  */
 
-import type { Config, TSSection } from "./config.ts";
-import { ConfigError } from "./config.ts";
+import { EXEMPTION_CLASSES } from "./contract/contract.generated.ts";
+import type { GeneratedFact } from "./generated-file.ts";
+import type { ResolvedConfig } from "./config.ts";
 import {
-  EXEMPTION_CLASSES,
-  isExemptionClass,
   TS_EXEMPTION_CLASSES,
   typescriptVisibilityOf,
   type ExemptionClass,
   type TSExemptionClass,
   type TypeScriptVisibility,
 } from "./exempt-classes.ts";
-import type { Inventory, InventorySymbol, SymbolKind, Visibility } from "./inventory.ts";
-import type { Matrix } from "./matrix.ts";
+import type { Inventory, InventorySymbol, Visibility } from "./inventory.ts";
 import { byPosition, positionKey, type Position } from "./position.ts";
 import { Unanswerable } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 import type { Templates } from "./template-field.ts";
-import { sweep, type Exemption, type Implementing, type Mode, type SweepInput } from "./sweep.ts";
+import type { Mode } from "./tests/file-class.ts";
+import { bytewise } from "./text/compare.ts";
+
+/** One declaration an exemption class holds back, and the evidence it was found by. */
+export interface Exemption {
+  /** The identifier of the declaration held back. */
+  readonly id: string;
+  readonly class: TSExemptionClass;
+  /** One clause naming the relation, then the thing it relates to: `passed to JSON.stringify`. */
+  readonly detail: string;
+  /** Where the evidence is written. */
+  readonly site: Position;
+  /**
+   * The component file, below the target root, whose markup holds the evidence. The
+   * record holds only while that file is live.
+   */
+  readonly whileLive?: string;
+  /**
+   * The interface methods the retained member implements, and whether its body is empty.
+   * The record holds only while one of them is called through its interface.
+   */
+  readonly implementing?: Implementing;
+  /** Whether the record holds only where a write the mode counts stores into the declaration. */
+  readonly whileWritten?: true;
+}
+
+/** The interface methods one retained class member implements, and whether its body is empty. */
+interface Implementing {
+  /** The declarations of the interface's methods the member answers, by identifier. */
+  readonly methods: readonly string[];
+  readonly empty: boolean;
+}
 
 /** One declaration a detector holds back, and where and why. */
 export interface Evidence {
@@ -37,6 +66,8 @@ export interface Evidence {
   readonly whileLive?: string;
   /** Where the evidence is an implementation of interface methods, which and how. */
   readonly implementing?: Implementing;
+  /** Whether the evidence holds only where a write the mode counts stores into the declaration. */
+  readonly whileWritten?: true;
 }
 
 /** What a detector reads of one project, while the project's view is open. */
@@ -47,11 +78,11 @@ export interface DetectorInput<Brand> {
   /** The configured templates, read once for the run. */
   readonly templates: Templates;
   /** The `ts` section, whose declarations the configured classes read. */
-  readonly ts: TSSection;
+  readonly ts: ResolvedConfig["ts"];
   /** The absolute path of each declared consumer, whose modules are part of the analysis. */
   readonly consumers: readonly string[];
-  /** The project's generated files, by path below the target root, each with the detail its retentions name. */
-  readonly generated?: ReadonlyMap<string, string>;
+  /** The project's generated files, by path below the target root, each with what decided it. */
+  readonly generated?: ReadonlyMap<string, GeneratedFact>;
 }
 
 /**
@@ -71,24 +102,11 @@ interface Holding {
 }
 
 /**
- * The classes `exemptions.disabled` switches off. A name is refused unless the
- * vocabulary holds it; a class that runs on another language only is admitted and
- * switches nothing off here, so one configuration serves every analyzer.
+ * The classes `exemptions.disabled` switches off. A class that runs on another language
+ * only switches nothing off here, so one configuration serves every analyzer.
  */
-export function disabledClasses(config: Config): ReadonlySet<ExemptionClass> {
-  const disabled = new Set<ExemptionClass>();
-  for (const name of config.exemptionsDisabled) {
-    if (!isExemptionClass(name)) {
-      const known = EXEMPTION_CLASSES.map((row) => row.class).join(", ");
-      throw new ConfigError(
-        "malformed",
-        "exemptions.disabled",
-        `exemptions.disabled: ${JSON.stringify(name)} is not an exemption class: the classes are ${known}`,
-      );
-    }
-    disabled.add(name);
-  }
-  return disabled;
+export function disabledClasses(config: ResolvedConfig): ReadonlySet<ExemptionClass> {
+  return new Set(config.exemptions.disabled);
 }
 
 /**
@@ -105,20 +123,12 @@ function retainable(allowed: TypeScriptVisibility, visibility: Visibility | unde
   return true;
 }
 
-/**
- * The kinds of declaration each class can hold back, which a detector that stops holds
- * back whole. A class with no row here holds back every declaration but a file.
- */
-const RETAINABLE: ReadonlyMap<TSExemptionClass, ReadonlySet<SymbolKind>> = new Map([
-  ["interface-satisfaction", new Set<SymbolKind>(["method", "class-member"])],
-  ["enum-group", new Set<SymbolKind>(["enum-member"])],
-  ["injection-container", new Set<SymbolKind>(["method", "class-member"])],
-  ["framework-lifecycle", new Set<SymbolKind>(["method", "class-member"])],
-  [
-    "serialization-contract",
-    new Set<SymbolKind>(["method", "class-member", "interface-method", "type-member"]),
-  ],
-]);
+/** The kinds of declaration each class can hold back, which a detector that stops holds back whole. */
+const RETAINABLE: ReadonlyMap<string, ReadonlySet<string>> = new Map(
+  EXEMPTION_CLASSES.flatMap((row) =>
+    "ts" in row.retainsKinds ? [[row.class, new Set<string>(row.retainsKinds.ts)] as const] : [],
+  ),
+);
 
 /** The detail of a record a detector that could not finish holds. */
 const UNANSWERED_DETAIL = "kept live by a question the checker did not answer";
@@ -147,7 +157,7 @@ function detected<Brand>(
     }
     const kinds = RETAINABLE.get(exemptionClass);
     return input.held.symbols
-      .filter((symbol) => (kinds === undefined ? symbol.kind !== "file" : kinds.has(symbol.kind)))
+      .filter((symbol) => kinds?.has(symbol.kind) === true)
       .map((symbol) => ({ id: symbol.id, detail: UNANSWERED_DETAIL, site: symbol.position }));
   }
 }
@@ -193,12 +203,26 @@ export function evidenceRecords<Brand>(
         site: evidence.site,
         ...(evidence.whileLive === undefined ? {} : { whileLive: evidence.whileLive }),
         ...(evidence.implementing === undefined ? {} : { implementing: evidence.implementing }),
+        ...(evidence.whileWritten === undefined ? {} : { whileWritten: evidence.whileWritten }),
       });
     }
   }
   return found;
 }
 
+/**
+ * The records that hold given the declarations a write the mode counts stores into: one
+ * that holds only while written holds where its declaration is among them.
+ */
+export function writtenRecords(
+  records: readonly Exemption[],
+  written: ReadonlySet<string>,
+): readonly Exemption[] {
+  return records.flatMap(({ whileWritten, ...record }) =>
+    whileWritten === undefined || written.has(record.id) ? [record] : [],
+  );
+}
+
 /** The records that hold under one mode, beside the evidence a production mode found in a test file. */
 export function heldRecords(records: readonly Exemption[], holding: Holding): Detected {
   const found: Exemption[] = [];
@@ -213,14 +237,6 @@ export function heldRecords(records: readonly Exemption[], holding: Holding): De
   return { records: exemptionsOf(found), inTestFiles };
 }
 
-/** Two strings ordered bytewise. */
-function compare(a: string, b: string): number {
-  if (a === b) {
-    return 0;
-  }
-  return a < b ? -1 : 1;
-}
-
 /**
  * Records as a run holds them: ordered by site, then class, then declaration, and one
  * per declaration, class, detail and file it holds while live, the one at the first
@@ -228,7 +244,7 @@ function compare(a: string, b: string): number {
  */
 export function exemptionsOf(found: readonly Exemption[]): readonly Exemption[] {
   const ordered = [...found].sort(
-    (a, b) => byPosition(a.site, b.site) || compare(a.class, b.class) || compare(a.id, b.id),
+    (a, b) => byPosition(a.site, b.site) || bytewise(a.class, b.class) || bytewise(a.id, b.id),
   );
   const seen = new Set<string>();
   return ordered.filter((record) => {
@@ -241,21 +257,6 @@ export function exemptionsOf(found: readonly Exemption[]): readonly Exemption[]
   });
 }
 
-/**
- * The records that hold while the component files at `live` are live: every record that
- * holds whatever is live, and each one a live file's markup holds, as a record of the run.
- */
-export function holdingWhile(
-  records: readonly Exemption[],
-  live: ReadonlySet<string>,
-): readonly Exemption[] {
-  return exemptionsOf(
-    records.flatMap(({ whileLive, ...record }) =>
-      whileLive === undefined || live.has(whileLive) ? [record] : [],
-    ),
-  );
-}
-
 /** The records per declaration, each declaration's in the order given. */
 function byDeclaration(records: readonly Exemption[]): ReadonlyMap<string, readonly Exemption[]> {
   const grouped = new Map<string, Exemption[]>();
@@ -271,37 +272,8 @@ function byDeclaration(records: readonly Exemption[]): ReadonlyMap<string, reado
 }
 
 /**
- * The records that held back a declaration: one some configuration's graph, swept
- * again with no exemption and its marks, judges a candidate, whatever another
- * configuration answers, or one in `writeOnly`, which the run would report as written
- * and never read without the record's read. A declaration a relation or a mark holds
- * live in every configuration is held back by no record. The order is the
- * declarations' site order, and for one declaration the input's.
- */
-export function retainedIn(
-  matrix: Matrix,
-  input: SweepInput,
-  writeOnly: ReadonlySet<string> = new Set(),
-): readonly Exemption[] {
-  const exempt = input.exempt ?? [];
-  if (exempt.length === 0) {
-    return [];
-  }
-  const bare: SweepInput = { marked: input.marked, mode: input.mode };
-  const dead = new Set(
-    matrix.graphs.flatMap((graph) =>
-      sweep(graph, bare).candidates.map((candidate) => candidate.id),
-    ),
-  );
-  const held = byDeclaration(
-    exempt.filter((record) => dead.has(record.id) || writeOnly.has(record.id)),
-  );
-  return matrix.union.symbols.flatMap((symbol) => held.get(symbol.id) ?? []);
-}
-
-/**
- * One line per held-back declaration, in site order: its reference, then each record's
- * class, site and detail, all separated by tabs.
+ * One line per held-back declaration, in site order: its reference and position, then
+ * each record's class, site and detail, all separated by tabs.
  */
 export function retainedLines(
   symbols: readonly InventorySymbol[],
@@ -318,6 +290,6 @@ export function retainedLines(
       positionKey(record.site),
       record.detail,
     ]);
-    return [[symbol.ref, ...fields].join("\t")];
+    return [[symbol.ref, positionKey(symbol.position), ...fields].join("\t")];
   });
 }