@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.2

package/src/roots.ts

@@ -22,19 +22,24 @@ import {
   type SourceFile,
 } from "@typescript/native/ast";
 import { aliasChains } from "./alias-chain.ts";
-import type { ParseFile } from "./configuration-files.ts";
+import {
+  filesNamedBy,
+  outsideChain,
+  relativeSpecifiers,
+  type ParseFile,
+} from "./configuration-files.ts";
 import { conventionEntries, type Conventions } from "./conventions.ts";
 import { entryPoints, type EntryRule } from "./entry-points.ts";
 import { globExpression } from "./glob.ts";
 import type { Host } from "./host.ts";
 import { nodeKey, type Inventory, type InventorySymbol } from "./inventory.ts";
 import type { Manifest, ManifestEntry } from "./manifest.ts";
-import { relativePath, resolvePath } from "./paths.ts";
+import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.ts";
 import { byPosition } from "./position.ts";
 import { UNANSWERED } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 import type { Symbol as TSSymbol, Type } from "@typescript/native/sync";
-import { sourceFilesOf } from "./source-files.ts";
+import { sourceFilesOf, type SourceFiles } from "./source-files.ts";
 import { typeQueryAliases } from "./type-query-alias.ts";
 
 /** Why one declaration is a root. */
@@ -104,6 +109,8 @@ export interface Roots {
    * unknown; otherwise each one an unanswered published type name may name.
    */
   readonly unanswered: readonly string[];
+  /** Every manifest entry naming a file to import or run that reads back to no file of this project. */
+  readonly unmappedEntries: readonly ManifestEntry[];
 }
 
 /** What decides the roots beside the declarations themselves. */
@@ -134,6 +141,8 @@ export interface RootOptions {
    * inside the target whose entries are published API whatever the target's kind.
    */
   readonly publishedMembers?: ReadonlySet<string> | undefined;
+  /** Every file a program of the run holds, so a file another configuration compiles is no outside file. */
+  readonly runFiles?: ReadonlySet<string> | undefined;
 }
 
 /** Whether one declaration is written below the directory of a published workspace member. */
@@ -171,11 +180,25 @@ const OUTPUT_EXTENSION = /\.(?:d\.ts|d\.mts|d\.cts|js|mjs|cjs|jsx)$/u;
 /** The extension a source file's name drops. */
 const SOURCE_EXTENSION = /\.(?:d\.)?[cm]?[jt]sx?$/u;
 
