@cplieger/deadset-ts 3.12.1 → 3.13.0

package/src/analysis.ts

@@ -16,6 +16,11 @@ import {
   moduleIdentity,
   type LoadedConsumer,
 } from "./consumers.ts";
+import {
+  configuredDeclarations,
+  configuredRef,
+  declarationsNamed,
+} from "./configured-declarations.ts";
 import { decorator } from "./decorator.ts";
 import { dependenciesOf, projectNeeds } from "./dependencies.ts";
 import { deprecatedDeclarations } from "./deprecation.ts";
@@ -33,7 +38,7 @@ import {
 import type { TSExemptionClass } from "./exempt-classes.ts";
 import { heldByInclusion, sourceTree } from "./file-facts.ts";
 import type { Finding } from "./finding.ts";
-import { findingsPass, type PassResult } from "./findings-pass.ts";
+import { findingsPass, recordedFindings, rowKey, type PassResult } from "./findings-pass.ts";
 import type { EmitterInput } from "./findings/emitter.ts";
 import {
   NO_SELF_CHECK,
@@ -45,7 +50,8 @@ import type { Host } from "./host.ts";
 import { implementations, mergeImplementations } from "./implementations.ts";
 import { injectionContainer } from "./injection-container.ts";
 import { interfaceSatisfaction } from "./interface-satisfaction.ts";
-import { inventory, type Inventory } from "./inventory.ts";
+import { intraFunctionFacts, projectParts, type ProjectParts } from "./intra-function-parts.ts";
+import { inventory, type Inventory, type InventorySymbol } from "./inventory.ts";
 import { readManifest } from "./manifest.ts";
 import {
   matrixOf,
@@ -64,8 +70,8 @@ import type { Scope } from "./scope.ts";
 import { serializationContract } from "./serialization-contract.ts";
 import { diagnosticsOf, runSession, type Engine, type ProjectView } from "./session.ts";
 import { accessorsOf, storesOf } from "./stores.ts";
-import type { Suppressions } from "./suppress.ts";
-import { readBaseline, readIgnoreFile } from "./suppress-file.ts";
+import { isPartKind, type SuppressionRecord, type Suppressions, type Verdict } from "./suppress.ts";
+import { bindRows, readBaseline, readIgnoreFile, type Recorded } from "./suppress-file.ts";
 import { inlineDirectives, inlineSuppressions, type InlineDirective } from "./suppress-inline.ts";
 import type { Exemption, Mode, SweepInput } from "./sweep.ts";
 import { readTemplates, templateField } from "./template-field.ts";
@@ -345,7 +351,11 @@ function readRun<Extra>(
   config: Config,
   mode: Mode,
   detectors: Detectors,
-  extra: <Brand>(project: ProjectView<Brand>, read: ProjectRead) => Extra,
+  extra: <Brand>(
+    project: ProjectView<Brand>,
+    read: ProjectRead,
+    references: readonly Reference[],
+  ) => Extra,
 ): ReadRun<Extra> {
   const targetRoot = scope.target.path;
   const disabled = disabledClasses(config);
@@ -377,7 +387,7 @@ function readRun<Extra>(
       configFile: projectRead.configFile,
       configured,
       exempt,
-      extra: extra(project, projectRead),
+      extra: extra(project, projectRead, resolved.references),
     };
   });
   const consumed = read.consumers.references;
@@ -446,6 +456,8 @@ interface EmitterExtra {
   readonly heldByInclusion: readonly string[];
   readonly rooted: Roots;
   readonly directives: readonly InlineDirective[];
+  readonly declarationsNamed: readonly boolean[];
+  readonly parts: ProjectParts;
 }
 
 /** Reads a run's projects with every per-project fact an emitter reads. */
@@ -458,7 +470,7 @@ function readEmitterRun(
   detectors: Detectors,
 ): ReadRun<EmitterExtra> {
   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),
@@ -466,6 +478,8 @@ function readEmitterRun(
     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),
   }));
 }
 
