@cplieger/deadset-ts 3.12.1 → 4.0.0

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

@@ -1,2 +1,91 @@
-/** The findings of the intra-function family, `DS1800` to `DS1899`. */
-export const intraFunction = () => [];
+import { KINDS } from "../kinds.js";
+import { UNUSED_PARAMETER, UNUSED_RESULT } from "../intra-function-parts.js";
+/** A list of rules as a sentence names them. */
+function spelled(rules) {
+    if (rules.length < 2) {
+        return rules.join("");
+    }
+    return `${rules.slice(0, -1).join(", ")} and ${rules.at(-1) ?? ""}`;
+}
+/** The clause a message ends with: the other rules that report the kind, or that none is known. */
+function overlapClause(overlap) {
+    return overlap.length === 1 && overlap[0] === "none known"
+        ? "no other rule is known to report it"
+        : `also reported by ${spelled(overlap)}`;
+}
+/**
+ * Whether one part is reported. A parameter needs its function's signature free to
+ * change; a result needs that, every call in the loaded program to discard it, and every
+ * call site to be in the loaded program, so a function with a root or one a module
+ * exports to callers the run cannot see has no result to report. Every other part is
+ * reported wherever no project found it in use.
+ */
+function reported(input, part, callersUnknown) {
+    if (part.used) {
+        return false;
+    }
+    const { free, discardedEverywhere } = input.intraFunction;
+    switch (part.code) {
+        case UNUSED_PARAMETER:
+            return free.has(part.declaration);
+        case UNUSED_RESULT:
+            return (free.has(part.declaration) &&
+                discardedEverywhere.has(part.declaration) &&
+                !callersUnknown.has(part.declaration));
+        default:
+            return true;
+    }
+}
+/**
+ * The findings of the intra-function family, `DS1800` to `DS1899`, each about a part of
+ * the declaration its reference names, at the part's own position, whatever the sweep
+ * decided about that declaration. Each message names the other rules that report the
+ * kind, as the vocabulary lists them, and so does the finding's details.
+ */
+export const intraFunction = (input) => {
+    const union = input.swept.matrix.union;
+    const byId = new Map(union.symbols.map((symbol) => [symbol.id, symbol]));
+    const unknown = new Set(union.rooted.flatMap((root) => {
+        const symbol = union.symbols[root.at];
+        return symbol === undefined ? [] : [symbol.id];
+    }));
+    const { declared, loaded } = input.boundary.consumers;
+    const closed = input.config.consumersComplete && declared.every((id) => loaded.includes(id));
+    const published = (id) => {
+        const symbol = byId.get(id);
+        return (symbol !== undefined &&
+            symbol.kind !== "file" &&
+            (symbol.exported || published(symbol.parent)));
+    };
+    if (!closed) {
+        for (const part of input.intraFunction.parts) {
+            if (published(part.declaration)) {
+                unknown.add(part.declaration);
+            }
+        }
+    }
+    const found = [];
+    for (const part of input.intraFunction.parts) {
+        const declaration = byId.get(part.declaration);
+        const overlap = KINDS.get(part.code)?.overlap ?? [];
+        if (declaration === undefined || !reported(input, part, unknown)) {
+            continue;
+        }
+        found.push({
+            code: part.code,
+            position: part.position,
+            symbol: {
+                ref: declaration.ref,
+                kind: part.kind,
+                name: part.name,
+                sizeLines: part.position.endLine - part.position.line + 1,
+            },
+            message: `${part.message}; ${overlapClause(overlap)}`,
+            details: {
+                ...(part.kind === "store" ? { writePositions: [part.position] } : {}),
+                overlap,
+            },
+        });
+    }
+    return found;
+};

package/dist/src/findings/self-check.js

@@ -2,6 +2,10 @@ import { REPOSITORY_DOCUMENT } from "../config.js";
 import { STALE_SUPPRESSION, SUPPRESSION_WITHOUT_REASON, } from "../suppress.js";
 /** The code a configured root that matches nothing is reported under. */
 const UNMATCHED_ROOT = "DS1704";
+/** The code a configured declaration that names nothing is reported under. */
+const UNMATCHED_DECLARATION = "DS1706";
+/** The subject kind of a finding about a configured declaration. */
+const DECLARATION_SUBJECT = "configured-declaration";
 /** The subject kind of a finding about a suppression record. */
 const SUPPRESSION_SUBJECT = "suppression";
 /** The subject kind of a finding about a configured root. */
@@ -13,6 +17,7 @@ export const NO_SELF_CHECK = {
     refusals: [],
     unmatchedRoots: [],
     rootsDocument: "",
+    unmatchedDeclarations: [],
 };
 /** The words a message names a mechanism by. */
 const WRITTEN = {
@@ -104,6 +109,27 @@ export function staleSuppressions(stale, files) {
         };
     });
 }
