@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.20

package/dist/src/findings/completion.js

@@ -3,29 +3,20 @@
  * the code's row of the issue-kind vocabulary, and the dials that withhold a finding
  * together with every finding that falls with a root they withhold.
  */
-import { componentId } from "../components.js";
-import { deadComponents } from "../matrix.js";
-import { OUTSIDE } from "../graph.js";
+import { CODE, FAMILY_KEY_LENGTH, KIND_ROWS, } from "../contract/contract.generated.js";
+import { componentId } from "../liveness/components.js";
+import { deadComponents } from "../liveness/sweep.js";
+import { OUTSIDE } from "../liveness/graph.js";
 import { KINDS } from "../kinds.js";
 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 unused-file code, whose deletion removes every use its file writes. */
-const FILE_NEVER_IMPORTED = "DS1502";
 /**
- * The codes whose subject the run that counts test references holds live, as
- * finding.schema.json lists them, so a test file's candidate reported under one carries
- * none of a dead declaration's sweep facts.
+ * The codes whose subject the run that counts test references holds live, so a test
+ * file's candidate reported under one carries none of a dead declaration's sweep facts.
  */
-const LIVE_SUBJECT = new Set([
-    "DS1101",
-    "DS1102",
-    "DS1104",
-    "DS1204",
-    "DS1301",
-]);
-/** The fixability grammar/analysis.md "Fixability" gives a finding about a held declaration. */
+const LIVE_SUBJECT = new Set(KIND_ROWS.filter((row) => row.holdsLive).map((row) => row.code));
+/** The fixability grammar/analysis/fixability.md 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([
@@ -50,8 +41,9 @@ function everyDeclaredLoaded(boundary) {
  * naming its family, else the code's default.
  */
 function severityOf(input, code, fallback) {
-    const { config } = input;
-    return (config.severity.get(code) ?? config.severity.get(code.slice(0, FAMILY_KEY_LENGTH)) ?? fallback);
+    const { severity } = input.config;
+    const key = [code, code.slice(0, FAMILY_KEY_LENGTH)].find((one) => Object.hasOwn(severity, one));
+    return key === undefined ? fallback : (severity[key] ?? fallback);
 }
 /**
  * The declarations the roots name as a library's published API, each public member of a
@@ -87,10 +79,13 @@ function testedByIn(input) {
  * 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 member an `in` expression tests by name is `possible`.
+ * consumer set. A member an `in` expression tests by name, one a function outside the
+ * analysis fills, and one {@link possiblyLoaded} names, is `possible`.
  */
