@cplieger/deadset-ts 7.0.0-dev.1 → 7.0.0-dev.3

package/dist/src/erased-stores.js

@@ -0,0 +1,317 @@
+/**
+ * The values the program stores in a slot of a container: a property, an index signature,
+ * an array element, and a variable. A serializer walking the container emits the value the
+ * slot holds, so it walks each stored value at its own static type, a subtype stored where
+ * the slot's type names a supertype, `object`, `unknown` or `any` included. A container is
+ * identified by the checker's type identity, so two containers of one type share what
+ * either stores. A store into an erased property of a type the analyzed program does not
+ * declare hands the value to the code that declares the type.
+ */
+import { isArrayLiteralExpression, isBinaryExpression, isCallExpression, isElementAccessExpression, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadElement, isStringLiteral, isVariableDeclaration, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { SymbolFlags, TypeFlags } from "@typescript/native/unstable/sync";
+import { must } from "./query.js";
+/** The types that keep nothing of the value they are given. */
+const ERASED = TypeFlags.Any | TypeFlags.Unknown;
+/** The array methods whose arguments become elements of the array they are called on. */
+const ELEMENT_STORES = new Set(["push", "unshift"]);
+/** The name an element access's literal index spells, or none. */
+function literalKey(node) {
+    return isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node) || isNumericLiteral(node)
+        ? node.text
+        : undefined;
+}
+function unwrapped(node) {
+    return isParenthesizedExpression(node) ? unwrapped(node.expression) : node;
+}
+/**
+ * Whether a variable declaration's type can differ from what is stored in it: it carries an
+ * annotation, or it has neither an annotation nor an initializer, so its type evolves.
+ */
+function declaresSlot(node) {
+    const held = node;
+    return held.type !== undefined || held.initializer === undefined;
+}
+/** The element of an array literal at one place, where no spread before it moves the places. */
+function elementAt(source, at) {
+    if (!isArrayLiteralExpression(source)) {
+        return undefined;
+    }
+    const before = source.elements.slice(0, at + 1);
+    return before.some((one) => isSpreadElement(one)) ? undefined : source.elements[at];
+}
+/** The name a property spells, and none for a computed one. */
+function propertyName(name) {
+    return isIdentifier(name) || isStringLiteral(name) || isNumericLiteral(name)
+        ? name.text
+        : undefined;
+}
+/** The name one property of an object literal spells and the expression it holds, or none. */
+function propertyParts(property) {
+    if (isPropertyAssignment(property)) {
+        const name = propertyName(property.name);
+        return name === undefined ? undefined : { name, value: property.initializer };
+    }
+    if (isShorthandPropertyAssignment(property) && isIdentifier(property.name)) {
+        return { name: property.name.text, value: property.name };
+    }
+    return undefined;
+}
+/** The value an object literal gives one property, where it gives it by a plain or a shorthand property. */
+function propertyAt(source, name) {
+    if (!isObjectLiteralExpression(source)) {
+        return undefined;
+    }
+    for (const property of source.properties) {
+        const parts = propertyParts(property);
+        if (parts?.name === name) {
+            return parts.value;
+        }
+    }
+    return undefined;
+}
+/**
+ * Every target one destructuring pattern writes at any depth, each with the expression
+ * whose value it receives: the matching element or property of a literal on the right,
+ * else the right side with the path into it. A rest element copies, so it is no target
+ * here, and a default value is stored in its target too.
+ */
+function patternTargets(pattern, from, out) {
+    const target = unwrapped(pattern);
+    const source = from.path.length === 0 ? unwrapped(from.value) : from.value;
+    const into = (element, step, literal) => {
+        patternTargets(element, literal === undefined
+            ? { value: from.value, path: [...from.path, step] }
+            : { value: literal, path: [] }, out);
+    };
+    if (isArrayLiteralExpression(target)) {
+        target.elements.forEach((element, at) => {
+            if (!isSpreadElement(element) && element.kind !== SyntaxKind.OmittedExpression) {
+                into(element, at, from.path.length === 0 ? elementAt(source, at) : undefined);
+            }
+        });
+        return;
+    }
+    if (isObjectLiteralExpression(target)) {
+        for (const property of target.properties) {
+            const parts = propertyParts(property);
+            if (parts !== undefined) {
+                into(parts.value, parts.name, from.path.length === 0 ? propertyAt(source, parts.name) : undefined);
+            }
+            if (parts !== undefined &&
+                isShorthandPropertyAssignment(property) &&
+                property.objectAssignmentInitializer !== undefined) {
+                out.push({ target: parts.value, value: property.objectAssignmentInitializer, path: [] });
+            }
+        }
+        return;
+    }
+    if (isBinaryExpression(target) && target.operatorToken.kind === SyntaxKind.EqualsToken) {
+        patternTargets(target.left, from, out);
+        out.push({ target: target.left, value: target.right, path: [] });
+        return;
+    }
+    out.push({ target, ...from });
+}
+/** Every store one project's own files write, and the stores into variables declared erased. */
+export function erasedStores(project) {
+    const queries = project.queries;
+    const own = project.ownPaths();
+    const stores = [];
+    const assigned = [];
+    const slotVariables = [];
+    for (const file of project.ownSourceFiles()) {
+        const visit = (node) => {
+            if (isObjectLiteralExpression(node)) {
+                for (const property of node.properties) {
+                    if (isShorthandPropertyAssignment(property) && isIdentifier(property.name)) {
+                        const { name } = property;
+                        stores.push({
+                            container: node,
+                            contextual: true,
+                            name: name.text,
+                            value: name,
+                            path: [],
+                        });
+                    }
+                    else if (isPropertyAssignment(property) &&
+                        (isIdentifier(property.name) || isStringLiteral(property.name))) {
+                        const value = property.initializer;
+                        stores.push({
+                            container: node,
+                            contextual: true,
+                            name: property.name.text,
+                            value,
+                            path: [],
+                        });
+                    }
+                }
+            }
+            else if (isArrayLiteralExpression(node)) {
+                for (const element of node.elements) {
+                    if (!isSpreadElement(element)) {
+                        stores.push({
+                            container: node,
+                            contextual: true,
+                            name: undefined,
+                            value: element,
+                            path: [],
+                        });
+                    }
+                }
+            }
+            else if (isBinaryExpression(node) && node.operatorToken.kind === SyntaxKind.EqualsToken) {
+                const targets = [];
+                patternTargets(node.left, { value: node.right, path: [] }, targets);
+                for (const { target, value, path } of targets) {
+                    if (isPropertyAccessExpression(target)) {
+                        stores.push({
+                            container: target.expression,
+                            contextual: false,
+                            name: target.name.text,
+                            value,
+                            path,
+                        });
+                    }
+                    else if (isElementAccessExpression(target)) {
+                        stores.push({
+                            container: target.expression,
+                            contextual: false,
+                            name: literalKey(target.argumentExpression),
+                            value,
+                            path,
+                        });
+                    }
+                    else if (isIdentifier(target)) {
+                        assigned.push({ target, value, path });
+                    }
+                }
+            }
+            else if (isCallExpression(node) &&
+                isPropertyAccessExpression(node.expression) &&
+                ELEMENT_STORES.has(node.expression.name.text)) {
+                for (const argument of node.arguments) {
+                    stores.push({
+                        container: node.expression.expression,
+                        contextual: false,
+                        name: undefined,
+                        value: argument,
+                        path: [],
+                    });
+                }
+            }
+            else if (isVariableDeclaration(node) && declaresSlot(node)) {
+                slotVariables.push(node);
+                if (node.initializer !== undefined) {
+                    assigned.push({ target: node, value: node.initializer, path: [] });
+                }
+            }
+            node.forEachChild(visit);
+        };
+        file.forEachChild(visit);
+    }
+    const contextual = stores.filter((one) => one.contextual);
+    const contexts = queries.contextualTypes(contextual.map((one) => one.container)).map(must);
+    const containerOf = new Map(contextual.map((one, at) => [one, contexts[at]]));
+    const typed = stores.filter((one) => !one.contextual);
+    queries
+        .typesAt(typed.map((one) => one.container))
+        .map(must)
+        .forEach((type, at) => {
+        const one = typed[at];
+        if (one !== undefined) {
+            containerOf.set(one, type);
+        }
+    });
+    const slotTypes = new Map();
+    /** The type a slot of one object type holds: a property's, else the string index's, else an element's. */
+    const slotOf = (type, name) => {
+        const key = `${String(type.id)}\u0000${name ?? ""}`;
+        if (slotTypes.has(key)) {
+            return slotTypes.get(key);
+        }
+        let found;
+        const property = name === undefined
+            ? undefined
+            : must(queries.propertiesOf(type)).find((one) => one.name === name);
+        if (property !== undefined) {
+            found =
+                (property.flags & SymbolFlags.Property) !== 0
+                    ? must(queries.typeOfSymbol(property))
+                    : undefined;
+        }
+        else if (type.isTypeReference() && must(queries.isArray(type))) {
+            found = must(queries.typeArguments(type))[0];
+        }
+        else {
+            found = must(queries.indexInfosOf(type))[0]?.valueType;
+        }
+        slotTypes.set(key, found);
+        return found;
+    };
+    const declaredOutside = (type) => {
+        const symbol = must(queries.symbolOfType(type));
+        return (symbol !== undefined &&
+            symbol.declarations.length > 0 &&
+            symbol.declarations.every((handle) => !own.has(handle.path)));
+    };
+    /** The type of the part of a stored value its path names, a step at a time. */
+    const partOf = (type, path) => path.reduce((at, step) => (at === undefined ? undefined : slotOf(at, String(step))), type);
+    const valueTypes = queries
+        .typesAt(stores.map((one) => one.value))
+        .map((type, at) => partOf(must(type), stores[at]?.path ?? []));
+    const inside = new Map();
+    const outside = [];
+    stores.forEach((store, at) => {
+        const container = containerOf.get(store);
+        const value = valueTypes[at];
+        if (container === undefined || value === undefined) {
+            return;
+        }
+        const parts = container.isUnionType() || container.isIntersectionType()
+            ? must(queries.constituents(container))
+            : [container];
+        for (const part of parts) {
+            if (!part.isObjectType()) {
+                continue;
+            }
+            const { name } = store;
+            const erased = name !== undefined && ((slotOf(part, name)?.flags ?? 0) & ERASED) !== 0;
+            if (erased && declaredOutside(part)) {
+                outside.push({ value: store.value, type: value, property: name });
+            }
+            else {
+                inside.set(part.id, [...(inside.get(part.id) ?? []), value]);
+            }
+        }
+    });
+    const targets = assigned.map((one) => isVariableDeclaration(one.target) ? one.target.name : one.target);
+    const symbols = queries.symbolsAt(targets).map(must);
+    const slots = new Set(slotVariables);
+    const declarationOf = (symbol) => {
+        const handle = symbol?.valueDeclaration ?? symbol?.declarations[0];
+        return handle === undefined ? undefined : project.declarationAt(handle)?.node;
+    };
+    const assignedTypes = queries
+        .typesAt(assigned.map((one) => one.value))
+        .map((type, at) => partOf(must(type), assigned[at]?.path ?? []));
+    const byVariable = new Map();
+    assigned.forEach((_one, at) => {
+        const declaration = declarationOf(symbols[at]);
+        const type = assignedTypes[at];
+        if (declaration !== undefined && slots.has(declaration) && type !== undefined) {
+            byVariable.set(declaration, [...(byVariable.get(declaration) ?? []), type]);
+        }
+    });
+    return {
+        inside: (type) => inside.get(type.id) ?? [],
+        ofVariable: (node) => {
+            if (byVariable.size === 0 || !isIdentifier(node)) {
+                return undefined;
+            }
+            const [symbol] = queries.symbolsAt([node]).map(must);
+            const declaration = declarationOf(symbol);
+            return declaration === undefined ? undefined : byVariable.get(declaration);
+        },
+        outside,
+    };
+}

