@cplieger/deadset-ts 5.2.3 → 6.0.1

package/dist/src/findings/emitters.js

@@ -1,5 +1,6 @@
 import { evaluateEdges } from "../edges.js";
 import { liveFilesAt } from "../matrix.js";
+import { declarationKey } from "../ref.js";
 import { ledgerOf } from "../suppress.js";
 import { insideSkipped } from "../type-errors.js";
 import { completed, dialsOf, reportable } from "./completion.js";
@@ -23,24 +24,24 @@ export const EMITTERS = new Map([
     ["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.
+ * The keys 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) {
+function heldKeys(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));
+        .map((symbol) => declarationKey(symbol.ref, symbol.position.path)));
 }
 /**
- * The references of every top-level declaration of a live component file. The file's
+ * The keys of every top-level declaration of a live component file. The file's
  * markup may use each of them, which no analysis of the markup can rule out, so the run
  * reports nothing about one while the file is live.
  */
-function markupRefs(input) {
+function markupKeys(input) {
     const { swept } = input;
     if (swept.componentFiles.length === 0) {
         return new Set();
@@ -48,7 +49,7 @@ function markupRefs(input) {
     const live = new Set(liveFilesAt(swept.matrix, swept.sweep, new Set(swept.componentFiles)).map((symbol) => symbol.id));
     return new Set(swept.matrix.union.symbols
         .filter((symbol) => live.has(symbol.parent))
-        .map((symbol) => symbol.ref));
+        .map((symbol) => declarationKey(symbol.ref, symbol.position.path)));
 }
 /** Every family's findings over one sweep, and those of any further emitter, completed by one step. */
 function completedOver(input, ...more) {
@@ -68,32 +69,70 @@ function dialsOver(input, found, suppressed, unmarked) {
     };
 }
 /**
- * Every finding of one run swept under its suppressions' marks, decided in one pass: every
- * family's findings completed by one step, so every component number is minted once, a
- * pending finding's among them; the finding each record claims withheld, whatever its
- * kind; the rest withheld by the dials, so a root one family reports withholds what
- * another family reports in its component; and every declared edge evaluated over what
- * remains, so a finding it holds pending is in its evaluation and nowhere else.
+ * Every finding of one run swept under its suppressions' marks, decided in one pass: each
+ * family's findings completed by one step, so every component number is minted once, the
+ * finding each record claims withheld, the rest withheld by the dials, so a root one family
+ * reports withholds what another reports in its component, and every declared edge
+ * evaluated over what remains, so a pending finding is in its evaluation alone. What the
+ * minimum confidence withheld is what the same decision at the lowest minimum adds.
  */
 export function decidedFindings(input, suppressed = { unmarked: input, records: [] }) {
     const found = completedOver(input);
     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 unanswered = heldRefs(input);
-    const markup = markupRefs(input);
-    const kept = reportable(input, found.filter((finding) => !ledger.withheld(finding) &&
-        !unanswered.has(finding.symbol.ref) &&
-        !markup.has(finding.symbol.ref) &&
-        !insideSkipped(input.swept.skipped, finding.position)));
-    const evaluated = evaluateEdges(kept, input.boundary.edges, input.swept.matrix.union.symbols);
+    const decided = dialledOver(input, suppressed, found, unmarked);
+    const shown = input.config.analysis.minConfidence === "possible"
+        ? decided
+        : dialledOver(atPossible(input), {
+            unmarked: atPossible(suppressed.unmarked),
+            records: suppressed.records,
+        }, found, unmarked);
+    return { ...decided, would, withheld: withheldOf(decided.findings, shown.findings) };
+}
+/** The run's input with the minimum confidence at its lowest, which withholds nothing. */
+function atPossible(input) {
+    const { config } = input;
     return {
-        findings: evaluated.findings,
-        evaluations: evaluated.evaluations,
-        ledger,
-        would,
+        ...input,
+        config: { ...config, analysis: { ...config.analysis, minConfidence: "possible" } },
     };
 }
+/**
+ * The run's completed findings decided under its dials: the finding each record claims
+ * withheld, the rest withheld by the dials, and every declared edge evaluated over what
+ * remains.
+ */
+function dialledOver(input, suppressed, found, unmarked) {
+    const would = [...unmarked, ...found];
+    const ledger = ledgerOf(suppressed.records, would, dialsOver(input, found, suppressed, unmarked));
+    const unanswered = heldKeys(input);
+    const markup = markupKeys(input);
+    const kept = reportable(input, found.filter((finding) => {
+        const key = declarationKey(finding.symbol.ref, finding.position.path);
+        return (!ledger.withheld(finding) &&
+            !unanswered.has(key) &&
+            !markup.has(key) &&
+            !insideSkipped(input.swept.skipped, finding.position));
+    }));
+    const evaluated = evaluateEdges(kept, input.boundary.edges, input.swept.matrix.union.symbols);
+    return { findings: evaluated.findings, evaluations: evaluated.evaluations, ledger };
+}
+/** The findings the lowest minimum would report that the run does not, counted by confidence. */
+function withheldOf(reported, shown) {
+    const kept = new Set(reported.map(findingKey));
+    const counts = { certain: 0, probable: 0, possible: 0 };
+    for (const finding of shown) {
+        if (!kept.has(findingKey(finding))) {
+            counts[finding.confidence] += 1;
+        }
+    }
+    return counts;
+}
+/** A finding's identity across two decisions of one run: its position, code and subject. */
+function findingKey(finding) {
+    const { path, line, column } = finding.position;
+    return JSON.stringify([path, line, column, finding.code, finding.symbol.ref]);
+}
 /** Every finding the run reports, each family's in table order. */
 export function findingsOf(input) {
     return decidedFindings(input).findings;

package/dist/src/findings/interfaces.js

@@ -54,15 +54,16 @@ function findingOf(code, symbol, message, implementations) {
  * The findings of the interfaces family, `DS1200` to `DS1299`: `DS1201`, a dead
  * interface, whose members fall with it unreported; and `DS1203`, a method of a live
  * interface no reference names, unless it is a marker, a method whose every
- * implementation has an empty body. A test file's declaration is neither kind's
- * subject, because a production sweep counts none of the references it can have.
+ * implementation has an empty body. A test file's declaration is neither kind's subject,
+ * because a production sweep counts none of the references it can have, save an interface
+ * the run that counts test references does not reach, which is `DS1201`'s.
  */
 export const interfaces = (input) => {
     const run = indexed(input);
     const found = [];
     for (const candidate of input.swept.sweep.candidates) {
         const symbol = run.symbolOf(candidate.id);
-        if (symbol === undefined || run.inTest(candidate.id)) {
+        if (symbol === undefined || (run.inTest(candidate.id) && !candidate.unreferencedTest)) {
             continue;
         }
         if (symbol.kind === "interface") {

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

@@ -14,6 +14,19 @@ function overlapClause(overlap) {
         ? "no other rule is known to report it"
         : `also reported by ${spelled(overlap)}`;
 }
+/**
+ * Whether one parameter's name is reported: every unread one of a function whose
+ * signature is free, and of a function used as a value only one no read parameter follows,
+ * because a caller may pass such a function more arguments than it declares.
+ */
+function parameterReported(part, free, freeButValued) {
+    const place = part.parameter;
+    if (place?.inValue !== true && free.has(part.declaration)) {
+        return true;
+    }
+    const valued = place?.inValue === true || freeButValued.has(part.declaration);
+    return valued && place?.beforeARead !== true;
+}
 /**
  * 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
@@ -25,10 +38,10 @@ function reported(input, part, callersUnknown) {
     if (part.used) {
         return false;
     }
-    const { free, discardedEverywhere } = input.intraFunction;
+    const { free, freeButValued, discardedEverywhere } = input.intraFunction;
     switch (part.code) {
         case UNUSED_PARAMETER:
-            return free.has(part.declaration);
+            return parameterReported(part, free, freeButValued);
         case UNUSED_RESULT:
             return (free.has(part.declaration) &&
                 discardedEverywhere.has(part.declaration) &&

package/dist/src/findings/reads-and-writes.js

@@ -1,4 +1,5 @@
 import { positionKey } from "../position.js";
+import { declarationKey } from "../ref.js";
 /** The containers whose type parameters `DS1303` reports: a function and a class method. */
 const SIGNATURES = new Set(["function", "method"]);
 function indexed(input) {
@@ -175,12 +176,12 @@ function unusedTypeParameters(run) {
         .map((symbol) => findingAbout(symbol, "DS1303", `type parameter ${symbol.name} is named in neither its signature nor its body`));
 }
 /**
- * The references of the declarations the write-only kind reports, whatever the
+ * The keys of the declarations the write-only kind reports, whatever the
  * severity: a narrowing kind yields each to it, since deleting the declaration
  * supersedes narrowing it.
  */
 export function writeOnlyDeclarations(input) {
-    return new Set(writeOnlySymbols(indexed(input)).map((finding) => finding.symbol.ref));
+    return new Set(writeOnlySymbols(indexed(input)).map((finding) => declarationKey(finding.symbol.ref, finding.position.path)));
 }
 /**
  * The findings of the reads-and-writes family, `DS1300` to `DS1399`, in code order and

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

@@ -49,9 +49,14 @@ function codeOf(judged) {
     if (candidate.testOfDeadCode) {
         return "DS1005";
     }
-    if (judged.test || judged.containerDead || NOT_THIS_FAMILY.has(symbol.kind)) {
+    if ((judged.test && !candidate.unreferencedTest) ||
+        judged.containerDead ||
+        NOT_THIS_FAMILY.has(symbol.kind)) {
         return undefined;
     }
+    if (candidate.unreferencedTest) {
+        return unreferencedCode(symbol);
+    }
     const referenced = candidate.productionRefs + candidate.testRefs > 0;
     if (symbol.kind === "enum-member" && !referenced) {
         return undefined;
@@ -73,6 +78,13 @@ function codeOf(judged) {
     }
     return judged.unreachable ? undefined : "DS1001";
 }
+/** The code a declaration nothing references carries, by its shape and its visibility. */
+function unreferencedCode(symbol) {
+    if (MEMBERS.has(symbol.kind)) {
+        return "DS1003";
+    }
+    return symbol.exported ? "DS1001" : "DS1002";
+}
 /** The visibility a member's message names, where it narrows the member's reach. */
 function visibilityWord(symbol) {
     switch (symbol.visibility) {

package/dist/src/findings/visibility-narrowing.js

@@ -1,4 +1,5 @@
 import { OUTSIDE } from "../graph.js";
+import { declarationKey } from "../ref.js";
 import { writeOnlyDeclarations } from "./reads-and-writes.js";
 const UNNECESSARY_EXPORT = "DS1101";
 const UNREACHABLE_EXPORT = "DS1103";
@@ -119,7 +120,7 @@ function narrowing(facts, at, symbol, world) {
     const { closed } = world;
     const file = facts.fileOf[at] ?? OUTSIDE;
     if (!topLevelExport(facts, at, symbol) ||
-        world.writeOnly.has(symbol.ref) ||
+        world.writeOnly.has(declarationKey(symbol.ref, symbol.position.path)) ||
         symbol.kind === "export-alias" ||
         entersByName(facts.rootedBy[at]) ||
         entersByName(facts.rootedBy[file]) ||

package/dist/src/findings-pass.js

@@ -55,6 +55,7 @@ export function findingsPass(inputs) {
             reasonsRecorded: counts.reasonsRecorded,
             staleSuppressions: records.length,
             pending: decided.evaluations.filter((one) => one.finding !== undefined).length,
+            withheld: decided.withheld,
         },
         ledger,
     };

package/dist/src/graph.js

@@ -32,11 +32,11 @@ const SWEPT = {
 };
 /**
  * Whether a root of each kind names a caller, which holds it live under both relations: a
- * tool reads the configuration it loads and the files its strings name, a runtime runs a
- * test file, a setup file, a worker, a page's module script, a command and a script, the
- * manifest names what enters the package, an alias global stands for the export it names,
- * and an entry file, a configured root and a pattern assert a caller. A library's
- * published API only supposes an unseen consumer, so it is live under reachability alone.
+ * tool reads what it loads and what its strings name, a runtime runs a test, setup or
+ * worker file, a page's module script, a command, a script or a workflow step, the manifest
+ * names what enters the package, an alias global stands for its export, and an entry file,
+ * a configured root and a pattern assert a caller. A library's published API only supposes
+ * an unseen consumer, so it is live under reachability alone.
  */
 const NAMES_A_CALLER = {
     "entry-file": true,
@@ -52,10 +52,10 @@ const NAMES_A_CALLER = {
     "configuration-file": true,
     "configuration-string": true,
     "test-runner": true,
-    "mutation-testing": true,
     "browser-tests": true,
     worker: true,
     "html-entry": true,
+    "workflow-step": true,
 };
 /** Whether the sweep judges a declaration of one kind. */
 export function swept(kind) {

package/dist/src/implementations.js

@@ -54,7 +54,7 @@ function typesAt(project, nodes) {
     return typeAt;
 }
 /** Whether one class member is a method whose every written body holds no statement. */
-function emptyImplementation(project, member) {
+export function emptyImplementation(project, member) {
     const own = project.ownPaths();
     let bodies = 0;
     for (const handle of member.declarations) {

package/dist/src/indexed-access.js

@@ -0,0 +1,215 @@
+/**
+ * The members an indexed-access type names. `T["a" | "b"]` reads the members `a` and `b`
+ * of `T` as a property access by either name would. Where the index is a type parameter
+ * a call fixes, the call names the members the literal type argument names, written or
+ * inferred, which is read off the parameter the type parameter annotates whole. The type
+ * query of a type-query alias is no reference.
+ */
+import { isArrowFunction, isCallExpression, isFunctionDeclaration, isFunctionExpression, isIdentifier, isIndexedAccessTypeNode, isLiteralTypeNode, isMethodDeclaration, isNewExpression, isNoSubstitutionTemplateLiteral, isNumericLiteral, isParenthesizedTypeNode, isPropertyAccessExpression, isStringLiteral, isTypeReferenceNode, isUnionTypeNode, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { nodeKey } from "./inventory.js";
+import { renderPosition } from "./position.js";
+import { UNANSWERED } from "./query.js";
+import { typeQueryAliases } from "./type-query-alias.js";
+function isGeneric(node) {
+    return ((isFunctionDeclaration(node) ||
+        isMethodDeclaration(node) ||
+        isArrowFunction(node) ||
+        isFunctionExpression(node)) &&
+        node.typeParameters !== undefined);
+}
+function unwrappedType(node) {
+    return isParenthesizedTypeNode(node) ? unwrappedType(node.type) : node;
+}
+/** The names a literal index type spells, or none where the index is any other type. */
+function literalNames(index) {
+    const node = unwrappedType(index);
+    if (isUnionTypeNode(node)) {
+        const names = node.types.map(literalNames);
+        return names.every((one) => one !== undefined) ? names.flat() : undefined;
+    }
+    if (!isLiteralTypeNode(node)) {
+        return undefined;
+    }
+    const literal = node.literal;
+    if (isStringLiteral(literal) || isNoSubstitutionTemplateLiteral(literal)) {
+        return [literal.text];
+    }
+    return isNumericLiteral(literal) ? [String(Number(literal.text))] : undefined;
+}
+/** The name a literal type carries, a union's each, or none where a constituent is no literal. */
+function literalTypeNames(type, parts) {
+    const names = [];
+    for (const part of parts(type)) {
+        if (part.isStringLiteralType()) {
+            names.push(part.value);
+        }
+        else if (part.isNumberLiteralType()) {
+            names.push(String(part.value));
+        }
+        else {
+            return undefined;
+        }
+    }
+    return names;
+}
+/**
+ * The references the indexed-access types of one project's own files make to the members
+ * they name, each made by the declaration that holds the type or the call, or by the file.
+ */
+export function indexedAccessReferences(project, held, chains, root, testFiles) {
+    const queries = project.queries;
+    const accesses = [];
+    const generics = new Map();
+    const calls = [];
+    const names = new Set();
+    for (const file of project.ownSourceFiles()) {
+        const fileId = held.declarations.get(nodeKey(file, file));
+        if (fileId === undefined) {
+            continue;
+        }
+        const aliasTypes = new Set(typeQueryAliases(file).map((alias) => alias.type));
+        const visit = (node, from, enclosing) => {
+            const own = held.declarations.get(nodeKey(file, node));
+            const holder = own ?? from;
+            const inside = isGeneric(node) ? [...enclosing, node] : enclosing;
+            if (isIndexedAccessTypeNode(node) && !aliasTypes.has(node)) {
+                const literal = literalNames(node.indexType);
+                if (literal !== undefined) {
+                    accesses.push({ file, from: holder, at: node, object: node.objectType, names: literal });
+                }
+                else {
+                    parameterIndex(node, inside, file, generics, names);
+                }
+            }
+            if (isCallExpression(node) || isNewExpression(node)) {
+                const callee = node.expression;
+                const name = isIdentifier(callee)
+                    ? callee.text
+                    : isPropertyAccessExpression(callee) && isIdentifier(callee.name)
+                        ? callee.name.text
+                        : undefined;
+                if (name !== undefined) {
+                    calls.push({ file, from: holder, call: node, name });
+                }
+            }
+            node.forEachChild((child) => {
+                visit(child, holder, inside);
+            });
+        };
+        file.forEachChild((child) => {
+            visit(child, fileId, []);
+        });
+    }
+    for (const { file, from, call, name } of calls) {
+        if (!names.has(name)) {
+            continue;
+        }
+        const resolved = queries.resolvedSignature(call);
+        if (resolved === UNANSWERED || resolved?.declaration === undefined) {
+            continue;
+        }
+        const declaration = project.declarationAt(resolved.declaration)?.node;
+        const byParameter = declaration === undefined
+            ? undefined
+            : generics.get(nodeKey(declaration.getSourceFile(), declaration));
+        if (byParameter === undefined) {
+            continue;
+        }
+        for (const { object, parameter } of byParameter) {
+            const fixed = queries.typeAtPosition(resolved, parameter);
+            const literal = fixed === UNANSWERED ? undefined : literalTypeNames(fixed, (type) => partsOf(type));
+            if (literal !== undefined) {
+                accesses.push({ file, from, at: call, object, names: literal });
+            }
+        }
+    }
+    function partsOf(type) {
+        const parts = queries.constituents(type);
+        return parts === UNANSWERED ? [type] : parts;
+    }
+    const objectNodes = accesses.flatMap((one) => ("kind" in one.object ? [one.object] : []));
+    const typeOf = new Map();
+    queries.typesAt(objectNodes).forEach((answer, index) => {
+        const node = objectNodes[index];
+        if (answer !== UNANSWERED && answer !== undefined && node !== undefined) {
+            typeOf.set(node, answer);
+        }
+    });
+    const found = [];
+    for (const access of accesses) {
+        const type = "kind" in access.object ? typeOf.get(access.object) : access.object;
+        if (type === undefined) {
+            continue;
+        }
+        const position = renderPosition(access.file, root, access.at.getStart());
+        for (const part of partsOf(type)) {
+            const properties = queries.propertiesOf(part);
+            if (properties === UNANSWERED) {
+                continue;
+            }
+            for (const property of properties) {
+                if (!access.names.includes(property.escapedName)) {
+                    continue;
+                }
+                for (const to of chains.declarationsOf(property)) {
+                    found.push({
+                        from: access.from,
+                        to,
+                        position,
+                        use: "read",
+                        resolution: "batch",
+                        test: testFiles.has(position.path),
+                    });
+                }
+            }
+        }
+    }
+    return found;
+}
+/**
+ * Records an indexed-access type whose index names a type parameter of an enclosing
+ * function that a parameter of that function is annotated with whole, so a call's
+ * argument for that parameter fixes the index.
+ */
+function parameterIndex(node, enclosing, file, generics, names) {
+    const index = unwrappedType(node.indexType);
+    if (!isTypeReferenceNode(index) || !isIdentifier(index.typeName)) {
+        return;
+    }
+    const spelled = index.typeName.text;
+    for (const generic of [...enclosing].reverse()) {
+        const declares = (generic.typeParameters ?? []).some((parameter) => isIdentifier(parameter.name) && parameter.name.text === spelled);
+        if (!declares) {
+            continue;
+        }
+        const at = generic.parameters.findIndex((parameter) => {
+            const type = parameter.type === undefined ? undefined : unwrappedType(parameter.type);
+            return (type !== undefined &&
+                isTypeReferenceNode(type) &&
+                isIdentifier(type.typeName) &&
+                type.typeName.text === spelled);
+        });
+        if (at >= 0) {
+            const key = nodeKey(file, generic);
+            generics.set(key, [...(generics.get(key) ?? []), { object: node.objectType, parameter: at }]);
+            const name = calledName(generic);
+            if (name !== undefined) {
+                names.add(name);
+            }
+        }
+        return;
+    }
+}
+/** The name a call writes to call one generic function: its own, or its variable's. */
+function calledName(generic) {
+    const own = generic.name;
+    if (own !== undefined && isIdentifier(own)) {
+        return own.text;
+    }
+    const parent = generic.parent;
+    return parent.kind === SyntaxKind.VariableDeclaration &&
+        parent.name !== undefined &&
+        isIdentifier(parent.name)
+        ? parent.name.text
+        : undefined;
+}