@cplieger/deadset-ts 5.1.0 → 5.2.0

package/src/conventions.ts

@@ -7,6 +7,7 @@
  */
 
 import {
+  isArrayLiteralExpression,
   isAsExpression,
   isBinaryExpression,
   isCallExpression,
@@ -50,6 +51,7 @@ import {
   type ConventionRow,
   type DirectoryMove,
   type OptionsCall,
+  type ShortNameReading,
 } from "./convention-rows.ts";
 import { globExpression } from "./glob.ts";
 import type { Host } from "./host.ts";
@@ -106,6 +108,8 @@ export interface Conventions {
   readonly globs: readonly ConventionGlob[];
   readonly generated: readonly GeneratedDirectory[];
   readonly failures: readonly ConventionFailure[];
+  /** The dependencies the applied rows' short names use, by name, each once. */
+  readonly uses: readonly string[];
 }
 
 /** One file a row roots. */
@@ -445,6 +449,28 @@ function objectOf(
   return at;
 }
 
+/** The text of a string literal or a template literal with no substitution, or undefined. */
+function literalText(node: Node): string | undefined {
+  const at = unwrapped(node);
+  return isStringLiteral(at) || isNoSubstitutionTemplateLiteral(at) ? at.text : undefined;
+}
+
+/**
+ * The literal texts one value at a path's end writes: the literal itself, or, where
+ * `elements`, each element of an array literal of literals. Undefined for any other value.
+ */
+function literalTexts(held: Node, elements: boolean): readonly string[] | undefined {
+  const one = literalText(held);
+  if (one !== undefined) {
+    return [one];
+  }
+  if (!elements || !isArrayLiteralExpression(held)) {
+    return undefined;
+  }
+  const texts = held.elements.map(literalText);
+  return texts.every((text) => text !== undefined) ? texts : undefined;
+}
+
 /**
  * Reads the values at one path of keys below one object literal into `values`, and
  * answers the first member that does not write its value out: a spread, a value that is
@@ -454,6 +480,7 @@ function readPath(
   object: ObjectLiteralExpression,
   keys: readonly string[],
   values: string[],
+  elements: boolean,
 ): Node | undefined {
   const [key, ...rest] = keys;
   for (const member of object.properties) {
@@ -465,15 +492,16 @@ function readPath(
     }
     const held = isPropertyAssignment(member) ? unwrapped(member.initializer) : undefined;
     if (rest.length === 0) {
-      if (held === undefined || !(isStringLiteral(held) || isNoSubstitutionTemplateLiteral(held))) {
+      const texts = held === undefined ? undefined : literalTexts(held, elements);
+      if (texts === undefined) {
         return member;
       }
-      values.push(held.text);
+      values.push(...texts);
     } else {
       if (held === undefined || !isObjectLiteralExpression(held)) {
         return member;
       }
-      const failed = readPath(held, rest, values);
+      const failed = readPath(held, rest, values, elements);
       if (failed !== undefined) {
         return failed;
       }
@@ -493,14 +521,16 @@ interface PropertyReading {
 /**
  * Every value one file writes at one property's path inside the object it is read from:
  * the options argument of every call `call` names, or the file's default export. A string
- * literal or a template literal with no substitution is the value. A read object, or an
- * object along the path, that is not written out as an object literal, or that spreads
- * another object into itself, is not a literal, and neither is any other value at the path.
+ * literal or a template literal with no substitution is the value, and so is each element
+ * of an array literal of them where `elements`. A read object, or an object along the
+ * path, that is not written out as an object literal, or that spreads another object into
+ * itself, is not a literal, and neither is any other value at the path.
  */
 export function readProperty(
   file: SourceFile,
   property: string,
   call?: OptionsCall,
+  elements = false,
 ): PropertyReading {
   const declared = declaredValues(file);
   const objects =
@@ -515,7 +545,7 @@ export function readProperty(
       continue;
     }
     const notLiteral = isObjectLiteralExpression(object)
-      ? readPath(object, property.split("."), values)
+      ? readPath(object, property.split("."), values, elements)
       : object;
     if (notLiteral !== undefined) {
       return { values, notLiteral };
@@ -585,29 +615,19 @@ function resolveMove(
 ): MoveResult {
   const set: string[] = [];
   for (const reading of move.readings) {
-    for (const glob of reading.files) {
-      for (const name of configurationFiles(host, dir, glob)) {
-        const path = joinPath(dir, name);
-        let text: string;
-        try {
-          text = host.readFile(path);
-        } catch {
-          continue;
-        }
-        const file = parse(path, text);
-        const read = readProperty(file, reading.property, reading.call);
-        if (read.notLiteral !== undefined) {
-          const line = lineOf(text, read.notLiteral.getStart());
-          return {
-            failure:
-              `${name}:${String(line)} sets ${reading.property}, which moves a directory ` +
-              `the convention row ${row.name} reads, to a value that is not a string literal: ` +
-              `write it as a literal, or name ${row.name} in ts.disabled_conventions and its ` +
-              `files in ts.entry_files`,
-          };
-        }
-        set.push(...read.values);
+    for (const { name, text, file } of readingFiles(host, parse, dir, reading.files)) {
+      const read = readProperty(file, reading.property, reading.call);
+      if (read.notLiteral !== undefined) {
+        const line = lineOf(text, read.notLiteral.getStart());
+        return {
+          failure:
+            `${name}:${String(line)} sets ${reading.property}, which moves a directory ` +
+            `the convention row ${row.name} reads, to a value that is not a string literal: ` +
+            `write it as a literal, or name ${row.name} in ts.disabled_conventions and its ` +
+            `files in ts.entry_files`,
+        };
       }
+      set.push(...read.values);
     }
   }
   const dirs: (string | undefined)[] = [];
@@ -621,6 +641,71 @@ function resolveMove(
   return { dirs: [...new Set(dirs)] };
 }
 
+/** The texts each configuration file a reading names holds, parsed, in name order. */
+function readingFiles(
+  host: Host,
+  parse: ParseSource,
+  dir: string,
+  files: readonly string[],
+): readonly { readonly name: string; readonly text: string; readonly file: SourceFile }[] {
+  const found = [];
+  for (const glob of files) {
+    for (const name of configurationFiles(host, dir, glob)) {
+      const path = joinPath(dir, name);
+      let text: string;
+      try {
+        text = host.readFile(path);
+      } catch {
+        continue;
+      }
+      found.push({ name, text, file: parse(path, text) });
+    }
+  }
+  return found;
+}
+
+/**
+ * The dependencies one manifest declares that an applied row's short names use: the
+ * package each literal value stands for, and, for a value that is not a literal, every
+ * declared dependency the row's package name stands for with some value.
+ */
+function shortNameUses(
+  host: Host,
+  parse: ParseSource,
+  dir: string,
+  manifest: unknown,
+  readings: readonly ShortNameReading[],
+): readonly string[] {
+  const declared = new Set(
+    DEPENDENCY_SECTIONS.flatMap((section) => {
+      const held = isRecord(manifest) ? manifest[section] : undefined;
+      return isRecord(held) ? Object.keys(held) : [];
+    }),
+  );
+  const used = new Set<string>();
+  for (const reading of readings) {
+    const [before = "", after = ""] = reading.package.split("{}");
+    for (const { file } of readingFiles(host, parse, dir, reading.files)) {
+      const read = readProperty(file, reading.property, reading.call, true);
+      for (const value of read.values) {
+        used.add(`${before}${value}${after}`);
+      }
+      if (read.notLiteral !== undefined) {
+        for (const name of declared) {
+          if (
+            name.length >= before.length + after.length &&
+            name.startsWith(before) &&
+            name.endsWith(after)
+          ) {
+            used.add(name);
+          }
+        }
+      }
+    }
+  }
+  return [...used].filter((name) => declared.has(name)).sort(compare);
+}
+
 /** Two strings ordered bytewise. */
 function compare(a: string, b: string): number {
   if (a === b) {
@@ -644,6 +729,7 @@ export function readConventions(
   const globs: ConventionGlob[] = [];
   const generated: GeneratedDirectory[] = [];
   const failures: ConventionFailure[] = [];
+  const uses = new Set<string>();
   for (const manifest of manifests) {
     const declared = readJSON(host, joinPath(manifest.dir, "package.json"));
     const versions = new Map<string, string | undefined>();
@@ -702,6 +788,9 @@ export function readConventions(
         version,
         manifest: manifest.path,
       });
+      for (const name of shortNameUses(host, parse, manifest.dir, declared, row.shortNames ?? [])) {
+        uses.add(name);
+      }
       const excludes = [
         ...new Set((row.excludes ?? []).flatMap((one) => expand(one, resolved))),
       ].map(globExpression);
@@ -725,7 +814,7 @@ export function readConventions(
       compare(a.manifest, b.manifest) ||
       compare(JSON.stringify(a), JSON.stringify(b)),
   );
-  return { applied: unique, globs, generated, failures };
+  return { applied: unique, globs, generated, failures, uses: [...uses].sort(compare) };
 }
 
 /**

package/src/dependencies.ts

@@ -61,6 +61,15 @@ export interface DeclaredDependency {
   readonly position: FindingPosition;
 }
 
+/** What a configuration's own reading needs: packages no deletion of a declaration removes. */
+export function configurationNeeds(packages: readonly string[]): ProjectNeeds {
+  return {
+    packages: new Set(packages),
+    uses: new Map([[PROJECT_OWNER, new Set(packages)]]),
+    unanswered: false,
+  };
+}
+
 /** What the installed copy of one declared dependency states about itself. */
 export interface InstalledDependency {
   /** Whether its manifest declares a command. */

package/src/entry-point-gaps.ts

@@ -26,10 +26,10 @@ const UNREAD =
   "file only it loads is reported as never imported unless ts.entry_files or roots.patterns " +
   "names it.";
 
-/** Why a configuration's file names that are not relative literals are declined. */
-const NOT_RELATIVE =
-  "A string of a configuration file names a file only where it is a literal starting with ./ " +
-  "or ../, so a file named otherwise is reported as never imported.";
+/** Why a configuration's file names that are not literals are declined. */
+const NOT_LITERAL =
+  "A string of a configuration file names a file only where it is a literal, so a file a " +
+  "computed value names is reported as never imported.";
 
 /** The tools whose own conventions are not read. */
 const UNREAD_TOOLS: readonly string[] = [
@@ -230,11 +230,6 @@ const PARTLY_ENTERED: readonly DeclinedConvention[] = [
       "A testMatch that is not a string literal leaves the test-file set unknown, and an " +
       "unknown set enters nothing.",
   },
-  {
-    tool: "playwright",
-    convention: "a globalSetup or globalTeardown file named without a leading ./ or ../",
-    reason: NOT_RELATIVE,
-  },
   {
     tool: "playwright",
     convention: "the testDir and testMatch of an entry in projects",
@@ -300,22 +295,15 @@ const PARTLY_ENTERED: readonly DeclinedConvention[] = [
   },
   {
     tool: "vite",
-    convention: "an entry point its configuration names without a leading ./ or ../, or computes",
-    reason: NOT_RELATIVE,
-  },
-  {
-    tool: "vite",
-    convention: "the module scripts an index.html loads",
-    reason:
-      "No rule reads an HTML file, so a script only index.html loads is reported as never " +
-      "imported unless ts.entry_files names it.",
+    convention: "an entry point its configuration computes",
+    reason: NOT_LITERAL,
   },
   {
     tool: "vitest",
-    convention: "the benchmark and type-test files",
+    convention: "the benchmark files",
     reason:
-      "A test file is one ts.test_files classifies, so a *.bench.* or *.test-d.* file is " +
-      "entered only where a configured pattern names it.",
+      "A test file is one ts.test_files classifies, so a *.bench.* file is entered only " +
+      "where a configured pattern names it.",
   },
   {
     tool: "vitest",
@@ -324,11 +312,6 @@ const PARTLY_ENTERED: readonly DeclinedConvention[] = [
       "A string is read against the configuration file's directory, so a setup file named " +
       "against a root the configuration moves is not entered.",
   },
-  {
-    tool: "vitest",
-    convention: "a setup file named without a leading ./ or ../",
-    reason: NOT_RELATIVE,
-  },
   {
     tool: "vitest",
     convention: "the test files a configuration's include member names",
@@ -338,8 +321,8 @@ const PARTLY_ENTERED: readonly DeclinedConvention[] = [
   },
   {
     tool: "webpack",
-    convention: "an entry point its configuration names without a leading ./ or ../, or computes",
-    reason: NOT_RELATIVE,
+    convention: "an entry point its configuration computes",
+    reason: NOT_LITERAL,
   },
 ];
 

package/src/entry-points.ts

@@ -38,6 +38,7 @@ import {
 } from "./configuration-files.ts";
 import { globExpression } from "./glob.ts";
 import type { Host } from "./host.ts";
+import { htmlEntries } from "./html-entries.ts";
 import { dirnamePath, relativePath, resolvePath } from "./paths.ts";
 import { UNANSWERED } from "./query.ts";
 import type { ProjectView } from "./session.ts";
@@ -56,7 +57,9 @@ export type EntryRule =
   /** The test files below the browser-test runner's test directory. */
   | "browser-tests"
   /** A worker or service worker a call addresses by a string literal. */
-  | "worker";
+  | "worker"
+  /** A file a module script of an HTML file below the target root loads. */
+  | "html-entry";
 
 /** One file a rule enters. */
 export interface EntryPoint {
@@ -542,5 +545,8 @@ export function entryPoints<Brand>(
     }
     found.push(...workersOf(project, file, files));
   }
+  for (const { file, source } of htmlEntries(host, targetRoot, files, parse)) {
+    found.push({ file, rule: "html-entry", source, exports: true });
+  }
   return found;
 }

package/src/exempt.ts

@@ -48,10 +48,7 @@ export interface DetectorInput<Brand> {
   readonly ts: TSSection;
   /** The absolute path of each declared consumer, whose modules are part of the analysis. */
   readonly consumers: readonly string[];
-  /**
-   * The project's generated files, by path below the target root, each with the
-   * convention row that names its directory as generated.
-   */
+  /** The project's generated files, by path below the target root, each with the detail its retentions name. */
   readonly generated?: ReadonlyMap<string, string>;
 }
 
@@ -187,12 +184,23 @@ export function detectExemptions<Brand>(
   detectors: Detectors,
   holding: Holding,
 ): Detected {
+  return heldRecords(evidenceRecords(input, detectors, holding.disabled), holding);
+}
+
+/**
+ * Every record one project's detectors found, one per piece of evidence, before the
+ * mode decides which of them hold: what {@link heldRecords} reads.
+ */
+export function evidenceRecords<Brand>(
+  input: DetectorInput<Brand>,
+  detectors: Detectors,
+  disabled: ReadonlySet<ExemptionClass>,
+): readonly Exemption[] {
   const visibility = new Map(input.held.symbols.map((symbol) => [symbol.id, symbol.visibility]));
   const found: Exemption[] = [];
-  const inTestFiles: Exemption[] = [];
   for (const exemptionClass of TS_EXEMPTION_CLASSES) {
     const detect = detectors.get(exemptionClass);
-    if (detect === undefined || holding.disabled.has(exemptionClass)) {
+    if (detect === undefined || disabled.has(exemptionClass)) {
       continue;
     }
     const allowed = typescriptVisibilityOf(exemptionClass);
@@ -200,17 +208,26 @@ export function detectExemptions<Brand>(
       if (!retainable(allowed, visibility.get(evidence.id))) {
         continue;
       }
-      const record = {
+      found.push({
         id: evidence.id,
         class: exemptionClass,
         detail: evidence.detail,
         site: evidence.site,
         ...(evidence.whileLive === undefined ? {} : { whileLive: evidence.whileLive }),
-      };
-      if (holding.mode.production && holding.testFiles.has(evidence.site.path)) {
-        inTestFiles.push(record);
-        continue;
-      }
+      });
+    }
+  }
+  return found;
+}
+
+/** The records that hold under one mode, beside the evidence a production mode found in a test file. */
+export function heldRecords(records: readonly Exemption[], holding: Holding): Detected {
+  const found: Exemption[] = [];
+  const inTestFiles: Exemption[] = [];
+  for (const record of records) {
+    if (holding.mode.production && holding.testFiles.has(record.site.path)) {
+      inTestFiles.push(record);
+    } else {
       found.push(record);
     }
   }

package/src/file-facts.ts

@@ -47,7 +47,7 @@ export interface FileFacts {
    * reference names is included by the file that names it.
    */
   readonly heldByInclusion: ReadonlySet<string>;
-  /** The paths below the target root of the files below a directory an applied row names as generated. */
+  /** The paths below the target root of the generated files. */
   readonly generated?: ReadonlySet<string>;
 }
 
@@ -65,13 +65,11 @@ function lastLine(text: string): number {
 }
 
 /**
- * Every source file below the target root, in path order. A directory that cannot be
- * read is skipped, as discovery skips it, and a file that cannot be read is skipped
- * with it: a tree the analysis may not enter holds no file it can report.
+ * The path below the target root of every source file there, in path order. A directory
+ * that cannot be read is skipped, as discovery skips it.
  */
-export function sourceTree(host: Host, targetRoot: string): readonly TreeFile[] {
-  const scopeOf = packageScope(host, targetRoot);
-  const found: TreeFile[] = [];
+export function sourcePaths(host: Host, targetRoot: string): readonly string[] {
+  const found: string[] = [];
   const pending = [""];
   for (let dir = pending.pop(); dir !== undefined; dir = pending.pop()) {
     let entries: readonly { readonly name: string; readonly directory: boolean }[];
@@ -88,23 +86,29 @@ export function sourceTree(host: Host, targetRoot: string): readonly TreeFile[]
         }
         continue;
       }
-      if (!SOURCE_FILE.test(entry.name) || DECLARATION_FILE.test(entry.name)) {
-        continue;
+      if (SOURCE_FILE.test(entry.name) && !DECLARATION_FILE.test(entry.name)) {
+        found.push(path);
       }
-      let text: string;
-      try {
-        text = host.readFile(joinPath(targetRoot, path));
-      } catch {
-        continue;
-      }
-      found.push({
-        path,
-        ref: renderRef(scopeOf(path), { of: "module" }),
-        endLine: lastLine(text),
-      });
     }
   }
-  return found.sort((a, b) => (a.path < b.path ? -1 : 1));
+  return found.sort((a, b) => (a < b ? -1 : 1));
+}
+
+/**
+ * Every source file below the target root, in path order. A file that cannot be read is
+ * skipped: a tree the analysis may not enter holds no file it can report.
+ */
+export function sourceTree(host: Host, targetRoot: string): readonly TreeFile[] {
+  const scopeOf = packageScope(host, targetRoot);
+  return sourcePaths(host, targetRoot).flatMap((path) => {
+    let text: string;
+    try {
+      text = host.readFile(joinPath(targetRoot, path));
+    } catch {
+      return [];
+    }
+    return [{ path, ref: renderRef(scopeOf(path), { of: "module" }), endLine: lastLine(text) }];
+  });
 }
 
 /** Whether one file changes what the program sees by being included in it. */

package/src/findings/completion.ts

@@ -55,16 +55,19 @@ function publishedIds(union: Graph): ReadonlySet<string> {
 
 /**
  * The reachability class of one declaration of the run. A declaration of a library's
- * published API, a public member of a published type included, has callers outside the
- * target: it is `certain` where the run loaded every consumer the scope declared and
- * declared at least one, `probable` where it declared consumers and did not load them
- * all, and `possible` where it declared none. Whether the configuration declares the
- * consumer set complete decides nothing here. Every other declaration has every reference
- * in the loaded program, a private member and a `#private` name among them, and is
- * `certain`.
+ * published API, a public member of a published type included, is `certain` where the
+ * run loaded every consumer the scope declared and declared one, `probable` where one did
+ * not load, and `possible` where it declared none, whatever the configuration says of the
+ * consumer set. A declaration of test-support code that test code references, outside the
+ * test-of-dead-code rule, is `possible`. Every other declaration is `certain`.
  */
 function reachabilityClasses(input: EmitterInput): (id: string) => Confidence {
   const published = publishedIds(input.swept.matrix.union);
+  const usedByTests = new Set(
+    input.swept.sweep.candidates
+      .filter((candidate) => candidate.heldByTests === candidate.id)
+      .map((candidate) => candidate.id),
+  );
   const { declared } = input.boundary.consumers;
   const outside: Confidence =
     declared.length === 0
@@ -72,7 +75,12 @@ function reachabilityClasses(input: EmitterInput): (id: string) => Confidence {
       : everyDeclaredLoaded(input.boundary)
         ? "certain"
         : "probable";
-  return (id) => (published.has(id) ? outside : "certain");
+  return (id) => {
+    if (usedByTests.has(id)) {
+      return "possible";
+    }
+    return published.has(id) ? outside : "certain";
+  };
 }
 
 /**
@@ -147,6 +155,12 @@ export function completed(
   const componentOf = findingComponents(swept, input.config.reporters.cascade);
   let minted = swept.sweep.components.length;
   const dead = new Set(swept.sweep.components.map((component) => component.id));
+  const fallingWith = new Map<string, number>();
+  for (const { heldByTests } of swept.sweep.candidates) {
+    if (heldByTests !== undefined) {
+      fallingWith.set(heldByTests, (fallingWith.get(heldByTests) ?? 0) + 1);
+    }
+  }
 
   const done = findings.map((finding): CompletedFinding => {
     const row = kinds.get(finding.code);
@@ -165,8 +179,14 @@ export function completed(
     const judged = !part && union.subject[at] === true ? symbol : undefined;
     const candidate = judged === undefined ? undefined : candidates.get(judged.id);
     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) {
+    // A test file's declaration is a component member only as a test of dead code, and
+    // test code keeps the test-support code it references out of every component.
+    if (
+      candidate !== undefined &&
+      found === undefined &&
+      union.test[at] !== true &&
+      candidate.heldByTests === undefined
+    ) {
       throw new Error(`${candidate.id} is judged dead and falls in no dead component`);
     }
     let component = found;
@@ -175,7 +195,7 @@ export function completed(
       component = {
         id: componentId(minted),
         root: true,
-        symbolCount: 1,
+        symbolCount: symbol?.kind === "interface" ? (fallingWith.get(symbol.id) ?? 1) : 1,
         deletableLines: 0,
       };
     }

package/src/findings/interfaces.ts

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

package/src/findings/intra-function.ts

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