@@ -516,6 +530,11 @@ function emitterInputOver(
       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)),
+    ),
   };
 }
 
@@ -548,15 +567,25 @@ export interface AnalysisInputs {
   readonly suppressions: Suppressions;
 }
 
+/** One run read once, and analyzed under any set of baseline rows without reading it again. */
+interface AnalysisReader {
+  readonly run: RunFacts;
+  readonly configured: readonly Configured[];
+  /** The declarations of the run, which a baseline row binds against. */
+  readonly symbols: readonly InventorySymbol[];
+  /** The inputs of the run under the directives, the ignore file and the baseline given. */
+  readonly inputsUnder: (baseline: Suppressions) => AnalysisInputs;
+}
+
 /**
  * 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(
+function readAnalysis(
   engine: Engine,
   host: Host,
   scope: Scope,
@@ -564,40 +593,17 @@ function runAnalysisInputs(
   provenance: Provenance,
   mode: Mode,
   detectors: Detectors,
-): {
-  readonly inputs: AnalysisInputs;
-  readonly run: RunFacts;
-  readonly configured: readonly Configured[];
-} {
+): AnalysisReader {
   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: Suppressions = {
-    records: documents.flatMap((one) => one.records),
-    refusals: documents.flatMap((one) => one.refusals),
-  };
-  const facts: SelfCheckFacts = {
-    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: Suppressions): AnalysisInputs =>
+    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,
@@ -610,6 +616,52 @@ function runAnalysisInputs(
       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: Host,
+  scope: Scope,
+  config: Config,
+  provenance: Provenance,
+  mode: Mode,
+  read: ReadRun<EmitterExtra>,
+  documents: readonly Suppressions[],
+): AnalysisInputs {
+  const targetRoot = scope.target.path;
+  const suppressions: Suppressions = {
+    records: documents.flatMap((one) => one.records),
+    refusals: documents.flatMap((one) => one.refusals),
+  };
+  const facts: SelfCheckFacts = {
+    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,
   };
 }
 
@@ -655,14 +707,81 @@ export function runAnalysis(
   mode: Mode,
   detectors: Detectors = DETECTORS,
 ): RunAnalysis {
-  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: AnalysisReader, inputs: AnalysisInputs): RunAnalysis {
+  return {
+    result: findingsPass(inputs),
+    run: reader.run,
+    swept: inputs.marked.swept,
+    configured: reader.configured,
+  };
+}
+
+/** A baseline write: the analysis of its first round, and the rows its fixpoint holds. */
+interface BaselineWrite {
+  /** The first round, which reads no baseline. */
+  readonly first: RunAnalysis;
+  /** The rows that remain when a round records no row and removes none, in recording order. */
+  readonly rows: readonly Recorded[];
+}
+
+/**
+ * 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: Engine,
+  host: Host,
+  scope: Scope,
+  config: Config,
+  provenance: Provenance,
+  mode: Mode,
+  reason: string,
+  detectors: Detectors = DETECTORS,
+): BaselineWrite {
+  const reader = readAnalysis(engine, host, scope, config, provenance, mode, detectors);
+  const first = analysisOf(reader, reader.inputsUnder({ records: [], refusals: [] }));
+  let rows: readonly Recorded[] = [];
+  const removed = new Set<string>();
+  let result = first.result;
+  let stale: ReadonlySet<string> = new Set<string>();
+  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: readonly SuppressionRecord[],
+  verdicts: readonly Verdict[],
+): ReadonlySet<string> {
+  const live = new Set<string>();
+  const stale = new Set<string>();
+  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/src/components.ts

@@ -132,7 +132,8 @@ function linesSpanned(symbols: readonly (InventorySymbol | undefined)[]): number
 }
 
 /**
- * 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
@@ -145,7 +146,8 @@ function deadSubgraph(
 ): { readonly at: readonly number[]; readonly adjacent: readonly (readonly number[])[] } {
   const at: number[] = [];
   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/src/configured-declarations.ts

@@ -23,7 +23,7 @@ import {
 } from "@typescript/native/unstable/sync";
 import type { AliasChains } from "./alias-chain.ts";
 import { resolvedTargets } from "./calls.ts";
-import type { DeclarationEntry } from "./config.ts";
+import type { Config, DeclarationEntry } from "./config.ts";
 import type { Inventory } from "./inventory.ts";
 import { nameComponent } from "./ref.ts";
 import type { ProjectView } from "./session.ts";
@@ -306,3 +306,59 @@ export function spelledEntry(entry: DeclarationEntry, held: Inventory): string {
       return entry.global;
   }
 }
+
+/** One entry of a configuration key that names a declaration, and the key's dotted path. */
+interface ConfiguredDeclaration {
+  readonly key: string;
+  readonly entry: DeclarationEntry;
+}
+
+/** 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: Config): readonly ConfiguredDeclaration[] {
+  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<Brand>(
+  project: ProjectView<Brand>,
+  held: Inventory,
+  configured: readonly ConfiguredDeclaration[],
+): readonly boolean[] {
+  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: DeclarationEntry): string {
+  switch (entry.shape) {
+    case "symbol":
+      return entry.symbol;
+    case "module":
+      return `${entry.module}#${entry.name}`;
+    case "global":
+      return `#${entry.global}`;
+  }
+}

package/src/conformance-record.ts

@@ -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/src/edges.ts

@@ -13,6 +13,7 @@ import type { InventorySymbol } from "./inventory.ts";
 import { positionAt, walkDocument } from "./json-document.ts";
 import { joinPath } from "./paths.ts";
 import { positionKey } from "./position.ts";
+import { isPartSubject } from "./suppress.ts";
 
 /** The name and the location the Contract fixes for the edges document. */
 export const EDGES_FILE = "deadset-edges.json";
