@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.10

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

@@ -4,18 +4,17 @@
  * call sites that use or discard it, each statement control flow cannot reach, each
  * write to a local that no read reaches, and each case an earlier case covers.
  */
-import { isArrayBindingPattern, isArrowFunction, isAwaitExpression, isBigIntLiteral, isBinaryExpression, isBlock, isBreakStatement, isBindingElement, isCallExpression, isCaseClause, isCatchClause, isClassDeclaration, isClassExpression, isConstructorDeclaration, isContinueStatement, isDecorator, isDefaultClause, isEmptyStatement, isExportAssignment, isExportSpecifier, isExpressionStatement, isFunctionDeclaration, isFunctionExpression, isFunctionLikeDeclaration, isHeritageClause, isIdentifier, isIfStatement, isImportClause, isImportSpecifier, isInterfaceDeclaration, isMethodDeclaration, isModuleDeclaration, isNamespaceImport, isNewExpression, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParenthesizedExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isQualifiedName, isReturnStatement, isShorthandPropertyAssignment, isSourceFile, isStringLiteral, isSwitchStatement, isThrowStatement, isTypeAliasDeclaration, isTypeReferenceNode, isVariableStatement, isVoidExpression, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
+import { CODE } from "./contract/contract.generated.js";
+import { isArrowFunction, isAwaitExpression, isBigIntLiteral, isBinaryExpression, isBlock, isBreakStatement, isBindingElement, isCallExpression, isCaseClause, isCatchClause, isClassDeclaration, isClassExpression, isConstructorDeclaration, isContinueStatement, isDecorator, isDefaultClause, isEmptyStatement, isExportAssignment, isExportSpecifier, isExpressionStatement, isFunctionDeclaration, isFunctionExpression, isForInStatement, isForOfStatement, isFunctionLikeDeclaration, isHeritageClause, isIdentifier, isIfStatement, isImportClause, isImportSpecifier, isInterfaceDeclaration, isMethodDeclaration, isModuleDeclaration, isNamespaceImport, isNewExpression, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParenthesizedExpression, isPrefixUnaryExpression, isPropertyAssignment, isPropertyAccessExpression, isQualifiedName, isReturnStatement, isShorthandPropertyAssignment, isSourceFile, isStringLiteral, isSwitchStatement, isThrowStatement, isTypeAliasDeclaration, isTypeReferenceNode, isVariableDeclarationList, isVariableStatement, isVoidExpression, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
+import { SignatureKind } from "@typescript/native/sync";
+import { exportsLocally, implicitReads, importBindings, } from "./import-bindings.js";
 import { isParameterProperty, nodeKey } from "./inventory.js";
 import { positionKey, renderPosition } from "./position.js";
+import { importRef } from "./ref.js";
 import { isAnswered, UNANSWERED } from "./query.js";
 import { signatureOf } from "./signatures.js";
 import { spellsNoBinding } from "./spelled-names.js";
-/** The codes of the parts this module reads. */
-export const UNUSED_PARAMETER = "DS1801";
-export const UNUSED_RESULT = "DS1803";
-const UNREACHABLE_STATEMENT = "DS1805";
-const DEAD_STORE = "DS1807";
-const UNREACHABLE_CASE = "DS1809";
+import { parenthesesRemoved } from "./unwrap.js";
 /** The result types that carry no value, as the checker spells them. */
 const NO_VALUE = new Set([
     "void",
@@ -31,17 +30,13 @@ function spanOf(file, root, node) {
     const endLine = file.getLineAndCharacterOfPosition(node.end).line + 1;
     return { ...start, endLine };
 }
-/** The parenthesized expression's content, through every pair of parentheses. */
-function unwrapped(node) {
-    return isParenthesizedExpression(node) ? unwrapped(node.expression) : node;
-}
 /** The node the parentheses around one expression sit in. */
 function outerParent(node) {
     return isParenthesizedExpression(node.parent) ? outerParent(node.parent) : node.parent;
 }
 /** The name a call is made through: the identifier, or the member a property access names. */
 function calleeName(call) {
-    const callee = unwrapped(call.expression);
+    const callee = parenthesesRemoved(call.expression);
     if (isIdentifier(callee)) {
         return callee;
     }
@@ -96,7 +91,7 @@ function unreachableExempt(statement) {
 }
 /** The value a case expression is a literal of, as a key two equal literals share, or none. */
 function caseKey(expression) {
-    const node = unwrapped(expression);
+    const node = parenthesesRemoved(expression);
     if (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node)) {
         return `s:${node.text}`;
     }
@@ -207,7 +202,7 @@ function extendedNames(files) {
                     named = isQualifiedName(type.typeName) ? type.typeName.right : type.typeName;
                 }
                 else {
-                    const expression = unwrapped(type.expression);
+                    const expression = parenthesesRemoved(type.expression);
                     named = isPropertyAccessExpression(expression) ? expression.name : expression;
                 }
                 if (isIdentifier(named)) {
@@ -251,7 +246,7 @@ function decoratorFixes(constructor) {
 }
 /** The name an expression spells a class by: an identifier, or the member a property access names. */
 function spelledName(expression) {
-    const node = unwrapped(expression);
+    const node = parenthesesRemoved(expression);
     if (isIdentifier(node)) {
         return node;
     }
@@ -304,6 +299,33 @@ function readsBinding(use, declared, ids) {
     const own = ids.get(declared);
     return at === undefined || at === UNANSWERED || own === UNANSWERED || at === own;
 }
+/** Whether a name is spelled with a leading underscore, which declares it unread. */
+function declaredUnread(name) {
+    return name.text.startsWith("_");
+}
+/** A file's leading comments, where the compiler reads its `@ts-check` and `@ts-nocheck` pragmas. */
+const LEADING_COMMENTS = /^(?:#![^\n]*)?(?:\s|\/\/[^\n]*|\/\*[\s\S]*?\*\/)*/u;
+/** A comment of the leading comments, a line comment's text after its slashes captured. */
+const LEADING_COMMENT = /\/\*[\s\S]*?\*\/|\/\/\/?([^\n]*)/gu;
+/**
+ * Whether a file's leading comments hold one pragma: as the compiler reads it, a line
+ * comment that starts with the pragma's name, in any case, followed by nothing or a space.
+ */
+function hasPragma(leading, pragma) {
+    return [...leading.matchAll(LEADING_COMMENT)].some(([, text]) => text !== undefined && pragma.test(text));
+}
+/**
+ * Whether the compiler checks a file, so its rules report what they find there: a
+ * JavaScript file only under `checkJs` or a `@ts-check` pragma, and no file with a
+ * `@ts-nocheck` pragma.
+ */
+function checkedByTheCompiler(file, checkJs) {
+    const leading = LEADING_COMMENTS.exec(file.text)?.[0] ?? "";
+    if (hasPragma(leading, /^\s*@ts-nocheck(?:\s|$)/iu)) {
+        return false;
+    }
+    return (!/\.[cm]?jsx?$/u.test(file.fileName) || checkJs || hasPragma(leading, /^\s*@ts-check(?:\s|$)/iu));
+}
 /**
  * The parts of one project's own declarations. `references` are the project's own
  * references, which say which declarations a discarded call reaches, so the checker is
@@ -319,7 +341,12 @@ export function projectParts(project, held, references, targetRoot) {
     const constructions = new Set();
     const sites = [];
     const contextual = [];
+    const imports = [];
+    const refs = new Map(held.symbols.map((symbol) => [symbol.id, symbol.ref]));
+    const options = project.program.getCompilerOptions();
+    const jsx = options;
     for (const file of files) {
+        const checked = checkedByTheCompiler(file, options.checkJs === true);
         // A parameter property's own parts stay with the parameter when its member goes.
         const declarationAt = (node) => isParameterProperty(node) ? undefined : held.declarations.get(nodeKey(file, node));
         // A part no declaration holds belongs to the file, which is judged while the file is live.
@@ -338,6 +365,7 @@ export function projectParts(project, held, references, targetRoot) {
             values: [],
             catches: [],
             blocks: [],
+            loops: [],
             unreachable: [],
             cases: [],
         };
@@ -411,8 +439,8 @@ export function projectParts(project, held, references, targetRoot) {
             if ((isImportClause(node) || isNamespaceImport(node)) && node.name !== undefined) {
                 specifiers.add(position(node.name));
             }
-            if (isExportAssignment(node) && isIdentifier(unwrapped(node.expression))) {
-                specifiers.add(position(unwrapped(node.expression)));
+            if (isExportAssignment(node) && isIdentifier(parenthesesRemoved(node.expression))) {
+                specifiers.add(position(parenthesesRemoved(node.expression)));
             }
             if (isSwitchStatement(node)) {
                 const holder = holderOf(node);
@@ -433,6 +461,15 @@ export function projectParts(project, held, references, targetRoot) {
             if (isBlock(node) && silenced === 0 && holderOf(node) !== undefined) {
                 walk.blocks.push(node);
             }
+            const loopHolder = (isForOfStatement(node) || isForInStatement(node)) && silenced === 0
+                ? holderOf(node)
+                : undefined;
+            if (loopHolder !== undefined &&
+                (isForOfStatement(node) || isForInStatement(node)) &&
+                isVariableDeclarationList(node.initializer) &&
+                (node.initializer.flags & (NodeFlags.Let | NodeFlags.Const)) !== 0) {
+                walk.loops.push({ loop: node, holder: loopHolder });
+            }
             if (isBlock(node) || isCaseClause(node) || isDefaultClause(node)) {
                 statementsOf(node.statements);
                 return;
@@ -462,7 +499,37 @@ export function projectParts(project, held, references, targetRoot) {
         for (const store of stores) {
             asked.push(...store.flatMap((local) => [local.name, ...local.uses]));
         }
+        const loopVariables = walk.loops.map(({ loop, holder }) => {
+            const list = loop.initializer;
+            // A loop must bind a name, so one spelled declared unread is no subject.
+            const names = list.declarations
+                .flatMap((declaration) => boundNames(declaration.name))
+                .filter((name) => !declaredUnread(name));
+            const uses = identifiersNaming(loop.statement, new Set(names.map((one) => one.text)));
+            asked.push(...names, ...uses);
+            return { names, uses, holder };
+        });
+        const bindings = fileId === undefined ? [] : importBindings(file);
+        const bound = new Set(bindings);
+        const bindingUses = bindings.length === 0
+            ? []
+            : identifiersNaming(file, new Set(bindings.map((one) => one.text))).filter((use) => !bound.has(use));
+        asked.push(...bindings, ...bindingUses);
         const ids = resolvedIds(project, [...new Set(asked)]);
+        const implicit = bindings.length === 0 ? new Set() : implicitReads(file, jsx);
+        for (const binding of bindings) {
+            const fileRef = fileId === undefined ? undefined : refs.get(fileId);
+            if (fileId === undefined || fileRef === undefined) {
+                continue;
+            }
+            imports.push({
+                ref: importRef(fileRef, binding.text),
+                name: binding.text,
+                position: spanOf(file, targetRoot, binding),
+                used: implicit.has(binding.text) ||
+                    bindingUses.some((use) => use.text === binding.text && (exportsLocally(use) || readsBinding(use, binding, ids))),
+            });
+        }
         for (const one of walk.declared) {
             const constructor = isConstructorDeclaration(one.node);
             if (!constructor) {
@@ -476,7 +543,10 @@ export function projectParts(project, held, references, targetRoot) {
             });
             const reader = readers.get(one.signature);
             if (reader !== undefined) {
-                const found = parameterParts(file, targetRoot, one.id, one.signature, reader, ids, false);
+                const found = parameterParts(file, targetRoot, one.id, one.signature, reader, ids, {
+                    inValue: false,
+                    checked,
+                });
                 parts.push(...found.parts);
                 contextual.push(...found.contextual);
             }
@@ -484,14 +554,17 @@ export function projectParts(project, held, references, targetRoot) {
         for (const one of walk.values) {
             const reader = readers.get(one.signature);
             if (reader !== undefined) {
-                const found = parameterParts(file, targetRoot, one.holder, one.signature, reader, ids, true);
+                const found = parameterParts(file, targetRoot, one.holder, one.signature, reader, ids, {
+                    inValue: true,
+                    checked,
+                });
                 parts.push(...found.parts);
                 contextual.push(...found.contextual);
             }
         }
         walk.catches.forEach(({ name, holder }, at) => {
             parts.push({
-                code: DEAD_STORE,
+                code: CODE.deadStore,
                 declaration: holder,
                 kind: "store",
                 name: name.text,
@@ -500,6 +573,19 @@ export function projectParts(project, held, references, targetRoot) {
                 used: (caught[at] ?? []).some((use) => readsBinding(use, name, ids)),
             });
         });
+        for (const { names, uses, holder } of loopVariables) {
+            for (const name of names) {
+                parts.push({
+                    code: CODE.deadStore,
+                    declaration: holder,
+                    kind: "store",
+                    name: name.text,
+                    position: spanOf(file, targetRoot, name),
+                    message: `value written to ${name.text} is never read`,
+                    used: uses.some((use) => use.text === name.text && readsBinding(use, name, ids)),
+                });
+            }
+        }
         walk.blocks.forEach((block, at) => {
             const holder = holderOf(block);
             if (holder !== undefined) {
@@ -508,7 +594,7 @@ export function projectParts(project, held, references, targetRoot) {
         });
         for (const { statement, holder } of walk.unreachable) {
             parts.push({
-                code: UNREACHABLE_STATEMENT,
+                code: CODE.unreachableStatement,
                 declaration: holder,
                 kind: "statement",
                 name: "statement",
@@ -519,7 +605,7 @@ export function projectParts(project, held, references, targetRoot) {
         }
         for (const { clause, text, holder } of walk.cases) {
             parts.push({
-                code: UNREACHABLE_CASE,
+                code: CODE.unreachableCase,
                 declaration: holder,
                 kind: "case",
                 name: text,
@@ -532,6 +618,7 @@ export function projectParts(project, held, references, targetRoot) {
     parts.push(...resultParts(project, targetRoot, sites, references, calls));
     return {
         parts: withContextualRead(project, parts, contextual),
+        imports,
         signatures,
         calls,
         specifiers,
@@ -558,7 +645,9 @@ function valueSignature(node) {
 /**
  * Every name one function's parameters bind, a binding pattern's names one by one. A
  * `this` parameter receives no argument, a decorated one is read by its decorator, and a
- * parameter property is read by the write to its member, so none binds a subject.
+ * parameter property is read by the write to its member, so none binds a subject. A name
+ * spelled with a leading underscore is declared unread, so it is listed for its reads and
+ * reported never.
  */
 function parameterNames(signature) {
     const found = [];
@@ -570,7 +659,7 @@ function parameterNames(signature) {
                 continue;
             }
             if (isIdentifier(element.name)) {
-                const exempt = rest && element.dotDotDotToken === undefined;
+                const exempt = (rest && element.dotDotDotToken === undefined) || declaredUnread(element.name);
                 found.push({ name: element.name, at, pattern: true, exempt });
             }
             else {
@@ -586,7 +675,7 @@ function parameterNames(signature) {
         }
         if (isIdentifier(name)) {
             if (name.text !== "this") {
-                found.push({ name, at, pattern: false, exempt: false });
+                found.push({ name, at, pattern: false, exempt: declaredUnread(name) });
             }
             return;
         }
@@ -594,11 +683,90 @@ function parameterNames(signature) {
     });
     return found;
 }
+/** How deep a type is searched for a type parameter: a callback of a callback is two levels. */
+const TYPE_PARAMETER_DEPTH = 3;
+/** Whether one type is or holds a type parameter, through constituents, type arguments and signatures. */
+function namesTypeParameter(project, type, depth = 0) {
+    if (type.isTypeParameter()) {
+        return true;
+    }
+    if (depth >= TYPE_PARAMETER_DEPTH) {
+        return false;
+    }
+    const { queries } = project;
+    const parts = type.isUnionType() || type.isIntersectionType() ? queries.constituents(type) : [];
+    const args = queries.typeArguments(type);
+    const signatures = queries.signaturesOf(type, SignatureKind.Call);
+    if (!isAnswered(parts) || !isAnswered(args) || !isAnswered(signatures)) {
+        return true;
+    }
+    const inner = [
+        ...parts,
+        ...args,
+        ...signatures.flatMap((signature) => signature.parameters.map((_parameter, at) => queries.typeAtPosition(signature, at))),
+    ];
+    return inner.some((one) => !isAnswered(one) || namesTypeParameter(project, one, depth + 1));
+}
 /**
- * The parts with each name of `contextual` read where the compiler gives its function a
- * contextual type: the inference of the call holding the function may read a parameter's
- * annotation, and the code handing the argument may act on what an object pattern reads.
- * A question the checker leaves unanswered keeps the name read.
+ * Whether the call a function expression is written in may read the annotation of its
+ * parameter at `at`: the callee is generic, and its parameter type at the function's place
+ * reads a type parameter there. A function written inside an object literal a generic
+ * call is passed is read so too, and a question the checker leaves unanswered reads it.
+ */
+function calleeSteers(project, signature, at) {
+    const { queries } = project;
+    let value = signature;
+    while (isParenthesizedExpression(value.parent)) {
+        value = value.parent;
+    }
+    let nested = false;
+    while ((isPropertyAssignment(value.parent) && isObjectLiteralExpression(value.parent.parent)) ||
+        isObjectLiteralExpression(value.parent)) {
+        value = isObjectLiteralExpression(value.parent) ? value.parent : value.parent.parent;
+        nested = true;
+    }
+    const call = value.parent;
+    if (!isCallExpression(call) && !isNewExpression(call)) {
+        return false;
+    }
+    const argument = (call.arguments ?? []).findIndex((one) => one === value);
+    const resolved = argument < 0 ? undefined : queries.resolvedSignature(call);
+    const generic = resolved === undefined || !isAnswered(resolved) ? resolved : queries.genericOf(resolved);
+    if (argument < 0 || generic === undefined) {
+        return false;
+    }
+    if (!isAnswered(generic) || nested) {
+        return true;
+    }
+    const position = queries.typeAtPosition(generic, argument);
+    if (!isAnswered(position) || position.isTypeParameter()) {
+        return true;
+    }
+    const parts = position.isUnionType() || position.isIntersectionType()
+        ? queries.constituents(position)
+        : [position];
+    if (!isAnswered(parts)) {
+        return true;
+    }
+    return parts.some((part) => {
+        if (part.isTypeParameter()) {
+            return true;
+        }
+        const calls = queries.signaturesOf(part, SignatureKind.Call);
+        if (!isAnswered(calls)) {
+            return true;
+        }
+        return calls.some((one) => {
+            const type = at < one.parameters.length ? queries.typeAtPosition(one, at) : undefined;
+            return type !== undefined && (!isAnswered(type) || namesTypeParameter(project, type));
+        });
+    });
+}
+/**
+ * The parts with each name of `contextual` judged where the compiler gives its function a
+ * 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) {
@@ -606,9 +774,27 @@ function withContextualRead(project, parts, contextual) {
     }
     const signatures = [...new Set(contextual.map((one) => one.signature))];
     const answers = project.queries.contextualTypes(signatures);
-    const typed = new Set(signatures.filter((_signature, at) => answers[at] !== undefined));
-    const read = new Set(contextual.filter((one) => typed.has(one.signature)).map((one) => one.part));
-    return parts.map((part) => (read.has(part) ? { ...part, used: true } : part));
+    const typedBy = new Map(signatures.map((signature, at) => [signature, answers[at]]));
+    const judged = new Map();
+    for (const one of contextual) {
+        const answer = typedBy.get(one.signature);
+        if (answer === undefined) {
+            continue;
+        }
+        const place = one.part.parameter;
+        judged.set(one.part, answer === UNANSWERED || place === undefined
+            ? { ...one.part, used: true }
+            : 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);
 }
 /**
  * Each name one function's parameters bind and whether the function reads it, and the
@@ -616,7 +802,7 @@ function withContextualRead(project, parts, contextual) {
  * that carries a type annotation or is an object binding pattern. A binding pattern counts
  * as read where its function reads any name it binds.
  */
-function parameterParts(file, root, declaration, signature, reader, ids, inValue) {
+function parameterParts(file, root, declaration, signature, reader, ids, place) {
     // A function that reads its `arguments` reads every parameter by position. A nested
     // function other than an arrow has an `arguments` object of its own.
     const readsArguments = !isArrowFunction(signature) &&
@@ -632,14 +818,14 @@ function parameterParts(file, root, declaration, signature, reader, ids, inValue
             return;
         }
         const part = {
-            code: UNUSED_PARAMETER,
+            code: CODE.unusedParameter,
             declaration,
             kind: "parameter",
             name: name.text,
             position: spanOf(file, root, name),
             message: `parameter ${name.text} is never read in the body`,
             used: read[index] === true,
-            parameter: { beforeARead: !pattern && at < lastRead, inValue },
+            parameter: { beforeARead: !pattern && at < lastRead, ...place },
         };
         found.push(part);
         const parameter = signature.parameters[at];
@@ -647,42 +833,98 @@ function parameterParts(file, root, declaration, signature, reader, ids, inValue
             !part.used &&
             parameter !== undefined &&
             (parameter.type !== undefined || isObjectBindingPattern(parameter.name))) {
-            contextual.push({ part, signature: expression });
+            contextual.push({
+                part,
+                signature: expression,
+                at,
+                pattern: isObjectBindingPattern(parameter.name),
+            });
         }
     });
     return { parts: found, contextual };
 }
 /**
  * The names one declaration binds that a write of its initializer stores each on its own:
- * the declared name, or each element name of an array binding pattern at any depth.
+ * the declared name, or each element name of a binding pattern at any depth. A name with a
+ * default is left out, because removing it skips the default's evaluation, and so is a name
+ * beside a rest element of its object pattern, whose removal changes what the rest holds.
  */
-function arrayPatternNames(name) {
+function boundNames(name) {
     if (isIdentifier(name)) {
         return [name];
     }
-    if (!isArrayBindingPattern(name)) {
-        return [];
+    const rest = isObjectBindingPattern(name) &&
+        name.elements.some((element) => element.dotDotDotToken !== undefined);
+    return name.elements.flatMap((element) => {
+        if (!isBindingElement(element) || element.name === undefined) {
+            return [];
+        }
+        if (element.initializer !== undefined || (rest && element.dotDotDotToken === undefined)) {
+            return [];
+        }
+        return boundNames(element.name);
+    });
+}
+/** The function whose scope a `var` of one block belongs to, or none at a module's top level. */
+function functionOf(block) {
+    for (let at = block.parent;; at = at.parent) {
+        if (isFunctionLikeDeclaration(at)) {
+            return at;
+        }
+        if (isSourceFile(at)) {
+            return undefined;
+        }
     }
-    return name.elements.flatMap((element) => isBindingElement(element) && element.name !== undefined ? arrayPatternNames(element.name) : []);
 }
-/** The locals one block declares with `let` or `const`, each with the names that spell it. */
+/**
+ * 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;
         }
         const list = statement.declarationList;
-        if ((list.flags & (NodeFlags.Let | NodeFlags.Const)) === 0 ||
-            (list.flags & NodeFlags.Using) !== 0) {
+        const blockScoped = (list.flags & (NodeFlags.Let | NodeFlags.Const)) !== 0;
+        if ((!blockScoped && scope === undefined) || (list.flags & NodeFlags.Using) !== 0) {
             return;
         }
         for (const declaration of list.declarations) {
-            for (const name of arrayPatternNames(declaration.name)) {
+            // 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 &&
+                    identifiersNaming(scope?.body ?? block, new Set([name.text])).some((use) => inNestedFunction(use, scope ?? block))) {
+                    continue;
+                }
                 declared.push({
                     name,
                     statement: at,
                     initialized: declaration.initializer !== undefined,
+                    outlives: !blockScoped && outlives,
+                    hoisted: false,
                 });
             }
         }
@@ -696,19 +938,47 @@ function localsOf(block) {
         uses: spelled.filter((use) => use !== one.name && use.text === one.name.text),
     }));
 }
+/** Whether one name is the whole target of a plain assignment, which writes it and reads nothing. */
+function isPlainWrite(use) {
+    const parent = outerParent(use);
+    return (isBinaryExpression(parent) &&
+        parent.operatorToken.kind === SyntaxKind.EqualsToken &&
+        parenthesesRemoved(parent.left) === use);
+}
 /**
  * The writes to the locals of one block that no read reaches. A write is a declaration's
- * initializer or a plain assignment written as a statement of the block itself; it is
- * dead when the statements after it in the block read the local nowhere before the next
- * such write to it, or before the block ends, which ends the local's scope. A statement
- * that writes the local inside a nested construct ends the search with the write kept,
- * and a local a nested function names is no subject, because the function may read it
- * at any time.
+ * initializer or a plain assignment written as a statement of the block; it is dead when
+ * the block's later statements read the local nowhere before the next such write or the
+ * block's end. A statement writing it inside a nested construct ends the search with the
+ * write kept. A local a nested function reads is no subject, since the function may run at
+ * any time, and every write to a local nothing reads is dead, a nested function's included.
  */
 function deadStores(file, root, block, holder, locals, ids) {
     const found = [];
+    const deadAt = (local, target) => ({
+        code: CODE.deadStore,
+        declaration: holder,
+        kind: "store",
+        name: local.name.text,
+        position: spanOf(file, root, target),
+        message: `value written to ${local.name.text} is never read`,
+        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)) {
+            // 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;
         }
@@ -719,12 +989,12 @@ function deadStores(file, root, block, holder, locals, ids) {
             if (!isExpressionStatement(statement)) {
                 return undefined;
             }
-            const expression = unwrapped(statement.expression);
+            const expression = parenthesesRemoved(statement.expression);
             if (!isBinaryExpression(expression) ||
                 expression.operatorToken.kind !== SyntaxKind.EqualsToken) {
                 return undefined;
             }
-            const target = unwrapped(expression.left);
+            const target = parenthesesRemoved(expression.left);
             return isIdentifier(target) && uses.includes(target)
                 ? { target, value: expression.right }
                 : undefined;
@@ -746,7 +1016,7 @@ function deadStores(file, root, block, holder, locals, ids) {
             if (sameStatement.length > 0) {
                 continue;
             }
-            let dead = true;
+            let dead = !local.outlives;
             for (let at = write.at + 1; at < statements.length; at += 1) {
                 const statement = statements[at];
                 if (statement === undefined) {
@@ -763,19 +1033,9 @@ function deadStores(file, root, block, holder, locals, ids) {
                     break;
                 }
             }
-            if (!dead) {
-                continue;
+            if (dead) {
+                found.push(deadAt(local, write.target));
             }
-            const position = spanOf(file, root, write.target);
-            found.push({
-                code: DEAD_STORE,
-                declaration: holder,
-                kind: "store",
-                name: local.name.text,
-                position,
-                message: `value written to ${local.name.text} is never read`,
-                used: false,
-            });
         }
     }
     return found;
@@ -812,7 +1072,7 @@ function resultParts(project, root, sites, references, calls) {
         const valued = project.queries.nonNullable(result);
         const members = isAnswered(valued) ? project.queries.propertiesOf(valued) : UNANSWERED;
         found.push({
-            code: UNUSED_RESULT,
+            code: CODE.unusedResult,
             declaration: id,
             kind: "result",
             name: "result",
@@ -839,6 +1099,12 @@ export function intraFunctionFacts(projects, references, exempted) {
         const known = parts.get(key);
         parts.set(key, known === undefined ? part : { ...known, used: known.used || part.used });
     }
+    const imports = new Map();
+    for (const binding of projects.flatMap((one) => one.imports)) {
+        const key = positionKey(binding.position);
+        const known = imports.get(key);
+        imports.set(key, known === undefined ? binding : { ...known, used: known.used || binding.used });
+    }
     const calls = new Map();
     const specifiers = new Set();
     for (const one of projects) {
@@ -885,5 +1151,11 @@ export function intraFunctionFacts(projects, references, exempted) {
     const discardedEverywhere = new Set([...called]
         .filter(([id, all]) => all && !valued.has(id) && !sequenced.has(id))
         .map(([id]) => id));
-    return { parts: [...parts.values()], free, freeButValued, discardedEverywhere };
+    return {
+        parts: [...parts.values()],
+        imports: [...imports.values()],
+        free,
+        freeButValued,
+        discardedEverywhere,
+    };
 }