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

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 {
@@ -45,6 +45,8 @@ import {
   SignatureKind,
   SymbolFlags,
   TypeFlags,
+  type NodeHandle,
+  type Signature,
   type Symbol as TSSymbol,
   type Type,
 } from "@typescript/native/sync";
@@ -64,7 +66,7 @@ import { renderPosition } from "./position.ts";
 import { must } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 import { erasedStores, type ErasedStores } from "./erased-stores.ts";
-import { checkedTypes, valueReach, type Reached } from "./value-reach.ts";
+import { checkedTypes, CONVERSION_MEMBERS, valueReach, type Reached } from "./value-reach.ts";
 
 /** The serializer every run reads, whatever the configuration names. */
 const JSON_STRINGIFY: DeclarationEntry = { shape: "global", global: "JSON.stringify" };
@@ -78,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.
@@ -484,14 +489,19 @@ function destinations<Brand>(
     own.has(path) || input.consumers.some((root) => path === root || path.startsWith(`${root}/`));
   const implemented = implementedOwners(project, inAnalysis);
   /**
-   * Whether every declaration of a callee is outside the analysis or ambient. An ambient
-   * declaration has no body, so the code that runs is outside the analysis, unless it is a
-   * member of an interface or an object type a class or a typed object literal of the
-   * analysis implements; `settled` false skips that question, which asks the checker.
+   * Whether every one of `declarations`, all of the callee's by default, is outside the
+   * analysis or ambient. An ambient declaration has no body, so the code that runs is
+   * outside the analysis, unless it is a member of an interface or an object type a class
+   * or a typed object literal of the analysis implements; `settled` false skips that
+   * question, which asks the checker.
    */
-  const outside = (target: TSSymbol, settled: boolean): boolean =>
-    target.declarations.length > 0 &&
-    target.declarations.every((handle) => {
+  const outside = (
+    target: TSSymbol,
+    settled: boolean,
+    declarations: readonly NodeHandle[] = target.declarations,
+  ): boolean =>
+    declarations.length > 0 &&
+    declarations.every((handle) => {
       if (!inAnalysis(handle.path)) {
         return true;
       }
@@ -505,6 +515,13 @@ function destinations<Brand>(
       const owner = must(queries.parentOf(target));
       return owner === undefined || !implemented().has(owner.id);
     });
+  /**
+   * Whether some one declaration of a callee is outside the analysis or ambient, without
+   * asking the checker. A project's declaration merged into a library's symbol leaves the
+   * library's beside it, so a call can still resolve to the library's.
+   */
+  const mayBeOutside = (target: TSSymbol): boolean =>
+    target.declarations.some((handle) => outside(target, false, [handle]));
   const invocation = (call: CallExpression): Invocation => {
     const form = forms.get(call);
     const method = form === undefined ? undefined : callees.get(form.method);
@@ -513,7 +530,7 @@ function destinations<Brand>(
     if (
       form !== undefined &&
       method !== undefined &&
-      outside(method, false) &&
+      mayBeOutside(method) &&
       FUNCTION_INTERFACES.has(must(project.queries.parentOf(method))?.name ?? "")
     ) {
       return form.invocation;
@@ -524,6 +541,56 @@ function destinations<Brand>(
     const name = calleeName(invocation(call).callee);
     return name === undefined ? undefined : callees.get(name);
   };
+  const signatures = new Map<CallExpression, Signature | undefined>();
+  const resolvedOf = (call: CallExpression): Signature | undefined => {
+    if (!signatures.has(call)) {
+      signatures.set(call, must(queries.resolvedSignature(call)));
+    }
+    return signatures.get(call);
+  };
+  /**
+   * The declarations of a callee that the declaration of a direct call's resolved
+   * signature lies in, or all of them where it lies in none: a declaration merged into
+   * the callee's symbol that the call does not resolve to does not decide where it runs.
+   */
+  const calledDeclarations = (call: CallExpression, target: TSSymbol): readonly NodeHandle[] => {
+    const declaration = invocation(call).indirect ? undefined : resolvedOf(call)?.declaration;
+    const signature =
+      declaration === undefined ? undefined : project.declarationAt(declaration)?.node;
+    if (declaration === undefined || signature === undefined) {
+      return target.declarations;
+    }
+    const containing = target.declarations.filter((handle) => {
+      const node =
+        handle.path === declaration.path ? project.declarationAt(handle)?.node : undefined;
+      return node !== undefined && node.pos <= signature.pos && signature.end <= node.end;
+    });
+    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);
@@ -536,9 +603,33 @@ function destinations<Brand>(
         ? type === undefined
           ? []
           : must(queries.signaturesOf(type, SignatureKind.Call))
-        : [must(queries.resolvedSignature(call))].filter((one) => one !== undefined);
+        : [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;
@@ -563,7 +654,7 @@ function destinations<Brand>(
     if (entry !== undefined) {
       return { reach: "properties", callee: spelledEntry(entry.entry, held) };
     }
-    if (outside(target, true)) {
+    if (outside(target, true, calledDeclarations(call, target))) {
       return erasedAt(call, argument)
         ? {
             reach: "conversions",
@@ -602,7 +693,7 @@ function destinations<Brand>(
     if (target === undefined) {
       return false;
     }
-    if (named.some((one) => names(one, target, chains)) || outside(target, false)) {
+    if (named.some((one) => names(one, target, chains)) || mayBeOutside(target)) {
       return true;
     }
     return chains
@@ -733,7 +824,7 @@ export function serializationContract<Brand>(input: DetectorInput<Brand>): reado
   // the value left the analysis.
   const holdsBack = (flags: SymbolFlags, name: string, to: Destination): boolean =>
     (flags & SymbolFlags.Property) !== 0 ||
-    ((flags & SymbolFlags.Method) !== 0 &&
+    ((flags & CONVERSION_MEMBERS) !== 0 &&
       (name === SERIALIZED_CONVERSION || (to.reach === "conversions" && CONVERSIONS.has(name))));
   const found: Evidence[] = [];
   for (const flow of flows) {

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();
@@ -419,6 +426,8 @@ export interface ProjectDiagnostics {
   readonly syntactic: readonly Diagnostic[];
   readonly semantic: readonly Diagnostic[];
   readonly configParsing: readonly Diagnostic[];
+  /** The program's diagnostics placed in no file, each once, its `fileName` undefined. */
+  readonly unplaced: readonly Diagnostic[];
   /** The line and column of one offset into one of the program's files, counted from one. */
   readonly locate: (
     fileName: string,
@@ -426,12 +435,31 @@ export interface ProjectDiagnostics {
   ) => { line: number; column: number } | undefined;
 }
 
-/** The three diagnostic sets one project carries, read before any analysis. */
+/**
+ * The program's diagnostics placed in no file. The per-file sets never carry one; the
+ * client answers its `fileName` as `null`, and the global set repeats the program set:
+ * https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/api/session.go#L3726-L3752
+ */
+function unplacedOf(program: Program): readonly Diagnostic[] {
+  const seen = new Set<string>();
+  return [...program.getGlobalDiagnostics(), ...program.getProgramDiagnostics()]
+    .filter((diagnostic) => diagnostic.fileName == null)
+    .filter((diagnostic) => {
+      const key = `${String(diagnostic.code)}\u0000${diagnostic.text}`;
+      const fresh = !seen.has(key);
+      seen.add(key);
+      return fresh;
+    })
+    .map((diagnostic) => ({ ...diagnostic, fileName: undefined }));
+}
+
+/** The diagnostic sets one project carries, read before any analysis. */
 export function diagnosticsOf<Brand>(project: ProjectView<Brand>): ProjectDiagnostics {
   return {
     syntactic: project.program.getSyntacticDiagnostics(),
     semantic: project.program.getSemanticDiagnostics(),
     configParsing: project.program.getConfigFileParsingDiagnostics(),
+    unplaced: unplacedOf(project.program),
     locate: (fileName, offset) => {
       const file = project.program.getSourceFile(fileName);
       if (file === undefined || offset < 0 || offset > file.text.length) {

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/spelled-names.ts

@@ -0,0 +1,102 @@
+import {
+  isBindingElement,
+  isBreakStatement,
+  isClassDeclaration,
+  isClassExpression,
+  isContinueStatement,
+  isEnumDeclaration,
+  isEnumMember,
+  isExportDeclaration,
+  isExportSpecifier,
+  isFunctionDeclaration,
+  isFunctionExpression,
+  isGetAccessorDeclaration,
+  isImportClause,
+  isImportEqualsDeclaration,
+  isImportSpecifier,
+  isInterfaceDeclaration,
+  isJsxAttribute,
+  isLabeledStatement,
+  isMetaProperty,
+  isMethodDeclaration,
+  isMethodSignatureDeclaration,
+  isModuleDeclaration,
+  isNamespaceExport,
+  isNamespaceExportDeclaration,
+  isNamespaceImport,
+  isParameterDeclaration,
+  isPropertyAccessExpression,
+  isPropertyAssignment,
+  isPropertyDeclaration,
+  isPropertySignatureDeclaration,
+  isQualifiedName,
+  isSetAccessorDeclaration,
+  isTypeAliasDeclaration,
+  isTypeParameterDeclaration,
+  isVariableDeclaration,
+  type Identifier,
+} from "@typescript/native/ast";
+
+/**
+ * Whether one identifier spells a name without referring to a binding of it: a member's
+ * name after a dot, a property or member an object literal, a class, a type or an enum
+ * declares, the name a declaration binds, the property a binding element destructures,
+ * an import or export specifier's name in another module or under a rename, a JSX
+ * attribute's name, a statement label, or the name of a meta-property. A shorthand
+ * property and an unrenamed local export are no such spelling: each reads the binding.
+ */
+export function spellsNoBinding(node: Identifier): boolean {
+  const parent = node.parent;
+  if (isPropertyAccessExpression(parent) || isMetaProperty(parent)) {
+    return parent.name === node;
+  }
+  if (isQualifiedName(parent)) {
+    return parent.right === node;
+  }
+  if (isBindingElement(parent)) {
+    return parent.propertyName === node || parent.name === node;
+  }
+  if (isImportSpecifier(parent)) {
+    return true;
+  }
+  if (isExportSpecifier(parent)) {
+    return (
+      (isExportDeclaration(parent.parent.parent) &&
+        parent.parent.parent.moduleSpecifier !== undefined) ||
+      (parent.propertyName !== undefined && parent.name === node)
+    );
+  }
+  if (
+    isPropertyAssignment(parent) ||
+    isPropertyDeclaration(parent) ||
+    isMethodDeclaration(parent) ||
+    isPropertySignatureDeclaration(parent) ||
+    isMethodSignatureDeclaration(parent) ||
+    isGetAccessorDeclaration(parent) ||
+    isSetAccessorDeclaration(parent) ||
+    isEnumMember(parent) ||
+    isJsxAttribute(parent) ||
+    isVariableDeclaration(parent) ||
+    isParameterDeclaration(parent) ||
+    isFunctionDeclaration(parent) ||
+    isFunctionExpression(parent) ||
+    isClassDeclaration(parent) ||
+    isClassExpression(parent) ||
+    isInterfaceDeclaration(parent) ||
+    isTypeAliasDeclaration(parent) ||
+    isEnumDeclaration(parent) ||
+    isModuleDeclaration(parent) ||
+    isTypeParameterDeclaration(parent) ||
+    isImportClause(parent) ||
+    isNamespaceImport(parent) ||
+    isImportEqualsDeclaration(parent) ||
+    isNamespaceExport(parent) ||
+    isNamespaceExportDeclaration(parent)
+  ) {
+    return parent.name === node;
+  }
+  return (
+    (isLabeledStatement(parent) || isBreakStatement(parent) || isContinueStatement(parent)) &&
+    parent.label === node
+  );
+}

package/src/suppress-file.ts

@@ -19,6 +19,7 @@ import {
   UNSCOPED_ENTRY,
   blankReason,
   isEntryPath,
+  isPartKind,
   isSymbolRef,
   siteText,
   type Mechanism,
@@ -98,7 +99,7 @@ type ByReference = ReadonlyMap<string, readonly InventorySymbol[]>;
  */
 function readRecord(value: unknown, site: Position, byReference: ByReference, shape: Shape): Read {
   const refuse = (text: string, want: string): never => {
-    throw new SuppressionError(shape.mechanism, `${shape.file} ${siteText(site)}`, text, want);
+    throw new SuppressionError(shape.mechanism, siteText(site), text, want);
   };
   if (!isObject(value)) {
     return refuse(JSON.stringify(value), shape.recordWant);
@@ -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) {
@@ -217,7 +228,7 @@ function readDocument(
   const records: SuppressionRecord[] = [];
   const refusals: Refusal[] = [];
   (held as readonly unknown[]).forEach((value, index) => {
-    const offset = walk.opened[index];
+    const offset = walk.starts[index];
     const site = offset === undefined ? documentSite(shape) : positionAt(text, shape.file, offset);
     const read = readRecord(value, site, byReference, shape);
     records.push(...read.records);

package/src/suppress-inline.ts

@@ -10,8 +10,10 @@ import {
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
+import { importBindings } from "./import-bindings.ts";
 import { isParameterProperty, nodeKey, type Inventory } from "./inventory.ts";
 import { byPosition, positionKey, renderPosition, type Position } from "./position.ts";
+import { importRef } from "./ref.ts";
 import type { ProjectView } from "./session.ts";
 import { signatureOf } from "./signatures.ts";
 import {
@@ -134,7 +136,9 @@ function lineComments(file: SourceFile): readonly LineComment[] {
   const spans: { readonly start: number; readonly end: number }[] = [];
   const visit = (node: Node): void => {
     if (LITERALS.has(node.kind)) {
-      spans.push({ start: tokenStart(text, node.pos), end: node.end });
+      // JSX text carries no trivia: its first code unit is at `pos`, even a `//`.
+      const start = node.kind === SyntaxKind.JsxText ? node.pos : tokenStart(text, node.pos);
+      spans.push({ start, end: node.end });
     }
     node.forEachChild(visit);
   };
@@ -198,6 +202,7 @@ function declarationLines(
   file: SourceFile,
   held: Inventory,
   symbols: ReadonlyMap<string, Declared>,
+  targetRoot: string,
 ): ReadonlyMap<number, readonly Binding[]> {
   const below = new Map<number, Binding[]>();
   const add = (offset: number, one: Binding): void => {
@@ -243,6 +248,20 @@ function declarationLines(
     node.forEachChild(visit);
   };
   file.forEachChild(visit);
+  // An import binding is a subject of its own, bound on its line as a declaration is.
+  const fileId = held.declarations.get(nodeKey(file, file));
+  const moduleRef = held.symbols.find((symbol) => symbol.id === fileId)?.ref ?? "";
+  for (const name of moduleRef === "" ? [] : importBindings(file)) {
+    const position = renderPosition(file, targetRoot, name.getStart());
+    const one = { id: positionKey(position), ref: importRef(moduleRef, name.text), position };
+    let statement: Node = name;
+    while (statement.parent.kind !== SyntaxKind.SourceFile) {
+      statement = statement.parent;
+    }
+    for (const at of [statement.pos, name.getStart()]) {
+      add(at, { declared: one, part: one });
+    }
+  }
   return below;
 }
 
@@ -283,7 +302,7 @@ export function inlineDirectives<Brand>(
     if (comments.length === 0) {
       continue;
     }
-    const below = declarationLines(file, held, symbols);
+    const below = declarationLines(file, held, symbols, targetRoot);
     for (const comment of comments) {
       const site = renderPosition(file, targetRoot, comment.offset);
       const target = trails(file, comment.offset) ? site.line : site.line + 1;

package/src/suppress.ts

@@ -243,10 +243,11 @@ function claimKey(finding: Finding): string {
 
 /**
  * Whether one record names one finding. A record reaches a finding in two ways: it bound
- * the declaration at the finding's position, or it names the finding's reference and the
- * file the finding is reported in, each exactly. The second is how an entry copied from a
- * finding about a part of a declaration reaches the part, and the only way any record
- * reaches a dependency row.
+ * the declaration at the finding's position, or it names the finding's reference, or the
+ * reference of the declaration holding a part that has one of its own, and the file the
+ * finding is reported in, each exactly. The second is how an entry copied from a finding
+ * about a part of a declaration reaches the part, and the only way any record reaches a
+ * dependency row.
  */
 export function pairs(record: SuppressionRecord, finding: Finding): boolean {
   if (record.code !== finding.code) {
@@ -265,7 +266,10 @@ export function pairs(record: SuppressionRecord, finding: Finding): boolean {
   if (record.bound !== "" && record.bound === positionKey(finding.position)) {
     return true;
   }
-  return record.symbol === finding.symbol.ref && record.path === finding.position.path;
+  return (
+    (record.symbol === finding.symbol.ref || record.symbol === finding.symbol.holder) &&
+    record.path === finding.position.path
+  );
 }
 
 /**