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

package/src/findings/intra-function.ts

@@ -1,8 +1,8 @@
-import type { Confidence } from "../config.ts";
+import { CODE, type Confidence } from "../contract/contract.generated.ts";
 import type { Finding } from "../finding.ts";
 import { KINDS } from "../kinds.ts";
 import { parameterRef } from "../ref.ts";
-import { UNUSED_PARAMETER, UNUSED_RESULT, type PartFact } from "../intra-function-parts.ts";
+import { type PartFact } from "../intra-function-parts.ts";
 import { reachedWithTheTests } from "../sweep.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
 
@@ -42,7 +42,8 @@ type ParameterVerdict =
  * caller may pass a function used as a value more arguments than it declares, so there one
  * a read parameter follows is renamed to an underscore name, which the compilers read as
  * declared unread, and one no read parameter follows is deleted: kept where the call's
- * inference may read its annotation, at `probable` where nothing reads the annotation.
+ * inference may read its annotation, at `probable` where nothing reads the annotation or
+ * where it is a name a contextually typed object pattern binds.
  */
 function parameterVerdict(
   part: PartFact,
@@ -63,7 +64,8 @@ function parameterVerdict(
   if (place?.annotated === "steers") {
     return undefined;
   }
-  return { fix: "delete", confidence: place?.annotated === "free" ? "probable" : "certain" };
+  const unseen = place?.annotated === "free" || place?.contextualPattern === true;
+  return { fix: "delete", confidence: unseen ? "probable" : "certain" };
 }
 
 /**
@@ -83,9 +85,9 @@ function reported(
   }
   const { free, freeButValued, discardedEverywhere } = input.intraFunction;
   switch (part.code) {
-    case UNUSED_PARAMETER:
+    case CODE.unusedParameter:
       return parameterVerdict(part, free, freeButValued) !== undefined;
-    case UNUSED_RESULT:
+    case CODE.unusedResult:
       return (
         free.has(part.declaration) &&
         discardedEverywhere.has(part.declaration) &&
@@ -97,7 +99,7 @@ function reported(
 }
 
 /**
- * The findings of the intra-function family, `DS1800` to `DS1899`, each about a part of
+ * The findings of the inside-functions family, `DS1401` to `DS1406`, each about a part of
  * the declaration its reference names, at the part's own position, whatever the sweep
  * 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
@@ -125,7 +127,7 @@ export const intraFunction: Emitter = (input) => {
     }),
   );
   const { declared, loaded } = input.boundary.consumers;
-  const closed = input.config.consumersComplete && declared.every((id) => loaded.includes(id));
+  const closed = input.config.consumers.complete && declared.every((id) => loaded.includes(id));
   const published = (id: string): boolean => {
     const symbol = byId.get(id);
     return (
@@ -144,12 +146,12 @@ export const intraFunction: Emitter = (input) => {
   const found: Finding[] = [];
   for (const part of input.intraFunction.parts) {
     const declaration = byId.get(part.declaration);
-    const overlap = KINDS.get(part.code)?.overlap ?? [];
+    const overlap = KINDS.get(part.code)?.overlap?.ts ?? [];
     if (declaration === undefined || !judged(declaration.id) || !reported(input, part, unknown)) {
       continue;
     }
     const verdict =
-      part.code === UNUSED_PARAMETER
+      part.code === CODE.unusedParameter
         ? parameterVerdict(part, input.intraFunction.free, input.intraFunction.freeButValued)
         : undefined;
     const message =
@@ -160,7 +162,7 @@ export const intraFunction: Emitter = (input) => {
       code: part.code,
       position: part.position,
       symbol: {
-        ...(part.code === UNUSED_PARAMETER
+        ...(part.code === CODE.unusedParameter
           ? { ref: parameterRef(declaration.ref, part.name), holder: declaration.ref }
           : { ref: declaration.ref }),
         kind: part.kind,

package/src/findings/non-code-artifacts.ts

@@ -1,10 +1,8 @@
-import type { Config } from "../config.ts";
+import { CODE } from "../contract/contract.generated.ts";
+import type { ResolvedConfig } from "../config.ts";
 import type { Finding } from "../finding.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
 
-const FILE_NEVER_BUILT = "DS1501";
-const FILE_NEVER_IMPORTED = "DS1502";
-
 /** The subject kind of a finding about a source file, from the finding schema's vocabulary. */
 const FILE_SUBJECT = "file";
 
@@ -17,10 +15,10 @@ const FILE_START = 1;
  * completeness and listing no project declares it of a matrix the run derived, and a
  * derived matrix is never complete.
  */
-function completeMatrix(config: Config): boolean {
+function completeMatrix(config: ResolvedConfig): boolean {
   return (
-    config.analysis.matrixComplete &&
-    config.analysis.configurations.some((entry) => entry.shape === "project")
+    config.analysis.matrix.complete &&
+    config.analysis.configurations.some((entry) => "project" in entry)
   );
 }
 
@@ -57,7 +55,7 @@ function fileNeverBuilt({ config, swept, files }: EmitterInput): readonly Findin
   const message = `no project of the build matrix includes this file (${swept.matrix.configurations.join(", ")})`;
   return files.tree
     .filter((file) => !built.has(file.path))
-    .map((file) => fileFinding(FILE_NEVER_BUILT, file, message));
+    .map((file) => fileFinding(CODE.fileNeverBuilt, file, message));
 }
 
 /** The files of the run, each with whether a reference written in another file reaches it. */
@@ -152,21 +150,21 @@ function fileNeverImported(input: EmitterInput): readonly Finding[] {
       return referenced.has(symbol.position.path)
         ? {
             ...fileFinding(
-              FILE_NEVER_IMPORTED,
+              CODE.fileNeverImported,
               file,
               "only code that is itself dead imports this file, and no root names it or a declaration in it",
             ),
             unreachableOnly: true as const,
           }
         : fileFinding(
-            FILE_NEVER_IMPORTED,
+            CODE.fileNeverImported,
             file,
             "no import reaches this file and no root names it or a declaration in it",
           );
     });
 }
 
