@cplieger/deadset-ts 3.12.1 → 3.13.0

package/README.md

@@ -4,11 +4,11 @@
 
 > Deterministic dead-code analysis for TypeScript, class and type members included.
 
-deadset-ts is a command-line analyzer for TypeScript and JavaScript projects. It builds the program from your `tsconfig.json` files through the TypeScript 7 compiler API, resolves every reference in one pass, and reports the declarations nothing reaches: unused exports, type-only exports without a consumer, unused class members (private, protected, static and accessors), unused interface, type-alias, enum and namespace members, exports that can be narrowed to a smaller visibility, and whole groups of declarations that only keep each other alive. Every finding carries an issue code, a confidence and a stable symbol reference from the [deadset Contract](https://github.com/cplieger/deadset-spec), so the same report shape works for a Go analyzer and for a merged multi-language report. The analysis is deterministic: the same tree gives the same report, with no cache and no text search.
+deadset-ts is a command-line analyzer for TypeScript and JavaScript projects. It builds the program from your `tsconfig.json` files through the TypeScript 7 compiler API, resolves every reference in one pass, and reports the declarations nothing reaches: unused exports, type-only exports without a consumer, unused class members (private, protected, static and accessors), unused interface, type-alias, enum and namespace members, exports that can be narrowed to a smaller visibility, whole groups of declarations that only keep each other alive, and inside a function the unused parameters, results nobody reads, unreachable statements, dead stores and unreachable cases. Every finding carries an issue code, a confidence and a stable symbol reference from the [deadset Contract](https://github.com/cplieger/deadset-spec), so the same report shape works for a Go analyzer and for a merged multi-language report. The analysis is deterministic: the same tree gives the same report, with no cache and no text search.
 
 deadset-ts is report-only. It never edits source, and it refuses any `--fix` flag.
 
-**Status: pre-release.** This version implements contract 3.2.0 and ships the analyzer's foundation: one compiler session per run over the projects `analysis.configurations` declares, in the order it lists them, each a compiler configuration file below the target, or, where it declares none, every `tsconfig` project discovered under the target (the explicit scope, every `tsconfig*.json`, each project's `references`), a fail-closed read of every project's diagnostics, configuration decoding against the contract's closed key list with `print-config` and its provenance, `print-projects`, the report-only guard, the symbol inventory of every declaration a project's own files hold down to its class and type members, the one-pass reference resolution over that inventory, which resolves each file's identifiers in batches ([batch-cap calibration](docs/batch-cap-calibration.md) is the measurement behind the batch size), and the root set `print-roots` prints. A root is a declaration the analysis keeps live without a reference: what a file exports when the manifest names it through `main`, `module`, `types`, `bin` or `exports`, or when `ts.entry_files` matches it; a library target's published API; the configuration, setup and test files of Vitest, Stryker and Playwright, the flat configuration of ESLint, and a worker or service worker a call addresses by a string literal; and every declaration a `roots.patterns` entry names. An entry that names nothing is reported as `DS1704` and fails the run. The entry-point conventions of other tools are not read, and `DECLINED_CONVENTIONS` lists each one with the reason. Seven exemption classes hold a declaration back from the sweep, and `print-retained` lists what each one held back: `interface-satisfaction`, a member an interface requires of a class whose value reaches that interface; `decorator`, a decorated member and every member of a decorated class; `injection-container`, a decorated property of a class a dependency-injection container constructs, being a class passed to a call `ts.injection_registrations` names or one a parameter of whose constructor carries a decorator; `framework-lifecycle`, a member a `ts.lifecycle_contracts` entry lists, on a class that is the entry's component by a decorator or a call the entry names or by extending a class it names; `serialization-contract`, the properties of a class whose values reach `JSON.stringify` or a declaration `ts.serializers` names, and those and its `toJSON` and `toString` where a value is passed to an `unknown` or `any` parameter of a function outside the analysis; and, at the lowest confidence, `template-field`, a member an action of a template under `analysis.template_dirs` names, and `reflective-lookup`, a member a literal key of an element access or of `Reflect.get`, `Reflect.set` or `Reflect.has` names. None of them holds back a `#private` member. `analyze` writes the report the Contract's report schema declares, with text, JSON, GitHub annotation, SARIF 2.1.0 and template renderings beside it on request. A scope document passed with `--scope` names the consumers loaded beside the target, each a directory whose compiler configurations open in the same session; a reference from a consumer keeps a target declaration live, the report names every consumer it loaded, and a consumer that is absent or does not load ends the run with exit code 3. A library target's published API is `certain` once every declared consumer loads and `possible` with no consumer information, and in that second case `DS1001` defaults to `allow` and the narrowing kinds report only in files no manifest export reaches. `explain` answers why one declaration is reported, retained, live or dead, from the same analysis the report is built from. `describe` prints the analyzer's description with its conformance record over the published corpus and the declared gaps `conformance.json` lists. The analysis is reached through the command, and through `run()` for a caller that runs the command in-process. The one runtime dependency is the `typescript` package at exactly 7.0.2, installed under the `@typescript/native` name until TypeScript 7.1 ships a compiler API the tooling can share.
+**Status: pre-release.** This version implements contract 4.0.0 and ships the analyzer's foundation: one compiler session per run over the projects `analysis.configurations` declares, in the order it lists them, each a compiler configuration file below the target, or, where it declares none, every `tsconfig` project discovered under the target (the explicit scope, every `tsconfig*.json`, each project's `references`), a fail-closed read of every project's diagnostics, configuration decoding against the contract's closed key list with `print-config` and its provenance, `print-projects`, the report-only guard, the symbol inventory of every declaration a project's own files hold down to its class and type members, the one-pass reference resolution over that inventory, which resolves each file's identifiers in batches ([batch-cap calibration](docs/batch-cap-calibration.md) is the measurement behind the batch size), and the root set `print-roots` prints. A root is a declaration the analysis keeps live without a reference: what a file exports when the manifest names it through `main`, `module`, `types`, `bin` or `exports`, or when `ts.entry_files` matches it; a library target's published API; the configuration, setup and test files of Vitest, Stryker and Playwright, the flat configuration of ESLint, and a worker or service worker a call addresses by a string literal; and every declaration a `roots.patterns` entry names. An entry that names nothing is reported as `DS1704` and fails the run. The entry-point conventions of other tools are not read, and `DECLINED_CONVENTIONS` lists each one with the reason. Seven exemption classes hold a declaration back from the sweep, and `print-retained` lists what each one held back: `interface-satisfaction`, a member an interface requires of a class whose value reaches that interface; `decorator`, a decorated member and every member of a decorated class; `injection-container`, a decorated property of a class a dependency-injection container constructs, being a class passed to a call `ts.injection_registrations` names or one a parameter of whose constructor carries a decorator; `framework-lifecycle`, a member a `ts.lifecycle_contracts` entry lists, on a class that is the entry's component by a decorator or a call the entry names or by extending a class it names; `serialization-contract`, the properties of a class whose values reach `JSON.stringify` or a declaration `ts.serializers` names, and those and its `toJSON` and `toString` where a value is passed to an `unknown` or `any` parameter of a function outside the analysis; and, at the lowest confidence, `template-field`, a member an action of a template under `analysis.template_dirs` names, and `reflective-lookup`, a member a literal key of an element access or of `Reflect.get`, `Reflect.set` or `Reflect.has` names. None of them holds back a `#private` member. `analyze` writes the report the Contract's report schema declares, with text, JSON, GitHub annotation, SARIF 2.1.0 and template renderings beside it on request. A scope document passed with `--scope` names the consumers loaded beside the target, each a directory whose compiler configurations open in the same session; a reference from a consumer keeps a target declaration live, the report names every consumer it loaded, and a consumer that is absent or does not load ends the run with exit code 3. A library target's published API is `certain` once every declared consumer loads and `possible` with no consumer information, and in that second case `DS1001` defaults to `allow` and the narrowing kinds report only in files no manifest export reaches. `explain` answers why one declaration is reported, retained, live or dead, from the same analysis the report is built from. `describe` prints the analyzer's description with its conformance record over the published corpus and the declared gaps `conformance.json` lists. The analysis is reached through the command, and through `run()` for a caller that runs the command in-process. The one runtime dependency is the `typescript` package at exactly 7.0.2, installed under the `@typescript/native` name until TypeScript 7.1 ships a compiler API the tooling can share.
 
 ## Install
 

