@cplieger/deadset-ts 8.0.0-dev.21 → 8.0.0-dev.22

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

@@ -4,12 +4,13 @@
  * 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 { 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 { isArrowFunction, isAwaitExpression, isBigIntLiteral, isBinaryExpression, isBindingElement, isBlock, isBreakStatement, isCallExpression, isCaseClause, isCatchClause, isClassDeclaration, isClassStaticBlockDeclaration, isClassExpression, isConditionalExpression, isConstructorDeclaration, isContinueStatement, isDecorator, isDefaultClause, isDoStatement, isEnumDeclaration, isExportDeclaration, isExportAssignment, isExportSpecifier, isExpressionStatement, isExpressionWithTypeArguments, isForInStatement, isForOfStatement, isForStatement, isFunctionDeclaration, isFunctionExpression, isFunctionLikeDeclaration, isGetAccessorDeclaration, isHeritageClause, isIdentifier, isIfStatement, isInterfaceDeclaration, isImportClause, isImportDeclaration, isImportEqualsDeclaration, isImportSpecifier, isLabeledStatement, isMethodDeclaration, isModuleBlock, isModuleDeclaration, isNamedExports, isNamespaceImport, isNewExpression, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParenthesizedExpression, isParameterDeclaration, isPrefixUnaryExpression, isPrivateIdentifier, isPropertyAccessExpression, isPropertyAssignment, isPropertyDeclaration, isPropertySignatureDeclaration, isQualifiedName, isReturnStatement, isSetAccessorDeclaration, isShorthandPropertyAssignment, isSourceFile, isStringLiteral, isSwitchStatement, isThrowStatement, isTryStatement, isTypeAliasDeclaration, isTypePredicateNode, isTypeReferenceNode, isVariableDeclaration, isVariableDeclarationList, isVariableStatement, isVoidExpression, isWhileStatement, isWithStatement, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
+import { SignatureKind, SymbolFlags, TypeFlags, } 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 { publishedAPI } from "./roots/published-reach.js";
+import { sourceFilesOf } from "./source-files.js";
 import { importRef } from "./ref.js";
 import { isAnswered, UNANSWERED } from "./query.js";
 import { signatureOf } from "./signatures.js";
@@ -52,42 +53,595 @@ function callUse(call) {
         ? "awaited"
         : "used";
 }
-/** Whether one statement leaves its statement list on every path: the rest of the list never runs. */
-function abrupt(statement) {
-    if (isReturnStatement(statement) ||
-        isThrowStatement(statement) ||
-        isBreakStatement(statement) ||
-        isContinueStatement(statement)) {
-        return true;
+/** What a namespace declaration holds at run time: nothing, only const enums, or values. */
+const HOLDS_NOTHING = 0;
+const HOLDS_CONST_ENUMS = 1;
+const HOLDS_VALUES = 2;
+/**
+ * The instance state of one declaration, as the compiler's binder computes it
+ * (`getModuleInstanceState`) from the declaration's own body. A name an export clause
+ * re-exports takes the state of the local declarations it names. A node met again while it
+ * is still being decided holds nothing, as in the binder.
+ */
+function instanceState(node, visited = new Map()) {
+    const known = visited.get(node);
+    if (known !== undefined || visited.has(node)) {
+        return known ?? HOLDS_NOTHING;
     }
-    if (isBlock(statement)) {
-        return statement.statements.some(abrupt);
+    visited.set(node, HOLDS_NOTHING);
+    const highest = (nodes, of) => {
+        let state = HOLDS_NOTHING;
+        for (const one of nodes) {
+            state = Math.max(state, of(one));
+            if (state === HOLDS_VALUES) {
+                break;
+            }
+        }
+        return state;
+    };
+    let state = HOLDS_VALUES;
+    if (isModuleDeclaration(node)) {
+        state = node.body === undefined ? HOLDS_VALUES : instanceState(node.body, visited);
     }
-    if (isIfStatement(statement)) {
-        return (statement.elseStatement !== undefined &&
-            abrupt(statement.thenStatement) &&
-            abrupt(statement.elseStatement));
+    else if (isModuleBlock(node)) {
+        state = highest(node.statements, (one) => instanceState(one, visited));
     }
-    return false;
+    else if (isInterfaceDeclaration(node) || isTypeAliasDeclaration(node)) {
+        state = HOLDS_NOTHING;
+    }
+    else if (isEnumDeclaration(node) && hasModifier(node, SyntaxKind.ConstKeyword)) {
+        state = HOLDS_CONST_ENUMS;
+    }
+    else if ((isImportDeclaration(node) || isImportEqualsDeclaration(node)) &&
+        !hasModifier(node, SyntaxKind.ExportKeyword)) {
+        state = HOLDS_NOTHING;
+    }
+    else if (isExportDeclaration(node) &&
+        node.moduleSpecifier === undefined &&
+        node.exportClause !== undefined &&
+        isNamedExports(node.exportClause)) {
+        state = highest(node.exportClause.elements, (one) => reexportedState(one, visited));
+    }
+    visited.set(node, state);
+    return state;
+}
+/** The instance state of the local declarations one export specifier names, the nearest scope's. */
+function reexportedState(specifier, visited) {
+    const name = specifier.propertyName ?? specifier.name;
+    if (!isIdentifier(name)) {
+        return HOLDS_VALUES;
+    }
+    const names = (statement) => {
+        if (isVariableStatement(statement)) {
+            return statement.declarationList.declarations.some(names);
+        }
+        const declared = statement.name;
+        return declared !== undefined && isIdentifier(declared) && declared.text === name.text;
+    };
+    for (let at = specifier.parent;; at = at.parent) {
+        if (isBlock(at) || isModuleBlock(at) || isSourceFile(at)) {
+            let found;
+            for (const statement of at.statements.filter(names)) {
+                if (isImportEqualsDeclaration(statement)) {
+                    return HOLDS_VALUES;
+                }
+                found = Math.max(found ?? HOLDS_NOTHING, instanceState(statement, visited));
+                if (found === HOLDS_VALUES) {
+                    return found;
+                }
+            }
+            if (found !== undefined) {
+                return found;
+            }
+        }
+        if (isSourceFile(at)) {
+            return HOLDS_VALUES;
+        }
+    }
+}
+/**
+ * Whether the compiler counts one statement as code that runs (`isPotentiallyExecutableNode`):
+ * any statement but a block or an empty one, a `var` only where it initializes a name, and a
+ * class, an enum or a namespace.
+ */
+function executable(node) {
+    if (isVariableStatement(node)) {
+        const list = node.declarationList;
+        return ((list.flags & NodeFlags.BlockScoped) !== 0 ||
+            list.declarations.some((one) => one.initializer !== undefined));
+    }
+    return ((node.kind >= SyntaxKind.FirstStatement && node.kind <= SyntaxKind.LastStatement) ||
+        isClassDeclaration(node) ||
+        isEnumDeclaration(node) ||
+        isModuleDeclaration(node));
 }
 /**
- * Whether an unreachable statement is no subject: a declaration the language hoists or
- * that emits nothing, an empty statement, and a `var` that initializes nothing.
+ * Whether an unreached statement is a finding, by the checker's exclusions
+ * (`isSourceElementUnreachable`): a const enum only while const enums are preserved, and a
+ * namespace only where its own declaration holds a value, or preserved const enums.
  */
-function unreachableExempt(statement) {
-    if (isFunctionDeclaration(statement) ||
-        isInterfaceDeclaration(statement) ||
-        isTypeAliasDeclaration(statement) ||
-        isModuleDeclaration(statement) ||
-        isEmptyStatement(statement)) {
+function reportable(statement, constEnumsPreserved) {
+    if (isEnumDeclaration(statement)) {
+        return constEnumsPreserved || !hasModifier(statement, SyntaxKind.ConstKeyword);
+    }
+    if (!isModuleDeclaration(statement)) {
         return true;
     }
-    if (isVariableStatement(statement)) {
-        const list = statement.declarationList;
-        return ((list.flags & (NodeFlags.Let | NodeFlags.Const | NodeFlags.Using)) === 0 &&
-            list.declarations.every((one) => one.initializer === undefined));
+    const state = instanceState(statement);
+    return state === HOLDS_VALUES || (constEnumsPreserved && state === HOLDS_CONST_ENUMS);
+}
+/**
+ * The bodies one statement runs as part of its own flow, as the binder does
+ * (`isImmediatelyInvoked`): a non-async, non-generator function expression or arrow that the
+ * statement's whole expression calls, or each static block of a class declaration, in order.
+ * Every other function-like body starts a flow of its own.
+ */
+function runsInline(statement) {
+    if (isClassDeclaration(statement)) {
+        return statement.members.filter(isClassStaticBlockDeclaration).map((one) => one.body);
     }
-    return false;
+    const call = isExpressionStatement(statement)
+        ? parenthesesRemoved(statement.expression)
+        : undefined;
+    const callee = call !== undefined && isCallExpression(call) ? parenthesesRemoved(call.expression) : undefined;
+    return callee !== undefined &&
+        (isFunctionExpression(callee) || isArrowFunction(callee)) &&
+        isBlock(callee.body) &&
+        !hasModifier(callee, SyntaxKind.AsyncKeyword) &&
+        callee.asteriskToken === undefined
+        ? [callee.body]
+        : [];
+}
+/** Whether a callee is a dotted name (`isDottedName`), whose call statement the binder's flow records. */
+function dottedName(node) {
+    if (isPropertyAccessExpression(node) || isParenthesizedExpression(node)) {
+        return dottedName(node.expression);
+    }
+    return (isIdentifier(node) ||
+        node.kind === SyntaxKind.ThisKeyword ||
+        node.kind === SyntaxKind.SuperKeyword ||
+        node.kind === SyntaxKind.MetaProperty);
+}
+/** Whether an argument is the checker's constant `false` (`isFalseExpression`). */
+function falseExpression(node) {
+    const bare = parenthesesRemoved(node);
+    if (bare.kind === SyntaxKind.FalseKeyword) {
+        return true;
+    }
+    if (!isBinaryExpression(bare)) {
+        return false;
+    }
+    const operator = bare.operatorToken.kind;
+    return operator === SyntaxKind.AmpersandAmpersandToken
+        ? falseExpression(bare.left) || falseExpression(bare.right)
+        : operator === SyntaxKind.BarBarToken &&
+            falseExpression(bare.left) &&
+            falseExpression(bare.right);
+}
+/** Whether a node is a member of a class body (`IsClassElement`). */
+function classElement(node) {
+    return CLASS_ELEMENTS.has(node.kind);
+}
+const CLASS_ELEMENTS = new Set([
+    SyntaxKind.Constructor,
+    SyntaxKind.PropertyDeclaration,
+    SyntaxKind.MethodDeclaration,
+    SyntaxKind.GetAccessor,
+    SyntaxKind.SetAccessor,
+    SyntaxKind.IndexSignature,
+    SyntaxKind.ClassStaticBlockDeclaration,
+    SyntaxKind.SemicolonClassElement,
+]);
+const THIS_CONTAINERS = new Set([
+    SyntaxKind.FunctionDeclaration,
+    SyntaxKind.FunctionExpression,
+    SyntaxKind.ModuleDeclaration,
+    SyntaxKind.ClassStaticBlockDeclaration,
+    SyntaxKind.PropertyDeclaration,
+    SyntaxKind.PropertySignature,
+    SyntaxKind.MethodDeclaration,
+    SyntaxKind.MethodSignature,
+    SyntaxKind.Constructor,
+    SyntaxKind.GetAccessor,
+    SyntaxKind.SetAccessor,
+    SyntaxKind.CallSignature,
+    SyntaxKind.ConstructSignature,
+    SyntaxKind.IndexSignature,
+    SyntaxKind.EnumDeclaration,
+    SyntaxKind.SourceFile,
+]);
+/** The node that binds a `this`, arrows passed through (`GetThisContainer`). */
+function thisContainer(node) {
+    let at = node.parent;
+    while (at !== undefined) {
+        if (THIS_CONTAINERS.has(at.kind)) {
+            return at;
+        }
+        if (at.kind === SyntaxKind.ComputedPropertyName) {
+            at = at.parent.parent;
+        }
+        else if (at.kind === SyntaxKind.Decorator) {
+            if (at.parent.kind === SyntaxKind.Parameter && classElement(at.parent.parent)) {
+                at = at.parent.parent;
+            }
+            else if (classElement(at.parent)) {
+                at = at.parent;
+            }
+        }
+        at = at.parent;
+    }
+    return undefined;
+}
+/** A predicate this port cannot read, whose signature then ends no call. */
+const UNKNOWN = Symbol("unknown");
+/**
+ * The call statements of a project's files that never return, by the checker's rule ported from
+ * the pinned typescript-go (microsoft/TypeScript 042e0fb, tsc/internal/checker/flow.go): the call
+ * arm of isReachableFlowNodeWorker (2554), getEffectsSignature (2059), getTypeOfDottedName (2134),
+ * getExplicitTypeOfSymbol (2167), hasTypePredicateOrNeverReturnType (2223), getExplicitThisType
+ * (2227); relater.go getTypePredicateOfSignature (2052). What the API hides or leaves unanswered
+ * (a mapped member's origin, a union signature's predicate) ends nothing.
+ */
+function neverReturning(project, files) {
+    const { queries } = project;
+    const statements = [];
+    const visit = (node) => {
+        if (isExpressionStatement(node) &&
+            isCallExpression(node.expression) &&
+            node.expression.expression.kind !== SyntaxKind.SuperKeyword &&
+            dottedName(node.expression.expression)) {
+            statements.push(node);
+        }
+        node.forEachChild(visit);
+    };
+    files.forEach(visit);
+    const known = (answer) => answer === undefined || !isAnswered(answer) ? undefined : answer;
+    const nodeOf = (handle) => handle === undefined ? undefined : project.declarationAt(handle)?.node;
+    const symbolAt = (node) => known(project.symbolsAt([project.handle(node)])[0]);
+    const never = (type) => type !== undefined && (type.flags & TypeFlags.Never) !== 0;
+    // resolvingExplicitTypeOfSymbol (flow.go:2169): the for-of arm recurses through the iterated
+    // name, so loops whose iterables name each other's variables would recurse forever. A call
+    // through such a variable still reaches this walk where narrowing types it `never`. A symbol
+    // met again on the walk has no explicit type, so its call ends nothing.
+    const resolving = new Set();
+    const explicitTypeOf = (given) => {
+        // IsNonLocalAlias: an alias with no meaning of its own, or one an assignment declares.
+        const aliased = (given.flags & SymbolFlags.Alias) !== 0 &&
+            ((given.flags & (SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace)) === 0 ||
+                (given.flags & SymbolFlags.Assignment) !== 0);
+        const symbol = aliased ? known(queries.aliased(given)) : given;
+        if (symbol === undefined || resolving.has(symbol.id)) {
+            return undefined;
+        }
+        resolving.add(symbol.id);
+        try {
+            if ((symbol.flags &
+                (SymbolFlags.Function |
+                    SymbolFlags.Method |
+                    SymbolFlags.Class |
+                    SymbolFlags.ValueModule)) !==
+                0) {
+                return known(queries.typeOfSymbol(symbol));
+            }
+            if ((symbol.flags & (SymbolFlags.Variable | SymbolFlags.Property)) === 0) {
+                return undefined;
+            }
+            // A mapped member declares no value of its own, and the API does not expose its origin.
+            const declaration = nodeOf(symbol.valueDeclaration);
+            if (declaration === undefined) {
+                return undefined;
+            }
+            if (explicitlyTyped(declaration)) {
+                return known(queries.typeOfSymbol(symbol));
+            }
+            if (isVariableDeclaration(declaration) && isForOfStatement(declaration.parent.parent)) {
+                const { expression } = declaration.parent.parent;
+                const iterated = dottedTypeOf(expression);
+                const held = iterated === undefined ? undefined : known(queries.typeAt(expression));
+                // The variable's own type iterates the expression's type there, which is the checker's
+                // iteration of the dotted name's type where the two are one type.
+                return held !== undefined && held.id === iterated?.id
+                    ? known(queries.typeOfSymbol(symbol))
+                    : undefined;
+            }
+            return undefined;
+        }
+        finally {
+            resolving.delete(symbol.id);
+        }
+    };
+    const propertyOf = (type, name) => {
+        const properties = known(queries.propertiesOf(type));
+        if (properties === undefined) {
+            return undefined;
+        }
+        if (isIdentifier(name)) {
+            return properties.find((one) => one.name === name.text);
+        }
+        if (!isPrivateIdentifier(name)) {
+            return undefined;
+        }
+        // getTypeOfDottedName (flow.go:2149) keys a private name by the receiver type's own symbol,
+        // so only that class's member answers, and a type with no symbol has none. The lexical
+        // member's key is that key exactly where its class is the receiver type's symbol.
+        const owner = known(queries.symbolOfType(type));
+        const declared = owner === undefined ? undefined : symbolAt(name);
+        if (owner === undefined || declared === undefined) {
+            return undefined;
+        }
+        return known(queries.parentOf(declared))?.id === owner.id
+            ? properties.find((one) => one.name === declared.name)
+            : undefined;
+    };
+    // getSignatureFromDeclaration's `this` parameter (checker.go:20510, 20529): the container's
+    // own or, for an accessor without one, its pair's, which getAccessorThisParameter takes only
+    // from a getter with one parameter or a setter with two.
+    const thisParameterOf = (container) => {
+        const [own] = container.parameters;
+        if (own !== undefined && symbolName(own) === "this") {
+            return own;
+        }
+        const getter = isGetAccessorDeclaration(container);
+        if (!getter && !isSetAccessorDeclaration(container)) {
+            return undefined;
+        }
+        const other = getter ? isSetAccessorDeclaration : isGetAccessorDeclaration;
+        const pair = symbolAt(container.name)
+            ?.declarations.map(nodeOf)
+            .find((one) => one !== undefined && other(one));
+        const first = pair?.parameters[0];
+        return first !== undefined &&
+            pair?.parameters.length === (getter ? 2 : 1) &&
+            symbolName(first) === "this"
+            ? first
+            : undefined;
+    };
+    const explicitThisTypeOf = (node) => {
+        const container = thisContainer(node);
+        if (container === undefined) {
+            return undefined;
+        }
+        if (isFunctionLikeDeclaration(container)) {
+            const signature = known(queries.signatureOf(container));
+            if (signature === undefined) {
+                return undefined;
+            }
+            if (signature.thisParameter !== undefined) {
+                const declaration = thisParameterOf(container);
+                const parameter = declaration === undefined ? undefined : symbolAt(declaration.name);
+                return parameter === undefined ? undefined : explicitTypeOf(parameter);
+            }
+        }
+        const owner = container.parent;
+        const name = owner !== undefined && (isClassDeclaration(owner) || isClassExpression(owner))
+            ? owner.name
+            : undefined;
+        const symbol = name === undefined ? undefined : symbolAt(name);
+        if (symbol === undefined) {
+            return undefined;
+        }
+        return isClassStaticBlockDeclaration(container) ||
+            (classElement(container) && hasModifier(container, SyntaxKind.StaticKeyword))
+            ? known(queries.typeOfSymbol(symbol))
+            : known(queries.declaredTypeOf(symbol));
+    };
+    const dottedTypeOf = (node) => {
+        if ((node.flags & NodeFlags.InWithStatement) !== 0) {
+            return undefined;
+        }
+        if (isIdentifier(node)) {
+            // A name's value meaning finds a module member's export symbol, which is
+            // getExportSymbolOfValueSymbolIfExported over its resolved symbol.
+            const symbol = symbolAt(node);
+            return symbol === undefined ? undefined : explicitTypeOf(symbol);
+        }
+        if (node.kind === SyntaxKind.ThisKeyword) {
+            return explicitThisTypeOf(node);
+        }
+        if (node.kind === SyntaxKind.SuperKeyword) {
+            return known(queries.typeAt(node));
+        }
+        if (isPropertyAccessExpression(node)) {
+            const type = dottedTypeOf(node.expression);
+            const property = type === undefined ? undefined : propertyOf(type, node.name);
+            return property === undefined ? undefined : explicitTypeOf(property);
+        }
+        return isParenthesizedExpression(node) ? dottedTypeOf(node.expression) : undefined;
+    };
+    const predicateOf = (signature, declaration) => {
+        const declared = known(queries.signatureOf(declaration));
+        let at = signature;
+        for (let step = 0; at !== undefined && at.id !== declared?.id; step++) {
+            at = step < SIGNATURE_TARGET_DEPTH ? known(queries.genericOf(at)) : undefined;
+        }
+        // A union's signature carries its first member's declaration and its own predicate.
+        if (at === undefined) {
+            return UNKNOWN;
+        }
+        const type = declaration.type;
+        if (type === undefined || !isTypePredicateNode(type)) {
+            return undefined;
+        }
+        const name = type.parameterName;
+        const parameters = declaration.parameters ?? [];
+        const named = parameters.filter((one, index) => !(index === 0 && symbolName(one) === "this"));
+        return {
+            asserts: type.assertsModifier !== undefined,
+            typed: type.type !== undefined,
+            index: name.kind === SyntaxKind.ThisType
+                ? -1
+                : named.findIndex((one) => isIdentifier(name) && symbolName(one) === name.text),
+        };
+    };
+    // getReturnTypeFromAnnotation (checker.go:20705). A constructor's result is its instance type,
+    // which is not never, and a declaration with no type node writes no never result: a JavaScript
+    // type tag's signature is declared by the tag's own function type, which carries the annotation.
+    const annotatedNever = (declaration) => {
+        if (declaration.type === undefined) {
+            return false;
+        }
+        const declared = known(queries.signatureOf(declaration));
+        return declared !== undefined && never(known(queries.returnTypeOf(declared)));
+    };
+    // Whether a signature has a predicate or writes `never` as its result, where the API tells.
+    const marked = (signature) => {
+        const declaration = nodeOf(signature.declaration);
+        if (declaration === undefined) {
+            return false;
+        }
+        const predicate = predicateOf(signature, declaration);
+        return predicate !== UNKNOWN && (predicate !== undefined || annotatedNever(declaration));
+    };
+    const effectsOf = (call) => {
+        const type = dottedTypeOf(call.expression);
+        const signatures = type === undefined ? undefined : known(queries.signaturesOf(type, SignatureKind.Call));
+        if (signatures === undefined) {
+            return undefined;
+        }
+        const [only] = signatures;
+        const chosen = signatures.length === 1 && only !== undefined && (only.typeParameters?.length ?? 0) === 0
+            ? only
+            : signatures.some(marked)
+                ? known(queries.resolvedSignature(call))
+                : undefined;
+        return chosen !== undefined && marked(chosen) ? chosen : undefined;
+    };
+    // The effects signature's result is the call's own type, so a call typed neither `never` nor
+    // `void` with a false argument cannot end, and is never asked about.
+    const types = statements.length === 0 ? [] : queries.typesAt(statements.map((one) => one.expression));
+    const ends = new Set();
+    statements.forEach((statement, at) => {
+        const type = known(types[at]);
+        const call = statement.expression;
+        if (type === undefined ||
+            (!never(type) &&
+                ((type.flags & TypeFlags.Void) === 0 || !call.arguments.some(falseExpression)))) {
+            return;
+        }
+        const effects = effectsOf(call);
+        const declaration = effects === undefined ? undefined : nodeOf(effects.declaration);
+        if (effects === undefined || declaration === undefined) {
+            return;
+        }
+        // The checker ends a bare `asserts value` call whose argument there is false.
+        const predicate = predicateOf(effects, declaration);
+        const asserted = predicate !== UNKNOWN && predicate?.asserts === true && !predicate.typed
+            ? call.arguments[predicate.index]
+            : undefined;
+        if ((asserted !== undefined && falseExpression(asserted)) ||
+            never(known(queries.returnTypeOf(effects)))) {
+            ends.add(statement);
+        }
+    });
+    return ends;
+}
+/** Whether a declaration writes its own type (`isDeclarationWithExplicitTypeAnnotation`, flow.go:2209). */
+function explicitlyTyped(declaration) {
+    if (isVariableDeclaration(declaration) ||
+        isPropertyDeclaration(declaration) ||
+        isPropertySignatureDeclaration(declaration) ||
+        isParameterDeclaration(declaration)) {
+        return declaration.type !== undefined;
+    }
+    // An expando property is typed by the function it is assigned, where that writes its result.
+    return (isBinaryExpression(declaration) &&
+        (isFunctionExpression(declaration.right) || isArrowFunction(declaration.right)) &&
+        declaration.right.type !== undefined);
+}
+/** The name a declaration's symbol carries, for an identifier-named one. */
+function symbolName(declaration) {
+    const name = declaration.name;
+    return name !== undefined && isIdentifier(name) ? name.text : undefined;
+}
+/** How many instantiations deep a signature's generic is followed to its declaration's own. */
+const SIGNATURE_TARGET_DEPTH = 8;
+/**
+ * The statements of one file the compiler counts as code that runs and that no path from the
+ * start of their own flow reaches: the file's, a namespace body's, or a function-like body's
+ * that does not run inline. The walk is `flowWalk`'s with each statement a target of its own,
+ * and a construct it does not follow leaves every statement inside it reached.
+ */
+function unreachedOf(file, ends) {
+    const flows = [];
+    const inline = new Set();
+    const collect = (node, members) => {
+        for (const body of runsInline(node)) {
+            inline.add(body);
+        }
+        node.forEachChild((child) => {
+            const own = isModuleBlock(child)
+                ? child.statements
+                : isBlock(child) &&
+                    !inline.has(child) &&
+                    (isFunctionLikeDeclaration(node) || isClassStaticBlockDeclaration(node))
+                    ? child.statements
+                    : undefined;
+            if (own !== undefined) {
+                const inner = [];
+                flows.push({ statements: own, members: inner });
+                collect(child, inner);
+                return;
+            }
+            if (executable(child)) {
+                members.push(child);
+            }
+            collect(child, members);
+        });
+    };
+    const top = [];
+    flows.push({ statements: file.statements, members: top });
+    collect(file, top);
+    const unreached = new Set();
+    for (const { statements, members } of flows) {
+        // Members are in source order, so those inside one node are one run of bits.
+        const first = (pos) => {
+            let low = 0;
+            for (let high = members.length; low < high;) {
+                const middle = (low + high) >> 1;
+                if ((members[middle]?.pos ?? pos) < pos) {
+                    low = middle + 1;
+                }
+                else {
+                    high = middle;
+                }
+            }
+            return low;
+        };
+        const inside = (node) => {
+            if (node === undefined) {
+                return NOTHING;
+            }
+            let low = first(node.pos);
+            const high = first(node.end);
+            while (low < high && (members[low]?.end ?? 0) > node.end) {
+                low += 1;
+            }
+            return low >= high ? NOTHING : ((1n << BigInt(high - low)) - 1n) << BigInt(low);
+        };
+        const indexes = new Map(members.map((one, at) => [one, at]));
+        const walk = flowWalk({
+            inside,
+            at: (statement) => {
+                const index = indexes.get(statement);
+                return index === undefined ? NOTHING : 1n << BigInt(index);
+            },
+            writes: [],
+            ends,
+        });
+        const reached = walk.sequence(statements, NOTHING, {
+            exit: NOTHING,
+            raise: NOTHING,
+            escape: NOTHING,
+            labels: new Map(),
+        });
+        const digits = reached.toString(2);
+        members.forEach((member, at) => {
+            if (digits[digits.length - 1 - at] !== "1") {
+                unreached.add(member);
+            }
+        });
+    }
+    return unreached;
 }
 /** The value a case expression is a literal of, as a key two equal literals share, or none. */
 function caseKey(expression) {
@@ -190,38 +744,61 @@ function returnsAValue(signature) {
 function hasModifier(node, kind) {
     return (node.modifiers ?? []).some((modifier) => modifier.kind === kind);
 }
-/** Every class name an `extends` clause of the project names, by its last identifier. */
-function extendedNames(files) {
-    const names = new Set();
+/** How many alias links a heritage name is followed through, one per re-export. */
+const ALIAS_DEPTH = 16;
+/** The last identifier of one heritage type: a class's clause holds expressions, an interface's may hold type references. */
+function heritageName(type) {
+    if (isTypeReferenceNode(type)) {
+        const named = isQualifiedName(type.typeName) ? type.typeName.right : type.typeName;
+        return isIdentifier(named) ? named : undefined;
+    }
+    return isExpressionWithTypeArguments(type) ? spelledName(type.expression) : undefined;
+}
+/** What every heritage clause of the project's files names, asked of the checker in one batch. */
+function heritageOf(project, files) {
+    const named = [];
     const visit = (node) => {
-        if (isHeritageClause(node) && node.token === SyntaxKind.ExtendsKeyword) {
-            for (const type of node.types) {
-                // A class's clause holds expressions; an interface's holds type references.
-                let named;
-                if (isTypeReferenceNode(type)) {
-                    named = isQualifiedName(type.typeName) ? type.typeName.right : type.typeName;
-                }
-                else {
-                    const expression = parenthesesRemoved(type.expression);
-                    named = isPropertyAccessExpression(expression) ? expression.name : expression;
-                }
-                if (isIdentifier(named)) {
-                    names.add(named.text);
-                }
-            }
+        if (isHeritageClause(node)) {
+            named.push(...node.types.flatMap((type) => heritageName(type) ?? []));
         }
         node.forEachChild(visit);
     };
     for (const file of files) {
         file.forEachChild(visit);
     }
-    return names;
+    const ids = new Set();
+    const unanswered = new Set();
+    project.symbolsAt(named.map((name) => project.handle(name))).forEach((answer, at) => {
+        let symbol = answer;
+        for (let step = 0; step < ALIAS_DEPTH && symbol !== undefined && symbol !== UNANSWERED; step++) {
+            const next = project.aliasStepOf(symbol);
+            if (next === undefined) {
+                break;
+            }
+            symbol = next;
+        }
+        if (symbol === UNANSWERED) {
+            unanswered.add(named[at]?.text ?? "");
+        }
+        else if (symbol !== undefined) {
+            ids.add(symbol.id);
+        }
+    });
+    return { ids, names: new Set(named.map((name) => name.text)), unanswered };
+}
+/** The names a class is known by: its own, and the variable a class expression initializes. */
+function classNames(owner) {
+    const own = owner.name;
+    const holder = isClassExpression(owner) ? outerParent(owner) : undefined;
+    const held = holder !== undefined && isVariableDeclaration(holder) ? holder.name : undefined;
+    return [own, held].filter((name) => name !== undefined && isIdentifier(name));
 }
 /**
  * Whether a class hierarchy fixes one method's signature: its class extends or implements
- * another type, is abstract or is extended itself, or the method is marked `override`.
+ * another type, is abstract, or is a type a clause of the project extends or implements,
+ * or the method is marked `override`.
  */
-function hierarchyFixes(declared, extended) {
+function hierarchyFixes(declared, heritage, ids) {
     if (!isMethodDeclaration(declared)) {
         return false;
     }
@@ -230,13 +807,16 @@ function hierarchyFixes(declared, extended) {
         return false;
     }
     if (hasModifier(declared, SyntaxKind.OverrideKeyword) ||
-        hasModifier(owner, SyntaxKind.AbstractKeyword)) {
+        hasModifier(owner, SyntaxKind.AbstractKeyword) ||
+        (owner.heritageClauses ?? []).length > 0) {
         return true;
     }
-    if ((owner.heritageClauses ?? []).length > 0) {
-        return true;
-    }
-    return owner.name !== undefined && extended.has(owner.name.text);
+    return classNames(owner).some((name) => {
+        const id = ids.get(name);
+        return id === undefined || id === UNANSWERED
+            ? heritage.names.has(name.text)
+            : heritage.ids.has(id) || heritage.unanswered.has(name.text);
+    });
 }
 /** Whether a decorator on a constructor's class or on one of its parameters fixes its signature. */
 function decoratorFixes(constructor) {
@@ -326,6 +906,15 @@ function checkedByTheCompiler(file, checkJs) {
     }
     return (!/\.[cm]?jsx?$/u.test(file.fileName) || checkJs || hasPragma(leading, /^\s*@ts-check(?:\s|$)/iu));
 }
+/** Whether one child of a node is a statement it runs in no statement list: a branch or a body. */
+function inStatementPosition(node, child) {
+    if (isIfStatement(node)) {
+        return child === node.thenStatement || child === node.elseStatement;
+    }
+    // The body of a `do`, a label, a `for…of`, a `for…in` or a `with` runs whenever its
+    // statement does, so only these can start an unreachable run of their own.
+    return (isWhileStatement(node) || isForStatement(node)) && child === node.statement;
+}
 /**
  * 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
@@ -333,7 +922,7 @@ function checkedByTheCompiler(file, checkJs) {
  */
 export function projectParts(project, held, references, targetRoot) {
     const files = project.ownSourceFiles();
-    const extended = extendedNames(files);
+    const heritage = heritageOf(project, files);
     const parts = [];
     const signatures = [];
     const calls = new Map();
@@ -345,7 +934,14 @@ export function projectParts(project, held, references, targetRoot) {
     const refs = new Map(held.symbols.map((symbol) => [symbol.id, symbol.ref]));
     const options = project.program.getCompilerOptions();
     const jsx = options;
+    // The compiler's `shouldPreserveConstEnums`, whose isolated modules include `verbatimModuleSyntax`.
+    const constEnumsPreserved = options.preserveConstEnums === true ||
+        options.isolatedModules === true ||
+        options.verbatimModuleSyntax === true;
+    const ends = neverReturning(project, files);
+    const judged = new Set();
     for (const file of files) {
+        judged.add(renderPosition(file, targetRoot, 0).path);
         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));
@@ -371,26 +967,24 @@ export function projectParts(project, held, references, targetRoot) {
         };
         const covered = new Set();
         const position = (node) => positionKey(renderPosition(file, targetRoot, node.getStart()));
-        // Code below an unreachable statement is still walked for its calls and specifiers,
-        // and reports no part of its own: the unreachable statement is the one finding.
+        // Code inside a run of unreachable statements is still walked for its calls and
+        // specifiers, and reports no part of its own: the run's first statement is the one
+        // finding, as the compiler reports one diagnostic per run.
+        const unreached = unreachedOf(file, ends);
+        const unreachable = (statement) => unreached.has(statement) && reportable(statement, constEnumsPreserved);
         let silenced = 0;
         const statementsOf = (statements) => {
-            let reachable = true;
-            let reported = false;
+            let inRun = false;
             for (const statement of statements) {
-                if (reachable) {
-                    visit(statement);
-                    reachable = !abrupt(statement);
-                    continue;
-                }
-                const holder = holderOf(statement);
-                if (silenced === 0 && !reported && !unreachableExempt(statement) && holder !== undefined) {
+                const unreached = unreachable(statement);
+                const holder = unreached && !inRun && silenced === 0 ? holderOf(statement) : undefined;
+                if (holder !== undefined) {
                     walk.unreachable.push({ statement, holder });
-                    reported = true;
                 }
-                silenced += 1;
+                inRun = unreached;
+                silenced += unreached ? 1 : 0;
                 visit(statement);
-                silenced -= 1;
+                silenced -= unreached ? 1 : 0;
             }
         };
         const visit = (node) => {
@@ -458,7 +1052,12 @@ export function projectParts(project, held, references, targetRoot) {
                     }
                 }
             }
-            if (isBlock(node) && silenced === 0 && holderOf(node) !== undefined) {
+            // A block whose first statement no flow reaches is never entered: the compiler
+            // reports the run from inside it, and its locals hold no store of their own.
+            if (isBlock(node) &&
+                silenced === 0 &&
+                (node.statements[0] === undefined || !unreachable(node.statements[0])) &&
+                holderOf(node) !== undefined) {
                 walk.blocks.push(node);
             }
             const loopHolder = (isForOfStatement(node) || isForInStatement(node)) && silenced === 0
@@ -470,13 +1069,21 @@ export function projectParts(project, held, references, targetRoot) {
                 (node.initializer.flags & (NodeFlags.Let | NodeFlags.Const)) !== 0) {
                 walk.loops.push({ loop: node, holder: loopHolder });
             }
-            if (isBlock(node) || isCaseClause(node) || isDefaultClause(node)) {
+            if (isBlock(node) || isCaseClause(node) || isDefaultClause(node) || isModuleBlock(node)) {
                 statementsOf(node.statements);
                 return;
             }
-            node.forEachChild(visit);
+            // A statement that is a branch or a body of another, in no list, is a run of its own.
+            node.forEachChild((child) => {
+                if (inStatementPosition(node, child)) {
+                    statementsOf([child]);
+                }
+                else {
+                    visit(child);
+                }
+            });
         };
-        file.forEachChild(visit);
+        statementsOf(file.statements);
         // One batch per file resolves every name a parameter or a local is read through.
         const asked = [];
         const readers = new Map();
@@ -509,6 +1116,15 @@ export function projectParts(project, held, references, targetRoot) {
             asked.push(...names, ...uses);
             return { names, uses, holder };
         });
+        const measured = lengthReads(file);
+        const measuredNames = new Set(measured.map((one) => one.text));
+        const named = walk.declared.flatMap(({ node }) => {
+            const name = node.name;
+            return name !== undefined && isIdentifier(name) && measuredNames.has(name.text) ? [name] : [];
+        });
+        asked.push(...measured, ...named);
+        const owners = walk.declared.flatMap(({ node }) => isMethodDeclaration(node) ? classNames(node.parent) : []);
+        asked.push(...owners);
         const bindings = fileId === undefined ? [] : importBindings(file);
         const bound = new Set(bindings);
         const bindingUses = bindings.length === 0
@@ -538,11 +1154,11 @@ export function projectParts(project, held, references, targetRoot) {
             signatures.push({
                 declaration: one.id,
                 stub: isStub(one.signature),
-                fixed: constructor ? decoratorFixes(one.node) : hierarchyFixes(one.node, extended),
+                fixed: constructor ? decoratorFixes(one.node) : hierarchyFixes(one.node, heritage, ids),
                 constructor,
             });
             const reader = readers.get(one.signature);
-            if (reader !== undefined) {
+            if (reader !== undefined && !lengthRead(one.node, measured, ids)) {
                 const found = parameterParts(file, targetRoot, one.id, one.signature, reader, ids, {
                     inValue: false,
                     checked,
@@ -562,68 +1178,105 @@ export function projectParts(project, held, references, targetRoot) {
                 contextual.push(...found.contextual);
             }
         }
+        const part = (declaration, kind, name, node) => ({
+            declaration,
+            kind,
+            name,
+            position: spanOf(file, targetRoot, node),
+        });
         walk.catches.forEach(({ name, holder }, at) => {
-            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: (caught[at] ?? []).some((use) => readsBinding(use, name, ids)),
-            });
+            if (!(caught[at] ?? []).some((use) => readsBinding(use, name, ids))) {
+                parts.push(part(holder, "store", name.text, name));
+            }
         });
         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)),
-                });
+                if (!uses.some((use) => use.text === name.text && readsBinding(use, name, ids))) {
+                    parts.push(part(holder, "store", name.text, name));
+                }
             }
         }
         walk.blocks.forEach((block, at) => {
             const holder = holderOf(block);
             if (holder !== undefined) {
-                parts.push(...deadStores(file, targetRoot, block, holder, stores[at] ?? [], ids));
+                for (const { local, target } of deadStores(block, stores[at] ?? [], ids, ends)) {
+                    parts.push(part(holder, "store", local.name.text, target));
+                }
             }
         });
         for (const { statement, holder } of walk.unreachable) {
-            parts.push({
-                code: CODE.unreachableStatement,
-                declaration: holder,
-                kind: "statement",
-                name: "statement",
-                position: spanOf(file, targetRoot, statement),
-                message: "statement is unreachable",
-                used: false,
-            });
+            parts.push(part(holder, "statement", "statement", statement));
         }
         for (const { clause, text, holder } of walk.cases) {
-            parts.push({
-                code: CODE.unreachableCase,
-                declaration: holder,
-                kind: "case",
-                name: text,
-                position: spanOf(file, targetRoot, clause),
-                message: `case ${text} is covered by an earlier case of the same switch`,
-                used: false,
-            });
+            parts.push(part(holder, "case", text, clause));
         }
     }
-    parts.push(...resultParts(project, targetRoot, sites, references, calls));
+    const results = resultParts(project, targetRoot, sites, references, calls);
     return {
-        parts: withContextualRead(project, parts, contextual),
+        // Only a result reads whether outside callers can reach its declaration.
+        published: results.parts.length === 0 ? new Set() : importable(project, held, targetRoot),
+        parts: [...withContextualRead(project, parts, contextual), ...results.parts],
         imports,
         signatures,
         calls,
         specifiers,
         constructions,
+        files: judged,
+        results: results.judged,
+    };
+}
+/** Every identifier of one file whose `length` a property access reads. */
+function lengthReads(file) {
+    const found = [];
+    const visit = (node) => {
+        if (isPropertyAccessExpression(node) && node.name.text === "length") {
+            const read = parenthesesRemoved(node.expression);
+            if (isIdentifier(read)) {
+                found.push(read);
+            }
+        }
+        node.forEachChild(visit);
     };
+    file.forEachChild(visit);
+    return found;
+}
+/**
+ * Whether the program reads the `length` of one declared function through its own binding,
+ * which counts its parameters, so none can go. A read the checker leaves unanswered counts.
+ */
+function lengthRead(declared, measured, ids) {
+    const name = declared.name;
+    if (name === undefined || !isIdentifier(name)) {
+        return false;
+    }
+    const own = ids.get(name);
+    return measured.some((read) => {
+        if (read.text !== name.text) {
+            return false;
+        }
+        const at = ids.get(read);
+        return (at === undefined || at === UNANSWERED || own === undefined || own === UNANSWERED || at === own);
+    });
+}
+/**
+ * Every declaration an outside importer of any of the project's own files can name, as the
+ * published-API reach states it with each file published, and each one it guessed.
+ */
+function importable(project, held, targetRoot) {
+    const files = sourceFilesOf(project, targetRoot);
+    const exported = new Map();
+    for (const symbol of held.symbols) {
+        if (symbol.exported) {
+            exported.set(symbol.parent, [...(exported.get(symbol.parent) ?? []), symbol.id]);
+        }
+    }
+    const own = [...files.byName.values()];
+    const exportsOf = new Map(own.map((file) => [
+        file.fileName,
+        exported.get(held.declarations.get(nodeKey(file, file)) ?? "") ?? [],
+    ]));
+    const api = publishedAPI(project, own, exportsOf, held, files.byPath, []);
+    return new Set([...api.ids, ...api.guessed]);
 }
 /**
  * A function written in place that no declaration declares: an arrow, a function
@@ -766,7 +1419,7 @@ function calleeSteers(project, signature, at) {
  * 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.
+ * checker leaves unanswered keeps the name read, so its part is dropped.
  */
 function withContextualRead(project, parts, contextual) {
     if (contextual.length === 0) {
@@ -783,7 +1436,7 @@ function withContextualRead(project, parts, contextual) {
         }
         const place = one.part.parameter;
         judged.set(one.part, answer === UNANSWERED || place === undefined
-            ? { ...one.part, used: true }
+            ? undefined
             : one.pattern
                 ? { ...one.part, parameter: { ...place, contextualPattern: true } }
                 : {
@@ -794,13 +1447,13 @@ function withContextualRead(project, parts, contextual) {
                     },
                 });
     }
-    return parts.map((part) => judged.get(part) ?? part);
+    return parts.flatMap((part) => (judged.has(part) ? (judged.get(part) ?? []) : [part]));
 }
 /**
- * Each name one function's parameters bind and whether the function reads it, and the
- * unread names a contextual type of a function expression may keep: those of a parameter
- * 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.
+ * Each name one function's parameters bind that the function never reads, and those of
+ * them a contextual type of a function expression may keep: the names of a parameter 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, place) {
     // A function that reads its `arguments` reads every parameter by position. A nested
@@ -813,24 +1466,25 @@ function parameterParts(file, root, declaration, signature, reader, ids, place)
     const found = [];
     const contextual = [];
     const expression = isArrowFunction(signature) || isFunctionExpression(signature) ? signature : undefined;
+    const length = signature.parameters.findIndex((one) => one.initializer !== undefined || one.dotDotDotToken !== undefined);
     reader.names.forEach(({ name, at, pattern, exempt }, index) => {
-        if (exempt) {
+        if (exempt || read[index] === true) {
             return;
         }
         const part = {
-            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, ...place },
+            parameter: {
+                beforeARead: !pattern && at < lastRead,
+                counted: length < 0 || at < length,
+                ...place,
+            },
         };
         found.push(part);
         const parameter = signature.parameters[at];
         if (expression !== undefined &&
-            !part.used &&
             parameter !== undefined &&
             (parameter.type !== undefined || isObjectBindingPattern(parameter.name))) {
             contextual.push({
@@ -945,25 +1599,344 @@ function isPlainWrite(use) {
         parent.operatorToken.kind === SyntaxKind.EqualsToken &&
         parenthesesRemoved(parent.left) === use);
 }
+const NOTHING = 0n;
+const READ = 1n;
+/** Whether a block sits inside a `try` whose `catch` or `finally` runs after the block is left. */
+function handledOutside(block, scope) {
+    for (let at = block.parent; at !== scope && !isSourceFile(at); at = at.parent) {
+        if (isTryStatement(at) &&
+            (at.finallyBlock !== undefined ||
+                (at.catchClause !== undefined && within(block, at.tryBlock)))) {
+            return true;
+        }
+    }
+    return false;
+}
+const UNEVALUATED = { yes: false, no: false, nullish: false, throws: false };
+/** The literals whose evaluation runs no code. */
+const LITERALS = new Set([
+    SyntaxKind.TrueKeyword,
+    SyntaxKind.FalseKeyword,
+    SyntaxKind.NullKeyword,
+    SyntaxKind.NumericLiteral,
+    SyntaxKind.BigIntLiteral,
+    SyntaxKind.StringLiteral,
+    SyntaxKind.NoSubstitutionTemplateLiteral,
+    SyntaxKind.RegularExpressionLiteral,
+]);
 /**
- * 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; 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.
+ * One walk over an expression with JavaScript's short-circuit. It folds only the values the
+ * binder folds (`bindCondition`): an absent part, and a bare `true` or `false` that is the
+ * whole condition, an operand of `&&` or `||` or a `?:` condition, seen through `(` and `!`
+ * only to a logical operator. The binder sends a falsy left operand of `??` to the right;
+ * JavaScript and this walk end the `??` there.
  */
-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,
+function evaluationOf(node) {
+    if (node === undefined) {
+        return { yes: true, no: false, nullish: false, throws: false };
+    }
+    const core = logicalCore(node);
+    if (core === undefined) {
+        const leaf = negationsRemoved(node);
+        const literal = LITERALS.has(leaf.kind);
+        const folded = (leaf.kind === SyntaxKind.TrueKeyword || leaf.kind === SyntaxKind.FalseKeyword) &&
+            leaf === node &&
+            !(isBinaryExpression(node.parent) &&
+                node.parent.operatorToken.kind === SyntaxKind.QuestionQuestionToken);
+        // The binder judges a `?:` whole, so it goes either way; a branch runs where its condition may go its way.
+        const test = isConditionalExpression(leaf) ? evaluationOf(leaf.condition) : undefined;
+        const branches = test !== undefined && isConditionalExpression(leaf)
+            ? [...(test.yes ? [leaf.whenTrue] : []), ...(test.no ? [leaf.whenFalse] : [])].map((branch) => evaluationOf(branch))
+            : undefined;
+        return {
+            yes: !folded || leaf.kind === SyntaxKind.TrueKeyword,
+            no: !folded || leaf.kind === SyntaxKind.FalseKeyword,
+            nullish: leaf === parenthesesRemoved(node) &&
+                (branches?.some((one) => one.nullish) ??
+                    (!literal || leaf.kind === SyntaxKind.NullKeyword)),
+            throws: test === undefined ? !literal : test.throws || (branches ?? []).some((one) => one.throws),
+        };
+    }
+    if (isParenthesizedExpression(node)) {
+        return evaluationOf(node.expression);
+    }
+    if (isPrefixUnaryExpression(node)) {
+        const inner = evaluationOf(node.operand);
+        return { yes: inner.no, no: inner.yes, nullish: false, throws: inner.throws };
+    }
+    const left = evaluationOf(core.left);
+    const operator = core.operatorToken.kind;
+    const runs = operator === SyntaxKind.AmpersandAmpersandToken
+        ? left.yes
+        : operator === SyntaxKind.BarBarToken
+            ? left.no
+            : left.nullish;
+    const right = runs ? evaluationOf(core.right) : UNEVALUATED;
+    return {
+        yes: (operator !== SyntaxKind.AmpersandAmpersandToken && left.yes) || right.yes,
+        no: (operator !== SyntaxKind.BarBarToken && left.no) || right.no,
+        nullish: (operator === SyntaxKind.AmpersandAmpersandToken && left.nullish) || right.nullish,
+        throws: left.throws || right.throws,
+    };
+}
+/** One expression below any parentheses and `!` around it. */
+function negationsRemoved(node) {
+    let at = node;
+    while (isParenthesizedExpression(at) ||
+        (isPrefixUnaryExpression(at) && at.operator === SyntaxKind.ExclamationToken)) {
+        at = isParenthesizedExpression(at) ? at.expression : at.operand;
+    }
+    return at;
+}
+/** The `&&`, `||` or `??` an expression is below any parentheses and `!`, if it is one. */
+function logicalCore(node) {
+    const core = negationsRemoved(node);
+    return isBinaryExpression(core) &&
+        [
+            SyntaxKind.AmpersandAmpersandToken,
+            SyntaxKind.BarBarToken,
+            SyntaxKind.QuestionQuestionToken,
+        ].includes(core.operatorToken.kind)
+        ? core
+        : undefined;
+}
+/**
+ * One backward transfer over statements, which dead stores and unreachable statements share:
+ * what a path from each statement's start reaches, given what one from its end reaches and
+ * where its jumps land. A write is a plain assignment of the judged local that an expression
+ * statement or a `for` head evaluates, or the bare name a `for…of` or `for…in` assigns; `live`
+ * holds what a path from each write reaches. A node the walk does not follow reaches every
+ * target inside it.
+ */
+function flowWalk(judged) {
+    const { inside: reads, writes, ends } = judged;
+    const live = new Map();
+    const record = (target, after) => {
+        live.set(target, (live.get(target) ?? NOTHING) | after);
+    };
+    const fixpoint = (step) => {
+        let head = NOTHING;
+        for (let next = step(head); next !== head; next = step(head)) {
+            head = next;
+        }
+        return head;
+    };
+    const sequence = (statements, after, to) => statements.reduceRight((out, statement) => flow(statement, out, to), after);
+    // A body run inline is a function's or a static block's: only `return` and a throw leave it,
+    // so it starts with no break, continue or label target.
+    const ran = (body, after, exit, raise) => sequence(body.statements, after, { exit, raise, escape: NOTHING, labels: new Map() });
+    // Every label of a chain such as `a: b: while` names the loop, so each one continues it.
+    const looped = (to, after, head, chain) => ({
+        ...to,
+        breaks: after,
+        continues: head,
+        labels: new Map([
+            ...to.labels,
+            ...chain.map((label) => [label, { breaks: after, continues: head }]),
+        ]),
     });
+    const when = (condition, reached) => (condition ? reached : NOTHING);
+    // Code that may throw reaches `raise`, where a throw lands, before it writes anything.
+    const thrown = (node, raise) => when(evaluationOf(node).throws, raise);
+    // A comma's operands run in turn, so a throw in the right one follows the left one's write.
+    // A store to the local, whose declaration has run, throws only where its value does.
+    const evaluated = (node, after, raise) => {
+        const expression = node === undefined ? undefined : parenthesesRemoved(node);
+        if (expression !== undefined &&
+            isBinaryExpression(expression) &&
+            expression.operatorToken.kind === SyntaxKind.CommaToken) {
+            return evaluated(expression.left, evaluated(expression.right, after, raise), raise);
+        }
+        const target = expression !== undefined &&
+            isBinaryExpression(expression) &&
+            expression.operatorToken.kind === SyntaxKind.EqualsToken
+            ? parenthesesRemoved(expression.left)
+            : undefined;
+        if (expression === undefined ||
+            !isBinaryExpression(expression) ||
+            target === undefined ||
+            !isIdentifier(target) ||
+            !writes.includes(target)) {
+            return reads(expression) | after | thrown(expression, raise);
+        }
+        record(target, after);
+        return reads(expression.right) | thrown(expression.right, raise);
+    };
+    // A statement may throw where it starts, before it writes anything, but entering a block
+    // runs nothing. A part a statement runs again, or after a write of its own, gets its own
+    // throw edge.
+    const flow = (node, after, to, chain = []) => judged.at(node) | transfer(node, after, to, chain) | when(!isBlock(node), to.raise);
+    const transfer = (node, after, to, chain) => {
+        if (isBlock(node)) {
+            return sequence(node.statements, after, to);
+        }
+        if (isExpressionStatement(node)) {
+            const [body] = runsInline(node);
+            const call = parenthesesRemoved(node.expression);
+            if (body !== undefined && isCallExpression(call)) {
+                // The arguments run first, then the body, whose `return` ends the call.
+                return call.arguments.reduce((out, argument) => out | reads(argument), ran(body, after, after, to.raise));
+            }
+            return evaluated(node.expression, ends.has(node) ? NOTHING : after, to.raise);
+        }
+        if (isClassDeclaration(node)) {
+            return runsInline(node).reduceRight((out, body) => ran(body, out, NOTHING, to.raise), after);
+        }
+        if (isIfStatement(node)) {
+            const then = flow(node.thenStatement, after, to);
+            const otherwise = node.elseStatement === undefined ? after : flow(node.elseStatement, after, to);
+            const way = evaluationOf(node.expression);
+            return reads(node.expression) | when(way.yes, then) | when(way.no, otherwise);
+        }
+        if (isLabeledStatement(node)) {
+            const labels = new Map([...to.labels, [node.label.text, { breaks: after }]]);
+            return flow(node.statement, after, { ...to, labels }, [...chain, node.label.text]);
+        }
+        if (isWithStatement(node)) {
+            return reads(node.expression) | flow(node.statement, after, to);
+        }
+        if (isWhileStatement(node) || isDoStatement(node)) {
+            const way = evaluationOf(node.expression);
+            const test = fixpoint((head) => {
+                const body = flow(node.statement, head, looped(to, after, head, chain));
+                return (reads(node.expression) |
+                    when(way.no, after) |
+                    when(way.yes, body) |
+                    thrown(node.expression, to.raise));
+            });
+            return isDoStatement(node)
+                ? flow(node.statement, test, looped(to, after, test, chain))
+                : test;
+        }
+        if (isForStatement(node)) {
+            const way = evaluationOf(node.condition);
+            const head = fixpoint((at) => {
+                const next = evaluated(node.incrementor, at, to.raise);
+                const body = flow(node.statement, next, looped(to, after, next, chain));
+                return (reads(node.condition) |
+                    when(way.no, after) |
+                    when(way.yes, body) |
+                    thrown(node.condition, to.raise));
+            });
+            return node.initializer !== undefined && isVariableDeclarationList(node.initializer)
+                ? reads(node.initializer) | head
+                : evaluated(node.initializer, head, to.raise);
+        }
+        if (isForOfStatement(node) || isForInStatement(node)) {
+            const target = parenthesesRemoved(node.initializer);
+            const assigned = isIdentifier(target) && writes.includes(target) ? target : undefined;
+            // The iterator runs on each pass through the head and may throw.
+            const head = fixpoint((at) => {
+                const body = flow(node.statement, at, looped(to, after, at, chain));
+                if (assigned === undefined) {
+                    return reads(node.initializer) | after | body | to.raise;
+                }
+                record(assigned, body);
+                return after | to.raise;
+            });
+            return reads(node.expression) | head;
+        }
+        if (isSwitchStatement(node)) {
+            const inside = { ...to, breaks: after };
+            let next = after;
+            let entered = NOTHING;
+            for (const clause of node.caseBlock.clauses.toReversed()) {
+                next = sequence(clause.statements, next, inside);
+                entered |= next | (isCaseClause(clause) ? reads(clause.expression) : NOTHING);
+            }
+            const total = node.caseBlock.clauses.some(isDefaultClause);
+            return reads(node.expression) | entered | when(!total, after);
+        }
+        if (isBreakStatement(node) || isContinueStatement(node)) {
+            const named = node.label === undefined ? undefined : to.labels.get(node.label.text);
+            const target = isBreakStatement(node)
+                ? node.label === undefined
+                    ? to.breaks
+                    : named?.breaks
+                : node.label === undefined
+                    ? to.continues
+                    : named?.continues;
+            return target ?? to.escape;
+        }
+        if (isReturnStatement(node)) {
+            return reads(node.expression) | to.exit;
+        }
+        if (isThrowStatement(node)) {
+            return reads(node.expression) | to.raise;
+        }
+        if (isTryStatement(node)) {
+            const final = node.finallyBlock;
+            // The finally block's entry depends only on what a path from where it continues
+            // reaches, so it is computed at most once for each answer.
+            const entries = new Map();
+            const through = (reached) => {
+                if (final === undefined) {
+                    return reached;
+                }
+                const known = entries.get(reached) ?? sequence(final.statements, reached, to);
+                entries.set(reached, known);
+                return known;
+            };
+            const map = (one) => ({
+                breaks: through(one.breaks),
+                ...(one.continues === undefined ? {} : { continues: through(one.continues) }),
+            });
+            const outer = {
+                exit: through(to.exit),
+                raise: through(to.raise),
+                escape: through(to.escape),
+                ...(to.breaks === undefined ? {} : { breaks: through(to.breaks) }),
+                ...(to.continues === undefined ? {} : { continues: through(to.continues) }),
+                labels: new Map([...to.labels].map(([name, one]) => [name, map(one)])),
+            };
+            const normal = through(after);
+            const handler = node.catchClause === undefined
+                ? undefined
+                : sequence(node.catchClause.block.statements, normal, outer);
+            // The binder's catch or finally sees the state before the try (`bindTryStatement`),
+            // so it is reached from the entry even where the block runs nothing.
+            const raise = handler ?? outer.raise;
+            return sequence(node.tryBlock.statements, normal, { ...outer, raise }) | raise;
+        }
+        return reads(node) | after;
+    };
+    return { sequence, record, live };
+}
+/**
+ * The writes to one local of its block that no read reaches, by `flowWalk` from the
+ * statement that declares it: a write is dead where no path from it reads the local before
+ * the next write or the end of its scope, and any node the walk does not follow that names
+ * the local reads it.
+ */
+function deadWrites(block, local, uses, escape, ends) {
+    const reads = (node) => node !== undefined && uses.some((use) => within(use, node)) ? READ : NOTHING;
+    const walk = flowWalk({ inside: reads, at: () => NOTHING, writes: uses, ends });
+    const statements = block.statements;
+    const declaration = statements[local.statement];
+    const outlives = local.outlives ? READ : NOTHING;
+    const after = walk.sequence(statements.slice(local.statement + 1), outlives, {
+        exit: escape ? READ : NOTHING,
+        raise: escape ? READ : NOTHING,
+        escape: outlives,
+        labels: new Map(),
+    });
+    // The rest of the declaring statement runs after the write: a later declarator may read the local.
+    if (local.initialized && declaration !== undefined && reads(declaration) === NOTHING) {
+        walk.record(local.name, after);
+    }
+    return [...walk.live]
+        .filter(([, read]) => read === NOTHING)
+        .map(([target]) => target)
+        .toSorted((a, b) => a.pos - b.pos);
+}
+/**
+ * The writes to the locals of one block that no read reaches. 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(block, locals, ids, ends) {
+    const found = [];
+    const scope = functionOf(block);
     for (const local of locals) {
         const own = local.hoisted ? block.statements[local.statement] : undefined;
         // A function's reads of itself keep it no more than its absence would.
@@ -972,89 +1945,36 @@ function deadStores(file, root, block, holder, locals, ids) {
             // 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)));
+            found.push(...targets.map((target) => ({ 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))) {
+        if (local.hoisted || uses.some((use) => inNestedFunction(use, block))) {
             continue;
         }
-        const statements = block.statements;
-        const usesIn = (statement) => uses.filter((use) => within(use, statement));
-        /** The plain assignment to the local a statement of the block is, where it is one. */
-        const writeOf = (statement) => {
-            if (!isExpressionStatement(statement)) {
-                return undefined;
-            }
-            const expression = parenthesesRemoved(statement.expression);
-            if (!isBinaryExpression(expression) ||
-                expression.operatorToken.kind !== SyntaxKind.EqualsToken) {
-                return undefined;
-            }
-            const target = parenthesesRemoved(expression.left);
-            return isIdentifier(target) && uses.includes(target)
-                ? { target, value: expression.right }
-                : undefined;
-        };
-        const writes = [];
-        if (local.initialized) {
-            writes.push({ at: local.statement, target: local.name });
-        }
-        statements.forEach((statement, at) => {
-            const write = writeOf(statement);
-            if (write !== undefined && at > local.statement) {
-                writes.push({ at, target: write.target });
-            }
-        });
-        for (const write of writes) {
-            // The rest of the write's own statement runs after it: a later declarator may read the local.
-            const own = statements[write.at];
-            const sameStatement = own !== undefined && write.target === local.name ? usesIn(own) : [];
-            if (sameStatement.length > 0) {
-                continue;
-            }
-            let dead = !local.outlives;
-            for (let at = write.at + 1; at < statements.length; at += 1) {
-                const statement = statements[at];
-                if (statement === undefined) {
-                    break;
-                }
-                const next = writeOf(statement);
-                if (next !== undefined) {
-                    dead = usesIn(next.value).length === 0;
-                    break;
-                }
-                const named = usesIn(statement);
-                if (named.length > 0) {
-                    dead = false;
-                    break;
-                }
-            }
-            if (dead) {
-                found.push(deadAt(local, write.target));
-            }
-        }
+        const escape = local.outlives && handledOutside(block, scope);
+        found.push(...deadWrites(block, local, uses, escape, ends).map((target) => ({ local, target })));
     }
     return found;
 }
 /**
  * The result of each function a discarded call reaches, where its type carries a value:
  * whether it is used is the call sites' to say, which the run decides over every project.
+ * `judged` holds every function whose result type the project was asked about.
  */
 function resultParts(project, root, sites, references, calls) {
     const discardedAt = new Set(references
         .filter((one) => (calls.get(positionKey(one.position)) ?? "used") !== "used")
         .map((one) => one.to));
     const found = [];
+    const judged = new Set();
     for (const { file, declared } of sites) {
         const { signature, node, id } = declared;
         const generator = signature.asteriskToken !== undefined;
         if (!discardedAt.has(id) || generator || !returnsAValue(signature)) {
             continue;
         }
+        judged.add(id);
         // A question the checker leaves unanswered withholds the finding.
         const typed = project.queries.signatureOf(signature);
         if (typed === undefined || !isAnswered(typed)) {
@@ -1072,33 +1992,39 @@ 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: CODE.unusedResult,
             declaration: id,
             kind: "result",
             name: "result",
             position: spanOf(file, root, at),
-            message: "result is discarded at every call site",
-            used: false,
             thenable: !isAnswered(members) || members.some((member) => member.name === "then"),
         });
     }
-    return found;
+    return { parts: found, judged };
 }
 /**
- * The parts of a run's projects merged: a part two projects hold is one part, in use
- * where either found it in use. A signature is free when no exemption record names its
- * declaration, its body is no stub, no class hierarchy fixes it, and every reference to
- * the declaration is a call or a specifier: any other reference uses the function as a
- * value, whose type then fixes the signature, and a reference a consumer makes is one
- * whose form this run does not read.
+ * The parts of a run's projects merged (matrix.6): a part stands only where every project
+ * that judges it finds it, a project judging the parts of each file it compiles and the
+ * result of each function it asked the checker about. A signature is free when no
+ * exemption record names it, its body is no stub, no class hierarchy fixes it, and every
+ * reference is a call or a specifier: any other uses the function as a value, and a
+ * consumer's reference has a form this run does not read.
  */
 export function intraFunctionFacts(projects, references, exempted) {
-    const parts = new Map();
-    for (const part of projects.flatMap((one) => one.parts)) {
-        const key = `${part.code}\u0000${positionKey(part.position)}`;
-        const known = parts.get(key);
-        parts.set(key, known === undefined ? part : { ...known, used: known.used || part.used });
+    const found = new Map();
+    for (const project of projects) {
+        for (const part of project.parts) {
+            const key = `${part.kind}\u0000${positionKey(part.position)}`;
+            const known = found.get(key) ?? { part, by: new Set() };
+            known.by.add(project);
+            found.set(key, known);
+        }
     }
+    const judges = (project, part) => part.kind === "result"
+        ? project.results.has(part.declaration)
+        : project.files.has(part.position.path);
+    const parts = [...found.values()]
+        .filter(({ part, by }) => projects.every((one) => by.has(one) || !judges(one, part)))
+        .map(({ part }) => part);
     const imports = new Map();
     for (const binding of projects.flatMap((one) => one.imports)) {
         const key = positionKey(binding.position);
@@ -1145,15 +2071,16 @@ export function intraFunctionFacts(projects, references, exempted) {
         .map((one) => one.declaration)
         .filter((id) => !fixed.has(id) && !exempted.has(id) && valued.has(id) && !constructors.has(id)));
     // Awaiting a thenable result sequences on it, so a call that awaits one uses it.
-    const sequenced = new Set([...parts.values()]
+    const sequenced = new Set(parts
         .filter((part) => part.thenable === true && awaited.has(part.declaration))
         .map((part) => part.declaration));
     const discardedEverywhere = new Set([...called]
         .filter(([id, all]) => all && !valued.has(id) && !sequenced.has(id))
         .map(([id]) => id));
     return {
-        parts: [...parts.values()],
+        parts,
         imports: [...imports.values()],
+        published: new Set(projects.flatMap((one) => [...one.published])),
         free,
         freeButValued,
         discardedEverywhere,