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

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))
           );
         });

package/src/dependencies.ts

@@ -376,8 +376,8 @@ export function projectNeeds<Brand>(
     sourceFilesOf(project, targetRoot),
     parse,
   );
-  for (const { file } of configuration.modules) {
-    const names = declaredAt(file.fileName);
+  for (const { file, manifestDir } of configuration.modules) {
+    const names = declaredAt(joinPath(manifestDir, MANIFEST));
     for (const { node, text } of moduleStrings(file)) {
       use(ownersOf(file, held, node), dependenciesNamed(text, names), file.fileName);
     }

package/src/destructuring.ts

@@ -24,7 +24,12 @@ import {
   type BinaryExpression,
   type Node,
 } from "@typescript/native/ast";
-import { TypeFlags, type Symbol as TSSymbol, type Type } from "@typescript/native/sync";
+import {
+  SignatureKind,
+  TypeFlags,
+  type Symbol as TSSymbol,
+  type Type,
+} from "@typescript/native/sync";
 import {
   isAnswered,
   propertyTables,
@@ -34,6 +39,10 @@ import {
 } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 
+/** The types of an iteration result's `value` that carry no element of the iterable. */
+const NO_ELEMENT =
+  TypeFlags.AnyOrUnknown | TypeFlags.Undefined | TypeFlags.Void | TypeFlags.Null | TypeFlags.Never;
+
 /** One property one object pattern reads. */
 export interface PropertyRead {
   /** The pattern, whose destructured value declares the property. */
@@ -298,11 +307,93 @@ export function destructuring<Brand>(
     return isAnswered(elements) ? elements[0] : UNANSWERED;
   };
 
+  /** The type of the one property of a type that `matches` accepts, unanswered where two do. */
+  const propertyTypeOf = (owner: Type, matches: (property: TSSymbol) => boolean): Found => {
+    const table = tableOf(owner);
+    if (!isAnswered(table)) {
+      return UNANSWERED;
+    }
+    const [property, ...more] = [...table.values()].filter(matches);
+    if (property === undefined) {
+      return undefined;
+    }
+    if (more.length > 0) {
+      return UNANSWERED;
+    }
+    patternLookups += 1;
+    return queries.typeOfSymbol(property);
+  };
+
+  const resultOf = (callee: Found): Found => {
+    if (callee === undefined || callee === UNANSWERED) {
+      return callee;
+    }
+    patternLookups += 1;
+    const signatures = queries.signaturesOf(callee, SignatureKind.Call);
+    if (!isAnswered(signatures)) {
+      return UNANSWERED;
+    }
+    const [signature] = signatures;
+    if (signature === undefined) {
+      return undefined;
+    }
+    patternLookups += 1;
+    return queries.returnTypeOf(signature);
+  };
+
+  const iterations = new Map<number, Found>();
+  /**
+   * The type a `for…of` takes from one iterable that is no array, read through the
+   * iteration protocol: the `value` of what the `next()` of its `[Symbol.iterator]()`
+   * answers. A constituent of that answer whose value is {@link NO_ELEMENT} carries no
+   * element; where more than one carries one, the element is left unanswered, so a read
+   * through it is resolved by name.
+   */
+  const iteratedOf = (type: Type): Found => {
+    if (iterations.has(type.id)) {
+      return iterations.get(type.id);
+    }
+    // The checker keys a member a unique symbol names `__@<name>@<symbol id>`, and escapes
+    // a written key that starts with `__` with one more `_`, so no string key matches; a
+    // unique symbol of the program's own named `iterator` does, which leaves two matches:
+    // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/checker/checker.go#L23096-L23108
+    // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/ast/symbol.go#L91-L103
+    const iterator = resultOf(
+      propertyTypeOf(type, (one) => one.escapedName.startsWith("__@iterator@")),
+    );
+    const result =
+      iterator === undefined || iterator === UNANSWERED
+        ? iterator
+        : resultOf(propertyTypeOf(iterator, (one) => one.name === "next"));
+    let found: Found = result;
+    if (result !== undefined && result !== UNANSWERED) {
+      let parts: Answer<readonly Type[]> = [result];
+      if (result.isUnionType()) {
+        patternLookups += 1;
+        parts = queries.constituents(result);
+      }
+      const values: readonly Found[] = isAnswered(parts)
+        ? parts.map((part) => propertyTypeOf(part, (one) => one.name === "value"))
+        : [UNANSWERED];
+      const carried = values.filter(
+        (value): value is Answer<Type> =>
+          value === UNANSWERED || (value !== undefined && (value.flags & NO_ELEMENT) === 0),
+      );
+      const [only, ...more] = carried;
+      found = more.length > 0 ? UNANSWERED : only;
+    }
+    iterations.set(type.id, found);
+    return found;
+  };
+
   const step = (type: Type, next: Step): Found => {
     const defined = definedOf(type);
     if (defined === undefined || defined === UNANSWERED) {
       return defined;
     }
+    if (next.kind === "iterated") {
+      return elementOf(defined, undefined) ?? iteratedOf(defined);
+    }
     if (next.kind === "property") {
       const table = tableOf(defined);
       if (!isAnswered(table)) {
@@ -315,7 +406,7 @@ export function destructuring<Brand>(
       patternLookups += 1;
       return queries.typeOfSymbol(property);
     }
-    return elementOf(defined, next.kind === "element" ? next.index : undefined);
+    return elementOf(defined, next.index);
   };
 
   const resolve = (reads: readonly PropertyRead[]): readonly Answer<TSSymbol | undefined>[] => {

package/src/discover.ts

@@ -2,7 +2,7 @@ import { DiagnosticCategory } from "@typescript/native/sync";
 import type { Diagnostic } from "@typescript/native/sync";
 import type { BuildConfiguration, ProjectConfiguration } from "./config.ts";
 import type { Host } from "./host.ts";
-import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.ts";
+import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.ts";
 import type { Scope } from "./scope.ts";
 import { SetupError } from "./setup-failure.ts";
 import type { Engine, ProjectDiagnostics } from "./session.ts";
@@ -95,20 +95,46 @@ export function diagnosticErrors(sets: {
 /** Why one open project cannot be analyzed, split by whether it loaded at all. */
 interface ProjectErrors {
   /**
-   * The errors in the configuration itself: no input matched, an option that does not
-   * parse. A project carrying one did not load, whatever its files say.
+   * The errors in the configuration itself, and the errors the compiler places in no file
+   * that leave its checker without a type it needs: no input matched, an option that
+   * does not parse, a missing global type. A project carrying one did not load, whatever
+   * its files say.
    */
   readonly load: readonly LocatedDiagnostic[];
   /** The errors in the files of a project that loaded: their syntax and their types. */
   readonly check: readonly LocatedDiagnostic[];
+  /**
+   * The libraries the configuration names that the compiler cannot find, which leave it
+   * loaded: a use of a name only such a library declares is an error in its file.
+   */
+  readonly unfound: readonly LocatedDiagnostic[];
 }
 
+/**
+ * The codes of a type library and a lib the configuration names that the compiler
+ * cannot find, which it reports while it gathers the program's files:
+ * https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/compiler/processingDiagnostic.go
+ */
+const UNFOUND_LIBRARY: ReadonlySet<number> = new Set([2688, 2726, 2727]);
+
 /** The errors one open project carries, each located in the file it names. */
 export function projectErrors(sets: ProjectDiagnostics): ProjectErrors {
-  const load = sets.configParsing.filter(isError);
+  // The compiler numbers its semantic messages from 2000 and its option messages from
+  // 5000. A file-less option error, a removed option or an output layout, leaves the
+  // program whole, and the compiler checks it all the same:
+  // https://github.com/microsoft/TypeScript/wiki/Coding-guidelines#diagnostic-message-codes
+  const semantic = sets.unplaced.filter(
+    (diagnostic) => isError(diagnostic) && diagnostic.code >= 2000 && diagnostic.code < 3000,
+  );
+  const unfound = semantic.filter(({ code }) => UNFOUND_LIBRARY.has(code));
+  const load = [
+    ...sets.configParsing.filter(isError),
+    ...semantic.filter(({ code }) => !UNFOUND_LIBRARY.has(code)),
+  ];
   return {
     load: locatedIn(load, sets.locate),
     check: load.length > 0 ? [] : locatedIn(diagnosticErrors(sets), sets.locate),
+    unfound: load.length > 0 ? [] : locatedIn(unfound, sets.locate),
   };
 }
 
@@ -182,10 +208,6 @@ interface Discovery {
   readonly fromScope: readonly string[];
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
 /**
  * The configuration files below `root`, in ascending path order, skipping an
  * ignored directory. A directory that cannot be read is skipped: a tree the
@@ -221,45 +243,6 @@ function configFilesUnder(host: Host, root: string): string[] {
   return found.sort();
 }
 
-/**
- * The configuration files one configuration's `references` name, resolved against
- * that configuration's own directory. A reference naming a directory names the
- * `tsconfig.json` in it, which is the compiler's own rule.
- */
-function referencesOf(host: Host, configFile: string): string[] {
-  let text: string;
-  try {
-    text = host.readFile(configFile);
-  } catch {
-    return [];
-  }
-  let value: unknown;
-  try {
-    value = JSON.parse(text);
-  } catch {
-    // What a configuration's contents say is refused by the compiler's own
-    // diagnostics, which name the position; nothing is inferred from it here.
-    return [];
-  }
-  if (!isRecord(value) || !Array.isArray(value["references"])) {
-    return [];
-  }
-  const dir = dirnamePath(configFile);
-  const found: string[] = [];
-  for (const entry of value["references"] as unknown[]) {
-    if (!isRecord(entry)) {
-      continue;
-    }
-    const path = entry["path"];
-    if (typeof path !== "string" || path === "") {
-      continue;
-    }
-    const resolved = isAbsolutePath(path) ? path : joinPath(dir, path);
-    found.push(resolved.endsWith(".json") ? resolved : joinPath(resolved, "tsconfig.json"));
-  }
-  return found;
-}
-
 /**
  * The configuration file the scope names for the target directly, where its path
  * names one rather than a directory. A target naming a directory is reached by the
@@ -274,15 +257,16 @@ function scopeConfigFiles(host: Host, scope: Scope): string[] {
 
 /**
  * Every configuration file reached from `pending`, in the order discovery reads them:
- * each once, each followed by the configurations it references, transitively. A
- * configuration the compiler cannot read ends the run naming it, unless `unreadable`
- * is given, which is then told the configuration and why, and the walk goes on
- * without it.
+ * each once, each followed by the configurations it references that `follows` admits,
+ * transitively. A configuration the compiler cannot read ends the run naming it, unless
+ * `unreadable` is given, which is then told the configuration and why, and the walk
+ * goes on without it.
  */
 function derivedFrom(
   engine: Engine,
   host: Host,
   pending: string[],
+  follows: (reference: string) => boolean,
   unreadable?: (configFile: string, reason: string) => void,
 ): string[] {
   const seen = new Set<string>();
@@ -297,19 +281,19 @@ function derivedFrom(
       continue;
     }
     seen.add(path);
-    const reason = unreadableReason(engine, path);
-    if (reason !== undefined) {
+    const read = readConfiguration(engine, path);
+    if ("reason" in read) {
       if (unreadable === undefined) {
         throw new DiscoveryError(
-          `${path} cannot be read as a compiler configuration: ${reason}`,
+          `${path} cannot be read as a compiler configuration: ${read.reason}`,
           [],
         );
       }
-      unreadable(path, reason);
+      unreadable(path, read.reason);
       continue;
     }
     found.push(path);
-    pending.push(...referencesOf(host, path));
+    pending.push(...read.references.filter(follows));
   }
   return found;
 }
@@ -335,7 +319,7 @@ export function consumerProjects(engine: Engine, host: Host, root: string): read
   if (kind !== "directory") {
     throw new DiscoveryError(`the consumer ${root} is not a directory`, []);
   }
-  const found = derivedFrom(engine, host, configFilesUnder(host, root));
+  const found = derivedFrom(engine, host, configFilesUnder(host, root), () => true);
   if (found.length === 0) {
     throw new DiscoveryError(
       `the consumer ${root} holds no compiler configuration, so none of its references can be read`,
@@ -353,39 +337,52 @@ function derivedId(targetRoot: string, configFile: string): string {
   return relativePath(targetRoot, configFile) ?? configFile;
 }
 
-/** Why the compiler cannot read one configuration file, or undefined where it can. */
-function unreadableReason(engine: Engine, configFile: string): string | undefined {
+/**
+ * The configuration files one configuration's `references` name, or why the compiler
+ * cannot read the configuration.
+ */
+function readConfiguration(
+  engine: Engine,
+  configFile: string,
+): { readonly references: readonly string[] } | { readonly reason: string } {
   try {
-    engine.parseConfigFile(configFile);
-    return undefined;
+    const parsed = engine.parseConfigFile(configFile);
+    // The parse answers a directory reference as the directory; the compiler reads a
+    // path not ending `.json` as its `tsconfig.json`:
+    // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/core/projectreference.go#L18
+    return {
+      references: (parsed.projectReferences ?? []).map(({ path }) =>
+        path.endsWith(".json") ? path : joinPath(path, "tsconfig.json"),
+      ),
+    };
   } catch (error: unknown) {
-    return error instanceof Error ? error.message : String(error);
+    return { reason: error instanceof Error ? error.message : String(error) };
   }
 }
 
 /**
- * Resolves one compiler configuration file, or ends the run naming it: a project
- * opened from a configuration the compiler cannot read would be analyzed with no
- * type information.
+ * The references of one compiler configuration file, or ends the run naming it: a
+ * project opened from a configuration the compiler cannot read would be analyzed with
+ * no type information.
  */
-function parseOrRefuse(engine: Engine, configFile: string, named: string): void {
-  const reason = unreadableReason(engine, configFile);
-  if (reason !== undefined) {
-    throw new DiscoveryError(`${named} cannot be read as a compiler configuration: ${reason}`, []);
+function parseOrRefuse(engine: Engine, configFile: string, named: string): readonly string[] {
+  const read = readConfiguration(engine, configFile);
+  if ("reason" in read) {
+    throw new DiscoveryError(
+      `${named} cannot be read as a compiler configuration: ${read.reason}`,
+      [],
+    );
   }
+  return read.references;
 }
 
 /**
- * The projects a build matrix declares, in the order it lists them. Each entry
- * names a file below the target root, and an entry naming a file that is absent,
- * that is a directory, or that the compiler cannot read ends the run naming it.
- *
- * A declared project's `references` are not followed, because the entries are the
- * matrix, and a reference to a configuration the matrix does not name ends the run
- * naming both: the compiler builds a referenced project's sources into the program
- * that references it without reporting their diagnostics, so the project the matrix
- * left out would be analyzed with its errors unread. An entry naming a file an
- * earlier entry named adds nothing, so the earlier identifier stands.
+ * The projects a build matrix declares, in its order, each entry a file below the target
+ * root: an entry naming an absent file, a directory or a file the compiler cannot read
+ * ends the run naming it, and one naming an earlier entry's file adds nothing. A
+ * reference below the root the matrix does not name ends the run naming both, because the
+ * compiler builds a referenced project's sources into the referencing program without
+ * reporting their diagnostics. A reference outside the root is an outside project.
  */
 function declaredProjects(
   engine: Engine,
@@ -395,6 +392,7 @@ function declaredProjects(
 ): Discovery {
   const seen = new Set<string>();
   const projects: DiscoveredProject[] = [];
+  const references = new Map<string, readonly string[]>();
   for (const entry of entries) {
     const configFile = joinPath(targetRoot, entry.project);
     const named = `the project ${JSON.stringify(entry.id)} (${configFile})`;
@@ -411,11 +409,13 @@ function declaredProjects(
       continue;
     }
     seen.add(configFile);
-    parseOrRefuse(engine, configFile, named);
+    references.set(configFile, parseOrRefuse(engine, configFile, named));
     projects.push({ id: entry.id, configFile });
   }
   for (const project of projects) {
-    const unnamed = referencesOf(host, project.configFile).find((path) => !seen.has(path));
+    const unnamed = references
+      .get(project.configFile)
+      ?.find((path) => !seen.has(path) && relativePath(targetRoot, path) !== undefined);
     if (unnamed !== undefined) {
       throw new DiscoveryError(
         `the project ${JSON.stringify(project.id)} (${project.configFile}) references ` +
@@ -435,21 +435,26 @@ function declaredProjects(
 }
 
 /**
- * The projects a run derives where the matrix declares none, in the order discovery
- * reads them: the paths the scope names, then every compiler configuration under
- * the target root that is not inside an ignored directory, then the configurations
- * each of those references, transitively. Each configuration appears once. A
- * configuration the scope names directly is the caller's own and ends the run where
- * it cannot be read; one the walk found is dropped and named.
+ * The projects a run derives where the matrix declares none, in discovery order: the
+ * paths the scope names, every compiler configuration under the target root outside an
+ * ignored directory, then each configuration below the root those reference,
+ * transitively, each once. A reference outside the root is an outside project, whose
+ * sources the compiler builds into the referencing program. A configuration the scope
+ * names ends the run where it cannot be read; one the walk found is dropped and named.
  */
 function derivedProjects(engine: Engine, host: Host, scope: Scope): Discovery {
   const targetRoot = scope.target.path;
   const fromScope = scopeConfigFiles(host, scope);
   const notBuilt: NotBuilt[] = [];
+  const rootDir = resolvePath(
+    host.workingDirectory(),
+    fromScope.length > 0 ? dirnamePath(targetRoot) : targetRoot,
+  );
   const configFiles = derivedFrom(
     engine,
     host,
     [...fromScope, ...configFilesUnder(host, targetRoot)],
+    (reference) => relativePath(rootDir, reference) !== undefined,
     (configFile, reason) => {
       if (fromScope.includes(configFile)) {
         throw new DiscoveryError(

package/src/edges.ts

@@ -156,7 +156,7 @@ export function readEdgeSides(host: Host, targetRoot: string): readonly EdgeSide
 
   const sides: EdgeSide[] = [];
   (edges as readonly unknown[]).forEach((value, index) => {
-    const offset = walk.opened[index];
+    const offset = walk.starts[index];
     const at =
       offset === undefined ? EDGES_FILE : positionKey(positionAt(text, EDGES_FILE, offset));
     const edge = readEdge(value, at);

package/src/intra-function-parts.ts

@@ -29,6 +29,7 @@ import {
   isExpressionStatement,
   isFunctionDeclaration,
   isFunctionExpression,
+  isFunctionLikeDeclaration,
   isHeritageClause,
   isIdentifier,
   isIfStatement,
@@ -49,6 +50,7 @@ import {
   isQualifiedName,
   isReturnStatement,
   isShorthandPropertyAssignment,
+  isSourceFile,
   isStringLiteral,
   isSwitchStatement,
   isThrowStatement,
@@ -77,6 +79,7 @@ import { isAnswered, UNANSWERED, type Answer } from "./query.ts";
 import type { Reference } from "./references.ts";
 import type { ProjectView } from "./session.ts";
 import { signatureOf, type SignatureNode } from "./signatures.ts";
+import { spellsNoBinding } from "./spelled-names.ts";
 
 /** The subject kind of each part this module reads. */
 type PartKind = "parameter" | "result" | "statement" | "store" | "case";
@@ -268,13 +271,12 @@ function caseKey(expression: Node): string | undefined {
   return undefined;
 }
 
-/** Every identifier below one node whose text one of the names spells, a member's name aside. */
+/** Every identifier below one node whose text one of the names spells as a reference. */
 function identifiersNaming(node: Node, names: ReadonlySet<string>): Identifier[] {
   const found: Identifier[] = [];
   const visit = (at: Node): void => {
     if (isIdentifier(at)) {
-      const parent = at.parent;
-      if (names.has(at.text) && !(isPropertyAccessExpression(parent) && parent.name === at)) {
+      if (names.has(at.text) && !spellsNoBinding(at)) {
         found.push(at);
       }
       return;
@@ -310,6 +312,16 @@ function inNestedFunction(node: Node, outer: Node): boolean {
   return false;
 }
 
+/** The nearest function around one node whose `arguments` object it names: an arrow has none. */
+function ownArgumentsOf(node: Node): Node | undefined {
+  for (let at = node.parent; !isSourceFile(at); at = at.parent) {
+    if (isFunctionLikeDeclaration(at) && !isArrowFunction(at)) {
+      return at;
+    }
+  }
+  return undefined;
+}
+
 /** Whether a body is a stub: it holds no statement, or nothing but `throw` statements. */
 function isStub(signature: SignatureNode): boolean {
   const body = signature.body;
@@ -876,9 +888,13 @@ function parameterParts(
   ids: ReadonlyMap<Node, Answer<number>>,
   inValue: boolean,
 ): { readonly parts: PartFact[]; readonly contextual: ContextualParameter[] } {
-  // A function that reads `arguments` reads every parameter by position.
+  // A function that reads its `arguments` reads every parameter by position. A nested
+  // function other than an arrow has an `arguments` object of its own.
   const readsArguments =
-    !isArrowFunction(signature) && identifiersNaming(signature, new Set(["arguments"])).length > 0;
+    !isArrowFunction(signature) &&
+    identifiersNaming(signature, new Set(["arguments"])).some(
+      (use) => ownArgumentsOf(use) === signature,
+    );
   const read = reader.names.map(
     ({ name }) =>
       readsArguments ||

package/src/inventory.ts

@@ -459,6 +459,18 @@ function nameNodeOf(node: Node): Node | undefined {
   return (node as { readonly name?: Node }).name;
 }
 
+/**
+ * The fragment component one declaration's name spells in a reference, as the inventory
+ * spells it, or undefined for a name the grammar does not represent.
+ */
+export function declaredComponent(node: Node): string | undefined {
+  const component = componentOf(nameNodeOf(node));
+  if (component === undefined) {
+    return undefined;
+  }
+  return component.computed ? computedComponent(component.text) : nameComponent(component.text);
+}
+
 /**
  * One node's identity inside one program, which is how two readings of that program
  * name one declaration.