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

package/src/mdx-entries.ts

@@ -0,0 +1,218 @@
+/**
+ * The files the import declarations of the target's Markdown and MDX documents load. A
+ * document is read as text: a line outside a fenced code block that starts with `import`
+ * is an import declaration, which an MDX compiler hoists into the module it builds.
+ */
+
+import type { SourceFile } from "@typescript/native/ast";
+import { resolveRelativeSpecifier } from "./configuration-files.ts";
+import type { Host } from "./host.ts";
+import { dirnamePath, joinPath, resolvePath } from "./paths.ts";
+import type { SourceFiles } from "./source-files.ts";
+import { filesBelow } from "./fs/tree.ts";
+
+/** One file a document imports, the specifier that named it, and the export names it reads. */
+interface DocumentEntry {
+  readonly file: SourceFile;
+  readonly source: string;
+  /** The export names the import reads, or undefined for a namespace import, which reads them all. */
+  readonly names: readonly string[] | undefined;
+}
+
+/** The extensions of a document whose imports an MDX compiler reads. */
+const DOCUMENT = /\.mdx?$/u;
+
+/** A fence line, its marker run and what follows it captured. */
+const FENCE = /^ {0,3}(`{3,}|~{3,})(.*)$/u;
+
+/** A string literal in either quote, its escapes included. */
+const STRING = String.raw`"(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*'`;
+
+/** An import declaration at the start of a line, its clause and its specifier captured. */
+const IMPORT_LINE = new RegExp(
+  String.raw`^import\s+(?:((?:[^"'\n]|${STRING})*?)\s+from\s*)?["']([^"'\n]+)["']`,
+  "u",
+);
+
+/** The braces of an import clause, what they hold captured. */
+const BRACES = new RegExp(String.raw`\{((?:[^}"']|${STRING})*)\}`, "u");
+
+/** One comma-separated part of a clause's braces. */
+const PART = new RegExp(String.raw`(?:[^,"']|${STRING})+`, "gu");
+
+/** A named import of a clause's braces: the exported name and an optional local alias. */
+const NAMED_IMPORT = new RegExp(String.raw`^([\w$]+|${STRING})(?:\s+as\s+[\w$]+)?$`, "u");
+
+/** The single-character escapes of a string literal and the character each stands for. */
+const SINGLE_ESCAPES: ReadonlyMap<string, string> = new Map([
+  ["b", "\b"],
+  ["f", "\f"],
+  ["n", "\n"],
+  ["r", "\r"],
+  ["t", "\t"],
+  ["v", "\v"],
+  ["0", "\0"],
+  ["'", "'"],
+  ['"', '"'],
+  ["\\", "\\"],
+]);
+
+/**
+ * One escape of a string literal: two hexadecimal digits, a code unit, a code point, or one
+ * character and the digit after it.
+ */
+const ESCAPE = /\\(?:x([\da-fA-F]{2})|u([\da-fA-F]{4})|u\{([\da-fA-F]+)\}|(.)(\d?))/gu;
+
+/** What one escape stands for, or undefined for one a module cannot hold. */
+function unescaped([, hex, unit, point, single, digit]: RegExpExecArray): string | undefined {
+  if (single === undefined) {
+    const code = Number.parseInt(hex ?? unit ?? point ?? "", 16);
+    return code <= 0x10ffff ? String.fromCodePoint(code) : undefined;
+  }
+  return /[1-9xu]/u.test(single) || (single === "0" && digit !== "")
+    ? undefined
+    : `${SINGLE_ESCAPES.get(single) ?? single}${digit ?? ""}`;
+}
+
+/**
+ * The value of a quoted export name, its escapes decoded, or undefined for an escape this
+ * reading does not decode. A module is strict code, so no legacy octal escape is valid.
+ */
+function quotedName(literal: string): string | undefined {
+  const body = literal.slice(1, -1);
+  let value = "";
+  let from = 0;
+  for (const escape of body.matchAll(ESCAPE)) {
+    const decoded = unescaped(escape);
+    if (decoded === undefined) {
+      return undefined;
+    }
+    value += body.slice(from, escape.index) + decoded;
+    from = escape.index + escape[0].length;
+  }
+  return value + body.slice(from);
+}
+
+/**
+ * The export names one import clause reads: `default` for a default binding and each name
+ * its braces list, or undefined for a namespace import, which reads every export, and for
+ * a clause this reading does not parse, which may read any.
+ */
+function clauseNames(clause: string): readonly string[] | undefined {
+  const braces = BRACES.exec(clause);
+  const head = (braces === null ? clause : clause.slice(0, braces.index))
+    .replace(/,\s*$/u, "")
+    .trim();
+  if (head.includes("*")) {
+    return undefined;
+  }
+  const names = head === "" ? [] : ["default"];
+  if (head !== "" && !/^[\w$]+$/u.test(head)) {
+    return undefined;
+  }
+  for (const part of (braces?.[1]?.match(PART) ?? []).map((one) => one.trim())) {
+    const named = NAMED_IMPORT.exec(part);
+    if (part === "") {
+      continue;
+    }
+    if (named?.[1] === undefined) {
+      return undefined;
+    }
+    const name = /^["']/u.test(named[1]) ? quotedName(named[1]) : named[1];
+    if (name === undefined) {
+      return undefined;
+    }
+    names.push(name);
+  }
+  return names;
+}
+
+/** The relative specifiers one document's import lines name, its fenced code blocks skipped. */
+function importedBy(
+  text: string,
+): readonly { readonly specifier: string; readonly names: readonly string[] | undefined }[] {
+  const found: { specifier: string; names: readonly string[] | undefined }[] = [];
+  let open: string | undefined;
+  for (const line of text.split(/\r?\n/u)) {
+    const fence = FENCE.exec(line);
+    const marker = fence?.[1];
+    if (marker !== undefined && open === undefined) {
+      open = marker;
+      continue;
+    }
+    // https://spec.commonmark.org/0.31.2/#fenced-code-blocks: only a run of the opening
+    // character, at least as long and followed by nothing, closes a fence.
+    if (
+      marker !== undefined &&
+      open !== undefined &&
+      marker.startsWith(open.slice(0, 1)) &&
+      marker.length >= open.length &&
+      fence?.[2]?.trim() === ""
+    ) {
+      open = undefined;
+      continue;
+    }
+    const matched = open === undefined ? IMPORT_LINE.exec(line) : null;
+    const specifier = matched?.[2];
+    if (specifier?.startsWith("./") === true || specifier?.startsWith("../") === true) {
+      found.push({ specifier, names: clauseNames(matched?.[1] ?? "") });
+    }
+  }
+  return found;
+}
+
+/** One document below a target root, by absolute path, and what its import lines name. */
+interface DocumentImports {
+  readonly path: string;
+  readonly imports: ReturnType<typeof importedBy>;
+}
+
+/**
+ * The documents each host's target roots hold, which every project of a run reads alike,
+ * kept for the host's life as {@link Host} allows.
+ */
+const documentsOf = new WeakMap<Host, Map<string, readonly DocumentImports[]>>();
+
+/** Every readable document below `root` and the import lines it writes, read once per host. */
+function documentImports(host: Host, root: string): readonly DocumentImports[] {
+  const byRoot = documentsOf.get(host) ?? new Map<string, readonly DocumentImports[]>();
+  documentsOf.set(host, byRoot);
+  const known = byRoot.get(root);
+  if (known !== undefined) {
+    return known;
+  }
+  const found = filesBelow(host, root, (name) => DOCUMENT.test(name)).flatMap((below) => {
+    const path = joinPath(root, below);
+    try {
+      return [{ path, imports: importedBy(host.readFile(path)) }];
+    } catch {
+      return [];
+    }
+  });
+  byRoot.set(root, found);
+  return found;
+}
+
+/**
+ * Every own file one document below the target root imports by a relative specifier,
+ * read against the document's directory, on disk or through the emit mapping.
+ */
+export function documentEntries(
+  host: Host,
+  targetRoot: string,
+  files: SourceFiles,
+): readonly DocumentEntry[] {
+  const root = resolvePath(host.workingDirectory(), targetRoot);
+  const found: DocumentEntry[] = [];
+  for (const { path, imports } of documentImports(host, root)) {
+    const dir = dirnamePath(path);
+    for (const { specifier, names } of imports) {
+      const reached = resolveRelativeSpecifier(host, dir, specifier);
+      const held = reached === undefined ? undefined : files.byName.get(reached);
+      for (const file of held === undefined ? files.named(resolvePath(dir, specifier)) : [held]) {
+        found.push({ file, source: specifier, names });
+      }
+    }
+  }
+  return found;
+}

package/src/module-declarations.ts

@@ -104,6 +104,8 @@ function namesModule(specifier: string, name: string): boolean {
 interface Named {
   readonly id: string;
   readonly members: readonly string[];
+  /** Whether the declaration's name is a pattern, which a specifier names by matching it. */
+  readonly wildcard: boolean;
 }
 
 /**
@@ -140,7 +142,7 @@ function namedBy(
         ]),
       );
       const members = (children.get(id) ?? []).filter((child) => wanted.has(child.ref));
-      return [{ id, members: members.map((child) => child.id) }];
+      return [{ id, members: members.map((child) => child.id), wildcard: name.includes("*") }];
     });
 }
 
@@ -208,28 +210,24 @@ export function moduleDeclarationReferences<Brand>(
   imports.forEach((one, index) => {
     const resolved = moduleOf(declared.length + index);
     const position = renderPosition(one.file, root, one.specifier.getStart());
-    const read = (to: string, resolution: Reference["resolution"]): void => {
-      found.push({
-        from: one.from,
-        to,
-        position,
-        use: "read",
-        resolution,
-        test: testFiles.has(position.path),
-      });
+    const read = (to: string, resolution: Reference["resolution"], test: boolean): void => {
+      found.push({ from: one.from, to, position, use: "read", resolution, test });
     };
+    const test = testFiles.has(position.path);
     const same = new Set(
       declared
         .filter((_, at) => resolved !== undefined && resolved === moduleOf(at))
         .map((declaration) => declaration.id),
     );
     for (const id of same) {
-      read(id, "batch");
+      read(id, "batch", test);
     }
     for (const declaration of named(one.specifier.text, one.names)) {
-      if (!same.has(declaration.id)) {
+      // A wildcard declaration is how the compiler types the file a matching specifier
+      // names, so the import uses it whoever writes it, a test included.
+      if (declaration.wildcard || !same.has(declaration.id)) {
         for (const to of [declaration.id, ...declaration.members]) {
-          read(to, "syntax");
+          read(to, "syntax", test && !declaration.wildcard);
         }
       }
     }

package/src/outside-tests.ts

@@ -20,7 +20,7 @@ import {
   type SourceFile,
 } from "@typescript/native/ast";
 import { RESOLVED_EXTENSIONS, type ParseFile } from "./configuration-files.ts";
-import { emittedFrom } from "./emit-map.ts";
+import { emittedFrom } from "./load/emit-map.ts";
 import type { Host } from "./host.ts";
 import type { Inventory } from "./inventory.ts";
 import { namesImported } from "./module-declarations.ts";

package/src/overrides.ts

@@ -1,10 +1,9 @@
 /**
- * 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, 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.
+ * The overrides of the target's class members. A call through the base class runs the
+ * override of whichever subclass the value is, so the base member references every
+ * override. A member, static or not, overriding one of a class declared outside the target
+ * at any depth of its `extends` chain, a library's interface-and-variable class such as
+ * `Error` included, is used by outside code holding the value, so its own class references it.
  */
 
 import {
@@ -115,12 +114,16 @@ export function overrideReferences<Brand>(
       if (
         inTarget.length === 0 &&
         declared !== UNANSWERED &&
-        (declared.flags & SymbolFlags.Class) !== 0 &&
-        // The target's augmentation of an outside class merges an interface into it,
-        // so only a class declaration says where the class is.
-        declared.declarations.some(
-          (handle) => CLASS_DECLARATIONS.has(handle.kind) && !own.has(handle.path),
-        )
+        (((declared.flags & SymbolFlags.Class) !== 0 &&
+          // The target's augmentation of an outside class merges an interface into it,
+          // so only a class declaration says where the class is.
+          declared.declarations.some(
+            (handle) => CLASS_DECLARATIONS.has(handle.kind) && !own.has(handle.path),
+          )) ||
+          ((declared.flags & SymbolFlags.Interface) !== 0 &&
+            declared.declarations.some(
+              (handle) => handle.kind === SyntaxKind.VariableDeclaration && !own.has(handle.path),
+            )))
       ) {
         outsideBases.set(id, declared);
       }
@@ -185,11 +188,13 @@ function outsideMemberNames<Brand>(
   outsideBases: ReadonlyMap<string, TSSymbol>,
 ): ReadonlyMap<string, ReadonlySet<string>> {
   const direct = new Map<string, ReadonlySet<string>>();
+  const error = errorType(project);
   for (const [classId, base] of outsideBases) {
     const instance = project.queries.declaredTypeOf(base);
     const statics = project.queries.typeOfSymbol(base);
     const components = [
       ...namesOf(project, instance === UNANSWERED ? undefined : instance).map(nameComponent),
+      ...(instance !== UNANSWERED && reaches(project, instance, error) ? ["toString"] : []),
       ...namesOf(project, statics === UNANSWERED ? undefined : statics).map(
         (name) => `${nameComponent(name)}:static`,
       ),
@@ -218,6 +223,40 @@ function outsideMemberNames<Brand>(
   return names;
 }
 
+/** The global `Error` instance type's identifier, where the program's library declares one. */
+function errorType<Brand>(project: ProjectView<Brand>): number | undefined {
+  const symbol = project.queries.resolveName("Error", SymbolFlags.Type, undefined, false);
+  if (symbol === UNANSWERED || symbol === undefined) {
+    return undefined;
+  }
+  const type = project.queries.declaredTypeOf(symbol);
+  return type === UNANSWERED ? undefined : type.id;
+}
+
+/**
+ * Whether one type is the `Error` instance type or extends it at any depth: the runtime
+ * prints an error through its `toString`, a member the library's `Error` interface omits.
+ */
+function reaches<Brand>(
+  project: ProjectView<Brand>,
+  type: Type,
+  target: number | undefined,
+): boolean {
+  const seen = new Set<number>();
+  const pending = [type];
+  for (let next = pending.pop(); next !== undefined; next = pending.pop()) {
+    if (next.id === target) {
+      return true;
+    }
+    if (!seen.has(next.id)) {
+      seen.add(next.id);
+      const bases = project.queries.baseTypes(next);
+      pending.push(...(bases === UNANSWERED ? [] : bases));
+    }
+  }
+  return false;
+}
+
 /** 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);

package/src/partial.ts

@@ -1,6 +1,7 @@
-import type { NotBuilt } from "./discover.ts";
+import type { NotBuilt } from "./load/discover.ts";
 import { relativePath } from "./paths.ts";
 import type { UnansweredQuestion } from "./query.ts";
+import { bytewise } from "./text/compare.ts";
 
 /** What a run read only in part. */
 interface Partial {
@@ -24,7 +25,7 @@ function counted(n: number, one: string, many: string): string {
  */
 export function partialNotes(partial: Partial): readonly string[] {
   const notes = [...partial.notBuilt]
-    .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
+    .sort((a, b) => bytewise(a.id, b.id))
     .map(
       (one) =>
         `the derived configuration ${one.id} was not built and is not analyzed: ${one.error}`,

package/src/paths.ts

@@ -1,11 +1,7 @@
 /**
- * Filesystem paths, as the supported platform spells them: a solidus separates
- * segments and a leading solidus makes a path absolute.
- *
- * They are written here rather than taken from the platform's own library because
- * every module below the command line stays free of the platform, and because the
- * supported platform set is one, so a second spelling would be a rule nothing
- * exercises.
+ * Filesystem paths as the supported platform spells them: a solidus between segments, a
+ * leading one for an absolute path. They are written here rather than taken from the
+ * platform's library so every module below the command line stays free of the platform.
  */
 
 const SEPARATOR = "/";
@@ -67,6 +63,25 @@ export function dirnamePath(path: string): string {
   return cut === 0 ? SEPARATOR : normalized.slice(0, cut);
 }
 
+/**
+ * `dir` and every directory above it, nearest first, normalized. With `top`, the list ends
+ * at `top` and is empty where `dir` is neither `top` nor below it; without, it ends at the
+ * root of the path.
+ */
+export function ancestors(dir: string, top?: string): readonly string[] {
+  const end = top === undefined ? undefined : normalizePath(top);
+  const found: string[] = [];
+  for (let at = normalizePath(dir); ; at = dirnamePath(at)) {
+    if (end !== undefined && at !== end && relativePath(end, at) === undefined) {
+      return [];
+    }
+    found.push(at);
+    if (at === end || dirnamePath(at) === at) {
+      return found;
+    }
+  }
+}
+
 /**
  * The extension of one path's last segment, from its last full stop, or the empty string
  * where it has none. A segment that only starts with a full stop has none.
@@ -101,14 +116,11 @@ export function queriedModulePath(specifier: string): string | undefined {
 }
 
 /**
- * One path as it reads below a root, or undefined when it is not below the root.
- * Both are normalized first, so a root written with a trailing separator or a `.`
- * segment reaches the same answer, and the comparison is then lexical, so a root
- * and a path spelled through different symbolic links name nothing in common. The
- * root itself is not below itself.
- *
- * The caller resolves both against the same directory before calling: a relative
- * root and an absolute path are two spellings this cannot reconcile.
+ * One path as it reads below a root, or undefined when it is not strictly below the root:
+ * the root itself is not below itself. Both are normalized, then compared lexically, so a
+ * root and a path spelled through different symbolic links name nothing in common. The
+ * caller resolves both against the same directory first: a relative root and an absolute
+ * path cannot be reconciled.
  */
 export function relativePath(root: string, path: string): string | undefined {
   const at = normalizePath(root);

package/src/position.ts

@@ -1,5 +1,6 @@
 import type { SourceFile } from "@typescript/native/ast";
 import { relativePath } from "./paths.ts";
+import { bytewise } from "./text/compare.ts";
 
 /**
  * Where one declaration is written, as every report renders it.
@@ -87,7 +88,7 @@ export function positionKey(position: Position): string {
  */
 export function byPosition(a: Position, b: Position): number {
   if (a.path !== b.path) {
-    return a.path < b.path ? -1 : 1;
+    return bytewise(a.path, b.path);
   }
   if (a.line !== b.line) {
     return a.line - b.line;

package/src/print.ts

@@ -1,95 +1,16 @@
-import {
-  renderOrigin,
-  type Config,
-  type DeclarationEntry,
-  type Provenance,
-  type Provider,
-} from "./config.ts";
-
-/** One declaration entry as a document writes it: the members of its shape alone. */
-function declarationOf(entry: DeclarationEntry): Record<string, string> {
-  switch (entry.shape) {
-    case "symbol":
-      return { symbol: entry.symbol };
-    case "module":
-      return { module: entry.module, name: entry.name };
-    case "global":
-      return { global: entry.global };
-  }
-}
-
-/** One provider entry as a document writes it: the members of its shape alone. */
-function providerOf(entry: Provider): Record<string, unknown> {
-  const installed = { name: entry.name, languages: entry.languages, command: entry.command };
-  if (entry.shape === "installed") {
-    return installed;
-  }
-  return { ...installed, source: entry.source, version: entry.version, digest: entry.digest };
-}
+import { renderOrigin, type Provenance, type ResolvedConfig } from "./config.ts";
+import { bytewise } from "./text/compare.ts";
 
 /**
- * The resolved configuration and its provenance as one JSON object, indented,
- * ending in a newline.
- *
- * The output is an instance of the closed key list, so reading it back as a
- * repository configuration resolves to the same configuration: the provenance
- * object is a declared key resolution ignores. Keys are written in the schema's
- * order and the severity and provenance objects in ascending key order, so one
- * configuration renders to one string whatever order a source named its settings
- * in.
+ * The resolved configuration and its provenance as one JSON object, indented, ending
+ * in a newline: the configuration in the order resolution gives it, then the provenance
+ * object in ascending key order. Read back as a repository configuration it resolves to
+ * the same configuration, because resolution checks the provenance object and then
+ * ignores it.
  */
-export function printConfig(config: Config, provenance: Provenance): string {
-  const document = {
-    contract_version: config.contractVersion,
-    target: { kind: config.targetKind },
-    analysis: {
-      languages: config.analysis.languages,
-      min_confidence: config.analysis.minConfidence,
-      generated_files: config.analysis.generatedFiles,
-      consumer_tests: config.analysis.consumerTests,
-      configurations: config.analysis.configurations.map((entry) =>
-        entry.shape === "project"
-          ? { id: entry.id, project: entry.project }
-          : { id: entry.id, os: entry.os, arch: entry.arch, tags: entry.tags },
-      ),
-      matrix: { complete: config.analysis.matrixComplete },
-      template_dirs: config.analysis.templateDirs,
-      template_delimiters: {
-        left: config.analysis.templateDelimiters.left,
-        right: config.analysis.templateDelimiters.right,
-      },
-    },
-    consumers: { complete: config.consumersComplete },
-    roots: { patterns: config.rootPatterns },
-    severity: Object.fromEntries([...config.severity].sort(([a], [b]) => (a < b ? -1 : 1))),
-    exemptions: { disabled: config.exemptionsDisabled },
-    reporters: {
-      formats: config.reporters.formats,
-      sort: config.reporters.sort,
-      cascade: config.reporters.cascade,
-      max_findings: config.reporters.maxFindings,
-      fail_on: config.reporters.failOn,
-    },
-    providers: { analyzers: config.providers.analyzers.map(providerOf) },
-    go: {},
-    ts: {
-      test_files: config.ts.testFiles,
-      entry_files: config.ts.entryFiles,
-      component_extensions: config.ts.componentExtensions,
-      disabled_conventions: config.ts.disabledConventions,
-      injection_registrations: config.ts.injectionRegistrations.map(declarationOf),
-      lifecycle_contracts: config.ts.lifecycleContracts.map((entry) => ({
-        components: entry.components.map(declarationOf),
-        bases: entry.bases.map(declarationOf),
-        members: entry.members,
-      })),
-      serializers: config.ts.serializers.map(declarationOf),
-    },
-    provenance: Object.fromEntries(
-      [...provenance]
-        .sort(([a], [b]) => (a < b ? -1 : 1))
-        .map(([path, origin]) => [path, renderOrigin(origin)]),
-    ),
-  };
-  return `${JSON.stringify(document, undefined, 2)}\n`;
+export function printConfig(config: ResolvedConfig, provenance: Provenance): string {
+  const origins = [...provenance]
+    .sort(([a], [b]) => bytewise(a, b))
+    .map(([path, origin]): [string, string] => [path, renderOrigin(origin)]);
+  return `${JSON.stringify({ ...config, provenance: Object.fromEntries(origins) }, undefined, 2)}\n`;
 }

package/src/product.ts

@@ -0,0 +1,18 @@
+import { LANGUAGE_ROWS } from "./contract/contract.generated.ts";
+import type { Writer } from "./run.ts";
+
+/** The language this analyzer reads. */
+export const LANGUAGE = "ts";
+
+/** The analyzer's name: the one its language's row names, which every output spells it with. */
+export const PRODUCT = LANGUAGE_ROWS[LANGUAGE].analyzer;
+
+/** Writes one diagnostic line to the error stream, named for the analyzer. */
+export function diagnose(err: Writer, text: string): void {
+  err.write(`${PRODUCT}: ${text}\n`);
+}
+
+/** The text one thrown value carries. */
+export function message(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}

package/src/query.ts

@@ -211,6 +211,8 @@ export interface Queries {
   symbolOfType(type: Type): Answer<TSSymbol | undefined>;
   signaturesOf(type: Type, kind: SignatureKind): Answer<readonly Signature[]>;
   resolvedSignature(node: Node): Answer<Signature | undefined>;
+  /** The signature each call-like node resolves to. */
+  resolvedSignatures(nodes: readonly Node[], cap?: number): Answer<Signature | undefined>[];
   parameterType(signature: Signature, index: number): Answer<Type | undefined>;
   /** The generic signature an instantiated one instantiates; none for another signature. */
   genericOf(signature: Signature): Answer<Signature | undefined>;
@@ -544,6 +546,15 @@ export function queriesOf(
         () => nodeLocation(node),
         () => checker.getResolvedSignature(node),
       ),
+    resolvedSignatures: (nodes, cap = DEFAULT_BATCH_CAP) =>
+      each(
+        "getResolvedSignature",
+        nodes,
+        cap,
+        nodeLocation,
+        (node) => checker.getResolvedSignature.gen(node),
+        (node) => checker.getResolvedSignature(node),
+      ),
     parameterType: (signature, index) =>
       one(
         "getParameterType",

package/src/ref.ts

@@ -49,9 +49,12 @@ export const REF_EXPRESSIONS: readonly string[] = [
   `^${SCOPE}#$`,
   `^${SCOPE}#${TS_HEAD}$`,
   `^${SCOPE}#(?:${TS_QUOTED}\\.)?${TS_HEAD}:alias$`,
+  `^${SCOPE}#${TS_HEAD}:import$`,
   `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+$`,
   `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+:static$`,
+  `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+\\.${TS_QUOTED}:case$`,
   `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})*(?::static)?<${TS_IDENT}>$`,
+  `^${SCOPE}#(?:${TS_HEAD}(?:\\.${TS_MEMBER})*(?::static)?)?\\(${TS_IDENT}\\)$`,
   `^${MANIFEST_SCOPE}#${TS_PACKAGE}:(?:dependency|dev-dependency|peer-dependency)$`,
 ];
 
@@ -151,6 +154,16 @@ export function computedComponent(text: string): string {
   return `[${text.replaceAll(ASCII_WHITESPACE, "")}]`;
 }
 
+/** The reference of an import binding, read against the reference of the module that holds it. */
+export function importRef(moduleRef: string, name: string): string {
+  return `${moduleRef}${nameComponent(name)}:import`;
+}
+
+/** The reference of a parameter, read against the reference of the declaration that holds it. */
+export function parameterRef(holderRef: string, name: string): string {
+  return `${holderRef}(${name})`;
+}
+
 /** 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)}.`;