-/** The findings of the non-code-artifacts family, `DS1500` to `DS1599`. */
+/** The findings of the files family, `DS1600` to `DS1699`. */
 export const nonCodeArtifacts: Emitter = (input) => [
   ...fileNeverBuilt(input),
   ...fileNeverImported(input),

package/src/findings/reads-and-writes.ts

@@ -1,17 +1,20 @@
+import { CODE } from "../contract/contract.generated.ts";
 import type { Finding, FindingDetails, FindingPosition } from "../finding.ts";
 import type { InventorySymbol } from "../inventory.ts";
 import type { MatrixCandidate } from "../matrix.ts";
 import { positionKey } from "../position.ts";
 import { declarationKey } from "../ref.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
+import { bytewise } from "../text/compare.ts";
 
-/** The codes of this family. */
-type ReadsAndWritesCode = "DS1301" | "DS1302" | "DS1303";
+/** The codes this emitter reports. */
+type ReadsAndWritesCode =
+  typeof CODE.writeOnlySymbol | typeof CODE.unusedEnumMember | typeof CODE.unusedTypeParameter;
 
-/** The containers whose type parameters `DS1303` reports: a function and a class method. */
-const SIGNATURES: ReadonlySet<string> = new Set(["function", "method"]);
+/** The containers whose type parameters `DS1006` reports: a function, a class method and a type alias. */
+const SIGNATURES: ReadonlySet<string> = new Set(["function", "method", "type"]);
 
-/** What the family reads of one run, indexed by declaration. */
+/** What this emitter reads of one run, indexed by declaration. */
 interface Run {
   readonly input: EmitterInput;
   readonly symbols: ReadonlyMap<string, InventorySymbol>;
@@ -121,7 +124,7 @@ function writeOnlyMessage(
     : "never read";
   const cascade = [
     ...parametersOnlyNamedBy(run, namedBy, symbol).map((name) => `type parameter ${name}`),
-    ...[...held.alone].sort().map((name) => `import ${name}`),
+    ...[...held.alone].sort(bytewise).map((name) => `import ${name}`),
   ];
   const word = SUBJECT_WORDS[symbol.kind] ?? "member";
   const message = `${word} ${symbol.name} is written ${writes} and ${read}`;
@@ -185,7 +188,7 @@ function writeOnlySymbols(run: Run): readonly Finding[] {
       continue;
     }
     found.push(
-      findingAbout(symbol, "DS1301", writeOnlyMessage(run, namedBy, symbol, held), {
+      findingAbout(symbol, CODE.writeOnlySymbol, writeOnlyMessage(run, namedBy, symbol, held), {
         writePositions: held.writes,
       }),
     );
@@ -214,21 +217,22 @@ function unnamed(run: Run, kind: InventorySymbol["kind"]): readonly InventorySym
 }
 
 /**
- * `DS1302`: a member of an enum declaration that nothing names. A member an enum-group
+ * `DS1005`: a member of an enum declaration that nothing names. A member an enum-group
  * record holds back is no candidate, so a member a conversion can produce never reaches
  * this kind.
  */
 function unusedEnumMembers(run: Run): readonly Finding[] {
   return unnamed(run, "enum-member").map((symbol) =>
-    findingAbout(symbol, "DS1302", `enum member ${symbol.name} is named nowhere`),
+    findingAbout(symbol, CODE.unusedEnumMember, `enum member ${symbol.name} is named nowhere`),
   );
 }
 
 /**
- * `DS1303`: a type parameter of a function or a class method that neither the
- * declaration's signature nor its body names. A type parameter of a class, an interface,
- * a type alias or a method signature belongs to a type declaration and is never
- * reported, because a phantom parameter makes two instantiations distinct types.
+ * `DS1006`: a type parameter of a function, a class method or a type alias that neither
+ * the declaration's signature nor its body names. An alias names no type of its own, so
+ * a parameter its type never names makes no two instantiations distinct. One of a class,
+ * an interface or a method signature is never reported: a class or an interface merges
+ * only with declarations of the same parameters.
  */
 function unusedTypeParameters(run: Run): readonly Finding[] {
   return unnamed(run, "type-parameter")
@@ -236,7 +240,7 @@ function unusedTypeParameters(run: Run): readonly Finding[] {
     .map((symbol) =>
       findingAbout(
         symbol,
-        "DS1303",
+        CODE.unusedTypeParameter,
         `type parameter ${symbol.name} is named in neither its signature nor its body`,
       ),
     );
@@ -256,8 +260,8 @@ export function writeOnlyDeclarations(input: EmitterInput): ReadonlySet<string>
 }
 
 /**
- * The findings of the reads-and-writes family, `DS1300` to `DS1399`, in code order and
- * each code's in site order.
+ * The findings of the reads-and-writes kinds, `DS1301`, `DS1005` and `DS1006`, in that
+ * order and each code's in site order.
  */
 export const readsAndWrites: Emitter = (input) => {
   const run = indexed(input);

package/src/findings/self-check.ts

@@ -1,3 +1,4 @@
+import { CODE } from "../contract/contract.generated.ts";
 import { REPOSITORY_DOCUMENT } from "../config.ts";
 import type { Finding, FindingDetails, SuppressionEntry } from "../finding.ts";
 import type { InventorySymbol } from "../inventory.ts";
@@ -6,19 +7,12 @@ import type { Position } from "../position.ts";
 import {
   isDependencyCode,
   isUnsuppressibleCode,
-  STALE_SUPPRESSION,
-  SUPPRESSION_WITHOUT_REASON,
   type Mechanism,
   type Refusal,
   type SuppressionRecord,
 } from "../suppress.ts";
 import type { Emitter } from "./emitter.ts";
-
-/** 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";
+import { bytewise } from "../text/compare.ts";
 
 /** The subject kind of a finding about a configured declaration. */
 const DECLARATION_SUBJECT = "configured-declaration";
@@ -39,7 +33,7 @@ export interface StaleRecord {
   readonly reports: readonly string[];
 }
 
-/** What the self-check family reads: the run's refused suppressions and its configured roots. */
+/** What the configuration family reads: the run's refused suppressions and its configured roots. */
 export interface SelfCheckFacts {
   /** The suppressions the grammar refused with a finding, in reading order. */
   readonly refusals: readonly Refusal[];
@@ -135,7 +129,7 @@ function refusedSuppressions(refusals: readonly Refusal[], files: FileRefs): rea
       suppressionRef(refused.symbol, refused.path, files),
       refused.site,
       `${WRITTEN[refused.mechanism]} for ${refused.code} ${
-        refused.reported === SUPPRESSION_WITHOUT_REASON
+        refused.reported === CODE.suppressionWithoutReason
           ? "carries no reason"
           : "names a symbol and no path"
       }`,
@@ -146,7 +140,7 @@ function refusedSuppressions(refusals: readonly Refusal[], files: FileRefs): rea
 
 /** One stale suppression as the report's stale-suppression record carries it. */
 export interface StaleSuppression {
-  readonly code: typeof STALE_SUPPRESSION;
+  readonly code: typeof CODE.staleSuppression;
   readonly mechanism: Mechanism;
   readonly entry: {
     readonly code: string;
@@ -178,10 +172,10 @@ export function staleSuppressions(
     bySite.set(key, held);
   }
   return [...bySite.values()].map(({ first, records }) => {
-    const codes = [...new Set(records.map((one) => one.record.code))].sort();
+    const codes = [...new Set(records.map((one) => one.record.code))].sort(bytewise);
     const reports = [...new Set(records.flatMap((one) => one.reports))]
       .filter((code) => !codes.includes(code))
-      .sort();
+      .sort(bytewise);
     const rows = codes.filter(isUnsuppressibleCode);
     const dependencies = first.mechanism === "inline" ? codes.filter(isDependencyCode) : [];
     const settable = rows.filter((code) => !FIXED_SEVERITY_CODES.includes(code));
@@ -209,7 +203,7 @@ export function staleSuppressions(
           ? ""
           : `, and ${declared}`;
     return {
-      code: STALE_SUPPRESSION,
+      code: CODE.staleSuppression,
       mechanism: first.mechanism,
       entry: {
         code: first.code,
@@ -242,7 +236,7 @@ function unmatchedDeclarationFindings(
   unmatched: readonly UnmatchedDeclaration[],
 ): readonly Finding[] {
   return unmatched.map((one) => ({
-    code: UNMATCHED_DECLARATION,
+    code: CODE.unmatchedConfiguredDeclaration,
     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`,
@@ -262,7 +256,7 @@ export function unmatchedRootFindings(
 ): readonly Finding[] {
   const position = documentPosition(document);
   return sources.map((source) => ({
-    code: UNMATCHED_ROOT,
+    code: CODE.unmatchedRoot,
     position,
     symbol: { ref: source, kind: ROOT_SUBJECT, name: source, sizeLines: 1 },
     message:
@@ -273,7 +267,7 @@ export function unmatchedRootFindings(
 }
 
 /**
- * The findings of the self-check family, `DS1700` to `DS1799`: a suppression refused for
+ * The findings of the configuration family, `DS9000` to `DS9099`: a suppression refused for
  * 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

package/src/findings/unused-declarations.ts

@@ -1,7 +1,9 @@
+import { CODE } from "../contract/contract.generated.ts";
 import type { Finding } from "../finding.ts";
 import type { InventorySymbol, SymbolKind } from "../inventory.ts";
 import type { MatrixCandidate } from "../matrix.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
+import { testsUnseenAPI } from "./completion.ts";
 import { unreachableExports } from "./visibility-narrowing.ts";
 
 /** The kinds of declaration that are members of a class, an interface, a type or an enum. */
@@ -13,18 +15,18 @@ const MEMBERS: ReadonlySet<SymbolKind> = new Set([
 ]);
 
 /**
- * The kinds of declaration no code of this family reports: an interface and a method an
+ * The kinds of declaration no code of this emitter reports: an interface and a method an
  * interface declares are the interface kinds' subjects, and a type parameter is the
  * subject of the unused-type-parameter kind or of none.
  */
-const NOT_THIS_FAMILY: ReadonlySet<SymbolKind> = new Set([
+const NOT_REPORTED_HERE: ReadonlySet<SymbolKind> = new Set([
   "file",
   "interface",
   "interface-method",
   "type-parameter",
 ]);
 
-/** The reader's word for each kind of declaration a finding of the family names. */
+/** The reader's word for each kind of declaration a finding of this emitter names. */
 const WORDS: Readonly<Record<SymbolKind, string>> = {
   file: "file",
   function: "function",
@@ -55,21 +57,24 @@ interface Judged {
   readonly deprecated: boolean;
   /** Whether the unreachable-export kind reports it. */
   readonly unreachable: boolean;
+  /** Whether it is a test with a target that is published API no declared consumer judges. */
+  readonly testsUnseenAPI: boolean;
 }
 
 /**
  * The code one candidate is reported under, or none, each symbol once under the most
  * specific code: a test of dead code first; no other test-file declaration or enum
  * member nothing names; a test-support declaration test code references as test-only
- * use; then deprecation, a test reference, and the unreferenced codes, an unimportable
- * unused export being the unreachable kind's.
+ * use; then deprecation, a test reference, or only dead production references beside a
+ * test that stays, and the unreferenced codes, an unimportable unused export being the
+ * unreachable kind's.
  */
 function codeOf(judged: Judged): string | undefined {
   const { candidate, symbol } = judged;
   if (candidate.testOfDeadCode) {
-    return "DS1005";
+    return judged.testsUnseenAPI ? undefined : CODE.testOfDeadCode;
   }
-  if ((judged.test && !candidate.unreferencedTest) || NOT_THIS_FAMILY.has(symbol.kind)) {
+  if ((judged.test && !candidate.unreferencedTest) || NOT_REPORTED_HERE.has(symbol.kind)) {
     return undefined;
   }
   const referenced = candidate.productionRefs + candidate.testRefs > 0;
@@ -80,29 +85,33 @@ function codeOf(judged: Judged): string | undefined {
     return unreferencedCode(symbol);
   }
   if (candidate.heldByTests === candidate.id) {
-    return "DS1004";
+    return CODE.testOnlyUse;
   }
   if (candidate.productionRefs === 0 && judged.deprecated) {
-    return "DS1006";
+    return CODE.deprecatedUnused;
   }
-  if (candidate.productionRefs === 0 && candidate.testRefs > 0) {
-    return "DS1004";
+  if (
+    candidate.testRefs > 0 &&
+    (candidate.productionRefs === 0 ||
+      (candidate.relation === "reachability" && candidate.keptByTests))
+  ) {
+    return CODE.testOnlyUse;
   }
   if (MEMBERS.has(symbol.kind)) {
-    return "DS1003";
+    return CODE.unusedMember;
   }
   if (!symbol.exported) {
-    return "DS1002";
+    return CODE.unusedUnexported;
   }
-  return judged.unreachable ? undefined : "DS1001";
+  return judged.unreachable ? undefined : CODE.unusedExported;
 }
 
 /** The code a declaration nothing references carries, by its shape and its visibility. */
 function unreferencedCode(symbol: InventorySymbol): string {
   if (MEMBERS.has(symbol.kind)) {
-    return "DS1003";
+    return CODE.unusedMember;
   }
-  return symbol.exported ? "DS1001" : "DS1002";
+  return symbol.exported ? CODE.unusedExported : CODE.unusedUnexported;
 }
 
 /** The visibility a member's message names, where it narrows the member's reach. */
@@ -127,15 +136,17 @@ function messageOf(code: string, judged: Judged): string {
   const { candidate, symbol } = judged;
   const word = WORDS[symbol.kind];
   switch (code) {
-    case "DS1005":
+    case CODE.testOfDeadCode:
       return TEST_OF_DEAD_CODE;
-    case "DS1006":
+    case CODE.deprecatedUnused:
       return `deprecated ${word} has no production reference`;
-    case "DS1004":
-      return `${word} is referenced only from test files and never from production code`;
+    case CODE.testOnlyUse:
+      return candidate.productionRefs === 0
+        ? `${word} is referenced only from test files and never from production code`
+        : `${word} is referenced only from test files and from declarations that are themselves dead`;
   }
   const subject =
-    code === "DS1003"
+    code === CODE.unusedMember
       ? `${visibilityWord(symbol)}${word}`
       : symbol.kind === "export-alias"
         ? word
@@ -143,7 +154,7 @@ function messageOf(code: string, judged: Judged): string {
   if (candidate.relation === "reachability") {
     return `${subject} is referenced only from declarations that are themselves dead`;
   }
-  if (code === "DS1001") {
+  if (code === CODE.unusedExported) {
     return `${subject} has no reference in the target and none from any loaded consumer`;
   }
   return `${subject} has no reference in the target`;
@@ -195,25 +206,25 @@ function brandMembers(input: EmitterInput): ReadonlySet<string> {
 /** The kinds of member a brand is: a data member of a type or of a class. */
 const BRANDS: ReadonlySet<SymbolKind> = new Set(["type-member", "class-member"]);
 
-/** The findings of the unused-declarations family, `DS1000` to `DS1099`. */
+/** The findings of the unused-declaration kinds, `DS1001` to `DS1004` and `DS1102` to `DS1104`. */
 export const unusedDeclarations: Emitter = (input) => [
-  ...familyFindings(input, false),
+  ...emitterFindings(input, false),
   ...unusedImports(input),
 ];
 
 /**
- * The import bindings their file never reads, under the unexported code. A generated
- * file's are the generator's to remove unless the run includes generated files.
+ * The import bindings their file never reads. A generated file's are the generator's to
+ * remove unless the run includes generated files.
  */
 function unusedImports(input: EmitterInput): Finding[] {
   const generated =
-    input.config.analysis.generatedFiles === "include" ? undefined : input.files.generated;
+    input.config.analysis.generated_files === "include" ? undefined : input.files.generated;
   return input.intraFunction.imports.flatMap((binding) =>
     binding.used || generated?.has(binding.position.path) === true
       ? []
       : [
           {
-            code: "DS1002",
+            code: CODE.unusedImport,
             position: binding.position,
             symbol: { ref: binding.ref, kind: "import", name: binding.name, sizeLines: 1 },
             message: `import binding ${binding.name} is never read in its file`,
@@ -227,13 +238,14 @@ function unusedImports(input: EmitterInput): Finding[] {
  * a record on such a member is matched against, since the report carries the container's
  * finding rather than one of the member's own.
  */
-export const fallenMembers: Emitter = (input) => familyFindings(input, true);
+export const fallenMembers: Emitter = (input) => emitterFindings(input, true);
 
-/** The family's findings, or, where `fallen` is set, its dead containers' members' alone. */
-function familyFindings(input: EmitterInput, fallen: boolean): Finding[] {
+/** This emitter's findings, or, where `fallen` is set, its dead containers' members' alone. */
+function emitterFindings(input: EmitterInput, fallen: boolean): Finding[] {
   const union = input.swept.matrix.union;
   const dead = new Set(input.swept.sweep.candidates.map((candidate) => candidate.id));
   const unreachable = unreachableExports(input);
+  const unseenAPI = testsUnseenAPI(input);
   let brands: ReadonlySet<string> | undefined;
 
   const found: Finding[] = [];
@@ -253,11 +265,12 @@ function familyFindings(input: EmitterInput, fallen: boolean): Finding[] {
       test: union.test[at] === true,
       deprecated: input.deprecated.has(symbol.id),
       unreachable: unreachable.has(symbol.id),
+      testsUnseenAPI: candidate.testOfDeadCode && unseenAPI(candidate.id),
     };
     const code = codeOf(judged);
     if (
       code === undefined ||
-      (code === "DS1003" && (brands ??= brandMembers(input)).has(symbol.id))
+      (code === CODE.unusedMember && (brands ??= brandMembers(input)).has(symbol.id))
     ) {
       continue;
     }

package/src/findings/visibility-narrowing.ts

@@ -1,3 +1,4 @@
+import { CODE } from "../contract/contract.generated.ts";
 import type { Finding } from "../finding.ts";
 import { OUTSIDE, type Graph } from "../graph.ts";
 import type { InventorySymbol, SymbolKind } from "../inventory.ts";
@@ -8,10 +9,6 @@ import { runnerCalls } from "../sweep.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
 import { writeOnlyDeclarations } from "./reads-and-writes.ts";
 
-const UNNECESSARY_EXPORT = "DS1101";
-const UNREACHABLE_EXPORT = "DS1103";
-const REDUNDANT_EXPORT_KEYWORD = "DS1104";
-
 /** How far the references to one declaration reach, from the narrowest. */
 type Reach = "file" | "package" | "outside";
 
@@ -22,7 +19,7 @@ type Reach = "file" | "package" | "outside";
  */
 const PUBLISHING: ReadonlySet<RootKind> = new Set<RootKind>(["manifest-entry", "published-api"]);
 
-/** The reader's word for each kind of declaration this family reports. */
+/** The reader's word for each kind of declaration this emitter reports. */
 const WORDS: Partial<Readonly<Record<SymbolKind, string>>> = {
   function: "function",
   class: "class",
@@ -63,6 +60,12 @@ function entersByName(kinds: ReadonlySet<RootKind> | undefined): boolean {
   return [...(kinds ?? [])].some((kind) => !PUBLISHING.has(kind) && !RUN_ONLY.has(kind));
 }
 
+/**
+ * The root kinds whose root of a file enters no export by name: a document's import roots
+ * each export it imports, so an export it does not import is judged as in any file.
+ */
+const PER_NAME: ReadonlySet<RootKind> = new Set<RootKind>(["document-import"]);
+
 /**
  * Whether the roots of a declaration's file enter it by name: a test runner's root
  * enters only an export the runner calls, so another export of a test file is judged.
@@ -72,7 +75,7 @@ function fileEntersByName(
   symbol: InventorySymbol,
 ): boolean {
   const entering = [...(kinds ?? [])].filter(
-    (kind) => !PUBLISHING.has(kind) && !RUN_ONLY.has(kind),
+    (kind) => !PUBLISHING.has(kind) && !RUN_ONLY.has(kind) && !PER_NAME.has(kind),
   );
   return (
     entering.some((kind) => kind !== "test-runner") || (entering.length > 0 && runnerCalls(symbol))
@@ -145,8 +148,8 @@ function wordOf(symbol: InventorySymbol): string {
 
 /** The visibility each narrowing code names, which only the narrowing codes carry. */
 const NARROWER: Readonly<Record<string, "file" | "package">> = {
-  [REDUNDANT_EXPORT_KEYWORD]: "file",
-  [UNNECESSARY_EXPORT]: "package",
+  [CODE.redundantExportKeyword]: "file",
+  [CODE.unnecessaryExport]: "package",
 };
 
 function findingOf(symbol: InventorySymbol, code: string, message: string): Finding {
@@ -200,7 +203,7 @@ function narrowing(
       }
       return findingOf(
         symbol,
-        REDUNDANT_EXPORT_KEYWORD,
+        CODE.redundantExportKeyword,
         `exported ${word} is referenced only inside the file that declares it`,
       );
     case "package":
@@ -209,7 +212,7 @@ function narrowing(
       }
       return findingOf(
         symbol,
-        UNNECESSARY_EXPORT,
+        CODE.unnecessaryExport,
         `exported ${word} is referenced only inside the package that declares it`,
       );
     default:
@@ -222,7 +225,7 @@ function narrowing(
  * export no code outside the target can import, because the manifest declares
  * `exports` and no root reaches it. Each arm yields to a more specific kind, so one
  * declaration is reported once: a test whose every subject is dead, an interface, a
- * declaration only a test file references, and a deprecated one.
+ * declaration only a test file references or a test that stays keeps, and a deprecated one.
  */
 function unreachable(
   facts: Facts,
@@ -237,7 +240,7 @@ function unreachable(
     (facts.rootedBy[at]?.size ?? 0) > 0 ||
     candidate.testOfDeadCode ||
     symbol.kind === "interface" ||
-    (candidate.productionRefs === 0 && candidate.testRefs > 0) ||
+    (candidate.testRefs > 0 && (candidate.productionRefs === 0 || candidate.keptByTests)) ||
     (candidate.productionRefs === 0 && input.deprecated.has(symbol.id))
   ) {
     return undefined;
@@ -248,13 +251,13 @@ function unreachable(
       : "has no reference in the target";
   return findingOf(
     symbol,
-    UNREACHABLE_EXPORT,
+    CODE.unreachableExport,
     `exported ${wordOf(symbol)} ${found}, and nothing outside can import the file that declares it`,
   );
 }
 
 /**
- * The visibility-narrowing family over one run: `DS1101`, `DS1103` and `DS1104`. A finding
+ * The visibility-narrowing kinds over one run: `DS1501`, `DS1101` and `DS1503`. A finding
  * about a symbol a declared cross-language edge names is reported here like any other, and
  * the edge's evaluation then holds it pending, because the edge stands for a reference from
  * outside the file and the package whose use is decided in the other language. A
@@ -263,13 +266,13 @@ function unreachable(
 export function narrowings(input: EmitterInput): readonly Finding[] {
   const facts = factsOf(input.swept.matrix.union);
   const { declared, loaded } = input.boundary.consumers;
-  const closed = input.config.consumersComplete && declared.every((id) => loaded.includes(id));
+  const closed = input.config.consumers.complete && declared.every((id) => loaded.includes(id));
   const world = { closed, writeOnly: writeOnlyDeclarations(input) };
   const candidates = new Map(
     input.swept.sweep.candidates.map((candidate) => [candidate.id, candidate]),
   );
   const generated =
-    input.config.analysis.generatedFiles === "include" ? undefined : input.files.generated;
+    input.config.analysis.generated_files === "include" ? undefined : input.files.generated;
 
   const findings: Finding[] = [];
   facts.graph.symbols.forEach((symbol, at) => {
@@ -310,5 +313,5 @@ export function unreachableExports(input: EmitterInput): ReadonlySet<string> {
   return found;
 }
 
-/** The findings of the visibility-narrowing family, `DS1100` to `DS1199`. */
+/** The findings of the visibility-narrowing kinds, `DS1501`, `DS1101` and `DS1503`. */
 export const visibilityNarrowing: Emitter = narrowings;