fallow-type-aware 3.35.0 → 3.36.0

package/src/reference-names.mjs

@@ -1,4 +1,6 @@
-import {
+import { ast } from "./backend.mjs";
+
+const {
   isExportDeclaration,
   isImportDeclaration,
   isImportEqualsDeclaration,
@@ -7,7 +9,7 @@ import {
   isNamedExports,
   isNamespaceExportDeclaration,
   isNamespaceImport,
-} from "typescript/unstable/ast/is";
+} = ast;
 
 const JAVASCRIPT_FILE = /\.[cm]?jsx?$/iu;
 
@@ -28,9 +30,10 @@ const exportNames = ({ exportClause }) => {
   return [exportClause.name];
 };
 
-const moduleBodyNames = (body) => {
-  if (body && isModuleDeclaration(body)) return moduleBodyNames(body.body);
-  return body && isModuleBlock(body) ? body.statements.flatMap(statementAliasNames) : [];
+/** Returns the statements of a `namespace` or `declare module` body, also when nested. */
+export const moduleBodyStatements = (body) => {
+  if (body && isModuleDeclaration(body)) return moduleBodyStatements(body.body);
+  return body && isModuleBlock(body) ? body.statements : [];
 };
 
 const statementAliasNames = (statement) => {
@@ -39,26 +42,32 @@ const statementAliasNames = (statement) => {
     return [statement.name];
   }
   if (isExportDeclaration(statement)) return exportNames(statement);
-  if (isModuleDeclaration(statement)) return moduleBodyNames(statement.body);
+  if (isModuleDeclaration(statement)) {
+    return moduleBodyStatements(statement.body).flatMap(statementAliasNames);
+  }
   return [];
 };
 
 // Default-library and external-library files sit below node_modules. The
 // path check skips them before the source file and its metadata, which each
 // cost a checker round trip.
-const NODE_MODULES_SEGMENT = /[\\/]node_modules[\\/]/u;
+export const NODE_MODULES_SEGMENT = /[\\/]node_modules[\\/]/u;
 
 const isOwnSourceFile = (project, sourceFile) =>
   Boolean(sourceFile) &&
   !project.program.isSourceFileDefaultLibrary(sourceFile) &&
   !project.program.isSourceFileFromExternalLibrary(sourceFile);
 
-const programAliasNames = (project) =>
+/** Returns the program files outside node_modules and the default libraries. */
+export const ownSourceFiles = (project) =>
   project.program
     .getSourceFileNames()
     .filter((fileName) => !NODE_MODULES_SEGMENT.test(fileName))
     .map((fileName) => project.program.getSourceFile(fileName))
-    .filter((sourceFile) => isOwnSourceFile(project, sourceFile))
+    .filter((sourceFile) => isOwnSourceFile(project, sourceFile));
+
+const programAliasNames = (project) =>
+  ownSourceFiles(project)
     .flatMap((sourceFile) => sourceFile.statements.flatMap(statementAliasNames))
     .map((name) => name?.text)
     .filter((text) => typeof text === "string");

package/src/semantic-identity.mjs

@@ -1,7 +1,11 @@
 import path from "node:path";
 
-import { SymbolFlags } from "typescript/unstable/sync";
-import {
+import { sync, ast } from "./backend.mjs";
+
+import { canonicalFileIdentity } from "./file-identity.mjs";
+
+const { SymbolFlags } = sync;
+const {
   isClassDeclaration,
   isClassExpression,
   isEnumDeclaration,
@@ -19,9 +23,7 @@ import {
   isSourceFile,
   isTypeAliasDeclaration,
   isVariableDeclaration,
-} from "typescript/unstable/ast/is";
-
-import { canonicalFileIdentity } from "./file-identity.mjs";
+} = ast;
 
 const DECLARATION_KIND_RULES = [
   [[isClassDeclaration, isClassExpression], "class"],

package/src/semantic.mjs

@@ -1,33 +1,11 @@
 import { createHash } from "node:crypto";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 import path from "node:path";
 
-import { API, SignatureKind, SymbolFlags } from "typescript/unstable/sync";
-import {
-  isCallExpression,
-  isClassDeclaration,
-  isClassExpression,
-  isDecorator,
-  isElementAccessExpression,
-  isExportDeclaration,
-  isExportSpecifier,
-  isFunctionBody,
-  isGetAccessorDeclaration,
-  isIdentifier,
-  isImportDeclaration,
-  isImportSpecifier,
-  isImportTypeNode,
-  isNamespaceImport,
-  isPropertyAccessExpression,
-  isQualifiedName,
-  isPrivateIdentifier,
-  isSetAccessorDeclaration,
-  isStringLiteralLikeNode,
-  isTypeNode,
-  isTypeQueryNode,
-} from "typescript/unstable/ast/is";
+import { ast, createApi as createBackendApi, heritageTypeName, sync } from "./backend.mjs";
 
 import { canonicalFileIdentity } from "./file-identity.mjs";
+import { packagePathTargets, projectPackage } from "./project-package.mjs";
 import { projectResult, projectState } from "./project-state.mjs";
 import {
   declarationName,
@@ -51,9 +29,49 @@ import {
 } from "./semantic-identity.mjs";
 import { analyzeSymbolImpact } from "./symbol-impact.mjs";
 import { isJavaScriptFile, referenceNames } from "./reference-names.mjs";
-import { matchingAliasEntries, matchingSymbolEntries, targetName } from "./symbol-targets.mjs";
+import { recordComputedMemberAccess } from "./computed-member-access.mjs";
+import {
+  namespaceSourceIdentity,
+  recordDynamicImportUncertainty,
+  recordNamespaceUse,
+} from "./namespace-uses.mjs";
+import {
+  isLiteralMemberName,
+  qualifierExpression,
+  referenceValueSymbol,
+  shorthandReferenceSymbols,
+} from "./shorthand-references.mjs";
+import {
+  matchingAliasEntries,
+  matchingSymbolEntries,
+  recordSymbolUncertainty,
+  targetName,
+} from "./symbol-targets.mjs";
 import { analyzeTypeCoupling } from "./type-coupling.mjs";
 
+const { SignatureKind, SymbolFlags } = sync;
+const {
+  isCallExpression,
+  isClassDeclaration,
+  isClassExpression,
+  isDecorator,
+  isExportDeclaration,
+  isExportSpecifier,
+  isFunctionBody,
+  isGetAccessorDeclaration,
+  isIdentifier,
+  isImportDeclaration,
+  isImportSpecifier,
+  isImportTypeNode,
+  isNamespaceImport,
+  isPropertyAccessExpression,
+  isPrivateIdentifier,
+  isSetAccessorDeclaration,
+  isStringLiteralLikeNode,
+  isTypeNode,
+  isTypeQueryNode,
+} = ast;
+
 const ATTACHED_COMMENT_PATTERN = /\/\/|\/\*/u;
 const MAX_SYMBOL_USE_EVIDENCE = 1;
 const DECLARATION_KINDS = new Set([
@@ -358,13 +376,10 @@ const candidateNameMatches = (candidateNames, name) => !candidateNames || candid
 const isIdentifierReference = (node, names) =>
   isIdentifier(node) && candidateNameMatches(names, node.text);
 
-const isElementNameNode = (node) =>
-  isStringLiteralLikeNode(node) &&
-  isElementAccessExpression(node.parent) &&
-  node.parent.argumentExpression === node;
-
 const isElementReference = (node, candidateNames) =>
-  isElementNameNode(node) && candidateNameMatches(candidateNames, node.text);
+  isStringLiteralLikeNode(node) &&
+  candidateNameMatches(candidateNames, node.text) &&
+  isLiteralMemberName(node);
 
 const entriesByName = (entries) => {
   const byName = new Map();
@@ -478,9 +493,6 @@ const importTypeSpecifier = (node) => {
   return literal && isStringLiteralLikeNode(literal) ? literal : undefined;
 };
 
-const isDynamicImportCall = (node) =>
-  isCallExpression(node) && node.expression.getText(node.getSourceFile()) === "import";
-
 const MODULE_SOURCE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
 
 const lexicalModuleIdentityForText = (project, sourceFile, specifierText) => {
@@ -516,19 +528,8 @@ const moduleIdentityForSpecifier = (project, specifier) => {
 };
 
 const namespaceImportDeclaration = (project, node) => {
-  const parent = node.parent;
-  if (!parent) return undefined;
-  const namespace = isPropertyAccessExpression(parent)
-    ? parent.name === node
-      ? parent.expression
-      : undefined
-    : isElementAccessExpression(parent) && parent.argumentExpression === node
-      ? parent.expression
-      : isQualifiedName(parent) && parent.right === node
-        ? parent.left
-        : undefined;
-  if (!namespace) return undefined;
-  if (!isIdentifier(namespace)) return undefined;
+  const namespace = qualifierExpression(node);
+  if (!namespace || !isIdentifier(namespace)) return undefined;
   const symbol = project.checker.getSymbolAtLocation(namespace);
   return symbol?.declarations
     ?.map((declaration) => declaration.resolve(project))
@@ -536,7 +537,7 @@ const namespaceImportDeclaration = (project, node) => {
 };
 
 const localAliasModuleEdgeDeclaration = (project, node) => {
-  const symbol = project.checker.getSymbolAtLocation(node);
+  const symbol = referenceValueSymbol(project, node);
   return symbol?.declarations
     ?.map((declaration) => moduleEdgeDeclaration(declaration.resolve(project)))
     .find(Boolean);
@@ -567,7 +568,8 @@ const referencedModuleIdentity = (project, node) => {
 
 const isExactExportReference = (project, entry, node) => {
   if (entry.query.symbol.declarationKind !== "export") return true;
-  const referencedModule = referencedModuleIdentity(project, node);
+  const referencedModule =
+    referencedModuleIdentity(project, node) ?? namespaceSourceIdentity(project, node);
   if (!referencedModule) return false;
   const queryModule = canonicalFileIdentity(entry.query.symbol.absolutePath);
   return (
@@ -612,58 +614,17 @@ const classMemberEntrySetForProject = (state, project) => {
   return entries;
 };
 
-const recordSymbolUncertainty = (state, entry, reasonCode) => {
-  state.uncertaintiesByQuery.get(entry.query.id).add(reasonCode);
-};
-
-const isExactElementReference = (node) => isElementNameNode(node) && typeof node.text === "string";
+const isExactElementReference = (node) =>
+  isLiteralMemberName(node) && typeof node.text === "string";
 
-const recordStringDispatchedMemberAccess = (state, projectEntries, node) => {
-  if (!isStringLiteralLikeNode(node) || isExactElementReference(node)) return;
+const recordNameUncertainty = (state, projectEntries, node) =>
   (state.classMemberEntriesByName.get(node.text) ?? [])
     .filter((entry) => projectEntries.has(entry))
     .forEach((entry) => recordSymbolUncertainty(state, entry, "dynamic-member-access"));
-};
-
-const recordComputedMemberAccess = (state, project, entries, node) => {
-  if (
-    entries.size === 0 ||
-    state.projectsWithUnknownDynamicAccess.has(project) ||
-    !isElementAccessExpression(node) ||
-    node.argumentExpression === undefined ||
-    isStringLiteralLikeNode(node.argumentExpression)
-  ) {
-    return;
-  }
-  const receiverType = project.checker.getTypeAtLocation(node.expression);
-  const receiverProperties = project.checker.getPropertiesOfType(receiverType);
-  if (receiverProperties.length === 0) {
-    entries.forEach((entry) => recordSymbolUncertainty(state, entry, "dynamic-member-access"));
-    state.projectsWithUnknownDynamicAccess.add(project);
-    return;
-  }
-  const matched = new Set(
-    receiverProperties
-      .filter((property) => state.candidateNames.has(property.name))
-      .flatMap((property) => [...matchingSymbolEntries(project, property, "value", state)]),
-  );
-  matched.forEach((entry) => recordSymbolUncertainty(state, entry, "dynamic-member-access"));
-};
 
-const recordDynamicImportUncertainty = (state, project, node) => {
-  if (!isDynamicImportCall(node)) return;
-  const specifier = node.arguments[0];
-  if (!specifier || !isStringLiteralLikeNode(specifier)) {
-    (state.exportEntriesByProject.get(project) ?? []).forEach((entry) =>
-      recordSymbolUncertainty(state, entry, "dynamic-behavior"),
-    );
-    return;
-  }
-  const moduleIdentity = moduleIdentityForSpecifier(project, specifier);
-  if (!moduleIdentity) return;
-  (state.exportEntriesByModule.get(moduleIdentity) ?? []).forEach((entry) =>
-    recordSymbolUncertainty(state, entry, "dynamic-behavior"),
-  );
+const recordStringDispatchedMemberAccess = (state, projectEntries, node) => {
+  if (!isStringLiteralLikeNode(node) || isExactElementReference(node)) return;
+  recordNameUncertainty(state, projectEntries, node);
 };
 
 const referenceNamespaces = (project, node, rawSymbol) => {
@@ -706,7 +667,7 @@ const scanSymbolUseFile = (root, state, project, sourceFile, names) => {
   const projectEntries = classMemberEntrySetForProject(state, project);
   const nodes = [];
   visit(sourceFile, (node) => {
-    recordDynamicImportUncertainty(state, project, node);
+    recordDynamicImportUncertainty(state, project, node, moduleIdentityForSpecifier);
     if (projectEntries.size > 0) {
       recordStringDispatchedMemberAccess(state, projectEntries, node);
       recordComputedMemberAccess(state, project, projectEntries, node);
@@ -718,11 +679,16 @@ const scanSymbolUseFile = (root, state, project, sourceFile, names) => {
     if (isElementReference(node, state.candidateNames)) nodes.push(node);
   });
   const symbols = project.checker.getSymbolAtLocation(nodes);
+  const references = shorthandReferenceSymbols(project, nodes, symbols, state);
+  references.unresolved.forEach((node) => recordNameUncertainty(state, projectEntries, node));
   nodes.forEach((node, index) => {
     const rawSymbol = symbols[index];
+    recordNamespaceUse(state, project, node, rawSymbol);
     referenceNamespaces(project, node, rawSymbol).forEach((namespace) => {
       const entries = new Set([
-        ...matchingAliasEntries(project, rawSymbol, namespace, state),
+        ...references.symbols[index].flatMap((symbol) => [
+          ...matchingAliasEntries(project, symbol, namespace, state),
+        ]),
         ...surfaceEntriesForNode(state, project, node, namespace),
       ]);
       entries.forEach((entry) => recordSymbolUse(root, state, project, entry, node, namespace));
@@ -972,7 +938,7 @@ const frameworkContractRelationsFor = (root, project, declaration, contracts, me
       : "extends";
     for (const heritageType of clause.types ?? []) {
       const rawSymbol =
-        project.checker.getSymbolAtLocation(heritageType.expression) ??
+        project.checker.getSymbolAtLocation(heritageTypeName(heritageType)) ??
         project.checker.getTypeAtLocation(heritageType).aliasSymbol ??
         project.checker.getTypeAtLocation(heritageType).symbol;
       const symbol = resolveAlias(project.checker, rawSymbol);
@@ -1253,31 +1219,6 @@ const wildcardPattern = (target) => {
   return new RegExp(`^${escaped}$`, "u");
 };
 
-const pathWithin = (root, candidate) =>
-  candidate === root || candidate.startsWith(`${root}${path.sep}`);
-
-const packageAt = (directory) => {
-  const packageFile = path.join(directory, "package.json");
-  if (!existsSync(packageFile)) return undefined;
-  try {
-    return { root: directory, json: JSON.parse(readFileSync(packageFile, "utf8")) };
-  } catch {
-    return { root: directory, json: {} };
-  }
-};
-
-const projectPackage = (root, project) => {
-  const normalizedRoot = path.resolve(root);
-  let current = path.dirname(project.configFileName);
-  while (pathWithin(normalizedRoot, current)) {
-    const found = packageAt(current);
-    if (found) return found;
-    if (current === normalizedRoot) break;
-    current = path.dirname(current);
-  }
-  return { root: normalizedRoot, json: {} };
-};
-
 const ancestorRoots = (root, start) => {
   const normalizedRoot = path.resolve(root);
   const roots = [];
@@ -1345,12 +1286,6 @@ const addPathEntry = (entries, sourceFiles, roots, target) => {
   );
 };
 
-const packagePathTargets = (project, packageJson) => {
-  const packageName = packageJson.name;
-  if (typeof packageName !== "string") return [];
-  return project.compilerOptions.paths?.[packageName] ?? [];
-};
-
 const discoverEntryPoints = (root, project, requested) => {
   const sourceFiles = sourceFileIndex(project);
   if (requested.length > 0) return requestedEntryPoints(requested, sourceFiles);
@@ -2164,7 +2099,7 @@ const executeDisposableSemanticAnalysis = (input) => {
 
 export const analyzeSemanticQueries = (
   { root, projects, queries, evidenceLimit },
-  { createApi = (cwd) => new API({ cwd }) } = {},
+  { createApi = (cwd) => createBackendApi({ cwd }) } = {},
 ) => {
   if (queries.length === 0) return emptyRequestedAnalysis();
   const setupStartedAt = performance.now();
@@ -2183,7 +2118,10 @@ export const analyzeSemanticQueries = (
   }
 };
 
-export const createSemanticSession = (root, { createApi = (cwd) => new API({ cwd }) } = {}) => {
+export const createSemanticSession = (
+  root,
+  { createApi = (cwd) => createBackendApi({ cwd }) } = {},
+) => {
   const api = createApi(root);
   const state = {
     openFiles: new Set(),

package/src/shorthand-references.mjs

@@ -0,0 +1,243 @@
+import { SyntaxKind, ast } from "./backend.mjs";
+
+const {
+  isArrayLiteralExpression,
+  isBinaryExpression,
+  isBindingElement,
+  isComputedPropertyName,
+  isElementAccessExpression,
+  isForInStatement,
+  isForOfStatement,
+  isIdentifier,
+  isImportClause,
+  isImportEqualsDeclaration,
+  isImportSpecifier,
+  isObjectBindingPattern,
+  isObjectLiteralExpression,
+  isParenthesizedExpression,
+  isPropertyAccessExpression,
+  isPropertyAssignment,
+  isQualifiedName,
+  isShorthandPropertyAssignment,
+  isSpreadAssignment,
+  isSpreadElement,
+  isStringLiteralLikeNode,
+  isVariableDeclaration,
+} = ast;
+
+// A shorthand name is one identifier with two meanings. The checker resolves
+// it to the local binding, so the property it reads, or the import it
+// forwards, needs a separate lookup.
+
+// A literal key can sit in a computed name, such as `{ ["name"]: local }`.
+const keyNode = (node) => (isComputedPropertyName(node.parent) ? node.parent : node);
+
+const bindingKeyPattern = (node) => {
+  const key = keyNode(node);
+  const element = key.parent;
+  if (!isBindingElement(element) || !isObjectBindingPattern(element.parent)) return undefined;
+  const isKey = element.propertyName
+    ? element.propertyName === key
+    : element.name === key && !element.dotDotDotToken;
+  return isKey ? element.parent : undefined;
+};
+
+// The checker already resolves an identifier key that renames, such as `name`
+// in `{ name: local }`, to the property.
+const isRenamingKey = (node) =>
+  isIdentifier(node) && isBindingElement(node.parent) && node.parent.propertyName === node;
+
+const assignmentKeyProperty = (node) => {
+  const key = keyNode(node);
+  const property = key.parent;
+  return (isShorthandPropertyAssignment(property) || isPropertyAssignment(property)) &&
+    property.name === key
+    ? property
+    : undefined;
+};
+
+const isShorthandPropertyName = (node) =>
+  isShorthandPropertyAssignment(node.parent) && node.parent.name === node;
+
+/** Returns the symbol of the value that a name reads, also for a shorthand property. */
+export const referenceValueSymbol = (project, node) =>
+  isShorthandPropertyName(node)
+    ? project.checker.getShorthandAssignmentValueSymbol(node.parent)
+    : project.checker.getSymbolAtLocation(node);
+
+// Both `const { name } = ns` and `const { name: local } = ns` read `name`
+// from `ns`.
+const destructuredExpression = (node) => {
+  const element = node.parent;
+  const readName = element.propertyName ?? element.name;
+  const declaration = element.parent?.parent;
+  return readName === node && isVariableDeclaration(declaration)
+    ? declaration.initializer
+    : undefined;
+};
+
+const QUALIFIER_RULES = [
+  [isBindingElement, (parent, node) => destructuredExpression(node)],
+  [
+    isPropertyAccessExpression,
+    (parent, node) => (parent.name === node ? parent.expression : undefined),
+  ],
+  [
+    isElementAccessExpression,
+    (parent, node) => (parent.argumentExpression === node ? parent.expression : undefined),
+  ],
+  [isQualifiedName, (parent, node) => (parent.right === node ? parent.left : undefined)],
+];
+
+/** Returns the expression that qualifies a name, such as `ns` in `ns.name`. */
+export const qualifierExpression = (node) => {
+  const parent = node.parent;
+  const rule = parent && QUALIFIER_RULES.find(([matches]) => matches(parent));
+  return rule?.[1](parent, node);
+};
+
+const isImportBinding = (node) =>
+  isImportSpecifier(node) || isImportClause(node) || isImportEqualsDeclaration(node);
+
+const importBindingNames = (nodes) =>
+  new Set(
+    nodes
+      .filter((node) => isImportBinding(node.parent) && node.parent.name === node)
+      .map((node) => node.text),
+  );
+
+const isEqualsAssignmentOf = (parent, node) =>
+  parent.operatorToken.kind === SyntaxKind.EqualsToken && parent.left === node;
+const isInitializerOf = (parent, node) => parent.initializer === node;
+
+const ASSIGNMENT_TARGET_RULES = [
+  [isBinaryExpression, isEqualsAssignmentOf],
+  [isForOfStatement, isInitializerOf],
+  [isForInStatement, isInitializerOf],
+  [
+    isPropertyAssignment,
+    (parent, node) => isInitializerOf(parent, node) && isAssignmentTarget(parent.parent),
+  ],
+  [isArrayLiteralExpression, (parent) => isAssignmentTarget(parent)],
+  [isParenthesizedExpression, (parent) => isAssignmentTarget(parent)],
+  [isSpreadElement, (parent) => isAssignmentTarget(parent)],
+  [isSpreadAssignment, (parent) => isAssignmentTarget(parent)],
+];
+
+/** Returns true when a node is the target of an assignment, such as a pattern in `({ a } = b)`. */
+export const isAssignmentTarget = (node) => {
+  const parent = node.parent;
+  const rule = parent && ASSIGNMENT_TARGET_RULES.find(([matches]) => matches(parent));
+  return rule ? rule[1](parent, node) : false;
+};
+
+const propertyNameText = (name) =>
+  isIdentifier(name) || isStringLiteralLikeNode(name) ? name.text : undefined;
+
+// Only a direct `=` source and nested object patterns resolve. Array and loop
+// patterns give undefined, and the caller records an uncertainty for them.
+const assignmentPatternType = (project, literal) => {
+  const parent = literal.parent;
+  if (isBinaryExpression(parent)) {
+    // A binary that is itself a pattern target is a default value, and the
+    // pattern also reads the outer source.
+    return isAssignmentTarget(parent) ? undefined : project.checker.getTypeAtLocation(parent.right);
+  }
+  if (!isPropertyAssignment(parent) || !isObjectLiteralExpression(parent.parent)) return undefined;
+  const outer = assignmentPatternType(project, parent.parent);
+  const name = propertyNameText(parent.name);
+  if (!outer || name === undefined) return undefined;
+  const property = project.checker.getPropertyOfType(outer, name);
+  return property ? project.checker.getTypeOfSymbolAtLocation(property, parent) : undefined;
+};
+
+const bindingPropertySymbols = (project, nodes, symbolsByNode) => {
+  if (nodes.length === 0) return;
+  const types = project.checker.getTypeAtLocation(nodes.map(bindingKeyPattern));
+  nodes.forEach((node, index) => {
+    const property = types[index] && project.checker.getPropertyOfType(types[index], node.text);
+    if (property) symbolsByNode.set(node, [property]);
+  });
+};
+
+const assignmentPropertySymbol = (project, node) => {
+  const type = assignmentPatternType(project, assignmentKeyProperty(node).parent);
+  return type ? project.checker.getPropertyOfType(type, node.text) : undefined;
+};
+
+const isPropertyName = (node) => assignmentKeyProperty(node) !== undefined;
+
+/**
+ * Returns the object binding pattern or the assignment pattern whose source a
+ * key reads, such as `{ name }` in `const { name } = source`.
+ */
+export const patternOfKey = (node) => {
+  const pattern = bindingKeyPattern(node);
+  if (pattern) return pattern;
+  const literal = assignmentKeyProperty(node)?.parent;
+  return literal && isAssignmentTarget(literal) ? literal : undefined;
+};
+
+/** Returns the type of the source that a binding or an assignment pattern reads. */
+export const patternSourceType = (project, pattern) =>
+  isObjectBindingPattern(pattern)
+    ? project.checker.getTypeAtLocation(pattern)
+    : assignmentPatternType(project, pattern);
+
+/** Returns true when a string literal names the member that an access or a pattern reads. */
+export const isLiteralMemberName = (node) =>
+  isStringLiteralLikeNode(node) &&
+  ((isElementAccessExpression(node.parent) && node.parent.argumentExpression === node) ||
+    patternOfKey(node) !== undefined);
+
+const shorthandPropertySymbols = (project, node, names, unresolved) => {
+  if (isAssignmentTarget(assignmentKeyProperty(node).parent)) {
+    if (!names.candidates.has(node.text)) return [];
+    const property = assignmentPropertySymbol(project, node);
+    if (!property) unresolved.push(node);
+    return property ? [property] : [];
+  }
+  if (!isShorthandPropertyName(node)) return [];
+  if (!names.readsExports || !names.imports.has(node.text)) return [];
+  const value = project.checker.getShorthandAssignmentValueSymbol(node.parent);
+  return value ? [value] : [];
+};
+
+/**
+ * Returns the symbols that each name in `nodes` reads. `symbols` holds the
+ * checker symbol of each name. The key of a binding element, also a string or
+ * computed string key, reads a property of the destructured type. A key in an
+ * assignment pattern does the same. A shorthand property in an object literal
+ * also reads the binding it names, which can be an import.
+ *
+ * The candidate names of `state` limit the property lookups, and its export
+ * names enable the import lookups. `unresolved` lists the assignment pattern
+ * names whose source type is unknown.
+ */
+export const shorthandReferenceSymbols = (project, nodes, symbols, state) => {
+  const symbolsByNode = new Map();
+  const unresolved = [];
+  bindingPropertySymbols(
+    project,
+    nodes.filter(
+      (node) =>
+        state.candidateNames.has(node.text) && bindingKeyPattern(node) && !isRenamingKey(node),
+    ),
+    symbolsByNode,
+  );
+  const shorthandProperties = nodes.filter(isPropertyName);
+  const readsExports = state.exportedNames.size > 0;
+  const names = {
+    candidates: state.candidateNames,
+    readsExports,
+    imports: readsExports && shorthandProperties.length > 0 ? importBindingNames(nodes) : new Set(),
+  };
+  shorthandProperties.forEach((node) => {
+    const extra = shorthandPropertySymbols(project, node, names, unresolved);
+    if (extra.length > 0) symbolsByNode.set(node, extra);
+  });
+  return {
+    symbols: nodes.map((node, index) => [symbols[index], ...(symbolsByNode.get(node) ?? [])]),
+    unresolved,
+  };
+};

package/src/symbol-impact.mjs

@@ -1,11 +1,6 @@
 import path from "node:path";
 
-import {
-  isCallExpression,
-  isExportDeclaration,
-  isImportDeclaration,
-  isStringLiteralLikeNode,
-} from "typescript/unstable/ast/is";
+import { ast } from "./backend.mjs";
 
 import { canonicalFileIdentity } from "./file-identity.mjs";
 import {
@@ -15,6 +10,8 @@ import {
   sourceFileIdentity,
 } from "./semantic-identity.mjs";
 
+const { isCallExpression, isExportDeclaration, isImportDeclaration, isStringLiteralLikeNode } = ast;
+
 const TEST_FILE_PATTERN = /(?:^|[/_.-])(?:test|spec)\.[cm]?[jt]sx?$/u;
 const compareText = (left, right) => Buffer.compare(Buffer.from(left), Buffer.from(right));
 const slash = (value) => value.split(path.sep).join("/");