+/** The first position of the document that configured a setting, or of the conventional one. */
+function documentPosition(document) {
+    return {
+        path: document === "" ? REPOSITORY_DOCUMENT : document,
+        line: DOCUMENT_POSITION,
+        column: DOCUMENT_POSITION,
+        endLine: DOCUMENT_POSITION,
+    };
+}
+/**
+ * One finding per configured declaration that named no declaration in any project, at the
+ * first position of the document that configured its key, as a configured root's is.
+ */
+function unmatchedDeclarationFindings(unmatched) {
+    return unmatched.map((one) => ({
+        code: UNMATCHED_DECLARATION,
+        position: documentPosition(one.document),
+        symbol: { ref: one.ref, kind: DECLARATION_SUBJECT, name: one.ref, sizeLines: 1 },
+        message: `${one.key} entry names no declaration in any project`,
+    }));
+}
 /**
  * One finding per configured root or pattern that named nothing in any project. A finding
  * names the document that declared the roots, or the conventional repository configuration
@@ -112,12 +138,7 @@ export function staleSuppressions(stale, files) {
  * own, so the string each finding names tells one from another.
  */
 export function unmatchedRootFindings(sources, document) {
-    const position = {
-        path: document === "" ? REPOSITORY_DOCUMENT : document,
-        line: DOCUMENT_POSITION,
-        column: DOCUMENT_POSITION,
-        endLine: DOCUMENT_POSITION,
-    };
+    const position = documentPosition(document);
     return sources.map((source) => ({
         code: UNMATCHED_ROOT,
         position,
@@ -129,11 +150,13 @@ export function unmatchedRootFindings(sources, document) {
 }
 /**
  * The findings of the self-check family, `DS1700` to `DS1799`: a suppression refused for
- * carrying no reason or naming no path, and a configured root that named nothing. A
+ * carrying no reason or naming no path, and a configured root or declaration that named
+ * nothing. A
  * suppression that matched nothing is a record of the report's stale suppressions, which
  * {@link staleSuppressions} builds, and a stale cross-language edge is the merge's to report.
  */
 export const selfCheck = ({ selfCheck: facts, swept }) => [
     ...refusedSuppressions(facts.refusals, fileRefsOf(swept.matrix.union.symbols)),
     ...unmatchedRootFindings(facts.unmatchedRoots, facts.rootsDocument),
+    ...unmatchedDeclarationFindings(facts.unmatchedDeclarations),
 ];

package/dist/src/findings/unused-declarations.js

@@ -111,7 +111,15 @@ function messageOf(code, judged) {
     return `${subject} has no reference in the target`;
 }
 /** The findings of the unused-declarations family, `DS1000` to `DS1099`. */
-export const unusedDeclarations = (input) => {
+export const unusedDeclarations = (input) => familyFindings(input, false);
+/**
+ * The finding each member of a dead container would carry were its container live: what
+ * a record on such a member is matched against, since the report carries the container's
+ * finding rather than one of the member's own.
+ */
+export const fallenMembers = (input) => familyFindings(input, true);
+/** The family's findings, or, where `fallen` is set, its dead containers' members' alone. */
+function familyFindings(input, fallen) {
     const union = input.swept.matrix.union;
     const dead = new Set(input.swept.sweep.candidates.map((candidate) => candidate.id));
     const unreachable = unreachableExports(input);
@@ -122,11 +130,15 @@ export const unusedDeclarations = (input) => {
         if (symbol === undefined) {
             continue;
         }
+        const containerDead = dead.has(symbol.parent);
+        if (fallen !== containerDead) {
+            continue;
+        }
         const judged = {
             candidate,
             symbol,
             test: union.test[at] === true,
-            containerDead: dead.has(symbol.parent),
+            containerDead: containerDead && !fallen,
             deprecated: input.deprecated.has(symbol.id),
             unreachable: unreachable.has(symbol.id),
         };
@@ -148,4 +160,4 @@ export const unusedDeclarations = (input) => {
         });
     }
     return found;
-};
+}

package/dist/src/findings-pass.js

@@ -76,18 +76,25 @@ export function verdictOf(result, config) {
     return failing ? EXIT_FINDINGS : EXIT_CLEAN;
 }
 /**
- * The findings of a report as a baseline records them, in report order. A finding about a
- * row of a document is not recorded: no record withholds one, so a row recording it would
- * be stale on the first read back.
+ * The rows one round of a baseline write records from its findings, in their order. A
+ * finding about a row of a document is not recorded: no record withholds one, so a row
+ * recording it would be stale on the first read back. Two findings that would record the
+ * same row, two parts of one declaration under one code, record it once.
  */
-export function recordedFindings(result) {
-    return result.findings
-        .filter((finding) => !isRowSubject(finding.symbol.kind))
-        .map((finding) => ({
-        code: finding.code,
-        symbol: finding.symbol.ref,
-        path: finding.position.path,
-    }));
+export function recordedFindings(findings) {
+    const rows = new Map();
+    for (const finding of findings) {
+        if (isRowSubject(finding.symbol.kind)) {
+            continue;
+        }
+        const row = { code: finding.code, symbol: finding.symbol.ref, path: finding.position.path };
+        rows.set(rowKey(row), rows.get(rowKey(row)) ?? row);
+    }
+    return [...rows.values()];
+}
+/** One row's identity: its code, its symbol and its path. */
+export function rowKey(row) {
+    return `${row.code}\u0000${row.symbol}\u0000${row.path}`;
 }
 /** The analyzer identity a baseline this analyzer writes names as its rows' provenance. */
 export function analyzerProvenance(version) {

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