@cplieger/deadset-ts 3.5.0 → 3.7.0

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

@@ -1,4 +1,197 @@
-import type { Emitter } from "./emitter.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 type { Emitter, EmitterInput } from "./emitter.ts";
 
-/** The findings of the reads-and-writes family, `DS1300` to `DS1399`. */
-export const readsAndWrites: Emitter = () => [];
+/** The codes of this family. */
+type ReadsAndWritesCode = "DS1301" | "DS1302" | "DS1303";
+
+/** The containers whose type parameters `DS1303` reports: a function and a class method. */
+const SIGNATURES: ReadonlySet<string> = new Set(["function", "method"]);
+
+/** What the family reads of one run, indexed by declaration. */
+interface Run {
+  readonly input: EmitterInput;
+  readonly symbols: ReadonlyMap<string, InventorySymbol>;
+  readonly candidates: ReadonlyMap<string, MatrixCandidate>;
+}
+
+function indexed(input: EmitterInput): Run {
+  const { matrix, sweep } = input.swept;
+  return {
+    input,
+    symbols: new Map(matrix.union.symbols.map((symbol) => [symbol.id, symbol])),
+    candidates: new Map(sweep.candidates.map((candidate) => [candidate.id, candidate])),
+  };
+}
+
+/** Where one declaration is, as a finding states it. */
+function positionOf(symbol: InventorySymbol): FindingPosition {
+  return {
+    path: symbol.position.path,
+    line: symbol.position.line,
+    column: symbol.position.column,
+    endLine: Math.max(symbol.position.line, symbol.endLine),
+  };
+}
+
+/** The finding one code makes about one declaration. */
+function findingAbout(
+  symbol: InventorySymbol,
+  code: ReadsAndWritesCode,
+  message: string,
+  details?: FindingDetails,
+): Finding {
+  const position = positionOf(symbol);
+  return {
+    code,
+    position,
+    symbol: {
+      ref: symbol.ref,
+      kind: symbol.kind,
+      name: symbol.name,
+      sizeLines: position.endLine - position.line + 1,
+    },
+    message,
+    ...(details === undefined ? {} : { details }),
+  };
+}
+
+/** How one declaration's counted references divide for the write-only kind. */
+interface Uses {
+  readonly writes: FindingPosition[];
+  reads: number;
+}
+
+/**
+ * Whether one declaration is a subject of the write-only kind: a module-level variable,
+ * or a class member that is state rather than code. A getter or a setter is code, so a
+ * store into one runs it.
+ */
+function writable(run: Run, symbol: InventorySymbol): boolean {
+  if (symbol.kind === "variable") {
+    return true;
+  }
+  return symbol.kind === "class-member" && !run.input.stores.accessors.has(symbol.id);
+}
+
+/**
+ * `DS1301`: a module-level variable or a class member the counted references store into
+ * and never read, named with every position written.
+ *
+ * The subject is a live declaration: a store is a reference, so the sweep holds a
+ * written one live and its candidates are never this kind's. Every reference that is
+ * not a store reads, and so does an exemption record naming the declaration.
+ */
+function writeOnlySymbols(run: Run): readonly Finding[] {
+  const { stores } = run.input;
+  const { matrix } = run.input.swept;
+  const uses = new Map<string, Uses>();
+  for (const reference of stores.references) {
+    let held = uses.get(reference.to);
+    if (held === undefined) {
+      held = { writes: [], reads: 0 };
+      uses.set(reference.to, held);
+    }
+    if (reference.use !== "write") {
+      held.reads += 1;
+      continue;
+    }
+    const at = reference.position;
+    const key = positionKey(at);
+    if (!held.writes.some((written) => positionKey(written) === key)) {
+      held.writes.push({ path: at.path, line: at.line, column: at.column, endLine: at.line });
+    }
+  }
+
+  const found: Finding[] = [];
+  for (const symbol of matrix.union.symbols) {
+    const held = uses.get(symbol.id);
+    if (
+      held === undefined ||
+      held.writes.length === 0 ||
+      held.reads > 0 ||
+      !writable(run, symbol) ||
+      stores.exempt.has(symbol.id) ||
+      run.candidates.has(symbol.id)
+    ) {
+      continue;
+    }
+    const writes = held.writes.length === 1 ? "once" : `at ${String(held.writes.length)} positions`;
+    const word = symbol.kind === "variable" ? "variable" : "member";
+    found.push(
+      findingAbout(symbol, "DS1301", `${word} ${symbol.name} is written ${writes} and never read`, {
+        writePositions: held.writes,
+      }),
+    );
+  }
+  return found;
+}
+
+/**
+ * The candidates no reference of any file names whose container is not itself dead, of
+ * one kind. A reference from a test file alone leaves a candidate to the test-only kind,
+ * and a member of a dead container falls with it and is reported inside its component.
+ */
+function unnamed(run: Run, kind: InventorySymbol["kind"]): readonly InventorySymbol[] {
+  return run.input.swept.sweep.candidates.flatMap((candidate): InventorySymbol[] => {
+    const symbol = run.symbols.get(candidate.id);
+    if (
+      symbol?.kind !== kind ||
+      candidate.productionRefs > 0 ||
+      candidate.testRefs > 0 ||
+      run.candidates.has(symbol.parent)
+    ) {
+      return [];
+    }
+    return [symbol];
+  });
+}
+
+/**
+ * `DS1302`: 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`),
+  );
+}
+
+/**
+ * `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.
+ */
+function unusedTypeParameters(run: Run): readonly Finding[] {
+  return unnamed(run, "type-parameter")
+    .filter((symbol) => SIGNATURES.has(run.symbols.get(symbol.parent)?.kind ?? ""))
+    .map((symbol) =>
+      findingAbout(
+        symbol,
+        "DS1303",
+        `type parameter ${symbol.name} is named in neither its signature nor its body`,
+      ),
+    );
+}
+
+/**
+ * The references of the declarations the write-only kind reports, whatever the
+ * severity: a narrowing kind yields each to it, since deleting the declaration
+ * supersedes narrowing it.
+ */
+export function writeOnlyDeclarations(input: EmitterInput): ReadonlySet<string> {
+  return new Set(writeOnlySymbols(indexed(input)).map((finding) => finding.symbol.ref));
+}
+
+/**
+ * The findings of the reads-and-writes family, `DS1300` to `DS1399`, in code order and
+ * each code's in site order.
+ */
+export const readsAndWrites: Emitter = (input) => {
+  const run = indexed(input);
+  return [...writeOnlySymbols(run), ...unusedEnumMembers(run), ...unusedTypeParameters(run)];
+};

