@cplieger/deadset-ts 3.13.0 → 4.0.0

package/dist/src/enum-group.js

@@ -11,7 +11,7 @@ import { TypeFlags } from "@typescript/native/unstable/sync";
 import { aliasChains } from "./alias-chain.js";
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
-import { DEFAULT_BATCH_CAP } from "./references.js";
+import { isAnswered, UNANSWERED } from "./query.js";
 /** The operand types a conversion produces an enum value from. */
 const NUMBER = TypeFlags.NumberLike;
 const STRING = TypeFlags.StringLike;
@@ -104,24 +104,31 @@ function sitesOf(file) {
  * 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) {
-    const parts = type.isUnionType() ? type.getTypes() : [type];
-    return parts.filter((part) => (part.flags & TypeFlags.EnumLike) === 0);
+function partsOf(project, 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, enumName, operand) {
+function detailOf(project, site, enumName, operand) {
     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";
     }
@@ -160,32 +167,33 @@ export function enumGroup(input) {
     const sites = files.flatMap(sitesOf);
     const named = new Map();
     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) => [...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();
-    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);
-            }
-        });
-    }
+    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();
     for (const symbol of held.symbols) {
         if (symbol.kind === "enum-member" && enums.has(symbol.parent)) {
@@ -200,17 +208,15 @@ export function enumGroup(input) {
     }
     const found = [];
     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/dist/src/exempt.js

@@ -9,6 +9,7 @@
 import { ConfigError } from "./config.js";
 import { EXEMPTION_CLASSES, isExemptionClass, TS_EXEMPTION_CLASSES, typescriptVisibilityOf, } from "./exempt-classes.js";
 import { byPosition, positionKey } from "./position.js";
+import { Unanswerable } from "./query.js";
 import { sweep } from "./sweep.js";
 /**
  * The classes `exemptions.disabled` switches off. A name is refused unless the
@@ -39,6 +40,46 @@ function retainable(allowed, visibility) {
     }
     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 = new Map([
+    ["interface-satisfaction", new Set(["method", "class-member"])],
+    ["enum-group", new Set(["enum-member"])],
+    ["injection-container", new Set(["method", "class-member"])],
+    ["framework-lifecycle", new Set(["method", "class-member"])],
+    [
+        "serialization-contract",
+        new Set(["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) {
+    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(exemptionClass, detect, input) {
+    try {
+        return detect(input);
+    }
+    catch (error) {
+        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
@@ -55,7 +96,7 @@ export function computeExemptions(input, detectors, holding) {
             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/dist/src/findings/emitters.js

@@ -20,6 +20,19 @@ export const EMITTERS = new Map([
     ["self-check", selfCheck],
     ["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) {
+    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));
+}
 /** Every family's findings over one sweep, and those of any further emitter, completed by one step. */
 function completedOver(input, ...more) {
     return completed(input, [...EMITTERS.values(), ...more].flatMap((emit) => emit(input)));
@@ -50,7 +63,8 @@ export function decidedFindings(input, suppressed = { unmarked: input, records:
     const unmarked = suppressed.records.length === 0 ? [] : completedOver(suppressed.unmarked, fallenMembers);
     const would = [...unmarked, ...found];
     const ledger = ledgerOf(suppressed.records, would, dialsOver(input, found, suppressed, unmarked));
-    const kept = reportable(input, found.filter((finding) => !ledger.withheld(finding)));
+    const unanswered = heldRefs(input);
+    const kept = reportable(input, found.filter((finding) => !ledger.withheld(finding) && !unanswered.has(finding.symbol.ref)));
     const evaluated = evaluateEdges(kept, input.boundary.edges, input.swept.matrix.union.symbols);
     return {
         findings: evaluated.findings,

package/dist/src/findings/interfaces.js

@@ -88,8 +88,14 @@ function unusedMessage(candidate) {
         ? UNUSED_TEST_MESSAGE
         : 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, method) {
+    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/dist/src/framework-lifecycle.js

@@ -12,6 +12,7 @@ import { classMembers, memberComponent, typesAt } from "./class-members.js";
 import { entriesAt, names, namesADeclaration, resolveEntries, spelledEntry, } from "./configured-declarations.js";
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
+import { must } from "./query.js";
 /** Every contract's components and bases, resolved in one pass over the entries. */
 function resolveContracts(project, held, contracts) {
     const entries = contracts.flatMap((contract) => [
@@ -106,7 +107,7 @@ function byBases(project, held, chains, contracts) {
     if (classes.length === 0) {
         return [];
     }
-    const checker = project.checker;
+    const queries = project.queries;
     const ancestry = new Map();
     const ancestorsOf = (type, seen) => {
         const known = ancestry.get(type.id);
@@ -116,15 +117,16 @@ function byBases(project, held, chains, contracts) {
         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;
     };
@@ -135,7 +137,7 @@ function byBases(project, held, chains, contracts) {
         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/dist/src/implementations.js

@@ -9,7 +9,7 @@ import { isClassDeclaration, isHeritageClause, isInterfaceDeclaration, isMethodD
 import { SymbolFlags } from "@typescript/native/unstable/sync";
 import { aliasChains } from "./alias-chain.js";
 import { nodeKey } from "./inventory.js";
-import { DEFAULT_BATCH_CAP } from "./references.js";
+import { must, Unanswerable } from "./query.js";
 /** The interfaces, the classes and the `implements` entries of one project's own files. */
 function walk(project, held) {
     const interfaces = [];
@@ -41,23 +41,21 @@ function walk(project, held) {
     }
     return { interfaces, classes, clauses };
 }
-/** The type at each node, asked in capped batches. */
+/** The type at each node. */
 function typesAt(project, nodes) {
     const typeAt = new Map();
-    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(project, member) {
-    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.
@@ -77,15 +75,32 @@ function emptyImplementation(project, member) {
     }
     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(project, held) {
     const classes = new Map();
     const bodies = new Map();
+    try {
+        implementedIn(project, held, classes, bodies);
+        return { classes, bodies, unknown: new Set() };
+    }
+    catch (error) {
+        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(project, held, classes, bodies) {
     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),
@@ -114,8 +129,8 @@ export function implementations(project, held) {
             classAt.set(owner.id, { owner, type });
         }
     }
-    const membersOf = (at) => (at.members ??= checker.getPropertiesOfType(at.type));
-    const classMembers = (at) => (at.members ??= new Map(checker.getPropertiesOfType(at.type).map((member) => [member.escapedName, member])));
+    const membersOf = (at) => (at.members ??= must(queries.propertiesOf(at.type)));
+    const classMembers = (at) => (at.members ??= new Map(must(queries.propertiesOf(at.type)).map((member) => [member.escapedName, member])));
     const methodIds = new Set(held.symbols.filter((symbol) => symbol.kind === "interface-method").map((symbol) => symbol.id));
     const chains = aliasChains(project, held);
     const record = (at, implementer) => {
@@ -161,11 +176,13 @@ export function implementations(project, held) {
         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 = [];
     for (const at of byType.values()) {
         const members = at.generic ? [] : membersOf(at);
         if (members.length === 0) {
@@ -178,16 +195,21 @@ export function implementations(project, held) {
             }
             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)) {
-                pair(at, implementer);
+                members.some((member) => written.has(member.escapedName))) {
+                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) {
+    const unknown = new Set(per.flatMap((one) => [...one.unknown]));
     const classes = new Map();
     const bodies = new Map();
     for (const one of per) {
@@ -206,5 +228,5 @@ export function mergeImplementations(per) {
             }
         }
     }
-    return { classes, bodies };
+    return { classes, bodies, unknown };
 }

package/dist/src/interface-satisfaction.js

@@ -17,7 +17,7 @@ import { SymbolFlags } from "@typescript/native/unstable/sync";
 import { aliasChains } from "./alias-chain.js";
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
-import { DEFAULT_BATCH_CAP } from "./references.js";
+import { must } from "./query.js";
 /** The operators of an assignment whose right side is stored into the left side's type. */
 const STORES = new Set([
     SyntaxKind.EqualsToken,
@@ -157,7 +157,7 @@ function walk(files, declarations) {
  */
 export function interfaceSatisfaction(input) {
     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) {
@@ -171,15 +171,13 @@ export function interfaceSatisfaction(input) {
         ...flows.filter((flow) => flow.self === undefined).map((flow) => flow.value),
     ];
     const typeAt = new Map();
-    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();
     const instanceOf = new Map();
     for (const owner of classes) {
@@ -197,7 +195,7 @@ export function interfaceSatisfaction(input) {
         }
         let parts = constituents.get(type.id);
         if (parts === undefined) {
-            parts = type.getTypes();
+            parts = must(queries.constituents(type));
             constituents.set(type.id, parts);
         }
         return parts;
@@ -213,7 +211,7 @@ export function interfaceSatisfaction(input) {
             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 }];
@@ -222,7 +220,7 @@ export function interfaceSatisfaction(input) {
     /** The interface types one position's type is or holds, each with the interface's name. */
     const interfacesOf = (type) => 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
                 ? symbol.name
                 : undefined);
@@ -251,7 +249,8 @@ export function interfaceSatisfaction(input) {
             reach(clause.owner, source, reached.type, reached.name, clause.entry);
         }
     }
-    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 = flow.self !== undefined && self !== undefined
@@ -259,38 +258,42 @@ export function interfaceSatisfaction(input) {
             : 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();
     const members = new Map();
     const found = [];
-    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));
+            names = new Set(must(queries.propertiesOf(pair.target)).map((property) => property.escapedName));
             required.set(pair.target.id, names);
         }
         let answering = members.get(pair.owner.id);
         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)]));
+            answering = new Map(must(queries.propertiesOf(instance)).map((property) => [
+                property.escapedName,
+                chains.declarationsOf(property),
+            ]));
             members.set(pair.owner.id, answering);
         }
         const detail = `satisfies ${pair.name}`;