package/dist/src/exempt-classes.js

@@ -1,72 +1,59 @@
 /**
- * The exemption classes of the Contract's vocabulary, in its order: each class's name,
- * the languages it runs on, the confidence it is recorded at and, for a class that runs
- * on TypeScript, which private members it may retain.
- *
- * The rows are written out rather than read from the Contract at run time, for the
- * reason the fixed severity codes are, and a test holds them equal to the Contract
- * release this analyzer implements. A class name is a type, so a detector table or a
- * record naming a class the vocabulary does not hold, or one that runs on another
- * language only, does not compile.
+ * The exemption classes of the Contract's vocabulary, in its order: each class's name, its
+ * languages and, for a TypeScript class, which private members it may retain. The rows are
+ * written out, as the fixed severity codes are, and a test holds them equal to the Contract.
+ * A class name is a type, so a table or a record naming a class outside the vocabulary, or
+ * one of another language only, does not compile.
  */
 /** Every class of the vocabulary, in the order the Contract lists them. */
 export const EXEMPTION_CLASSES = [
     {
         class: "interface-satisfaction",
         languages: ["go", "ts"],
-        confidence: "certain",
         typescriptVisibility: { private: false, privateName: false },
     },
-    { class: "encoding-reflection", languages: ["go"], confidence: "certain" },
-    { class: "format-verb-contract", languages: ["go"], confidence: "certain" },
-    { class: "errors-duck-typing", languages: ["go"], confidence: "certain" },
+    { class: "encoding-reflection", languages: ["go"] },
+    { class: "format-verb-contract", languages: ["go"] },
+    { class: "errors-duck-typing", languages: ["go"] },
     {
         class: "enum-group",
         languages: ["go", "ts"],
-        confidence: "certain",
         typescriptVisibility: { private: false, privateName: false },
     },
     {
         class: "generated-file",
         languages: ["go", "ts"],
-        confidence: "certain",
         typescriptVisibility: { private: true, privateName: false },
     },
-    { class: "linkname-cgo-asm-plugin", languages: ["go"], confidence: "certain" },
+    { class: "linkname-cgo-asm-plugin", languages: ["go"] },
     {
         class: "template-field",
         languages: ["go", "ts"],
-        confidence: "possible",
         typescriptVisibility: { private: true, privateName: false },
     },
     {
         class: "reflective-lookup",
         languages: ["go", "ts"],
-        confidence: "possible",
         typescriptVisibility: { private: true, privateName: false },
     },
     {
         class: "decorator",
         languages: ["ts"],
-        confidence: "certain",
         typescriptVisibility: { private: true, privateName: false },
     },
     {
         class: "injection-container",
         languages: ["ts"],
-        confidence: "certain",
         typescriptVisibility: { private: true, privateName: false },
     },
     {
         class: "framework-lifecycle",
         languages: ["ts"],
-        confidence: "certain",
         typescriptVisibility: { private: true, privateName: false },
     },
     {
         class: "serialization-contract",
         languages: ["ts"],
-        confidence: "certain",
         typescriptVisibility: { private: true, privateName: false },
     },
 ];

