@cplieger/deadset-ts 5.1.1 → 5.2.1

package/dist/src/findings/interfaces.js

@@ -26,7 +26,6 @@ function indexed(input) {
     return {
         symbolOf,
         inTest: (id) => union.test[union.at(id)] === true,
-        inSupport: (id) => union.support[union.at(id)] === true,
         candidateOf: (id) => candidates.get(id),
         implementationsOf: (id) => [...(input.implementations.classes.get(id) ?? [])]
             .map(symbolOf)
@@ -56,17 +55,14 @@ function findingOf(code, symbol, message, implementations) {
  * interface, whose members fall with it unreported; and `DS1203`, a method of a live
  * interface no reference names, unless it is a marker, a method whose every
  * implementation has an empty body. A test file's declaration is neither kind's
- * subject, because a production sweep counts none of the references it can have, and
- * neither is a test-support declaration test code references, which that code keeps live.
+ * subject, because a production sweep counts none of the references it can have.
  */
 export const interfaces = (input) => {
     const run = indexed(input);
     const found = [];
     for (const candidate of input.swept.sweep.candidates) {
         const symbol = run.symbolOf(candidate.id);
-        if (symbol === undefined ||
-            run.inTest(candidate.id) ||
-            (run.inSupport(candidate.id) && candidate.testRefs > 0)) {
+        if (symbol === undefined || run.inTest(candidate.id)) {
             continue;
         }
         if (symbol.kind === "interface") {

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

@@ -1,5 +1,6 @@
 import { KINDS } from "../kinds.js";
 import { UNUSED_PARAMETER, UNUSED_RESULT } from "../intra-function-parts.js";
+import { reachedWithTheTests } from "../sweep.js";
 /** A list of rules as a sentence names them. */
 function spelled(rules) {
     if (rules.length < 2) {
@@ -39,12 +40,23 @@ function reported(input, part, callersUnknown) {
 /**
  * The findings of the intra-function family, `DS1800` to `DS1899`, each about a part of
  * the declaration its reference names, at the part's own position, whatever the sweep
- * decided about that declaration. Each message names the other rules that report the
- * kind, as the vocabulary lists them, and so does the finding's details.
+ * decided about a production declaration. A part of test code is reported only where the
+ * run that counts test references reaches its declaration and that is no test of dead
+ * code. Each message and the finding's details name the other rules that report the kind.
  */
 export const intraFunction = (input) => {
     const union = input.swept.matrix.union;
     const byId = new Map(union.symbols.map((symbol) => [symbol.id, symbol]));
+    const reached = reachedWithTheTests(union, [
+        ...input.swept.exempt.map((record) => record.id),
+        ...input.swept.heldByUnanswered,
+    ]);
+    const testsOfDeadCode = new Set(input.swept.sweep.candidates.filter((one) => one.testOfDeadCode).map((one) => one.id));
+    const judged = (id) => {
+        const at = union.at(id);
+        const testCode = union.test[at] === true || union.support[at] === true;
+        return !testCode || (reached[at] === true && !testsOfDeadCode.has(id));
+    };
     const unknown = new Set(union.rooted.flatMap((root) => {
         const symbol = union.symbols[root.at];
         return symbol === undefined ? [] : [symbol.id];
@@ -68,7 +80,7 @@ export const intraFunction = (input) => {
     for (const part of input.intraFunction.parts) {
         const declaration = byId.get(part.declaration);
         const overlap = KINDS.get(part.code)?.overlap ?? [];
-        if (declaration === undefined || !reported(input, part, unknown)) {
+        if (declaration === undefined || !judged(declaration.id) || !reported(input, part, unknown)) {
             continue;
         }
         found.push({

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

@@ -40,9 +40,9 @@ const TEST_OF_DEAD_CODE = "every target symbol this test references is reported
 /**
  * The code one candidate is reported under, or none, each symbol once under the most
  * specific code: a test of dead code first; no other test-file declaration, member of a
- * dead container or enum member nothing names, nor a test-support declaration test code
- * references; then deprecation, a test reference, and the unreferenced codes, an
- * unimportable unused export being the unreachable kind's.
+ * dead container or enum member nothing names; a test-support declaration test code
+ * references as test-only use; then deprecation, a test reference, and the unreferenced
+ * codes, an unimportable unused export being the unreachable kind's.
  */
 function codeOf(judged) {
     const { candidate, symbol } = judged;
@@ -56,8 +56,8 @@ function codeOf(judged) {
     if (symbol.kind === "enum-member" && !referenced) {
         return undefined;
     }
-    if (judged.support && candidate.testRefs > 0) {
-        return undefined;
+    if (candidate.heldByTests === candidate.id) {
+        return "DS1004";
     }
     if (candidate.productionRefs === 0 && judged.deprecated) {
         return "DS1006";
@@ -180,7 +180,6 @@ function familyFindings(input, fallen) {
             candidate,
             symbol,
             test: union.test[at] === true,
-            support: union.support[at] === true,
             containerDead: containerDead && !fallen,
             deprecated: input.deprecated.has(symbol.id),
             unreachable: unreachable.has(symbol.id),

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

@@ -168,7 +168,8 @@ function unreachable(facts, at, symbol, candidate, input) {
  * The visibility-narrowing family over one run: `DS1101`, `DS1103` and `DS1104`. A finding
  * about a symbol a declared cross-language edge names is reported here like any other, and
  * the edge's evaluation then holds it pending, because the edge stands for a reference from
- * outside the file and the package whose use is decided in the other language.
+ * outside the file and the package whose use is decided in the other language. A
+ * declaration of a generated file is reported only where generated files are included.
  */
 export function narrowings(input) {
     const facts = factsOf(input.swept.matrix.union);
@@ -176,8 +177,12 @@ export function narrowings(input) {
     const closed = input.config.consumersComplete && declared.every((id) => loaded.includes(id));
     const world = { closed, writeOnly: writeOnlyDeclarations(input) };
     const candidates = new Map(input.swept.sweep.candidates.map((candidate) => [candidate.id, candidate]));
+    const generated = input.config.analysis.generatedFiles === "include" ? undefined : input.files.generated;
     const findings = [];
     facts.graph.symbols.forEach((symbol, at) => {
+        if (generated?.has(symbol.position.path) === true) {
+            return;
+        }
         const candidate = candidates.get(symbol.id);
         const found = candidate === undefined
             ? narrowing(facts, at, symbol, world)

package/dist/src/generated-file.js

@@ -1,8 +1,74 @@
 /**
- * The generated-file class on TypeScript: every declaration in a file below a directory
- * an applied convention row names as generated is retained, because the framework owns
- * the file and a deletion there is undone at the next generation.
+ * 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
+ * generation.
  */
+/** 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. */
+const GENERATED_TAG = /(?<![\w@$])@generated(?![\w$-])/u;
+/** The comments before a text's first token, a leading hashbang line skipped. */
+function leadingComments(text) {
+    const comments = [];
+    let at = text.startsWith("\uFEFF") ? 1 : 0;
+    if (text.startsWith("#!", at)) {
+        const end = text.indexOf("\n", at);
+        at = end === -1 ? text.length : end + 1;
+    }
+    for (;;) {
+        while (at < text.length && /\s/u.test(text.charAt(at))) {
+            at++;
+        }
+        if (text.startsWith("//", at)) {
+            const end = text.slice(at).search(/[\r\n\u2028\u2029]/u);
+            const stop = end === -1 ? text.length : at + end;
+            comments.push(text.slice(at, stop));
+            at = stop;
+        }
+        else if (text.startsWith("/*", at)) {
+            const end = text.indexOf("*/", at + 2);
+            if (end === -1) {
+                return comments;
+            }
+            comments.push(text.slice(at, end + 2));
+            at = end + 2;
+        }
+        else {
+            return comments;
+        }
+    }
+}
+/** The detail a file's leading comments mark it generated by, or undefined where they mark nothing. */
+export function generatedByComment(text) {
+    const comments = leadingComments(text);
+    if (comments.some((one) => one.split(/\r?\n/u).some((line) => HEADER_LINE.test(line)))) {
+        return "generated by the header line its leading comments hold";
+    }
+    if (comments.some((one) => GENERATED_TAG.test(one))) {
+        return "generated by the @generated tag its leading comments hold";
+    }
+    return undefined;
+}
+/**
+ * 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.
+ */
+export function generatedFilesOf(files, byRow) {
+    const found = new Map();
+    for (const [path, file] of files.byPath) {
+        const row = byRow.get(path);
+        const detail = generatedByComment(file.text) ??
+            (row === undefined
+                ? undefined
+                : `generated below a directory the convention row ${row} names`);
+        if (detail !== undefined) {
+            found.set(path, detail);
+        }
+    }
+    return found;
+}
 /** The generated-file detector, recording each file's first line. */
 export function generatedFile(input) {
     const generated = input.generated;
@@ -10,15 +76,9 @@ export function generatedFile(input) {
         return [];
     }
     return input.held.symbols.flatMap((symbol) => {
-        const row = generated.get(symbol.position.path);
-        return symbol.kind === "file" || row === undefined
+        const detail = generated.get(symbol.position.path);
+        return symbol.kind === "file" || detail === undefined
             ? []
-            : [
-                {
-                    id: symbol.id,
-                    detail: `generated below a directory the convention row ${row} names`,
-                    site: { path: symbol.position.path, line: 1, column: 1 },
-                },
-            ];
+            : [{ id: symbol.id, detail, site: { path: symbol.position.path, line: 1, column: 1 } }];
     });
 }

package/dist/src/graph.js

@@ -33,10 +33,10 @@ const SWEPT = {
 /**
  * Whether a root of each kind names a caller, which holds it live under both relations: a
  * tool reads the configuration it loads and the files its strings name, a runtime runs a
- * test file, a setup file, a worker, a command and a script, the manifest names what
- * enters the package, an alias global stands for the export it names, and an entry file,
- * a configured root and a pattern assert a caller. A library's published API only supposes
- * a consumer the run may not see, so it is live under reachability alone.
+ * test file, a setup file, a worker, a page's module script, a command and a script, the
+ * manifest names what enters the package, an alias global stands for the export it names,
+ * 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.
  */
 const NAMES_A_CALLER = {
     "entry-file": true,
@@ -55,6 +55,7 @@ const NAMES_A_CALLER = {
     "mutation-testing": true,
     "browser-tests": true,
     worker: true,
+    "html-entry": true,
 };
 /** Whether the sweep judges a declaration of one kind. */
 export function swept(kind) {

package/dist/src/html-entries.js

@@ -0,0 +1,137 @@
+/**
+ * The files the module scripts of the target's HTML files load. An HTML file is read as
+ * text and no markup is parsed, so a `<script>` inside a comment is read as well.
+ */
+import { isExportDeclaration, isImportDeclaration, isStringLiteral, } from "@typescript/native/unstable/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";
+/** 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. */
+const SCRIPT_END = /<\/script\s*>/iu;
+/** One attribute: a name, then a double-quoted, single-quoted or unquoted value. */
+const ATTRIBUTE = /([^\s"'=<>/]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/gu;
+/** A value that names a resource on another origin, or by another scheme. */
+const ELSEWHERE = /^(?:\/\/|[A-Za-z][A-Za-z\d+.-]*:)/u;
+/** 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();
+    for (const match of text.matchAll(ATTRIBUTE)) {
+        const [, name = "", double, single, bare] = match;
+        const key = name.toLowerCase();
+        if (!found.has(key)) {
+            found.set(key, double ?? single ?? bare ?? "");
+        }
+    }
+    return found;
+}
+/** The specifiers of the import and re-export declarations one inline script holds. */
+function specifiersOf(parse, fileName, content) {
+    return parse(fileName, content).statements.flatMap((statement) => {
+        const specifier = isImportDeclaration(statement) || isExportDeclaration(statement)
+            ? statement.moduleSpecifier
+            : undefined;
+        return specifier !== undefined && isStringLiteral(specifier) ? [specifier.text] : [];
+    });
+}
+/**
+ * Every value a module script of one HTML file names a file by: a `src` attribute's
+ * value, or each specifier an inline script imports or re-exports that starts with `/`,
+ * `./` or `../`.
+ */
+function scriptValues(parse, path, text) {
+    const values = [];
+    for (const match of text.matchAll(SCRIPT_TAG)) {
+        const held = attributes(match[1] ?? "");
+        if (held.get("type") !== "module") {
+            continue;
+        }
+        const src = held.get("src");
+        if (src !== undefined) {
+            values.push(src);
+            continue;
+        }
+        if (parse === undefined) {
+            continue;
+        }
+        const start = match.index + match[0].length;
+        const rest = text.slice(start);
+        const end = rest.search(SCRIPT_END);
+        const content = end === -1 ? rest : rest.slice(0, end);
+        values.push(...specifiersOf(parse, `${path}.${String(start)}.ts`, content).filter((specifier) => FILE_PREFIXES.some((prefix) => specifier.startsWith(prefix))));
+    }
+    return values;
+}
+/** 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;
+        }
+        if (at === root) {
+            break;
+        }
+    }
+    return root;
+}
+/**
+ * The own files the module scripts of every HTML file below the target root load. A value
+ * starting with a single `/` is read against the nearest manifest's directory, any other
+ * against the HTML file's own, and either resolves as a configuration file's relative
+ * specifier does. A value naming another origin or scheme, or no source file of the
+ * program, loads nothing here.
+ */
+export function htmlEntries(host, targetRoot, files, parse) {
+    const root = resolvePath(host.workingDirectory(), targetRoot);
+    const found = [];
+    for (const path of htmlFiles(host, root)) {
+        let text;
+        try {
+            text = host.readFile(path);
+        }
+        catch {
+            continue;
+        }
+        const dir = dirnamePath(path);
+        for (const value of scriptValues(parse, path, text)) {
+            if (ELSEWHERE.test(value)) {
+                continue;
+            }
+            const reached = value.startsWith("/")
+                ? resolveRelativeSpecifier(host, manifestDirectory(host, root, dir), `.${value}`)
+                : resolveRelativeSpecifier(host, dir, value);
+            const file = reached === undefined ? undefined : files.byName.get(reached);
+            if (file !== undefined) {
+                found.push({ file, source: value });
+            }
+        }
+    }
+    return found;
+}

package/dist/src/kinds.js

@@ -40,7 +40,7 @@ const ROWS = [
         code: "DS1004",
         name: "test-only-use",
         languages: ["go", "ts"],
-        rule: "A symbol with zero production references and at least one test reference: an unused-exported, unused-unexported or unused-member candidate whose test reference count is not zero, reported once under this code. A reference from a consumer's test files is a test reference unless the configuration counts consumer tests as production. A reference from test-support code, a package or file that only test code imports, is a test reference, and a declaration of test-support code is never reported under this code.",
+        rule: "A symbol with zero production references and at least one test reference: an unused-exported, unused-unexported or unused-member candidate whose test reference count is not zero, reported once under this code. A reference from a consumer's test files is a test reference unless the configuration counts consumer tests as production. A reference from test-support code, a package or file that only tests reach, is a test reference. A declaration of test-support code that test code references is reported under this code at the reachability class possible, as grammar/analysis.md states. Such a declaration that is an interface is reported under DS1201 instead.",
         defaultSeverity: "deny",
         maxClass: "certain",
         fixability: "deletable",
@@ -144,7 +144,7 @@ const ROWS = [
         code: "DS1301",
         name: "write-only-symbol",
         languages: ["go", "ts"],
-        rule: "A package-level or module-level variable, struct field, class member, type member or collection that production code writes and never reads. In production mode a read from a test file counts as no read. A comparison of struct values reads every field of the type: in Go, a value of a struct type used as an operand of `==` or `!=`, as a map key, or as a `switch` tag or `case` expression is a read of every field of that type, transitively through the fields of every struct type it holds, recorded at the comparison, because equality reads every field and a field that decides equality carries information. In TypeScript a comparison of two object references reads no member, because `===` compares identity and never a member. In TypeScript a property of an object literal writes the member of the same name that the literal's contextual type declares, whether or not the compiler checks the literal for excess properties. Where that contextual type is a union or an intersection, the property writes the member of that name on each constituent that declares one. So a literal that a declaration annotates, a function returns, a call passes or a `satisfies` expression checks writes the members of the type it is given. A store through the value a field or a member holds reads that field or member rather than writing it, because the store lands in storage every other holder of the value reads. In Go that store is an assignment, an increment, a compound assignment or a `delete` whose target is reached through a struct field holding a map, a slice or a pointer. Examples are `s.f[k] = v`, `s.f.x = v` and `delete(s.f, k)`. The same store through a field holding an array or a struct is a store into the field itself. TypeScript holds every object by reference, so an element or property store through a member's value reads the member. The finding names each write position, so the deletion set is visible. Deleting the subject and its writes also deletes every declaration whose only uses they hold. Such a declaration is a type parameter of the subject's declaring type that the subject's type alone names, or an import binding the writes alone use. The finding's message names each such declaration.",
+        rule: "A package-level or module-level variable, struct field, class member, type member or collection that production code writes and never reads. In production mode a read from a test file counts as no read. A write from a loaded consumer's code counts as a read, because the deletion the finding names would break a consumer the target does not own. A write in a consumer's test file counts as a read in the run that counts test references. It counts in a production sweep only where the configuration counts consumer tests as production. A comparison of struct values reads every field of the type: in Go, a value of a struct type used as an operand of `==` or `!=`, as a map key, or as a `switch` tag or `case` expression is a read of every field of that type, transitively through the fields of every struct type it holds, recorded at the comparison, because equality reads every field and a field that decides equality carries information. In Go a type argument the program instantiates a type parameter with, where the parameter's constraint is `comparable` or embeds it, is compared as an operand of `==` of that type is, recorded at the instantiation, so the struct values `slices.Equal`, `slices.Index` or `maps.Equal` compares have every field read. `reflect.DeepEqual` is not a comparison under this rule. In TypeScript a comparison of two object references reads no member, because `===` compares identity and never a member. In TypeScript a property of an object literal writes the member of the same name that the literal's contextual type declares, whether or not the compiler checks the literal for excess properties. Where that contextual type is a union or an intersection, the property writes the member of that name on each constituent that declares one. So a literal that a declaration annotates, a function returns, a call passes or a `satisfies` expression checks writes the members of the type it is given. A store through the value a field or a member holds reads that field or member rather than writing it, because the store lands in storage every other holder of the value reads. In Go that store is an assignment, an increment, a compound assignment or a `delete` whose target is reached through a struct field holding a map, a slice or a pointer. Examples are `s.f[k] = v`, `s.f.x = v` and `delete(s.f, k)`. The same store through a field holding an array or a struct is a store into the field itself. TypeScript holds every object by reference, so an element or property store through a member's value reads the member. The finding names each write position, so the deletion set is visible. Deleting the subject and its writes also deletes every declaration whose only uses they hold. Such a declaration is a type parameter of the subject's declaring type that the subject's type alone names, an import binding the writes alone use, or a declaration whose every use is in the type annotation of the subject or of another subject this rule reports, or in the writes those findings name. The finding's message names each such declaration, and no finding is reported about the declaration itself.",
         defaultSeverity: "deny",
         maxClass: "certain",
         fixability: "deletable",

package/dist/src/manifest.js

@@ -139,7 +139,11 @@ export function readManifest(host, targetRoot) {
         }
     }
     return {
-        entries: found.map((entry) => ({ ...entry, path: resolvePath(targetRoot, entry.path) })),
+        entries: found.map((entry) => ({
+            ...entry,
+            path: resolvePath(targetRoot, entry.path),
+            dir: targetRoot,
+        })),
         declaresExports: manifest["exports"] !== undefined,
     };
 }

package/dist/src/matrix.js

@@ -4,7 +4,7 @@
  * and intersected, with the dead components computed once over every configuration.
  */
 import { componentsOf } from "./components.js";
-import { graphOf } from "./graph.js";
+import { graphOf, OUTSIDE } from "./graph.js";
 import { byPosition } from "./position.js";
 import { sweep } from "./sweep.js";
 /** Two strings ordered bytewise. */
@@ -102,6 +102,7 @@ export function sweepMatrix(matrix, input) {
     const union = matrix.union;
     const dead = union.symbols.map(() => false);
     const testOfDeadCode = union.symbols.map(() => false);
+    const heldBy = union.symbols.map(() => undefined);
     const candidates = [];
     union.symbols.forEach((symbol, at) => {
         const held = matrix.heldIn[at] ?? [];
@@ -111,23 +112,28 @@ export function sweepMatrix(matrix, input) {
         }
         const all = found.filter((candidate) => candidate !== undefined);
         const admitted = all.every((candidate) => candidate.testOfDeadCode);
+        const testRefs = union.made[at]?.test ?? 0;
+        const heldByTests = heldBy[union.parent[at] ?? OUTSIDE] ??
+            (union.support[at] === true && testRefs > 0 && !admitted ? symbol.id : undefined);
         dead[at] = true;
         testOfDeadCode[at] = admitted;
+        heldBy[at] = heldByTests;
         candidates.push({
             id: symbol.id,
             productionRefs: union.made[at]?.production ?? 0,
-            testRefs: union.made[at]?.test ?? 0,
+            testRefs,
             relation: all.every((candidate) => candidate.relation === "reference-counting")
                 ? "reference-counting"
                 : "reachability",
             testOfDeadCode: admitted,
             configurations: held,
+            heldByTests,
         });
     });
     return {
         liveUnder: liveAnywhere(union.symbols, per),
         candidates,
-        components: componentsOf(union, dead, testOfDeadCode),
+        components: componentsOf(union, dead.map((one, at) => one && heldBy[at] === undefined), testOfDeadCode),
     };
 }
 /**

package/dist/src/namespace-objects.js

@@ -0,0 +1,158 @@
+/**
+ * Module namespace objects: the binding of a namespace import, the value an `await` of a
+ * dynamic `import()` produces, the first parameter of the first callback passed to `then`
+ * on one, and a `const` binding initialized with one of these. A use reads the exports it
+ * names and no other: a property access by name or by a literal index, or a destructured
+ * property, names one export, and any other use may read every export.
+ */
+import { isArrowFunction, isAwaitExpression, isBindingElement, isCallExpression, isElementAccessExpression, isExpressionStatement, isFunctionExpression, isIdentifier, isImportDeclaration, isNamespaceImport, isNoSubstitutionTemplateLiteral, isObjectBindingPattern, isParenthesizedExpression, isPropertyAccessExpression, isQualifiedName, isStringLiteral, isVariableDeclaration, isVariableDeclarationList, isVoidExpression, NodeFlags, SyntaxKind, } from "@typescript/native/unstable/ast";
+function isLiteralText(node) {
+    return isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node);
+}
+/** The outermost expression one node is, through the parentheses written around it. */
+function parenthesized(node) {
+    let at = node;
+    while (isParenthesizedExpression(at.parent)) {
+        at = at.parent;
+    }
+    return at;
+}
+/** Whether one call is a dynamic `import()` whose argument is literal text. */
+function isLiteralImport(node) {
+    if (!isCallExpression(node) || node.expression.kind !== SyntaxKind.ImportKeyword) {
+        return false;
+    }
+    const [argument] = node.arguments;
+    return argument !== undefined && isLiteralText(argument);
+}
+/** The node a `const` binding's name is visible below: the block or file its statement is in. */
+function scopeOf(declaration) {
+    const statement = declaration.parent.parent;
+    return statement.parent;
+}
+/** Every identifier below `scope` that spells `name`, other than `declared` and a member's name. */
+function occurrences(scope, name, declared) {
+    const found = [];
+    const visit = (node) => {
+        if (isIdentifier(node)) {
+            const parent = node.parent;
+            const member = (isPropertyAccessExpression(parent) && parent.name === node) ||
+                (isQualifiedName(parent) && parent.right === node) ||
+                (isBindingElement(parent) && parent.propertyName === node);
+            if (node !== declared && node.text === name && !member) {
+                found.push(node);
+            }
+            return;
+        }
+        node.forEachChild(visit);
+    };
+    scope.forEachChild(visit);
+    return found;
+}
+/**
+ * Every use of the namespace objects one file holds, keyed by the node the use is written
+ * at, that reads more than a name the checker resolves: an indexed read by a literal, and
+ * any use that may read every export. A shadowing declaration of a binding's name inside
+ * its scope is read as the binding, which can only keep an export live.
+ */
+export function namespaceUses(file) {
+    const uses = new Map();
+    const binding = (name, scope, specifier, seen) => {
+        if (seen.has(name)) {
+            return;
+        }
+        seen.add(name);
+        for (const one of occurrences(scope, name.text, name)) {
+            value(one, specifier, seen);
+        }
+    };
+    /** One use of a namespace object's value, at `node`. */
+    const value = (node, specifier, seen) => {
+        const at = parenthesized(node);
+        const parent = at.parent;
+        if (isExpressionStatement(parent) || isVoidExpression(parent)) {
+            return;
+        }
+        if ((isPropertyAccessExpression(parent) && parent.expression === at) ||
+            (isQualifiedName(parent) && parent.left === at)) {
+            return;
+        }
+        if (isElementAccessExpression(parent) && parent.expression === at) {
+            const index = parent.argumentExpression;
+            uses.set(node, isLiteralText(index) ? { kind: "indexed", literal: index } : { kind: "whole", specifier });
+            return;
+        }
+        if (isVariableDeclaration(parent) && parent.initializer === at) {
+            const pattern = parent.name;
+            if (isObjectBindingPattern(pattern)) {
+                const named = pattern.elements.every((element) => element.dotDotDotToken === undefined &&
+                    element.propertyName?.kind !== SyntaxKind.ComputedPropertyName);
+                if (!named) {
+                    uses.set(node, { kind: "whole", specifier });
+                }
+                return;
+            }
+            const list = parent.parent;
+            if (isIdentifier(pattern) &&
+                isVariableDeclarationList(list) &&
+                (list.flags & NodeFlags.Const) !== 0) {
+                binding(pattern, scopeOf(parent), specifier, seen);
+                return;
+            }
+        }
+        uses.set(node, { kind: "whole", specifier });
+    };
+    /** One use of a dynamic `import()` call, at `call`. */
+    const imported = (call, specifier, seen) => {
+        const at = parenthesized(call);
+        const parent = at.parent;
+        if (isExpressionStatement(parent) || isVoidExpression(parent)) {
+            return;
+        }
+        if (isAwaitExpression(parent)) {
+            value(parent, specifier, seen);
+            return;
+        }
+        const then = parent.parent;
+        if (isPropertyAccessExpression(parent) &&
+            parent.expression === at &&
+            parent.name.text === "then" &&
+            isCallExpression(then) &&
+            then.expression === parent) {
+            const [callback] = then.arguments;
+            if (callback !== undefined && (isArrowFunction(callback) || isFunctionExpression(callback))) {
+                const [first] = callback.parameters;
+                if (first === undefined || isObjectBindingPattern(first.name)) {
+                    return;
+                }
+                if (isIdentifier(first.name)) {
+                    binding(first.name, callback, specifier, seen);
+                    return;
+                }
+            }
+        }
+        uses.set(call, { kind: "whole", specifier });
+    };
+    const visit = (node) => {
+        if (isImportDeclaration(node)) {
+            const clause = node.importClause;
+            const bindings = clause?.namedBindings;
+            if (clause !== undefined &&
+                clause.phaseModifier !== SyntaxKind.TypeKeyword &&
+                bindings !== undefined &&
+                isNamespaceImport(bindings)) {
+                binding(bindings.name, file, node.moduleSpecifier, new Set());
+            }
+            return;
+        }
+        if (isLiteralImport(node) && isCallExpression(node)) {
+            const [argument] = node.arguments;
+            if (argument !== undefined) {
+                imported(node, argument, new Set());
+            }
+        }
+        node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+    return uses;
+}

package/dist/src/partial.js

@@ -19,7 +19,7 @@ export function partialNotes(partial) {
             byProject.set(configFile, (byProject.get(configFile) ?? 0) + 1);
         }
         const where = [...byProject].map(([configFile, n]) => `${configFile}: ${String(n)}`).join(", ");
-        notes.push(`the checker answered ${counted(partial.unanswered.length, "question", "questions")} with a failure (${where}); every declaration an answer could have kept live is kept live and reported by nothing`);
+        notes.push(`the checker answered ${counted(partial.unanswered.length, "question", "questions")} with a failure (${where}), so every declaration an answer could have kept live is kept live and reported by nothing`);
     }
     return notes;
 }