@@ -219,7 +220,9 @@ export function evaluateEdges<F extends Finding>(
   }
   const held = new Map<string, number>();
   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<number>();

package/src/finding.ts

@@ -55,7 +55,7 @@ export interface FindingDetails {
   readonly narrowerVisibility?: "file" | "package";
   /** On `DS1201` and `DS1203`: the classes implementing the interface, in site order. */
   readonly implementations?: readonly PositionedSymbol[];
-  /** On `DS1301`: every position the subject is written at, in site order. */
+  /** On `DS1301` and `DS1807`: every position the subject is written at, in site order. */
   readonly writePositions?: readonly FindingPosition[];
   /** On `DS1601`: the manifest section that declares the dependency. */
   readonly dependencyClass?: DependencySection;
@@ -63,6 +63,8 @@ export interface FindingDetails {
   readonly mechanism?: Mechanism;
   /** On `DS1701` and `DS1702`: the refused suppression as written, a member absent where it lacks one. */
   readonly entry?: SuppressionEntry;
+  /** On the intra-function kinds: the external rules that report the same kind, as the vocabulary lists them. */
+  readonly overlap?: readonly string[];
 }
 
 /** One suppression in the four-member form the ignore file and the baseline share. */
@@ -91,6 +93,8 @@ export interface FindingComponent {
   /** The number of the component's members. */
   readonly symbolCount: number;
   readonly deletableLines: number;
+  /** Every member, the subject included, where the run lists a component in full. */
+  readonly members?: readonly PositionedSymbol[];
 }
 
 /** One finding with every member the finding schema requires. */

package/src/findings/completion.ts

@@ -6,12 +6,13 @@
 
 import type { RunSweep } from "../analysis.ts";
 import { componentId, type Component } from "../components.ts";
-import type { Confidence, Severity } from "../config.ts";
-import type { CompletedFinding, Finding, FindingComponent } from "../finding.ts";
+import type { Cascade, Confidence, Severity } from "../config.ts";
+import type { CompletedFinding, Finding, FindingComponent, PositionedSymbol } from "../finding.ts";
 import { OUTSIDE } from "../graph.ts";
 import { KINDS, type KindRow } from "../kinds.ts";
+import { byPosition } from "../position.ts";
 import { FAMILY_KEY_LENGTH } from "../resolve.ts";
-import { isRowSubject, type Dials } from "../suppress.ts";
+import { isPartSubject, isRowSubject, type Dials } from "../suppress.ts";
 import type { Boundary } from "./boundary.ts";
 import type { EmitterInput } from "./emitter.ts";
 
@@ -83,14 +84,42 @@ function reachabilityClasses(input: EmitterInput): (id: string) => Confidence {
   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: RunSweep): (id: string) => FindingComponent | undefined {
+/**
+ * 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: RunSweep,
+  cascade: Cascade,
+): (id: string) => FindingComponent | undefined {
   const held = new Map<string, Component>();
   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): readonly PositionedSymbol[] =>
+    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
@@ -100,6 +129,7 @@ function findingComponents(swept: RunSweep): (id: string) => FindingComponent |
           root: component.roots.includes(id),
           symbolCount: component.members.length,
           deletableLines: component.deletableLines,
+          ...(cascade === "full" ? { members: listed(component) } : {}),
         };
   };
 }
@@ -123,7 +153,7 @@ export function completed(
   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): CompletedFinding => {
@@ -136,11 +166,15 @@ export function completed(
     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;
@@ -173,7 +207,9 @@ export function completed(
       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/src/findings/emitter.ts

@@ -4,6 +4,7 @@ import type { Dependencies } from "../dependencies.ts";
 import type { FileFacts } from "../file-facts.ts";
 import type { Finding } from "../finding.ts";
 import type { Implementations } from "../implementations.ts";
+import type { IntraFunctionFacts } from "../intra-function-parts.ts";
 import type { Stores } from "../stores.ts";
 import type { Boundary } from "./boundary.ts";
 import type { SelfCheckFacts } from "./self-check.ts";
@@ -30,6 +31,8 @@ export interface EmitterInput {
   readonly boundary: Boundary;
   /** The run's suppression outcomes and configured roots, which the self-check family reports. */
   readonly selfCheck: SelfCheckFacts;
+  /** The parts of the run's declarations, which the intra-function family reports. */
+  readonly intraFunction: IntraFunctionFacts;
 }
 
 /**

package/src/findings/emitters.ts

@@ -9,7 +9,7 @@ import { intraFunction } from "./intra-function.ts";
 import { nonCodeArtifacts } from "./non-code-artifacts.ts";
 import { readsAndWrites } from "./reads-and-writes.ts";
 import { selfCheck } from "./self-check.ts";
-import { unusedDeclarations } from "./unused-declarations.ts";
+import { fallenMembers, unusedDeclarations } from "./unused-declarations.ts";
 import { visibilityNarrowing } from "./visibility-narrowing.ts";
 
 /** Every kind family this analyzer reports, each by its emitter, in code order. */
@@ -44,11 +44,14 @@ export interface DecidedFindings {
   readonly would: readonly CompletedFinding[];
 }
 
-/** Every family's findings over one sweep, completed by one step. */
-function completedOver(input: EmitterInput): readonly CompletedFinding[] {
+/** Every family's findings over one sweep, and those of any further emitter, completed by one step. */
+function completedOver(
+  input: EmitterInput,
+  ...more: readonly Emitter[]
+): readonly CompletedFinding[] {
   return completed(
     input,
-    [...EMITTERS.values()].flatMap((emit) => emit(input)),
+    [...EMITTERS.values(), ...more].flatMap((emit) => emit(input)),
   );
 }
 
@@ -85,7 +88,8 @@ export function decidedFindings(
   suppressed: Suppressed = { unmarked: input, records: [] },
 ): DecidedFindings {
   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(