package/src/findings/unused-declarations.ts

@@ -1,4 +1,178 @@
+import type { Finding } from "../finding.ts";
+import type { InventorySymbol, SymbolKind } from "../inventory.ts";
+import type { MatrixCandidate } from "../matrix.ts";
 import type { Emitter } from "./emitter.ts";
+import { unreachableExports } from "./visibility-narrowing.ts";
+
+/** The kinds of declaration that are members of a class, an interface, a type or an enum. */
+const MEMBERS: ReadonlySet<SymbolKind> = new Set([
+  "method",
+  "class-member",
+  "type-member",
+  "enum-member",
+]);
+
+/**
+ * The kinds of declaration no code of this family 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([
+  "file",
+  "interface",
+  "interface-method",
+  "type-parameter",
+]);
+
+/** The reader's word for each kind of declaration a finding of the family names. */
+const WORDS: Readonly<Record<SymbolKind, string>> = {
+  file: "file",
+  function: "function",
+  class: "class",
+  interface: "interface",
+  type: "type alias",
+  enum: "enum",
+  namespace: "namespace",
+  variable: "variable",
+  "export-alias": "re-export",
+  method: "method",
+  "class-member": "class member",
+  "interface-method": "interface method",
+  "type-member": "type member",
+  "enum-member": "enum member",
+  "type-parameter": "type parameter",
+};
+
+/** What the test-of-dead-code kind says, which states the rule it applies. */
+const TEST_OF_DEAD_CODE = "every target symbol this test references is reported dead";
+
+/** What the run holds about one candidate that decides its code. */
+interface Judged {
+  readonly candidate: MatrixCandidate;
+  readonly symbol: InventorySymbol;
+  /** Whether a test file declares it. */
+  readonly test: boolean;
+  /** Whether its container is itself dead, so it falls with the container. */
+  readonly containerDead: boolean;
+  readonly deprecated: boolean;
+  /** Whether the unreachable-export kind reports it. */
+  readonly unreachable: 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, member of a
+ * dead container or enum member nothing names; then deprecation, a test reference, 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";
+  }
+  if (judged.test || judged.containerDead || NOT_THIS_FAMILY.has(symbol.kind)) {
+    return undefined;
+  }
+  const referenced = candidate.productionRefs + candidate.testRefs > 0;
+  if (symbol.kind === "enum-member" && !referenced) {
+    return undefined;
+  }
+  if (candidate.productionRefs === 0 && judged.deprecated) {
+    return "DS1006";
+  }
+  if (candidate.productionRefs === 0 && candidate.testRefs > 0) {
+    return "DS1004";
+  }
+  if (MEMBERS.has(symbol.kind)) {
+    return "DS1003";
+  }
+  if (!symbol.exported) {
+    return "DS1002";
+  }
+  return judged.unreachable ? undefined : "DS1001";
+}
+
+/** The visibility a member's message names, where it narrows the member's reach. */
+function visibilityWord(symbol: InventorySymbol): string {
+  switch (symbol.visibility) {
+    case "private":
+    case "private-name":
+      return "private ";
+    case "protected":
+      return "protected ";
+    case "public":
+      return "";
+  }
+}
+
+/**
+ * What one finding says: what the subject is, and what the analysis found about its
+ * references. A candidate reachability found has references, each from a declaration
+ * that is itself dead, so saying it has none would be false.
+ */
+function messageOf(code: string, judged: Judged): string {
+  const { candidate, symbol } = judged;
+  const word = WORDS[symbol.kind];
+  switch (code) {
+    case "DS1005":
+      return TEST_OF_DEAD_CODE;
+    case "DS1006":
+      return `deprecated ${word} has no production reference`;
+    case "DS1004":
+      return `${word} is referenced only from test files and never from production code`;
+  }
+  const subject =
+    code === "DS1003"
+      ? `${visibilityWord(symbol)}${word}`
+      : symbol.kind === "export-alias"
+        ? word
+        : `${symbol.exported ? "exported" : "unexported"} ${word}`;
+  if (candidate.relation === "reachability") {
+    return `${subject} is referenced only from declarations that are themselves dead`;
+  }
+  if (code === "DS1001") {
+    return `${subject} has no reference in the target and none from any loaded consumer`;
+  }
+  return `${subject} has no reference in the target`;
+}
 
 /** The findings of the unused-declarations family, `DS1000` to `DS1099`. */