package/dist/src/analysis.js

@@ -8,6 +8,7 @@
  * project's checker, and that holds only for views the session itself hands out.
  */
 import { consumerLoads, consumerReferences, moduleIdentity, } from "./consumers.js";
+import { configuredDeclarations, configuredRef, declarationsNamed, } from "./configured-declarations.js";
 import { decorator } from "./decorator.js";
 import { dependenciesOf, projectNeeds } from "./dependencies.js";
 import { deprecatedDeclarations } from "./deprecation.js";
@@ -16,12 +17,13 @@ import { readEdgeSides } from "./edges.js";
 import { enumGroup } from "./enum-group.js";
 import { computeExemptions, disabledClasses, exemptionsOf, retainedIn, } from "./exempt.js";
 import { heldByInclusion, sourceTree } from "./file-facts.js";
-import { findingsPass } from "./findings-pass.js";
+import { findingsPass, recordedFindings, rowKey } from "./findings-pass.js";
 import { NO_SELF_CHECK, unmatchedRootFindings, } from "./findings/self-check.js";
 import { frameworkLifecycle } from "./framework-lifecycle.js";
 import { implementations, mergeImplementations } from "./implementations.js";
 import { injectionContainer } from "./injection-container.js";
 import { interfaceSatisfaction } from "./interface-satisfaction.js";
