@cplieger/deadset-ts 6.1.0 → 7.0.0-dev.1

package/src/intra-function-parts.ts

@@ -6,6 +6,7 @@
  */
 
 import {
+  isArrayBindingPattern,
   isArrowFunction,
   isAwaitExpression,
   isBigIntLiteral,
@@ -55,10 +56,12 @@ import {
   isVoidExpression,
   NodeFlags,
   SyntaxKind,
+  type ArrowFunction,
   type BindingName,
   type Block,
   type CallExpression,
   type CatchClause,
+  type FunctionExpression,
   type Identifier,
   type Node,
   type SourceFile,
@@ -473,6 +476,7 @@ export function projectParts<Brand>(
   const calls = new Map<string, boolean>();
   const specifiers = new Set<string>();
   const sites: { readonly file: SourceFile; readonly declared: Declared }[] = [];
+  const contextual: ContextualParameter[] = [];
 
   for (const file of files) {
     const declarationAt = (node: Node): string | undefined => {
@@ -624,15 +628,25 @@ export function projectParts<Brand>(
       });
       const reader = readers.get(one.signature);
       if (reader !== undefined) {
-        parts.push(...parameterParts(file, targetRoot, one.id, one.signature, reader, ids, false));
+        const found = parameterParts(file, targetRoot, one.id, one.signature, reader, ids, false);
+        parts.push(...found.parts);
+        contextual.push(...found.contextual);
       }
     }
     for (const one of walk.values) {
       const reader = readers.get(one.signature);
       if (reader !== undefined) {
-        parts.push(
-          ...parameterParts(file, targetRoot, one.holder, one.signature, reader, ids, true),
+        const found = parameterParts(
+          file,
+          targetRoot,
+          one.holder,
+          one.signature,
+          reader,
+          ids,
+          true,
         );
+        parts.push(...found.parts);
+        contextual.push(...found.contextual);
       }
     }
     walk.catches.forEach(({ name, holder }, at) => {
@@ -677,7 +691,7 @@ export function projectParts<Brand>(
   }
 
   parts.push(...resultParts(project, targetRoot, sites, references, calls));
-  return { parts, signatures, calls, specifiers };
+  return { parts: withContextualRead(project, parts, contextual), signatures, calls, specifiers };
 }
 
 /**
@@ -743,9 +757,38 @@ function parameterNames(signature: SignatureNode): ParameterName[] {
   return found;
 }
 
+/** An unread name of a parameter that a contextual type of its function expression keeps. */
+interface ContextualParameter {
+  readonly part: PartFact;
+  readonly signature: ArrowFunction | FunctionExpression;
+}
+
+/**
+ * The parts with each name of `contextual` read where the compiler gives its function a
+ * contextual type: the inference of the call holding the function may read a parameter's
+ * annotation, and the code handing the argument may act on what an object pattern reads.
+ * A question the checker leaves unanswered keeps the name read.
+ */
+function withContextualRead<Brand>(
+  project: ProjectView<Brand>,
+  parts: readonly PartFact[],
+  contextual: readonly ContextualParameter[],
+): readonly PartFact[] {
+  if (contextual.length === 0) {
+    return parts;
+  }
+  const signatures = [...new Set(contextual.map((one) => one.signature))];
+  const answers = project.queries.contextualTypes(signatures);
+  const typed = new Set(signatures.filter((_signature, at) => answers[at] !== undefined));
+  const read = new Set(contextual.filter((one) => typed.has(one.signature)).map((one) => one.part));
+  return parts.map((part) => (read.has(part) ? { ...part, used: true } : part));
+}
+
 /**
- * Each name one function's parameters bind and whether the function reads it. A binding
- * pattern counts as read where its function reads any name it binds.
+ * Each name one function's parameters bind and whether the function reads it, and the
+ * unread names a contextual type of a function expression may keep: those of a parameter
+ * that carries a type annotation or is an object binding pattern. A binding pattern counts
+ * as read where its function reads any name it binds.
  */
 function parameterParts(
   file: SourceFile,
@@ -755,7 +798,7 @@ function parameterParts(
   reader: { readonly names: readonly ParameterName[]; readonly uses: readonly Identifier[] },
   ids: ReadonlyMap<Node, Answer<number>>,
   inValue: boolean,
-): PartFact[] {
+): { readonly parts: PartFact[]; readonly contextual: ContextualParameter[] } {
   // A function that reads `arguments` reads every parameter by position.
   const readsArguments =
     !isArrowFunction(signature) && identifiersNaming(signature, new Set(["arguments"])).length > 0;
@@ -766,11 +809,14 @@ function parameterParts(
   );
   const lastRead = Math.max(-1, ...reader.names.filter((_, at) => read[at]).map((one) => one.at));
   const found: PartFact[] = [];
+  const contextual: ContextualParameter[] = [];
+  const expression =
+    isArrowFunction(signature) || isFunctionExpression(signature) ? signature : undefined;
   reader.names.forEach(({ name, at, pattern, exempt }, index) => {
     if (exempt) {
       return;
     }
-    found.push({
+    const part: PartFact = {
       code: UNUSED_PARAMETER,
       declaration,
       kind: "parameter",
@@ -779,9 +825,19 @@ function parameterParts(
       message: `parameter ${name.text} is never read in the body`,
       used: read[index] === true,
       parameter: { beforeARead: !pattern && at < lastRead, inValue },
-    });
+    };
+    found.push(part);
+    const parameter = signature.parameters[at];
+    if (
+      expression !== undefined &&
+      !part.used &&
+      parameter !== undefined &&
+      (parameter.type !== undefined || isObjectBindingPattern(parameter.name))
+    ) {
+      contextual.push({ part, signature: expression });
+    }
   });
-  return found;
+  return { parts: found, contextual };
 }
 
 /** One local a block declares by name, and every identifier of the block that spells it. */
@@ -792,6 +848,22 @@ interface Local {
   readonly uses: readonly Identifier[];
 }
 
+/**
+ * The names one declaration binds that a write of its initializer stores each on its own:
+ * the declared name, or each element name of an array binding pattern at any depth.
+ */
+function arrayPatternNames(name: BindingName): readonly Identifier[] {
+  if (isIdentifier(name)) {
+    return [name];
+  }
+  if (!isArrayBindingPattern(name)) {
+    return [];
+  }
+  return name.elements.flatMap((element) =>
+    isBindingElement(element) && element.name !== undefined ? arrayPatternNames(element.name) : [],
+  );
+}
+
 /** The locals one block declares with `let` or `const`, each with the names that spell it. */
 function localsOf(block: Block): readonly Local[] {
   const declared: { name: Identifier; statement: number; initialized: boolean }[] = [];
@@ -807,9 +879,9 @@ function localsOf(block: Block): readonly Local[] {
       return;
     }
     for (const declaration of list.declarations) {
-      if (isIdentifier(declaration.name)) {
+      for (const name of arrayPatternNames(declaration.name)) {
         declared.push({
-          name: declaration.name,
+          name,
           statement: at,
           initialized: declaration.initializer !== undefined,
         });

package/src/kinds.ts

@@ -101,7 +101,7 @@ const ROWS: readonly KindRow[] = [
     code: "DS1101",
     name: "unnecessary-export",
     languages: ["go", "ts"],
-    rule: "An exported symbol whose every reference is inside the symbol's own package or module, reported as a candidate for unexporting. The subject is a package-level declaration or a method. Three subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending.",
+    rule: "An exported symbol whose every reference is inside the symbol's own package or module, reported as a candidate for unexporting. The subject is a package-level declaration or a method. Three subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface, and so is a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, because that interface fixes them whether or not the program converts the method's type to it. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending. A reference from a Go external test package, a test file whose package clause names its directory's package with the suffix _test, is a reference from outside the package, because that test builds as another package and needs the export.",
     precondition:
       "Closed world only. A Go main package, and an internal/ directory tree for importers outside its parent, are closed worlds whatever the configuration declares, because no other program can import them, so this finding is reported there always. A published package is a closed world only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type that a parameter or a result of an exported function or method of its own package names is not reported when a reference from outside the package references that function or method, because the caller holds values of the type, and unexporting it would leave an exported signature naming a type its callers cannot name.",
     defaultSeverity: "warn",
@@ -113,7 +113,7 @@ const ROWS: readonly KindRow[] = [
     code: "DS1102",
     name: "unnecessary-exposure",
     languages: ["go"],
-    rule: "An exported symbol of a non-internal package whose every reference is inside the target module, reported as a candidate for relocation behind an internal boundary. The subject is a package-level declaration or a method. Three subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending.",
+    rule: "An exported symbol of a non-internal package whose every reference is inside the target module, reported as a candidate for relocation behind an internal boundary. The subject is a package-level declaration or a method. Three subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface, and so is a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, because that interface fixes them whether or not the program converts the method's type to it. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending. A reference from a Go external test package, a test file whose package clause names its directory's package with the suffix _test, is a reference from outside the package, because that test builds as another package and needs the export.",
     precondition:
       "Closed world only. Reported always for a main package and an internal/ directory tree, and for a published package only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type that a parameter or a result of an exported function or method of its own package names is not reported when a reference from outside the target module references that function or method, because the caller holds values of the type, and moving it behind an internal boundary would leave an exported signature naming a type its callers cannot name.",
     defaultSeverity: "warn",
@@ -235,7 +235,7 @@ const ROWS: readonly KindRow[] = [
     languages: ["go", "ts"],
     rule: "A directly declared dependency that no import in the target needs. On the Go side, a direct require whose module provides no package any target package or test variant imports. On the TypeScript side, a manifest dependency, development dependency or peer dependency the project's import closure does not need. A deletion finding whose fix would remove the last use of a dependency names that dependency.",
     precondition:
-      "On the Go side the rule is the semantics of `go mod tidy -diff` exactly: a requirement marked indirect is never reported, because it exists to pin a transitive version and removing it changes the build list. On the TypeScript side the import closure is the files of the run's projects, and four more dependencies are needed. The first is one whose installed manifest declares a command, because a command is run by name rather than imported. The second is one that the installed manifest of a needed dependency declares as a peer and does not mark optional. The third is every required peer of a dependency so held, to a fixpoint. The fourth is one that a string names under a manifest key of an applied convention row, as grammar/analysis.md states. An installed manifest is the package's manifest in the nearest node_modules directory at or above the target, and a dependency with none is decided by the import closure alone.",
+      "On the Go side the rule is the semantics of `go mod tidy -diff` exactly: a requirement marked indirect is never reported, because it exists to pin a transitive version and removing it changes the build list. On the TypeScript side the import closure is the files of the run's projects, and a call of `import.meta.resolve` or of `require.resolve` in them, whatever `require` names, whose first argument is a string literal or a template literal with no substitution needs each dependency an import of that specifier needs. Three more dependencies are needed: one whose command a script entry or a workflow step runs, one that a string of a configuration file names, and one that a string names under a manifest key or a package key of an applied convention row, each as grammar/analysis.md states. A command no script entry and no workflow step runs needs nothing, and a peer the installed manifest of a needed dependency requires is needed only as any other dependency is, because the package manager installs a required peer itself. A dependency of a manifest whose directory holds source only in configurations the run lists in configurations_not_built is reported at the reachability class possible, because the source that may import it was not analyzed. An installed manifest is the package's manifest in the nearest node_modules directory at or above the target, and a dependency with none is decided by the import closure alone.",
     defaultSeverity: "deny",
     maxClass: "certain",
     fixability: "manual",
@@ -319,7 +319,7 @@ const ROWS: readonly KindRow[] = [
     languages: ["go", "ts"],
     rule: "A parameter with no reference inside its function body, on a function whose signature is free to change.",
     precondition:
-      "The signature must be free, defined as follows: the function is not a method retained by interface satisfaction, is not used as a value, is not a go:linkname or cgo target, is not a function the Go test driver runs (a test, benchmark or fuzz test of a test file, or TestMain), and is not a stub whose body is empty or only panics. A parameter its body never names is dead whatever the callers, so a published declaration of a library is reported too, with the fixability the vocabulary gives the kind: the signature change is a breaking change. In TypeScript a caller may pass a function used as a value more arguments than it declares parameters, so in such a function whose signature is free but for that use, a parameter its body never reads is reported when its body reads no parameter after it, and an unread parameter before the last read one is not. A TypeScript parameter that is a binding pattern is judged by the names it binds: each name the body never reads is reported wherever the pattern stands, because removing it from the pattern moves no argument, except a name beside a rest element of the same object pattern, whose removal changes what that element holds, and the pattern counts as a read parameter when the body reads any name it binds. A rest parameter is judged as the last parameter. A TypeScript `this` parameter declares the type of `this` and receives no argument, so it is never reported. No name exempts a parameter. A TypeScript parameter whose name starts with an underscore is judged as any other is, and a Go parameter named by the blank identifier declares no name a body could read and is never reported.",
+      "The signature must be free, defined as follows: the function is not a method retained by interface satisfaction, is not a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, is not used as a value, is not a go:linkname or cgo target, is not a function the Go test driver runs (a test, benchmark or fuzz test of a test file, or TestMain), and is not a stub whose body is empty or only panics. A function literal or function expression that initializes a variable the program only calls, never passing, storing, returning or assigning it, is called by name and is not used as a value. A parameter its body never names is dead whatever the callers, so a published declaration of a library is reported too, with the fixability the vocabulary gives the kind: the signature change is a breaking change. In TypeScript a caller may pass a function used as a value more arguments than it declares parameters, so in such a function whose signature is free but for that use, a parameter its body never reads is reported when its body reads no parameter after it, and an unread parameter before the last read one is not. A parameter of a TypeScript function expression or arrow function that the compiler gives a contextual type is not reported when it carries a type annotation, because the inference of the call that holds the function may read the annotation, or when it is an object binding pattern, because the pattern reads each property it names from the argument and the code that hands the argument may act on that read. No name such a pattern binds is reported either. Any other TypeScript parameter that is a binding pattern is judged by the names it binds: each name the body never reads is reported wherever the pattern stands, because removing it from the pattern moves no argument, except a name beside a rest element of the same object pattern, whose removal changes what that element holds, and the pattern counts as a read parameter when the body reads any name it binds. A rest parameter is judged as the last parameter. A TypeScript `this` parameter declares the type of `this` and receives no argument, so it is never reported. No name exempts a parameter. A TypeScript parameter whose name starts with an underscore is judged as any other is, and a Go parameter named by the blank identifier declares no name a body could read and is never reported.",
     defaultSeverity: "warn",
     maxClass: "certain",
     fixability: "manual",
@@ -330,8 +330,9 @@ const ROWS: readonly KindRow[] = [
     code: "DS1802",
     name: "unused-receiver",
     languages: ["go"],
-    rule: "A named method receiver with no reference inside the method body, on a method whose signature is free to change. Go permits a method with no receiver name, so the fix deletes an identifier and changes no signature.",
-    precondition: "The same free-signature rule as unused-parameter, applied to the receiver.",
+    rule: "A named method receiver with no reference inside the method body. Go permits a method with no receiver name, so the fix deletes an identifier and changes no signature.",
+    precondition:
+      "None beyond the rule. Deleting a receiver name changes no signature, so a method retained by interface satisfaction, a method used as a value and a stub are reported as any other method is.",
     defaultSeverity: "warn",
     maxClass: "certain",
     fixability: "deletable",

package/src/references.ts

@@ -51,6 +51,7 @@ import { byPosition, isComponentFile, renderPosition, type Position } from "./po
 import { DEFAULT_BATCH_CAP, propertyTables, UNANSWERED, type Answer } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 import { typeQueryAliases } from "./type-query-alias.ts";
+import { computedKeyNames, keyNameOf, keyedUses, type KeyedAccess } from "./symbol-keys.ts";
 import { handedOn, valuesOf } from "./value-flow.ts";
 
 /**
@@ -80,12 +81,12 @@ import { handedOn, valuesOf } from "./value-flow.ts";
 export type Use = "read" | "write" | "evaluation" | "decorator";
 
 /**
- * Which path answered for one reference: `batch`, a file's batched lookup; `resolved-symbol`,
- * the per-node lookup for its residue; `shorthand`, the value `{ a }` reads; `alias`, a step
- * along an import or export chain; `syntax`, the tree alone (a decorator's target, a
- * component's markup); `destructured`, the property a pattern names; `contextual`, the member
- * a literal property writes or a value's position reads; `override`, the override a base
- * member's call dispatches to; `by-name`, every declaration so spelled, where the checker failed.
+ * Which path answered for one reference: `batch`, a file's batched lookup; `resolved-symbol`, the
+ * per-node lookup for its residue; `shorthand`, the value `{ a }` reads; `alias`, a step along an
+ * import or export chain; `syntax`, the tree alone (a decorator's target, a component's markup);
+ * `destructured`, the property a pattern names; `contextual`, the member a literal property writes
+ * or a value's position reads; `override`, the override a base call dispatches to; `keyed`, the
+ * member a symbol key selects; `by-name`, each declaration so spelled, where the checker failed.
  */
 export type Resolution =
   | "batch"
@@ -96,6 +97,7 @@ export type Resolution =
   | "destructured"
   | "contextual"
   | "override"
+  | "keyed"
   | "by-name";
 
 /** One use of one declaration by one declaration. */
@@ -297,12 +299,11 @@ function unparenthesized(node: Node): Node {
  * Records the name one store writes into.
  *
  * A property access writes the member it names. An element access writes the collection
- * it stores into, because a collection a module only ever stores into holds nothing
- * anything reads, and the key is no declaration of the target. A destructuring target
- * writes each name it binds, through the spreads and the nested patterns it binds them
- * in.
+ * it stores into, since a collection a module only stores into holds nothing anything
+ * reads, and joins `accesses` for the member a unique-symbol key selects. A destructuring
+ * target writes each name it binds, through its spreads and nested patterns.
  */
-function markWrite(target: Node, writes: Set<number>): void {
+function markWrite(target: Node, writes: Set<number>, accesses: Set<Node>): void {
   const held = unparenthesized(target);
   if (isName(held)) {
     writes.add(held.pos);
@@ -315,37 +316,38 @@ function markWrite(target: Node, writes: Set<number>): void {
     return;
   }
   if (isElementAccessExpression(held)) {
+    accesses.add(held);
     // A store through a member's value lands in storage every holder of the value
     // reads, so it reads the member; a variable only ever stored into stays written.
     if (!isPropertyAccessExpression(unparenthesized(held.expression))) {
-      markWrite(held.expression, writes);
+      markWrite(held.expression, writes, accesses);
     }
     return;
   }
   if (isArrayLiteralExpression(held)) {
     for (const element of held.elements) {
-      markWrite(element, writes);
+      markWrite(element, writes, accesses);
     }
     return;
   }
   if (isObjectLiteralExpression(held)) {
     for (const property of held.properties) {
       if (isPropertyAssignment(property)) {
-        markWrite(property.initializer, writes);
+        markWrite(property.initializer, writes, accesses);
         continue;
       }
       if (isShorthandPropertyAssignment(property)) {
-        markWrite(property.name, writes);
+        markWrite(property.name, writes, accesses);
         continue;
       }
       if (isSpreadAssignment(property)) {
-        markWrite(property.expression, writes);
+        markWrite(property.expression, writes, accesses);
       }
     }
     return;
   }
   if (isSpreadElement(held)) {
-    markWrite(held.expression, writes);
+    markWrite(held.expression, writes, accesses);
   }
 }
 
@@ -356,16 +358,21 @@ function markWrite(target: Node, writes: Set<number>): void {
  * holds. A store that reads its target as well records it in `reads`: a logical
  * assignment, and a compound assignment, an increment or a decrement whose value is used.
  */
-function markStores(node: Node, writes: Set<number>, reads: Set<number>): void {
+function markStores(
+  node: Node,
+  writes: Set<number>,
+  reads: Set<number>,
+  accesses: { readonly written: Set<Node>; readonly read: Set<Node> },
+): void {
   if (isBinaryExpression(node)) {
     const operator = node.operatorToken.kind;
     if (ASSIGNMENTS.has(operator)) {
-      markWrite(node.left, writes);
+      markWrite(node.left, writes, accesses.written);
       if (
         LOGICAL_ASSIGNMENTS.has(operator) ||
         (operator !== SyntaxKind.EqualsToken && !valueDiscarded(node))
       ) {
-        markWrite(node.left, reads);
+        markWrite(node.left, reads, accesses.read);
       }
     }
     return;
@@ -375,20 +382,20 @@ function markStores(node: Node, writes: Set<number>, reads: Set<number>): void {
       node.operator === SyntaxKind.PlusPlusToken ||
       node.operator === SyntaxKind.MinusMinusToken
     ) {
-      markWrite(node.operand, writes);
+      markWrite(node.operand, writes, accesses.written);
       if (!valueDiscarded(node)) {
-        markWrite(node.operand, reads);
+        markWrite(node.operand, reads, accesses.read);
       }
     }
     return;
   }
   if (isDeleteExpression(node)) {
-    markWrite(node.expression, writes);
+    markWrite(node.expression, writes, accesses.written);
     return;
   }
   if (isForInStatement(node) || isForOfStatement(node)) {
     if (node.initializer.kind !== SyntaxKind.VariableDeclarationList) {
-      markWrite(node.initializer, writes);
+      markWrite(node.initializer, writes, accesses.written);
     }
   }
 }
@@ -475,6 +482,7 @@ interface FileSites {
   readonly wholes: readonly WholeRead[];
   readonly urls: readonly ModuleURL[];
   readonly decorated: readonly Decorated[];
+  readonly keyed: readonly KeyedAccess[];
 }
 
 /** Whether one node is `import.meta.url`. */
@@ -667,6 +675,8 @@ function sitesOf(
   const flows: FlowAt[] = [];
   const writes = new Set<number>();
   const alsoRead = new Set<number>();
+  const accesses = { written: new Set<Node>(), read: new Set<Node>() };
+  const keyed: KeyedAccess[] = [];
   const declared = new Set<number>();
   const shorthands = new Map<number, Node>();
   let enclosing = fileId;
@@ -712,7 +722,17 @@ function sitesOf(
       return;
     }
     markNames(node);
-    markStores(node, writes, alsoRead);
+    markStores(node, writes, alsoRead, accesses);
+    const key = isElementAccessExpression(node) ? keyNameOf(node.argumentExpression) : undefined;
+    if (key !== undefined && isElementAccessExpression(node)) {
+      const written = accesses.written.has(node);
+      keyed.push({
+        access: node,
+        key,
+        from: enclosing,
+        use: written ? (accesses.read.has(node) ? "both" : "write") : "read",
+      });
+    }
     if (isObjectLiteralExpression(node) && !isAssignmentPattern(node)) {
       literals.push({ literal: node, from: enclosing });
     }
@@ -747,7 +767,18 @@ function sitesOf(
   };
 
   file.forEachChild(visit);
-  return { uses: found, literals, flows, reads, links, evaluations, wholes, urls, decorated };
+  return {
+    uses: found,
+    literals,
+    flows,
+    reads,
+    links,
+    evaluations,
+    wholes,
+    urls,
+    decorated,
+    keyed,
+  };
 }
 
 /** The declaration kinds of a property an object literal declares. */
@@ -1230,7 +1261,19 @@ export function references<Brand>(
     }
   }
 
-  for (const { file, fileId, uses, reads, links, evaluations, wholes, urls, decorated } of walked) {
+  const keyNames = computedKeyNames(held.symbols);
+  for (const {
+    file,
+    fileId,
+    uses,
+    reads,
+    links,
+    evaluations,
+    wholes,
+    urls,
+    decorated,
+    keyed,
+  } of walked) {
     const test = testFile.get(file) === true;
     // A component file's markup may use any binding its blocks declare at the top level.
     const markup = isComponentFile(file);
@@ -1449,6 +1492,22 @@ export function references<Brand>(
       }
     });
 
+    const resolvedKeys = keyed.flatMap((access) => {
+      const symbol =
+        isIdentifier(access.key) && keyNames.has(access.key.text)
+          ? answered.get(access.key)
+          : undefined;
+      return typeof symbol === "object" ? [{ access, symbol }] : [];
+    });
+    for (const { access, ids } of keyedUses(project, chains, resolvedKeys, tables, cap)) {
+      const position = renderPosition(file, root, access.access.argumentExpression.getStart());
+      for (const id of ids) {
+        for (const use of access.use === "both" ? (["read", "write"] as const) : [access.use]) {
+          found.push({ from: access.from, to: id, position, use, resolution: "keyed", test });
+        }
+      }
+    }
+
     for (const site of uses) {
       const direct: Resolution =
         site.shorthand !== undefined