@cplieger/deadset-ts 6.0.0 → 6.1.0

package/src/edges.ts

@@ -200,9 +200,10 @@ function compare(a: string, b: string): number {
 
 /**
  * Evaluates every declared side of this language over the run's findings. A side naming a
- * symbol the run enumerates nothing under is `absent`; one naming a symbol the run holds a
- * finding about is `dead` and carries that finding, pending until a merge reads the other
- * side and reported nowhere else, a narrowing finding included; any other is `live`.
+ * symbol the run enumerates nothing under is `absent`; otherwise it is evaluated once per
+ * declaration its reference spells. A declaration the run holds a finding about is `dead`
+ * and carries that finding, pending until a merge reads the other side and reported
+ * nowhere else, a narrowing finding included; any other is `live`.
  */
 export function evaluateEdges<F extends Finding>(
   findings: readonly F[],
@@ -212,10 +213,10 @@ export function evaluateEdges<F extends Finding>(
   if (sides.length === 0) {
     return { findings, evaluations: [] };
   }
-  const byRef = new Map<string, string>();
+  const byRef = new Map<string, string[]>();
   for (const symbol of symbols) {
-    if (symbol.kind !== "file" && !byRef.has(symbol.ref)) {
-      byRef.set(symbol.ref, symbol.id);
+    if (symbol.kind !== "file") {
+      byRef.set(symbol.ref, [...(byRef.get(symbol.ref) ?? []), symbol.id]);
     }
   }
   const held = new Map<string, number>();
@@ -226,18 +227,20 @@ export function evaluateEdges<F extends Finding>(
   });
 
   const pending = new Set<number>();
-  const evaluations = sides.map((side): EdgeEvaluation<F> => {
-    const id = byRef.get(side.symbol);
-    if (id === undefined) {
-      return { ...side, state: "absent" };
+  const evaluations = sides.flatMap((side): EdgeEvaluation<F>[] => {
+    const ids = byRef.get(side.symbol);
+    if (ids === undefined) {
+      return [{ ...side, state: "absent" }];
     }
-    const at = held.get(id);
-    const finding = at === undefined ? undefined : findings[at];
-    if (at === undefined || finding === undefined) {
-      return { ...side, state: "live" };
-    }
-    pending.add(at);
-    return { ...side, state: "dead", finding };
+    return ids.map((id) => {
+      const at = held.get(id);
+      const finding = at === undefined ? undefined : findings[at];
+      if (at === undefined || finding === undefined) {
+        return { ...side, state: "live" };
+      }
+      pending.add(at);
+      return { ...side, state: "dead", finding };
+    });
   });
   evaluations.sort((a, b) => compare(a.edge, b.edge) || compare(a.side, b.side));
   return { findings: findings.filter((_finding, at) => !pending.has(at)), evaluations };

package/src/findings/completion.ts

@@ -10,7 +10,8 @@ import type { Cascade, Confidence, Severity } from "../config.ts";
 import type { CompletedFinding, Finding, FindingComponent, PositionedSymbol } from "../finding.ts";
 import { OUTSIDE, type Graph } from "../graph.ts";
 import { KINDS, type KindRow } from "../kinds.ts";
-import { byPosition } from "../position.ts";
+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 { Boundary } from "./boundary.ts";
@@ -149,7 +150,9 @@ export function completed(
 ): readonly CompletedFinding[] {
   const { swept } = input;
   const union = swept.matrix.union;
-  const positions = new Map(union.symbols.map((symbol, at) => [symbol.ref, at]));
+  const positions = new Map(
+    union.symbols.map((symbol, at) => [declarationKey(symbol.ref, symbol.position.path), at]),
+  );
   const candidates = new Map(swept.sweep.candidates.map((candidate) => [candidate.id, candidate]));
   const classOf = reachabilityClasses(input);
   const componentOf = findingComponents(swept, input.config.reporters.cascade);
@@ -168,10 +171,14 @@ export function completed(
       throw new Error(`${finding.code} names no live row of the issue-kind vocabulary`);
     }
     // A row's reference may spell a declaration's, as an ignore entry naming one does, and
-    // a row is still never the declaration.
+    // 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 at = isRowSubject(finding.symbol.kind)
       ? OUTSIDE
-      : (positions.get(finding.symbol.ref) ?? OUTSIDE);
+      : union.symbols[declared]?.ref === finding.symbol.ref
+        ? declared
+        : (positions.get(declarationKey(finding.symbol.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);

package/src/findings/emitters.ts

@@ -2,6 +2,7 @@ import type { Confidence } from "../config.ts";
 import { evaluateEdges, type EdgeEvaluation } from "../edges.ts";
 import type { CompletedFinding } from "../finding.ts";
 import { liveFilesAt } from "../matrix.ts";
+import { declarationKey } from "../ref.ts";
 import { ledgerOf, type Dials, type Ledger, type SuppressionRecord } from "../suppress.ts";
 import { insideSkipped } from "../type-errors.ts";
 import { completed, dialsOf, reportable } from "./completion.ts";
@@ -28,10 +29,10 @@ export const EMITTERS: Emitters = new Map<string, Emitter>([
 ]);
 
 /**
- * The references of every declaration an unanswered question could have kept live, which
- * the run reports nothing about: a finding about one would be computed from the gap.
+ * The keys of every declaration an unanswered question could have kept live, which the run
+ * reports nothing about: a finding about one would be computed from the gap.
  */
-function heldRefs(input: EmitterInput): ReadonlySet<string> {
+function heldKeys(input: EmitterInput): ReadonlySet<string> {
   const held = new Set(input.swept.heldByUnanswered);
   if (held.size === 0) {
     return held;
@@ -39,16 +40,16 @@ function heldRefs(input: EmitterInput): ReadonlySet<string> {
   return new Set(
     input.swept.matrix.union.symbols
       .filter((symbol) => held.has(symbol.id))
-      .map((symbol) => symbol.ref),
+      .map((symbol) => declarationKey(symbol.ref, symbol.position.path)),
   );
 }
 
 /**
- * The references of every top-level declaration of a live component file. The file's
+ * The keys of every top-level declaration of a live component file. The file's
  * markup may use each of them, which no analysis of the markup can rule out, so the run
  * reports nothing about one while the file is live.
  */
-function markupRefs(input: EmitterInput): ReadonlySet<string> {
+function markupKeys(input: EmitterInput): ReadonlySet<string> {
   const { swept } = input;
   if (swept.componentFiles.length === 0) {
     return new Set();
@@ -61,7 +62,7 @@ function markupRefs(input: EmitterInput): ReadonlySet<string> {
   return new Set(
     swept.matrix.union.symbols
       .filter((symbol) => live.has(symbol.parent))
-      .map((symbol) => symbol.ref),
+      .map((symbol) => declarationKey(symbol.ref, symbol.position.path)),
   );
 }
 
@@ -126,8 +127,7 @@ function dialsOver(
  * family's findings completed by one step, so every component number is minted once, the
  * finding each record claims withheld, the rest withheld by the dials, so a root one family
  * reports withholds what another reports in its component, and every declared edge
- * evaluated over what remains, so a pending finding is in its evaluation alone. What the
- * minimum confidence withheld is what the same decision at the lowest minimum adds.
+ * evaluated over what remains, so a pending finding is in its evaluation alone.
  */
 export function decidedFindings(
   input: EmitterInput,
@@ -137,20 +137,7 @@ export function decidedFindings(
   const unmarked =
     suppressed.records.length === 0 ? [] : completedOver(suppressed.unmarked, fallenMembers);
   const would = [...unmarked, ...found];
-  const decided = dialledOver(input, suppressed, found, unmarked);
-  const shown =
-    input.config.analysis.minConfidence === "possible"
-      ? decided
-      : dialledOver(
-          atPossible(input),
-          {
-            unmarked: atPossible(suppressed.unmarked),
-            records: suppressed.records,
-          },
-          found,
-          unmarked,
-        );
-  return { ...decided, would, withheld: withheldOf(decided.findings, shown.findings) };
+  return { ...dialledOver(input, suppressed, found, unmarked), would };
 }
 
 /** The run's input with the minimum confidence at its lowest, which withholds nothing. */
@@ -172,46 +159,46 @@ function dialledOver(
   suppressed: Suppressed,
   found: readonly CompletedFinding[],
   unmarked: readonly CompletedFinding[],
-): Omit<DecidedFindings, "would" | "withheld"> {
+): Omit<DecidedFindings, "would"> {
   const would = [...unmarked, ...found];
   const ledger = ledgerOf(suppressed.records, would, dialsOver(input, found, suppressed, unmarked));
-  const unanswered = heldRefs(input);
-  const markup = markupRefs(input);
-  const kept = reportable(
-    input,
-    found.filter(
-      (finding) =>
-        !ledger.withheld(finding) &&
-        !unanswered.has(finding.symbol.ref) &&
-        !markup.has(finding.symbol.ref) &&
-        !insideSkipped(input.swept.skipped, finding.position),
-    ),
-  );
+  const unanswered = heldKeys(input);
+  const markup = markupKeys(input);
+  const candidates = found.filter((finding) => {
+    const key = declarationKey(finding.symbol.ref, finding.position.path);
+    return (
+      !ledger.withheld(finding) &&
+      !unanswered.has(key) &&
+      !markup.has(key) &&
+      !insideSkipped(input.swept.skipped, finding.position)
+    );
+  });
+  const kept = reportable(input, candidates);
   const evaluated = evaluateEdges(kept, input.boundary.edges, input.swept.matrix.union.symbols);
-  return { findings: evaluated.findings, evaluations: evaluated.evaluations, ledger };
+  return {
+    findings: evaluated.findings,
+    evaluations: evaluated.evaluations,
+    ledger,
+    withheld: withheldOf(input, candidates),
+  };
 }
 
-/** The findings the lowest minimum would report that the run does not, counted by confidence. */
-function withheldOf(
-  reported: readonly CompletedFinding[],
-  shown: readonly CompletedFinding[],
-): Withheld {
-  const kept = new Set(reported.map(findingKey));
+/**
+ * The findings the dials withhold only because their confidence is below the minimum, each
+ * counted at the confidence this run gives it: the dials at the lowest minimum keep them.
+ */
+function withheldOf(input: EmitterInput, candidates: readonly CompletedFinding[]): Withheld {
+  const dials = dialsOf(input, candidates);
+  const lowest = dialsOf(atPossible(input), candidates);
   const counts = { certain: 0, probable: 0, possible: 0 };
-  for (const finding of shown) {
-    if (!kept.has(findingKey(finding))) {
+  for (const finding of candidates) {
+    if (dials.withholds(finding) && !lowest.withholds(finding)) {
       counts[finding.confidence] += 1;
     }
   }
   return counts;
 }
 
-/** A finding's identity across two decisions of one run: its position, code and subject. */
-function findingKey(finding: CompletedFinding): string {
-  const { path, line, column } = finding.position;
-  return JSON.stringify([path, line, column, finding.code, finding.symbol.ref]);
-}
-
 /** Every finding the run reports, each family's in table order. */
 export function findingsOf(input: EmitterInput): readonly CompletedFinding[] {
   return decidedFindings(input).findings;

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

@@ -2,6 +2,7 @@ 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";
 
 /** The codes of this family. */
@@ -242,12 +243,16 @@ function unusedTypeParameters(run: Run): readonly Finding[] {
 }
 
 /**
- * The references of the declarations the write-only kind reports, whatever the
+ * The keys 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));
+  return new Set(
+    writeOnlySymbols(indexed(input)).map((finding) =>
+      declarationKey(finding.symbol.ref, finding.position.path),
+    ),
+  );
 }
 
 /**

package/src/findings/visibility-narrowing.ts

@@ -2,6 +2,7 @@ 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 { declarationKey } from "../ref.ts";
 import type { RootKind } from "../roots.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
 import { writeOnlyDeclarations } from "./reads-and-writes.ts";
@@ -159,7 +160,7 @@ function narrowing(
   const file = facts.fileOf[at] ?? OUTSIDE;
   if (
     !topLevelExport(facts, at, symbol) ||
-    world.writeOnly.has(symbol.ref) ||
+    world.writeOnly.has(declarationKey(symbol.ref, symbol.position.path)) ||
     symbol.kind === "export-alias" ||
     entersByName(facts.rootedBy[at]) ||
     entersByName(facts.rootedBy[file]) ||

package/src/inventory.ts

@@ -1110,7 +1110,12 @@ function refOf(record: Building, chain: readonly Component[]): string {
     return renderRef(record.module, { of: "module" });
   }
   if (record.kind === "export-alias") {
-    return renderRef(record.module, { of: "alias", name: record.component.text });
+    const block = record.parentChain.at(-1);
+    return renderRef(record.module, {
+      of: "alias",
+      name: record.component.text,
+      ...(block === undefined ? {} : { block: block.text }),
+    });
   }
   return renderRef(record.module, {
     of: "declaration",

package/src/module-declarations.ts

@@ -26,7 +26,7 @@ import {
 import { nodeKey, type Inventory, type InventorySymbol } from "./inventory.ts";
 import { renderPosition } from "./position.ts";
 import { UNANSWERED } from "./query.ts";
-import { nameComponent } from "./ref.ts";
+import { aliasFragment, nameComponent } from "./ref.ts";
 import type { Reference } from "./references.ts";
 import type { ProjectView } from "./session.ts";
 
@@ -110,7 +110,7 @@ interface Named {
  * The module declarations of an inventory a specifier names by name or pattern, each with
  * the members that hold the export names given.
  */
-export function namedBy(
+function namedBy(
   held: Inventory,
 ): (specifier: string, names: readonly string[]) => readonly Named[] {
   if (held.modules.size === 0) {
@@ -139,7 +139,7 @@ export function namedBy(
       const wanted = new Set(
         names.flatMap((one) => [
           `${ref}.${nameComponent(one)}`,
-          `${scope}#${nameComponent(one)}:alias`,
+          `${scope}#${aliasFragment(one, name)}`,
         ]),
       );
       const members = (children.get(id) ?? []).filter((child) => wanted.has(child.ref));

package/src/outside-tests.ts

@@ -1,10 +1,10 @@
 /**
  * The test files no compiler configuration of a run holds. The runner executes them all
  * the same, so each module one names is a test reference: the own file a relative
- * specifier names, and the declarations that file exports under the names read from it,
- * or a module declaration the specifier names by name or pattern and its members of
- * those names. Such a file is read without a program, so what its body references
- * beyond the modules it names is not known.
+ * specifier names, and the declarations that file exports under the names read from it.
+ * No compiler run reads a module declaration for such a file, so its imports name none.
+ * Such a file is read without a program, so what its body references beyond the modules
+ * it names is not known.
  */
 
 import {
@@ -23,7 +23,7 @@ import { RESOLVED_EXTENSIONS, type ParseFile } from "./configuration-files.ts";
 import { emittedFrom } from "./emit-map.ts";
 import type { Host } from "./host.ts";
 import type { Inventory } from "./inventory.ts";
-import { namedBy, namesImported } from "./module-declarations.ts";
+import { namesImported } from "./module-declarations.ts";
 import { dirnamePath, joinPath, normalizePath, queriedModulePath } from "./paths.ts";
 import { renderPosition } from "./position.ts";
 import { nameComponent } from "./ref.ts";
@@ -154,7 +154,6 @@ export function outsideTestReferences(
       exported.set(key, [...(exported.get(key) ?? []), symbol.id]);
     }
   }
-  const declared = namedBy(held);
   const found: Reference[] = [];
   for (const { path, file } of tests) {
     const from = `${path}#`;
@@ -164,11 +163,6 @@ export function outsideTestReferences(
       const read = (to: string, use: Reference["use"]): void => {
         found.push({ from, to, position, use, resolution: "syntax", test: true, unheld: true });
       };
-      for (const declaration of declared(named.text, named.names)) {
-        for (const to of [declaration.id, ...declaration.members]) {
-          read(to, "read");
-        }
-      }
       const written = named.text.includes("?") ? queriedModulePath(named.text) : named.text;
       if (written === undefined) {
         continue;

package/src/overrides.ts

@@ -1,9 +1,10 @@
 /**
  * The overrides of the target's class members. A call through the base class names the
  * base's member and runs the override of whichever subclass the value is, so the base
- * member's declaration references every override. A method overriding a member of a class
- * declared outside the target, at any depth of its `extends` chain, is called by outside
- * code holding the instance through that class, so its own class references it.
+ * member's declaration references every override. A method, an accessor or a property,
+ * static or not, overriding a member of a class declared outside the target, at any depth
+ * of its `extends` chain, is used by outside code holding the instance or the class
+ * through that class, so its own class references it.
  */
 
 import {
@@ -19,8 +20,9 @@ import {
 import type { AliasChains } from "./alias-chain.ts";
 import { memberComponent } from "./class-members.ts";
 import { nodeKey, type Inventory, type InventorySymbol } from "./inventory.ts";
-import { SymbolFlags, type Symbol as TSSymbol } from "@typescript/native/unstable/sync";
+import { SymbolFlags, type Symbol as TSSymbol, type Type } from "@typescript/native/unstable/sync";
 import { UNANSWERED } from "./query.ts";
+import { nameComponent } from "./ref.ts";
 import type { Reference } from "./references.ts";
 import type { ProjectView } from "./session.ts";
 
@@ -60,7 +62,7 @@ function extending<Brand>(
 
 /**
  * The references each base class member makes to its overrides, for the classes of one
- * project that extend another class of the target, and each class makes to its methods
+ * project that extend another class of the target, and each class makes to its members
  * that override a member of a class declared outside the target. A member a nearer base
  * already overrides is reached through that override. A private member is not
  * overridden. Each reference is placed at the override and made by its file.
@@ -134,7 +136,7 @@ export function overrideReferences<Brand>(
   const outsideNames = outsideMemberNames(project, bases, outsideBases);
   for (const [classId, names] of outsideNames) {
     for (const [component, member] of members.get(classId) ?? []) {
-      if (member.kind === "method" && names.has(component)) {
+      if (names.has(component)) {
         found.push({
           from: classId,
           to: member.id,
@@ -166,7 +168,8 @@ export function overrideReferences<Brand>(
 
 /**
  * Per class of the target with a class declared outside the target in its `extends`
- * chain, the names of the members that outside class's instances carry.
+ * chain, the member components that outside class's instances and constructor carry, a
+ * static one spelled as a static member's component is.
  */
 function outsideMemberNames<Brand>(
   project: ProjectView<Brand>,
@@ -175,10 +178,16 @@ function outsideMemberNames<Brand>(
 ): ReadonlyMap<string, ReadonlySet<string>> {
   const direct = new Map<string, ReadonlySet<string>>();
   for (const [classId, base] of outsideBases) {
-    const type = project.queries.declaredTypeOf(base);
-    const properties = type === UNANSWERED ? UNANSWERED : project.queries.propertiesOf(type);
-    if (properties !== UNANSWERED) {
-      direct.set(classId, new Set(properties.map((property) => property.escapedName)));
+    const instance = project.queries.declaredTypeOf(base);
+    const statics = project.queries.typeOfSymbol(base);
+    const components = [
+      ...namesOf(project, instance === UNANSWERED ? undefined : instance).map(nameComponent),
+      ...namesOf(project, statics === UNANSWERED ? undefined : statics).map(
+        (name) => `${nameComponent(name)}:static`,
+      ),
+    ];
+    if (components.length > 0) {
+      direct.set(classId, new Set(components));
     }
   }
   const names = new Map<string, ReadonlySet<string>>();
@@ -200,3 +209,9 @@ function outsideMemberNames<Brand>(
   }
   return names;
 }
+
+/** The names of a type's properties; none where the type or its properties are unanswered. */
+function namesOf<Brand>(project: ProjectView<Brand>, type: Type | undefined): readonly string[] {
+  const properties = type === undefined ? UNANSWERED : project.queries.propertiesOf(type);
+  return properties === UNANSWERED ? [] : properties.map((property) => property.name);
+}

package/src/ref.ts

@@ -47,7 +47,7 @@ const MANIFEST_SCOPE = `${PREFIX}${TS_PACKAGE}/package\\.json`;
 export const REF_EXPRESSIONS: readonly string[] = [
   `^${SCOPE}#$`,
   `^${SCOPE}#${TS_HEAD}$`,
-  `^${SCOPE}#${TS_HEAD}:alias$`,
+  `^${SCOPE}#(?:${TS_QUOTED}\\.)?${TS_HEAD}:alias$`,
   `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+$`,
   `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+:static$`,
   `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})*(?::static)?<${TS_IDENT}>$`,
@@ -107,8 +107,12 @@ export type Fragment =
       readonly static: boolean;
       readonly typeParameter?: string;
     }
-  /** One export specifier, a symbol of its own beside the declaration it names. */
-  | { readonly of: "alias"; readonly name: string }
+  /**
+   * One export specifier, a symbol of its own beside the declaration it names. One
+   * written inside a `declare module` block carries the block's name, which is always
+   * quoted, so the aliases two blocks of one file declare under one name stay apart.
+   */
+  | { readonly of: "alias"; readonly name: string; readonly block?: string }
   /** One dependency of a manifest, scoped by that manifest. */
   | { readonly of: "dependency"; readonly name: string; readonly section: DependencySection };
 
@@ -124,6 +128,10 @@ export function nameComponent(name: string): string {
   if (IDENTIFIER.test(name) || PRIVATE_NAME.test(name)) {
     return name;
   }
+  return quoted(name);
+}
+
+function quoted(name: string): string {
   const escaped = name
     .replaceAll("\\", "\\\\")
     .replaceAll("'", "\\'")
@@ -142,6 +150,12 @@ export function computedComponent(text: string): string {
   return `[${text.replaceAll(ASCII_WHITESPACE, "")}]`;
 }
 
+/** The fragment of an export alias, inside the `declare module` block named, if one is. */
+export function aliasFragment(name: string, block?: string): string {
+  const head = block === undefined ? "" : `${quoted(block)}.`;
+  return `${head}${nameComponent(name)}:alias`;
+}
+
 function spell(component: Component): string {
   return component.computed ? computedComponent(component.text) : nameComponent(component.text);
 }
@@ -157,7 +171,7 @@ export function renderRef(module: Module, fragment: Fragment): string {
     case "module":
       return `${scope}#`;
     case "alias":
-      return `${scope}#${nameComponent(fragment.name)}:alias`;
+      return `${scope}#${aliasFragment(fragment.name, fragment.block)}`;
     case "dependency":
       return `${scope}#${fragment.name}:${fragment.section}`;
     case "declaration": {
@@ -169,6 +183,15 @@ export function renderRef(module: Module, fragment: Fragment): string {
   }
 }
 
+/**
+ * One declaration's key among a run's: its reference and the file that declares it. Two
+ * packages of one name spell one reference for two declarations, so the reference alone
+ * keys neither.
+ */
+export function declarationKey(ref: string, path: string): string {
+  return `${ref}\u0000${path}`;
+}
+
 /**
  * Whether one string is a reference of this language's grammar, in its canonical
  * spelling. A string that is not, whether misspelled or spelled in a form the

package/src/reporters/sarif.ts

@@ -1,6 +1,7 @@
 import type { Confidence, Severity } from "../config.ts";
 import { jsonChunks } from "../json-chunks.ts";
 import { KINDS, type KindRow } from "../kinds.ts";
+import { declarationKey } from "../ref.ts";
 import type { Report, WireFinding, WireStaleSuppression } from "../report.ts";
 import { lineHashes, symbolFingerprint } from "./fingerprint.ts";
 import { RenderError, type RenderOptions } from "./reporter.ts";
@@ -160,7 +161,10 @@ function relatedOf(found: WireFinding): readonly Related[] {
     related.push({ label: "write", at, endLine: at.end_line });
   }
   for (const one of found.component.members ?? []) {
-    if (one.ref !== found.symbol.ref) {
+    if (
+      declarationKey(one.ref, one.position.path) !==
+      declarationKey(found.symbol.ref, found.position.path)
+    ) {
       related.push({ label: "member", at: one.position, endLine: one.position.end_line });
     }
   }

package/src/suppress-file.ts

@@ -11,6 +11,7 @@ import { jsonChunks } from "./json-chunks.ts";
 import { joinPath } from "./paths.ts";
 import { positionAt, walkDocument } from "./json-document.ts";
 import type { Position } from "./position.ts";
+import { declarationKey } from "./ref.ts";
 import {
   CODE_FORM,
   SUPPRESSION_WITHOUT_REASON,
@@ -84,10 +85,6 @@ interface Read {
 /** The declarations of the run by reference and file, which is what an entry names. */
 type ByReference = ReadonlyMap<string, readonly InventorySymbol[]>;
 
-function referenceKey(ref: string, path: string): string {
-  return `${ref}\u0000${path}`;
-}
-
 /**
  * Reads one entry or row: the records it binds, the refusals it carries, or the
  * malformed value that ends the run.
@@ -148,7 +145,7 @@ function readRecord(value: unknown, site: Position, byReference: ByReference, sh
   if (refusals.length > 0) {
     return { records: [], refusals };
   }
-  const named = byReference.get(referenceKey(symbol, written.path)) ?? [];
+  const named = byReference.get(declarationKey(symbol, written.path)) ?? [];
   if (named.length === 0) {
     return { records: [{ ...written, bound: "" }], refusals: [] };
   }
@@ -158,7 +155,7 @@ function readRecord(value: unknown, site: Position, byReference: ByReference, sh
 function byReferenceOf(symbols: readonly InventorySymbol[]): ByReference {
   const byReference = new Map<string, InventorySymbol[]>();
   for (const symbol of symbols) {
-    const key = referenceKey(symbol.ref, symbol.position.path);
+    const key = declarationKey(symbol.ref, symbol.position.path);
     byReference.set(key, [...(byReference.get(key) ?? []), symbol]);
   }
   return byReference;

package/src/version.ts

@@ -4,4 +4,4 @@
  * independently of the analyzer's own version, which is the one the host answers
  * from the package the analyzer was installed from.
  */
-export const CONTRACT_VERSION = "6.0.0";
+export const CONTRACT_VERSION = "6.1.0";