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

package/dist/src/kinds.js

@@ -43,7 +43,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 tests reach and that carries test evidence of its own language, is a test reference. A declaration of test-support code is test code and is no subject of this code, as grammar/analysis.md states. An interface method whose only calls and selections through the interface are in test code, and that DS1203's precondition does not exempt, is reported under this code. The methods implementing it are not reported with it, because the test reaches them through it.",
+        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 and that carries test evidence of its own language, is a test reference. A declaration of test-support code is test code and is no subject of this code, as grammar/analysis.md states. An interface method whose only calls and selections through the interface are in test code, and that DS1203's precondition does not exempt, is reported under this code. The methods implementing it are not reported with it, because the test reaches them through it. A candidate found dead under reachability, every production reference to which is made by a declaration itself dead, is reported under this code as well where test code that is no test of dead code, and that the run counting test references reaches, references it, because that test keeps it, and the finding's message names both kinds of reference.",
         defaultSeverity: "deny",
         maxClass: "certain",
         fixability: "deletable",
@@ -54,7 +54,7 @@ const ROWS = [
         code: "DS1005",
         name: "test-of-dead-code",
         languages: ["go", "ts"],
-        rule: "A test symbol whose set of referenced target symbols is non-empty and every member of that set is reported dead. In TypeScript an ambient declaration, one a declaration file holds or one a `declare` modifier carries or a declaration carrying one holds, describes code the target does not implement, so it is no target symbol of that set. A test that references at least one live target symbol is never reported, no notion of a test's subject and no name matching enters the rule, and the message states the rule. The test joins the dead component of the symbols it references, and it and each of them count as referencing each other, so the test is a member of their cycle and never a dead symbol outside it.",
+        rule: "A test symbol whose set of referenced target symbols is non-empty and every member of that set is reported dead. In TypeScript an ambient declaration, one a declaration file holds or one a `declare` modifier carries or a declaration carrying one holds, describes code the target does not implement, so it is no target symbol of that set. A test that references at least one live target symbol is never reported, no notion of a test's subject and no name matching enters the rule, and the message states the rule. A production declaration whose reachability class is `possible` because programs outside the analysis may use it, being published API of a library whose run declares no consumer, and in Go a declaration of a package no build links or an export of a unit a dropped module requires, counts as a live target symbol of every test that references it, so such a test is no test of dead code. The declaration is still reported at `possible`. The test joins the dead component of the symbols it references, and it and each of them count as referencing each other, so the test is a member of their cycle and never a dead symbol outside it.",
         defaultSeverity: "deny",
         maxClass: "certain",
         fixability: "deletable",
@@ -110,7 +110,7 @@ const ROWS = [
         name: "redundant-export-keyword",
         languages: ["ts"],
         rule: "An exported declaration used only inside its own file, reported as a candidate for removing the export keyword. The finding names the narrower visibility the references support.",
-        precondition: 'Closed world only. Reported in a file that is not an entry file, a file only a configuration string or a script token names being none, because each runs the file and reads no name it exports, and a test file being one only for the exports its test runner calls, as grammar/analysis.md "Test code" states, and that either belongs to a project whose consumer set the configuration declares complete or is reached by no manifest export. A declared cross-language edge counts as a reference from outside the file. Where the edge\'s other side is unknown to the analyzer, the finding is emitted pending. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first.',
+        precondition: 'Closed world only. Reported in a file that is not an entry file, a file only a configuration string or a script token names being none, because each runs the file and reads no name it exports, while a file a build script\'s bundler call names is one, because the bundle exposes what it exports, and a test file being one only for the exports its test runner calls, as grammar/analysis.md "Test code" states, and a file a Markdown or MDX document imports one only for the exports the import reads, as grammar/analysis.md "Markdown and MDX documents" states, and that either belongs to a project whose consumer set the configuration declares complete or is reached by no manifest export. A declared cross-language edge counts as a reference from outside the file. Where the edge\'s other side is unknown to the analyzer, the finding is emitted pending. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first.',
         defaultSeverity: "warn",
         maxClass: "certain",
         fixability: "narrowable",
@@ -174,8 +174,8 @@ const ROWS = [
         code: "DS1303",
         name: "unused-type-parameter",
         languages: ["go", "ts"],
-        rule: "A type parameter of a function or method that no part of the declaration's signature and no part of the declaration's body names, at the certain class. The deletion is local to the declaration and the explicit instantiations the reference set already lists. A type parameter of a function or method that is itself dead falls with it and is reported under no code of its own.",
-        precondition: "Function and method type parameters only. A type parameter of a type declaration is never reported, because a phantom type parameter such as `type ID[T any] int` makes two instantiations distinct types while naming the parameter nowhere, so deleting it changes the program. A method signature an interface or an object type declares belongs to that type declaration, so its type parameters are never reported either.",
+        rule: "A type parameter of a function, a method or a TypeScript type alias that no part of the declaration's signature, body or aliased type names, at the certain class. The deletion is local to the declaration and the explicit instantiations the reference set already lists. A type parameter of a declaration that is itself dead falls with it and is reported under no code of its own.",
+        precondition: "Function and method type parameters, and in TypeScript those of a type alias. A TypeScript alias names no type of its own, so two instantiations that differ only in a parameter its type never names are one type. A Go type declaration's type parameter is never reported, because a phantom type parameter such as `type ID[T any] int` makes two instantiations distinct types while naming the parameter nowhere, so deleting it changes the program. Nor is one of a TypeScript class or interface, which merges only with declarations of the same type parameters. A method signature an interface or an object type declares belongs to that type declaration, so its type parameters are never reported either.",
         defaultSeverity: "deny",
         maxClass: "certain",
         fixability: "deletable",
@@ -289,7 +289,7 @@ const ROWS = [
         name: "unused-parameter",
         languages: ["go", "ts"],
         rule: "A parameter with no reference inside its function body, on a function whose signature is free to change.",
-        precondition: "The signature must be free, defined as follows: the function is not a method retained by interface satisfaction, is not a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, is not used as a value, is not a go:linkname or cgo target, is not a go-fuzz entry point, is not a function the Go test driver runs (a test, benchmark or fuzz test of a test file, or TestMain), and is not a stub whose body is empty or only panics. A function literal or function expression that initializes a variable the program only calls, never passing, storing, returning or assigning it, is called by name and is not used as a value. In Go a function literal that is the callee of the call it is written in, the call of a `go` or a `defer` statement included, is not used as a value, wherever the literal is written. A parameter its body never names is dead whatever the callers, so a published declaration of a library is reported too, with the fixability the vocabulary gives the kind: the signature change is a breaking change. In TypeScript a caller may pass a function used as a value more arguments than it declares parameters, so in such a function whose signature is free but for that use, a parameter its body never reads is reported for deletion when its body reads no parameter after it, and an unread parameter before the last read one is reported for a rename to its name with a leading underscore, which keeps every argument in place and which the compilers' unused-parameter rules read as declared unread, unless its name already starts with one. A parameter of a TypeScript function expression or arrow function that the compiler gives a contextual type, and that carries a type annotation, is not reported for deletion where the inference of the call holding the function may read the annotation, being where the callee is generic and its parameter type at the function's place names a type parameter at the parameter's place, or where the function is written inside an object literal such a call is passed, and it is reported for deletion at `probable` where it carries an annotation no such inference reads, because nothing in the program shows that an outside reader ignores it. Such a parameter is not reported when it is an object binding pattern, because the pattern reads each property it names from the argument and the code that hands the argument may act on that read. No name such a pattern binds is reported either. Any other TypeScript parameter that is a binding pattern is judged by the names it binds: each name the body never reads is reported wherever the pattern stands, because removing it from the pattern moves no argument, except a name beside a rest element of the same object pattern, whose removal changes what that element holds, and the pattern counts as a read parameter when the body reads any name it binds. A rest parameter is judged as the last parameter. A TypeScript `this` parameter declares the type of `this` and receives no argument, so it is never reported. A TypeScript constructor is used as a value where its class is used as a value other than as the callee of a `new` expression or the class an `extends` clause names, and its signature is not free where its class carries a decorator or a parameter of the constructor carries one, because the code that decorator or a container runs may construct the class. A parameter property is read by the write to its member the constructor makes, so it is never reported under this kind, and its member is judged under DS1301. A TypeScript name a parameter binds, whole or through a binding pattern, that starts with an underscore is never reported, because a leading underscore is the spelling unused-parameter rules read as declared unread, and no other name exempts a parameter. A Go parameter named by the blank identifier declares no name a body could read and is never reported.",
+        precondition: "The signature must be free, defined as follows: the function is not a method retained by interface satisfaction, is not a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, is not used as a value, is not a go:linkname or cgo target, is not a go-fuzz entry point, is not a function the Go test driver runs (a test, benchmark or fuzz test of a test file, or TestMain), and is not a stub whose body is empty or only panics. A function literal or function expression that initializes a variable the program only calls, never passing, storing, returning or assigning it, is called by name and is not used as a value. In Go a function literal that is the callee of the call it is written in, the call of a `go` or a `defer` statement included, is not used as a value, wherever the literal is written. A parameter its body never names is dead whatever the callers, so a published declaration of a library is reported too, with the fixability the vocabulary gives the kind: the signature change is a breaking change. In TypeScript a caller may pass a function used as a value more arguments than it declares parameters, so in such a function whose signature is free but for that use, a parameter its body never reads is reported for deletion when its body reads no parameter after it, and an unread parameter before the last read one is reported for a rename to its name with a leading underscore, which keeps every argument in place and which the compilers' unused-parameter rules read as declared unread, unless its name already starts with one. A parameter of a TypeScript function expression or arrow function that the compiler gives a contextual type, and that carries a type annotation, is not reported for deletion where the inference of the call holding the function may read the annotation, being where the callee is generic and its parameter type at the function's place names a type parameter at the parameter's place, or where the function is written inside an object literal such a call is passed, and it is reported for deletion at `probable` where it carries an annotation no such inference reads, because nothing in the program shows that an outside reader ignores it. A name an object binding pattern of a parameter of such a function binds, annotated or not, that the body never reads is reported for deletion at `probable`, because the pattern reads the property it names from the argument and the code that hands the argument may act on that read, which nothing in the program shows. Any other TypeScript parameter that is a binding pattern is judged by the names it binds: each name the body never reads is reported wherever the pattern stands, because removing it from the pattern moves no argument, except a name beside a rest element of the same object pattern, whose removal changes what that element holds, and the pattern counts as a read parameter when the body reads any name it binds. A rest parameter is judged as the last parameter. A TypeScript `this` parameter declares the type of `this` and receives no argument, so it is never reported. A TypeScript constructor is used as a value where its class is used as a value other than as the callee of a `new` expression or the class an `extends` clause names, and its signature is not free where its class carries a decorator or a parameter of the constructor carries one, because the code that decorator or a container runs may construct the class. A parameter property is read by the write to its member the constructor makes, so it is never reported under this kind, and its member is judged under DS1301. A TypeScript name a parameter binds, whole or through a binding pattern, that starts with an underscore is never reported, because a leading underscore is the spelling unused-parameter rules read as declared unread, and no other name exempts a parameter. A Go parameter named by the blank identifier declares no name a body could read and is never reported.",
         defaultSeverity: "warn",
         maxClass: "certain",
         fixability: "manual",
@@ -313,7 +313,7 @@ const ROWS = [
         name: "unused-result",
         languages: ["go", "ts"],
         rule: "A result value that no call site of the function uses, on a function whose signature is free to change.",
-        precondition: "The same free-signature rule as unused-parameter, plus a closed-world condition: every call site of the function must be in the loaded graph, because an unknown caller may consume the result, so the kind reports only for a function whose callers are all visible. A call that is the operand of an await expression written as a statement of its own uses a result whose type has a member named then, a promise or another thenable, because the caller sequences on it, and discards any other result. A call written as a statement of its own, or as the operand of void, discards its result whatever its type.",
+        precondition: "The same free-signature rule as unused-parameter, plus a closed-world condition: every call site of the function must be in the loaded graph, because an unknown caller may consume the result, so the kind reports only for a function whose callers are all visible. A function a program run by naming the file names, a file under the `ignore` tag or a script of a dropped module, has call sites outside the loaded graph. A call that is the operand of an await expression written as a statement of its own uses a result whose type has a member named then, a promise or another thenable, because the caller sequences on it, and discards any other result. A call written as a statement of its own, or as the operand of void, discards its result whatever its type.",
         defaultSeverity: "warn",
         maxClass: "certain",
         fixability: "manual",
@@ -336,7 +336,7 @@ const ROWS = [
         name: "dead-store",
         languages: ["go", "ts"],
         rule: "A write to a local variable with no read before the next write to it or the end of its scope, computed on the same read-and-write classification the write-only-symbol kind uses. The finding names the write position.",
-        precondition: "In TypeScript the binding of a catch clause is a local variable the clause writes when it catches, so a binding that is a name and that the clause's block never reads is a dead store, positioned at the binding: the clause written with no binding behaves the same. A TypeScript local is a name a `let` or `const` declaration of a block binds, or a `var` declaration of a block of a function, a name an object or array binding pattern of one binds at any depth included, except a name with a default, whose removal skips the default's evaluation, and a name beside a rest element of its object pattern, whose removal changes what the rest holds. A `var` of a block nested in its function's body is judged in that block, its last write kept because the function scope reads on past the block's end, and is no subject where a nested function of its function names it. A local a nested function reads is no subject, because the function may read it at any time, and every write to a local nothing reads is dead, one a nested function makes included, each positioned at the name it writes. The variable a `let` or `const` declaration of a `for…of` or `for…in` statement binds is written at each iteration, so one the loop body never reads is a dead store positioned at the binding, except a name that starts with an underscore, because a loop must bind a name and that spelling declares it unread. In Go a function literal a package-level variable's initializer holds is a function body of its own, and a finding about one of its stores carries the reference of the variable the literal initializes, which for a blank variable is its package's, as `grammar/symbol-ref.md` states for a blank-identifier declaration. In Go a range statement stores its key and its value at the start of every iteration, and an empty range stores neither. In Go a function literal reads each variable it names where it is written, and a store that a literal naming its variable may precede on some path of the control-flow graph, the literal of an earlier iteration of a loop included, is not dead, because a call of the literal the graph does not order may read it. A store no such literal precedes is judged as any other. A literal that is the callee of the call it is written in, outside a `go` or `defer` statement, runs there, so it reads its variables at that call and precedes no later store.",
+        precondition: "In TypeScript the binding of a catch clause is a local variable the clause writes when it catches, so a binding that is a name and that the clause's block never reads is a dead store, positioned at the binding: the clause written with no binding behaves the same. A TypeScript local is a name a `let` or `const` declaration of a block binds, or a `var` declaration of a block of a function, a name an object or array binding pattern of one binds at any depth included, except a name with a default, whose removal skips the default's evaluation, and a name beside a rest element of its object pattern, whose removal changes what the rest holds. A function declaration of a block of a function is a TypeScript local too, written with its function when the block starts, wherever it stands in the block, so one that nothing outside its own body reads is a dead store positioned at its name, and a read anywhere else in the block reads it. A `let` or `var` declaration with no initializer writes `undefined`, so one that nothing reads and nothing writes is a dead store positioned at its name. A local whose declaration carries the type annotation `never` is no subject: a write to it is the compiler's exhaustiveness check, which fails to compile once a case goes unhandled, so deleting it changes what the program checks. A `var` of a block nested in its function's body is judged in that block, its last write kept because the function scope reads on past the block's end, and is no subject where a nested function of its function names it. A local a nested function reads is no subject, because the function may read it at any time, and every write to a local nothing reads is dead, one a nested function makes included, each positioned at the name it writes. The variable a `let` or `const` declaration of a `for…of` or `for…in` statement binds is written at each iteration, so one the loop body never reads is a dead store positioned at the binding, except a name that starts with an underscore, because a loop must bind a name and that spelling declares it unread. In Go a function literal a package-level variable's initializer holds is a function body of its own, and a finding about one of its stores carries the reference of the variable the literal initializes, which for a blank variable is its package's, as `grammar/symbol-ref.md` states for a blank-identifier declaration. In Go a range statement stores its key and its value at the start of every iteration, and an empty range stores neither. In Go a function literal reads each variable it names where it is written, and a store that a literal naming its variable may precede on some path of the control-flow graph, the literal of an earlier iteration of a loop included, is not dead, because a call of the literal the graph does not order may read it. A store no such literal precedes is judged as any other. A literal that is the callee of the call it is written in, outside a `go` or `defer` statement, runs there, so it reads its variables at that call and precedes no later store.",
         defaultSeverity: "deny",
         maxClass: "certain",
         fixability: "deletable",

package/dist/src/manifest.js

@@ -110,6 +110,24 @@ export function readManifest(host, targetRoot) {
             found.push({ member, path: value, role: "import", published: true });
         }
     }
+    // A `browser` string replaces `main` in a browser bundle, and an object replaces each
+    // module it maps with the file it names: https://github.com/defunctzombie/package-browser-field-spec
+    const browser = manifest["browser"];
+    if (typeof browser === "string" && isTarget(browser, false)) {
+        found.push({ member: "browser", path: browser, role: "import", published: true });
+    }
+    else if (isRecord(browser)) {
+        for (const [replaced, value] of Object.entries(browser)) {
+            if (typeof value === "string" && isTarget(value, true)) {
+                found.push({
+                    member: below("browser", replaced),
+                    path: value,
+                    role: "import",
+                    published: true,
+                });
+            }
+        }
+    }
     const bin = manifest["bin"];
     if (typeof bin === "string" && isTarget(bin, false)) {
         found.push({ member: "bin", path: bin, role: "run", published: false });

package/dist/src/matrix.js

@@ -70,11 +70,13 @@ export function matrixOf(per) {
         }
     });
     symbols.sort((a, b) => byPosition(a.position, b.position));
+    const testUsed = new Set(per.flatMap((one) => one.testUsedFiles ?? []));
     return {
         configurations: per.map((one) => one.configuration),
         graphs: per.map((one) => graphOf(one.symbols, one.references, one.roots, one.testFiles, one.supportFiles, one.ambient)),
         union: graphOf(symbols, references, per.flatMap((one) => one.roots), [...new Set(per.flatMap((one) => one.testFiles))], [...new Set(per.flatMap((one) => one.supportFiles ?? []))], new Set(per.flatMap((one) => [...(one.ambient ?? [])]))),
         heldIn: symbols.map((symbol) => holders.get(symbol.id) ?? []),
+        testUsed: symbols.map((symbol) => testUsed.has(symbol.position.path)),
         dependents,
     };
 }
@@ -101,18 +103,24 @@ export function sweepMatrix(matrix, input) {
     ]));
     const union = matrix.union;
     const heldBy = union.symbols.map(() => undefined);
-    const testReached = reachedWithTheTests(union, [
+    const held = [
         ...input.marked,
         ...(input.exempt ?? []).map((record) => record.id),
         ...(input.unanswered ?? []),
-    ]);
-    const judged = union.symbols.map((symbol, at) => {
+    ];
+    const testReached = reachedWithTheTests(union, held);
+    // A test uses what it names: a file a test reads through a star re-export or a
+    // namespace keeps the exports nothing names at their own class.
+    const testNamed = reachedWithTheTests(union, held, false);
+    const everywhere = union.symbols.map((symbol, at) => {
         const held = matrix.heldIn[at] ?? [];
         const found = held.map((configuration) => byConfiguration.get(configuration)?.get(symbol.id));
         return held.length === 0 || found.some((candidate) => candidate === undefined)
             ? undefined
             : found.filter((candidate) => candidate !== undefined);
     });
+    const compiled = compiledReferences(matrix, new Set(union.symbols.flatMap((symbol, at) => (everywhere[at] === undefined ? [] : [symbol.id]))), input.mode);
+    const judged = everywhere.map((found, at) => compiled.has(union.symbols[at]?.id ?? "") ? undefined : found);
     // A configuration that does not hold a test's subject's caller finds the subject dead,
     // so a test is of dead code only where every production subject it names is dead in
     // every configuration that holds it.
@@ -121,6 +129,9 @@ export function sweepMatrix(matrix, input) {
         union.ambient[edge.to] === true ||
         union.subject[edge.to] !== true ||
         judged[edge.to] !== undefined);
+    const admittedAt = (at) => judged[at]?.every((candidate) => candidate.testOfDeadCode) === true && subjectsDead(at);
+    const kept = keptByTests(union, testReached, admittedAt);
+    const testUsed = testUsedReach(union, union.symbols.map((_symbol, at) => matrix.testUsed[at] === true && testNamed[at] === true), judged.map((one) => one !== undefined));
     const candidates = [];
     union.symbols.forEach((symbol, at) => {
         const all = judged[at];
@@ -128,7 +139,7 @@ export function sweepMatrix(matrix, input) {
             return;
         }
         const held = matrix.heldIn[at] ?? [];
-        const admitted = all.every((candidate) => candidate.testOfDeadCode) && subjectsDead(at);
+        const admitted = admittedAt(at);
         const testRefs = union.made[at]?.test ?? 0;
         const heldByTests = heldBy[union.parent[at] ?? OUTSIDE] ??
             (union.support[at] === true && testRefs > 0 && !admitted ? symbol.id : undefined);
@@ -148,6 +159,8 @@ export function sweepMatrix(matrix, input) {
             configurations: held,
             heldByTests,
             unreferencedTest: unreferenced,
+            testUsed: testUsed[at] === true,
+            keptByTests: kept[at] === true,
         });
     });
     const liveUnder = liveAnywhere(union.symbols, per);
@@ -157,6 +170,65 @@ export function sweepMatrix(matrix, input) {
         components: deadComponents(matrix, { liveUnder, candidates }, new Set()),
     };
 }
+/**
+ * Every declaration of `dead`, those dead in every configuration that holds them, that a
+ * configuration's graph references from a judged declaration outside `dead` or already
+ * kept, until none joins: deleting one would break that configuration's compile. A
+ * production run counts no reference a test file made.
+ */
+function compiledReferences(matrix, dead, mode) {
+    const kept = new Set();
+    for (let changed = true; changed;) {
+        changed = false;
+        for (const graph of matrix.graphs) {
+            graph.out.forEach((edges, from) => {
+                const id = graph.symbols[from]?.id ?? "";
+                if (graph.subject[from] !== true || (dead.has(id) && !kept.has(id))) {
+                    return;
+                }
+                for (const edge of edges) {
+                    const to = graph.symbols[edge.to]?.id ?? "";
+                    if ((!mode.production || !edge.test) && dead.has(to) && !kept.has(to)) {
+                        kept.add(to);
+                        changed = true;
+                    }
+                }
+            });
+        }
+    }
+    return kept;
+}
+/** Per declaration of the union, whether one of `seeds` is it or reaches it through `dead` declarations. */
+function testUsedReach(union, seeds, dead) {
+    // A file is no candidate, and its top level is what reaches what it alone calls.
+    const reached = seeds.map((seed, at) => seed && dead[at] === true);
+    const queue = seeds.flatMap((one, at) => (one ? [at] : []));
+    for (let at = queue.pop(); at !== undefined; at = queue.pop()) {
+        for (const edge of union.out[at] ?? []) {
+            if (dead[edge.to] === true && reached[edge.to] !== true) {
+                reached[edge.to] = true;
+                queue.push(edge.to);
+            }
+        }
+    }
+    return reached;
+}
+/** Per declaration of the union, whether test code `reached` holds and `admitted` rejects references it. */
+function keptByTests(union, reached, admitted) {
+    const kept = union.symbols.map(() => false);
+    union.out.forEach((edges, from) => {
+        const testCode = union.test[from] === true || union.support[from] === true;
+        if (!testCode || reached[from] !== true || admitted(from)) {
+            return;
+        }
+        for (const edge of edges) {
+            if (edge.test) {
+                kept[edge.to] = true;
+            }
+        }
+    });
+    return kept;
+}
 /**
  * The dead components of one sweep over the union, with the file declarations at `files`
  * dead as well: a file that is deleted whole takes the declarations it holds and every

package/dist/src/references.js

@@ -1,4 +1,4 @@
-import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isDecorator, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isExpressionStatement, isExternalModuleReference, isForInStatement, isForOfStatement, isForStatement, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isMetaProperty, isNewExpression, isNamespaceExport, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, isVoidExpression, SyntaxKind, } from "@typescript/native/ast";
+import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isDecorator, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isExpressionStatement, isExternalModuleReference, isForInStatement, isForOfStatement, isForStatement, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isInterfaceDeclaration, isMetaProperty, isModuleBlock, isModuleDeclaration, isNewExpression, isNamespaceExport, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, isVoidExpression, SyntaxKind, } from "@typescript/native/ast";
 import { aliasChains } from "./alias-chain.js";
 import { contextualUses } from "./contextual-uses.js";
 import { destructuring, propertyReadsOf } from "./destructuring.js";
@@ -6,7 +6,7 @@ import { specifierCandidates } from "./configuration-files.js";
 import { namespaceUses } from "./namespace-objects.js";
 import { globExpression } from "./glob.js";
 import { declarationsByName, isParameterProperty, nodeKey, } from "./inventory.js";
-import { augmentationReferences } from "./augmentations.js";
+import { ambientGlobalInterfaces, augmentationReferences } from "./augmentations.js";
 import { elementAccessReferences } from "./element-access.js";
 import { indexedAccessReferences } from "./indexed-access.js";
 import { keyofComparisonReferences } from "./keyof-comparisons.js";
@@ -1135,6 +1135,37 @@ export function references(project, held, targetRoot, options) {
             }
         }
     }
+    /** The ambient global interfaces of the walked files that merge into a declaration outside the project's own files. */
+    const libraryMerged = (scripts) => {
+        const names = new Map();
+        const visit = (node) => {
+            if (isInterfaceDeclaration(node)) {
+                const id = declaredAt(node);
+                if (id !== undefined) {
+                    names.set(id, node.name);
+                }
+            }
+            else if (isModuleDeclaration(node) || isModuleBlock(node)) {
+                node.forEachChild(visit);
+            }
+        };
+        for (const { file } of walked) {
+            file.forEachChild(visit);
+        }
+        const global = new Set(ambientGlobalInterfaces(held, [...names.keys()], scripts));
+        const asked = [...names].filter(([id]) => global.has(id));
+        if (asked.length === 0) {
+            return new Set();
+        }
+        const answers = project.symbolsAt(asked.map(([, name]) => project.handle(name)));
+        return new Set(asked.flatMap(([id], at) => {
+            const symbol = answers[at];
+            return typeof symbol === "object" &&
+                symbol.declarations.some((handle) => !ownPaths.has(handle.path))
+                ? [id]
+                : [];
+        }));
+    };
     const usesOf = new Map(walked.map((one) => [one.file, one.uses]));
     for (const [file, writes] of valued) {
         const uses = usesOf.get(file) ?? [];
@@ -1159,7 +1190,7 @@ export function references(project, held, targetRoot, options) {
         typedLookups = (options.requestCount?.() ?? 0) - before;
     }
     const scripts = new Set(walked.filter((one) => one.file.externalModuleIndicator === undefined).map((one) => one.fileId));
-    found.push(...augmentationReferences(held, found, scripts));
+    found.push(...augmentationReferences(held, found, scripts, libraryMerged(scripts)));
     found.sort((a, b) => byPosition(a.position, b.position) ||
         compare(a.to, b.to) ||
         compare(a.from, b.from) ||

package/dist/src/report.js

@@ -11,6 +11,21 @@ export const SCHEMA_VERSIONS_ACCEPTED = [SCHEMA_VERSION];
 export const ANALYZER_NAME = "deadset-ts";
 /** The language this analyzer claims. */
 export const LANGUAGE = "ts";
+/**
+ * Each component the findings name, once, with the members the first finding naming it
+ * carries, in the order the findings are: `findings` paired with their wire forms and
+ * sorted, then the edge evaluations' findings.
+ */
+function componentsOf(findings) {
+    const listed = new Map();
+    for (const [wire, finding] of findings) {
+        const { members } = finding.component;
+        if (members !== undefined && !listed.has(wire.component.id)) {
+            listed.set(wire.component.id, { id: wire.component.id, members: members.map(wireSymbol) });
+        }
+    }
+    return [...listed.values()];
+}
 /** Two strings ordered bytewise. */
 function compare(a, b) {
     if (a === b) {
@@ -85,9 +100,6 @@ export function wireFinding(finding) {
             root: finding.component.root,
             symbol_count: finding.component.symbolCount,
             deletable_lines: finding.component.deletableLines,
-            ...(finding.component.members === undefined
-                ? {}
-                : { members: finding.component.members.map(wireSymbol) }),
         },
         retained_by: finding.retainedBy,
         configurations: finding.configurations,
@@ -198,7 +210,11 @@ function totalsOf(findings, result) {
 }
 /** Builds the report of one run, every array in the order the Contract fixes for it. */
 export function buildReport(input) {
-    const findings = input.result.findings.map(wireFinding).sort(canonical);
+    const paired = input.result.findings
+        .map((finding) => [wireFinding(finding), finding])
+        .sort(([a], [b]) => canonical(a, b));
+    const findings = paired.map(([wire]) => wire);
+    const evaluated = input.result.edgeEvaluations.flatMap((one) => one.finding === undefined ? [] : [[wireFinding(one.finding), one.finding]]);
     const unavailable = [...new Map(input.unavailable.map((one) => [one.id, one])).values()]
         .sort((a, b) => compare(a.id, b.id))
         .map((one) => ({ id: one.id, role: "consumer", reason: one.reason }));
@@ -228,6 +244,9 @@ export function buildReport(input) {
             .map((one) => ({ id: one.id, project: one.project, error: one.error })),
         consumers: { declared: loaded.length + unavailable.length, loaded, unavailable },
         findings,
+        ...(input.listsComponents === true
+            ? { components: componentsOf([...paired, ...evaluated]) }
+            : {}),
         edge_evaluations: input.result.edgeEvaluations.map(wireEvaluation).sort(byEdge),
         stale_suppressions: input.result.staleSuppressions.map(wireStale).sort(canonicalStale),
         // Every gap shares the one component of the canonical key a gap supplies, the analyzer's

package/dist/src/reporters/sarif.js

@@ -114,7 +114,7 @@ function lineHashCache(read) {
     };
 }
 /** Every position a finding names beyond its own, in the mapping's order, the first hundred. */
-function relatedOf(found) {
+function relatedOf(found, members) {
     const related = [];
     for (const one of found.details.implementations ?? []) {
         related.push({ label: "implementation", at: one.position, endLine: one.position.end_line });
@@ -126,7 +126,7 @@ function relatedOf(found) {
         const at = found.details.name_literal;
         related.push({ label: "name", at, endLine: at.end_line });
     }
-    for (const one of found.component.members ?? []) {
+    for (const one of members(found.component.id)) {
         if (declarationKey(one.ref, one.position.path) !==
             declarationKey(found.symbol.ref, found.position.path)) {
             related.push({ label: "member", at: one.position, endLine: one.position.end_line });
@@ -143,7 +143,9 @@ function messageWithLinks(message, related) {
     return `${message} (see ${links.join(", ")})`;
 }
 /** Every member of the finding the mapping places nowhere else, under its schema name. */
-function propertiesOf(found) {
+/** A result's member bag, its component holding the members the report lists for it once. */
+function propertiesOf(found, members) {
+    const listed = members(found.component.id);
     return {
         language: found.language,
         symbol: found.symbol,
@@ -154,7 +156,7 @@ function propertiesOf(found) {
             : { liveness_relation: found.liveness_relation }),
         test_only: found.test_only,
         generated: found.generated,
-        component: found.component,
+        component: listed.length === 0 ? found.component : { ...found.component, members: listed },
         retained_by: found.retained_by,
         configurations: found.configurations,
         consumers_loaded: found.consumers_loaded,
@@ -169,8 +171,8 @@ function ruleIndex(index, code) {
     }
     return at;
 }
-function findingResult(found, index, hashOf) {
-    const related = relatedOf(found);
+function findingResult(found, index, hashOf, members) {
+    const related = relatedOf(found, members);
     return {
         ruleId: found.code,
         ruleIndex: ruleIndex(index, found.code),
@@ -190,7 +192,7 @@ function findingResult(found, index, hashOf) {
             primaryLocationLineHash: hashOf(found.position),
             "deadsetSymbolRef/v1": symbolFingerprint(found.code, found.symbol.ref),
         },
-        properties: propertiesOf(found),
+        properties: propertiesOf(found, members),
     };
 }
 /** A stale suppression at the failing level, at its own site; it is no finding, so it carries no member bag. */
@@ -218,8 +220,10 @@ export function sarif(report, options) {
     const ruleList = rules(kinds);
     const index = new Map(kinds.map((kind, at) => [kind.code, at]));
     const hashOf = lineHashCache(options.readSource);
+    const listed = new Map((report.components ?? []).map((one) => [one.id, one.members]));
+    const members = (id) => listed.get(id) ?? [];
     const results = [
-        ...report.findings.map((found) => findingResult(found, index, hashOf)),
+        ...report.findings.map((found) => findingResult(found, index, hashOf, members)),
         ...report.stale_suppressions.map((stale) => staleResult(stale, index, hashOf)),
     ];
     const languages = [...report.analyzer.languages].sort().join("+");

package/dist/src/roots.js

@@ -7,7 +7,7 @@
  * decides; the published API only supposes a consumer, so a published export is live
  * under reachability and still a candidate under reference counting.
  */
-import { isExpressionWithTypeArguments, isFunctionLikeDeclaration, isPropertyAccessExpression, isQualifiedName, isTypeQueryNode, isTypeReferenceNode, isPropertyDeclaration, isVariableDeclaration, isVariableStatement, } from "@typescript/native/ast";
+import { isArrowFunction, isAssertionExpression, isExpressionWithTypeArguments, isFunctionLikeDeclaration, isIdentifier, isMethodDeclaration, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAssignment, isReturnStatement, isSatisfiesExpression, isPropertyAccessExpression, isQualifiedName, isTypeQueryNode, isTypeReferenceNode, isPropertyDeclaration, isVariableDeclaration, isVariableStatement, SyntaxKind, } from "@typescript/native/ast";
 import { aliasChains } from "./alias-chain.js";
 import { filesNamedBy, outsideChain, relativeSpecifiers, } from "./configuration-files.js";
 import { conventionEntries } from "./conventions.js";
@@ -260,6 +260,10 @@ export function roots(project, held, targetRoot, options) {
             published.push(...entryFiles(entry));
         }
     }
+    if (options.publishedAPI) {
+        // A library's bundle hands what its entry exports to every program that loads it.
+        published.push(...points.filter((point) => point.rule === "bundler-entry").map((point) => point.file));
+    }
     const publishedNames = new Set(published.map((file) => file.fileName));
     const patterned = [];
     for (const pattern of options.entryFiles) {
@@ -485,14 +489,23 @@ function publishedAPI(project, published, exportsOf, held, byPath, tagged) {
             const symbol = byId.get(id);
             return symbol === undefined || symbol.kind === "file" ? [] : nodes.typeNamesOf(symbol);
         });
-        for (const symbol of inferredTypeSymbols(project, round.flatMap((id) => {
+        const inferred = inferredTypeSymbols(project, round.flatMap((id) => {
             const symbol = byId.get(id);
             return symbol === undefined ? [] : nodes.nodesOf(symbol);
-        }))) {
+        }));
+        for (const symbol of inferred.types) {
             for (const target of chains.chainOf(symbol)) {
                 reach(target.id);
             }
         }
+        for (const symbol of inferred.members) {
+            for (const target of chains.chainOf(symbol)) {
+                const member = byId.get(target.id);
+                if (member?.visibility === "public" || member?.visibility === "protected") {
+                    reach(target.id);
+                }
+            }
+        }
         project.symbolsAt(named.map((node) => project.handle(node))).forEach((symbol, index) => {
             if (symbol === UNANSWERED) {
                 for (const id of held.byName.get(named[index]?.getText() ?? "") ?? []) {
@@ -544,11 +557,101 @@ function declarationNodes(held, byPath) {
 /** How deep the type arguments and constituents of an inferred type are followed. */
 const INFERRED_DEPTH = 4;
 /**
- * The declarations of the types the compiler infers where a declaration writes none: the
- * type of a variable or a property with no annotation, and the result of a function or a
- * method with no result annotation, each with the types its type arguments and its union
- * or intersection constituents name, to a fixed depth. A question the checker leaves
- * unanswered names nothing.
+ * The values one function body returns, each through the type assertions around it: the
+ * value a caller receives carries the operand's type whatever type the assertion or the
+ * signature names. A nested function's returns are its own.
+ */
+function returnedValues(body) {
+    const found = [];
+    const add = (value) => {
+        for (let at = value; at !== undefined;) {
+            found.push(at);
+            at =
+                isAssertionExpression(at) || isSatisfiesExpression(at) || isParenthesizedExpression(at)
+                    ? at.expression
+                    : undefined;
+        }
+    };
+    if (!isFunctionLikeDeclaration(body.parent) || body.parent.body !== body) {
+        return found;
+    }
+    if (isArrowFunction(body.parent) && body.kind !== SyntaxKind.Block) {
+        add(body);
+        return found;
+    }
+    const visit = (node) => {
+        if (isFunctionLikeDeclaration(node)) {
+            return;
+        }
+        if (isReturnStatement(node) && node.expression !== undefined) {
+            add(node.expression);
+        }
+        node.forEachChild(visit);
+    };
+    body.forEachChild(visit);
+    return found;
+}
+/** The object literal one returned value is, written there or as the initializer of a variable `body` declares. */
+function returnedLiteral(value, body) {
+    if (isObjectLiteralExpression(value)) {
+        return value;
+    }
+    if (!isIdentifier(value)) {
+        return undefined;
+    }
+    let found;
+    const visit = (node) => {
+        if (isVariableDeclaration(node) &&
+            isIdentifier(node.name) &&
+            node.name.text === value.text &&
+            node.initializer !== undefined) {
+            let at = node.initializer;
+            while (isAssertionExpression(at) ||
+                isSatisfiesExpression(at) ||
+                isParenthesizedExpression(at)) {
+                at = at.expression;
+            }
+            found = isObjectLiteralExpression(at) ? at : found;
+        }
+        if (!isFunctionLikeDeclaration(node)) {
+            node.forEachChild(visit);
+        }
+    };
+    body.forEachChild(visit);
+    return found;
+}
+/**
+ * The values one function body returns, and those each method of an object literal it
+ * returns returns, to a fixed depth: a caller holding the literal calls its methods, and
+ * receives what they return.
+ */
+function returnedThroughLiterals(body, depth = 0) {
+    const values = returnedValues(body);
+    if (depth >= INFERRED_DEPTH) {
+        return values;
+    }
+    const found = [...values];
+    for (const value of values) {
+        for (const property of returnedLiteral(value, body)?.properties ?? []) {
+            const fn = isMethodDeclaration(property)
+                ? property
+                : isPropertyAssignment(property) && isFunctionLikeDeclaration(property.initializer)
+                    ? property.initializer
+                    : undefined;
+            if (fn?.body !== undefined) {
+                found.push(...returnedThroughLiterals(fn.body, depth + 1));
+            }
+        }
+    }
+    return found;
+}
+/**
+ * The declarations of the types the compiler infers where a declaration writes none, and
+ * of the values a function returns: the type of a variable or a property with no
+ * annotation, the result of a function or a method with no result annotation, and the type
+ * of each value its body returns, each with the types its type arguments and its union or
+ * intersection constituents name, to a fixed depth; and as `members` the properties of each
+ * returned value's type. A question the checker leaves unanswered names nothing.
  */
 function inferredTypeSymbols(project, declarations) {
     const { queries } = project;
@@ -557,12 +660,24 @@ function inferredTypeSymbols(project, declarations) {
         !isFunctionLikeDeclaration(node.initializer ?? node)
         ? [node.name]
         : []);
+    const returned = declarations.flatMap((node) => {
+        const signature = isFunctionLikeDeclaration(node)
+            ? node
+            : isVariableDeclaration(node) &&
+                node.initializer !== undefined &&
+                isFunctionLikeDeclaration(node.initializer)
+                ? node.initializer
+                : undefined;
+        return signature?.body === undefined ? [] : returnedThroughLiterals(signature.body);
+    });
     const types = [];
-    queries.typesAt(valued).forEach((type) => {
+    const returnedTypes = [];
+    queries.typesAt([...valued, ...returned]).forEach((type, at) => {
         if (type !== UNANSWERED && type !== undefined) {
-            types.push(type);
+            (at < valued.length ? types : returnedTypes).push(type);
         }
     });
+    types.push(...returnedTypes);
     for (const node of declarations) {
         const signature = isFunctionLikeDeclaration(node)
             ? node
@@ -604,7 +719,19 @@ function inferredTypeSymbols(project, declarations) {
     types.forEach((type) => {
         visit(type, 0);
     });
-    return [...found.values()];
+    // A returned value carries each property of its type, one an anonymous type declares or
+    // an intersection merges included, which no type name reaches.
+    const members = new Map();
+    for (const type of returnedTypes) {
+        const parts = queries.constituents(type);
+        for (const one of [type, ...(parts === UNANSWERED ? [] : parts)]) {
+            const properties = queries.propertiesOf(one);
+            for (const property of properties === UNANSWERED ? [] : properties) {
+                members.set(property.id, property);
+            }
+        }
+    }
+    return { types: [...found.values()], members: [...members.values()] };
 }
 /**
  * The names of types one declaration's own syntax writes: in a type reference, a