@cplieger/deadset-ts 7.2.0-dev.3 → 8.0.0-dev.1

package/src/entry-points.ts

@@ -14,6 +14,7 @@
 import {
   isArrayLiteralExpression,
   isAsExpression,
+  isBinaryExpression,
   isCallExpression,
   isExportAssignment,
   isIdentifier,
@@ -26,6 +27,8 @@ import {
   isPropertyAssignment,
   isSatisfiesExpression,
   isStringLiteral,
+  isTemplateExpression,
+  SyntaxKind,
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
@@ -40,6 +43,7 @@ import type { Selected } from "./conventions.ts";
 import { globExpression } from "./glob.ts";
 import type { Host } from "./host.ts";
 import { htmlEntries } from "./html-entries.ts";
+import { documentEntries } from "./mdx-entries.ts";
 import { dirnamePath, relativePath, resolvePath } from "./paths.ts";
 import { UNANSWERED } from "./query.ts";
 import type { ProjectView } from "./session.ts";
@@ -61,7 +65,15 @@ export type EntryRule =
   /** A file a module script of an HTML file below the target root loads. */
   | "html-entry"
   /** A file a `run:` step of a workflow in the target root's `.github/workflows` names. */
-  | "workflow-step";
+  | "workflow-step"
+  /**
+   * A file a load whose path is computed may name: below the directory the literal
+   * start of an `import()` or `require()` argument names, or matched by the literal
+   * glob of `import.meta.glob`.
+   */
+  | "computed-import"
+  /** A file an import line of a Markdown or MDX document below the target root names. */
+  | "document-import";
 
 /** One file a rule enters. */
 interface EntryPoint {
@@ -78,6 +90,8 @@ interface EntryPoint {
    * level and names none of its exports.
    */
   readonly exports: boolean;
+  /** Where the file is entered for some of its exports only, their export names. */
+  readonly names?: readonly string[];
 }
 
 /** One file-name convention: the stems a tool looks for, under each extension it loads. */
@@ -114,8 +128,11 @@ const SETUP_MEMBERS = ["setupFiles", "globalSetup"] as const;
 /** A member that moves the directory every path of a test-runner configuration is read from. */
 const ROOT_MEMBER = "root";
 
-/** The prefixes a literal is relative with, in a module specifier and a URL reference alike. */
-const RELATIVE_PREFIXES = ["./", "../"] as const;
+/**
+ * A URL reference's scheme. A reference with none that does not start with a solidus is
+ * relative, the bare name included: https://url.spec.whatwg.org/#relative-url-string
+ */
+const URL_SCHEME = /^[a-z][a-z\d+.-]*:/iu;
 
 /** The constructors whose first argument addresses a worker script. */
 const WORKER_CONSTRUCTORS: ReadonlySet<string> = new Set(["Worker", "SharedWorker"]);
@@ -228,9 +245,17 @@ function literalsOf(value: Node): readonly string[] | undefined {
   return found;
 }
 
-/** Whether a literal is relative in the sense a module specifier and a URL reference share. */
+/**
+ * Whether a literal is a relative URL reference, which is also how the test runner reads a
+ * setup file's path against its root.
+ */
 function isRelative(text: string): boolean {
-  return RELATIVE_PREFIXES.some((prefix) => text.startsWith(prefix));
+  return text !== "" && !text.startsWith("/") && !URL_SCHEME.test(text);
+}
+
+/** Whether a module specifier is relative, which a bare name is not: it names a package. */
+function isModuleRelative(text: string): boolean {
+  return text.startsWith("./") || text.startsWith("../");
 }
 
 /** A URL reference with its query and its fragment removed, which name no part of the file. */
@@ -470,10 +495,10 @@ function workerSitesOf(file: SourceFile): readonly WorkerSite[] {
 }
 
 /**
- * The workers one file addresses. A call's names must resolve to the platform's own
- * declarations, which no file of the target declares and no import brings in; a
- * name the target binds itself is the target's own constructor or object, which
- * addresses no worker this rule knows. One batch per file that writes such a call.
+ * The workers one file addresses. A call's names must resolve to a symbol the platform
+ * declares, which a file of the target may augment and no import brings in; a name only
+ * the target declares is the target's own constructor or object, which addresses no
+ * worker this rule knows. One batch per file that writes such a call.
  */
 function workersOf<Brand>(
   project: ProjectView<Brand>,
@@ -498,8 +523,7 @@ function workersOf<Brand>(
     if (
       symbol !== undefined &&
       (symbol.flags & SymbolFlags.Alias) === 0 &&
-      symbol.declarations.length > 0 &&
-      symbol.declarations.every((handle) => !files.byName.has(handle.path))
+      symbol.declarations.some((handle) => !files.byName.has(handle.path))
     ) {
       platform.add(name);
     }
@@ -517,6 +541,94 @@ function workersOf<Brand>(
   return found;
 }
 
+/** The literal text a computed path starts with: a template's head, or a concatenation's first literal. */
+function leadingLiteral(node: Node): string | undefined {
+  const at = unwrapped(node);
+  if (isTemplateExpression(at)) {
+    return at.head.text;
+  }
+  if (isBinaryExpression(at) && at.operatorToken.kind === SyntaxKind.PlusToken) {
+    return literalOf(unwrapped(at.left)) ?? leadingLiteral(at.left);
+  }
+  return undefined;
+}
+
+/** Whether one call is `import.meta.glob(...)`. */
+function isMetaGlob(node: Node): boolean {
+  if (!isCallExpression(node) || !isPropertyAccessExpression(node.expression)) {
+    return false;
+  }
+  const { expression, name } = node.expression;
+  return (
+    isIdentifier(name) &&
+    name.text === "glob" &&
+    isMetaProperty(expression) &&
+    expression.keywordToken === SyntaxKind.ImportKeyword
+  );
+}
+
+/**
+ * The files one file loads by a computed path, each with what exports: every own file
+ * below the directory a relative literal start of an `import()` or `require()` argument
+ * names, other than the calling file's own directory or one holding it, which would name
+ * every sibling, and
+ * every own file a relative literal glob of `import.meta.glob` matches, both read against
+ * the calling file's directory, as a bundler's context module reads them.
+ */
+function computedImportsOf(file: SourceFile, files: SourceFiles): readonly EntryPoint[] {
+  const dir = dirnamePath(file.fileName);
+  const found: EntryPoint[] = [];
+  const below = (prefix: string): void => {
+    const target = resolvePath(dir, prefix);
+    if (
+      !isModuleRelative(prefix) ||
+      !prefix.endsWith("/") ||
+      target === dir ||
+      relativePath(target, dir) !== undefined
+    ) {
+      return;
+    }
+    for (const candidate of files.byName.values()) {
+      if (candidate !== file && relativePath(target, candidate.fileName) !== undefined) {
+        found.push({ file: candidate, rule: "computed-import", source: prefix, exports: true });
+      }
+    }
+  };
+  const globbed = (pattern: string): void => {
+    if (!isModuleRelative(pattern)) {
+      return;
+    }
+    const expression = globExpression(resolvePath(dir, pattern));
+    for (const candidate of files.byName.values()) {
+      if (candidate !== file && expression.test(candidate.fileName)) {
+        found.push({ file: candidate, rule: "computed-import", source: pattern, exports: true });
+      }
+    }
+  };
+  const visit = (node: Node): void => {
+    if (isCallExpression(node)) {
+      const [first] = node.arguments;
+      const callee = node.expression;
+      const loads =
+        callee.kind === SyntaxKind.ImportKeyword ||
+        (isIdentifier(callee) && callee.text === "require");
+      if (loads && first !== undefined) {
+        const prefix = leadingLiteral(first);
+        if (prefix !== undefined) {
+          below(prefix);
+        }
+      } else if (isMetaGlob(node) && first !== undefined) {
+        for (const pattern of literalsOf(first) ?? []) {
+          globbed(pattern);
+        }
+      }
+    }
+    node.forEachChild(visit);
+  };
+  file.forEachChild(visit);
+  return found;
+}
+
 /**
  * Every file of one project the rules enter, in no particular order and possibly more
  * than once: a file two rules enter appears once per rule.
@@ -554,10 +666,20 @@ export function entryPoints<Brand>(
       }
     }
     found.push(...workersOf(project, file, files));
+    found.push(...computedImportsOf(file, files));
   }
   for (const { file, source } of htmlEntries(host, targetRoot, files, parse)) {
     found.push({ file, rule: "html-entry", source, exports: true });
   }
+  for (const { file, source, names } of documentEntries(host, targetRoot, files)) {
+    found.push({
+      file,
+      rule: "document-import",
+      source,
+      exports: true,
+      ...(names === undefined ? {} : { names }),
+    });
+  }
   for (const { file, source } of workflowEntries(host, targetRoot, files)) {
     found.push({ file, rule: "workflow-step", source, exports: true });
   }

package/src/finding.ts

@@ -34,6 +34,12 @@ interface FindingSubject {
   readonly name: string;
   /** The number of source lines the subject spans. */
   readonly sizeLines: number;
+  /**
+   * Where the subject is a part whose reference is its own, a parameter's, the reference
+   * of the declaration that holds it, which a record binding that declaration matches.
+   * No report carries it.
+   */
+  readonly holder?: string;
 }
 
 /** A declaration a finding names beside the subject, with where it is written. */
@@ -87,6 +93,10 @@ export interface Finding {
   readonly details?: FindingDetails;
   /** The reachability class of a subject that is no declaration, where it is not `certain`. */
   readonly reachabilityClass?: Confidence;
+  /** Whether references to a subject that is no declaration exist, all from dead code. */
+  readonly unreachableOnly?: true;
+  /** The dead declarations and files whose component a subject that is no declaration falls with. */
+  readonly fallsWith?: readonly string[];
 }
 
 /** The dead component a finding names, as the finding schema spells its members. */

package/src/findings/completion.ts

@@ -6,6 +6,7 @@
 
 import type { RunSweep } from "../analysis.ts";
 import { componentId, type Component } from "../components.ts";
+import { deadComponents } from "../matrix.ts";
 import type { Cascade, Confidence, Severity } from "../config.ts";
 import type { CompletedFinding, Finding, FindingComponent, PositionedSymbol } from "../finding.ts";
 import { OUTSIDE, type Graph } from "../graph.ts";
@@ -15,9 +16,26 @@ import { byPosition, positionKey } from "../position.ts";
 import { declarationKey } from "../ref.ts";
 import { FAMILY_KEY_LENGTH } from "../resolve.ts";
 import { isPartSubject, isRowSubject, type Dials } from "../suppress.ts";
+import type { Candidate } from "../sweep.ts";
 import type { Boundary } from "./boundary.ts";
 import type { EmitterInput } from "./emitter.ts";
 
+/** The unused-file code, whose deletion removes every use its file writes. */
+const FILE_NEVER_IMPORTED = "DS1502";
+
+/**
+ * The codes whose subject the run that counts test references holds live, as
+ * finding.schema.json lists them, so a test file's candidate reported under one carries
+ * none of a dead declaration's sweep facts.
+ */
+const LIVE_SUBJECT: ReadonlySet<string> = new Set([
+  "DS1101",
+  "DS1102",
+  "DS1104",
+  "DS1204",
+  "DS1301",
+]);
+
 /** The fixability grammar/analysis.md "Fixability" gives a finding about a held declaration. */
 const MANUAL = "manual";
 
@@ -94,17 +112,11 @@ function testedByIn(input: EmitterInput): ReadonlySet<string> {
  * 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. Test-support code test code references, outside the test-of-dead-code
- * rule, what it contains, and a member an `in` expression tests by name are `possible`.
+ * consumer set. A member an `in` expression tests by name is `possible`.
  */
 function reachabilityClasses(input: EmitterInput): (id: string) => Confidence {
   const tested = testedByIn(input);
   const published = publishedIds(input.swept.matrix.union);
-  const usedByTests = new Set(
-    input.swept.sweep.candidates
-      .filter((candidate) => candidate.heldByTests !== undefined)
-      .map((candidate) => candidate.id),
-  );
   const { declared } = input.boundary.consumers;
   const outside: Confidence =
     declared.length === 0
@@ -113,7 +125,7 @@ function reachabilityClasses(input: EmitterInput): (id: string) => Confidence {
         ? "certain"
         : "probable";
   return (id) => {
-    if (usedByTests.has(id) || tested.has(id)) {
+    if (tested.has(id)) {
       return "possible";
     }
     return published.has(id) ? outside : "certain";
@@ -141,7 +153,12 @@ function testCeilings(
     for (const edge of union.out[union.at(id)] ?? []) {
       const target = union.symbols[edge.to];
       const testCode = union.test[edge.to] === true || union.support[edge.to] === true;
-      if (target !== undefined && !testCode && union.subject[edge.to] === true) {
+      if (
+        target !== undefined &&
+        !testCode &&
+        union.ambient[edge.to] !== true &&
+        union.subject[edge.to] === true
+      ) {
         lowest = capped(lowest, classOf(target.id));
       }
     }
@@ -149,16 +166,32 @@ function testCeilings(
   };
 }
 
+/**
+ * The ceiling the roots the run found put on one dead subject: a subject other declarations
+ * reference, found dead only because no root reaches them, is `probable` unless
+ * the configuration declares the roots complete, because a root the analysis cannot see
+ * would make it live; every other declaration has none below `certain`.
+ */
+function rootsCeiling(
+  input: EmitterInput,
+  finding: Finding,
+  candidate: Candidate | undefined,
+): Confidence {
+  const unreachable = candidate?.relation === "reachability" || finding.unreachableOnly === true;
+  return unreachable && !input.config.ts.rootsComplete ? "probable" : "certain";
+}
+
 /**
  * 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,
+  components: readonly Component[],
   cascade: Cascade,
 ): (id: string) => FindingComponent | undefined {
   const held = new Map<string, Component>();
-  for (const component of swept.sweep.components) {
+  for (const component of components) {
     for (const member of component.members) {
       held.set(member, component);
     }
@@ -196,6 +229,77 @@ function findingComponents(
   };
 }
 
+/**
+ * The run's dead components with each file a `DS1502` finding reports dead among them, so
+ * the file's declarations fall with it, and with the components each subject that is no
+ * declaration falls with joined into one.
+ */
+function runComponents(
+  swept: RunSweep,
+  findings: readonly Finding[],
+): {
+  readonly components: readonly Component[];
+  readonly computed: number;
+  readonly files: ReadonlyMap<string, string>;
+} {
+  const union = swept.matrix.union;
+  const reported = new Set(
+    findings.filter((one) => one.code === FILE_NEVER_IMPORTED).map((one) => one.position.path),
+  );
+  const files = new Map(
+    union.symbols.flatMap((symbol, at) =>
+      symbol.kind === "file" && reported.has(symbol.position.path) ? [[at, symbol] as const] : [],
+    ),
+  );
+  const computed =
+    files.size === 0
+      ? swept.sweep.components
+      : deadComponents(swept.matrix, swept.sweep, new Set(files.keys()));
+  const place = new Map<string, number>();
+  computed.forEach((component, at) => {
+    for (const member of component.members) {
+      place.set(member, at);
+    }
+  });
+  const leader = computed.map((_component, at) => at);
+  const find = (at: number): number => {
+    let top = at;
+    while ((leader[top] ?? top) !== top) {
+      top = leader[top] ?? top;
+    }
+    return top;
+  };
+  for (const { fallsWith } of findings) {
+    const joined = (fallsWith ?? []).flatMap((id) => place.get(id) ?? []).map(find);
+    const first = Math.min(...joined);
+    for (const one of joined) {
+      leader[one] = first;
+    }
+  }
+  const merged = new Map<number, Component>();
+  computed.forEach((component, at) => {
+    const top = find(at);
+    const into = merged.get(top);
+    merged.set(
+      top,
+      into === undefined
+        ? component
+        : {
+            id: into.id,
+            members: [...into.members, ...component.members],
+            roots: [...into.roots, ...component.roots],
+            deletableLines: into.deletableLines + component.deletableLines,
+            held: into.held && component.held,
+          },
+    );
+  });
+  return {
+    components: [...merged.values()],
+    computed: computed.length,
+    files: new Map([...files.values()].map((symbol) => [symbol.position.path, symbol.id])),
+  };
+}
+
 /**
  * Every finding of the run completed, in the order given. A dead declaration carries its
  * candidate's relation, counts, configurations and component; a live one carries no relation and
@@ -217,12 +321,12 @@ export function completed(
   const candidates = new Map(swept.sweep.candidates.map((candidate) => [candidate.id, candidate]));
   const classOf = reachabilityClasses(input);
   const ceilingOf = testCeilings(input, classOf);
-  const componentOf = findingComponents(swept, input.config.reporters.cascade);
-  const held = new Set(
-    swept.sweep.components.filter((one) => one.held).flatMap((one) => one.members),
-  );
-  let minted = swept.sweep.components.length;
-  const dead = new Set(swept.sweep.components.map((component) => component.id));
+  const { components, computed, files } = runComponents(swept, findings);
+  const componentOf = findingComponents(swept, components, input.config.reporters.cascade);
+  const held = new Set(components.filter((one) => one.held).flatMap((one) => one.members));
+  // A join keeps its first component's identifier, so a minted one counts past every computed one.
+  let minted = computed;
+  const dead = new Set(components.map((component) => component.id));
   const fallingWith = new Map<string, number>();
   for (const { heldByTests } of swept.sweep.candidates) {
     if (heldByTests !== undefined) {
@@ -239,18 +343,33 @@ export function completed(
     // a row is still never the declaration. Two declarations of one file can share a
     // reference, so the one the finding is positioned at is the subject where there is one.
     const declared = union.at(positionKey(finding.position));
+    const ref = finding.symbol.holder ?? finding.symbol.ref;
     const at = isRowSubject(finding.symbol.kind)
       ? OUTSIDE
-      : union.symbols[declared]?.ref === finding.symbol.ref
+      : union.symbols[declared]?.ref === ref
         ? declared
-        : (positions.get(declarationKey(finding.symbol.ref, finding.position.path)) ?? OUTSIDE);
+        : (positions.get(declarationKey(ref, finding.position.path)) ?? 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 = !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);
+    const candidate =
+      judged === undefined || LIVE_SUBJECT.has(finding.code)
+        ? undefined
+        : candidates.get(judged.id);
+    const fallsWith = finding.fallsWith?.[0];
+    const joined = fallsWith === undefined ? undefined : componentOf(fallsWith);
+    const file =
+      finding.code === FILE_NEVER_IMPORTED ? files.get(finding.position.path) : undefined;
+    const found =
+      joined !== undefined
+        ? { ...joined, root: false }
+        : file !== undefined
+          ? componentOf(file)
+          : symbol === undefined || part
+            ? undefined
+            : componentOf(symbol.id);
     // 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 (
@@ -287,9 +406,13 @@ export function completed(
         ? MANUAL
         : row.fixability;
     const lastUses =
-      fixability === "deletable" && candidate !== undefined
-        ? input.dependencies.lastUses.get(candidate.id)
-        : undefined;
+      fixability !== "deletable"
+        ? undefined
+        : candidate !== undefined
+          ? input.dependencies.lastUses.get(candidate.id)
+          : finding.code === FILE_NEVER_IMPORTED
+            ? input.dependencies.fileLastUses.get(finding.position.path)
+            : undefined;
     return {
       code: finding.code,
       kind: row.name,
@@ -298,7 +421,7 @@ export function completed(
       symbol: finding.symbol,
       reachabilityClass,
       confidence: capped(
-        capped(reachabilityClass, row.maxClass),
+        capped(capped(reachabilityClass, row.maxClass), rootsCeiling(input, finding, candidate)),
         judged === undefined ? "certain" : ceilingOf(judged.id),
       ),
       ...(candidate === undefined ? {} : { livenessRelation: candidate.relation }),

package/src/findings/dependencies-and-module-machinery.ts

@@ -1,48 +1,110 @@
 import { declarationKey, type Dependencies } from "../dependencies.ts";
 import type { Finding } from "../finding.ts";
 import { renderRef, type DependencySection } from "../ref.ts";
-import type { Emitter } from "./emitter.ts";
+import type { Emitter, EmitterInput } from "./emitter.ts";
+import { nonCodeArtifacts } from "./non-code-artifacts.ts";
 
 const UNUSED_DEPENDENCY = "DS1601";
 
+const FILE_NEVER_IMPORTED = "DS1502";
+
 const MESSAGES: Readonly<Record<DependencySection, string>> = {
   dependency: "no import in the target needs the declared dependency",
   "dev-dependency": "no import in the target needs the declared development dependency",
   "peer-dependency": "no import in the target needs the declared peer dependency",
 };
 
+const DEAD_USERS_MESSAGES: Readonly<Record<DependencySection, string>> = {
+  dependency: "only code that is itself dead uses the declared dependency",
+  "dev-dependency": "only code that is itself dead uses the declared development dependency",
+  "peer-dependency": "only code that is itself dead uses the declared peer dependency",
+};
+
+/** How the run judged the declarations and files a dependency's uses may sit in. */
+interface DeadCode {
+  /** The members of the dead components, and the top level of each file reported unimported. */
+  readonly dead: ReadonlySet<string>;
+  /** Those found dead under reachability alone. */
+  readonly reachedOnly: ReadonlySet<string>;
+  /** The declarations of a library's published API, whose findings sit at the consumers' class. */
+  readonly published: ReadonlySet<string>;
+}
+
+/**
+ * The run's dead code: test code keeps the code it references out of every dead component
+ * unless that code is dead as well, and a file's top level is dead where the file is.
+ */
+function deadCode(input: EmitterInput): DeadCode {
+  const { swept } = input;
+  const union = swept.matrix.union;
+  const files = new Map(
+    union.symbols.filter((one) => one.kind === "file").map((one) => [one.position.path, one.id]),
+  );
+  const dead = new Set(swept.sweep.components.flatMap((component) => component.members));
+  const reachedOnly = new Set(
+    swept.sweep.candidates.filter((one) => one.relation === "reachability").map((one) => one.id),
+  );
+  for (const finding of nonCodeArtifacts(input)) {
+    const id = files.get(finding.position.path);
+    if (finding.code === FILE_NEVER_IMPORTED && id !== undefined) {
+      dead.add(id);
+      if (finding.unreachableOnly === true) {
+        reachedOnly.add(id);
+      }
+    }
+  }
+  const published = new Set(
+    union.rooted
+      .filter((root) => root.kind === "published-api")
+      .flatMap((root) => union.symbols[root.at]?.id ?? []),
+  );
+  return { dead, reachedOnly, published };
+}
+
 /**
  * A dependency, development dependency or peer dependency of a manifest the run reads
- * that the target does not need, at the position of its key.
+ * that the target does not need, at the position of its key, and one whose every use is
+ * held by dead code, which is dead only through that code and falls with its component:
+ * at `possible` where one of its holders is published, and found under reachability alone
+ * where one of them is.
  */
-function unusedDependencies(dependencies: Dependencies): Finding[] {
-  return dependencies.declared
-    .filter(
-      (dependency) =>
-        !dependencies.needed.has(declarationKey(dependency)) &&
-        !dependencies.ran.has(declarationKey(dependency)),
-    )
-    .map((dependency) => ({
-      code: UNUSED_DEPENDENCY,
-      position: dependency.position,
-      symbol: {
-        ref: renderRef(dependency.manifest, {
-          of: "dependency",
+function unusedDependencies(input: EmitterInput, dependencies: Dependencies): Finding[] {
+  const { dead, reachedOnly, published } = deadCode(input);
+  return dependencies.declared.flatMap((dependency) => {
+    const key = declarationKey(dependency);
+    const held = dependencies.heldBy.get(key);
+    const users = held?.every((id) => dead.has(id)) === true ? held : undefined;
+    if (dependencies.ran.has(key) || (dependencies.needed.has(key) && users === undefined)) {
+      return [];
+    }
+    const unbuilt = dependencies.unbuilt.has(dependency.position.path);
+    const atPossible = unbuilt || users?.some((id) => published.has(id)) === true;
+    return [
+      {
+        code: UNUSED_DEPENDENCY,
+        position: dependency.position,
+        symbol: {
+          ref: renderRef(dependency.manifest, {
+            of: "dependency",
+            name: dependency.name,
+            section: dependency.section,
+          }),
+          kind: "dependency",
           name: dependency.name,
-          section: dependency.section,
-        }),
-        kind: "dependency",
-        name: dependency.name,
-        sizeLines: 1,
+          sizeLines: 1,
+        },
+        message: (users === undefined ? MESSAGES : DEAD_USERS_MESSAGES)[dependency.section],
+        details: { dependencyClass: dependency.section },
+        ...(atPossible ? { reachabilityClass: "possible" as const } : {}),
+        ...(users?.some((id) => reachedOnly.has(id)) === true
+          ? { unreachableOnly: true as const }
+          : {}),
+        ...(users === undefined ? {} : { fallsWith: users }),
       },
-      message: MESSAGES[dependency.section],
-      details: { dependencyClass: dependency.section },
-      ...(dependencies.unbuilt.has(dependency.position.path)
-        ? { reachabilityClass: "possible" as const }
-        : {}),
-    }));
+    ];
+  });
 }
 
 /** The findings of the dependencies-and-module-machinery family, `DS1600` to `DS1699`. */
-export const dependenciesAndModuleMachinery: Emitter = ({ dependencies }) =>
-  unusedDependencies(dependencies);
+export const dependenciesAndModuleMachinery: Emitter = (input) =>
+  unusedDependencies(input, input.dependencies);

package/src/findings/emitters.ts

@@ -165,7 +165,7 @@ function dialledOver(
   const unanswered = heldKeys(input);
   const markup = markupKeys(input);
   const candidates = found.filter((finding) => {
-    const key = declarationKey(finding.symbol.ref, finding.position.path);
+    const key = declarationKey(finding.symbol.holder ?? finding.symbol.ref, finding.position.path);
     return (
       !ledger.withheld(finding) &&
       !unanswered.has(key) &&