-export const unusedDeclarations: Emitter = () => [];
+export const unusedDeclarations: Emitter = (input) => {
+  const union = input.swept.matrix.union;
+  const dead = new Set(input.swept.sweep.candidates.map((candidate) => candidate.id));
+  const unreachable = unreachableExports(input);
+
+  const found: Finding[] = [];
+  for (const candidate of input.swept.sweep.candidates) {
+    const at = union.at(candidate.id);
+    const symbol = union.symbols[at];
+    if (symbol === undefined) {
+      continue;
+    }
+    const judged: Judged = {
+      candidate,
+      symbol,
+      test: union.test[at] === true,
+      containerDead: dead.has(symbol.parent),
+      deprecated: input.deprecated.has(symbol.id),
+      unreachable: unreachable.has(symbol.id),
+    };
+    const code = codeOf(judged);
+    if (code === undefined) {
+      continue;
+    }
+    const endLine = Math.max(symbol.position.line, symbol.endLine);
+    found.push({
+      code,
+      position: { ...symbol.position, endLine },
+      symbol: {
+        ref: symbol.ref,
+        kind: symbol.kind,
+        name: symbol.name,
+        sizeLines: endLine - symbol.position.line + 1,
+      },
+      message: messageOf(code, judged),
+    });
+  }
+  return found;
+};

