@cplieger/deadset-ts 5.1.0 → 5.2.0

package/src/references.ts

@@ -12,8 +12,11 @@ import {
   isForInStatement,
   isForOfStatement,
   isForStatement,
+  isIdentifier,
   isImportDeclaration,
   isImportEqualsDeclaration,
+  isMetaProperty,
+  isNewExpression,
   isNamespaceExport,
   isNoSubstitutionTemplateLiteral,
   isObjectLiteralExpression,
@@ -35,9 +38,12 @@ import type { Symbol as TSSymbol } from "@typescript/native/unstable/sync";
 import { aliasChains, type ChainTarget } from "./alias-chain.ts";
 import { contextualUses, type FlowAt, type LiteralAt } from "./contextual-uses.ts";
 import { destructuring, propertyReadsOf, type PropertyRead } from "./destructuring.ts";
+import { specifierCandidates } from "./configuration-files.ts";
+import { namespaceUses } from "./namespace-objects.ts";
 import { globExpression } from "./glob.ts";
 import { declarationsByName, nodeKey, type Inventory, type InventorySymbol } from "./inventory.ts";
-import { relativePath } from "./paths.ts";
+import { overrideReferences } from "./overrides.ts";
+import { dirnamePath, queriedModulePath, relativePath, resolvePath } from "./paths.ts";
 import { byPosition, isComponentFile, renderPosition, type Position } from "./position.ts";
 import { DEFAULT_BATCH_CAP, propertyTables, UNANSWERED, type Answer } from "./query.ts";
 import type { ProjectView } from "./session.ts";
@@ -71,12 +77,12 @@ import { handedOn, valuesOf } from "./value-flow.ts";
 export type Use = "read" | "write" | "evaluation" | "decorator";
 
 /**
- * Which path answered for one reference: `batch`, the batched lookup over a file's names;
- * `resolved-symbol`, the per-node lookup for a batch's 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;
- * `by-name`, every declaration spelled as the site is, 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
+ * member's call dispatches to; `by-name`, every declaration so spelled, where the checker failed.
  */
 export type Resolution =
   | "batch"
@@ -86,6 +92,7 @@ export type Resolution =
   | "syntax"
   | "destructured"
   | "contextual"
+  | "override"
   | "by-name";
 
 /** One use of one declaration by one declaration. */
@@ -112,6 +119,8 @@ export interface Reference {
    * the consumer's root.
    */
   readonly consumer?: string;
+  /** Made by a target file no project of the run holds, so it enters as a consumer's reference does. */
+  readonly unheld?: true;
   /**
    * On a write, the local names of the writing file's import bindings that only the
    * values its file writes into the same declaration use, which deleting the
@@ -420,6 +429,27 @@ interface Evaluation {
   readonly from: string;
 }
 
+/**
+ * One module URL a source file builds: `new URL(<literal>, import.meta.url)` or
+ * `import.meta.resolve(<literal>)`, the literal relative. A runtime starts the file it
+ * names as a module, so it is an import of that file for its effects.
+ */
+interface ModuleURL {
+  readonly specifier: string;
+  /** The `URL` the constructor names, which must name no declaration of the target. */
+  readonly constructor: Node | undefined;
+  readonly at: Node;
+}
+
+/** One use of a module namespace object that may read every export of the module. */
+interface WholeRead {
+  /** The module specifier, whose symbol is the module read. */
+  readonly specifier: Node;
+  /** The use, whose position the reference carries. */
+  readonly at: Node;
+  readonly from: string;
+}
+
 /** One decorator expression, and the declaration it is attached to. */
 interface Decorated {
   readonly decorator: Node;
@@ -439,9 +469,55 @@ interface FileSites {
   readonly reads: readonly Read[];
   readonly links: readonly Link[];
   readonly evaluations: readonly Evaluation[];
+  readonly wholes: readonly WholeRead[];
+  readonly urls: readonly ModuleURL[];
   readonly decorated: readonly Decorated[];
 }
 
+/** Whether one node is `import.meta.url`. */
+function isImportMetaURL(node: Node): boolean {
+  const at = unparenthesized(node);
+  return (
+    isPropertyAccessExpression(at) &&
+    isMetaProperty(at.expression) &&
+    at.expression.keywordToken === SyntaxKind.ImportKeyword &&
+    at.name.text === "url"
+  );
+}
+
+/** The module URL one node builds, where it builds one. */
+function moduleURLOf(node: Node): ModuleURL | undefined {
+  const relative = (argument: Node | undefined): string | undefined => {
+    const at = argument === undefined ? undefined : unparenthesized(argument);
+    return at !== undefined &&
+      (isStringLiteral(at) || isNoSubstitutionTemplateLiteral(at)) &&
+      /^\.\.?\//u.test(at.text)
+      ? at.text
+      : undefined;
+  };
+  if (isNewExpression(node) && isIdentifier(node.expression) && node.expression.text === "URL") {
+    const [reference, base] = node.arguments ?? [];
+    const specifier = relative(reference);
+    return specifier !== undefined && base !== undefined && isImportMetaURL(base)
+      ? { specifier, constructor: node.expression, at: node }
+      : undefined;
+  }
+  if (isCallExpression(node)) {
+    const callee = unparenthesized(node.expression);
+    const specifier = relative(node.arguments[0]);
+    if (
+      specifier !== undefined &&
+      isPropertyAccessExpression(callee) &&
+      isMetaProperty(callee.expression) &&
+      callee.expression.keywordToken === SyntaxKind.ImportKeyword &&
+      callee.name.text === "resolve"
+    ) {
+      return { specifier, constructor: undefined, at: node };
+    }
+  }
+  return undefined;
+}
+
 /** Whether one node is a string literal or a template literal with no substitution. */
 function isLiteralText(node: Node | undefined): node is Node {
   return node !== undefined && (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node));
@@ -476,6 +552,24 @@ function evaluatedBy(node: Node): Node | undefined {
   return undefined;
 }
 
+/**
+ * The own file a module specifier with a query evaluates ({@link queriedModulePath}): the
+ * checker resolves the whole specifier to whatever module declaration matches it.
+ */
+function queriedFile(
+  file: SourceFile,
+  specifier: Node,
+  fileIdByName: ReadonlyMap<string, string>,
+): string | undefined {
+  if (!isStringLiteral(specifier) && !isNoSubstitutionTemplateLiteral(specifier)) {
+    return undefined;
+  }
+  const path = queriedModulePath(specifier.text);
+  return path === undefined
+    ? undefined
+    : fileIdByName.get(resolvePath(dirnamePath(file.fileName), path));
+}
+
 /**
  * The re-exports one node writes, if it is an export declaration. A specifier and a
  * namespace export are declarations whose names are where they are written, so no use is
@@ -562,7 +656,10 @@ function sitesOf(
   const reads: Read[] = [];
   const links: Link[] = [];
   const evaluations: Evaluation[] = [];
+  const wholes: WholeRead[] = [];
+  const urls: ModuleURL[] = [];
   const decorated: Decorated[] = [];
+  const namespaces = namespaceUses(file);
   const literals: LiteralAt[] = [];
   const flows: FlowAt[] = [];
   const writes = new Set<number>();
@@ -593,6 +690,12 @@ function sitesOf(
     if (unread.has(node)) {
       return;
     }
+    const namespace = namespaces.get(node);
+    if (namespace?.kind === "whole") {
+      wholes.push({ specifier: namespace.specifier, at: node, from: enclosing });
+    } else if (namespace?.kind === "indexed") {
+      found.push({ node: namespace.literal, shorthand: undefined, from: enclosing, use: "read" });
+    }
     if (isName(node)) {
       if (!declared.has(node.pos)) {
         const site = { node, shorthand: shorthands.get(node.pos), from: enclosing };
@@ -622,6 +725,10 @@ function sitesOf(
     if (evaluated !== undefined) {
       evaluations.push({ node: evaluated, from: enclosing });
     }
+    const url = moduleURLOf(node);
+    if (url !== undefined) {
+      urls.push(url);
+    }
     const held = declarations.get(nodeKey(file, node));
     const outer = enclosing;
     if (held !== undefined) {
@@ -637,7 +744,7 @@ function sitesOf(
   };
 
   file.forEachChild(visit);
-  return { uses: found, literals, flows, reads, links, evaluations, decorated };
+  return { uses: found, literals, flows, reads, links, evaluations, wholes, urls, decorated };
 }
 
 /** The declaration kinds of a property an object literal declares. */
@@ -900,6 +1007,36 @@ export function references<Brand>(
     return topLevel.get(fileId) ?? [];
   };
 
+  const exportsCache = new Map<number, readonly ChainTarget[]>();
+  /**
+   * Every declaration one module exports, each re-export walked along its chain. A module
+   * the checker left unanswered may be any file, so it reads every file's exports.
+   */
+  const exportsRead = (module: Answer<TSSymbol>): readonly ChainTarget[] => {
+    if (module === UNANSWERED) {
+      return [...fileIds].flatMap((id) =>
+        declaredIn(id)
+          .filter((symbol) => symbol.exported)
+          .map((symbol) => ({ id: symbol.id, stepped: false, guessed: true })),
+      );
+    }
+    const known = exportsCache.get(module.id);
+    if (known !== undefined) {
+      return known;
+    }
+    const table = project.queries.exportsOfModule(module);
+    const read =
+      table === UNANSWERED
+        ? chains.declarationsOf(module).flatMap((id) =>
+            declaredIn(id)
+              .filter((symbol) => symbol.exported)
+              .map((symbol) => ({ id: symbol.id, stepped: false, guessed: true })),
+          )
+        : table.flatMap((exported) => chains.chainOf(exported));
+    exportsCache.set(module.id, read);
+    return read;
+  };
+
   /** The identifier of the declaration one node of this program is, where it is one. */
   const declaredAt = (node: Node): string | undefined =>
     declarations.get(nodeKey(node.getSourceFile(), node));
@@ -1000,6 +1137,9 @@ export function references<Brand>(
     const fileId = declaredAt(file) ?? "";
     return { file, fileId, ...sitesOf(file, declarations, fileId, unread) };
   });
+  const fileIdByName = new Map<string, string>(
+    walked.filter((one) => fileIds.has(one.fileId)).map((one) => [one.file.fileName, one.fileId]),
+  );
   const contextual = contextualUses(
     project,
     held,
@@ -1087,7 +1227,7 @@ export function references<Brand>(
     }
   }
 
-  for (const { file, fileId, uses, reads, links, evaluations, decorated } of walked) {
+  for (const { file, fileId, uses, reads, links, evaluations, wholes, urls, decorated } 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);
@@ -1117,6 +1257,8 @@ export function references<Brand>(
         ...uses.filter((site) => site.shorthand === undefined).map((site) => site.node),
         ...links.map((link) => link.node),
         ...evaluations.map((evaluation) => evaluation.node),
+        ...wholes.map((whole) => whole.specifier),
+        ...urls.flatMap((url) => url.constructor ?? []),
         ...bindings.map((binding) => binding.node),
       ]),
     ];
@@ -1160,6 +1302,17 @@ export function references<Brand>(
     }
 
     for (const evaluation of evaluations) {
+      const queried = queriedFile(file, evaluation.node, fileIdByName);
+      if (queried !== undefined) {
+        found.push({
+          from: evaluation.from,
+          to: queried,
+          position: renderPosition(file, root, evaluation.node.getStart()),
+          use: "evaluation",
+          resolution: "syntax",
+          test,
+        });
+      }
       const module = answered.get(evaluation.node);
       if (module === undefined) {
         continue;
@@ -1181,6 +1334,47 @@ export function references<Brand>(
       }
     }
 
+    for (const url of urls) {
+      const constructor = url.constructor === undefined ? undefined : answered.get(url.constructor);
+      if (
+        typeof constructor === "object" &&
+        constructor.declarations.some((handle) => ownPaths.has(handle.path))
+      ) {
+        continue;
+      }
+      const loaded = specifierCandidates(dirnamePath(file.fileName), url.specifier)
+        .map((path) => fileIdByName.get(path))
+        .find((id) => id !== undefined);
+      if (loaded !== undefined) {
+        found.push({
+          from: fileId,
+          to: loaded,
+          position: renderPosition(file, root, url.at.getStart()),
+          use: "evaluation",
+          resolution: "syntax",
+          test,
+        });
+      }
+    }
+
+    for (const whole of wholes) {
+      const module = answered.get(whole.specifier);
+      if (module === undefined) {
+        continue;
+      }
+      const position = renderPosition(file, root, whole.at.getStart());
+      for (const target of exportsRead(module)) {
+        found.push({
+          from: whole.from,
+          to: target.id,
+          position,
+          use: "read",
+          resolution: target.guessed ? "by-name" : "batch",
+          test,
+        });
+      }
+    }
+
     if (markup) {
       for (const symbol of declaredIn(fileId)) {
         found.push({
@@ -1298,6 +1492,9 @@ export function references<Brand>(
     }
   }
 
+  if (consumer === undefined) {
+    found.push(...overrideReferences(project, held, chains, new Set(tests)));
+  }
   found.sort(
     (a, b) =>
       byPosition(a.position, b.position) ||