-function reachabilityClasses(input) {
+export function reachabilityClasses(input) {
     const tested = testedByIn(input);
+    const filled = input.boundary.filledOutside ?? new Set();
+    const possible = possiblyLoaded(input);
     const published = publishedIds(input.swept.matrix.union);
     const { declared } = input.boundary.consumers;
     const outside = declared.length === 0
@@ -99,7 +94,7 @@ function reachabilityClasses(input) {
             ? "certain"
             : "probable";
     return (id) => {
-        if (tested.has(id)) {
+        if (tested.has(id) || filled.has(id) || possible.has(id)) {
             return "possible";
         }
         return published.has(id) ? outside : "certain";
@@ -130,9 +125,38 @@ function testCeilings(input, classOf) {
         ? testTargets(union, id).reduce((lowest, target) => capped(lowest, classOf(target)), "certain")
         : "certain";
 }
+/**
+ * What only a bundler's retry of an import Node leaves unresolved names (program.38), and each
+ * dead declaration that reaches through dead declarations, as confidence.20 reads what only
+ * tests reach: each is dead only while no loader the analysis does not see loads the file.
+ */
+function possiblyLoaded(input) {
+    const seeds = input.boundary.possiblyLoaded ?? new Set();
+    if (seeds.size === 0) {
+        return seeds;
+    }
+    const union = input.swept.matrix.union;
+    const dead = new Set(input.swept.sweep.candidates.map((one) => one.id));
+    const reached = new Set();
+    const pending = union.symbols.flatMap((symbol, at) => (seeds.has(symbol.id) ? [at] : []));
+    for (let at = pending.pop(); at !== undefined; at = pending.pop()) {
+        const symbol = union.symbols[at];
+        if (symbol === undefined || reached.has(symbol.id)) {
+            continue;
+        }
+        reached.add(symbol.id);
+        for (const edge of union.out[at] ?? []) {
+            const to = union.symbols[edge.to];
+            if (to !== undefined && dead.has(to.id)) {
+                pending.push(edge.to);
+            }
+        }
+    }
+    return reached;
+}
 /**
  * The subjects dead only because production code only tests use is: each declaration the
- * sweep marks test-used, each `DS1502` file of such code, and each test of dead code every
+ * sweep marks test-used, each `DS1602` file of such code, and each test of dead code every
  * target of which is one. Nothing they hold references a dead declaration outside them, so
  * the rest of a component they share is reported without them.
  */
@@ -151,13 +175,16 @@ function testUsedSubjects(input) {
 }
 /**
  * The ceiling the roots the run found put on one dead subject: a subject other declarations
- * reference, found dead only because no root reaches them, is `probable` unless
- * the configuration declares the roots complete, because a root the analysis cannot see
- * would make it live; every other declaration has none below `certain`.
+ * reference, found dead only because no root reaches them, is `probable` unless the
+ * configuration declares the roots complete and no configuration holding the subject loads
+ * a module the analysis cannot resolve, because a root the analysis cannot see would make
+ * it live; every other declaration has none below `certain`.
  */
-function rootsCeiling(input, finding, candidate) {
+function rootsCeiling(input, finding, candidate, configurations) {
     const unreachable = candidate?.relation === "reachability" || finding.unreachableOnly === true;
-    return unreachable && !input.config.ts.rootsComplete ? "probable" : "certain";
+    const unseen = new Set((input.files.unseenLoads ?? []).map((load) => load.configuration));
+    const complete = input.config.ts.roots_complete && !configurations.some((one) => unseen.has(one));
+    return unreachable && !complete ? "probable" : "certain";
 }
 /**
  * The component each dead declaration of the run falls in, and none for a live one, with
@@ -170,8 +197,24 @@ function findingComponents(swept, components, cascade) {
             held.set(member, component);
         }
     }
+    const listed = membersListed(swept);
+    return (id) => {
+        const component = held.get(id);
+        return component === undefined
+            ? undefined
+            : {
+                id: component.id,
+                root: component.roots.includes(id),
+                symbolCount: component.members.length,
+                deletableLines: component.deletableLines,
+                ...(cascade === "full" ? { members: listed(component.members) } : {}),
+            };
+    };
+}
+/** The members of a component as the run lists them, positioned and in the canonical order. */
+function membersListed(swept) {
     const symbols = new Map(swept.matrix.union.symbols.map((symbol) => [symbol.id, symbol]));
-    const listed = (component) => component.members
+    return (members) => members
         .flatMap((member) => {
         const symbol = symbols.get(member);
         return symbol === undefined
@@ -188,27 +231,15 @@ function findingComponents(swept, components, cascade) {
             ];
     })
         .sort((a, b) => byPosition(a.position, b.position));
-    return (id) => {
-        const component = held.get(id);
-        return component === undefined
-            ? undefined
-            : {
-                id: component.id,
-                root: component.roots.includes(id),
-                symbolCount: component.members.length,
-                deletableLines: component.deletableLines,
-                ...(cascade === "full" ? { members: listed(component) } : {}),
-            };
-    };
 }
 /**
- * The run's dead components with each file a `DS1502` finding reports dead among them, so
+ * The run's dead components with each file a `DS1602` finding reports dead among them, so
  * the file's declarations fall with it, and with the components each subject that is no
  * declaration falls with joined into one.
  */
 function runComponents(swept, findings) {
     const union = swept.matrix.union;
-    const reported = new Set(findings.filter((one) => one.code === FILE_NEVER_IMPORTED).map((one) => one.position.path));
+    const reported = new Set(findings.filter((one) => one.code === CODE.fileNeverImported).map((one) => one.position.path));
     const files = new Map(union.symbols.flatMap((symbol, at) => symbol.kind === "file" && reported.has(symbol.position.path) ? [[at, symbol]] : []));
     const computed = files.size === 0
         ? swept.sweep.components
@@ -267,6 +298,7 @@ export function completed(input, findings, kinds = KINDS) {
     const union = swept.matrix.union;
     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 fileIds = new Map(union.symbols.flatMap((one) => (one.kind === "file" ? [[one.position.path, one.id]] : [])));
     const classOf = reachabilityClasses(input);
     const ceilingOf = testCeilings(input, classOf);
     const testUsed = testUsedSubjects(input);
@@ -277,11 +309,12 @@ export function completed(input, findings, kinds = KINDS) {
     let minted = computed;
     const dead = new Set(components.map((component) => component.id));
     const fallingWith = new Map();
-    for (const { heldByTests } of swept.sweep.candidates) {
+    for (const { id, heldByTests } of swept.sweep.candidates) {
         if (heldByTests !== undefined) {
-            fallingWith.set(heldByTests, (fallingWith.get(heldByTests) ?? 0) + 1);
+            fallingWith.set(heldByTests, [...(fallingWith.get(heldByTests) ?? []), id]);
         }
     }
+    const listed = membersListed(swept);
     const done = findings.map((finding) => {
         const row = kinds.get(finding.code);
         if (row === undefined) {
@@ -307,7 +340,7 @@ export function completed(input, findings, kinds = KINDS) {
             : candidates.get(judged.id);
         const fallsWith = finding.fallsWith?.[0];
         const joined = fallsWith === undefined ? undefined : componentOf(fallsWith);
-        const file = finding.code === FILE_NEVER_IMPORTED ? files.get(finding.position.path) : undefined;
+        const file = finding.code === CODE.fileNeverImported ? files.get(finding.position.path) : undefined;
         const found = joined !== undefined
             ? { ...joined, root: false }
             : file !== undefined
@@ -326,22 +359,45 @@ export function completed(input, findings, kinds = KINDS) {
         let component = found;
         if (component === undefined) {
             minted += 1;
+            const falling = symbol?.kind === "interface" ? fallingWith.get(symbol.id) : undefined;
             component = {
                 id: componentId(minted),
                 root: true,
-                symbolCount: symbol?.kind === "interface" ? (fallingWith.get(symbol.id) ?? 1) : 1,
+                symbolCount: falling?.length ?? 1,
                 deletableLines: 0,
+                ...(input.config.reporters.cascade !== "full"
+                    ? {}
+                    : falling === undefined
+                        ? {
+                            members: [
+                                {
+                                    ref: finding.symbol.ref,
+                                    name: finding.symbol.name,
+                                    position: finding.position,
+                                },
+                            ],
+                        }
+                        : { members: listed(falling) }),
             };
         }
         const counts = candidate === undefined
             ? union.made[at]
             : { production: candidate.productionRefs, test: candidate.testRefs };
-        const ownClass = judged === undefined ? (finding.reachabilityClass ?? "certain") : classOf(judged.id);
+        const ownClass = judged !== undefined
+            ? classOf(judged.id)
+            : (finding.reachabilityClass ??
+                (finding.code === CODE.fileNeverImported
+                    ? classOf(fileIds.get(finding.position.path) ?? "")
+                    : "certain"));
         const used = judged !== undefined
             ? candidate !== undefined && testUsed.declarations.has(judged.id)
-            : finding.code === FILE_NEVER_IMPORTED && testUsed.files.has(finding.position.path);
+            : finding.code === CODE.fileNeverImported && testUsed.files.has(finding.position.path);
         const reachabilityClass = used && candidate?.testOfDeadCode !== true ? "possible" : ownClass;
-        const untested = capped(capped(capped(ownClass, row.maxClass), rootsCeiling(input, finding, candidate)), judged === undefined ? "certain" : ceilingOf(judged.id));
+        const configurations = candidate?.configurations ??
+            (judged === undefined && !part
+                ? swept.matrix.configurations
+                : (swept.matrix.heldIn[at] ?? swept.matrix.configurations));
+        const untested = capped(capped(capped(ownClass, row.maxClass), rootsCeiling(input, finding, candidate, configurations)), judged === undefined ? "certain" : ceilingOf(judged.id));
         const generated = input.files.generated?.has(finding.position.path) === true;
         const fixability = generated
             ? "none"
@@ -355,7 +411,7 @@ export function completed(input, findings, kinds = KINDS) {
             ? undefined
             : candidate !== undefined
                 ? input.dependencies.lastUses.get(candidate.id)
-                : finding.code === FILE_NEVER_IMPORTED
+                : finding.code === CODE.fileNeverImported
                     ? input.dependencies.fileLastUses.get(finding.position.path)
                     : undefined;
         return {
@@ -372,10 +428,7 @@ export function completed(input, findings, kinds = KINDS) {
             generated,
             component,
             retainedBy: [],
-            configurations: candidate?.configurations ??
-                (judged === undefined && !part
-                    ? swept.matrix.configurations
-                    : (swept.matrix.heldIn[at] ?? swept.matrix.configurations)),
+            configurations,
             consumersLoaded: input.boundary.consumers.loaded,
             fixability,
             severity: severityOf(input, finding.code, row.defaultSeverity),
@@ -431,7 +484,7 @@ function dialed(finding, minConfidence) {
  * root withholds itself alone.
  */
 export function dialsOf(input, findings) {
-    const minConfidence = input.config.analysis.minConfidence;
+    const minConfidence = input.config.analysis.min_confidence;
     const components = new Set(findings
         .filter((finding) => finding.component.root &&
         dialed({ ...finding, confidence: componentConfidenceOf(finding) }, minConfidence))

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

@@ -1,8 +1,7 @@
+import { CODE } from "../contract/contract.generated.js";
 import { declarationKey } from "../dependencies.js";
 import { renderRef } from "../ref.js";
 import { nonCodeArtifacts } from "./non-code-artifacts.js";
-const UNUSED_DEPENDENCY = "DS1601";
-const FILE_NEVER_IMPORTED = "DS1502";
 const MESSAGES = {
     dependency: "no import in the target needs the declared dependency",
     "dev-dependency": "no import in the target needs the declared development dependency",
@@ -25,7 +24,7 @@ function deadCode(input) {
     const reachedOnly = new Set(swept.sweep.candidates.filter((one) => one.relation === "reachability").map((one) => one.id));
     for (const finding of nonCodeArtifacts(input)) {
         const id = files.get(finding.position.path);
-        if (finding.code === FILE_NEVER_IMPORTED && id !== undefined) {
+        if (finding.code === CODE.fileNeverImported && id !== undefined) {
             dead.add(id);
             if (finding.unreachableOnly === true) {
                 reachedOnly.add(id);
@@ -57,7 +56,7 @@ function unusedDependencies(input, dependencies) {
         const atPossible = unbuilt || users?.some((id) => published.has(id)) === true;
         return [
             {
-                code: UNUSED_DEPENDENCY,
+                code: CODE.unusedDependency,
                 position: dependency.position,
                 symbol: {
                     ref: renderRef(dependency.manifest, {
@@ -80,5 +79,5 @@ function unusedDependencies(input, dependencies) {
         ];
     });
 }
-/** The findings of the dependencies-and-module-machinery family, `DS1600` to `DS1699`. */
+/** The findings of the dependencies family, `DS1700` to `DS1799`. */
 export const dependenciesAndModuleMachinery = (input) => unusedDependencies(input, input.dependencies);

package/dist/src/findings/emitters.js

@@ -1,5 +1,4 @@
 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";
@@ -8,11 +7,11 @@ import { dependenciesAndModuleMachinery } from "./dependencies-and-module-machin
 import { interfaces } from "./interfaces.js";
 import { intraFunction } from "./intra-function.js";
 import { nonCodeArtifacts } from "./non-code-artifacts.js";
-import { readsAndWrites } from "./reads-and-writes.js";
+import { fallingWithWrites, readsAndWrites } from "./reads-and-writes.js";
 import { selfCheck } from "./self-check.js";
 import { fallenMembers, unusedDeclarations } from "./unused-declarations.js";
 import { visibilityNarrowing } from "./visibility-narrowing.js";
-/** Every kind family this analyzer reports, each by its emitter, in code order. */
+/** Every emitter this analyzer runs, by the name its tests select it by. */
 export const EMITTERS = new Map([
     ["unused-declarations", unusedDeclarations],
     ["visibility-narrowing", visibilityNarrowing],
@@ -23,37 +22,25 @@ export const EMITTERS = new Map([
     ["self-check", selfCheck],
     ["intra-function", intraFunction],
 ]);
-/**
- * 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 heldKeys(input) {
-    const held = new Set(input.swept.heldByUnanswered);
-    if (held.size === 0) {
-        return held;
-    }
+/** The keys of the declarations the identifiers name, as {@link findingKey} keys a finding. */
+function keysOf(input, ids) {
+    const named = new Set(ids);
     return new Set(input.swept.matrix.union.symbols
-        .filter((symbol) => held.has(symbol.id))
+        .filter((symbol) => named.has(symbol.id))
         .map((symbol) => declarationKey(symbol.ref, symbol.position.path)));
 }
+/** The key of the declaration a finding is about, or of the one holding the part it is about. */
+function findingKey(finding) {
+    return declarationKey(finding.symbol.holder ?? finding.symbol.ref, finding.position.path);
+}
 /**
- * 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.
+ * Every emitter's findings over one sweep, and those of any further emitter, completed by
+ * one step, but none about a declaration that falls with a write-only subject: that
+ * subject's finding names it, so no finding about it exists for a record to match.
  */
-function markupKeys(input) {
-    const { swept } = input;
-    if (swept.componentFiles.length === 0) {
-        return new Set();
-    }
-    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) => 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) {
-    return completed(input, [...EMITTERS.values(), ...more].flatMap((emit) => emit(input)));
+    const falls = keysOf(input, fallingWithWrites(input));
+    return completed(input, [...EMITTERS.values(), ...more].flatMap((emit) => emit(input))).filter((finding) => !falls.has(findingKey(finding)));
 }
 /**
  * The dials over the findings a record could name, each read against the sweep that
@@ -70,8 +57,8 @@ function dialsOver(input, found, suppressed, unmarked) {
 }
 /**
  * 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
+ * emitter'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 emitter
  * 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.
  */
@@ -86,7 +73,7 @@ function atPossible(input) {
     const { config } = input;
     return {
         ...input,
-        config: { ...config, analysis: { ...config.analysis, minConfidence: "possible" } },
+        config: { ...config, analysis: { ...config.analysis, min_confidence: "possible" } },
     };
 }
 /**
@@ -96,16 +83,15 @@ function atPossible(input) {
  */
 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 candidates = found.filter((finding) => {
-        const key = declarationKey(finding.symbol.holder ?? finding.symbol.ref, finding.position.path);
-        return (!ledger.withheld(finding) &&
-            !unanswered.has(key) &&
-            !markup.has(key) &&
-            !insideSkipped(input.swept.skipped, finding.position));
-    });
+    const { sweep } = input.swept;
+    // A hold is a gap of the analysis, which leaves a record it touches dormant; a live
+    // component file's markup is no gap, so a record on one of its bindings stays in effect.
+    const unanswered = keysOf(input, sweep.held);
+    const markup = keysOf(input, sweep.bindings);
+    const heldIds = new Set(sweep.held);
+    const held = (finding) => unanswered.has(findingKey(finding)) || insideSkipped(input.swept.skipped, finding.position);
+    const ledger = ledgerOf(suppressed.records, would, dialsOver(input, found, suppressed, unmarked), { withholds: held, holdsRecord: (record) => heldIds.has(record.bound) });
+    const candidates = found.filter((finding) => !ledger.withheld(finding) && !held(finding) && !markup.has(findingKey(finding)));
     const kept = reportable(input, candidates);
     const evaluated = evaluateEdges(kept, input.boundary.edges, input.swept.matrix.union.symbols);
     return {

package/dist/src/{implementations.js → findings/implementations.js}

@@ -7,9 +7,9 @@
  */
 import { isClassDeclaration, isHeritageClause, isInterfaceDeclaration, isMethodDeclaration, SyntaxKind, } from "@typescript/native/ast";
 import { SymbolFlags } from "@typescript/native/sync";
-import { aliasChains } from "./alias-chain.js";
-import { nodeKey } from "./inventory.js";
-import { must, Unanswerable } from "./query.js";
+import { aliasChains } from "../alias-chain.js";
+import { nodeKey } from "../inventory.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 = [];

package/dist/src/{in-operands.js → findings/in-operands.js}

@@ -4,7 +4,8 @@
  * links the read to a declaration, so only a text match can tell which member it reads.
  */
 import { isBinaryExpression, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
-import { sourceFilesOf } from "./source-files.js";
+import { sourceFilesOf } from "../source-files.js";
+import { bytewise } from "../text/compare.js";
 /**
  * The text of each string literal, or template literal with no substitution, written as
  * the left operand of an `in` expression in a file of the project that is no test file.
@@ -26,5 +27,5 @@ export function inOperandNames(project, targetRoot, testFiles) {
             file.forEachChild(visit);
         }
     }
-    return [...found].sort();
+    return [...found].sort(bytewise);
 }

package/dist/src/findings/interfaces.js

@@ -1,6 +1,5 @@
+import { CODE } from "../contract/contract.generated.js";
 import { byPosition } from "../position.js";
-const UNUSED_INTERFACE = "DS1201";
-const UNCALLED_INTERFACE_METHOD = "DS1203";
 /** What each finding says, by what the sweep found about the subject's references. */
 const UNUSED_MESSAGE = "nothing in the target names the interface as a type";
 const UNUSED_DEAD_MESSAGE = "the interface is named as a type only from declarations that are themselves dead";
@@ -45,7 +44,7 @@ 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, whose members fall with it unreported; and `DS1202`, 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, save an interface
@@ -60,7 +59,7 @@ export const interfaces = (input) => {
             continue;
         }
         if (symbol.kind === "interface") {
-            found.push(findingOf(UNUSED_INTERFACE, symbol, unusedMessage(candidate), run.implementationsOf(candidate.id)));
+            found.push(findingOf(CODE.unusedInterface, symbol, unusedMessage(candidate), run.implementationsOf(candidate.id)));
             continue;
         }
         if (symbol.kind !== "interface-method" ||
@@ -69,7 +68,7 @@ export const interfaces = (input) => {
             marker(input, candidate.id)) {
             continue;
         }
-        found.push(findingOf(UNCALLED_INTERFACE_METHOD, symbol, UNCALLED_MESSAGE, run.implementationsOf(symbol.parent)));
+        found.push(findingOf(CODE.uncalledInterfaceMethod, symbol, UNCALLED_MESSAGE, run.implementationsOf(symbol.parent)));
     }
     return found;
 };

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

@@ -1,7 +1,8 @@
+import { CODE } from "../contract/contract.generated.js";
 import { KINDS } from "../kinds.js";
 import { parameterRef } from "../ref.js";
-import { UNUSED_PARAMETER, UNUSED_RESULT } from "../intra-function-parts.js";
-import { reachedWithTheTests } from "../sweep.js";
+import {} from "../intra-function-parts.js";
+import { reachedWithTheTests } from "../liveness/sweep.js";
 /** A list of rules as a sentence names them. */
 function spelled(rules) {
     if (rules.length < 2) {
@@ -28,7 +29,8 @@ function overlapClause(overlap, part) {
  * caller may pass a function used as a value more arguments than it declares, so there one
  * a read parameter follows is renamed to an underscore name, which the compilers read as
  * declared unread, and one no read parameter follows is deleted: kept where the call's
- * inference may read its annotation, at `probable` where nothing reads the annotation.
+ * inference may read its annotation, at `probable` where nothing reads the annotation or
+ * where it is a name a contextually typed object pattern binds.
  */
 function parameterVerdict(part, free, freeButValued) {
     const place = part.parameter;
@@ -45,7 +47,8 @@ function parameterVerdict(part, free, freeButValued) {
     if (place?.annotated === "steers") {
         return undefined;
     }
-    return { fix: "delete", confidence: place?.annotated === "free" ? "probable" : "certain" };
+    const unseen = place?.annotated === "free" || place?.contextualPattern === true;
+    return { fix: "delete", confidence: unseen ? "probable" : "certain" };
 }
 /**
  * Whether one part is reported. A parameter needs its function's signature free to
@@ -60,9 +63,9 @@ function reported(input, part, callersUnknown) {
     }
     const { free, freeButValued, discardedEverywhere } = input.intraFunction;
     switch (part.code) {
-        case UNUSED_PARAMETER:
+        case CODE.unusedParameter:
             return parameterVerdict(part, free, freeButValued) !== undefined;
-        case UNUSED_RESULT:
+        case CODE.unusedResult:
             return (free.has(part.declaration) &&
                 discardedEverywhere.has(part.declaration) &&
                 !callersUnknown.has(part.declaration));
@@ -71,7 +74,7 @@ function reported(input, part, callersUnknown) {
     }
 }
 /**
- * The findings of the intra-function family, `DS1800` to `DS1899`, each about a part of
+ * The findings of the inside-functions family, `DS1401` to `DS1406`, each about a part of
  * the declaration its reference names, at the part's own position, whatever the sweep
  * decided about a production declaration. A part of test code is reported only where the
  * run that counts test references reaches its declaration and that is no test of dead
@@ -81,8 +84,8 @@ export const intraFunction = (input) => {
     const union = input.swept.matrix.union;
     const byId = new Map(union.symbols.map((symbol) => [symbol.id, symbol]));
     const reached = reachedWithTheTests(union, [
-        ...input.swept.exempt.map((record) => record.id),
-        ...input.swept.heldByUnanswered,
+        ...input.swept.sweep.exempt.map((record) => record.id),
+        ...input.swept.sweep.held,
     ]);
     const testsOfDeadCode = new Set(input.swept.sweep.candidates.filter((one) => one.testOfDeadCode).map((one) => one.id));
     const judged = (id) => {
@@ -95,7 +98,7 @@ export const intraFunction = (input) => {
         return symbol === undefined ? [] : [symbol.id];
     }));
     const { declared, loaded } = input.boundary.consumers;
-    const closed = input.config.consumersComplete && declared.every((id) => loaded.includes(id));
+    const closed = input.config.consumers.complete && declared.every((id) => loaded.includes(id));
     const published = (id) => {
         const symbol = byId.get(id);
         return (symbol !== undefined &&
@@ -112,11 +115,11 @@ export const intraFunction = (input) => {
     const found = [];
     for (const part of input.intraFunction.parts) {
         const declaration = byId.get(part.declaration);
-        const overlap = KINDS.get(part.code)?.overlap ?? [];
+        const overlap = KINDS.get(part.code)?.overlap?.ts ?? [];
         if (declaration === undefined || !judged(declaration.id) || !reported(input, part, unknown)) {
             continue;
         }
-        const verdict = part.code === UNUSED_PARAMETER
+        const verdict = part.code === CODE.unusedParameter
             ? parameterVerdict(part, input.intraFunction.free, input.intraFunction.freeButValued)
             : undefined;
         const message = verdict?.fix === "rename"
@@ -126,7 +129,7 @@ export const intraFunction = (input) => {
             code: part.code,
             position: part.position,
             symbol: {
-                ...(part.code === UNUSED_PARAMETER
+                ...(part.code === CODE.unusedParameter
                     ? { ref: parameterRef(declaration.ref, part.name), holder: declaration.ref }
                     : { ref: declaration.ref }),
                 kind: part.kind,