@cplieger/deadset-ts 6.0.0 → 6.1.0

package/README.md

@@ -4,7 +4,7 @@
 
 deadset-ts finds dead code in TypeScript projects, down to class members, type members and dead stores inside functions, and writes a report your CI can fail on.
 
-It reads your `tsconfig.json` projects, `allowJs` JavaScript and Vue, Svelte and Astro scripts included, with the type information of TypeScript 7.1.0-dev.20261006.1, its one dependency. Your project keeps its own TypeScript version. A type error under that version skips the function or statement that holds it. deadset-ts reports and never edits your code. It is pre-release, tested only on Linux, needs Node.js 24 or later and is licensed under GPL-3.0-or-later.
+It reads your `tsconfig.json` projects, `allowJs` JavaScript and Vue, Svelte and Astro scripts included, with the type information of TypeScript 7.1.0-dev.20261007.1, its one dependency. Your project keeps its own TypeScript version. A type error under that version skips the function or statement that holds it. deadset-ts reports and never edits your code. It is pre-release, tested only on Linux, needs Node.js 24 or later and is licensed under GPL-3.0-or-later.
 
 ## Why use it
 

package/dist/src/configured-declarations.js

@@ -143,8 +143,8 @@ function modulesNamed(project, specifiers) {
     return modules;
 }
 /**
- * The declaration each entry names in one project. A symbol entry names the
- * inventory's declaration whose reference it spells exactly; a module entry names the
+ * The declaration each entry names in one project. A symbol entry names every
+ * declaration of the inventory whose reference it spells exactly; a module entry names the
  * declaration its path reaches from the exports of the module its specifier resolves
  * to; a global entry names the declaration its path reaches from the global scope.
  * Every alias along a path is followed to the declaration it stands for.
@@ -153,12 +153,14 @@ export function resolveEntries(project, held, entries) {
     if (entries.length === 0) {
         return [];
     }
-    const byRef = new Map(held.symbols.map((symbol) => [symbol.ref, symbol.id]));
+    const byRef = new Map();
+    for (const symbol of held.symbols) {
+        byRef.set(symbol.ref, [...(byRef.get(symbol.ref) ?? []), symbol.id]);
+    }
     const modules = modulesNamed(project, new Set(entries.flatMap((entry) => (entry.shape === "module" ? [entry.module] : []))));
     return entries.map((entry) => {
         if (entry.shape === "symbol") {
-            const id = byRef.get(entry.symbol);
-            return { entry, handles: new Set(), ids: new Set(id === undefined ? [] : [id]) };
+            return { entry, handles: new Set(), ids: new Set(byRef.get(entry.symbol) ?? []) };
         }
         const { components, static: isStatic } = componentsOf(entry.shape === "module" ? entry.name : entry.global);
         const [first = "", ...rest] = components;

package/dist/src/conformance-record.js

@@ -2,9 +2,9 @@
 // Regenerate it with `UPDATE_GOLDEN=1 npx vitest --run src/conformance.corpus.test.ts`.
 export const RECORD = {
     conformance: {
-        corpusVersion: "4.0.0",
+        corpusVersion: "4.1.0",
         result: "pass",
-        digest: "sha256:8250b61deb71467139bf4cbcaf10802cdabb1a2c2261a11a571fc1ff55bfc3dc",
+        digest: "sha256:167f770cdff2776fa7ab28b7ff6121c4d7bdb01d83c5ba0057d9303281614008",
     },
     gaps: [],
 };

package/dist/src/convention-rows.js

@@ -31,6 +31,11 @@ const APP_DIRECTORY_ENTRIES = [
 ];
 const SOLIDSTART_PLUGIN = { module: "@solidjs/start/config", export: "solidStart" };
 const NUXT_CONFIG = [`nuxt.config.${ANY_MODULE}`];
+const BABEL_CONFIG = [
+    "babel.config.{json,js,cjs,mjs,cts,mts,ts}",
+    ".babelrc",
+    ".babelrc.{json,js,cjs,mjs,cts}",
+];
 const STRYKER_CONFIG = "{stryker,.stryker}.{conf,config}.{json,js,mjs,cjs}";
 const STRYKER_MODULE = "{stryker,.stryker}.{conf,config}.{js,mjs,cjs}";
 const VITEST_CONFIG = `{vitest,vite}.config.${ANY_MODULE}`;
@@ -57,6 +62,19 @@ export const CONVENTION_ROWS = [
             },
         ],
     },
+    {
+        name: "babel",
+        package: "@babel/core",
+        range: ">=7.0.0 <9.0.0",
+        entries: [],
+        moves: [],
+        helpers: ["@babel/plugin-transform-runtime", "@babel/transform-runtime"].map((value) => ({
+            property: "plugins",
+            files: BABEL_CONFIG,
+            value,
+            package: "@babel/runtime",
+        })),
+    },
     {
         name: "eslint",
         package: "eslint",
@@ -229,6 +247,21 @@ export const CONVENTION_ROWS = [
             },
         ],
     },
+    {
+        name: "rolldown",
+        package: "rolldown",
+        range: ">=1.0.0 <2.0.0",
+        entries: [],
+        moves: [],
+        helpers: [
+            {
+                property: "transform.helpers.mode",
+                files: [`rolldown.config.${ANY_MODULE}`],
+                value: "Runtime",
+                package: "@oxc-project/runtime",
+            },
+        ],
+    },
     {
         name: "solidstart",
         package: "@solidjs/start",
@@ -275,7 +308,10 @@ export const CONVENTION_ROWS = [
         range: ">=7.0.0 <11.0.0",
         entries: [STRYKER_MODULE],
         moves: [],
-        selections: [{ property: "mutate", files: [STRYKER_CONFIG] }],
+        selections: [
+            { property: "mutate", files: [STRYKER_CONFIG] },
+            { property: "ignorePatterns", files: [STRYKER_CONFIG] },
+        ],
         shortNames: [
             {
                 property: "testRunner",
@@ -406,6 +442,36 @@ export const CONVENTION_ROWS = [
             },
         ],
     },
+    {
+        name: "swc",
+        package: "@swc/core",
+        range: ">=1.0.0 <2.0.0",
+        entries: [],
+        moves: [],
+        helpers: [
+            {
+                property: "jsc.externalHelpers",
+                files: [".swcrc"],
+                value: true,
+                package: "@swc/helpers",
+            },
+        ],
+    },
+    {
+        name: "vite",
+        package: "vite",
+        range: ">=8.0.0 <9.0.0",
+        entries: [],
+        moves: [],
+        helpers: [
+            {
+                property: "oxc.helpers.mode",
+                files: [VITE_CONFIG],
+                value: "Runtime",
+                package: "@oxc-project/runtime",
+            },
+        ],
+    },
     {
         name: "vitest",
         package: "vitest",

package/dist/src/conventions.js

@@ -13,6 +13,8 @@ import { globExpression } from "./glob.js";
 import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "./paths.js";
 import { satisfies } from "./version-range.js";
 const JSON_EXTENSION = ".json";
+/** A configuration file with no extension that its tool reads as a JSON document. */
+const JSON_RC = /^\.[\w-]+rc$/u;
 /** The sections an installed package is required by, so its absence fails the run. */
 const REQUIRED_SECTIONS = ["dependencies", "devDependencies"];
 const DEPENDENCY_SECTIONS = [
@@ -351,11 +353,10 @@ function readPath(object, keys, values, elements) {
     return undefined;
 }
 /**
- * Every string literal one file writes at one property's path inside the objects it is
- * read from, as {@link readProperty} reads them: the value itself, or each element of an
- * array value, whatever else the path holds.
+ * Every value one file writes at one property's path inside the objects it is read from,
+ * as {@link readProperty} reads them, whatever else the path holds.
  */
-function stringsAt(file, property, call) {
+function valuesAt(file, property, call) {
     const declared = declaredValues(file);
     const objects = call === undefined
         ? defaultExports(file).map((one) => objectOf(one, declared, true))
@@ -374,12 +375,9 @@ function stringsAt(file, property, call) {
             if (rest.length > 0) {
                 visit(held, rest);
             }
-            else if (literalText(held) !== undefined) {
+            else {
                 found.push(held);
             }
-            else if (isArrayLiteralExpression(held)) {
-                found.push(...held.elements.map(unwrapped).filter((one) => literalText(one) !== undefined));
-            }
         }
     };
     for (const object of objects) {
@@ -389,6 +387,32 @@ function stringsAt(file, property, call) {
     }
     return found;
 }
+/** The string literals among values: each value itself, or each element of an array value. */
+function stringsAt(file, property, call) {
+    return valuesAt(file, property, call).flatMap((held) => {
+        if (literalText(held) !== undefined) {
+            return [held];
+        }
+        return isArrayLiteralExpression(held)
+            ? held.elements.map(unwrapped).filter((one) => literalText(one) !== undefined)
+            : [];
+    });
+}
+/** Whether one value holds a helper setting's value, as {@link HelperReading} states it. */
+function holdsValue(held, value) {
+    if (value === true) {
+        return held.kind === SyntaxKind.TrueKeyword;
+    }
+    if (literalText(held) === value) {
+        return true;
+    }
+    return (isArrayLiteralExpression(held) &&
+        held.elements.some((element) => {
+            const one = unwrapped(element);
+            const first = isArrayLiteralExpression(one) ? one.elements[0] : one;
+            return first !== undefined && literalText(first) === value;
+        }));
+}
 /** The strings an applied row's selection keys hold, added per configuration file to `into`. */
 function selectedStrings(host, parse, dir, readings, into) {
     for (const reading of readings) {
@@ -527,7 +551,11 @@ function readingFiles(host, parse, dir, files) {
             catch {
                 continue;
             }
-            found.push({ name, text, file: parse(path, text) });
+            found.push({
+                name,
+                text,
+                file: parse(JSON_RC.test(name) ? `${path}${JSON_EXTENSION}` : path, text),
+            });
         }
     }
     return found;
@@ -563,6 +591,17 @@ function shortNameUses(host, parse, dir, manifest, readings) {
     }
     return [...used].filter((name) => declared.has(name)).sort(compare);
 }
+/** The declared dependencies an applied row's helper settings use. */
+function helperUses(host, parse, dir, manifest, readings) {
+    const declared = new Set(DEPENDENCY_SECTIONS.flatMap((section) => {
+        const held = isRecord(manifest) ? manifest[section] : undefined;
+        return isRecord(held) ? Object.keys(held) : [];
+    }));
+    return readings
+        .filter((reading) => declared.has(reading.package) &&
+        readingFiles(host, parse, dir, reading.files).some(({ file }) => valuesAt(file, reading.property, reading.call).some((held) => holdsValue(held, reading.value))))
+        .map((reading) => reading.package);
+}
 /** Two strings ordered bytewise. */
 function compare(a, b) {
     if (a === b) {
@@ -644,6 +683,9 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
             for (const name of manifestKeyUses(declared, row.manifestKeys ?? [])) {
                 uses.add(name);
             }
+            for (const name of helperUses(host, parse, manifest.dir, declared, row.helpers ?? [])) {
+                uses.add(name);
+            }
             selectedStrings(host, parse, manifest.dir, row.selections ?? [], selected);
             const excludes = [
                 ...new Set((row.excludes ?? []).flatMap((one) => expand(one, resolved))),

package/dist/src/edges.js

@@ -154,9 +154,10 @@ function compare(a, b) {
 }
 /**
  * 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(findings, sides, symbols) {
     if (sides.length === 0) {
@@ -164,8 +165,8 @@ export function evaluateEdges(findings, sides, symbols) {
     }
     const byRef = new Map();
     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();
@@ -175,18 +176,20 @@ export function evaluateEdges(findings, sides, symbols) {
         }
     });
     const pending = new Set();
-    const evaluations = sides.map((side) => {
-        const id = byRef.get(side.symbol);
-        if (id === undefined) {
-            return { ...side, state: "absent" };
+    const evaluations = sides.flatMap((side) => {
+        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/dist/src/findings/completion.js

@@ -6,7 +6,8 @@
 import { componentId } from "../components.js";
 import { OUTSIDE } from "../graph.js";
 import { KINDS } from "../kinds.js";
-import { byPosition } from "../position.js";
+import { byPosition, positionKey } from "../position.js";
+import { declarationKey } from "../ref.js";
 import { FAMILY_KEY_LENGTH } from "../resolve.js";
 import { isPartSubject, isRowSubject } from "../suppress.js";
 /** The classes ranked by the claim each makes, the strongest highest. */
@@ -117,7 +118,7 @@ function findingComponents(swept, cascade) {
 export function completed(input, findings, kinds = KINDS) {
     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);
@@ -135,10 +136,14 @@ export function completed(input, findings, kinds = KINDS) {
             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/dist/src/findings/emitters.js

@@ -1,5 +1,6 @@
 import { evaluateEdges } from "../edges.js";
 import { liveFilesAt } from "../matrix.js";
+import { declarationKey } from "../ref.js";
 import { ledgerOf } from "../suppress.js";
 import { insideSkipped } from "../type-errors.js";
 import { completed, dialsOf, reportable } from "./completion.js";
@@ -23,24 +24,24 @@ export const EMITTERS = new Map([
     ["intra-function", intraFunction],
 ]);
 /**
- * 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) {
+function heldKeys(input) {
     const held = new Set(input.swept.heldByUnanswered);
     if (held.size === 0) {
         return held;
     }
     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) {
+function markupKeys(input) {
     const { swept } = input;
     if (swept.componentFiles.length === 0) {
         return new Set();
@@ -48,7 +49,7 @@ function markupRefs(input) {
     const live = new Set(liveFilesAt(swept.matrix, swept.sweep, new Set(swept.componentFiles)).map((symbol) => symbol.id));
     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)));
 }
 /** Every family's findings over one sweep, and those of any further emitter, completed by one step. */
 function completedOver(input, ...more) {
@@ -72,21 +73,13 @@ function dialsOver(input, found, suppressed, unmarked) {
  * 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, suppressed = { unmarked: input, records: [] }) {
     const found = completedOver(input);
     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. */
 function atPossible(input) {
@@ -104,31 +97,39 @@ function atPossible(input) {
 function dialledOver(input, suppressed, found, unmarked) {
     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, shown) {
-    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, candidates) {
+    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) {
-    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) {
     return decidedFindings(input).findings;

package/dist/src/findings/reads-and-writes.js

@@ -1,4 +1,5 @@
 import { positionKey } from "../position.js";
+import { declarationKey } from "../ref.js";
 /** The containers whose type parameters `DS1303` reports: a function and a class method. */
 const SIGNATURES = new Set(["function", "method"]);
 function indexed(input) {
@@ -175,12 +176,12 @@ function unusedTypeParameters(run) {
         .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
+ * 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) {
-    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)));
 }
 /**
  * The findings of the reads-and-writes family, `DS1300` to `DS1399`, in code order and

package/dist/src/findings/visibility-narrowing.js

@@ -1,4 +1,5 @@
 import { OUTSIDE } from "../graph.js";
+import { declarationKey } from "../ref.js";
 import { writeOnlyDeclarations } from "./reads-and-writes.js";
 const UNNECESSARY_EXPORT = "DS1101";
 const UNREACHABLE_EXPORT = "DS1103";
@@ -119,7 +120,7 @@ function narrowing(facts, at, symbol, world) {
     const { closed } = world;
     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/dist/src/inventory.js

@@ -787,7 +787,12 @@ function refOf(record, chain) {
         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/dist/src/module-declarations.js

@@ -9,7 +9,7 @@ import { isCallExpression, isExportDeclaration, isExternalModuleReference, isImp
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 import { UNANSWERED } from "./query.js";
-import { nameComponent } from "./ref.js";
+import { aliasFragment, nameComponent } from "./ref.js";
 /** Whether a node is a specifier's text: a string literal or a template with no substitution. */
 function literalText(node) {
     return node !== undefined && (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node));
@@ -78,7 +78,7 @@ function namesModule(specifier, name) {
  * 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(held) {
+function namedBy(held) {
     if (held.modules.size === 0) {
         return () => [];
     }
@@ -103,7 +103,7 @@ export function namedBy(held) {
         const scope = ref.slice(0, ref.indexOf("#"));
         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));
         return [{ id, members: members.map((child) => child.id) }];

package/dist/src/outside-tests.js

@@ -1,15 +1,15 @@
 /**
  * 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 { isCallExpression, isExportDeclaration, isImportDeclaration, isNamespaceExport, isNamespaceImport, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { RESOLVED_EXTENSIONS } from "./configuration-files.js";
 import { emittedFrom } from "./emit-map.js";
-import { namedBy, namesImported } from "./module-declarations.js";
+import { namesImported } from "./module-declarations.js";
 import { dirnamePath, joinPath, normalizePath, queriedModulePath } from "./paths.js";
 import { renderPosition } from "./position.js";
 import { nameComponent } from "./ref.js";
@@ -102,7 +102,6 @@ export function outsideTestReferences(tests, held, targetRoot) {
             exported.set(key, [...(exported.get(key) ?? []), symbol.id]);
         }
     }
-    const declared = namedBy(held);
     const found = [];
     for (const { path, file } of tests) {
         const from = `${path}#`;
@@ -112,11 +111,6 @@ export function outsideTestReferences(tests, held, targetRoot) {
             const read = (to, use) => {
                 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;