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

package/src/base-url.ts

@@ -0,0 +1,24 @@
+import { resolvePath } from "./paths.ts";
+import type { Engine } from "./session.ts";
+
+type CompilerOptions = ReturnType<Engine["parseConfigFile"]>["options"];
+
+/**
+ * The `paths` one configuration's resolved options map under the compilers before version
+ * 7, each target absolute: a target is read against the effective `baseUrl`, and a specifier
+ * no other pattern maps is looked up below it. Undefined where no `baseUrl` is set, so the
+ * options' own `paths` stand. Version 7 reads no `baseUrl`:
+ * https://github.com/microsoft/TypeScript/issues/62207
+ */
+export function baseUrlPaths(options: CompilerOptions): Record<string, string[]> | undefined {
+  const baseUrl: unknown = Reflect.get(options, "baseUrl");
+  if (typeof baseUrl !== "string") {
+    return undefined;
+  }
+  return Object.fromEntries(
+    Object.entries({ "*": ["*"], ...options.paths }).map(([key, targets]) => [
+      key,
+      targets.map((target) => resolvePath(baseUrl, target)),
+    ]),
+  );
+}

package/src/component-files.ts

@@ -188,18 +188,25 @@ function scriptTagAt(text: string, offset: number): boolean {
   );
 }
 
+/** Where the braces opening at one offset end, and whether a `}` matched them. */
+interface Braces {
+  /** Past the matching `}`, or where the scan stopped: a line-start `<script` or the end. */
+  readonly end: number;
+  readonly closed: boolean;
+}
+
 /**
- * The offset past the `}` matching the `{` at `from`, quoted strings skipped, or -1 where
- * none matches before the end or before a `<script` start tag that begins a line, so a
- * stray brace in markup never hides a block.
+ * The braces opening at `from`, quoted strings skipped. The scan stops unclosed at the
+ * end, or before a `<script` start tag that begins a line, so a stray brace in markup
+ * never hides a block.
  */
