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

package/dist/src/entry-points.js

@@ -10,14 +10,16 @@
  * value that is not a literal is not evaluated and not guessed, so a file it would
  * have named is entered by nothing here.
  */
-import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isExportAssignment, isIdentifier, isMetaProperty, isNewExpression, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isStringLiteral, isTemplateExpression, SyntaxKind, } from "@typescript/native/ast";
+import { isArrayLiteralExpression, isAsExpression, isCallExpression, isExportAssignment, isIdentifier, isMetaProperty, isNewExpression, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
 import { SymbolFlags } from "@typescript/native/sync";
 import { configurationFiles, filesNamedBy, moduleStrings, } from "./configuration-files.js";
+import { buildScriptEntries } from "./build-scripts.js";
 import { globExpression } from "./glob.js";
 import { htmlEntries } from "./html-entries.js";
 import { documentEntries } from "./mdx-entries.js";
 import { dirnamePath, relativePath, resolvePath } from "./paths.js";
 import { UNANSWERED } from "./query.js";
+import { computedLoadDirectory, leadingLiteral } from "./unseen-loads.js";
 import { workflowEntries } from "./workflow-steps.js";
 /** The extensions the test runner and the browser-test runner load a configuration from. */
 const MODULE_EXTENSIONS = ["js", "mjs", "cjs", "ts", "mts", "cts"];
@@ -210,7 +212,7 @@ function configurationEntries(host, targetRoot, files, parse, selected) {
         strings(dirnamePath(document.path), unselectedIn(document.path, document.strings));
     }
     for (const { file } of outside) {
-        strings(dirnamePath(file.fileName), moduleStrings(file).map((one) => one.text));
+        strings(dirnamePath(file.fileName), unselected(file));
     }
     return found;
 }
@@ -398,17 +400,6 @@ function workersOf(project, file, files) {
     }
     return found;
 }
