@cplieger/deadset-ts 3.12.1 → 4.0.0

package/src/findings/unused-declarations.ts

@@ -1,7 +1,7 @@
 import type { Finding } from "../finding.ts";
 import type { InventorySymbol, SymbolKind } from "../inventory.ts";
 import type { MatrixCandidate } from "../matrix.ts";
-import type { Emitter } from "./emitter.ts";
+import type { Emitter, EmitterInput } from "./emitter.ts";
 import { unreachableExports } from "./visibility-narrowing.ts";
 
 /** The kinds of declaration that are members of a class, an interface, a type or an enum. */
@@ -137,7 +137,17 @@ function messageOf(code: string, judged: Judged): string {
 }
 
 /** The findings of the unused-declarations family, `DS1000` to `DS1099`. */
-export const unusedDeclarations: Emitter = (input) => {
+export const unusedDeclarations: Emitter = (input) => familyFindings(input, false);
+
+/**
+ * The finding each member of a dead container would carry were its container live: what
+ * a record on such a member is matched against, since the report carries the container's
+ * finding rather than one of the member's own.
+ */
+export const fallenMembers: Emitter = (input) => familyFindings(input, true);
+
+/** The family's findings, or, where `fallen` is set, its dead containers' members' alone. */
+function familyFindings(input: EmitterInput, fallen: boolean): Finding[] {
   const union = input.swept.matrix.union;
   const dead = new Set(input.swept.sweep.candidates.map((candidate) => candidate.id));
   const unreachable = unreachableExports(input);
@@ -149,11 +159,15 @@ export const unusedDeclarations: Emitter = (input) => {
     if (symbol === undefined) {
       continue;
     }
+    const containerDead = dead.has(symbol.parent);
+    if (fallen !== containerDead) {
+      continue;
+    }
     const judged: Judged = {
       candidate,
       symbol,
       test: union.test[at] === true,
-      containerDead: dead.has(symbol.parent),
+      containerDead: containerDead && !fallen,
       deprecated: input.deprecated.has(symbol.id),
       unreachable: unreachable.has(symbol.id),
     };
@@ -175,4 +189,4 @@ export const unusedDeclarations: Emitter = (input) => {
     });
   }
   return found;
-};
+}

package/src/findings-pass.ts

@@ -122,19 +122,34 @@ export function verdictOf(result: PassResult, config: Config): number {
   return failing ? EXIT_FINDINGS : EXIT_CLEAN;
 }
 
+/** What a baseline row is recorded from: a finding's code, subject and file. */
+export interface RecordableFinding {
+  readonly code: string;
+  readonly symbol: { readonly ref: string; readonly kind: string };
+  readonly position: { readonly path: string };
+}
+
 /**
- * The findings of a report as a baseline records them, in report 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.
+ * 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.
  */