-function pastBraces(text: string, from: number): number {
+function scanBraces(text: string, from: number): Braces {
   let depth = 0;
   let at = from;
   while (at < text.length) {
     const code = text.charCodeAt(at);
     if (scriptTagAt(text, at)) {
-      return -1;
+      return { end: at, closed: false };
     }
     if (code === 0x22 || code === 0x27 || code === 0x60) {
       at = pastQuoted(text, at);
@@ -210,12 +217,59 @@ function pastBraces(text: string, from: number): number {
     } else if (code === 0x7d) {
       depth -= 1;
       if (depth === 0) {
-        return at + 1;
+        return { end: at + 1, closed: true };
       }
     }
     at += 1;
   }
-  return -1;
+  return { end: text.length, closed: false };
+}
+
+/** The offset past the `}` matching the `{` at `from`, or -1 where {@link scanBraces} finds none. */
+function pastBraces(text: string, from: number): number {
+  const braces = scanBraces(text, from);
+  return braces.closed ? braces.end : -1;
+}
+
+/** How one framework's parser reads the forms the frameworks disagree on. */
+interface Dialect {
+  /** Whether `<!-->`, `<!--->` and `--!>` end a comment, the opening dashes counted. */
+  readonly shortComments: boolean;
+  /** Whether a start tag's unmatched `{` is a character of an attribute name or value. */
+  readonly braceIsText: boolean;
+}
+
+/**
+ * The dialect each framework's parser reads: Vue's tokenizer, Svelte's parser and Astro's
+ * tokenizer, the last for any other extension too. `.vue` also closes `--!>`, which Vue
+ * does not, so a block Vue drops there is still read.
+ * https://github.com/vuejs/core/blob/main/packages/compiler-core/src/tokenizer.ts
+ * https://github.com/sveltejs/svelte/blob/main/packages/svelte/src/compiler/phases/1-parse/state/element.js
+ * https://github.com/withastro/compiler/blob/main/internal/token.go
+ */
+function dialectOf(extension: string): Dialect {
+  switch (extension.toLowerCase()) {
+    case ".svelte":
+      return { shortComments: false, braceIsText: false };
+    case ".vue":
+      return { shortComments: true, braceIsText: true };
+    default:
+      return { shortComments: true, braceIsText: false };
+  }
+}
+
+/** The offset past the comment whose `<!--` is at `lt`, or the text's length where none ends it. */
+function pastComment(text: string, lt: number, dialect: Dialect): number {
+  if (!dialect.shortComments) {
+    const close = text.indexOf("-->", lt + 4);
+    return close < 0 ? text.length : close + 3;
+  }
+  const dashes = text.indexOf("-->", lt + 2);
+  const bang = text.indexOf("--!>", lt + 2);
+  if (bang >= 0 && (dashes < 0 || bang < dashes)) {
+    return bang + 4;
+  }
+  return dashes < 0 ? text.length : dashes + 3;
 }
 
 interface Attribute {
@@ -234,17 +288,43 @@ interface StartTag {
   readonly attributes: readonly Attribute[];
 }
 
-/** The start tag whose `<` is at `from`, to its `>`. A quoted or braced value may hold `>`. */
-function readStartTag(text: string, from: number, nameStop: number): StartTag {
+/**
+ * Where an unmatched `{` of a start tag ends its braced value: at the first `>`, or where
+ * the brace scan stopped where that comes first.
+ */
+function unmatchedBraceEnd(text: string, from: number, braces: Braces): number {
+  const close = text.indexOf(">", from);
+  return close >= 0 && close < braces.end ? close : braces.end;
+}
+
+/**
+ * The start tag whose `<` is at `from`, to its `>`. A quoted or braced value may hold `>`.
+ * Past an unmatched `{`, the tag also ends before a `<script` start tag that begins a line.
+ */
+function readStartTag(text: string, from: number, nameStop: number, dialect: Dialect): StartTag {
   const name = text.slice(from + 1, nameStop).toLowerCase();
   const attributes: Attribute[] = [];
   let at = nameStop;
   let selfClosing = false;
+  let unmatched = false;
+  /** The braces opening at `at`, and whether they make a braced value rather than text. */
+  const bracesAt = (): { readonly braces: Braces; readonly value: boolean } | undefined => {
+    if (text.charCodeAt(at) !== 0x7b) {
+      return undefined;
+    }
+    const braces = scanBraces(text, at);
+    return { braces, value: braces.closed || !dialect.braceIsText };
+  };
+  const bracedEnd = (braces: Braces): number =>
+    braces.closed ? braces.end : unmatchedBraceEnd(text, at, braces);
   while (at < text.length) {
     const code = text.charCodeAt(at);
     if (code === 0x3e) {
       return { name, end: at + 1, selfClosing, attributes };
     }
+    if (unmatched && scriptTagAt(text, at)) {
+      return { name, end: at, selfClosing, attributes };
+    }
     if (isSpace(code)) {
       at += 1;
       continue;
@@ -256,12 +336,13 @@ function readStartTag(text: string, from: number, nameStop: number): StartTag {
     }
     selfClosing = false;
     const start = at;
-    if (code === 0x7b) {
-      const past = pastBraces(text, at);
-      at = past < 0 ? text.length : past;
+    const bare = bracesAt();
+    unmatched ||= bare?.braces.closed === false;
+    if (bare?.value === true) {
+      at = bracedEnd(bare.braces);
       attributes.push({
         name: "",
-        value: text.slice(start + 1, at - 1),
+        value: text.slice(start + 1, bare.braces.closed ? at - 1 : at),
         start,
         end: at,
         valueStart: start + 1,
@@ -287,16 +368,18 @@ function readStartTag(text: string, from: number, nameStop: number): StartTag {
         at += 1;
       }
       const opening = text.charCodeAt(at);
+      const braced = bracesAt();
+      unmatched ||= braced?.braces.closed === false;
       if (opening === 0x22 || opening === 0x27) {
-        const past = pastQuoted(text, at);
+        // An attribute value has no escapes: a backslash before its quote is text.
+        const close = text.indexOf(text.charAt(at), at + 1);
         valueStart = at + 1;
-        value = text.slice(at + 1, Math.max(past - 1, at + 1));
-        at = past;
-      } else if (opening === 0x7b) {
-        const past = pastBraces(text, at);
-        const stop = past < 0 ? text.length : past;
+        value = text.slice(at + 1, close < 0 ? text.length : close);
+        at = close < 0 ? text.length : close + 1;
+      } else if (braced?.value === true) {
+        const stop = bracedEnd(braced.braces);
         valueStart = at + 1;
-        value = text.slice(at + 1, Math.max(stop - 1, at + 1));
+        value = text.slice(at + 1, braced.braces.closed ? stop - 1 : stop);
         at = stop;
       } else {
         valueStart = at;
@@ -410,9 +493,11 @@ function scriptsInside(text: string, from: number, to: number): number[] {
  * The scan keeps a stack of open elements. A comment, a doctype or processing instruction and
  * an expression in braces are text, and an end tag closes back to the nearest open element of
  * its name. A raw-text element at the top level runs to its own end tag, and only a `script`
- * element whose start tag begins a line at the top level is a block.
+ * element whose start tag begins a line at the top level is a block. The file's extension
+ * names the framework whose reading of a comment and of a stray brace applies.
  */
-export function readComponent(text: string): ComponentFile {
+export function readComponent(text: string, extension: string): ComponentFile {
+  const dialect = dialectOf(extension);
   const blocks: Block[] = [];
   const imports: SourceImport[] = [];
   const warnings: ComponentWarning[] = [];
@@ -442,8 +527,7 @@ export function readComponent(text: string): ComponentFile {
     }
     const lt = at;
     if (text.startsWith("<!--", lt)) {
-      const close = text.indexOf("-->", lt + 4);
-      at = close < 0 ? text.length : close + 3;
+      at = pastComment(text, lt, dialect);
       continue;
     }
     const next = text.charCodeAt(lt + 1);
@@ -467,7 +551,7 @@ export function readComponent(text: string): ComponentFile {
       at = lt + 1;
       continue;
     }
-    const tag = readStartTag(text, lt, nameStop);
+    const tag = readStartTag(text, lt, nameStop, dialect);
     const rawText = open.length === 0 && RAW_TEXT.has(tag.name);
     for (const attribute of rawText ? [] : tag.attributes) {
       if (attribute.value !== "") {
@@ -542,9 +626,9 @@ export function readComponent(text: string): ComponentFile {
 }
 
 /**
- * Whether the module's text exports a default at its top level: an `export default`
- * or an export clause naming `default`, outside every comment, string, template and
- * regular expression, and outside every bracket.
+ * Whether the module's text exports a default at its top level: an `export default`, an
+ * `export * as default`, or an export clause naming `default`, outside every comment,
+ * string, template and regular expression, and outside every bracket.
  */
 export function exportsDefault(text: string): boolean {
   const words: string[] = [];
@@ -633,7 +717,8 @@ export function exportsDefault(text: string): boolean {
     const matched = word.exec(text);
     if (matched !== null) {
       const name = matched[0];
-      if (depth === 0 && words.at(-1) === "export" && name === "default") {
+      const starAs = words.at(-3) === "export" && words.at(-2) === "*" && words.at(-1) === "as";
+      if (depth === 0 && (words.at(-1) === "export" || starAs) && name === "default") {
         return true;
       }
       if (clause && name === "default") {
@@ -662,8 +747,8 @@ export function exportsDefault(text: string): boolean {
 }
 
 /** The module one component file's text is read as, and the span map back to the file. */
-export function componentModule(text: string): ComponentModule {
-  const { blocks, imports } = readComponent(text);
+export function componentModule(text: string, fileExtension: string): ComponentModule {
+  const { blocks, imports } = readComponent(text, fileExtension);
   const out: string[] = [];
   let at = 0;
   let language: BlockLanguage | undefined;

package/src/components.ts

@@ -208,12 +208,12 @@ function linesSpanned(symbols: readonly (InventorySymbol | undefined)[]): number
 }
 
 /**
- * The dead declarations by subgraph place (`at`, and `position` per graph declaration),
- * a test file's only where it tests dead code or nothing the tests reach. `adjacent` holds
- * each reference one makes to another, except an unreferenced test-file declaration's to
- * production code, which decides nothing of its target; an edge each way between a dead
- * member and its dead container; and one back from each production target of an admitted
- * test, which puts the test in its subject's component. `references` holds the first alone.
+ * The dead declarations by subgraph place (`at`, and `position` per graph declaration), a
+ * test file's only where it tests dead code or nothing the tests reach. `adjacent` holds each
+ * reference one makes to another, but an unreferenced test-file declaration's to production
+ * code, which decides nothing; an edge each way between a dead member and its dead container;
+ * and one back from each non-ambient production target of an admitted test, which puts the
+ * test in its subject's component. `references` holds the first alone.
  */
 function deadSubgraph(
   graph: Graph,
@@ -248,6 +248,7 @@ function deadSubgraph(
       if (
         testOfDeadCode[index] === true &&
         graph.test[edge.to] !== true &&
+        graph.ambient[edge.to] !== true &&
         graph.subject[edge.to] === true
       ) {
         adjacent[to]?.push(from);

package/src/config.ts

@@ -175,6 +175,8 @@ export interface TSSection {
   readonly injectionRegistrations: readonly DeclarationEntry[];
   readonly lifecycleContracts: readonly LifecycleContract[];
   readonly serializers: readonly DeclarationEntry[];
+  /** Whether the maintainer declares the roots the analysis finds every root the target has. */
+  readonly rootsComplete: boolean;
 }
 
 /**
@@ -253,6 +255,7 @@ export function defaultConfig(): Config {
       injectionRegistrations: [],
       lifecycleContracts: [],
       serializers: [],
+      rootsComplete: false,
     },
   };
 }

package/src/configuration-files.ts

@@ -8,10 +8,13 @@
  */
 
 import {
+  isCallExpression,
   isExportDeclaration,
+  isIdentifier,
   isImportDeclaration,
   isNoSubstitutionTemplateLiteral,
   isStringLiteral,
+  SyntaxKind,
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
@@ -110,7 +113,7 @@ interface ConfigurationDocument {
 export type ParseFile = (fileName: string, text: string) => SourceFile;
 
 /** One file no program holds that a configuration module outside the program leads to. */
-interface OutsideModule {
+export interface OutsideModule {
   /** The file, parsed alone. */
   readonly file: SourceFile;
   /** The directories of the manifests of the configuration files the file was reached from. */
@@ -278,8 +281,15 @@ function readDocument(host: Host, path: string): unknown {
 
 /** The configuration files one project holds and sits beside. */
 interface ConfigurationFiles {
-  /** Every own file that is a configuration module, with the form its name has. */
-  readonly modules: readonly { readonly file: SourceFile; readonly form: string }[];
+  /**
+   * Every own file that is a configuration module, with the form its name has and the
+   * directory of the manifest whose dependencies its strings are read against.
+   */
+  readonly modules: readonly {
+    readonly file: SourceFile;
+    readonly form: string;
+    readonly manifestDir: string;
+  }[];
   /**
    * Every configuration module in a directory of the project that the program does not
    * hold, and every file such a file imports or re-exports by a relative specifier that
@@ -345,12 +355,13 @@ export function configurationFiles(
     return held;
   };
 
-  const modules: { file: SourceFile; form: string }[] = [];
+  const modules: { file: SourceFile; form: string; manifestDir: string }[] = [];
   const dirs = new Set<string>([root]);
   for (const file of files.byPath.values()) {
     const form = configurationModuleForm(basename(file.fileName));
-    if (form !== undefined && holdsManifest(dirnamePath(file.fileName))) {
-      modules.push({ file, form });
+    const fileDir = dirnamePath(file.fileName);
+    if (form !== undefined && holdsManifest(fileDir)) {
+      modules.push({ file, form, manifestDir: fileDir });
     }
     for (
       let dir = dirnamePath(file.fileName);
@@ -383,7 +394,7 @@ export function configurationFiles(
       if (path.endsWith(".json")) {
         pending.push({ path, manifestDir: dir });
       } else if (held !== undefined) {
-        modules.push({ file: held, form: "a script's configuration flag" });
+        modules.push({ file: held, form: "a script's configuration flag", manifestDir: dir });
       } else {
         named.push({ path, manifestDir: dir });
       }
@@ -431,19 +442,70 @@ export function configurationFiles(
   };
 }
 
-/** The relative specifiers one file's imports and re-exports name. */
-function relativeSpecifiers(file: SourceFile): readonly string[] {
-  return file.statements.flatMap((statement) => {
-    const specifier =
+/** The literal module specifier one `require(...)` or `import(...)` call names, if any. */
+function calledSpecifier(node: Node): Node | undefined {
+  if (!isCallExpression(node) || node.arguments.length !== 1) {
+    return undefined;
+  }
+  const callee = node.expression;
+  const loads =
+    callee.kind === SyntaxKind.ImportKeyword || (isIdentifier(callee) && callee.text === "require");
+  return loads ? node.arguments[0] : undefined;
+}
+
+/**
+ * The relative specifiers one file's imports and re-exports name, and those its
+ * `require(...)` and `import(...)` calls name by a literal.
+ */
+export function relativeSpecifiers(file: SourceFile): readonly string[] {
+  const known = specifiersOf.get(file);
+  if (known !== undefined) {
+    return known;
+  }
+  const found: string[] = [];
+  const named = (specifier: Node | undefined): void => {
+    if (
+      specifier !== undefined &&
+      (isStringLiteral(specifier) || isNoSubstitutionTemplateLiteral(specifier)) &&
+      RELATIVE_PREFIXES.some((prefix) => specifier.text.startsWith(prefix))
+    ) {
+      found.push(specifier.text);
+    }
+  };
+  const visit = (node: Node): void => {
+    named(calledSpecifier(node));
+    node.forEachChild(visit);
+  };
+  for (const statement of file.statements) {
+    named(
       isImportDeclaration(statement) || isExportDeclaration(statement)
         ? statement.moduleSpecifier
-        : undefined;
-    return specifier !== undefined &&
-      isStringLiteral(specifier) &&
-      RELATIVE_PREFIXES.some((prefix) => specifier.text.startsWith(prefix))
-      ? [specifier.text]
-      : [];
-  });
+        : undefined,
+    );
+    visit(statement);
+  }
+  specifiersOf.set(file, found);
+  return found;
+}
+
+/** What {@link relativeSpecifiers} found in each file, which every project of a run reads alike. */
+const specifiersOf = new WeakMap<SourceFile, readonly string[]>();
+
+/**
+ * The files no program holds that a chain from `seeds` reads: each seed, and each file
+ * below the target root one imports, re-exports or loads by a relative specifier that no
+ * program holds either, until no further file joins, each read against the manifest
+ * directory its seed names. A file that cannot be read is skipped.
+ */
+export function outsideChain(
+  host: Host,
+  targetRoot: string,
+  files: SourceFiles,
+  parse: ParseFile,
+  seeds: readonly { readonly path: string; readonly manifestDir: string }[],
+): readonly OutsideModule[] {
+  const root = resolvePath(host.workingDirectory(), targetRoot);
+  return outsideModules(host, root, [], files, () => false, parse, seeds);
 }
 
 /**

package/src/configured-declarations.ts

@@ -20,7 +20,7 @@ import { SymbolFlags, type NodeHandle, type Symbol as TSSymbol } from "@typescri
 import type { AliasChains } from "./alias-chain.ts";
 import { resolvedTargets } from "./calls.ts";
 import type { Config, DeclarationEntry } from "./config.ts";
-import type { Inventory } from "./inventory.ts";
+import { declaredComponent, type Inventory } from "./inventory.ts";
 import { must, Unanswerable } from "./query.ts";
 import { nameComponent } from "./ref.ts";
 import type { ProjectView } from "./session.ts";
@@ -118,15 +118,44 @@ function candidatesOf<Brand>(
   ];
 }
 
-/** The member of one container a path component spells, followed through any alias. */
+/**
+ * The properties of the type one container declares, or of its constructor's type for a
+ * static member. A member a symbol keys is bound to that type later than the container's
+ * symbol table is built, so the table does not hold it.
+ */
+function typeMembersOf<Brand>(
+  project: ProjectView<Brand>,
+  container: TSSymbol,
+  isStatic: boolean,
+): readonly TSSymbol[] {
+  const queries = project.queries;
+  const type = must(isStatic ? queries.typeOfSymbol(container) : queries.declaredTypeOf(container));
+  return type === undefined ? [] : must(queries.propertiesOf(type));
+}
+
+/**
+ * The member of one container a path component spells, followed through any alias. A
+ * component in brackets is a computed key, compared with the key each declaration of a
+ * candidate writes: the checker names a member a symbol keys by no spelling of its own.
+ */
 function memberOf<Brand>(
   project: ProjectView<Brand>,
   container: TSSymbol,
   component: string,
   isStatic: boolean,
 ): TSSymbol | undefined {
-  const member = candidatesOf(project, container, isStatic).find(
-    (candidate) => nameComponent(candidate.name) === component,
+  const computed = component.startsWith("[");
+  const candidates = candidatesOf(project, container, isStatic);
+  const member = (
+    computed ? [...candidates, ...typeMembersOf(project, container, isStatic)] : candidates
+  ).find(
+    (candidate) =>
+      nameComponent(candidate.name) === component ||
+      (computed &&
+        candidate.declarations.some((handle) => {
+          const node = project.declarationAt(handle)?.node;
+          return node !== undefined && declaredComponent(node) === component;
+        })),
   );
   return member === undefined ? undefined : unaliased(project, member);
 }

package/src/conformance-record.ts

@@ -2,9 +2,9 @@
 // Regenerate it with `UPDATE_GOLDEN=1 npx vitest --run src/conformance.corpus.test.ts`.
 export const RECORD = {
   conformance: {
-    corpusVersion: "5.2.0",
+    corpusVersion: "6.0.0",
     result: "pass",
-    digest: "sha256:4050d1b67fb757bc12a60f8ece7317a3e8485d3383ec52919cd24b9dfd5509dc",
+    digest: "sha256:76c07ac14bda6e302444918d832b01844bac6f29b6f22a742d538804480c0769",
   },
   gaps: [],
 } as const;

package/src/contextual-uses.ts

@@ -319,14 +319,15 @@ export function contextualUses<Brand>(
     return found;
   };
 
-  const calls = new Map<number, Called | undefined>();
+  const calls = new Map<number, readonly Called[]>();
   /**
-   * The parameter and return types of a type's one call signature, or of its one construct
-   * signature where it has no call signature, read once per type.
+   * The parameter and return types of each of a type's call signatures, or of each of its
+   * construct signatures where it has no call signature, read once per type.
    */
-  const callOf = (type: Type): Called | undefined => {
-    if (calls.has(type.id)) {
-      return calls.get(type.id);
+  const callsOf = (type: Type): readonly Called[] => {
+    const known = calls.get(type.id);
+    if (known !== undefined) {
+      return known;
     }
     lookups += 1;
     let kind = SignatureKind.Call;
@@ -336,31 +337,29 @@ export function contextualUses<Brand>(
       kind = SignatureKind.Construct;
       signatures = queries.signaturesOf(type, kind);
     }
-    let called: Called | undefined;
-    const [signature, ...more] = isAnswered(signatures) ? signatures : [];
-    if (signature !== undefined && more.length === 0) {
+    const called = (isAnswered(signatures) ? signatures : []).map((signature): Called => {
       const parameters = signature.parameters.map((_parameter, index) =>
         queries.parameterType(signature, index),
       );
       const result = queries.returnTypeOf(signature);
       lookups += parameters.length + 1;
-      called = {
+      return {
         kind,
         parameters: parameters.map((one) => (isAnswered(one) ? one : undefined)),
         result: isAnswered(result) ? result : undefined,
       };
-    }
+    });
     calls.set(type.id, called);
     return called;
   };
 
   /**
    * Each object type a value of `source` is checked as against the object types of
-   * `target`: the value's own, and through array elements, a function's parameters,
-   * checked the other way, and result, and the type arguments two instantiations share
-   * by place, an array among them, as an array reaches `Iterable<T>`.
-   * A source that is one of the target's own object types matches it as it stands. Each
-   * pair is compared once, which ends the walk over a recursive type.
+   * `target`: the value's own, and through array elements, every pair of signatures
+   * (parameters checked the other way, then results), which reads more than the overload
+   * the checker picks, and the type arguments of two instantiations by place, as an array
+   * reaches `Iterable<T>`. A source that is one of the target's own object types matches
+   * it as it stands. Each pair is compared once, which ends the walk over a recursive type.
    */
   const compared = (
     source: Type | undefined,
@@ -385,7 +384,7 @@ export function contextualUses<Brand>(
         into.push({ source: one, targets, outside: true });
       }
       const element = elementOf(one);
-      const called = element === undefined ? callOf(one) : undefined;
+      const called = element === undefined ? callsOf(one) : [];
       const sourceArguments = typeArgumentsOf(one);
       for (const part of targets) {
         const partElement = elementOf(part);
@@ -399,17 +398,17 @@ export function contextualUses<Brand>(
         sourceArguments.slice(0, targetArguments.length).forEach((argument, index) => {
           compared(argument, targetArguments[index], into, seen);
         });
-        if (element !== undefined) {
+        if (element !== undefined || called.length === 0) {
           continue;
         }
-        const other = called === undefined ? undefined : callOf(part);
-        if (called === undefined || other?.kind !== called.kind) {
-          continue;
+        for (const other of callsOf(part)) {
+          for (const signature of called.filter((one) => one.kind === other.kind)) {
+            other.parameters.forEach((parameter, index) => {
+              compared(parameter, signature.parameters[index], into, seen);
+            });
+            compared(signature.result, other.result, into, seen);
+          }
         }
-        other.parameters.forEach((parameter, index) => {
-          compared(parameter, called.parameters[index], into, seen);
-        });
-        compared(called.result, other.result, into, seen);
       }
     }
   };
@@ -431,7 +430,7 @@ export function contextualUses<Brand>(
       if (element !== undefined) {
         return mayCarry(element, seen);
       }
-      return callOf(part) !== undefined || typeArgumentsOf(part).some((one) => mayCarry(one, seen));
+      return callsOf(part).length > 0 || typeArgumentsOf(part).some((one) => mayCarry(one, seen));
     });
   };
 
@@ -467,11 +466,12 @@ export function contextualUses<Brand>(
         continue;
       }
       for (const [name, member] of sourceMembers) {
+        // A member the position shares with the source is no read of it. A member with no
+        // declaration, as a mapped type over literal keys has, is never one it shares.
         const read = tables.some((table) => {
           const declared = table.get(name);
           return (
             declared !== undefined &&
-            declared.handles.size > 0 &&
             ![...declared.handles].some((handle) => member.handles.has(handle))
           );
         });