-/** The literal text a computed path starts with: a template's head, or a concatenation's first literal. */
-function leadingLiteral(node) {
-    const at = unwrapped(node);
-    if (isTemplateExpression(at)) {
-        return at.head.text;
-    }
-    if (isBinaryExpression(at) && at.operatorToken.kind === SyntaxKind.PlusToken) {
-        return literalOf(unwrapped(at.left)) ?? leadingLiteral(at.left);
-    }
-    return undefined;
-}
 /** Whether one call is `import.meta.glob(...)`. */
 function isMetaGlob(node) {
     if (!isCallExpression(node) || !isPropertyAccessExpression(node.expression)) {
@@ -432,11 +423,8 @@ function computedImportsOf(file, files) {
     const dir = dirnamePath(file.fileName);
     const found = [];
     const below = (prefix) => {
-        const target = resolvePath(dir, prefix);
-        if (!isModuleRelative(prefix) ||
-            !prefix.endsWith("/") ||
-            target === dir ||
-            relativePath(target, dir) !== undefined) {
+        const target = computedLoadDirectory(dir, prefix);
+        if (target === undefined) {
             return;
         }
         for (const candidate of files.byName.values()) {
@@ -522,6 +510,9 @@ export function entryPoints(project, files, testFiles, host, targetRoot, parse,
             ...(names === undefined ? {} : { names }),
         });
     }
+    for (const { file, source } of buildScriptEntries(host, targetRoot, files, parse)) {
+        found.push({ file, rule: "bundler-entry", source, exports: true });
+    }
     for (const { file, source } of workflowEntries(host, targetRoot, files)) {
         found.push({ file, rule: "workflow-step", source, exports: true });
     }

package/dist/src/findings/completion.js

@@ -105,6 +105,32 @@ function reachabilityClasses(input) {
         return published.has(id) ? outside : "certain";
     };
 }
+/**
+ * Whether one test of dead code references a target symbol that is published API of a run
+ * that declares no consumer, which outside programs the run cannot see may use, so the
+ * target counts as live for the test and the test is no test of dead code.
+ */
+export function testsUnseenAPI(input) {
+    if (input.boundary.consumers.declared.length > 0) {
+        return () => false;
+    }
+    const union = input.swept.matrix.union;
+    const published = publishedIds(union);
+    return (id) => testTargets(union, id).some((target) => published.has(target));
+}
+/** The target symbols one test of dead code references, by id: production declarations the sweep judges. */
+function testTargets(union, id) {
+    return (union.out[union.at(id)] ?? []).flatMap((edge) => {
+        const target = union.symbols[edge.to];
+        const testCode = union.test[edge.to] === true || union.support[edge.to] === true;
+        return target !== undefined &&
+            !testCode &&
+            union.ambient[edge.to] !== true &&
+            union.subject[edge.to] === true
+            ? [target.id]
+            : [];
+    });
+}
 /**
  * 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
@@ -113,33 +139,41 @@ function reachabilityClasses(input) {
 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.ambient[edge.to] !== true &&
-                union.subject[edge.to] === true) {
-                lowest = capped(lowest, classOf(target.id));
-            }
+    return (id) => tests.has(id)
+        ? testTargets(union, id).reduce((lowest, target) => capped(lowest, classOf(target)), "certain")
+        : "certain";
+}
+/**
+ * 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
+ * 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.
+ */
+function testUsedSubjects(input) {
+    const { matrix, sweep } = input.swept;
+    const union = matrix.union;
+    const used = new Set(sweep.candidates.filter((one) => one.testUsed).map((one) => one.id));
+    for (const test of sweep.candidates.filter((one) => one.testOfDeadCode)) {
+        const targets = testTargets(union, test.id);
+        if (targets.length > 0 && targets.every((target) => used.has(target))) {
+            used.add(test.id);
         }
-        return lowest;
-    };
+    }
+    const files = new Set(union.symbols.flatMap((symbol, at) => matrix.testUsed[at] === true ? [symbol.position.path] : []));
+    return { declarations: used, files };
 }
 /**
  * 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.rootsComplete && !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
@@ -152,8 +186,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
@@ -170,18 +220,6 @@ 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
@@ -251,6 +289,7 @@ export function completed(input, findings, kinds = KINDS) {
     const candidates = new Map(swept.sweep.candidates.map((candidate) => [candidate.id, candidate]));
     const classOf = reachabilityClasses(input);
     const ceilingOf = testCeilings(input, classOf);
+    const testUsed = testUsedSubjects(input);
     const { components, computed, files } = runComponents(swept, findings);
     const componentOf = findingComponents(swept, components, input.config.reporters.cascade);
     const held = new Set(components.filter((one) => one.held).flatMap((one) => one.members));
@@ -258,11 +297,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,17 +347,40 @@ 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 reachabilityClass = judged === undefined ? (finding.reachabilityClass ?? "certain") : classOf(judged.id);
+        const ownClass = judged === undefined ? (finding.reachabilityClass ?? "certain") : classOf(judged.id);
+        const used = judged !== undefined
+            ? candidate !== undefined && testUsed.declarations.has(judged.id)
+            : finding.code === FILE_NEVER_IMPORTED && testUsed.files.has(finding.position.path);
+        const reachabilityClass = used && candidate?.testOfDeadCode !== true ? "possible" : ownClass;
+        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"
@@ -341,16 +404,14 @@ export function completed(input, findings, kinds = KINDS) {
             position: finding.position,
             symbol: finding.symbol,
             reachabilityClass,
-            confidence: capped(capped(capped(reachabilityClass, row.maxClass), rootsCeiling(input, finding, candidate)), judged === undefined ? "certain" : ceilingOf(judged.id)),
+            confidence: used ? "possible" : untested,
+            ...(used ? { componentConfidence: untested } : {}),
             ...(candidate === undefined ? {} : { livenessRelation: candidate.relation }),
             testOnly: judged !== undefined && counts?.production === 0 && counts.test > 0,
             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),
@@ -365,7 +426,7 @@ export function completed(input, findings, kinds = KINDS) {
 /**
  * The findings with every finding of a dead component capped by the lowest confidence
  * among the component's root members, so the minimum confidence reports or withholds a
- * component whole.
+ * component whole but for the findings test-used code lowers on their own.
  */
 function componentCapped(findings, dead) {
     const lowest = new Map();
@@ -373,16 +434,27 @@ function componentCapped(findings, dead) {
         const { id, root } = finding.component;
         if (root && dead.has(id)) {
             const held = lowest.get(id);
-            lowest.set(id, held === undefined ? finding.confidence : capped(held, finding.confidence));
+            const own = componentConfidenceOf(finding);
+            lowest.set(id, held === undefined ? own : capped(held, own));
         }
     }
     return findings.map((finding) => {
         const cap = lowest.get(finding.component.id);
-        return cap === undefined || RANK[cap] >= RANK[finding.confidence]
-            ? finding
-            : { ...finding, confidence: cap };
+        if (cap === undefined) {
+            return finding;
+        }
+        const own = finding.componentConfidence;
+        return {
+            ...finding,
+            confidence: capped(finding.confidence, cap),
+            ...(own === undefined ? {} : { componentConfidence: capped(own, cap) }),
+        };
     });
 }
+/** The confidence a finding gives its component's cap and the dials. */
+function componentConfidenceOf(finding) {
+    return finding.componentConfidence ?? finding.confidence;
+}
 /** Whether the dials withhold a finding by its own severity or confidence. */
 function dialed(finding, minConfidence) {
     return finding.severity === "allow" || RANK[finding.confidence] < RANK[minConfidence];
@@ -397,7 +469,8 @@ function dialed(finding, minConfidence) {
 export function dialsOf(input, findings) {
     const minConfidence = input.config.analysis.minConfidence;
     const components = new Set(findings
-        .filter((finding) => finding.component.root && dialed(finding, minConfidence))
+        .filter((finding) => finding.component.root &&
+        dialed({ ...finding, confidence: componentConfidenceOf(finding) }, minConfidence))
         .map((finding) => finding.component.id));
     return {
         allows: (code) => {

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

@@ -28,7 +28,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 +46,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

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

@@ -1,7 +1,7 @@
 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"]);
+/** The containers whose type parameters `DS1303` reports: a function, a class method and a type alias. */
+const SIGNATURES = new Set(["function", "method", "type"]);
 function indexed(input) {
     const { matrix, sweep } = input.swept;
     return {
@@ -165,10 +165,11 @@ function unusedEnumMembers(run) {
     return unnamed(run, "enum-member").map((symbol) => findingAbout(symbol, "DS1302", `enum member ${symbol.name} is named nowhere`));
 }
 /**
- * `DS1303`: a type parameter of a function or a class method that neither the
- * declaration's signature nor its body names. A type parameter of a class, an interface,
- * a type alias or a method signature belongs to a type declaration and is never
- * reported, because a phantom parameter makes two instantiations distinct types.
+ * `DS1303`: a type parameter of a function, a class method or a type alias that neither
+ * the declaration's signature nor its body names. An alias names no type of its own, so
+ * a parameter its type never names makes no two instantiations distinct. One of a class,
+ * an interface or a method signature is never reported: a class or an interface merges
+ * only with declarations of the same parameters.
  */
 function unusedTypeParameters(run) {
     return unnamed(run, "type-parameter")

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

@@ -1,3 +1,4 @@
+import { testsUnseenAPI } from "./completion.js";
 import { unreachableExports } from "./visibility-narrowing.js";
 /** The kinds of declaration that are members of a class, an interface, a type or an enum. */
 const MEMBERS = new Set([
@@ -41,13 +42,14 @@ const TEST_OF_DEAD_CODE = "every target symbol this test references is reported
  * The code one candidate is reported under, or none, each symbol once under the most
  * specific code: a test of dead code first; no other test-file declaration or enum
  * member nothing names; a test-support declaration test code references as test-only
- * use; then deprecation, a test reference, and the unreferenced codes, an unimportable
- * unused export being the unreachable kind's.
+ * use; then deprecation, a test reference, or only dead production references beside a
+ * test that stays, and the unreferenced codes, an unimportable unused export being the
+ * unreachable kind's.
  */
 function codeOf(judged) {
     const { candidate, symbol } = judged;
     if (candidate.testOfDeadCode) {
-        return "DS1005";
+        return judged.testsUnseenAPI ? undefined : "DS1005";
     }
     if ((judged.test && !candidate.unreferencedTest) || NOT_THIS_FAMILY.has(symbol.kind)) {
         return undefined;
@@ -65,7 +67,9 @@ function codeOf(judged) {
     if (candidate.productionRefs === 0 && judged.deprecated) {
         return "DS1006";
     }
-    if (candidate.productionRefs === 0 && candidate.testRefs > 0) {
+    if (candidate.testRefs > 0 &&
+        (candidate.productionRefs === 0 ||
+            (candidate.relation === "reachability" && candidate.keptByTests))) {
         return "DS1004";
     }
     if (MEMBERS.has(symbol.kind)) {
@@ -109,7 +113,9 @@ function messageOf(code, judged) {
         case "DS1006":
             return `deprecated ${word} has no production reference`;
         case "DS1004":
-            return `${word} is referenced only from test files and never from production code`;
+            return candidate.productionRefs === 0
+                ? `${word} is referenced only from test files and never from production code`
+                : `${word} is referenced only from test files and from declarations that are themselves dead`;
     }
     const subject = code === "DS1003"
         ? `${visibilityWord(symbol)}${word}`
@@ -194,6 +200,7 @@ 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);
+    const unseenAPI = testsUnseenAPI(input);
     let brands;
     const found = [];
     for (const candidate of input.swept.sweep.candidates) {
@@ -212,6 +219,7 @@ function familyFindings(input, fallen) {
             test: union.test[at] === true,
             deprecated: input.deprecated.has(symbol.id),
             unreachable: unreachable.has(symbol.id),
+            testsUnseenAPI: candidate.testOfDeadCode && unseenAPI(candidate.id),
         };
         const code = codeOf(judged);
         if (code === undefined ||

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

@@ -34,12 +34,17 @@ const RUN_ONLY = new Set(["configuration-string", "script"]);
 function entersByName(kinds) {
     return [...(kinds ?? [])].some((kind) => !PUBLISHING.has(kind) && !RUN_ONLY.has(kind));
 }
+/**
+ * The root kinds whose root of a file enters no export by name: a document's import roots
+ * each export it imports, so an export it does not import is judged as in any file.
+ */
+const PER_NAME = new Set(["document-import"]);
 /**
  * Whether the roots of a declaration's file enter it by name: a test runner's root
  * enters only an export the runner calls, so another export of a test file is judged.
  */
 function fileEntersByName(kinds, symbol) {
-    const entering = [...(kinds ?? [])].filter((kind) => !PUBLISHING.has(kind) && !RUN_ONLY.has(kind));
+    const entering = [...(kinds ?? [])].filter((kind) => !PUBLISHING.has(kind) && !RUN_ONLY.has(kind) && !PER_NAME.has(kind));
     return (entering.some((kind) => kind !== "test-runner") || (entering.length > 0 && runnerCalls(symbol)));
 }
 /**
@@ -163,7 +168,7 @@ function narrowing(facts, at, symbol, world) {
  * export no code outside the target can import, because the manifest declares
  * `exports` and no root reaches it. Each arm yields to a more specific kind, so one
  * declaration is reported once: a test whose every subject is dead, an interface, a
- * declaration only a test file references, and a deprecated one.
+ * declaration only a test file references or a test that stays keeps, and a deprecated one.
  */
 function unreachable(facts, at, symbol, candidate, input) {
     if (!input.boundary.encapsulated ||
@@ -171,7 +176,7 @@ function unreachable(facts, at, symbol, candidate, input) {
         (facts.rootedBy[at]?.size ?? 0) > 0 ||
         candidate.testOfDeadCode ||
         symbol.kind === "interface" ||
-        (candidate.productionRefs === 0 && candidate.testRefs > 0) ||
+        (candidate.testRefs > 0 && (candidate.productionRefs === 0 || candidate.keptByTests)) ||
         (candidate.productionRefs === 0 && input.deprecated.has(symbol.id))) {
         return undefined;
     }

package/dist/src/graph.js

@@ -34,9 +34,9 @@ const SWEPT = {
  * Whether a root of each kind names a caller, which holds it live under both relations: a
  * 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.
+ * names what enters the package, an alias global stands for its export, an outside
+ * declaration names a global interface merging into it, and an entry file, a configured root
+ * and a pattern assert a caller. A published API supposes a consumer: reachability alone.
  */
 const NAMES_A_CALLER = {
     "entry-file": true,
@@ -49,8 +49,10 @@ const NAMES_A_CALLER = {
     pattern: true,
     "type-error": true,
     "type-query-alias": true,
+    "global-augmentation": true,
     "configuration-file": true,
     "configuration-string": true,
+    "bundler-entry": true,
     "test-runner": true,
     "browser-tests": true,
     worker: true,

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

@@ -772,10 +772,9 @@ function calleeSteers(project, signature, at) {
 }
 /**
  * The parts with each name of `contextual` judged where the compiler gives its function a
- * contextual type: the code handing the argument may act on what an object pattern reads,
- * so each such name is read, and an annotated parameter is marked with whether the call's
- * inference may read its annotation. A question the checker leaves unanswered keeps the
- * name read.
+ * contextual type: a name an object pattern binds is marked as one, and an annotated
+ * parameter with whether the call's inference may read its annotation. A question the
+ * checker leaves unanswered keeps the name read.
  */
 function withContextualRead(project, parts, contextual) {
     if (contextual.length === 0) {
@@ -791,15 +790,17 @@ function withContextualRead(project, parts, contextual) {
             continue;
         }
         const place = one.part.parameter;
-        judged.set(one.part, one.pattern || answer === UNANSWERED || place === undefined
+        judged.set(one.part, answer === UNANSWERED || place === undefined
             ? { ...one.part, used: true }
-            : {
-                ...one.part,
-                parameter: {
-                    ...place,
-                    annotated: calleeSteers(project, one.signature, one.at) ? "steers" : "free",
-                },
-            });
+            : one.pattern
+                ? { ...one.part, parameter: { ...place, contextualPattern: true } }
+                : {
+                    ...one.part,
+                    parameter: {
+                        ...place,
+                        annotated: calleeSteers(project, one.signature, one.at) ? "steers" : "free",
+                    },
+                });
     }
     return parts.map((part) => judged.get(part) ?? part);
 }
@@ -884,15 +885,28 @@ function functionOf(block) {
     }
 }
 /**
- * The locals one block declares with `let`, `const` or `var`, each with the names of the
- * block that spell it. A `var` of a nested block is one where no nested function of its
- * function names it, since the function scope holds it past the block's end.
+ * The locals one block declares with `let`, `const`, `var` or a function declaration
+ * inside a function, each with the names of the block that spell it. A `var` of a nested
+ * block is one where no nested function of its function names it, since the function scope
+ * holds it past the block's end.
  */
 function localsOf(block) {
     const declared = [];
     const scope = functionOf(block);
     const outlives = scope?.body !== block;
     block.statements.forEach((statement, at) => {
+        if (isFunctionDeclaration(statement)) {
+            if (scope !== undefined && statement.name !== undefined && statement.body !== undefined) {
+                declared.push({
+                    name: statement.name,
+                    statement: at,
+                    initialized: true,
+                    outlives: false,
+                    hoisted: true,
+                });
+            }
+            return;
+        }
         if (!isVariableStatement(statement)) {
             return;
         }
@@ -902,6 +916,11 @@ function localsOf(block) {
             return;
         }
         for (const declaration of list.declarations) {
+            // A write to a local typed `never` is the compiler's exhaustiveness check, which
+            // fails to compile once a case goes unhandled.
+            if (declaration.type?.kind === SyntaxKind.NeverKeyword) {
+                continue;
+            }
             for (const name of boundNames(declaration.name)) {
                 if (!blockScoped &&
                     outlives &&
@@ -913,6 +932,7 @@ function localsOf(block) {
                     statement: at,
                     initialized: declaration.initializer !== undefined,
                     outlives: !blockScoped && outlives,
+                    hoisted: false,
                 });
             }
         }
@@ -953,12 +973,20 @@ function deadStores(file, root, block, holder, locals, ids) {
         used: false,
     });
     for (const local of locals) {
-        const uses = local.uses.filter((use) => readsBinding(use, local.name, ids));
+        const own = local.hoisted ? block.statements[local.statement] : undefined;
+        // A function's reads of itself keep it no more than its absence would.
+        const uses = local.uses.filter((use) => readsBinding(use, local.name, ids) && (own === undefined || !within(use, own)));
         if (!local.outlives && uses.every(isPlainWrite)) {
-            const targets = [...(local.initialized ? [local.name] : []), ...uses];
+            // A declaration with no initializer writes `undefined`, the one store left to name.
+            const writes = [...(local.initialized ? [local.name] : []), ...uses];
+            const targets = writes.length === 0 ? [local.name] : writes;
             found.push(...targets.map((target) => deadAt(local, target)));
             continue;
         }
+        // A read anywhere in the block reads a function declaration, which is written first.
+        if (local.hoisted) {
+            continue;
+        }
         if (uses.some((use) => inNestedFunction(use, block))) {
             continue;
         }