@cplieger/deadset-ts 3.13.0 → 4.0.0

package/src/discover.ts

@@ -4,7 +4,7 @@ import type { BuildConfiguration, ProjectConfiguration } from "./config.ts";
 import type { Host } from "./host.ts";
 import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.ts";
 import type { Scope } from "./scope.ts";
-import type { Engine } from "./session.ts";
+import type { Engine, ProjectDiagnostics } from "./session.ts";
 
 /** Directory names discovery does not descend into. */
 export const IGNORED_DIRECTORIES: ReadonlySet<string> = new Set(["node_modules", ".git"]);
@@ -20,24 +20,60 @@ const CONFIG_FILE = /^tsconfig.*\.json$/u;
  */
 export class DiscoveryError extends Error {
   /** The diagnostics the compiler reported, in the order it reported them. */
-  readonly diagnostics: readonly Diagnostic[];
+  readonly diagnostics: readonly LocatedDiagnostic[];
 
-  constructor(message: string, diagnostics: readonly Diagnostic[]) {
+  constructor(message: string, diagnostics: readonly LocatedDiagnostic[]) {
     super(message);
     this.name = "DiscoveryError";
     this.diagnostics = diagnostics;
   }
 }
 
+/** The category an error diagnostic carries, which the protocol sends as a number. */
+const ERROR_CATEGORY: number = DiagnosticCategory.Error;
+
 /** Whether one diagnostic is an error, which is what fails a run closed. */
 export function isError(diagnostic: Diagnostic): boolean {
-  return diagnostic.category === DiagnosticCategory.Error;
+  return diagnostic.category === ERROR_CATEGORY;
 }
 
-/** One diagnostic as a line naming its position, its code and its message. */
-export function renderDiagnostic(diagnostic: Diagnostic): string {
-  const where = diagnostic.fileName ?? "<no file>";
-  return `${where}:${String(diagnostic.pos)}: TS${String(diagnostic.code)}: ${diagnostic.text}`;
+/** One diagnostic, with the line and column its offset falls on where it names a file. */
+export interface LocatedDiagnostic {
+  readonly diagnostic: Diagnostic;
+  /** Where the diagnostic starts, counted from one; absent where it names no position. */
+  readonly at?: { readonly line: number; readonly column: number } | undefined;
+}
+
+/**
+ * One diagnostic as a line naming its file, its line and column, its code and its
+ * message: `path:line:column: TScode: message`, the position left out where the
+ * diagnostic names none and the file where it names none. `display` spells the
+ * file's path; it answers the path itself where it is not given.
+ */
+export function renderDiagnostic(
+  located: LocatedDiagnostic,
+  display: (path: string) => string = (path) => path,
+): string {
+  const { diagnostic, at } = located;
+  const message = `TS${String(diagnostic.code)}: ${diagnostic.text}`;
+  if (diagnostic.fileName === undefined) {
+    return message;
+  }
+  const where = display(diagnostic.fileName);
+  return at === undefined
+    ? `${where}: ${message}`
+    : `${where}:${String(at.line)}:${String(at.column)}: ${message}`;
+}
+
+/** Each diagnostic with the line and column its offset falls on. */
+function locatedIn(
+  diagnostics: readonly Diagnostic[],
+  locate: (fileName: string, offset: number) => { line: number; column: number } | undefined,
+): readonly LocatedDiagnostic[] {
+  return diagnostics.map((diagnostic) => ({
+    diagnostic,
+    at: diagnostic.fileName === undefined ? undefined : locate(diagnostic.fileName, diagnostic.pos),
+  }));
 }
 
 /**
@@ -55,6 +91,26 @@ export function diagnosticErrors(sets: {
   return [...sets.configParsing, ...sets.syntactic, ...sets.semantic].filter(isError);
 }
 
+/** Why one open project cannot be analyzed, split by whether it loaded at all. */
+interface ProjectErrors {
+  /**
+   * The errors in the configuration itself: no input matched, an option that does not
+   * parse. A project carrying one did not load, whatever its files say.
+   */
+  readonly load: readonly LocatedDiagnostic[];
+  /** The errors in the files of a project that loaded: their syntax and their types. */
+  readonly check: readonly LocatedDiagnostic[];
+}
+
+/** The errors one open project carries, each located in the file it names. */
+export function projectErrors(sets: ProjectDiagnostics): ProjectErrors {
+  const load = sets.configParsing.filter(isError);
+  return {
+    load: locatedIn(load, sets.locate),
+    check: load.length > 0 ? [] : locatedIn(diagnosticErrors(sets), sets.locate),
+  };
+}
+
 /** One project a run analyzes. */
 export interface DiscoveredProject {
   /**
@@ -68,10 +124,54 @@ export interface DiscoveredProject {
   readonly configFile: string;
 }
 
+/**
+ * One project discovery derived and the run could not build, with the first line of
+ * the error that dropped it.
+ */
+export interface NotBuilt {
+  /** The name the project would have carried, as {@link DiscoveredProject.id} spells it. */
+  readonly id: string;
+  /** The compiler configuration file, absolute. */
+  readonly configFile: string;
+  /**
+   * The error's first line, every path below the target root spelled relative to it, so
+   * a report naming it carries no path of the machine it ran on.
+   */
+  readonly error: string;
+}
+
+/**
+ * The first line of one error about the target, every mention of the target root
+ * spelled relative to it: a path below the root loses the root and its separator, and
+ * the root itself is `.`.
+ */
+export function targetRelative(text: string, targetRoot: string): string {
+  const root = targetRoot.endsWith("/") ? targetRoot.slice(0, -1) : targetRoot;
+  const [first = ""] = text.split(/\r?\n/u);
+  const spelled = first.split(`${root}/`).join("").split(root).join(".").trim();
+  return spelled === "" ? "the configuration could not be built" : spelled;
+}
+
+/**
+ * Whether one configuration is the analyzer's own guess: discovery derived it and the
+ * scope did not name it. A guess that does not load is dropped; any other ends the run.
+ */
+export function isGuess(discovery: Discovery, configFile: string): boolean {
+  return discovery.derived && !discovery.fromScope.includes(configFile);
+}
+
 /** Every project discovery found, and where each came from. */
 export interface Discovery {
   /** The projects, in discovery order, each once. */
   readonly projects: readonly DiscoveredProject[];
+  /**
+   * Whether discovery derived the projects rather than reading them from a declared
+   * matrix. A derived project that fails to load is dropped and named in
+   * {@link Discovery.notBuilt}; a declared one ends the run.
+   */
+  readonly derived: boolean;
+  /** The derived configurations the compiler could not read, in discovery order. */
+  readonly notBuilt: readonly NotBuilt[];
   /** The configuration file of each project, in the same order. */
   readonly configFiles: readonly string[];
   /**
@@ -174,9 +274,16 @@ function scopeConfigFiles(host: Host, scope: Scope): string[] {
 /**
  * Every configuration file reached from `pending`, in the order discovery reads them:
  * each once, each followed by the configurations it references, transitively. A
- * configuration the compiler cannot read ends the run naming it.
+ * configuration the compiler cannot read ends the run naming it, unless `unreadable`
+ * is given, which is then told the configuration and why, and the walk goes on
+ * without it.
  */
-function derivedFrom(engine: Engine, host: Host, pending: string[]): string[] {
+function derivedFrom(
+  engine: Engine,
+  host: Host,
+  pending: string[],
+  unreadable?: (configFile: string, reason: string) => void,
+): string[] {
   const seen = new Set<string>();
   const found: string[] = [];
   while (pending.length > 0) {
@@ -189,7 +296,17 @@ function derivedFrom(engine: Engine, host: Host, pending: string[]): string[] {
       continue;
     }
     seen.add(path);
-    parseOrRefuse(engine, path, path);
+    const reason = unreadableReason(engine, path);
+    if (reason !== undefined) {
+      if (unreadable === undefined) {
+        throw new DiscoveryError(
+          `${path} cannot be read as a compiler configuration: ${reason}`,
+          [],
+        );
+      }
+      unreadable(path, reason);
+      continue;
+    }
     found.push(path);
     pending.push(...referencesOf(host, path));
   }
@@ -232,20 +349,25 @@ function derivedId(targetRoot: string, configFile: string): string {
   return relativePath(targetRoot, configFile) ?? configFile;
 }
 
+/** Why the compiler cannot read one configuration file, or undefined where it can. */
+function unreadableReason(engine: Engine, configFile: string): string | undefined {
+  try {
+    engine.parseConfigFile(configFile);
+    return undefined;
+  } catch (error: unknown) {
+    return error instanceof Error ? error.message : String(error);
+  }
+}
+
 /**
  * Resolves one compiler configuration file, or ends the run naming it: a project
  * opened from a configuration the compiler cannot read would be analyzed with no
  * type information.
  */
 function parseOrRefuse(engine: Engine, configFile: string, named: string): void {
-  try {
-    engine.parseConfigFile(configFile);
-  } catch (error: unknown) {
-    throw new DiscoveryError(
-      `${named} cannot be read as a compiler configuration: ` +
-        (error instanceof Error ? error.message : String(error)),
-      [],
-    );
+  const reason = unreadableReason(engine, configFile);
+  if (reason !== undefined) {
+    throw new DiscoveryError(`${named} cannot be read as a compiler configuration: ${reason}`, []);
   }
 }
 
@@ -299,26 +421,50 @@ function declaredProjects(
       );
     }
   }
-  return { projects, configFiles: projects.map((project) => project.configFile), fromScope: [] };
+  return {
+    projects,
+    derived: false,
+    notBuilt: [],
+    configFiles: projects.map((project) => project.configFile),
+    fromScope: [],
+  };
 }
 
 /**
  * The projects a run derives where the matrix declares none, in the order discovery
  * reads them: the paths the scope names, then every compiler configuration under
  * the target root that is not inside an ignored directory, then the configurations
- * each of those references, transitively. Each configuration appears once.
+ * each of those references, transitively. Each configuration appears once. A
+ * configuration the scope names directly is the caller's own and ends the run where
+ * it cannot be read; one the walk found is dropped and named.
  */
 function derivedProjects(engine: Engine, host: Host, scope: Scope): Discovery {
+  const targetRoot = scope.target.path;
   const fromScope = scopeConfigFiles(host, scope);
-  const configFiles = derivedFrom(engine, host, [
-    ...fromScope,
-    ...configFilesUnder(host, scope.target.path),
-  ]);
+  const notBuilt: NotBuilt[] = [];
+  const configFiles = derivedFrom(
+    engine,
+    host,
+    [...fromScope, ...configFilesUnder(host, targetRoot)],
+    (configFile, reason) => {
+      if (fromScope.includes(configFile)) {
+        throw new DiscoveryError(
+          `${configFile} cannot be read as a compiler configuration: ${reason}`,
+          [],
+        );
+      }
+      notBuilt.push({
+        id: derivedId(targetRoot, configFile),
+        configFile,
+        error: targetRelative(reason, resolvePath(host.workingDirectory(), targetRoot)),
+      });
+    },
+  );
   const projects = configFiles.map((configFile) => ({
-    id: derivedId(scope.target.path, configFile),
+    id: derivedId(targetRoot, configFile),
     configFile,
   }));
-  return { projects, configFiles, fromScope };
+  return { projects, derived: true, notBuilt, configFiles, fromScope };
 }
 
 /**
@@ -331,12 +477,10 @@ function derivedProjects(engine: Engine, host: Host, scope: Scope): Discovery {
  * scope and the target tree. A platform entry names a configuration of another
  * language and plays no part here.
  *
- * A configuration file the compiler cannot read ends the run with the failure code,
- * so a project that would have been analyzed with no type information is never
- * analyzed at all, whether the matrix declared it or discovery derived it. What a
- * configuration's own contents say is refused once its project is open, by
- * {@link diagnosticErrors} over the three sets a program reports, because a
- * resolution carries no diagnostics.
+ * A configuration file the compiler cannot read is never analyzed. One the matrix or
+ * the scope names ends the run with the failure code; a guess is dropped and named in
+ * {@link Discovery.notBuilt}. What a configuration's own contents say is read once its
+ * project is open, by {@link diagnosticErrors}, because a resolution carries none.
  *
  * Nothing reads a build output: a project is the files its configuration names, so a
  * package whose sources ship as TypeScript is analyzed as it stands.

package/src/entry-points.ts

@@ -32,6 +32,7 @@ import {
 import { SymbolFlags } from "@typescript/native/unstable/sync";
 import { globExpression } from "./glob.ts";
 import { dirnamePath, relativePath, resolvePath } from "./paths.ts";
+import { UNANSWERED } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 import type { SourceFiles } from "./source-files.ts";
 
@@ -435,8 +436,14 @@ function workersOf<Brand>(
   const names = sites.flatMap((site) => site.platformNames);
   const symbols = project.symbolsAt(names.map((name) => project.handle(name)));
   const platform = new Set<Node>();
+  // A name the checker could not resolve is read as the platform's, so a worker it
+  // stands on is rooted rather than reported.
   names.forEach((name, index) => {
     const symbol = symbols[index];
+    if (symbol === UNANSWERED) {
+      platform.add(name);
+      return;
+    }
     if (
       symbol !== undefined &&
       (symbol.flags & SymbolFlags.Alias) === 0 &&

package/src/enum-group.ts

@@ -33,7 +33,8 @@ 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 { isAnswered, UNANSWERED, type Answer } from "./query.ts";
+import type { ProjectView } from "./session.ts";
 
 /** The operand types a conversion produces an enum value from. */
 const NUMBER = TypeFlags.NumberLike;
@@ -146,25 +147,38 @@ function sitesOf(file: SourceFile): readonly Site[] {
  * union, and itself otherwise. An enum's own value, or one of its members, is a value the
  * source names, whichever number or string it also is.
  */
-function partsOf(type: Type): readonly Type[] {
-  const parts = type.isUnionType() ? type.getTypes() : [type];
-  return parts.filter((part) => (part.flags & TypeFlags.EnumLike) === 0);
+function partsOf<Brand>(project: ProjectView<Brand>, type: Type): Answer<readonly Type[]> {
+  const parts = type.isUnionType() ? project.queries.constituents(type) : [type];
+  return isAnswered(parts)
+    ? parts.filter((part) => (part.flags & TypeFlags.EnumLike) === 0)
+    : parts;
 }
 
+/** The detail a site records whose operand's type the checker could not answer. */
+const UNTYPED_DETAIL = "converted from a value of unanswered type";
+
 /**
  * The detail one site records about the enum it produces, or undefined where the
  * operand's type converts nothing: a number, or a string an assertion converts, is
  * converted, a value of type `any` or `unknown` is decoded, and a value of an enum is one
  * the source names.
  */
-function detailOf(site: Site, enumName: string, operand: Type | undefined): string | undefined {
+function detailOf<Brand>(
+  project: ProjectView<Brand>,
+  site: Site,
+  enumName: string,
+  operand: Answer<Type> | undefined,
+): string | undefined {
   if (site.form === "lookup") {
     return `looked up by an element access on ${enumName}`;
   }
   if (operand === undefined) {
     return undefined;
   }
-  const parts = partsOf(operand);
+  const parts = operand === UNANSWERED ? UNANSWERED : partsOf(project, operand);
+  if (parts === UNANSWERED) {
+    return UNTYPED_DETAIL;
+  }
   if (parts.some((part) => (part.flags & NUMBER) !== 0)) {
     return "converted from number";
   }
@@ -204,35 +218,37 @@ export function enumGroup<Brand>(input: DetectorInput<Brand>): readonly Evidence
   }
 
   const sites = files.flatMap(sitesOf);
-  const named = new Map<Site, string>();
+  const named = new Map<Site, readonly string[]>();
   const chains = aliasChains(project, held);
-  for (let from = 0; from < sites.length; from += DEFAULT_BATCH_CAP) {
-    const run = sites.slice(from, from + DEFAULT_BATCH_CAP);
-    project.symbolsAt(run.map((site) => project.handle(site.name))).forEach((symbol, index) => {
-      const site = run[index];
-      if (symbol === undefined || site === undefined) {
-        return;
-      }
-      const target = chains.chainOf(symbol).find((link) => enums.has(link.id));
-      if (target !== undefined) {
-        named.set(site, target.id);
+  // A name the checker could not resolve may stand for any enum of the target it spells.
+  const enumsNamed = (text: string): readonly string[] =>
+    [...enums].flatMap(([id, name]) => (name === text ? [id] : []));
+  project.symbolsAt(sites.map((site) => project.handle(site.name))).forEach((symbol, index) => {
+    const site = sites[index];
+    if (symbol === undefined || site === undefined) {
+      return;
+    }
+    if (symbol === UNANSWERED) {
+      const ids = enumsNamed(site.name.getText());
+      if (ids.length > 0) {
+        named.set(site, ids);
       }
-    });
-  }
+      return;
+    }
+    const target = chains.chainOf(symbol).find((link) => enums.has(link.id));
+    if (target !== undefined) {
+      named.set(site, [target.id]);
+    }
+  });
 
   const typed = sites.filter((site) => named.has(site) && site.operand !== undefined);
-  const operandType = new Map<Site, Type>();
-  for (let from = 0; from < typed.length; from += DEFAULT_BATCH_CAP) {
-    const run = typed.slice(from, from + DEFAULT_BATCH_CAP);
-    project.checker
-      .getTypeAtLocation(run.map((site) => site.operand ?? site.at))
-      .forEach((type, index) => {
-        const site = run[index];
-        if (type !== undefined && site !== undefined) {
-          operandType.set(site, type);
-        }
-      });
-  }
+  const operandType = new Map<Site, Answer<Type>>();
+  project.queries.typesAt(typed.map((site) => site.operand ?? site.at)).forEach((type, index) => {
+    const site = typed[index];
+    if (type !== undefined && site !== undefined) {
+      operandType.set(site, type);
+    }
+  });
 
   const members = new Map<string, string[]>();
   for (const symbol of held.symbols) {
@@ -248,17 +264,15 @@ export function enumGroup<Brand>(input: DetectorInput<Brand>): readonly Evidence
 
   const found: Evidence[] = [];
   for (const site of sites) {
-    const enumId = named.get(site);
-    if (enumId === undefined) {
-      continue;
-    }
-    const detail = detailOf(site, enums.get(enumId) ?? "", operandType.get(site));
-    if (detail === undefined) {
-      continue;
-    }
-    const position = renderPosition(site.at.getSourceFile(), targetRoot, site.at.getStart());
-    for (const id of members.get(enumId) ?? []) {
-      found.push({ id, detail, site: position });
+    for (const enumId of named.get(site) ?? []) {
+      const detail = detailOf(project, site, enums.get(enumId) ?? "", operandType.get(site));
+      if (detail === undefined) {
+        continue;
+      }
+      const position = renderPosition(site.at.getSourceFile(), targetRoot, site.at.getStart());
+      for (const id of members.get(enumId) ?? []) {
+        found.push({ id, detail, site: position });
+      }
     }
   }
   return found;

package/src/exempt.ts

@@ -18,9 +18,10 @@ import {
   type TSExemptionClass,
   type TypeScriptVisibility,
 } from "./exempt-classes.ts";
-import type { Inventory, InventorySymbol, Visibility } from "./inventory.ts";
+import type { Inventory, InventorySymbol, SymbolKind, Visibility } from "./inventory.ts";
 import type { Matrix } from "./matrix.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 Mode, type SweepInput } from "./sweep.ts";
@@ -100,6 +101,53 @@ 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 detail of a record a detector that could not finish holds. */
+const UNANSWERED_DETAIL = "kept live by a question the checker did not answer";
+
+/** Whether one record is held by a detector that could not finish. */
+export function isUnansweredRecord(record: Exemption): boolean {
+  return record.detail === UNANSWERED_DETAIL;
+}
+
+/**
+ * What one detector holds back over one project. A detector that stops because the
+ * checker left a question it needs unanswered holds back every declaration of the
+ * project its class could hold back, each recorded at its own position, so the gap
+ * never yields a finding.
+ */
+function detected<Brand>(
+  exemptionClass: TSExemptionClass,
+  detect: Detector,
+  input: DetectorInput<Brand>,
+): readonly Evidence[] {
+  try {
+    return detect(input);
+  } catch (error: unknown) {
+    if (!(error instanceof Unanswerable)) {
+      throw error;
+    }
+    const kinds = RETAINABLE.get(exemptionClass);
+    return input.held.symbols
+      .filter((symbol) => (kinds === undefined ? symbol.kind !== "file" : kinds.has(symbol.kind)))
+      .map((symbol) => ({ id: symbol.id, detail: UNANSWERED_DETAIL, site: symbol.position }));
+  }
+}
+
 /**
  * The records one project's detectors found, each class in the vocabulary's order and
  * none of a switched-off class. Evidence on a private member the class's row says it
@@ -120,7 +168,7 @@ export function computeExemptions<Brand>(
       continue;
     }
     const allowed = typescriptVisibilityOf(exemptionClass);
-    for (const evidence of detect(input)) {
+    for (const evidence of detected(exemptionClass, detect, input)) {
       if (!retainable(allowed, visibility.get(evidence.id))) {
         continue;
       }

package/src/findings/emitters.ts

@@ -24,6 +24,22 @@ export const EMITTERS: Emitters = new Map<string, Emitter>([
   ["intra-function", intraFunction],
 ]);
 
+/**
+ * The references of every declaration an unanswered question could have kept live, which
+ * the run reports nothing about: a finding about one would be computed from the gap.
+ */
+function heldRefs(input: EmitterInput): ReadonlySet<string> {
+  const held = new Set(input.swept.heldByUnanswered);
+  if (held.size === 0) {
+    return held;
+  }
+  return new Set(
+    input.swept.matrix.union.symbols
+      .filter((symbol) => held.has(symbol.id))
+      .map((symbol) => symbol.ref),
+  );
+}
+
 /** What the suppressions of a run swept under their marks are decided against. */
 export interface Suppressed {
   /** The same run swept with no mark, which is where a kind about liveness reports a marked declaration. */
@@ -92,9 +108,10 @@ export function decidedFindings(
     suppressed.records.length === 0 ? [] : completedOver(suppressed.unmarked, fallenMembers);
   const would = [...unmarked, ...found];
   const ledger = ledgerOf(suppressed.records, would, dialsOver(input, found, suppressed, unmarked));
+  const unanswered = heldRefs(input);
   const kept = reportable(
     input,
-    found.filter((finding) => !ledger.withheld(finding)),
+    found.filter((finding) => !ledger.withheld(finding) && !unanswered.has(finding.symbol.ref)),
   );
   const evaluated = evaluateEdges(kept, input.boundary.edges, input.swept.matrix.union.symbols);
   return {

package/src/findings/interfaces.ts

@@ -131,8 +131,14 @@ function unusedMessage(candidate: Candidate): string {
     : UNUSED_MESSAGE;
 }
 
-/** Whether one interface method has implementations and every one has an empty body. */
+/**
+ * Whether one interface method has implementations and every one has an empty body, or
+ * is one whose implementations the run could not read in full.
+ */
 function marker(input: EmitterInput, method: string): boolean {
+  if (input.implementations.unknown.has(method)) {
+    return true;
+  }
   const bodies = [...(input.implementations.bodies.get(method)?.values() ?? [])];
   return bodies.length > 0 && bodies.every((empty) => empty);
 }

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;
 }