package/dist/src/exempt.js

@@ -80,23 +80,11 @@ function detected(exemptionClass, detect, input) {
             .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
- * cannot retain is dropped first, whatever the detector found. Under a production mode
- * a record whose evidence is written in a test file holds nothing, as a reference a
- * test file makes is none there.
- */
-export function computeExemptions(input, detectors, holding) {
-    return detectExemptions(input, detectors, holding).records;
-}
-/** The records of {@link computeExemptions}, beside the test-file evidence it set aside. */
-export function detectExemptions(input, detectors, holding) {
-    return heldRecords(evidenceRecords(input, detectors, holding.disabled), holding);
-}
 /**
  * Every record one project's detectors found, one per piece of evidence, before the
- * mode decides which of them hold: what {@link heldRecords} reads.
+ * mode decides which of them hold: what {@link heldRecords} reads. Classes run in the
+ * vocabulary's order and a switched-off class runs not at all; evidence on a private
+ * member the class's row says it cannot retain is dropped, whatever the detector found.
  */
 export function evidenceRecords(input, detectors, disabled) {
     const visibility = new Map(input.held.symbols.map((symbol) => [symbol.id, symbol.visibility]));

package/dist/src/findings/completion.js

@@ -10,6 +10,15 @@ import { byPosition, positionKey } from "../position.js";
 import { declarationKey } from "../ref.js";
 import { FAMILY_KEY_LENGTH } from "../resolve.js";
 import { isPartSubject, isRowSubject } from "../suppress.js";
+/** The fixability grammar/analysis.md "Fixability" gives a finding about a held declaration. */
+const MANUAL = "manual";
+/** The member kinds an object property can declare, which an `in` expression tests by name. */
+const IN_TESTED = new Set([
+    "class-member",
+    "method",
+    "type-member",
+    "interface-method",
+]);
 /** The classes ranked by the claim each makes, the strongest highest. */
 const RANK = { certain: 3, probable: 2, possible: 1 };
 /** The weaker of two classes, which is a class capped by a ceiling. */
@@ -38,18 +47,39 @@ function publishedIds(union) {
         .filter((root) => root.kind === "published-api")
         .flatMap((root) => union.symbols[root.at]?.id ?? []));
 }
+/**
+ * The members whose name an `in` expression of a production file tests by a literal: a
+ * value narrowed that way is read back by the name, which no type links to the member.
+ */
+function testedByIn(input) {
+    const names = input.files.inOperands ?? new Set();
+    const union = input.swept.matrix.union;
+    if (names.size === 0) {
+        return names;
+    }
+    return new Set(union.symbols.flatMap((symbol, at) => {
+        const parent = union.symbols[union.parent[at] ?? OUTSIDE];
+        return IN_TESTED.has(symbol.kind) &&
+            parent !== undefined &&
+            symbol.name.startsWith(`${parent.name}.`) &&
+            names.has(symbol.name.slice(parent.name.length + 1))
+            ? [symbol.id]
+            : [];
+    }));
+}
 /**
  * The reachability class of one declaration of the run. A declaration of a library's
  * published API, a public member of a published type included, is `certain` where the
  * run loaded every consumer the scope declared and declared one, `probable` where one did
  * not load, and `possible` where it declared none, whatever the configuration says of the
- * consumer set. A declaration of test-support code that test code references, outside the
- * test-of-dead-code rule, is `possible`. Every other declaration is `certain`.
+ * consumer set. Test-support code test code references, outside the test-of-dead-code
+ * rule, what it contains, and a member an `in` expression tests by name are `possible`.
  */
 function reachabilityClasses(input) {
+    const tested = testedByIn(input);
     const published = publishedIds(input.swept.matrix.union);
     const usedByTests = new Set(input.swept.sweep.candidates
-        .filter((candidate) => candidate.heldByTests === candidate.id)
+        .filter((candidate) => candidate.heldByTests !== undefined)
         .map((candidate) => candidate.id));
     const { declared } = input.boundary.consumers;
     const outside = declared.length === 0
@@ -58,12 +88,35 @@ function reachabilityClasses(input) {
             ? "certain"
             : "probable";
     return (id) => {
-        if (usedByTests.has(id)) {
+        if (usedByTests.has(id) || tested.has(id)) {
             return "possible";
         }
         return published.has(id) ? outside : "certain";
     };
 }
+/**
+ * The confidence ceiling of a test of dead code: the lowest reachability class among the
+ * target symbols it references, because its deadness is theirs, whether or not they share
+ * its component. Every other declaration has none below `certain`.
+ */
+function testCeilings(input, classOf) {
+    const union = input.swept.matrix.union;
+    const tests = new Set(input.swept.sweep.candidates.filter((one) => one.testOfDeadCode).map((one) => one.id));
+    return (id) => {
+        let lowest = "certain";
+        if (!tests.has(id)) {
+            return lowest;
+        }
+        for (const edge of union.out[union.at(id)] ?? []) {
+            const target = union.symbols[edge.to];
+            const testCode = union.test[edge.to] === true || union.support[edge.to] === true;
+            if (target !== undefined && !testCode && union.subject[edge.to] === true) {
+                lowest = capped(lowest, classOf(target.id));
+            }
+        }
+        return lowest;
+    };
+}
 /**
  * The component each dead declaration of the run falls in, and none for a live one, with
  * its members listed in the canonical order where the run lists a component in full.
@@ -120,7 +173,9 @@ export function completed(input, findings, kinds = KINDS) {
     const positions = new Map(union.symbols.map((symbol, at) => [declarationKey(symbol.ref, symbol.position.path), at]));
     const candidates = new Map(swept.sweep.candidates.map((candidate) => [candidate.id, candidate]));
     const classOf = reachabilityClasses(input);
+    const ceilingOf = testCeilings(input, classOf);
     const componentOf = findingComponents(swept, input.config.reporters.cascade);
+    const held = new Set(swept.sweep.components.filter((one) => one.held).flatMap((one) => one.members));
     let minted = swept.sweep.components.length;
     const dead = new Set(swept.sweep.components.map((component) => component.id));
     const fallingWith = new Map();
@@ -173,6 +228,17 @@ export function completed(input, findings, kinds = KINDS) {
             : { production: candidate.productionRefs, test: candidate.testRefs };
         const reachabilityClass = judged === undefined ? (finding.reachabilityClass ?? "certain") : classOf(judged.id);
         const generated = input.files.generated?.has(finding.position.path) === true;
+        const fixability = generated
+            ? "none"
+            : found !== undefined &&
+                symbol !== undefined &&
+                held.has(symbol.id) &&
+                row.findingFixabilities?.includes(MANUAL) === true
+                ? MANUAL
+                : row.fixability;
+        const lastUses = fixability === "deletable" && candidate !== undefined
+            ? input.dependencies.lastUses.get(candidate.id)
+            : undefined;
         return {
             code: finding.code,
             kind: row.name,
@@ -180,7 +246,7 @@ export function completed(input, findings, kinds = KINDS) {
             position: finding.position,
             symbol: finding.symbol,
             reachabilityClass,
-            confidence: capped(reachabilityClass, row.maxClass),
+            confidence: capped(capped(reachabilityClass, row.maxClass), judged === undefined ? "certain" : ceilingOf(judged.id)),
             ...(candidate === undefined ? {} : { livenessRelation: candidate.relation }),
             testOnly: judged !== undefined && counts?.production === 0 && counts.test > 0,
             generated,
@@ -191,10 +257,12 @@ export function completed(input, findings, kinds = KINDS) {
                     ? swept.matrix.configurations
                     : (swept.matrix.heldIn[at] ?? swept.matrix.configurations)),
             consumersLoaded: input.boundary.consumers.loaded,
-            fixability: generated ? "none" : row.fixability,
+            fixability,
             severity: severityOf(input, finding.code, row.defaultSeverity),
             message: finding.message,
-            details: finding.details ?? {},
+            details: lastUses === undefined
+                ? (finding.details ?? {})
+                : { ...finding.details, removesLastUseOf: lastUses },
         };
     });
     return componentCapped(done, dead);
@@ -229,23 +297,17 @@ function dialed(finding, minConfidence) {
  * below the minimum confidence is withheld, and so is every finding of the component of a
  * root the dials withhold, because a symbol that falls with a root is dead only through it
  * and its deletion does not compile while the root stays. A withheld finding that is no
- * root withholds itself alone. A code is withheld from a declaration when the finding it
- * would report there, completed, is withheld by its own severity or confidence.
+ * root withholds itself alone.
  */
 export function dialsOf(input, findings) {
     const minConfidence = input.config.analysis.minConfidence;
-    const classOf = reachabilityClasses(input);
     const components = new Set(findings
         .filter((finding) => finding.component.root && dialed(finding, minConfidence))
         .map((finding) => finding.component.id));
     return {
-        withholdsCode: (code, id) => {
+        allows: (code) => {
             const row = KINDS.get(code);
-            return (row !== undefined &&
-                dialed({
-                    severity: severityOf(input, code, row.defaultSeverity),
-                    confidence: capped(classOf(id), row.maxClass),
-                }, minConfidence));
+            return row !== undefined && severityOf(input, code, row.defaultSeverity) === "allow";
         },
         withholds: (finding) => dialed(finding, minConfidence) || components.has(finding.component.id),
     };

package/dist/src/findings/dependencies-and-module-machinery.js

@@ -12,7 +12,7 @@ const MESSAGES = {
  */
 function unusedDependencies(dependencies) {
     return dependencies.declared
-        .filter((dependency) => !dependencies.needed.has(dependency.name) &&
+        .filter((dependency) => !dependencies.needed.has(declarationKey(dependency)) &&
         !dependencies.ran.has(declarationKey(dependency)))
         .map((dependency) => ({
         code: UNUSED_DEPENDENCY,

package/dist/src/findings/emitters.js

@@ -64,7 +64,7 @@ function dialsOver(input, found, suppressed, unmarked) {
     const before = dialsOf(suppressed.unmarked, unmarked);
     const fromUnmarked = new Set(unmarked);
     return {
-        withholdsCode: marked.withholdsCode,
+        allows: marked.allows,
         withholds: (finding) => fromUnmarked.has(finding) ? before.withholds(finding) : marked.withholds(finding),
     };
 }
@@ -130,7 +130,3 @@ function withheldOf(input, candidates) {
     }
     return counts;
 }
-/** Every finding the run reports, each family's in table order. */
-export function findingsOf(input) {
-    return decidedFindings(input).findings;
-}