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

package/dist/src/fs/tree.js

@@ -0,0 +1,88 @@
+import { ancestors, joinPath, resolvePath } from "../paths.js";
+import { LANGUAGE_ROWS } from "../contract/contract.generated.js";
+import { LANGUAGE } from "../product.js";
+import { bytewise } from "../text/compare.js";
+import { globExpression } from "../text/glob.js";
+/** The directories no walk of the tree enters, by the patterns the language's row names. */
+const SKIPPED_DIRECTORIES = LANGUAGE_ROWS[LANGUAGE].skippedDirectories.map(globExpression);
+function skipped(name) {
+    return SKIPPED_DIRECTORIES.some((pattern) => pattern.test(name));
+}
+/** One file's text without its line ending, or undefined where it cannot be read. */
+function lineOf(host, path) {
+    try {
+        return host.readFile(path).replace(/\r?\n$/u, "");
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The repository whose working tree holds `dir`: the nearest directory at or above it with a
+ * `.git`. A `.git` file, which a linked worktree or a submodule holds, names the repository's
+ * directory on its `gitdir:` line; that directory's `commondir` file, where it has one, names
+ * the directory shared with the main worktree, which holds `info/exclude`:
+ * https://git-scm.com/docs/gitrepository-layout
+ */
+export function repositoryOf(host, dir) {
+    for (const root of ancestors(dir)) {
+        const dotGit = joinPath(root, ".git");
+        const kind = host.kindOf(dotGit);
+        if (kind === "directory") {
+            return { root, exclude: joinPath(dotGit, "info/exclude") };
+        }
+        if (kind === "file") {
+            const named = /^gitdir: (.+)$/u.exec(lineOf(host, dotGit) ?? "")?.[1];
+            const gitDir = named === undefined ? undefined : resolvePath(root, named);
+            const common = gitDir === undefined ? undefined : lineOf(host, joinPath(gitDir, "commondir"));
+            const shared = gitDir === undefined || common === undefined ? gitDir : resolvePath(gitDir, common);
+            return { root, exclude: shared === undefined ? undefined : joinPath(shared, "info/exclude") };
+        }
+    }
+    return undefined;
+}
+/** The entries of one directory, none where it cannot be read. */
+export function entriesOf(host, dir) {
+    try {
+        return host.readDirectory(dir);
+    }
+    catch {
+        return [];
+    }
+}
+/** The names of the files directly in `dir` whose name `accepts`, in bytewise order. */
+export function filesIn(host, dir, accepts) {
+    return entriesOf(host, dir)
+        .filter((entry) => !entry.directory && accepts(entry.name))
+        .map((entry) => entry.name)
+        .sort(bytewise);
+}
+/** The names of the directories directly in `dir` a walk enters, in bytewise order. */
+export function directoriesIn(host, dir) {
+    return entriesOf(host, dir)
+        .filter((entry) => entry.directory && !skipped(entry.name))
+        .map((entry) => entry.name)
+        .sort(bytewise);
+}
+/**
+ * Every file below `root` whose name `accepts`, by its path relative to `root` in bytewise
+ * order, read in no skipped directory.
+ */
+export function filesBelow(host, root, accepts) {
+    const found = [];
+    const pending = [""];
+    for (let dir = pending.pop(); dir !== undefined; dir = pending.pop()) {
+        for (const entry of entriesOf(host, joinPath(root, dir))) {
+            const path = dir === "" ? entry.name : `${dir}/${entry.name}`;
+            if (!entry.directory) {
+                if (accepts(entry.name)) {
+                    found.push(path);
+                }
+            }
+            else if (!skipped(entry.name)) {
+                pending.push(path);
+            }
+        }
+    }
+    return found.sort(bytewise);
+}

package/dist/src/generated-file.js

@@ -1,9 +1,10 @@
 /**
  * The generated-file class on TypeScript: every declaration in a file that marks itself
- * generated, or below a directory an applied convention row names as generated, is
- * retained, because a generator owns the file and a deletion there is undone at the next
+ * generated, below a directory an applied convention row names as generated, or minified,
+ * is retained, because a generator owns the file and a deletion there is undone at the next
  * generation.
  */
+import { minified } from "./javascript-file.js";
 /** The generated-code header, matched against each line of a leading comment. */
 const HEADER_LINE = /^\/\/ Code generated .* DO NOT EDIT\.$/u;
 /** The documentation tag `@generated` as a word of a comment. */
@@ -64,7 +65,7 @@ export function generatedByComment(text) {
 /**
  * Every own file of one project that is generated, by its path below the target root,
  * with the detail a retention in it names: its leading comments' mark, else the row
- * naming its directory as generated.
+ * naming its directory as generated, else its minified text.
  */
 export function generatedFilesOf(files, byRow) {
     const found = new Map();
@@ -72,7 +73,9 @@ export function generatedFilesOf(files, byRow) {
         const row = byRow.get(path);
         const detail = generatedByComment(file.text) ??
             (row === undefined
-                ? undefined
+                ? minified(file.fileName, file.text)
+                    ? "generated as a minified JavaScript file"
+                    : undefined
                 : `generated below a directory the convention row ${row} names`);
         if (detail !== undefined) {
             found.set(path, detail);

package/dist/src/git-ignore.js

@@ -1,10 +1,12 @@
 /**
- * Which files the `.gitignore` files of a tree ignore, read as git reads them:
+ * Which files git ignores below a tree's root, read as git reads its ignore files:
  * https://git-scm.com/docs/gitignore#_pattern_format
  */
-import { globExpression } from "./glob.js";
-import { dirnamePath, joinPath, relativePath } from "./paths.js";
-/** The rules one `.gitignore` text writes, in order. */
+import { ancestors, dirnamePath, joinPath, relativePath } from "./paths.js";
+import { message } from "./product.js";
+import { gitignoreExpression } from "./text/glob.js";
+import { repositoryOf } from "./fs/tree.js";
+/** The rules one ignore file's text writes, in order. */
 function rulesOf(text) {
     const rules = [];
     for (const raw of text.split(/\r?\n/u)) {
@@ -13,7 +15,7 @@ function rulesOf(text) {
             continue;
         }
         const negated = line.startsWith("!");
-        line = negated || line.startsWith("\\") ? line.slice(1) : line;
+        line = negated ? line.slice(1) : line;
         const directoryOnly = line.endsWith("/");
         line = line.replace(/\/+$/u, "");
         if (line === "") {
@@ -26,43 +28,54 @@ function rulesOf(text) {
         rules.push({
             negated,
             directoryOnly,
-            expression: globExpression(anchored ? pattern : `**/${pattern}`),
+            expression: gitignoreExpression(anchored ? pattern : `**/${pattern}`),
         });
     }
     return rules;
 }
+function rulesIn(host, path, unread) {
+    try {
+        return rulesOf(host.readFile(path));
+    }
+    catch (error) {
+        if (host.kindOf(path) !== "absent") {
+            unread(path, message(error));
+        }
+        return [];
+    }
+}
 /**
- * Whether the `.gitignore` files at and below `root` ignore one absolute path. A path
- * outside `root` is not ignored, and a file below an ignored directory stays ignored
- * whatever a later pattern says, as git cannot re-include it.
+ * Whether git ignores one absolute path below `root`: by the repository's `info/exclude`, then
+ * the `.gitignore` files from its root down to the path's directory, a later pattern overriding
+ * an earlier one, though a file below an ignored directory stays ignored, as git cannot re-include
+ * it. A path outside `root` is not ignored. With no repository, the files at and below `root` are
+ * read; with one, the directories above `root` give patterns but are not tested. An unreadable
+ * ignore file ignores nothing, and `unread` is told it.
  */
-export function gitIgnored(host, root) {
+export function gitIgnored(host, root, unread = () => undefined) {
+    const found = repositoryOf(host, root);
+    const repository = found?.root;
+    const above = repository === undefined ? [] : [...ancestors(dirnamePath(root), repository)].reverse();
+    const excluded = found?.exclude === undefined ? [] : rulesIn(host, found.exclude, unread);
     const read = new Map();
     const rulesAt = (dir) => {
         let rules = read.get(dir);
         if (rules === undefined) {
-            try {
-                rules = rulesOf(host.readFile(joinPath(dir, ".gitignore")));
-            }
-            catch {
-                rules = [];
-            }
+            rules = rulesIn(host, joinPath(dir, ".gitignore"), unread);
             read.set(dir, rules);
         }
         return rules;
     };
-    /** Whether the rules of `root` and of each directory down to one path's own decide it ignored. */
     const decided = (path, directory) => {
-        const dirs = [];
-        for (let at = dirnamePath(path); relativePath(root, at) !== undefined; at = dirnamePath(at)) {
-            dirs.unshift(at);
-        }
-        dirs.unshift(root);
+        const sources = [
+            ...(repository === undefined ? [] : [[repository, excluded]]),
+            ...[...above, ...[...ancestors(dirnamePath(path), root)].reverse()].map((dir) => [dir, rulesAt(dir)]),
+        ];
         let ignored = false;
-        for (const dir of dirs) {
-            const below = relativePath(dir, path);
-            for (const rule of below === undefined ? [] : rulesAt(dir)) {
-                if ((directory || !rule.directoryOnly) && rule.expression.test(below ?? "")) {
+        for (const [dir, rules] of sources) {
+            const below = relativePath(dir, path) ?? "";
+            for (const rule of rules) {
+                if ((directory || !rule.directoryOnly) && rule.expression.test(below)) {
                     ignored = !rule.negated;
                 }
             }

package/dist/src/graph.js

@@ -34,9 +34,9 @@ const SWEPT = {
  * Whether a root of each kind names a caller, which holds it live under both relations: a
  * tool reads what it loads and what its strings name, a runtime runs a test, setup or
  * worker file, a page's module script, a command, a script or a workflow step, the manifest
- * names what enters the package, an alias global stands for its export, and an entry file,
- * a configured root and a pattern assert a caller. A library's published API only supposes
- * an unseen consumer, so it is live under reachability alone.
+ * names what enters the package, an alias global stands for its export, an outside
+ * declaration names a global interface merging into it, and an entry file, a configured root
+ * and a pattern assert a caller. A published API supposes a consumer: reachability alone.
  */
 const NAMES_A_CALLER = {
     "entry-file": true,
@@ -49,8 +49,10 @@ const NAMES_A_CALLER = {
     pattern: true,
     "type-error": true,
     "type-query-alias": true,
+    "global-augmentation": true,
     "configuration-file": true,
     "configuration-string": true,
+    "bundler-entry": true,
     "test-runner": true,
     "browser-tests": true,
     worker: true,

package/dist/src/html-entries.js

@@ -5,9 +5,9 @@
  */
 import { isExportDeclaration, isImportDeclaration, isStringLiteral, } from "@typescript/native/ast";
 import { resolveRelativeSpecifier } from "./configuration-files.js";
-import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
-/** The directory no HTML file is read below. */
-const SKIPPED = "node_modules";
+import { ancestors, dirnamePath, joinPath, resolvePath } from "./paths.js";
+import { filesBelow } from "./fs/tree.js";
+import { holdsManifest } from "./fs/manifest.js";
 /** A `<script` start tag, its attribute text captured. */
 const SCRIPT_TAG = /<script(?=[\s>/])([^>]*)>/giu;
 /** The end tag an inline module script's content runs to. */
@@ -20,29 +20,6 @@ const ELSEWHERE = /^(?:\/\/|[A-Za-z][A-Za-z\d+.-]*:)/u;
 const CLASSIC_TYPES = new Set(["text/javascript", "application/javascript"]);
 /** The prefixes an inline script's specifier names a file of the target with. */
 const FILE_PREFIXES = ["/", "./", "../"];
-/** Every HTML file below `dir`, outside every `node_modules` directory, by absolute path. */
-function htmlFiles(host, dir) {
-    let entries;
-    try {
-        entries = host.readDirectory(dir);
-    }
-    catch {
-        return [];
-    }
-    const found = [];
-    for (const entry of entries) {
-        const path = joinPath(dir, entry.name);
-        if (entry.directory) {
-            if (entry.name !== SKIPPED) {
-                found.push(...htmlFiles(host, path));
-            }
-        }
-        else if (entry.name.endsWith(".html")) {
-            found.push(path);
-        }
-    }
-    return found.sort();
-}
 /** Each attribute of one start tag's attribute text, by its lowercase name. */
 function attributes(text) {
     const found = new Map();
@@ -98,12 +75,7 @@ function scriptValues(parse, path, text) {
 }
 /** The directory of the nearest `package.json` at or above `dir`, inside `root`, else `root`. */
 function manifestDirectory(host, root, dir) {
-    for (let at = dir; relativePath(root, at) !== undefined; at = dirnamePath(at)) {
-        if (host.kindOf(joinPath(at, "package.json")) === "file") {
-            return at;
-        }
-    }
-    return root;
+    return ancestors(dir, root).find((at) => holdsManifest(host, at)) ?? root;
 }
 /**
  * The own files the scripts of every HTML file below the target root load. A value
@@ -115,7 +87,8 @@ function manifestDirectory(host, root, dir) {
 export function htmlEntries(host, targetRoot, files, parse) {
     const root = resolvePath(host.workingDirectory(), targetRoot);
     const found = [];
-    for (const path of htmlFiles(host, root)) {
+    for (const below of filesBelow(host, root, (name) => name.endsWith(".html"))) {
+        const path = joinPath(root, below);
         let text;
         try {
             text = host.readFile(path);

package/dist/src/in-operands.js

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

package/dist/src/index.js

@@ -2,4 +2,4 @@ export { run, SETTING_OPTIONS } from "./run.js";
 export { DECLINED_CONVENTIONS } from "./entry-point-gaps.js";
 export { byPosition, positionKey, PositionError, renderPosition, } from "./position.js";
 export { computedComponent, isRef, nameComponent, REF_EXPRESSIONS, renderRef, } from "./ref.js";
-export { CONTRACT_VERSION } from "./version.js";
+export { CONTRACT_VERSION } from "./contract/contract.generated.js";

package/dist/src/injection-container.js

@@ -24,7 +24,7 @@ function isInjected(node) {
 /** The classes of the target a call whose callee an entry names passes, with that call's entry. */
 function registrations(input) {
     const { project, held } = input;
-    const resolved = resolveEntries(project, held, input.ts.injectionRegistrations);
+    const resolved = resolveEntries(project, held, input.ts.injection_registrations);
     if (!resolved.some(namesADeclaration)) {
         return [];
     }

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

@@ -4,6 +4,7 @@
  * 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 { exportsLocally, implicitReads, importBindings, } from "./import-bindings.js";
@@ -13,12 +14,7 @@ import { importRef } from "./ref.js";
 import { isAnswered, UNANSWERED } from "./query.js";
 import { signatureOf } from "./signatures.js";
 import { spellsNoBinding } from "./spelled-names.js";
-/** The codes of the parts this module reads. */
-export const UNUSED_PARAMETER = "DS1801";
-export const UNUSED_RESULT = "DS1803";
-const UNREACHABLE_STATEMENT = "DS1805";
-const DEAD_STORE = "DS1807";
-const UNREACHABLE_CASE = "DS1809";
+import { parenthesesRemoved } from "./unwrap.js";
 /** The result types that carry no value, as the checker spells them. */
 const NO_VALUE = new Set([
     "void",
@@ -34,17 +30,13 @@ function spanOf(file, root, node) {
     const endLine = file.getLineAndCharacterOfPosition(node.end).line + 1;
     return { ...start, endLine };
 }
-/** The parenthesized expression's content, through every pair of parentheses. */
-function unwrapped(node) {
-    return isParenthesizedExpression(node) ? unwrapped(node.expression) : node;
-}
 /** The node the parentheses around one expression sit in. */
 function outerParent(node) {
     return isParenthesizedExpression(node.parent) ? outerParent(node.parent) : node.parent;
 }
 /** The name a call is made through: the identifier, or the member a property access names. */
 function calleeName(call) {
-    const callee = unwrapped(call.expression);
+    const callee = parenthesesRemoved(call.expression);
     if (isIdentifier(callee)) {
         return callee;
     }
@@ -99,7 +91,7 @@ function unreachableExempt(statement) {
 }
 /** The value a case expression is a literal of, as a key two equal literals share, or none. */
 function caseKey(expression) {
-    const node = unwrapped(expression);
+    const node = parenthesesRemoved(expression);
     if (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node)) {
         return `s:${node.text}`;
     }
@@ -210,7 +202,7 @@ function extendedNames(files) {
                     named = isQualifiedName(type.typeName) ? type.typeName.right : type.typeName;
                 }
                 else {
-                    const expression = unwrapped(type.expression);
+                    const expression = parenthesesRemoved(type.expression);
                     named = isPropertyAccessExpression(expression) ? expression.name : expression;
                 }
                 if (isIdentifier(named)) {
@@ -254,7 +246,7 @@ function decoratorFixes(constructor) {
 }
 /** The name an expression spells a class by: an identifier, or the member a property access names. */
 function spelledName(expression) {
-    const node = unwrapped(expression);
+    const node = parenthesesRemoved(expression);
     if (isIdentifier(node)) {
         return node;
     }
@@ -447,8 +439,8 @@ export function projectParts(project, held, references, targetRoot) {
             if ((isImportClause(node) || isNamespaceImport(node)) && node.name !== undefined) {
                 specifiers.add(position(node.name));
             }
-            if (isExportAssignment(node) && isIdentifier(unwrapped(node.expression))) {
-                specifiers.add(position(unwrapped(node.expression)));
+            if (isExportAssignment(node) && isIdentifier(parenthesesRemoved(node.expression))) {
+                specifiers.add(position(parenthesesRemoved(node.expression)));
             }
             if (isSwitchStatement(node)) {
                 const holder = holderOf(node);
@@ -572,7 +564,7 @@ export function projectParts(project, held, references, targetRoot) {
         }
         walk.catches.forEach(({ name, holder }, at) => {
             parts.push({
-                code: DEAD_STORE,
+                code: CODE.deadStore,
                 declaration: holder,
                 kind: "store",
                 name: name.text,
@@ -584,7 +576,7 @@ export function projectParts(project, held, references, targetRoot) {
         for (const { names, uses, holder } of loopVariables) {
             for (const name of names) {
                 parts.push({
-                    code: DEAD_STORE,
+                    code: CODE.deadStore,
                     declaration: holder,
                     kind: "store",
                     name: name.text,
@@ -602,7 +594,7 @@ export function projectParts(project, held, references, targetRoot) {
         });
         for (const { statement, holder } of walk.unreachable) {
             parts.push({
-                code: UNREACHABLE_STATEMENT,
+                code: CODE.unreachableStatement,
                 declaration: holder,
                 kind: "statement",
                 name: "statement",
@@ -613,7 +605,7 @@ export function projectParts(project, held, references, targetRoot) {
         }
         for (const { clause, text, holder } of walk.cases) {
             parts.push({
-                code: UNREACHABLE_CASE,
+                code: CODE.unreachableCase,
                 declaration: holder,
                 kind: "case",
                 name: text,
@@ -772,10 +764,9 @@ function calleeSteers(project, signature, at) {
 }
 /**
  * The parts with each name of `contextual` judged where the compiler gives its function a
- * contextual type: the code handing the argument may act on what an object pattern reads,
- * so each such name is read, and an annotated parameter is marked with whether the call's
- * inference may read its annotation. A question the checker leaves unanswered keeps the
- * name read.
+ * contextual type: a name an object pattern binds is marked as one, and an annotated
+ * parameter with whether the call's inference may read its annotation. A question the
+ * checker leaves unanswered keeps the name read.
  */
 function withContextualRead(project, parts, contextual) {
     if (contextual.length === 0) {
@@ -791,15 +782,17 @@ function withContextualRead(project, parts, contextual) {
             continue;
         }
         const place = one.part.parameter;
-        judged.set(one.part, one.pattern || answer === UNANSWERED || place === undefined
+        judged.set(one.part, answer === UNANSWERED || place === undefined
             ? { ...one.part, used: true }
-            : {
-                ...one.part,
-                parameter: {
-                    ...place,
-                    annotated: calleeSteers(project, one.signature, one.at) ? "steers" : "free",
-                },
-            });
+            : one.pattern
+                ? { ...one.part, parameter: { ...place, contextualPattern: true } }
+                : {
+                    ...one.part,
+                    parameter: {
+                        ...place,
+                        annotated: calleeSteers(project, one.signature, one.at) ? "steers" : "free",
+                    },
+                });
     }
     return parts.map((part) => judged.get(part) ?? part);
 }
@@ -825,7 +818,7 @@ function parameterParts(file, root, declaration, signature, reader, ids, place)
             return;
         }
         const part = {
-            code: UNUSED_PARAMETER,
+            code: CODE.unusedParameter,
             declaration,
             kind: "parameter",
             name: name.text,
@@ -884,15 +877,28 @@ function functionOf(block) {
     }
 }
 /**
- * The locals one block declares with `let`, `const` or `var`, each with the names of the
- * block that spell it. A `var` of a nested block is one where no nested function of its
- * function names it, since the function scope holds it past the block's end.
+ * The locals one block declares with `let`, `const`, `var` or a function declaration
+ * inside a function, each with the names of the block that spell it. A `var` of a nested
+ * block is one where no nested function of its function names it, since the function scope
+ * holds it past the block's end.
  */
 function localsOf(block) {
     const declared = [];
     const scope = functionOf(block);
     const outlives = scope?.body !== block;
     block.statements.forEach((statement, at) => {
+        if (isFunctionDeclaration(statement)) {
+            if (scope !== undefined && statement.name !== undefined && statement.body !== undefined) {
+                declared.push({
+                    name: statement.name,
+                    statement: at,
+                    initialized: true,
+                    outlives: false,
+                    hoisted: true,
+                });
+            }
+            return;
+        }
         if (!isVariableStatement(statement)) {
             return;
         }
@@ -902,6 +908,11 @@ function localsOf(block) {
             return;
         }
         for (const declaration of list.declarations) {
+            // A write to a local typed `never` is the compiler's exhaustiveness check, which
+            // fails to compile once a case goes unhandled.
+            if (declaration.type?.kind === SyntaxKind.NeverKeyword) {
+                continue;
+            }
             for (const name of boundNames(declaration.name)) {
                 if (!blockScoped &&
                     outlives &&
@@ -913,6 +924,7 @@ function localsOf(block) {
                     statement: at,
                     initialized: declaration.initializer !== undefined,
                     outlives: !blockScoped && outlives,
+                    hoisted: false,
                 });
             }
         }
@@ -931,7 +943,7 @@ function isPlainWrite(use) {
     const parent = outerParent(use);
     return (isBinaryExpression(parent) &&
         parent.operatorToken.kind === SyntaxKind.EqualsToken &&
-        unwrapped(parent.left) === use);
+        parenthesesRemoved(parent.left) === use);
 }
 /**
  * The writes to the locals of one block that no read reaches. A write is a declaration's
@@ -944,7 +956,7 @@ function isPlainWrite(use) {
 function deadStores(file, root, block, holder, locals, ids) {
     const found = [];
     const deadAt = (local, target) => ({
-        code: DEAD_STORE,
+        code: CODE.deadStore,
         declaration: holder,
         kind: "store",
         name: local.name.text,
@@ -953,12 +965,20 @@ function deadStores(file, root, block, holder, locals, ids) {
         used: false,
     });
     for (const local of locals) {
-        const uses = local.uses.filter((use) => readsBinding(use, local.name, ids));
+        const own = local.hoisted ? block.statements[local.statement] : undefined;
+        // A function's reads of itself keep it no more than its absence would.
+        const uses = local.uses.filter((use) => readsBinding(use, local.name, ids) && (own === undefined || !within(use, own)));
         if (!local.outlives && uses.every(isPlainWrite)) {
-            const targets = [...(local.initialized ? [local.name] : []), ...uses];
+            // A declaration with no initializer writes `undefined`, the one store left to name.
+            const writes = [...(local.initialized ? [local.name] : []), ...uses];
+            const targets = writes.length === 0 ? [local.name] : writes;
             found.push(...targets.map((target) => deadAt(local, target)));
             continue;
         }
+        // A read anywhere in the block reads a function declaration, which is written first.
+        if (local.hoisted) {
+            continue;
+        }
         if (uses.some((use) => inNestedFunction(use, block))) {
             continue;
         }
@@ -969,12 +989,12 @@ function deadStores(file, root, block, holder, locals, ids) {
             if (!isExpressionStatement(statement)) {
                 return undefined;
             }
-            const expression = unwrapped(statement.expression);
+            const expression = parenthesesRemoved(statement.expression);
             if (!isBinaryExpression(expression) ||
                 expression.operatorToken.kind !== SyntaxKind.EqualsToken) {
                 return undefined;
             }
-            const target = unwrapped(expression.left);
+            const target = parenthesesRemoved(expression.left);
             return isIdentifier(target) && uses.includes(target)
                 ? { target, value: expression.right }
                 : undefined;
@@ -1052,7 +1072,7 @@ function resultParts(project, root, sites, references, calls) {
         const valued = project.queries.nonNullable(result);
         const members = isAnswered(valued) ? project.queries.propertiesOf(valued) : UNANSWERED;
         found.push({
-            code: UNUSED_RESULT,
+            code: CODE.unusedResult,
             declaration: id,
             kind: "result",
             name: "result",