@cplieger/deadset-ts 3.13.0 → 4.0.0

package/dist/src/references.js

@@ -2,15 +2,10 @@ import { isArrayLiteralExpression, isBinaryExpression, isCallExpression, isDecor
 import { aliasChains } from "./alias-chain.js";
 import { destructuring, propertyReadsOf } from "./destructuring.js";
 import { globExpression } from "./glob.js";
-import { nodeKey } from "./inventory.js";
+import { declarationsByName, nodeKey } from "./inventory.js";
 import { relativePath } from "./paths.js";
 import { byPosition, renderPosition } from "./position.js";
-/**
- * The batch cap a run takes when the configuration names none. It bounds the size of
- * one answer rather than the work: the median file is one batch at this cap and the
- * largest production file a handful.
- */
-export const DEFAULT_BATCH_CAP = 4096;
+import { DEFAULT_BATCH_CAP, UNANSWERED } from "./query.js";
 /**
  * The operators whose left side one assignment stores into. A compound assignment is
  * among them: it reads its target only to write the result back, so nothing else
@@ -294,6 +289,49 @@ export function testFileRulesOf(testFiles, paths) {
     })
         .sort((a, b) => compare(a.rule, b.rule));
 }
+const importedCache = new WeakMap();
+/**
+ * Each local name one file's imports bind, mapped to the names it imports: the
+ * exported name of a named import, `default` for a default import, and `undefined` for
+ * a namespace import or an import assignment, which binds a whole module.
+ */
+function importedNames(file) {
+    const known = importedCache.get(file);
+    if (known !== undefined) {
+        return known;
+    }
+    const names = new Map();
+    const bind = (local, imported) => {
+        names.set(local, [...(names.get(local) ?? []), imported]);
+    };
+    for (const statement of file.statements) {
+        if (isImportEqualsDeclaration(statement)) {
+            bind(statement.name.text, undefined);
+            continue;
+        }
+        const clause = isImportDeclaration(statement) ? statement.importClause : undefined;
+        if (clause === undefined) {
+            continue;
+        }
+        if (clause.name !== undefined) {
+            bind(clause.name.text, "default");
+        }
+        const bindings = clause.namedBindings;
+        if (bindings === undefined) {
+            continue;
+        }
+        if (bindings.kind === SyntaxKind.NamespaceImport) {
+            bind(bindings.name.text, undefined);
+        }
+        else {
+            for (const element of bindings.elements) {
+                bind(element.name.text, element.propertyName?.text ?? element.name.text);
+            }
+        }
+    }
+    importedCache.set(file, names);
+    return names;
+}
 /** Two strings ordered bytewise, which is the order every set of a run is read in. */
 function compare(a, b) {
     if (a === b) {
@@ -347,7 +385,26 @@ export function references(project, held, targetRoot, options) {
      * Each later link is a declaration of its own that references the next, so one link
      * per re-export is what lets a chain be followed one declaration at a time.
      */
-    const carriedBy = (link, symbol) => link.alias ? chains.nextDeclared(symbol) : chains.declarationsOf(symbol);
+    const carriedBy = (link, symbol) => link.alias
+        ? chains.nextDeclared(symbol)
+        : chains.declarationsOf(symbol).map((id) => ({ id, stepped: false, guessed: false }));
+    /**
+     * Every declaration bearing the name one node spells, or the name an import of its
+     * file binds that name to, which is what a reference the checker could not resolve is
+     * counted as: it may be a use of any of them, and a declaration it may use is kept
+     * live. A name a namespace import binds may be a use of any file.
+     */
+    const named = (node) => {
+        const byName = declarationsByName(held);
+        const text = node.getText();
+        const imported = importedNames(node.getSourceFile()).get(text) ?? [];
+        return [
+            ...new Set([
+                ...(byName.get(text) ?? []),
+                ...imported.flatMap((name) => name === undefined ? [...fileIds] : (byName.get(name) ?? [])),
+            ]),
+        ];
+    };
     /** The symbol one site resolves to, asking only the accessor the site's form names. */
     const symbolFor = (site, answered) => {
         if (site.shorthand !== undefined) {
@@ -355,7 +412,7 @@ export function references(project, held, targetRoot, options) {
             return project.shorthandValueAt(project.handle(site.shorthand));
         }
         const batched = answered.get(site.node);
-        if (batched !== undefined) {
+        if (batched === UNANSWERED || typeof batched === "object") {
             return batched;
         }
         residueFallbacks += 1;
@@ -397,7 +454,7 @@ export function references(project, held, targetRoot, options) {
         batched += batching.length;
         for (let from = 0; from < batching.length; from += cap) {
             const run = batching.slice(from, from + cap);
-            const answers = project.symbolsAt(run.map((node) => project.handle(node)));
+            const answers = project.symbolsAt(run.map((node) => project.handle(node)), cap);
             fileBatches += 1;
             run.forEach((node, index) => {
                 const symbol = answers[index];
@@ -412,13 +469,16 @@ export function references(project, held, targetRoot, options) {
                 continue;
             }
             const position = renderPosition(file, root, link.at.getStart());
-            for (const id of carriedBy(link, symbol)) {
+            const carried = symbol === UNANSWERED
+                ? named(link.at).map((id) => ({ id, stepped: false, guessed: true }))
+                : carriedBy(link, symbol);
+            for (const target of carried) {
                 found.push({
                     from: link.from,
-                    to: id,
+                    to: target.id,
                     position,
                     use: "read",
-                    resolution: link.alias ? "alias" : "batch",
+                    resolution: target.guessed ? "by-name" : link.alias ? "alias" : "batch",
                     test,
                 });
             }
@@ -429,14 +489,16 @@ export function references(project, held, targetRoot, options) {
                 continue;
             }
             const position = renderPosition(file, root, evaluation.node.getStart());
-            for (const id of chains.declarationsOf(module)) {
+            // A module the checker could not resolve may be any file of the target.
+            const evaluated = module === UNANSWERED ? [...fileIds] : chains.declarationsOf(module);
+            for (const id of evaluated) {
                 if (fileIds.has(id)) {
                     found.push({
                         from: evaluation.from,
                         to: id,
                         position,
                         use: "evaluation",
-                        resolution: "batch",
+                        resolution: module === UNANSWERED ? "by-name" : "batch",
                         test,
                     });
                 }
@@ -450,13 +512,20 @@ export function references(project, held, targetRoot, options) {
                 return;
             }
             const position = renderPosition(file, root, read.key.getStart());
-            for (const target of chains.chainOf(symbol)) {
+            const targets = symbol === UNANSWERED
+                ? (declarationsByName(held).get(read.name) ?? []).map((id) => ({
+                    id,
+                    stepped: false,
+                    guessed: true,
+                }))
+                : chains.chainOf(symbol);
+            for (const target of targets) {
                 found.push({
                     from: read.from,
                     to: target.id,
                     position,
                     use: "read",
-                    resolution: "destructured",
+                    resolution: target.guessed ? "by-name" : "destructured",
                     test,
                 });
             }
@@ -464,7 +533,7 @@ export function references(project, held, targetRoot, options) {
         for (const site of uses) {
             const direct = site.shorthand !== undefined
                 ? "shorthand"
-                : answered.has(site.node)
+                : typeof answered.get(site.node) === "object"
                     ? "batch"
                     : "resolved-symbol";
             const symbol = symbolFor(site, answered);
@@ -474,13 +543,16 @@ export function references(project, held, targetRoot, options) {
             const position = renderPosition(file, root, site.node.getStart());
             // A re-export something imports is used and so is the declaration behind it, so
             // the use names every link of the chain its name stands at the head of.
-            for (const target of chains.chainOf(symbol)) {
+            const targets = symbol === UNANSWERED
+                ? named(site.node).map((id) => ({ id, stepped: false, guessed: true }))
+                : chains.chainOf(symbol);
+            for (const target of targets) {
                 found.push({
                     from: site.from,
                     to: target.id,
                     position,
                     use: site.use,
-                    resolution: target.stepped ? "alias" : direct,
+                    resolution: target.guessed ? "by-name" : target.stepped ? "alias" : direct,
                     test,
                 });
             }

package/dist/src/reflective-lookup.js

@@ -14,9 +14,9 @@
  */
 import { isCallExpression, isElementAccessExpression, isIdentifier, isNoSubstitutionTemplateLiteral, isPropertyAccessExpression, isStringLiteral, } from "@typescript/native/unstable/ast";
 import { TypeFlags } from "@typescript/native/unstable/sync";
-import { typesAt } from "./class-members.js";
 import { memberNames } from "./member-names.js";
 import { renderPosition } from "./position.js";
+import { isAnswered, UNANSWERED } from "./query.js";
 /** The `Reflect` methods whose second argument is a property key. */
 const REFLECT_KEYED = new Set(["get", "set", "has"]);
 /** The text one key denotes, where it is literal text. */
@@ -67,14 +67,17 @@ function lookupsOf(file) {
     file.forEachChild(visit);
     return found;
 }
-/** Whether a receiver's type is not `any` and declares a string index signature. */
+/**
+ * Whether a receiver's type is not `any` and declares a string index signature. A type
+ * whose index signatures the checker did not answer for is read as declaring none, so
+ * the lookup retains what it names.
+ */
 function readsAMapping(project, type) {
     if ((type.flags & TypeFlags.Any) !== 0) {
         return false;
     }
-    return project.checker
-        .getIndexInfosOfType(type)
-        .some((info) => (info.keyType.flags & TypeFlags.String) !== 0);
+    const infos = project.queries.indexInfosOf(type);
+    return isAnswered(infos) && infos.some((info) => (info.keyType.flags & TypeFlags.String) !== 0);
 }
 /**
  * The reflective-lookup detector: every member whose name a literal key of a lookup
@@ -89,13 +92,16 @@ export function reflectiveLookup(input) {
     }
     // Whether each written `Reflect` is the global one, asked in one batch: a
     // declaration of that name in one of the project's own files shadows it.
-    const ownFiles = new Set(files.map((file) => file.fileName));
+    const ownFiles = project.ownPaths();
     const reflects = lookups.flatMap((lookup) => lookup.reflect === undefined ? [] : [lookup.reflect]);
     const global = new Set();
     if (reflects.length > 0) {
         project.symbolsAt(reflects.map((node) => project.handle(node))).forEach((symbol, index) => {
             const node = reflects[index];
-            const declaredHere = symbol?.declarations.some((declaration) => ownFiles.has(declaration.path));
+            // A name the checker did not answer for is read as the global, which retains.
+            const declaredHere = symbol === UNANSWERED
+                ? false
+                : symbol?.declarations.some((declaration) => ownFiles.has(declaration.path));
             if (node !== undefined && declaredHere === false) {
                 global.add(node);
             }
@@ -105,9 +111,12 @@ export function reflectiveLookup(input) {
     // reads that mapping rather than a member, asked in one batch.
     const receivers = lookups.flatMap((lookup) => lookup.receiver === undefined ? [] : [lookup.receiver]);
     const mapped = new Set();
-    typesAt(project, receivers).forEach((type, index) => {
+    project.queries.typesAt(receivers).forEach((type, index) => {
         const receiver = receivers[index];
-        if (receiver !== undefined && type !== undefined && readsAMapping(project, type)) {
+        if (receiver !== undefined &&
+            type !== undefined &&
+            isAnswered(type) &&
+            readsAMapping(project, type)) {
             mapped.add(receiver);
         }
     });

package/dist/src/report.js

@@ -218,7 +218,9 @@ export function buildReport(input) {
         configurations: [...input.configurations]
             .sort((a, b) => compare(a.id, b.id))
             .map((one) => ({ id: one.id, project: one.project })),
-        configurations_not_built: [],
+        configurations_not_built: [...input.notBuilt]
+            .sort((a, b) => compare(a.id, b.id))
+            .map((one) => ({ id: one.id, project: one.project, error: one.error })),
         consumers: { declared: loaded.length + unavailable.length, loaded, unavailable },
         findings,
         edge_evaluations: input.result.edgeEvaluations.map(wireEvaluation).sort(byEdge),

package/dist/src/reporters/annotations.js

@@ -1,4 +1,5 @@
 import { fails } from "../config.js";
+import { coalesced } from "../json-chunks.js";
 import { KINDS } from "../kinds.js";
 /** The escapes a workflow command's message needs, so a line break does not end the command. */
 const DATA_ESCAPES = { "%": "%25", "\r": "%0D", "\n": "%0A" };
@@ -28,9 +29,12 @@ function command(level, at, endLine, title, message) {
  * because its kind is fixed on at the failing severity.
  */
 export function annotations(report, options) {
-    const lines = report.findings.map((found) => command(fails(found.severity, options.failOn) ? "error" : "warning", found.position, found.position.end_line, `${found.code} ${found.kind}`, found.message));
-    for (const stale of report.stale_suppressions) {
-        lines.push(command("error", stale.position, stale.position.line, `${stale.code} ${kindName(stale.code)}`, stale.message));
-    }
-    return lines.map((line) => `${line}\n`).join("");
+    return coalesced((function* lines() {
+        for (const found of report.findings) {
+            yield `${command(fails(found.severity, options.failOn) ? "error" : "warning", found.position, found.position.end_line, `${found.code} ${found.kind}`, found.message)}\n`;
+        }
+        for (const stale of report.stale_suppressions) {
+            yield `${command("error", stale.position, stale.position.line, `${stale.code} ${kindName(stale.code)}`, stale.message)}\n`;
+        }
+    })());
 }

package/dist/src/reporters/json.js

@@ -1,4 +1,5 @@
+import { jsonChunks } from "../json-chunks.js";
 /** The indentation of the report document, which with the schema's member order fixes its bytes. */
 const INDENT = 2;
-/** The report document itself: the report, indented, with a closing newline. */
-export const json = (report) => `${JSON.stringify(report, null, INDENT)}\n`;
+/** The report document itself, in pieces: the report, indented, with a closing newline. */
+export const json = (report) => jsonChunks(report, INDENT);

package/dist/src/reporters/sarif.js

@@ -1,3 +1,4 @@
+import { jsonChunks } from "../json-chunks.js";
 import { KINDS } from "../kinds.js";
 import { lineHashes, symbolFingerprint } from "./fingerprint.js";
 import { RenderError } from "./reporter.js";
@@ -236,5 +237,5 @@ export function sarif(report, options) {
             },
         ],
     };
-    return `${JSON.stringify(log, null, INDENT)}\n`;
+    return jsonChunks(log, INDENT);
 }

package/dist/src/reporters/template.js

@@ -6,6 +6,7 @@
  * and `println`. Any other function, `define`, `template` and `block` are refused at parse,
  * and a member the document does not carry fails the rendering.
  */
+import { CHUNK_LENGTH } from "../json-chunks.js";
 import { RenderError } from "./reporter.js";
 import { utf8Bytes } from "./sha256.js";
 /** A template that does not parse, which refuses the invocation before any analysis. */
@@ -735,10 +736,22 @@ function call(name, args) {
 /** One execution of a template over a document. */
 class Execution {
     scopes;
-    out = "";
+    /** The rendering so far, in pieces of about {@link CHUNK_LENGTH}, the last still growing. */
+    pieces = [""];
     constructor(root) {
         this.scopes = [new Map([["$", root]])];
     }
+    write(text) {
+        const last = this.pieces.length - 1;
+        const held = (this.pieces[last] ?? "") + text;
+        if (held.length >= CHUNK_LENGTH) {
+            this.pieces[last] = held;
+            this.pieces.push("");
+        }
+        else {
+            this.pieces[last] = held;
+        }
+    }
     lookup(name) {
         for (let i = this.scopes.length - 1; i >= 0; i -= 1) {
             const scope = this.scopes[i];
@@ -842,12 +855,12 @@ class Execution {
         for (const node of nodes) {
             switch (node.k) {
                 case "text":
-                    this.out += node.text;
+                    this.write(node.text);
                     break;
                 case "action": {
                     const value = this.pipeline(node.pipe, dot, true);
                     if (node.pipe.vars.length === 0) {
-                        this.out += formatted(value, false);
+                        this.write(formatted(value, false));
                     }
                     break;
                 }
@@ -925,12 +938,40 @@ class Execution {
     }
 }
 /**
- * The template's rendering of one document. The rendering is built whole, so a template
- * that fails partway renders nothing, and the failure names what it could not evaluate.
+ * One document as the JSON value it encodes: what `JSON.stringify` would write for it,
+ * read back, without writing it. A member holding nothing is left out, and an array
+ * element holding nothing, like a number that is not finite, is null.
+ */
+function plainOf(value) {
+    if (Array.isArray(value)) {
+        return value.map((element) => plainOf(element) ?? null);
+    }
+    if (typeof value === "object" && value !== null) {
+        const held = {};
+        for (const [key, member] of Object.entries(value)) {
+            const plain = plainOf(member);
+            if (plain !== undefined) {
+                held[key] = plain;
+            }
+        }
+        return held;
+    }
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? value : null;
+    }
+    if (typeof value === "string" || typeof value === "boolean" || value === null) {
+        return value;
+    }
+    return undefined;
+}
+/**
+ * The template's rendering of one document, in pieces of about {@link CHUNK_LENGTH}.
+ * The rendering is complete before it is answered, so a template that fails partway
+ * renders nothing, and the failure names what it could not evaluate.
  */
 export function renderTemplate(template, document) {
-    const root = JSON.parse(JSON.stringify(document));
+    const root = plainOf(document) ?? null;
     const execution = new Execution(root);
     execution.run(template.nodes, root);
-    return execution.out;
+    return execution.pieces.filter((piece) => piece !== "");
 }

package/dist/src/reporters/text.js

@@ -1,3 +1,4 @@
+import { coalesced } from "../json-chunks.js";
 /** The kind token and the confidence a stale suppression is rendered with, both fixed. */
 const STALE_KIND = "suppression";
 const STALE_CONFIDENCE = "certain";
@@ -24,11 +25,12 @@ function summary(totals) {
  * summary is deliberately not in that shape, so a filter for finding lines yields exactly
  * them. Nothing else is written: no timestamp, duration or host detail.
  */
-export const text = (report) => {
-    const lines = report.findings.map((found) => `${found.position.path}:${String(found.position.line)}:${String(found.position.column)}: ${found.symbol.kind} ${found.symbol.name}: ${found.message} [${found.confidence}] (${found.code})`);
+export const text = (report) => coalesced((function* lines() {
+    for (const found of report.findings) {
+        yield `${found.position.path}:${String(found.position.line)}:${String(found.position.column)}: ${found.symbol.kind} ${found.symbol.name}: ${found.message} [${found.confidence}] (${found.code})\n`;
+    }
     for (const stale of report.stale_suppressions) {
-        lines.push(`${stale.position.path}:${String(stale.position.line)}:${String(stale.position.column)}: ${STALE_KIND} ${stale.symbol}: ${stale.message} [${STALE_CONFIDENCE}] (${stale.code})`);
+        yield `${stale.position.path}:${String(stale.position.line)}:${String(stale.position.column)}: ${STALE_KIND} ${stale.symbol}: ${stale.message} [${STALE_CONFIDENCE}] (${stale.code})\n`;
     }
-    lines.push(summary(report.totals));
-    return `${lines.join("\n")}\n`;
-};
+    yield `${summary(report.totals)}\n`;
+})());

package/dist/src/roots.js

@@ -12,6 +12,7 @@ import { entryPoints } from "./entry-points.js";
 import { globExpression } from "./glob.js";
 import { nodeKey } from "./inventory.js";
 import { byPosition } from "./position.js";
+import { UNANSWERED } from "./query.js";
 import { sourceFilesOf } from "./source-files.js";
 /** Whether a configured string carries either special character. */
 function isPattern(text) {
@@ -142,7 +143,7 @@ export function roots(project, held, targetRoot, options) {
     for (const point of entryPoints(project, files, options.testFiles)) {
         enter(point.file, point.rule, point.source, point.exports);
     }
-    const exportsOf = exportTables(project, held, [
+    const { tables: exportsOf, answered } = exportTables(project, held, [
         ...entered.filter((entry) => entry.exports).map((entry) => entry.file),
         ...published,
     ]);
@@ -171,41 +172,56 @@ export function roots(project, held, targetRoot, options) {
         const site = left === undefined || right === undefined ? 0 : byPosition(left, right);
         return site || compare(a.kind, b.kind) || compare(a.source, b.source);
     });
-    return { configFile: project.configFile, liveUnderReachability: ordered, unmatched };
+    return {
+        configFile: project.configFile,
+        liveUnderReachability: ordered,
+        unmatched,
+        unanswered: answered ? [] : held.symbols.map((symbol) => symbol.id),
+    };
 }
 /**
  * Every declaration each file's module exports, by the file's name: the declaration
  * each name of the export table is, and every link of a re-export's chain. A name
- * whose declaration is outside the project's own files belongs to another program
- * and names nothing here.
- *
- * One batch resolves every file to its module and one request per module reads
- * its export table, star re-exports resolved into it. A file that is no module
- * exports nothing.
+ * whose declaration is outside the project's own files names nothing here. One batch
+ * resolves every file to its module and one request per module reads its export
+ * table, star re-exports resolved into it. A file that is no module exports nothing.
+ * `answered` is false where the checker left a table or a link of a chain unanswered.
  */
 function exportTables(project, held, wanted) {
     const unique = [...new Map(wanted.map((file) => [file.fileName, file])).values()];
     const tables = new Map();
+    let answered = true;
     if (unique.length === 0) {
-        return tables;
+        return { tables, answered };
     }
     const modules = project.symbolsAt(unique.map((file) => project.handle(file)));
     const chains = aliasChains(project, held);
+    const topLevel = (file) => {
+        const fileId = held.declarations.get(nodeKey(file, file));
+        return held.symbols.filter((symbol) => symbol.parent === fileId).map((symbol) => symbol.id);
+    };
     unique.forEach((file, index) => {
         const module = modules[index];
         if (module === undefined) {
             tables.set(file.fileName, []);
             return;
         }
+        const table = module === UNANSWERED ? UNANSWERED : project.queries.exportsOfModule(module);
+        if (table === UNANSWERED) {
+            answered = false;
+            tables.set(file.fileName, topLevel(file));
+            return;
+        }
         const ids = new Set();
-        for (const exported of project.checker.getExportsOfModule(module)) {
+        for (const exported of table) {
             for (const target of chains.chainOf(exported)) {
+                answered &&= !target.guessed;
                 ids.add(target.id);
             }
         }
         tables.set(file.fileName, [...ids]);
     });
-    return tables;
+    return { tables, answered };
 }
 /** The kinds of container whose export table, not its members' visibility, says what it publishes. */
 const EXPORTING_CONTAINERS = new Set(["file", "namespace"]);

package/dist/src/serialization-contract.js

@@ -16,6 +16,7 @@ import { classMembers, memberComponent, typesAt } from "./class-members.js";
 import { names, namesADeclaration, resolveEntries, spelledEntry, } from "./configured-declarations.js";
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
+import { must } from "./query.js";
 import { valueReach } from "./value-reach.js";
 /** The serializer every run reads, whatever the configuration names. */
 const JSON_STRINGIFY = { shape: "global", global: "JSON.stringify" };
@@ -185,12 +186,13 @@ function erasedParameters(project, parameters) {
         if (!parameter.rest) {
             return (type.flags & ERASED) !== 0;
         }
-        const [element] = type.isTypeReference() ? project.checker.getTypeArguments(type) : [];
+        const [element] = must(project.queries.typeArguments(type));
         return element !== undefined && (element.flags & ERASED) !== 0;
     });
     const bySymbol = new Map();
     project
         .symbolsAt(erased.map((parameter) => project.handle(parameter.name)))
+        .map(must)
         .forEach((symbol, index) => {
         const parameter = erased[index];
         if (symbol !== undefined && parameter !== undefined) {
@@ -206,11 +208,11 @@ function handedOn(project, sites, erased, invocationOf) {
         .filter((value) => spellings.has(value.name.getText()))
         .map((value) => ({ site, argument: index, value }))));
     const plain = candidates.filter((one) => !one.value.shorthand);
-    const resolved = project.symbolsAt(plain.map((one) => project.handle(one.value.name)));
+    const resolved = project.symbolsAt(plain.map((one) => project.handle(one.value.name))).map(must);
     const symbolOf = new Map(plain.map((one, index) => [one, resolved[index]]));
     return candidates.flatMap((one) => {
         const symbol = one.value.shorthand
-            ? project.shorthandValueAt(project.handle(one.value.name))
+            ? must(project.shorthandValueAt(project.handle(one.value.name)))
             : symbolOf.get(one);
         const parameter = symbol === undefined ? undefined : erased.get(symbol.id);
         return parameter === undefined ? [] : [{ parameter, site: one.site, argument: one.argument }];
@@ -226,8 +228,8 @@ function handedOn(project, sites, erased, invocationOf) {
  */
 function destinations(input, chains, walked) {
     const { project, held } = input;
-    const checker = project.checker;
-    const own = new Set(project.ownSourceFiles().map((file) => file.fileName));
+    const queries = project.queries;
+    const own = project.ownPaths();
     const named = resolveEntries(project, held, [JSON_STRINGIFY, ...input.ts.serializers]).filter(namesADeclaration);
     const forms = new Map();
     for (const site of walked.sites) {
@@ -259,7 +261,7 @@ function destinations(input, chains, walked) {
         if (form !== undefined &&
             method !== undefined &&
             outside(method) &&
-            FUNCTION_INTERFACES.has(method.getParent()?.name ?? "")) {
+            FUNCTION_INTERFACES.has(must(project.queries.parentOf(method))?.name ?? "")) {
             return form.invocation;
         }
         return { callee: call.expression, arguments: call.arguments, indirect: false };
@@ -275,14 +277,14 @@ function destinations(input, chains, walked) {
             const invoked = invocation(call);
             // Through a method of the prototype the resolved signature is the method's, so
             // the parameters are read off the callee's own signatures, any one erasing.
-            const type = invoked.indirect ? checker.getTypeAtLocation(invoked.callee) : undefined;
+            const type = invoked.indirect ? must(queries.typeAt(invoked.callee)) : undefined;
             const signatures = invoked.indirect
                 ? type === undefined
                     ? []
-                    : checker.getSignaturesOfType(type, SignatureKind.Call)
-                : [checker.getResolvedSignature(call)].filter((one) => one !== undefined);
+                    : must(queries.signaturesOf(type, SignatureKind.Call))
+                : [must(queries.resolvedSignature(call))].filter((one) => one !== undefined);
             indexes = new Set(invoked.arguments.flatMap((_unused, index) => signatures.some((signature) => {
-                const parameter = checker.getParameterType(signature, index);
+                const parameter = must(queries.parameterType(signature, index));
                 return parameter !== undefined && (parameter.flags & ERASED) !== 0;
             })
                 ? [index]