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

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

@@ -4,11 +4,15 @@
  * 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, isHeritageClause, isIdentifier, isIfStatement, isImportClause, isImportSpecifier, isInterfaceDeclaration, isMethodDeclaration, isModuleDeclaration, isNamespaceImport, isNewExpression, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParenthesizedExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isQualifiedName, isReturnStatement, isShorthandPropertyAssignment, isStringLiteral, isSwitchStatement, isThrowStatement, isTypeAliasDeclaration, isTypeReferenceNode, isVariableStatement, isVoidExpression, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
+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";
@@ -117,13 +121,12 @@ function caseKey(expression) {
     }
     return undefined;
 }
-/** Every identifier below one node whose text one of the names spells, a member's name aside. */
+/** Every identifier below one node whose text one of the names spells as a reference. */
 function identifiersNaming(node, names) {
     const found = [];
     const visit = (at) => {
         if (isIdentifier(at)) {
-            const parent = at.parent;
-            if (names.has(at.text) && !(isPropertyAccessExpression(parent) && parent.name === at)) {
+            if (names.has(at.text) && !spellsNoBinding(at)) {
                 found.push(at);
             }
             return;
@@ -154,6 +157,15 @@ function inNestedFunction(node, outer) {
     }
     return false;
 }
+/** The nearest function around one node whose `arguments` object it names: an arrow has none. */
+function ownArgumentsOf(node) {
+    for (let at = node.parent; !isSourceFile(at); at = at.parent) {
+        if (isFunctionLikeDeclaration(at) && !isArrowFunction(at)) {
+            return at;
+        }
+    }
+    return undefined;
+}
 /** Whether a body is a stub: it holds no statement, or nothing but `throw` statements. */
 function isStub(signature) {
     const body = signature.body;
@@ -295,6 +307,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
@@ -310,7 +349,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.
@@ -329,6 +373,7 @@ export function projectParts(project, held, references, targetRoot) {
             values: [],
             catches: [],
             blocks: [],
+            loops: [],
             unreachable: [],
             cases: [],
         };
@@ -424,6 +469,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;
@@ -453,7 +507,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) {
@@ -467,7 +551,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);
             }
@@ -475,7 +562,10 @@ 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);
             }
@@ -491,6 +581,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: DEAD_STORE,
+                    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) {
@@ -523,6 +626,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,
@@ -549,7 +653,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 = [];
@@ -561,7 +667,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 {
@@ -577,7 +683,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;
         }
@@ -585,11 +691,91 @@ 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));
+}
+/**
+ * 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` 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.
+ * 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.
  */
 function withContextualRead(project, parts, contextual) {
     if (contextual.length === 0) {
@@ -597,9 +783,25 @@ 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, one.pattern || answer === UNANSWERED || place === undefined
+            ? { ...one.part, used: 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
@@ -607,9 +809,11 @@ 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) {
-    // A function that reads `arguments` reads every parameter by position.
-    const readsArguments = !isArrowFunction(signature) && identifiersNaming(signature, new Set(["arguments"])).length > 0;
+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) &&
+        identifiersNaming(signature, new Set(["arguments"])).some((use) => ownArgumentsOf(use) === signature);
     const read = reader.names.map(({ name }) => readsArguments ||
         reader.uses.some((use) => use.text === name.text && readsBinding(use, name, ids)));
     const lastRead = Math.max(-1, ...reader.names.filter((_, at) => read[at]).map((one) => one.at));
@@ -628,7 +832,7 @@ function parameterParts(file, root, declaration, signature, reader, ids, inValue
             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];
@@ -636,42 +840,79 @@ 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` 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.
+ */
 function localsOf(block) {
     const declared = [];
+    const scope = functionOf(block);
+    const outlives = scope?.body !== block;
     block.statements.forEach((statement, at) => {
         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)) {
+            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,
                 });
             }
         }
@@ -685,19 +926,39 @@ 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 &&
+        unwrapped(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: DEAD_STORE,
+        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));
+        if (!local.outlives && uses.every(isPlainWrite)) {
+            const targets = [...(local.initialized ? [local.name] : []), ...uses];
+            found.push(...targets.map((target) => deadAt(local, target)));
+            continue;
+        }
         if (uses.some((use) => inNestedFunction(use, block))) {
             continue;
         }
@@ -735,7 +996,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) {
@@ -752,19 +1013,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;
@@ -828,6 +1079,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) {
@@ -874,5 +1131,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,
+    };
 }