@cplieger/deadset-ts 3.13.0 → 4.0.0

package/dist/src/intra-function-parts.js

@@ -4,10 +4,10 @@
  * call sites that use or discard it, each statement control flow cannot reach, each
  * write to a local that no read reaches, and each case an earlier case covers.
  */
-import { isArrowFunction, isAwaitExpression, isBigIntLiteral, isBinaryExpression, isBlock, isBreakStatement, isCallExpression, isCaseClause, isClassDeclaration, isClassExpression, isContinueStatement, isDecorator, isDefaultClause, isEmptyStatement, isExportAssignment, isExportSpecifier, isExpressionStatement, isFunctionDeclaration, isHeritageClause, isIdentifier, isIfStatement, isImportClause, isImportSpecifier, isInterfaceDeclaration, isMethodDeclaration, isModuleDeclaration, isNamespaceImport, isNoSubstitutionTemplateLiteral, isNumericLiteral, isParenthesizedExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isReturnStatement, isShorthandPropertyAssignment, isStringLiteral, isSwitchStatement, isThrowStatement, isTypeAliasDeclaration, isVariableStatement, isVoidExpression, NodeFlags, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { isArrowFunction, isAwaitExpression, isBigIntLiteral, isBinaryExpression, isBlock, isBreakStatement, isCallExpression, isCaseClause, isClassDeclaration, isClassExpression, isContinueStatement, isDecorator, isDefaultClause, isEmptyStatement, isExportAssignment, isExportSpecifier, isExpressionStatement, isFunctionDeclaration, isHeritageClause, isIdentifier, isIfStatement, isImportClause, isImportSpecifier, isInterfaceDeclaration, isMethodDeclaration, isModuleDeclaration, isNamespaceImport, isNoSubstitutionTemplateLiteral, isNumericLiteral, isParenthesizedExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isQualifiedName, isReturnStatement, isShorthandPropertyAssignment, isStringLiteral, isSwitchStatement, isThrowStatement, isTypeAliasDeclaration, isTypeReferenceNode, isVariableStatement, isVoidExpression, NodeFlags, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { nodeKey } from "./inventory.js";
 import { positionKey, renderPosition } from "./position.js";
-import { DEFAULT_BATCH_CAP } from "./references.js";
+import { isAnswered, UNANSWERED } from "./query.js";
 import { signatureOf } from "./signatures.js";
 /** The codes of the parts this module reads. */
 export const UNUSED_PARAMETER = "DS1801";
@@ -195,8 +195,15 @@ function extendedNames(files) {
     const visit = (node) => {
         if (isHeritageClause(node) && node.token === SyntaxKind.ExtendsKeyword) {
             for (const type of node.types) {
-                const expression = unwrapped(type.expression);
-                const named = isPropertyAccessExpression(expression) ? expression.name : expression;
+                // A class's clause holds expressions; an interface's holds type references.
+                let named;
+                if (isTypeReferenceNode(type)) {
+                    named = isQualifiedName(type.typeName) ? type.typeName.right : type.typeName;
+                }
+                else {
+                    const expression = unwrapped(type.expression);
+                    named = isPropertyAccessExpression(expression) ? expression.name : expression;
+                }
                 if (isIdentifier(named)) {
                     names.add(named.text);
                 }
@@ -230,31 +237,33 @@ function hierarchyFixes(declared, extended) {
     }
     return owner.name !== undefined && extended.has(owner.name.text);
 }
-/** The symbol identifier each of a batch of identifiers resolves to, where the batch answers. */
+/**
+ * The symbol identifier each of a batch of identifiers resolves to, where the batch
+ * resolves it, and {@link UNANSWERED} where the checker did not answer.
+ */
 function resolvedIds(project, nodes) {
     const ids = new Map();
-    for (let from = 0; from < nodes.length; from += DEFAULT_BATCH_CAP) {
-        const run = nodes.slice(from, from + DEFAULT_BATCH_CAP);
-        project.symbolsAt(run.map((node) => project.handle(node))).forEach((symbol, index) => {
-            const node = run[index];
-            if (symbol !== undefined && node !== undefined) {
-                ids.set(node, symbol.id);
-            }
-        });
-    }
+    project.symbolsAt(nodes.map((node) => project.handle(node))).forEach((symbol, index) => {
+        const node = nodes[index];
+        if (node !== undefined && symbol !== undefined) {
+            ids.set(node, symbol === UNANSWERED ? UNANSWERED : symbol.id);
+        }
+    });
     return ids;
 }
 /**
  * Whether one identifier reads the binding a name node declares: it resolves to the
- * same symbol, or the checker resolves it to nothing, which is read as a use rather than
- * risk a finding; a shorthand property reads the binding of its own name.
+ * same symbol, or the checker resolves it to nothing or does not answer for either
+ * name, which is read as a use rather than risk a finding; a shorthand property reads
+ * the binding of its own name.
  */
 function readsBinding(use, declared, ids) {
     if (isShorthandPropertyAssignment(use.parent)) {
         return true;
     }
     const at = ids.get(use);
-    return at === undefined || at === ids.get(declared);
+    const own = ids.get(declared);
+    return at === undefined || at === UNANSWERED || own === UNANSWERED || at === own;
 }
 /**
  * The parts of one project's own declarations. `references` are the project's own
@@ -575,9 +584,17 @@ function resultParts(project, root, sites, references, calls) {
         if (!discardedAt.has(id) || generator || !returnsAValue(signature)) {
             continue;
         }
-        const typed = project.checker.getSignatureFromDeclaration(signature);
-        const result = typed === undefined ? undefined : project.checker.getReturnTypeOfSignature(typed);
-        if (result === undefined || NO_VALUE.has(project.checker.typeToString(result))) {
+        // A question the checker leaves unanswered withholds the finding.
+        const typed = project.queries.signatureOf(signature);
+        if (typed === undefined || !isAnswered(typed)) {
+            continue;
+        }
+        const result = project.queries.returnTypeOf(typed);
+        if (result === undefined || !isAnswered(result)) {
+            continue;
+        }
+        const spelled = project.queries.typeToString(result);
+        if (!isAnswered(spelled) || NO_VALUE.has(spelled)) {
             continue;
         }
         const at = signature.type ?? node.name ?? node;

package/dist/src/inventory.js

@@ -2,6 +2,7 @@ import { isClassDeclaration, isComputedPropertyName, isEnumDeclaration, isEnumMe
 import { dirnamePath, joinPath, relativePath } from "./paths.js";
 import { byPosition, positionKey, renderPosition } from "./position.js";
 import { computedComponent, nameComponent, renderRef } from "./ref.js";
+import { isAnswered, UNANSWERED } from "./query.js";
 const MANIFEST = "package.json";
 /**
  * Resolves each file's package scope: the name of the nearest manifest at or above
@@ -493,12 +494,28 @@ export function inventory(project, host, targetRoot) {
     const handles = batched.map((node) => project.handle(node));
     const resolved = project.symbolsAt(handles);
     const symbolOf = new Map();
+    // A scope or a container whose symbol or table went unanswered keeps what its syntax
+    // declares, and everything under it is recorded unanswered.
+    const unansweredOwners = new Set();
     batched.forEach((node, index) => {
         const symbol = resolved[index];
-        if (symbol !== undefined) {
+        if (typeof symbol === "object") {
             symbolOf.set(node, symbol);
         }
     });
+    resolved.slice(0, exportScopes.length).forEach((symbol, index) => {
+        const scope = exportScopes[index];
+        if (symbol === UNANSWERED && scope !== undefined) {
+            unansweredOwners.add(scope.owner);
+        }
+    });
+    containers
+        .filter((container) => container.nameNode !== undefined)
+        .forEach((container, index) => {
+        if (resolved[exportScopes.length + index] === UNANSWERED) {
+            unansweredOwners.add(container.owner);
+        }
+    });
     let exportTables = 0;
     for (const scope of exportScopes) {
         const symbol = symbolOf.get(scope.nameNode);
@@ -506,7 +523,11 @@ export function inventory(project, host, targetRoot) {
             continue;
         }
         exportTables += 1;
-        for (const [, exported] of symbol.getExports()) {
+        const table = project.queries.exportsOf(symbol);
+        if (!isAnswered(table)) {
+            unansweredOwners.add(scope.owner);
+        }
+        for (const [, exported] of isAnswered(table) ? table : []) {
             for (const declaration of exported.declarations) {
                 const held = project.declarationAt(declaration);
                 if (held === undefined) {
@@ -527,11 +548,23 @@ export function inventory(project, host, targetRoot) {
         if (symbol !== undefined) {
             if (!container.membersAreExports) {
                 memberTables += 1;
-                outsideOwnFiles += readTable(container, symbol.getMembers(), seen, false);
+                const table = project.queries.membersOf(symbol);
+                if (isAnswered(table)) {
+                    outsideOwnFiles += readTable(container, table, seen, false);
+                }
+                else {
+                    unansweredOwners.add(container.owner);
+                }
             }
             if (container.membersAreExports || container.isClass) {
                 memberTables += 1;
-                outsideOwnFiles += readTable(container, symbol.getExports(), seen, container.isClass);
+                const table = project.queries.exportsOf(symbol);
+                if (isAnswered(table)) {
+                    outsideOwnFiles += readTable(container, table, seen, container.isClass);
+                }
+                else {
+                    unansweredOwners.add(container.owner);
+                }
             }
         }
         completeFromTree(container, seen);
@@ -635,6 +668,7 @@ export function inventory(project, host, targetRoot) {
         }
         return undefined;
     }
+    const byId = new Map(building.map((record) => [positionKey(record.position), record]));
     const symbols = building
         .map(render)
         .sort((a, b) => byPosition(a.position, b.position) || (a.ref < b.ref ? -1 : 1));
@@ -645,8 +679,47 @@ export function inventory(project, host, targetRoot) {
         cost: { batches: 1, exportTables, memberTables },
         starReExports,
         outsideOwnFiles,
+        unanswered: symbols
+            .filter((symbol) => underUnanswered(byId.get(symbol.id), unansweredOwners))
+            .map((symbol) => symbol.id),
+        byName: namesOf(building),
     };
 }
+/** Whether one declaration is, or is declared under, a scope or container left unanswered. */
+function underUnanswered(record, owners) {
+    for (let at = record; at !== undefined; at = at.parent) {
+        if (owners.has(at)) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Every declaration but a file, by each name a use may spell it with. */
+function namesOf(building) {
+    const byName = new Map();
+    for (const record of building) {
+        if (record.kind === "file") {
+            continue;
+        }
+        const id = positionKey(record.position);
+        const names = record.typeParameter === undefined
+            ? [record.component.text, record.localName]
+            : [record.typeParameter];
+        for (const name of new Set(names)) {
+            if (name === undefined) {
+                continue;
+            }
+            const ids = byName.get(name);
+            if (ids === undefined) {
+                byName.set(name, [id]);
+            }
+            else if (!ids.includes(id)) {
+                ids.push(id);
+            }
+        }
+    }
+    return byName;
+}
 /** The chain of components that names one declaration, read from the module inward. */
 function chainOf(record) {
     return [...record.parentChain, record.component];
@@ -691,3 +764,11 @@ function refOf(record, chain) {
         ...(record.typeParameter === undefined ? {} : { typeParameter: record.typeParameter }),
     });
 }
+/**
+ * Every declaration of an inventory other than a file, by each name a use may spell it
+ * with. It is how a reference the checker could not resolve is still counted, as a
+ * reference to every declaration that bears the name it spells.
+ */
+export function declarationsByName(held) {
+    return held.byName;
+}

package/dist/src/json-chunks.js

@@ -0,0 +1,76 @@
+/**
+ * A document written in pieces, so no stage of writing it holds the whole document as
+ * one string: a string has a length limit far below what a large report reaches.
+ */
+/** The length a piece grows to before it is handed on. */
+export const CHUNK_LENGTH = 1 << 16;
+/**
+ * The pieces of `pieces` joined into runs of about {@link CHUNK_LENGTH}, the last one
+ * shorter. A piece longer than that is handed on whole.
+ */
+export function* coalesced(pieces) {
+    let held = [];
+    let length = 0;
+    for (const piece of pieces) {
+        held.push(piece);
+        length += piece.length;
+        if (length >= CHUNK_LENGTH) {
+            yield held.join("");
+            held = [];
+            length = 0;
+        }
+    }
+    if (length > 0) {
+        yield held.join("");
+    }
+}
+/** Whether `JSON.stringify` writes nothing for a value where an object member holds it. */
+function omitted(value) {
+    return value === undefined || typeof value === "function" || typeof value === "symbol";
+}
+function* valueOf(value, prefix, step) {
+    // With no indentation the document is compact: no line breaks, and no space after a key.
+    const nl = step === "" ? "" : "\n";
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            yield "[]";
+            return;
+        }
+        const inner = prefix + step;
+        yield "[";
+        for (let at = 0; at < value.length; at += 1) {
+            yield at === 0 ? `${nl}${inner}` : `,${nl}${inner}`;
+            const element = value[at];
+            yield* omitted(element) ? ["null"] : valueOf(element, inner, step);
+        }
+        yield `${nl}${prefix}]`;
+        return;
+    }
+    if (typeof value === "object" && value !== null) {
+        const inner = prefix + step;
+        let first = true;
+        for (const [key, member] of Object.entries(value)) {
+            if (omitted(member)) {
+                continue;
+            }
+            yield `${first ? "{" : ","}${nl}${inner}${JSON.stringify(key)}:${step === "" ? "" : " "}`;
+            first = false;
+            yield* valueOf(member, inner, step);
+        }
+        yield first ? "{}" : `${nl}${prefix}}`;
+        return;
+    }
+    yield JSON.stringify(value);
+}
+/**
+ * One JSON document in pieces whose concatenation is the value as `JSON.stringify`
+ * writes it at `indent` spaces, followed by a newline. The value is plain data: objects,
+ * arrays, strings, finite numbers, booleans and null, an object member holding nothing
+ * being left out as `JSON.stringify` leaves it out.
+ */
+export function jsonChunks(value, indent) {
+    return coalesced((function* document() {
+        yield* valueOf(value, "", " ".repeat(indent));
+        yield "\n";
+    })());
+}

package/dist/src/partial.js

@@ -0,0 +1,23 @@
+/** A count with its noun, so a line reads for one as well as for several. */
+function counted(n, one, many) {
+    return `${String(n)} ${n === 1 ? one : many}`;
+}
+/**
+ * One line per configuration the run dropped, and one counting the questions the checker
+ * left unanswered by project, so a reader of the error stream sees where the analysis was
+ * partial. The lines carry no prefix; the caller writes them as its own diagnostics.
+ */
+export function partialNotes(partial) {
+    const notes = [...partial.notBuilt]
+        .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
+        .map((one) => `the derived configuration ${one.id} was not built and is not analyzed: ${one.error}`);
+    if (partial.unanswered.length > 0) {
+        const byProject = new Map();
+        for (const question of partial.unanswered) {
+            byProject.set(question.configFile, (byProject.get(question.configFile) ?? 0) + 1);
+        }
+        const where = [...byProject].map(([configFile, n]) => `${configFile}: ${String(n)}`).join(", ");
+        notes.push(`the checker answered ${counted(partial.unanswered.length, "question", "questions")} with a failure (${where}); every declaration an answer could have kept live is kept live and reported by nothing`);
+    }
+    return notes;
+}

package/dist/src/query.js

@@ -0,0 +1,207 @@
+/**
+ * The one way the analysis asks a project's checker anything. A question the compiler
+ * server panics on answers {@link UNANSWERED}, and a batch it panics on whole is asked
+ * again one question at a time; every caller reads an unanswered question as keeping a
+ * declaration live, and each is recorded once so a run can say where it was partial.
+ * Questions of one accessor about many locations go out together, through the array
+ * form where it has one and otherwise as one batch, one round trip per capped run.
+ */
+import { isIdentifier } from "@typescript/native/unstable/ast";
+/**
+ * The greatest number of locations one batched request asks about. A batch is
+ * answered by an array of its own length, so an uncapped batch over a large file
+ * makes one answer proportional to that file. The figure 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;
+/** The answer to a question the checker could not answer. */
+export const UNANSWERED = Symbol("unanswered");
+/** Whether one answer is an answer. */
+export function isAnswered(answer) {
+    return answer !== UNANSWERED;
+}
+/**
+ * The stop a pass raises where it cannot go on without an answer the checker did not
+ * give. Whoever runs the pass catches it and keeps live everything the pass could
+ * have kept live, so a pass that throws it never computes a finding from the gap.
+ */
+export class Unanswerable extends Error {
+    constructor() {
+        super("the checker did not answer a question this pass needs");
+        this.name = "Unanswerable";
+    }
+}
+/** The answer itself, or the stop of a pass that cannot go on without it. */
+export function must(answer) {
+    if (answer === UNANSWERED) {
+        throw new Unanswerable();
+    }
+    return answer;
+}
+/**
+ * Whether one failure is the server's report that a question panicked. The server
+ * recovers the panic and answers the question with its text, so the session
+ * survives it; any other failure, a closed channel among them, is not one this layer
+ * contains.
+ */
+function panicked(error) {
+    return error instanceof Error && error.message.startsWith("panic:");
+}
+const ASK_DIRECTLY = (_accessor, _locations, question) => question();
+/** What one run could not ask, each question once. */
+export class UnansweredLog {
+    #seen = new Map();
+    /** Records one question, once however many times it is asked. */
+    note(question) {
+        const key = [question.configFile, question.accessor, question.location].join("\u0000");
+        if (!this.#seen.has(key)) {
+            this.#seen.set(key, question);
+        }
+    }
+    /** Every question recorded, in the order first asked. */
+    get questions() {
+        return [...this.#seen.values()];
+    }
+}
+function nodeLocation(node) {
+    return `${node.getSourceFile().fileName}:${String(node.pos)}`;
+}
+function symbolLocation(symbol) {
+    return `symbol ${String(symbol.id)} ${symbol.name}`;
+}
+function typeLocation(type) {
+    return `type ${String(type.id)}`;
+}
+/**
+ * The guarded questions over one project's checker. `configFile` names the project
+ * in the log, `batch` sends many questions in one round trip, `log` is the run's,
+ * shared by every project, and every question is put through `ask`.
+ */
+export function queriesOf(checker, configFile, batch, log, ask = ASK_DIRECTLY) {
+    const note = (accessor, location) => {
+        log.note({ configFile, accessor, location });
+    };
+    const one = (accessor, location, question) => {
+        try {
+            return ask(accessor, () => [location()], question);
+        }
+        catch (error) {
+            if (!panicked(error)) {
+                throw error;
+            }
+            note(accessor, location());
+            return UNANSWERED;
+        }
+    };
+    /**
+     * One question per item of `items`, in runs of at most `cap`, each run in one
+     * round trip. A run fails as a whole only where the server panics outside any one
+     * question, and is then asked one question at a time.
+     */
+    const each = (accessor, items, cap, locate, question, alone) => {
+        function* guarded(item) {
+            try {
+                return yield* ask(accessor, () => [locate(item)], () => question(item));
+            }
+            catch (error) {
+                if (!panicked(error)) {
+                    throw error;
+                }
+                note(accessor, locate(item));
+                return UNANSWERED;
+            }
+        }
+        const answers = [];
+        for (let from = 0; from < items.length; from += cap) {
+            const run = items.slice(from, from + cap);
+            try {
+                answers.push(...batch(run.map(guarded)));
+            }
+            catch (error) {
+                if (!panicked(error)) {
+                    throw error;
+                }
+                answers.push(...run.map((item) => one(accessor, () => locate(item), () => alone(item))));
+            }
+        }
+        return answers;
+    };
+    /**
+     * One accessor's array form over `items`, in runs of at most `cap`. A run the server
+     * panics on is asked again as two halves, down to one item, so the items it can
+     * answer are answered and only an item that panics alone is unanswered.
+     */
+    const many = (accessor, items, cap, locate, question) => {
+        const answers = [];
+        const settle = (run) => {
+            try {
+                answers.push(...ask(accessor, () => run.map(locate), () => question(run)));
+                return;
+            }
+            catch (error) {
+                if (!panicked(error)) {
+                    throw error;
+                }
+            }
+            const [only] = run;
+            if (run.length === 1 && only !== undefined) {
+                note(accessor, locate(only));
+                answers.push(UNANSWERED);
+                return;
+            }
+            const half = Math.ceil(run.length / 2);
+            settle(run.slice(0, half));
+            settle(run.slice(half));
+        };
+        for (let from = 0; from < items.length; from += cap) {
+            settle(items.slice(from, from + cap));
+        }
+        return answers;
+    };
+    return {
+        symbolsAt: (nodes, cap = DEFAULT_BATCH_CAP) => many("getSymbolAtLocation", nodes, cap, nodeLocation, (run) => checker.getSymbolAtLocation(run)),
+        resolvedSymbol: (node) => isIdentifier(node)
+            ? one("getResolvedSymbol", () => nodeLocation(node), () => checker.getResolvedSymbol(node))
+            : undefined,
+        shorthandValue: (node) => one("getShorthandAssignmentValueSymbol", () => nodeLocation(node), () => checker.getShorthandAssignmentValueSymbol(node)),
+        immediateAliased: (symbol) => one("getImmediateAliasedSymbol", () => symbolLocation(symbol), () => checker.getImmediateAliasedSymbol(symbol)),
+        aliased: (symbol) => one("getAliasedSymbol", () => symbolLocation(symbol), () => checker.getAliasedSymbol(symbol)),
+        resolveName: (name, meaning, location, excludeGlobals) => one("resolveName", () => (location === undefined ? `name ${name}` : nodeLocation(location)), () => checker.resolveName(name, meaning, location, excludeGlobals)),
+        exportsOfModule: (module) => one("getExportsOfModule", () => symbolLocation(module), () => checker.getExportsOfModule(module)),
+        membersOf: (symbol) => one("getMembers", () => symbolLocation(symbol), () => symbol.getMembers()),
+        exportsOf: (symbol) => one("getExports", () => symbolLocation(symbol), () => symbol.getExports()),
+        parentOf: (symbol) => one("getParent", () => symbolLocation(symbol), () => symbol.getParent()),
+        jsDocTags: (symbols, cap = DEFAULT_BATCH_CAP) => each("getJsDocTags", symbols, cap, symbolLocation, (symbol) => symbol.getJsDocTags.gen(checker), (symbol) => symbol.getJsDocTags(checker)),
+        typesAt: (nodes, cap = DEFAULT_BATCH_CAP) => many("getTypeAtLocation", nodes, cap, nodeLocation, (run) => checker.getTypeAtLocation(run)),
+        typeAt: (node) => one("getTypeAtLocation", () => nodeLocation(node), () => checker.getTypeAtLocation(node)),
+        typesOfSymbols: (symbols, cap = DEFAULT_BATCH_CAP) => many("getTypeOfSymbol", symbols, cap, symbolLocation, (run) => checker.getTypeOfSymbol(run)),
+        typeOfSymbol: (symbol) => one("getTypeOfSymbol", () => symbolLocation(symbol), () => checker.getTypeOfSymbol(symbol)),
+        declaredTypeOf: (symbol) => one("getDeclaredTypeOfSymbol", () => symbolLocation(symbol), () => checker.getDeclaredTypeOfSymbol(symbol)),
+        contextualTypes: (nodes, cap = DEFAULT_BATCH_CAP) => each("getContextualType", nodes, cap, nodeLocation, (node) => checker.getContextualType.gen(node), (node) => checker.getContextualType(node)),
+        propertiesOf: (type) => one("getPropertiesOfType", () => typeLocation(type), () => checker.getPropertiesOfType(type)),
+        indexInfosOf: (type) => one("getIndexInfosOfType", () => typeLocation(type), () => checker.getIndexInfosOfType(type)),
+        typeArguments: (type) => type.isTypeReference()
+            ? one("getTypeArguments", () => typeLocation(type), () => checker.getTypeArguments(type))
+            : [],
+        nonNullable: (type) => one("getNonNullableType", () => typeLocation(type), () => checker.getNonNullableType(type)),
+        isArray: (type) => one("isArrayType", () => typeLocation(type), () => checker.isArrayType(type)),
+        assignableEach: (pairs, cap = DEFAULT_BATCH_CAP) => each("isTypeAssignableTo", pairs, cap, (pair) => `${typeLocation(pair.source)} to ${typeLocation(pair.target)}`, (pair) => checker.isTypeAssignableTo.gen(pair.source, pair.target), (pair) => checker.isTypeAssignableTo(pair.source, pair.target)),
+        baseTypes: (type) => type.isClassOrInterface()
+            ? one("getBaseTypes", () => typeLocation(type), () => checker.getBaseTypes(type))
+            : [],
+        constituents: (type) => type.isUnionType() || type.isIntersectionType()
+            ? one("getTypes", () => typeLocation(type), () => type.getTypes())
+            : [type],
+        targetOf: (type) => type.isTypeReference()
+            ? one("getTarget", () => typeLocation(type), () => type.getTarget())
+            : type,
+        symbolOfType: (type) => one("getSymbol", () => typeLocation(type), () => type.getSymbol()),
+        signaturesOf: (type, kind) => one("getSignaturesOfType", () => typeLocation(type), () => checker.getSignaturesOfType(type, kind)),
+        resolvedSignature: (node) => one("getResolvedSignature", () => nodeLocation(node), () => checker.getResolvedSignature(node)),
+        parameterType: (signature, index) => one("getParameterType", () => `signature ${String(signature.id)} parameter ${String(index)}`, () => checker.getParameterType(signature, index)),
+        signatureOf: (declaration) => one("getSignatureFromDeclaration", () => nodeLocation(declaration), () => checker.getSignatureFromDeclaration(declaration)),
+        returnTypeOf: (signature) => one("getReturnTypeOfSignature", () => `signature ${String(signature.id)}`, () => checker.getReturnTypeOfSignature(signature)),
+        typeToString: (type) => one("typeToString", () => typeLocation(type), () => checker.typeToString(type)),
+    };
+}