+/** Whether no `package.json` sits between one file and the manifest's directory, which holds it. */
+function ofPackage(host: Host, dir: string, file: string): boolean {
+  for (let at = dirnamePath(file); at !== dir; at = dirnamePath(at)) {
+    if (
+      relativePath(dir, at) === undefined ||
+      host.kindOf(joinPath(at, "package.json")) === "file"
+    ) {
+      return false;
+    }
+  }
+  return true;
+}
+
 /**
  * The rooted files one manifest target reads back to by name: its path below the
  * manifest's directory, past its first directory where it names one, without its output
- * extension, is the name, and a rooted file is one whose path below the same directory,
- * without its source extension, ends with that name at a directory boundary.
+ * extension, is the name, and a rooted file of the manifest's own package is one whose
+ * path below the same directory, without its source extension, ends with that name at a
+ * directory boundary.
  */
 function readBackByName(
   host: Host,
@@ -195,13 +218,52 @@ function readBackByName(
   const found = new Map<string, SourceFile>();
   for (const file of rooted) {
     const path = relativePath(dir, file.fileName)?.replace(SOURCE_EXTENSION, "");
-    if (path !== undefined && (path === name || path.endsWith(`/${name}`))) {
+    if (
+      path !== undefined &&
+      (path === name || path.endsWith(`/${name}`)) &&
+      ofPackage(host, dir, file.fileName)
+    ) {
       found.set(file.fileName, file);
     }
   }
   return [...found.values()];
 }
 
+/**
+ * The program files a manifest target no program holds reaches: the target is a file
+ * read as a configuration file outside the program is, and each file of the chain it
+ * starts loads the program files its relative specifiers name, read through the emit
+ * mapping, as a command's shim loads the compiled entry it runs.
+ */
+function throughOutside(
+  options: RootOptions,
+  targetRoot: string,
+  files: SourceFiles,
+  entry: ManifestEntry,
+): readonly SourceFile[] {
+  const cwd = options.host.workingDirectory();
+  const path = resolvePath(cwd, entry.path);
+  if (
+    options.parse === undefined ||
+    options.runFiles?.has(path) === true ||
+    options.host.kindOf(path) !== "file"
+  ) {
+    return [];
+  }
+  const chain = outsideChain(options.host, targetRoot, files, options.parse, [
+    { path, manifestDir: resolvePath(cwd, entry.dir) },
+  ]);
+  const found = new Map<string, SourceFile>();
+  for (const { file } of chain) {
+    for (const specifier of relativeSpecifiers(file)) {
+      for (const named of filesNamedBy(files, dirnamePath(file.fileName), specifier)) {
+        found.set(named.fileName, named);
+      }
+    }
+  }
+  return [...found.values()];
+}
+
 /** Whether a configured string carries either special character. */
 function isPattern(text: string): boolean {
   return text.includes("*") || text.includes("?");
@@ -307,9 +369,21 @@ export function roots<Brand>(
     found.set([id, kind, source].join("\u0000"), { id, kind, source });
   };
 
-  const entered: { file: SourceFile; kind: RootKind; source: string; exports: boolean }[] = [];
-  const enter = (file: SourceFile, kind: RootKind, source: string, exports: boolean): void => {
-    entered.push({ file, kind, source, exports });
+  const entered: {
+    file: SourceFile;
+    kind: RootKind;
+    source: string;
+    exports: boolean;
+    names?: readonly string[];
+  }[] = [];
+  const enter = (
+    file: SourceFile,
+    kind: RootKind,
+    source: string,
+    exports: boolean,
+    names?: readonly string[],
+  ): void => {
+    entered.push({ file, kind, source, exports, ...(names === undefined ? {} : { names }) });
   };
 
   const points = entryPoints(
@@ -344,11 +418,28 @@ export function roots<Brand>(
     ...scripted,
     ...points.filter((point) => READ_BACK_RULES.has(point.rule)).map((point) => point.file),
   ];
+  const entryFilesOf = new Map<ManifestEntry, readonly SourceFile[]>();
   const entryFiles = (entry: ManifestEntry): readonly SourceFile[] => {
+    const known = entryFilesOf.get(entry);
+    if (known !== undefined) {
+      return known;
+    }
+    const found = readEntryFiles(entry);
+    entryFilesOf.set(entry, found);
+    return found;
+  };
+  const readEntryFiles = (entry: ManifestEntry): readonly SourceFile[] => {
     const named = files.named(entry.path);
-    return named.length > 0 || entry.role === "script"
-      ? named
-      : readBackByName(options.host, entry, readBackTo);
+    if (named.length > 0 || entry.role === "script") {
+      return named;
+    }
+    const cwd = options.host.workingDirectory();
+    const shipped = files.namedAsOutput(resolvePath(cwd, entry.dir), resolvePath(cwd, entry.path));
+    if (shipped.length > 0) {
+      return shipped;
+    }
+    const byName = readBackByName(options.host, entry, readBackTo);
+    return byName.length > 0 ? byName : throughOutside(options, targetRoot, files, entry);
   };
   for (const { entry, publishes } of entries) {
     if (publishes) {
@@ -356,27 +447,41 @@ export function roots<Brand>(
     }
   }
   const publishedNames = new Set(published.map((file) => file.fileName));
-  for (const { entry } of entries) {
-    for (const file of entryFiles(entry)) {
-      const kind = ENTRY_KINDS[entry.role];
-      enter(file, kind, entry.member, !publishedNames.has(file.fileName));
-    }
-  }
+  const patterned: { file: SourceFile; pattern: string }[] = [];
   for (const pattern of options.entryFiles) {
     const expression = globExpression(pattern);
     for (const [path, file] of files.byPath) {
       if (expression.test(path)) {
-        enter(file, "entry-file", pattern, true);
+        patterned.push({ file, pattern });
       }
     }
   }
+  const unmapped: ManifestEntry[] = [];
+  const mapped = patterned.map(({ file }) => file);
+  for (const { entry } of entries) {
+    const named = entryFiles(entry);
+    if (named.length === 0 && entry.role !== "script") {
+      unmapped.push(entry);
+    }
+    mapped.push(...named);
+    for (const file of named) {
+      const kind = ENTRY_KINDS[entry.role];
+      enter(file, kind, entry.member, !publishedNames.has(file.fileName));
+    }
+  }
+  const unmappedEntries = unmapped.filter(
+    (entry) => readBackByName(options.host, entry, mapped).length === 0,
+  );
+  for (const { file, pattern } of patterned) {
+    enter(file, "entry-file", pattern, true);
+  }
   for (const { file, row } of options.conventions === undefined
     ? []
     : conventionEntries(options.conventions, files)) {
     enter(file, "convention", row, true);
   }
   for (const point of points) {
-    enter(point.file, point.rule, point.source, point.exports);
+    enter(point.file, point.rule, point.source, point.exports, point.names);
   }
   for (const file of files.byPath.values()) {
     for (const alias of typeQueryAliases(file)) {
@@ -390,7 +495,11 @@ export function roots<Brand>(
     }
   }
 
-  const { tables: exportsOf, answered } = exportTables(project, held, [
+  const {
+    tables: exportsOf,
+    named,
+    answered,
+  } = exportTables(project, held, [
     ...entered.filter((entry) => entry.exports).map((entry) => entry.file),
     ...published,
   ]);
@@ -401,8 +510,13 @@ export function roots<Brand>(
     }
     add(id, entry.kind, entry.source);
     if (entry.exports) {
-      for (const exported of exportsOf.get(entry.file.fileName) ?? []) {
-        add(exported, entry.kind, entry.source);
+      const byName = named.get(entry.file.fileName);
+      const exported =
+        entry.names === undefined || byName === undefined
+          ? (exportsOf.get(entry.file.fileName) ?? [])
+          : entry.names.flatMap((name) => byName.get(name) ?? []);
+      for (const one of exported) {
+        add(one, entry.kind, entry.source);
       }
     }
   }
@@ -433,6 +547,7 @@ export function roots<Brand>(
     liveUnderReachability: ordered,
     unmatched,
     unanswered: answered ? api.guessed : held.symbols.map((symbol) => symbol.id),
+    unmappedEntries,
   };
 }
 
@@ -448,12 +563,18 @@ function exportTables<Brand>(
   project: ProjectView<Brand>,
   held: Inventory,
   wanted: readonly SourceFile[],
-): { readonly tables: ReadonlyMap<string, readonly string[]>; readonly answered: boolean } {
+): {
+  readonly tables: ReadonlyMap<string, readonly string[]>;
+  /** Per file whose table the checker answered, the declarations each export name reaches. */
+  readonly named: ReadonlyMap<string, ReadonlyMap<string, readonly string[]>>;
+  readonly answered: boolean;
+} {
   const unique = [...new Map(wanted.map((file) => [file.fileName, file])).values()];
   const tables = new Map<string, readonly string[]>();
+  const named = new Map<string, Map<string, string[]>>();
   let answered = true;
   if (unique.length === 0) {
-    return { tables, answered };
+    return { tables, named, answered };
   }
   const modules = project.symbolsAt(unique.map((file) => project.handle(file)));
   const chains = aliasChains(project, held);
@@ -475,15 +596,18 @@ function exportTables<Brand>(
       return;
     }
     const ids = new Set<string>();
+    const byName = new Map<string, string[]>();
     for (const exported of table) {
       for (const target of chains.chainOf(exported)) {
         answered &&= !target.guessed;
         ids.add(target.id);
+        byName.set(exported.name, [...(byName.get(exported.name) ?? []), target.id]);
       }
     }
     tables.set(file.fileName, [...ids]);
+    named.set(file.fileName, byName);
   });
-  return { tables, answered };
+  return { tables, named, answered };
 }
 
 /** A release tag of a documentation comment: `@` and its name, between white space or the ends. */
@@ -553,11 +677,13 @@ function publishedAPI<Brand>(
   const nodes = declarationNodes(held, byPath);
   const chains = aliasChains(project, held);
   const reached = new Set<string>();
+  const entered = new Set<string>();
   const guessed = new Set<string>();
   const pending: string[] = [];
   const reach = (id: string): void => {
-    if (!reached.has(id) && byId.get(id)?.kind !== "file") {
-      reached.add(id);
+    const file = byId.get(id)?.kind === "file";
+    if (!(file ? entered : reached).has(id)) {
+      (file ? entered : reached).add(id);
       pending.push(id);
     }
   };
@@ -566,11 +692,7 @@ function publishedAPI<Brand>(
   }
   for (const file of published) {
     for (const id of exportsOf.get(file.fileName) ?? []) {
-      if (byId.get(id)?.kind === "file") {
-        pending.push(id);
-      } else {
-        reach(id);
-      }
+      reach(id);
     }
   }
   while (pending.length > 0) {
@@ -595,8 +717,7 @@ function publishedAPI<Brand>(
       project,
       round.flatMap((id) => {
         const symbol = byId.get(id);
-        const node = symbol === undefined ? undefined : nodes.nodeOf(symbol);
-        return node === undefined ? [] : [node];
+        return symbol === undefined ? [] : nodes.nodesOf(symbol);
       }),
     )) {
       for (const target of chains.chainOf(symbol)) {
@@ -625,24 +746,22 @@ function declarationNodes(
   byPath: ReadonlyMap<string, SourceFile>,
 ): {
   typeNamesOf(symbol: InventorySymbol): readonly Node[];
-  nodeOf(symbol: InventorySymbol): Node | undefined;
+  nodesOf(symbol: InventorySymbol): readonly Node[];
 } {
-  const walked = new Map<string, { byId: Map<string, Node>; nodes: Set<Node> }>();
-  const nodesIn = (path: string): { byId: Map<string, Node>; nodes: Set<Node> } => {
+  const walked = new Map<string, { byId: Map<string, Node[]>; nodes: Set<Node> }>();
+  const nodesIn = (path: string): { byId: Map<string, Node[]>; nodes: Set<Node> } => {
     const known = walked.get(path);
     if (known !== undefined) {
       return known;
     }
-    const found = { byId: new Map<string, Node>(), nodes: new Set<Node>() };
+    const found = { byId: new Map<string, Node[]>(), nodes: new Set<Node>() };
     const file = byPath.get(path);
     if (file !== undefined) {
       const visit = (node: Node): void => {
         const id = held.declarations.get(nodeKey(file, node));
         if (id !== undefined) {
           found.nodes.add(node);
-          if (!found.byId.has(id)) {
-            found.byId.set(id, node);
-          }
+          found.byId.set(id, [...(found.byId.get(id) ?? []), node]);
         }
         node.forEachChild(visit);
       };
@@ -654,10 +773,9 @@ function declarationNodes(
   return {
     typeNamesOf: (symbol) => {
       const { byId, nodes } = nodesIn(symbol.position.path);
-      const declaration = byId.get(symbol.id);
-      return declaration === undefined ? [] : typeNamesOf(declaration, nodes);
+      return (byId.get(symbol.id) ?? []).flatMap((declaration) => typeNamesOf(declaration, nodes));
     },
-    nodeOf: (symbol) => nodesIn(symbol.position.path).byId.get(symbol.id),
+    nodesOf: (symbol) => nodesIn(symbol.position.path).byId.get(symbol.id) ?? [],
   };
 }
 

package/src/schema.ts

@@ -106,6 +106,7 @@ export const SCHEMA_ROOT: KeyNode = {
           members: { components: declarations, bases: declarations, members: leaf },
         },
         serializers: declarations,
+        roots_complete: leaf,
       },
     },
     provenance: { kind: "map" },

package/src/serialization-contract.ts

@@ -1,10 +1,10 @@
 /**
  * The serialization-contract class: the data members and `toJSON` of every type a value's
  * static type reaches, where the value reaches `JSON.stringify` or a call `ts.serializers`
- * names, and `toString` too where it reaches an `unknown` or `any` parameter of a function
- * outside the analysis or an erased property of a type the program does not declare. A
- * function of the project handing such a parameter to a destination is one, to a fixpoint,
- * and a function invoked through `call`, `apply` or `bind` is the callee.
+ * names, and `toString` too where it reaches an erased parameter of a function outside the
+ * analysis, or an erased property of a type the program does not declare. A function of
+ * the project handing such a parameter to a destination is one, to a fixpoint, and a
+ * function invoked through `call`, `apply` or `bind` is the callee.
  */
 
 import {
@@ -80,6 +80,9 @@ const SERIALIZED_CONVERSION = "toJSON";
 /** The parameter types that keep nothing of the value they are given. */
 const ERASED = TypeFlags.Any | TypeFlags.Unknown;
 
+/** How deep a callee's result is searched for a type parameter: `Promise<Box<T>>` is two levels. */
+const MENTION_DEPTH = 3;
+
 /**
  * What a destination holds back of a class: its properties, or its properties and its
  * two conversion methods. The second holds back everything the first does.
@@ -564,6 +567,30 @@ function destinations<Brand>(
     });
     return containing.length === 0 ? target.declarations : containing;
   };
+  /** Whether a type names a type parameter, through constituents, type arguments and call signatures. */
+  const mentions = (type: Type, parameter: Type, depth: number): boolean => {
+    // A conditional type an alias names, `Awaited<T>` among them, carries its arguments
+    // only on the alias the client's type object reports.
+    const aliased = (type as { readonly aliasTypeArguments?: readonly number[] })
+      .aliasTypeArguments;
+    if (type.id === parameter.id || aliased?.includes(parameter.id) === true) {
+      return true;
+    }
+    if (depth >= MENTION_DEPTH) {
+      return false;
+    }
+    const inner = [
+      ...(type.isUnionType() || type.isIntersectionType() ? must(queries.constituents(type)) : []),
+      ...must(queries.typeArguments(type)),
+      ...must(queries.signaturesOf(type, SignatureKind.Call)).flatMap((signature) => [
+        ...signature.parameters.map((_parameter, at) =>
+          must(queries.typeAtPosition(signature, at)),
+        ),
+        ...[must(queries.returnTypeOf(signature))].filter((one) => one !== undefined),
+      ]),
+    ];
+    return inner.some((one) => mentions(one, parameter, depth + 1));
+  };
   const erasedArguments = new Map<CallExpression, ReadonlySet<number>>();
   const erasedAt = (call: CallExpression, argument: number): boolean => {
     let indexes = erasedArguments.get(call);
@@ -577,8 +604,32 @@ function destinations<Brand>(
           ? []
           : must(queries.signaturesOf(type, SignatureKind.Call))
         : [resolvedOf(call)].filter((one) => one !== undefined);
+      // A type parameter of the callee that nothing constrains and its result does not name
+      // keeps nothing of the value either: the instantiated signature names the value's own
+      // type there instead, and a result that names it hands the value back.
+      const generic = invoked.indirect ? undefined : resolvedOf(call);
+      const declared = generic === undefined ? undefined : must(queries.genericOf(generic));
+      const unconstrained = (index: number): boolean => {
+        const parameter =
+          declared === undefined ? undefined : must(queries.parameterType(declared, index));
+        const parts =
+          parameter === undefined
+            ? []
+            : parameter.isUnionType()
+              ? must(queries.constituents(parameter))
+              : [parameter];
+        const result = declared === undefined ? undefined : must(queries.returnTypeOf(declared));
+        return parts.some((part) => {
+          if (!part.isTypeParameter() || (result !== undefined && mentions(result, part, 0))) {
+            return false;
+          }
+          const constraint = must(queries.constraintOf(part));
+          return constraint === undefined || (constraint.flags & ERASED) !== 0;
+        });
+      };
       indexes = new Set(
         invoked.arguments.flatMap((_unused, index) =>
+          unconstrained(index) ||
           signatures.some((signature) => {
             const parameter = must(queries.parameterType(signature, index));
             return parameter !== undefined && (parameter.flags & ERASED) !== 0;

package/src/session.ts

@@ -129,6 +129,7 @@ export function openEngine(options: EngineOptions): Engine {
     ...(mapper === undefined ? {} : { runExternalCode: true }),
   });
   let closed = false;
+  const parsed = new Map<string, { readonly text: string; readonly file: SourceFile }>();
   return {
     parseConfigFile: (file) => api.parseConfigFile(file),
     parseConfigJson: (json, configFile) =>
@@ -160,8 +161,14 @@ export function openEngine(options: EngineOptions): Engine {
         moduleResolutions: { fallback: "resolve", entries: [...entries] },
       }),
     parseSourceFile: (fileName, text) => {
+      // Every project of a run reads the same files outside its program, so one parse serves all.
+      const known = parsed.get(fileName);
+      if (known?.text === text) {
+        return known.file;
+      }
       const retained = api.createSourceFile(fileName, text);
       try {
+        parsed.set(fileName, { text, file: retained.sourceFile });
         return retained.sourceFile;
       } finally {
         retained.dispose();

package/src/source-files.ts

@@ -6,12 +6,18 @@
 
 import type { SourceFile } from "@typescript/native/ast";
 import { commonDirectory, emittedFrom } from "./emit-map.ts";
-import { dirnamePath, relativePath, resolvePath } from "./paths.ts";
+import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.ts";
 import type { ProjectView } from "./session.ts";
 
 /** The one character a subpath pattern of a manifest's `exports` holds. */
 const SUBPATH_WILDCARD = "*";
 
+/** The extension a source file's name drops when the project writes it out. */
+const SOURCE_EXTENSION = /\.[cm]?[jt]sx?$/u;
+
+/** The extensions the project may write a source file's output under. */
+const OUTPUT_EXTENSIONS = [".js", ".mjs", ".cjs", ".jsx", ".d.ts", ".d.mts", ".d.cts"] as const;
+
 /**
  * Whether one path is what a subpath pattern stands for: the text before the
  * wildcard, any run of characters including the solidus, then the text after it.
@@ -40,6 +46,47 @@ export interface SourceFiles {
   named(path: string): readonly SourceFile[];
   /** The directories the project writes its output below, absolute: its output and declaration directories. */
   readonly outputDirs: readonly string[];
+  /** The output paths, absolute, the project writes one own file to, each of which {@link named} reads back to it. */
+  writtenAs(file: SourceFile): readonly string[];
+  /**
+   * The own files one absolute path names read as an output of the project written below
+   * `outputDir`: a manifest that ships from its build directory names its entries there.
+   */
+  namedAsOutput(outputDir: string, path: string): readonly SourceFile[];
+}
+
+/** The first own file of the paths given that the project holds, or none. */
+function heldAt(
+  byName: ReadonlyMap<string, SourceFile>,
+  paths: readonly string[],
+): readonly SourceFile[] {
+  for (const candidate of paths) {
+    const file = byName.get(candidate);
+    if (file !== undefined) {
+      return [file];
+    }
+  }
+  return [];
+}
+
+/** Where one project writes its output, and the directory it writes it from, absolute. */
+function layoutOf<Brand>(
+  project: ProjectView<Brand>,
+  fileNames: readonly string[],
+): {
+  readonly outDir: string | undefined;
+  readonly declarationDir: string | undefined;
+  readonly sourceDir: string;
+} {
+  const options = project.program.getCompilerOptions();
+  const configDir = dirnamePath(project.configFile);
+  const at = (option: string | undefined): string | undefined =>
+    option === undefined ? undefined : resolvePath(configDir, option);
+  return {
+    outDir: at(options.outDir),
+    declarationDir: at(options.declarationDir),
+    sourceDir: at(options.rootDir) ?? commonDirectory(fileNames),
+  };
 }
 
 /**
@@ -62,14 +109,7 @@ export function sourceFilesOf<Brand>(project: ProjectView<Brand>, targetRoot: st
     }
   }
 
-  const options = project.program.getCompilerOptions();
-  const configDir = dirnamePath(project.configFile);
-  const at = (option: string | undefined): string | undefined =>
-    option === undefined ? undefined : resolvePath(configDir, option);
-  const outDir = at(options.outDir);
-  const declarationDir = at(options.declarationDir);
-  const sourceDir = at(options.rootDir) ?? commonDirectory([...byName.keys()]);
-
+  const { outDir, declarationDir, sourceDir } = layoutOf(project, [...byName.keys()]);
   const layout = { outDir, declarationDir, sourceDirs: [sourceDir] };
 
   /** The source paths one written path may stand for, the path itself first. */
@@ -79,15 +119,25 @@ export function sourceFilesOf<Brand>(project: ProjectView<Brand>, targetRoot: st
     byPath,
     byName,
     outputDirs: [...new Set([outDir, declarationDir])].filter((dir) => dir !== undefined),
+    writtenAs: (file) => {
+      const below = relativePath(sourceDir, file.fileName);
+      if (below === undefined) {
+        return [];
+      }
+      const written = [outDir, declarationDir].flatMap((dir) =>
+        dir === undefined
+          ? []
+          : OUTPUT_EXTENSIONS.map((extension) =>
+              joinPath(dir, below.replace(SOURCE_EXTENSION, extension)),
+            ),
+      );
+      return [...new Set(written)].filter((path) => heldAt(byName, candidates(path))[0] === file);
+    },
+    namedAsOutput: (outputDir, path) =>
+      heldAt(byName, emittedFrom(path, { outDir: outputDir, sourceDirs: [sourceDir] })),
     named: (path) => {
       if (!path.includes(SUBPATH_WILDCARD)) {
-        for (const candidate of candidates(path)) {
-          const held = byName.get(candidate);
-          if (held !== undefined) {
-            return [held];
-          }
-        }
-        return [];
+        return heldAt(byName, candidates(path));
       }
       const patterns = candidates(path).filter((candidate) => candidate.includes(SUBPATH_WILDCARD));
       return [...byName.values()].filter((file) =>

package/src/suppress-file.ts

@@ -19,6 +19,7 @@ import {
   UNSCOPED_ENTRY,
   blankReason,
   isEntryPath,
+  isPartKind,
   isSymbolRef,
   siteText,
   type Mechanism,
@@ -155,13 +156,23 @@ function readRecord(value: unknown, site: Position, byReference: ByReference, sh
   if (refusals.length > 0) {
     return { records: [], refusals };
   }
-  const named = byReference.get(declarationKey(symbol, written.path)) ?? [];
+  const named =
+    byReference.get(declarationKey(symbol, written.path)) ??
+    (isPartKind(code)
+      ? byReference.get(declarationKey(parameterHolder(symbol), written.path))
+      : undefined) ??
+    [];
   if (named.length === 0) {
     return { records: [{ ...written, bound: "" }], refusals: [] };
   }
   return { records: named.map((one) => ({ ...written, bound: one.id })), refusals: [] };
 }
 
+/** The reference of the declaration a parameter's reference names it under, or `ref` itself. */
+function parameterHolder(ref: string): string {
+  return ref.endsWith(")") ? ref.slice(0, ref.lastIndexOf("(")) : ref;
+}
+
 function byReferenceOf(symbols: readonly InventorySymbol[]): ByReference {
   const byReference = new Map<string, InventorySymbol[]>();
   for (const symbol of symbols) {