package/src/findings/visibility-narrowing.ts

@@ -1,4 +1,320 @@
-import type { Emitter } from "./emitter.ts";
+import type { Finding } from "../finding.ts";
+import { OUTSIDE, type Graph } from "../graph.ts";
+import type { InventorySymbol, SymbolKind } from "../inventory.ts";
+import type { MatrixCandidate } from "../matrix.ts";
+import type { RootKind } from "../roots.ts";
+import type { PendingFinding } from "./boundary.ts";
+import type { Emitter, EmitterInput } from "./emitter.ts";
+import { writeOnlyDeclarations } from "./reads-and-writes.ts";
 
-/** The findings of the visibility-narrowing family, `DS1100` to `DS1199`. */
-export const visibilityNarrowing: Emitter = () => [];
+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";
+
+/**
+ * The root kinds by which a consumer importing the package reaches a declaration. A
+ * declaration or a file rooted by any other kind is entered by something that names it
+ * from outside the reference graph: a runtime, a tool, a framework or the configuration.
+ */
+const PUBLISHING: ReadonlySet<RootKind> = new Set<RootKind>(["manifest-entry", "published-api"]);
+
+/** The reader's word for each kind of declaration this family reports. */
+const WORDS: Partial<Readonly<Record<SymbolKind, string>>> = {
+  function: "function",
+  class: "class",
+  interface: "interface",
+  type: "type alias",
+  enum: "enum",
+  namespace: "namespace",
+  variable: "variable",
+  "export-alias": "re-export",
+};
+
+/** What the family found: the findings it reports, and those a declared edge holds pending. */
+export interface Narrowings {
+  readonly findings: readonly Finding[];
+  /** Ordered by edge, then by side. */
+  readonly pending: readonly PendingFinding[];
+}
+
+/** Per declaration of the run, the facts both rules read. */
+interface Facts {
+  readonly graph: Graph;
+  /** The position of the file that holds each declaration. */
+  readonly fileOf: readonly number[];
+  /** The root kinds naming each declaration. */
+  readonly rootedBy: readonly ReadonlySet<RootKind>[];
+  /** Per file, whether a manifest export reaches a declaration it holds. */
+  readonly published: readonly boolean[];
+  /** Per declaration, how many references name it, and how far they reach. */
+  readonly named: readonly number[];
+  readonly reach: readonly Reach[];
+}
+
+function publishes(kinds: ReadonlySet<RootKind> | undefined): boolean {
+  return [...(kinds ?? [])].some((kind) => PUBLISHING.has(kind));
+}
+
+function entersByName(kinds: ReadonlySet<RootKind> | undefined): boolean {
+  return [...(kinds ?? [])].some((kind) => !PUBLISHING.has(kind));
+}
+
+/**
+ * Folds the run's references into the reach of each declaration.
+ *
+ * A reference reaches the file that holds the declaration that makes it. A reference
+ * from a declaration the inventory does not hold is made by a consumer, and one from a
+ * re-export a manifest export reaches stands for every consumer importing the name it
+ * publishes; either reaches outside the package.
+ */
+function factsOf(graph: Graph): Facts {
+  const { symbols, parent } = graph;
+  const fileOf = symbols.map((_symbol, at) => {
+    let file = at;
+    while (file !== OUTSIDE && symbols[file]?.kind !== "file") {
+      file = parent[file] ?? OUTSIDE;
+    }
+    return file;
+  });
+  const rootedBy = symbols.map(() => new Set<RootKind>());
+  for (const root of graph.rooted) {
+    rootedBy[root.at]?.add(root.kind);
+  }
+  const published = symbols.map(() => false);
+  symbols.forEach((_symbol, at) => {
+    const file = fileOf[at] ?? OUTSIDE;
+    if (file !== OUTSIDE && publishes(rootedBy[at])) {
+      published[file] = true;
+    }
+  });
+
+  const order: readonly Reach[] = ["file", "package", "outside"];
+  const wider = (a: Reach, b: Reach): Reach => (order.indexOf(a) >= order.indexOf(b) ? a : b);
+  const inGraph = symbols.map(() => 0);
+  const reach = symbols.map((): Reach => "file");
+  graph.out.forEach((edges, from) => {
+    const republished = symbols[from]?.kind === "export-alias" && publishes(rootedBy[from]);
+    for (const edge of edges) {
+      inGraph[edge.to] = (inGraph[edge.to] ?? 0) + 1;
+      const scope: Reach = republished
+        ? "outside"
+        : fileOf[from] === fileOf[edge.to]
+          ? "file"
+          : "package";
+      reach[edge.to] = wider(reach[edge.to] ?? "file", scope);
+    }
+  });
+  const named = graph.made.map((counts) => counts.production + counts.test);
+  named.forEach((count, at) => {
+    if (count > (inGraph[at] ?? 0)) {
+      reach[at] = "outside";
+    }
+  });
+  return { graph, fileOf, rootedBy, published, named, reach };
+}
+
+/** Whether one declaration is a declaration its file's export table names. */
+function topLevelExport(facts: Facts, at: number, symbol: InventorySymbol): boolean {
+  const parent = facts.graph.parent[at] ?? OUTSIDE;
+  return symbol.exported && parent !== OUTSIDE && facts.graph.symbols[parent]?.kind === "file";
+}
+
+function wordOf(symbol: InventorySymbol): string {
+  return WORDS[symbol.kind] ?? symbol.kind;
+}
+
+/** 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",
+};
+
+function findingOf(symbol: InventorySymbol, code: string, message: string): Finding {
+  const { path, line, column } = symbol.position;
+  const narrower = Object.hasOwn(NARROWER, code) ? NARROWER[code] : undefined;
+  const endLine = Math.max(line, symbol.endLine);
+  return {
+    code,
+    position: { path, line, column, endLine },
+    symbol: {
+      ref: symbol.ref,
+      kind: symbol.kind,
+      name: symbol.name,
+      sizeLines: endLine - line + 1,
+    },
+    message,
+    details: narrower === undefined ? {} : { narrowerVisibility: narrower },
+  };
+}
+
+/**
+ * The narrowing finding about one live declaration, if one holds: an export of a file,
+ * no re-export and none the write-only kind reports, that a reference names and nothing
+ * enters by name. Every reference inside its own file makes it a redundant export
+ * keyword, where no manifest export reaches the file or the world is closed; references
+ * from other files of the package alone make a published one unnecessary when closed.
+ */
+function narrowing(
+  facts: Facts,
+  at: number,
+  symbol: InventorySymbol,
+  world: { readonly closed: boolean; readonly writeOnly: ReadonlySet<string> },
+): Finding | undefined {
+  const { closed } = world;
+  const file = facts.fileOf[at] ?? OUTSIDE;
+  if (
+    !topLevelExport(facts, at, symbol) ||
+    world.writeOnly.has(symbol.ref) ||
+    symbol.kind === "export-alias" ||
+    entersByName(facts.rootedBy[at]) ||
+    entersByName(facts.rootedBy[file]) ||
+    (facts.named[at] ?? 0) === 0
+  ) {
+    return undefined;
+  }
+  const word = wordOf(symbol);
+  switch (facts.reach[at]) {
+    case "file":
+      if (facts.published[file] === true && !closed) {
+        return undefined;
+      }
+      return findingOf(
+        symbol,
+        REDUNDANT_EXPORT_KEYWORD,
+        `exported ${word} is referenced only inside the file that declares it`,
+      );
+    case "package":
+      if (!closed || !publishes(facts.rootedBy[at])) {
+        return undefined;
+      }
+      return findingOf(
+        symbol,
+        UNNECESSARY_EXPORT,
+        `exported ${word} is referenced only inside the package that declares it`,
+      );
+    default:
+      return undefined;
+  }
+}
+
+/**
+ * The unreachable-export finding about one dead declaration, if one holds: an unused
+ * 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.
+ */
+function unreachable(
+  facts: Facts,
+  at: number,
+  symbol: InventorySymbol,
+  candidate: MatrixCandidate,
+  input: EmitterInput,
+): Finding | undefined {
+  if (
+    !input.boundary.encapsulated ||
+    !topLevelExport(facts, at, symbol) ||
+    (facts.rootedBy[at]?.size ?? 0) > 0 ||
+    candidate.testOfDeadCode ||
+    symbol.kind === "interface" ||
+    (candidate.productionRefs === 0 && candidate.testRefs > 0) ||
+    (candidate.productionRefs === 0 && input.deprecated.has(symbol.id))
+  ) {
+    return undefined;
+  }
+  const found =
+    candidate.relation === "reachability"
+      ? "is referenced only from declarations that are themselves dead"
+      : "has no reference in the target";
+  return findingOf(
+    symbol,
+    UNREACHABLE_EXPORT,
+    `exported ${wordOf(symbol)} ${found}, and nothing outside can import the file that declares it`,
+  );
+}
+
+/** Two strings ordered bytewise. */
+function compare(a: string, b: string): number {
+  if (a === b) {
+    return 0;
+  }
+  return a < b ? -1 : 1;
+}
+
+/**
+ * The visibility-narrowing family over one run: `DS1101`, `DS1103` and `DS1104`.
+ *
+ * A finding about a symbol a declared cross-language edge names is pending instead of
+ * reported, once per side naming it: the edge counts as a reference from outside the
+ * file and the package, and whether it is a use is decided on the side in the other
+ * language.
+ */
+export function narrowings(input: EmitterInput): Narrowings {
+  const { boundary } = input;
+  const facts = factsOf(input.swept.matrix.union);
+  const { declared, loaded } = boundary.consumers;
+  const closed = input.config.consumersComplete && 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 findings: Finding[] = [];
+  const pending: PendingFinding[] = [];
+  facts.graph.symbols.forEach((symbol, at) => {
+    const candidate = candidates.get(symbol.id);
+    const found =
+      candidate === undefined
+        ? narrowing(facts, at, symbol, world)
+        : unreachable(facts, at, symbol, candidate, input);
+    if (found === undefined) {
+      return;
+    }
+    const named = boundary.edges.filter((side) => side.symbol === symbol.ref);
+    if (named.length === 0) {
+      findings.push(found);
+      return;
+    }
+    for (const side of named) {
+      pending.push({ ...side, finding: found });
+    }
+  });
+  pending.sort((a, b) => compare(a.edge, b.edge) || compare(a.side, b.side));
+  return { findings, pending };
+}
+
+/**
+ * The declarations the unreachable-export kind reports, whether or not a declared edge
+ * holds the finding pending: the unused-declaration kinds yield each to it.
+ */
+export function unreachableExports(input: EmitterInput): ReadonlySet<string> {
+  const facts = factsOf(input.swept.matrix.union);
+  const found = new Set<string>();
+  for (const candidate of input.swept.sweep.candidates) {
+    const at = facts.graph.at(candidate.id);
+    const symbol = facts.graph.symbols[at];
+    if (symbol !== undefined && unreachable(facts, at, symbol, candidate, input) !== undefined) {
+      found.add(symbol.id);
+    }
+  }
+  return found;
+}
+
+/**
+ * The findings of the visibility-narrowing family, `DS1100` to `DS1199`. A finding a
+ * declared edge holds pending belongs in that edge's evaluation, which this analyzer
+ * does not publish yet, so a run that holds one is refused rather than reported
+ * without it.
+ */
+export const visibilityNarrowing: Emitter = (input) => {
+  const { findings, pending } = narrowings(input);
+  if (pending.length > 0) {
+    throw new Error(
+      `${String(pending.length)} finding(s) a declared edge holds pending, and no edge evaluation is published`,
+    );
+  }
+  return findings;
+};