+import { intraFunctionFacts, projectParts } from "./intra-function-parts.js";
 import { inventory } from "./inventory.js";
 import { readManifest } from "./manifest.js";
 import { matrixOf, referenceKey, sweepMatrix, } from "./matrix.js";
@@ -33,7 +35,8 @@ import { roots, unmatchedEverywhere } from "./roots.js";
 import { serializationContract } from "./serialization-contract.js";
 import { diagnosticsOf, runSession } from "./session.js";
 import { accessorsOf, storesOf } from "./stores.js";
-import { readBaseline, readIgnoreFile } from "./suppress-file.js";
+import { isPartKind } from "./suppress.js";
+import { bindRows, readBaseline, readIgnoreFile } from "./suppress-file.js";
 import { inlineDirectives, inlineSuppressions } from "./suppress-inline.js";
 import { readTemplates, templateField } from "./template-field.js";
 /** The setting whose source decides where a finding about a configured root sits. */
@@ -202,7 +205,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
             configFile: projectRead.configFile,
             configured,
             exempt,
-            extra: extra(project, projectRead),
+            extra: extra(project, projectRead, resolved.references),
         };
     });
     const consumed = read.consumers.references;
@@ -247,7 +250,7 @@ export function runSweep(engine, host, scope, config, input, detectors = DETECTO
 /** Reads a run's projects with every per-project fact an emitter reads. */
 function readEmitterRun(engine, host, scope, config, mode, detectors) {
     const targetRoot = scope.target.path;
-    return readRun(engine, host, scope, config, mode, detectors, (project, read) => ({
+    return readRun(engine, host, scope, config, mode, detectors, (project, read, references) => ({
         deprecated: deprecatedDeclarations(project, read.held),
         accessors: accessorsOf(project, read.held),
         needs: projectNeeds(project, read.held, host),
@@ -255,6 +258,8 @@ function readEmitterRun(engine, host, scope, config, mode, detectors) {
         heldByInclusion: heldByInclusion(project, targetRoot),
         rooted: read.rooted,
         directives: inlineDirectives(project, read.held, targetRoot),
+        declarationsNamed: declarationsNamed(project, read.held, configuredDeclarations(config)),
+        parts: projectParts(project, read.held, references, targetRoot),
     }));
 }
 /**
@@ -288,6 +293,7 @@ function emitterInputOver(host, scope, config, read, input, selfCheck) {
             edges: readEdgeSides(host, targetRoot),
         },
         selfCheck,
+        intraFunction: intraFunctionFacts(projects.map((one) => one.extra.parts), projects.flatMap((one) => one.configured.references), new Set(read.exempt.map((one) => one.id))),
     };
 }
 /**
@@ -303,37 +309,22 @@ export function runEmitterInput(engine, host, scope, config, input, detectors =
 }
 /**
  * Reads the run the scope and the configuration describe for its findings. The inline
- * directives, the ignore file's entries and the baseline's rows are read and bound before
- * any sweep, and the run is swept once under every bound record's mark and once under
- * none, so a record is decided against the finding its code would have produced. The
+ * directives, the ignore file's entries and the baseline's rows are bound before any
+ * sweep, and the run is swept once under every bound record's mark and once under none,
+ * so a record is decided against the finding its code would have produced. The
  * self-check family reports the refused suppressions and the roots that named nothing.
  * Beside the inputs it answers the projects and test-file rules a report names.
  */
-function runAnalysisInputs(engine, host, scope, config, provenance, mode, detectors) {
+function readAnalysis(engine, host, scope, config, provenance, mode, detectors) {
     const targetRoot = scope.target.path;
     const read = readEmitterRun(engine, host, scope, config, mode, detectors);
     const symbols = read.matrix.union.symbols;
-    const documents = [
+    const fixed = [
         inlineSuppressions(read.projects.map((one) => one.extra.directives)),
         readIgnoreFile(host, targetRoot, symbols),
-        readBaseline(host, targetRoot, symbols),
     ];
-    const suppressions = {
-        records: documents.flatMap((one) => one.records),
-        refusals: documents.flatMap((one) => one.refusals),
-    };
-    const facts = {
-        refusals: suppressions.refusals,
-        unmatchedRoots: unmatchedEverywhere(config.rootPatterns, read.projects.map((one) => one.extra.rooted)),
-        rootsDocument: documentOf(host, provenance, ROOTS_SETTING, targetRoot),
-    };
-    const marked = [...new Set(suppressions.records.map((record) => record.bound))].filter((id) => id !== "");
+    const inputsUnder = (baseline) => inputsOver(host, scope, config, provenance, mode, read, [...fixed, baseline]);
     return {
-        inputs: {
-            marked: emitterInputOver(host, scope, config, read, { marked, mode }, facts),
-            unmarked: emitterInputOver(host, scope, config, read, { marked: [], mode }, facts),
-            suppressions,
-        },
         run: {
             projects: read.projects.map((one) => ({
                 id: one.configured.configuration,
@@ -343,6 +334,38 @@ function runAnalysisInputs(engine, host, scope, config, provenance, mode, detect
             consumers: read.consumers,
         },
         configured: read.projects.map((one) => one.configured),
+        symbols,
+        inputsUnder,
+    };
+}
+/** The inputs of one read run under the suppression documents given, in reading order. */
+function inputsOver(host, scope, config, provenance, mode, read, documents) {
+    const targetRoot = scope.target.path;
+    const suppressions = {
+        records: documents.flatMap((one) => one.records),
+        refusals: documents.flatMap((one) => one.refusals),
+    };
+    const facts = {
+        refusals: suppressions.refusals,
+        unmatchedRoots: unmatchedEverywhere(config.rootPatterns, read.projects.map((one) => one.extra.rooted)),
+        rootsDocument: documentOf(host, provenance, ROOTS_SETTING, targetRoot),
+        unmatchedDeclarations: configuredDeclarations(config)
+            .filter((_, at) => !read.projects.some((one) => one.extra.declarationsNamed[at] === true))
+            .map((one) => ({
+            ref: configuredRef(one.entry),
+            key: one.key,
+            document: documentOf(host, provenance, one.key, targetRoot),
+        })),
+    };
+    const marked = [
+        ...new Set(suppressions.records
+            .filter((record) => !isPartKind(record.code))
+            .map((record) => record.bound)),
+    ].filter((id) => id !== "");
+    return {
+        marked: emitterInputOver(host, scope, config, read, { marked, mode }, facts),
+        unmarked: emitterInputOver(host, scope, config, read, { marked: [], mode }, facts),
+        suppressions,
     };
 }
 /**
@@ -352,6 +375,56 @@ function runAnalysisInputs(engine, host, scope, config, provenance, mode, detect
  * an explanation reads.
  */
 export function runAnalysis(engine, host, scope, config, provenance, mode, detectors = DETECTORS) {
-    const { inputs, run, configured } = runAnalysisInputs(engine, host, scope, config, provenance, mode, detectors);
-    return { result: findingsPass(inputs), run, swept: inputs.marked.swept, configured };
+    const reader = readAnalysis(engine, host, scope, config, provenance, mode, detectors);
+    const inputs = reader.inputsUnder(readBaseline(host, scope.target.path, reader.symbols));
+    return analysisOf(reader, inputs);
+}
+function analysisOf(reader, inputs) {
+    return {
+        result: findingsPass(inputs),
+        run: reader.run,
+        swept: inputs.marked.swept,
+        configured: reader.configured,
+    };
+}
+/**
+ * The fixpoint a baseline write records. The first round reads no baseline; each later
+ * round reads the rows recorded so far, records a row for each recordable finding no row
+ * already names, and removes every row it reports stale. A removed row is not recorded
+ * again, so the write ends.
+ */
+export function runBaselineWrite(engine, host, scope, config, provenance, mode, reason, detectors = DETECTORS) {
+    const reader = readAnalysis(engine, host, scope, config, provenance, mode, detectors);
+    const first = analysisOf(reader, reader.inputsUnder({ records: [], refusals: [] }));
+    let rows = [];
+    const removed = new Set();
+    let result = first.result;
+    let stale = new Set();
+    for (;;) {
+        const held = new Set(rows.map(rowKey));
+        const added = recordedFindings(result.findings).filter((row) => !held.has(rowKey(row)) && !removed.has(rowKey(row)));
+        if (added.length === 0 && stale.size === 0) {
+            return { first, rows };
+        }
+        for (const key of stale) {
+            removed.add(key);
+        }
+        rows = [...rows.filter((row) => !stale.has(rowKey(row))), ...added];
+        const inputs = reader.inputsUnder(bindRows(rows, reason, reader.symbols));
+        result = findingsPass(inputs);
+        stale = staleRows(inputs.suppressions.records, result.ledger.verdicts);
+    }
+}
+/** The baseline rows a round reports stale: every record a row binds to matched nothing. */
+function staleRows(records, verdicts) {
+    const live = new Set();
+    const stale = new Set();
+    records.forEach((record, at) => {
+        if (record.mechanism !== "baseline") {
+            return;
+        }
+        const key = rowKey(record);
+        (verdicts[at] === "stale" ? stale : live).add(key);
+    });
+    return new Set([...stale].filter((key) => !live.has(key)));
 }

package/dist/src/components.js

@@ -89,7 +89,8 @@ function linesSpanned(symbols) {
     return total;
 }
 /**
- * The dead declarations by their place in the subgraph, and the edges between them: each
+ * The dead declarations by their place in the subgraph, a test file's declaration only
+ * where it is a test of dead code, and the edges between them: each
  * reference one makes to another, an edge each way between a dead member and its dead
  * container (one direction alone leaves the member a component the container reaches),
  * and an edge back from each production target of an admitted test, which puts the test in
@@ -98,7 +99,8 @@ function linesSpanned(symbols) {
 function deadSubgraph(graph, dead, testOfDeadCode) {
     const at = [];
     const position = graph.symbols.map((_symbol, index) => {
-        if (dead[index] !== true) {
+        // A test file's declaration belongs to a component only as a test of dead code.
+        if (dead[index] !== true || (graph.test[index] === true && testOfDeadCode[index] !== true)) {
             return UNVISITED;
         }
         at.push(index);

package/dist/src/configured-declarations.js

@@ -230,3 +230,39 @@ export function spelledEntry(entry, held) {
             return entry.global;
     }
 }
+/** The key under which a lifecycle contract's declarations are configured. */
+const LIFECYCLE_KEY = "ts.lifecycle_contracts";
+/**
+ * Every entry of the three keys that name declarations, in the configuration's order:
+ * the injection registrations, each lifecycle contract's components and then its bases,
+ * and the serializers.
+ */
+export function configuredDeclarations(config) {
+    return [
+        ...config.ts.injectionRegistrations.map((entry) => ({
+            key: "ts.injection_registrations",
+            entry,
+        })),
+        ...config.ts.lifecycleContracts.flatMap((contract) => [...contract.components, ...contract.bases].map((entry) => ({ key: LIFECYCLE_KEY, entry }))),
+        ...config.ts.serializers.map((entry) => ({ key: "ts.serializers", entry })),
+    ];
+}
+/** Whether each configured entry names a declaration in one project, in the entries' order. */
+export function declarationsNamed(project, held, configured) {
+    return resolveEntries(project, held, configured.map((one) => one.entry)).map(namesADeclaration);
+}
+/**
+ * The reference a finding about a configured entry names it by, the entry as the
+ * configuration spells it: a symbol entry's reference, a module entry's module, a number
+ * sign and its name, and a global entry's path after a number sign.
+ */
+export function configuredRef(entry) {
+    switch (entry.shape) {
+        case "symbol":
+            return entry.symbol;
+        case "module":
+            return `${entry.module}#${entry.name}`;
+        case "global":
+            return `#${entry.global}`;
+    }
+}

package/dist/src/conformance-record.js

@@ -2,9 +2,9 @@
 // Regenerate it with `UPDATE_GOLDEN=1 npx vitest --run src/conformance.corpus.test.ts`.
 export const RECORD = {
     conformance: {
-        corpusVersion: "1.9.0",
+        corpusVersion: "2.0.0",
         result: "pass",
-        digest: "sha256:3e9e40876551faa2c196311bf06d47d220ab5127a9fb8921969aae552c42e824",
+        digest: "sha256:1274315595d7b944d22eb0126081e24cf293c9fe53a236f4d263c714644f32ee",
     },
     gaps: [
         {

package/dist/src/edges.js

@@ -8,6 +8,7 @@ import { ConfigError } from "./config.js";
 import { positionAt, walkDocument } from "./json-document.js";
 import { joinPath } from "./paths.js";
 import { positionKey } from "./position.js";
+import { isPartSubject } from "./suppress.js";
 /** The name and the location the Contract fixes for the edges document. */
 export const EDGES_FILE = "deadset-edges.json";
 /** The language prefix of every reference this analyzer evaluates. */
@@ -169,7 +170,9 @@ export function evaluateEdges(findings, sides, symbols) {
     }
     const held = new Map();
     findings.forEach((finding, at) => {
-        held.set(positionKey(finding.position), at);
+        if (!isPartSubject(finding.symbol.kind)) {
+            held.set(positionKey(finding.position), at);
+        }
     });
     const pending = new Set();
     const evaluations = sides.map((side) => {

package/dist/src/findings/completion.js

@@ -6,8 +6,9 @@
 import { componentId } from "../components.js";
 import { OUTSIDE } from "../graph.js";
 import { KINDS } from "../kinds.js";
+import { byPosition } from "../position.js";
 import { FAMILY_KEY_LENGTH } from "../resolve.js";
-import { isRowSubject } from "../suppress.js";
+import { isPartSubject, isRowSubject } from "../suppress.js";
 /** The classes ranked by the claim each makes, the strongest highest. */
 const RANK = { certain: 3, probable: 2, possible: 1 };
 /** The weaker of two classes, which is a class capped by a ceiling. */
@@ -66,14 +67,35 @@ function reachabilityClasses(input) {
             : "probable";
     return (id) => (published.has(id) ? outside : "certain");
 }
-/** The component each dead declaration of the run falls in, and none for a live one. */
-function findingComponents(swept) {
+/**
+ * The component each dead declaration of the run falls in, and none for a live one, with
+ * its members listed in the canonical order where the run lists a component in full.
+ */
+function findingComponents(swept, cascade) {
     const held = new Map();
     for (const component of swept.sweep.components) {
         for (const member of component.members) {
             held.set(member, component);
         }
     }
+    const symbols = new Map(swept.matrix.union.symbols.map((symbol) => [symbol.id, symbol]));
+    const listed = (component) => component.members
+        .flatMap((member) => {
+        const symbol = symbols.get(member);
+        return symbol === undefined
+            ? []
+            : [
+                {
+                    ref: symbol.ref,
+                    name: symbol.name,
+                    position: {
+                        ...symbol.position,
+                        endLine: Math.max(symbol.position.line, symbol.endLine),
+                    },
+                },
+            ];
+    })
+        .sort((a, b) => byPosition(a.position, b.position) || (a.ref === b.ref ? 0 : a.ref < b.ref ? -1 : 1));
     return (id) => {
         const component = held.get(id);
         return component === undefined
@@ -83,6 +105,7 @@ function findingComponents(swept) {
                 root: component.roots.includes(id),
                 symbolCount: component.members.length,
                 deletableLines: component.deletableLines,
+                ...(cascade === "full" ? { members: listed(component) } : {}),
             };
     };
 }
@@ -101,7 +124,7 @@ export function completed(input, findings, kinds = KINDS) {
     const positions = new Map(union.symbols.map((symbol, at) => [symbol.ref, at]));
     const candidates = new Map(swept.sweep.candidates.map((candidate) => [candidate.id, candidate]));
     const classOf = reachabilityClasses(input);
-    const componentOf = findingComponents(swept);
+    const componentOf = findingComponents(swept, input.config.reporters.cascade);
     let minted = swept.sweep.components.length;
     return findings.map((finding) => {
         const row = kinds.get(finding.code);
@@ -113,11 +136,15 @@ export function completed(input, findings, kinds = KINDS) {
         const at = isRowSubject(finding.symbol.kind)
             ? OUTSIDE
             : (positions.get(finding.symbol.ref) ?? OUTSIDE);
+        // A part names the declaration that holds it, and is decided inside it rather than by
+        // the declaration's liveness, so it carries none of the declaration's sweep facts.
+        const part = isPartSubject(finding.symbol.kind);
         const symbol = union.symbols[at];
-        const judged = union.subject[at] === true ? symbol : undefined;
+        const judged = !part && union.subject[at] === true ? symbol : undefined;
         const candidate = judged === undefined ? undefined : candidates.get(judged.id);
-        const found = symbol === undefined ? undefined : componentOf(symbol.id);
-        if (candidate !== undefined && found === undefined) {
+        const found = symbol === undefined || part ? undefined : componentOf(symbol.id);
+        // A test file's declaration is a component member only as a test of dead code.
+        if (candidate !== undefined && found === undefined && union.test[at] !== true) {
             throw new Error(`${candidate.id} is judged dead and falls in no dead component`);
         }
         let component = found;
@@ -148,7 +175,9 @@ export function completed(input, findings, kinds = KINDS) {
             component,
             retainedBy: [],
             configurations: candidate?.configurations ??
-                (judged === undefined ? swept.matrix.configurations : (swept.matrix.heldIn[at] ?? [])),
+                (judged === undefined && !part
+                    ? swept.matrix.configurations
+                    : (swept.matrix.heldIn[at] ?? swept.matrix.configurations)),
             consumersLoaded: input.boundary.consumers.loaded,
             fixability: row.fixability,
             severity: severityOf(input, finding.code, row.defaultSeverity),

package/dist/src/findings/emitters.js

@@ -7,7 +7,7 @@ import { intraFunction } from "./intra-function.js";
 import { nonCodeArtifacts } from "./non-code-artifacts.js";
 import { readsAndWrites } from "./reads-and-writes.js";
 import { selfCheck } from "./self-check.js";
-import { unusedDeclarations } from "./unused-declarations.js";
+import { fallenMembers, unusedDeclarations } from "./unused-declarations.js";
 import { visibilityNarrowing } from "./visibility-narrowing.js";
 /** Every kind family this analyzer reports, each by its emitter, in code order. */
 export const EMITTERS = new Map([
@@ -20,9 +20,9 @@ export const EMITTERS = new Map([
     ["self-check", selfCheck],
     ["intra-function", intraFunction],
 ]);
-/** Every family's findings over one sweep, completed by one step. */
-function completedOver(input) {
-    return completed(input, [...EMITTERS.values()].flatMap((emit) => emit(input)));
+/** Every family's findings over one sweep, and those of any further emitter, completed by one step. */
+function completedOver(input, ...more) {
+    return completed(input, [...EMITTERS.values(), ...more].flatMap((emit) => emit(input)));
 }
 /**
  * The dials over the findings a record could name, each read against the sweep that
@@ -47,7 +47,7 @@ function dialsOver(input, found, suppressed, unmarked) {
  */
 export function decidedFindings(input, suppressed = { unmarked: input, records: [] }) {
     const found = completedOver(input);
-    const unmarked = suppressed.records.length === 0 ? [] : completedOver(suppressed.unmarked);
+    const unmarked = suppressed.records.length === 0 ? [] : completedOver(suppressed.unmarked, fallenMembers);
     const would = [...unmarked, ...found];
     const ledger = ledgerOf(suppressed.records, would, dialsOver(input, found, suppressed, unmarked));
     const kept = reportable(input, found.filter((finding) => !ledger.withheld(finding)));

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

@@ -1,2 +1,91 @@
-/** The findings of the intra-function family, `DS1800` to `DS1899`. */
-export const intraFunction = () => [];
+import { KINDS } from "../kinds.js";
+import { UNUSED_PARAMETER, UNUSED_RESULT } from "../intra-function-parts.js";
+/** A list of rules as a sentence names them. */
+function spelled(rules) {
+    if (rules.length < 2) {
+        return rules.join("");
+    }
+    return `${rules.slice(0, -1).join(", ")} and ${rules.at(-1) ?? ""}`;
+}
+/** The clause a message ends with: the other rules that report the kind, or that none is known. */
+function overlapClause(overlap) {
+    return overlap.length === 1 && overlap[0] === "none known"
+        ? "no other rule is known to report it"
+        : `also reported by ${spelled(overlap)}`;
+}
+/**
+ * Whether one part is reported. A parameter needs its function's signature free to
+ * change; a result needs that, every call in the loaded program to discard it, and every
+ * call site to be in the loaded program, so a function with a root or one a module
+ * exports to callers the run cannot see has no result to report. Every other part is
+ * reported wherever no project found it in use.
+ */
+function reported(input, part, callersUnknown) {
+    if (part.used) {
+        return false;
+    }
+    const { free, discardedEverywhere } = input.intraFunction;
+    switch (part.code) {
+        case UNUSED_PARAMETER:
+            return free.has(part.declaration);
+        case UNUSED_RESULT:
+            return (free.has(part.declaration) &&
+                discardedEverywhere.has(part.declaration) &&
+                !callersUnknown.has(part.declaration));
+        default:
+            return true;
+    }
+}
+/**
+ * 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.
+ */
+export const intraFunction = (input) => {
+    const union = input.swept.matrix.union;
+    const byId = new Map(union.symbols.map((symbol) => [symbol.id, symbol]));
+    const unknown = new Set(union.rooted.flatMap((root) => {
+        const symbol = union.symbols[root.at];
+        return symbol === undefined ? [] : [symbol.id];
+    }));
+    const { declared, loaded } = input.boundary.consumers;
+    const closed = input.config.consumersComplete && declared.every((id) => loaded.includes(id));
+    const published = (id) => {
+        const symbol = byId.get(id);
+        return (symbol !== undefined &&
+            symbol.kind !== "file" &&
+            (symbol.exported || published(symbol.parent)));
+    };
+    if (!closed) {
+        for (const part of input.intraFunction.parts) {
+            if (published(part.declaration)) {
+                unknown.add(part.declaration);
+            }
+        }
+    }
+    const found = [];
+    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)) {
+            continue;
+        }
+        found.push({
+            code: part.code,
+            position: part.position,
+            symbol: {
+                ref: declaration.ref,
+                kind: part.kind,
+                name: part.name,
+                sizeLines: part.position.endLine - part.position.line + 1,
+            },
+            message: `${part.message}; ${overlapClause(overlap)}`,
+            details: {
+                ...(part.kind === "store" ? { writePositions: [part.position] } : {}),
+                overlap,
+            },
+        });
+    }
+    return found;
+};

package/dist/src/findings/self-check.js

@@ -2,6 +2,10 @@ import { REPOSITORY_DOCUMENT } from "../config.js";
 import { STALE_SUPPRESSION, SUPPRESSION_WITHOUT_REASON, } from "../suppress.js";
 /** The code a configured root that matches nothing is reported under. */
 const UNMATCHED_ROOT = "DS1704";
+/** The code a configured declaration that names nothing is reported under. */
+const UNMATCHED_DECLARATION = "DS1706";
+/** The subject kind of a finding about a configured declaration. */
+const DECLARATION_SUBJECT = "configured-declaration";
 /** The subject kind of a finding about a suppression record. */
 const SUPPRESSION_SUBJECT = "suppression";
 /** The subject kind of a finding about a configured root. */
@@ -13,6 +17,7 @@ export const NO_SELF_CHECK = {
     refusals: [],
     unmatchedRoots: [],
     rootsDocument: "",
+    unmatchedDeclarations: [],
 };
 /** The words a message names a mechanism by. */
 const WRITTEN = {
@@ -104,6 +109,27 @@ export function staleSuppressions(stale, files) {
         };
     });
 }
+/** The first position of the document that configured a setting, or of the conventional one. */
+function documentPosition(document) {
+    return {
+        path: document === "" ? REPOSITORY_DOCUMENT : document,
+        line: DOCUMENT_POSITION,
+        column: DOCUMENT_POSITION,
+        endLine: DOCUMENT_POSITION,
+    };
+}
+/**
+ * One finding per configured declaration that named no declaration in any project, at the
+ * first position of the document that configured its key, as a configured root's is.
+ */
+function unmatchedDeclarationFindings(unmatched) {
+    return unmatched.map((one) => ({
+        code: UNMATCHED_DECLARATION,
+        position: documentPosition(one.document),
+        symbol: { ref: one.ref, kind: DECLARATION_SUBJECT, name: one.ref, sizeLines: 1 },
+        message: `${one.key} entry names no declaration in any project`,
+    }));
+}
 /**
  * One finding per configured root or pattern that named nothing in any project. A finding
  * names the document that declared the roots, or the conventional repository configuration
@@ -112,12 +138,7 @@ export function staleSuppressions(stale, files) {
  * own, so the string each finding names tells one from another.
  */
 export function unmatchedRootFindings(sources, document) {
-    const position = {
-        path: document === "" ? REPOSITORY_DOCUMENT : document,
-        line: DOCUMENT_POSITION,
-        column: DOCUMENT_POSITION,
-        endLine: DOCUMENT_POSITION,
-    };
+    const position = documentPosition(document);
     return sources.map((source) => ({
         code: UNMATCHED_ROOT,
         position,
@@ -129,11 +150,13 @@ export function unmatchedRootFindings(sources, document) {
 }
 /**
  * The findings of the self-check family, `DS1700` to `DS1799`: a suppression refused for
- * carrying no reason or naming no path, and a configured root that named nothing. A
+ * carrying no reason or naming no path, and a configured root or declaration that named
+ * nothing. A
  * suppression that matched nothing is a record of the report's stale suppressions, which
  * {@link staleSuppressions} builds, and a stale cross-language edge is the merge's to report.
  */
 export const selfCheck = ({ selfCheck: facts, swept }) => [
     ...refusedSuppressions(facts.refusals, fileRefsOf(swept.matrix.union.symbols)),
     ...unmatchedRootFindings(facts.unmatchedRoots, facts.rootsDocument),
+    ...unmatchedDeclarationFindings(facts.unmatchedDeclarations),
 ];