-export function recordedFindings(result: PassResult): readonly Recorded[] {
-  return result.findings
-    .filter((finding) => !isRowSubject(finding.symbol.kind))
-    .map((finding) => ({
-      code: finding.code,
-      symbol: finding.symbol.ref,
-      path: finding.position.path,
-    }));
+export function recordedFindings(findings: readonly RecordableFinding[]): readonly Recorded[] {
+  const rows = new Map<string, Recorded>();
+  for (const finding of findings) {
+    if (isRowSubject(finding.symbol.kind)) {
+      continue;
+    }
+    const row = { code: finding.code, symbol: finding.symbol.ref, path: finding.position.path };
+    rows.set(rowKey(row), rows.get(rowKey(row)) ?? row);
+  }
+  return [...rows.values()];
+}
+
+/** One row's identity: its code, its symbol and its path. */
+export function rowKey(row: Recorded): string {
+  return `${row.code}\u0000${row.symbol}\u0000${row.path}`;
 }
 
 /** The analyzer identity a baseline this analyzer writes names as its rows' provenance. */

package/src/framework-lifecycle.ts

@@ -30,6 +30,7 @@ import {
 import type { DetectorInput, Evidence } from "./exempt.ts";
 import { nodeKey, type Inventory } from "./inventory.ts";
 import { renderPosition } from "./position.ts";
+import { must } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 
 /** One class that is a component of one contract, and what says it is. */
@@ -182,7 +183,7 @@ function byBases<Brand>(
   if (classes.length === 0) {
     return [];
   }
-  const checker = project.checker;
+  const queries = project.queries;
   const ancestry = new Map<number, readonly Type[]>();
   const ancestorsOf = (type: Type, seen: Set<number>): readonly Type[] => {
     const known = ancestry.get(type.id);
@@ -192,15 +193,16 @@ function byBases<Brand>(
     const declared = type.isClassOrInterface()
       ? type
       : type.isTypeReference()
-        ? type.getTarget()
+        ? must(queries.targetOf(type))
         : undefined;
     if (declared === undefined || !declared.isClassOrInterface() || seen.has(declared.id)) {
       return [];
     }
     seen.add(declared.id);
-    const found = checker
-      .getBaseTypes(declared)
-      .flatMap((base) => [base, ...ancestorsOf(base, seen)]);
+    const found = must(queries.baseTypes(declared)).flatMap((base) => [
+      base,
+      ...ancestorsOf(base, seen),
+    ]);
     ancestry.set(type.id, found);
     return found;
   };
@@ -215,7 +217,9 @@ function byBases<Brand>(
     if (type === undefined) {
       return;
     }
-    const ancestors = ancestorsOf(type, new Set()).flatMap((base) => base.getSymbol() ?? []);
+    const ancestors = ancestorsOf(type, new Set()).flatMap(
+      (base) => must(queries.symbolOfType(base)) ?? [],
+    );
     for (const contract of based) {
       for (const entry of contract.bases) {
         if (ancestors.some((symbol) => names(entry, symbol, chains))) {

package/src/host.ts

@@ -35,8 +35,10 @@ export interface Host {
    */
   analyzerVersion(): string;
   /**
-   * Writes one document whole, or a throw naming why it cannot. The write is atomic: a
-   * reader of the path sees the previous document or this one and never a part of it.
+   * Writes one document from its pieces, in order, or a throw naming why it cannot. The
+   * pieces are written as they come, so the document is never held as one string. The
+   * write is atomic: a reader of the path sees the previous document or this one and
+   * never a part of it.
    */
-  writeFile(path: string, text: string): void;
+  writeDocument(path: string, pieces: Iterable<string>): void;
 }

package/src/implementations.ts

@@ -17,7 +17,7 @@ import {
 import { SymbolFlags, type Symbol as TSSymbol, type Type } from "@typescript/native/unstable/sync";
 import { aliasChains } from "./alias-chain.ts";
 import { nodeKey, type Inventory } from "./inventory.ts";
-import { DEFAULT_BATCH_CAP } from "./references.ts";
+import { must, Unanswerable } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 
 /** What one run knows about how its interfaces are implemented. */
@@ -29,6 +29,13 @@ export interface Implementations {
    * class's implementation is a method whose body holds no statement.
    */
   readonly bodies: ReadonlyMap<string, ReadonlyMap<string, boolean>>;
+  /**
+   * The interface methods whose implementations a project could not read in full,
+   * because the checker left a question about them unanswered. Each is treated as a
+   * marker, whose every implementation is empty, so none is reported for want of an
+   * answer.
+   */
+  readonly unknown: ReadonlySet<string>;
 }
 
 /** One interface or class the inventory holds, by its declaration. */
@@ -97,24 +104,22 @@ function walk<Brand>(
   return { interfaces, classes, clauses };
 }
 
-/** The type at each node, asked in capped batches. */
+/** The type at each node. */
 function typesAt<Brand>(project: ProjectView<Brand>, nodes: readonly Node[]): Map<Node, Type> {
   const typeAt = new Map<Node, Type>();
-  for (let from = 0; from < nodes.length; from += DEFAULT_BATCH_CAP) {
-    const run = nodes.slice(from, from + DEFAULT_BATCH_CAP);
-    project.checker.getTypeAtLocation(run).forEach((type, index) => {
-      const node = run[index];
-      if (type !== undefined && node !== undefined) {
-        typeAt.set(node, type);
-      }
-    });
-  }
+  project.queries.typesAt(nodes).forEach((answer, index) => {
+    const type = must(answer);
+    const node = nodes[index];
+    if (type !== undefined && node !== undefined) {
+      typeAt.set(node, type);
+    }
+  });
   return typeAt;
 }
 
 /** Whether one class member is a method whose every written body holds no statement. */
 function emptyImplementation<Brand>(project: ProjectView<Brand>, member: TSSymbol): boolean {
-  const own = new Set(project.ownSourceFiles().map((file) => file.fileName));
+  const own = project.ownPaths();
   let bodies = 0;
   for (const handle of member.declarations) {
     // A body outside the target is one this analysis cannot read, so it is not empty.
@@ -135,19 +140,41 @@ function emptyImplementation<Brand>(project: ProjectView<Brand>, member: TSSymbo
   return bodies > 0;
 }
 
-/** How one project's interfaces are implemented by its classes. */
+/**
+ * How one project's interfaces are implemented by its classes. Where the checker leaves
+ * a question unanswered, what was read stands and every interface method of the project
+ * is named in {@link Implementations.unknown}.
+ */
 export function implementations<Brand>(
   project: ProjectView<Brand>,
   held: Inventory,
 ): Implementations {
   const classes = new Map<string, Set<string>>();
   const bodies = new Map<string, Map<string, boolean>>();
+  try {
+    implementedIn(project, held, classes, bodies);
+    return { classes, bodies, unknown: new Set() };
+  } catch (error: unknown) {
+    if (!(error instanceof Unanswerable)) {
+      throw error;
+    }
+    const methods = held.symbols.filter((symbol) => symbol.kind === "interface-method");
+    return { classes, bodies, unknown: new Set(methods.map((symbol) => symbol.id)) };
+  }
+}
+
+function implementedIn<Brand>(
+  project: ProjectView<Brand>,
+  held: Inventory,
+  classes: Map<string, Set<string>>,
+  bodies: Map<string, Map<string, boolean>>,
+): void {
   const walked = walk(project, held);
   if (walked.interfaces.length === 0 || walked.classes.length === 0) {
-    return { classes, bodies };
+    return;
   }
 
-  const checker = project.checker;
+  const queries = project.queries;
   const typeAt = typesAt(project, [
     ...walked.interfaces.map((one) => one.nameNode),
     ...walked.classes.map((one) => one.nameNode),
@@ -178,10 +205,10 @@ export function implementations<Brand>(
   }
 
   const membersOf = (at: InterfaceAt): readonly TSSymbol[] =>
-    (at.members ??= checker.getPropertiesOfType(at.type));
+    (at.members ??= must(queries.propertiesOf(at.type)));
   const classMembers = (at: ClassAt): ReadonlyMap<string, TSSymbol> =>
     (at.members ??= new Map(
-      checker.getPropertiesOfType(at.type).map((member) => [member.escapedName, member]),
+      must(queries.propertiesOf(at.type)).map((member) => [member.escapedName, member]),
     ));
 
   const methodIds = new Set(
@@ -233,12 +260,14 @@ export function implementations<Brand>(
     if (entry === undefined || implementer === undefined) {
       continue;
     }
-    const at = byType.get(entry.isTypeReference() ? entry.getTarget().id : entry.id);
+    const at = byType.get(must(queries.targetOf(entry)).id);
     if (at !== undefined) {
       pair(at, implementer);
     }
   }
 
+  // Every pair whose names line up is asked about at once.
+  const candidates: { readonly at: InterfaceAt; readonly implementer: ClassAt }[] = [];
   for (const at of byType.values()) {
     const members = at.generic ? [] : membersOf(at);
     if (members.length === 0) {
@@ -252,18 +281,25 @@ export function implementations<Brand>(
       const written = classMembers(implementer);
       if (
         required.every((member) => written.has(member.escapedName)) &&
-        members.some((member) => written.has(member.escapedName)) &&
-        checker.isTypeAssignableTo(implementer.type, at.type)
+        members.some((member) => written.has(member.escapedName))
       ) {
-        pair(at, implementer);
+        candidates.push({ at, implementer });
       }
     }
   }
-  return { classes, bodies };
+  const assignable = queries.assignableEach(
+    candidates.map((one) => ({ source: one.implementer.type, target: one.at.type })),
+  );
+  candidates.forEach((one, index) => {
+    if (must(assignable[index] ?? false)) {
+      pair(one.at, one.implementer);
+    }
+  });
 }
 
 /** Every project's answers as one run's, each implementation once. */
 export function mergeImplementations(per: readonly Implementations[]): Implementations {
+  const unknown = new Set(per.flatMap((one) => [...one.unknown]));
   const classes = new Map<string, Set<string>>();
   const bodies = new Map<string, Map<string, boolean>>();
   for (const one of per) {
@@ -282,5 +318,5 @@ export function mergeImplementations(per: readonly Implementations[]): Implement
       }
     }
   }
-  return { classes, bodies };
+  return { classes, bodies, unknown };
 }

package/src/interface-satisfaction.ts

@@ -52,7 +52,7 @@ import { aliasChains } from "./alias-chain.ts";
 import type { DetectorInput, Evidence } from "./exempt.ts";
 import { nodeKey } from "./inventory.ts";
 import { renderPosition } from "./position.ts";
-import { DEFAULT_BATCH_CAP } from "./references.ts";
+import { must } from "./query.ts";
 
 /** One class the inventory holds, by its declaration. */
 interface ClassAt {
@@ -246,7 +246,7 @@ function walk(files: readonly SourceFile[], declarations: ReadonlyMap<string, st
  */
 export function interfaceSatisfaction<Brand>(input: DetectorInput<Brand>): readonly Evidence[] {
   const { project, held, targetRoot } = input;
-  const checker = project.checker;
+  const queries = project.queries;
   const files = project.ownSourceFiles();
   const { classes, clauses, flows } = walk(files, held.declarations);
   if (classes.length === 0) {
@@ -261,15 +261,13 @@ export function interfaceSatisfaction<Brand>(input: DetectorInput<Brand>): reado
     ...flows.filter((flow) => flow.self === undefined).map((flow) => flow.value),
   ];
   const typeAt = new Map<Node, Type>();
-  for (let from = 0; from < asked.length; from += DEFAULT_BATCH_CAP) {
-    const run = asked.slice(from, from + DEFAULT_BATCH_CAP);
-    checker.getTypeAtLocation(run).forEach((type, index) => {
-      const node = run[index];
-      if (type !== undefined && node !== undefined) {
-        typeAt.set(node, type);
-      }
-    });
-  }
+  queries.typesAt(asked).forEach((answer, index) => {
+    const type = must(answer);
+    const node = asked[index];
+    if (type !== undefined && node !== undefined) {
+      typeAt.set(node, type);
+    }
+  });
 
   const classOfType = new Map<number, ClassAt>();
   const instanceOf = new Map<string, Type>();
@@ -289,7 +287,7 @@ export function interfaceSatisfaction<Brand>(input: DetectorInput<Brand>): reado
     }
     let parts = constituents.get(type.id);
     if (parts === undefined) {
-      parts = type.getTypes();
+      parts = must(queries.constituents(type));
       constituents.set(type.id, parts);
     }
     return parts;
@@ -307,7 +305,7 @@ export function interfaceSatisfaction<Brand>(input: DetectorInput<Brand>): reado
         return [];
       }
       if (!targets.has(part.id)) {
-        targets.set(part.id, classOfType.get(part.getTarget().id));
+        targets.set(part.id, classOfType.get(must(queries.targetOf(part)).id));
       }
       const generic = targets.get(part.id);
       return generic === undefined ? [] : [{ owner: generic, type: part }];
@@ -318,7 +316,7 @@ export function interfaceSatisfaction<Brand>(input: DetectorInput<Brand>): reado
   const interfacesOf = (type: Type): readonly { type: Type; name: string }[] =>
     partsOf(type).flatMap((part) => {
       if (!interfaceNames.has(part.id)) {
-        const symbol = part.isObjectType() ? part.getSymbol() : undefined;
+        const symbol = part.isObjectType() ? must(queries.symbolOfType(part)) : undefined;
         interfaceNames.set(
           part.id,
           symbol !== undefined && (symbol.flags & SymbolFlags.Interface) !== 0
@@ -352,7 +350,8 @@ export function interfaceSatisfaction<Brand>(input: DetectorInput<Brand>): reado
     }
   }
 
-  for (const flow of flows) {
+  // The positions of every flow carrying a class are asked for at once.
+  const carrying = flows.flatMap((flow) => {
     const self = flow.self === undefined ? undefined : instanceOf.get(flow.self.id);
     const valueType = typeAt.get(flow.value);
     const sources =
@@ -361,32 +360,35 @@ export function interfaceSatisfaction<Brand>(input: DetectorInput<Brand>): reado
         : valueType === undefined
           ? []
           : classesOf(valueType);
-    if (sources.length === 0) {
-      continue;
-    }
-    const position = checker.getContextualType(flow.value);
+    return sources.length === 0 ? [] : [{ flow, sources }];
+  });
+  const positions = queries.contextualTypes(carrying.map((one) => one.flow.value));
+  carrying.forEach(({ flow, sources }, index) => {
+    const position = must(positions[index]);
     if (position === undefined) {
-      continue;
+      return;
     }
     for (const reached of interfacesOf(position)) {
       for (const source of sources) {
         reach(source.owner, source.type, reached.type, reached.name, flow.value);
       }
     }
-  }
+  });
 
   const chains = aliasChains(project, held);
   const required = new Map<number, ReadonlySet<string>>();
   const members = new Map<string, ReadonlyMap<string, readonly string[]>>();
   const found: Evidence[] = [];
-  for (const pair of pairs.values()) {
-    if (!checker.isTypeAssignableTo(pair.source, pair.target)) {
+  const asking = [...pairs.values()];
+  const assignable = queries.assignableEach(asking);
+  for (const [index, pair] of asking.entries()) {
+    if (!must(assignable[index] ?? false)) {
       continue;
     }
     let names = required.get(pair.target.id);
     if (names === undefined) {
       names = new Set(
-        checker.getPropertiesOfType(pair.target).map((property) => property.escapedName),
+        must(queries.propertiesOf(pair.target)).map((property) => property.escapedName),
       );
       required.set(pair.target.id, names);
     }
@@ -394,9 +396,10 @@ export function interfaceSatisfaction<Brand>(input: DetectorInput<Brand>): reado
     if (answering === undefined) {
       const instance = instanceOf.get(pair.owner.id) ?? pair.source;
       answering = new Map(
-        checker
-          .getPropertiesOfType(instance)
-          .map((property) => [property.escapedName, chains.declarationsOf(property)]),
+        must(queries.propertiesOf(instance)).map((property) => [
+          property.escapedName,
+          chains.declarationsOf(property),
+        ]),
       );
       members.set(pair.owner.id, answering);
     }