@cplieger/deadset-ts 5.1.0 → 5.1.1

package/src/outside-tests.ts

@@ -0,0 +1,191 @@
+/**
+ * The test files no compiler configuration of a run holds. The runner executes them all
+ * the same, so each module one names is a test reference: the own file a relative
+ * specifier names, and the declarations that file exports under the names read from it.
+ * Such a file is read without a program, so what its body references beyond the modules
+ * it names is not known.
+ */
+
+import {
+  isCallExpression,
+  isExportDeclaration,
+  isImportDeclaration,
+  isNamespaceExport,
+  isNamespaceImport,
+  isNoSubstitutionTemplateLiteral,
+  isStringLiteral,
+  SyntaxKind,
+  type Node,
+  type SourceFile,
+} from "@typescript/native/unstable/ast";
+import { RESOLVED_EXTENSIONS, type ParseFile } from "./configuration-files.ts";
+import { emittedFrom } from "./emit-map.ts";
+import type { Host } from "./host.ts";
+import type { Inventory } from "./inventory.ts";
+import { dirnamePath, joinPath, normalizePath, queriedModulePath } from "./paths.ts";
+import { renderPosition } from "./position.ts";
+import { nameComponent } from "./ref.ts";
+import type { Reference } from "./references.ts";
+
+/** The paths below the target root one relative specifier may name, written path first. */
+function candidates(dir: string, specifier: string): readonly string[] {
+  if (!specifier.startsWith("./") && !specifier.startsWith("../")) {
+    return [];
+  }
+  const path = normalizePath(dir === "" ? specifier : `${dir}/${specifier}`);
+  return [
+    path,
+    ...emittedFrom(path, { sourceDirs: [] }),
+    ...RESOLVED_EXTENSIONS.map((extension) => path + extension),
+    ...RESOLVED_EXTENSIONS.map((extension) => `${path}/index${extension}`),
+  ];
+}
+
+/** One module a test file names, and the export names it reads from it; `evaluates` reads none. */
+interface NamedModule {
+  readonly specifier: Node;
+  readonly text: string;
+  readonly names: readonly string[];
+  readonly evaluates: boolean;
+}
+
+/** The text of a specifier written as literal text, or undefined for any other expression. */
+function literalText(node: Node | undefined): string | undefined {
+  return node !== undefined && (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node))
+    ? node.text
+    : undefined;
+}
+
+/**
+ * Every module one file names: an import declaration, a re-export, and an `import()` call
+ * of literal text anywhere in the file. A namespace form, a star re-export, a bare import
+ * and an `import()` evaluate the module.
+ */
+function modulesNamed(file: SourceFile): readonly NamedModule[] {
+  const found: NamedModule[] = [];
+  const name = (specifier: Node, names: readonly string[], evaluates: boolean): void => {
+    const text = literalText(specifier);
+    if (text !== undefined) {
+      found.push({ specifier, text, names, evaluates });
+    }
+  };
+  for (const statement of file.statements) {
+    if (isImportDeclaration(statement)) {
+      const clause = statement.importClause;
+      const bindings = clause?.namedBindings;
+      name(
+        statement.moduleSpecifier,
+        [
+          ...(clause?.name === undefined ? [] : ["default"]),
+          ...(bindings === undefined || isNamespaceImport(bindings)
+            ? []
+            : bindings.elements.map((one) => (one.propertyName ?? one.name).text)),
+        ],
+        bindings === undefined ? clause?.name === undefined : isNamespaceImport(bindings),
+      );
+    } else if (isExportDeclaration(statement) && statement.moduleSpecifier !== undefined) {
+      const clause = statement.exportClause;
+      const star = clause === undefined || isNamespaceExport(clause);
+      name(
+        statement.moduleSpecifier,
+        star ? [] : clause.elements.map((one) => (one.propertyName ?? one.name).text),
+        star,
+      );
+    }
+  }
+  const visit = (node: Node): void => {
+    if (isCallExpression(node) && node.expression.kind === SyntaxKind.ImportKeyword) {
+      const [argument] = node.arguments;
+      if (argument !== undefined) {
+        name(argument, [], true);
+      }
+    }
+    node.forEachChild(visit);
+  };
+  file.forEachChild(visit);
+  return found;
+}
+
+/** One test file read without a program. */
+export interface OutsideTest {
+  /** The path below the target root. */
+  readonly path: string;
+  readonly file: SourceFile;
+}
+
+/** Each of the given paths below the target root, parsed; one that cannot be read is skipped. */
+export function testFilesAt(
+  host: Host,
+  targetRoot: string,
+  paths: readonly string[],
+  parse: ParseFile,
+): readonly OutsideTest[] {
+  return paths.flatMap((path) => {
+    const fileName = joinPath(targetRoot, path);
+    let text: string;
+    try {
+      text = host.readFile(fileName);
+    } catch {
+      return [];
+    }
+    return [{ path, file: parse(fileName, text) }];
+  });
+}
+
+/**
+ * The references the given test files make to one project's own files through the
+ * modules they name ({@link modulesNamed}). A name read from a module references each
+ * top-level declaration the file exports under it; an evaluating form references the
+ * file. A query after the path names the file as {@link queriedModulePath} reads it.
+ */
+export function outsideTestReferences(
+  tests: readonly OutsideTest[],
+  held: Inventory,
+  targetRoot: string,
+): readonly Reference[] {
+  const fileAt = new Map(
+    held.symbols
+      .filter((symbol) => symbol.kind === "file")
+      .map((symbol) => [symbol.position.path, symbol.id]),
+  );
+  // Keyed on the reference's fragment, which spells the export name where the display
+  // name of a default export is its declared name.
+  const exported = new Map<string, string[]>();
+  for (const symbol of held.symbols) {
+    if (symbol.exported) {
+      const fragment = symbol.ref.slice(symbol.ref.lastIndexOf("#") + 1).replace(/:alias$/u, "");
+      const key = `${symbol.parent}\u0000${fragment}`;
+      exported.set(key, [...(exported.get(key) ?? []), symbol.id]);
+    }
+  }
+  const found: Reference[] = [];
+  for (const { path, file } of tests) {
+    const from = `${path}#`;
+    const dir = dirnamePath(path) === "." ? "" : dirnamePath(path);
+    for (const named of modulesNamed(file)) {
+      const written = named.text.includes("?") ? queriedModulePath(named.text) : named.text;
+      if (written === undefined) {
+        continue;
+      }
+      const fileId = candidates(dir, written)
+        .map((one) => fileAt.get(one))
+        .find((one) => one !== undefined);
+      if (fileId === undefined) {
+        continue;
+      }
+      const position = renderPosition(file, targetRoot, named.specifier.getStart());
+      const read = (to: string, use: Reference["use"]): void => {
+        found.push({ from, to, position, use, resolution: "syntax", test: true, unheld: true });
+      };
+      if (named.evaluates) {
+        read(fileId, "evaluation");
+      }
+      for (const name of named.names) {
+        for (const id of exported.get(`${fileId}\u0000${nameComponent(name)}`) ?? []) {
+          read(id, "read");
+        }
+      }
+    }
+  }
+  return found;
+}

package/src/overrides.ts

@@ -0,0 +1,136 @@
+/**
+ * The overrides of the target's class members. A call through the base class, `this`
+ * in the base's own body or a value typed as the base, names the base's member and
+ * runs the override of whichever subclass the value is, so the base member's
+ * declaration references every override as a use of it.
+ */
+
+import {
+  isClassDeclaration,
+  isClassExpression,
+  isExpressionWithTypeArguments,
+  isPropertyAccessExpression,
+  isQualifiedName,
+  SyntaxKind,
+  type HeritageClauseElement,
+  type Node,
+} from "@typescript/native/unstable/ast";
+import type { AliasChains } from "./alias-chain.ts";
+import { memberComponent } from "./class-members.ts";
+import { nodeKey, type Inventory, type InventorySymbol } from "./inventory.ts";
+import { UNANSWERED } from "./query.ts";
+import type { Reference } from "./references.ts";
+import type { ProjectView } from "./session.ts";
+
+/** The member kinds a subclass overrides. */
+const OVERRIDABLE: ReadonlySet<string> = new Set(["method", "class-member"]);
+
+/** The node naming the class one `extends` entry names. */
+function nameOf(entry: HeritageClauseElement): Node {
+  if (isExpressionWithTypeArguments(entry)) {
+    return isPropertyAccessExpression(entry.expression) ? entry.expression.name : entry.expression;
+  }
+  return isQualifiedName(entry.typeName) ? entry.typeName.right : entry.typeName;
+}
+
+/** Each class of the target whose `extends` clause names a class, with the name node. */
+function extending<Brand>(
+  project: ProjectView<Brand>,
+  held: Inventory,
+): readonly { readonly id: string; readonly base: Node }[] {
+  const found: { id: string; base: Node }[] = [];
+  for (const file of project.ownSourceFiles()) {
+    const visit = (node: Node): void => {
+      if (isClassDeclaration(node) || isClassExpression(node)) {
+        const id = held.declarations.get(nodeKey(file, node));
+        const clause = node.heritageClauses?.find((one) => one.token === SyntaxKind.ExtendsKeyword);
+        const base = clause?.types[0];
+        if (id !== undefined && base !== undefined) {
+          found.push({ id, base: nameOf(base) });
+        }
+      }
+      node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+  }
+  return found;
+}
+
+/**
+ * The references each base class member makes to its overrides, for the classes of one
+ * project that extend another class of the target. A member a nearer base already
+ * overrides is reached through that override. A private member is not overridden.
+ * Each reference is placed at the override and made by its file.
+ */
+export function overrideReferences<Brand>(
+  project: ProjectView<Brand>,
+  held: Inventory,
+  chains: AliasChains,
+  testFiles: ReadonlySet<string>,
+): readonly Reference[] {
+  const classes = extending(project, held);
+  if (classes.length === 0) {
+    return [];
+  }
+  const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
+  const members = new Map<string, Map<string, InventorySymbol>>();
+  for (const symbol of held.symbols) {
+    const component = memberComponent(symbol, byId);
+    if (
+      component === undefined ||
+      !OVERRIDABLE.has(symbol.kind) ||
+      symbol.visibility === "private" ||
+      symbol.visibility === "private-name"
+    ) {
+      continue;
+    }
+    const own = members.get(symbol.parent) ?? new Map<string, InventorySymbol>();
+    own.set(component, symbol);
+    members.set(symbol.parent, own);
+  }
+  const bases = new Map<string, readonly string[]>();
+  const symbols = project.symbolsAt(classes.map((one) => project.handle(one.base)));
+  classes.forEach(({ id }, index) => {
+    const symbol = symbols[index];
+    if (symbol !== undefined && symbol !== UNANSWERED) {
+      bases.set(
+        id,
+        chains
+          .chainOf(symbol)
+          .map((target) => target.id)
+          .filter((target) => byId.get(target)?.kind === "class" && target !== id),
+      );
+    }
+  });
+
+  /** The nearest member of one component the class or a class it extends declares. */
+  const declaredAbove = (classId: string, component: string, seen: Set<string>): string[] => {
+    if (seen.has(classId)) {
+      return [];
+    }
+    seen.add(classId);
+    const own = members.get(classId)?.get(component);
+    if (own !== undefined) {
+      return [own.id];
+    }
+    return (bases.get(classId) ?? []).flatMap((base) => declaredAbove(base, component, seen));
+  };
+
+  const found: Reference[] = [];
+  for (const [classId, baseIds] of bases) {
+    for (const [component, member] of members.get(classId) ?? []) {
+      const seen = new Set([classId]);
+      for (const base of baseIds.flatMap((one) => declaredAbove(one, component, seen))) {
+        found.push({
+          from: base,
+          to: member.id,
+          position: member.position,
+          use: "read",
+          resolution: "override",
+          test: testFiles.has(member.position.path),
+        });
+      }
+    }
+  }
+  return found;
+}

package/src/paths.ts

@@ -72,6 +72,24 @@ export function resolvePath(against: string, path: string): string {
   return isAbsolutePath(path) ? normalizePath(path) : joinPath(against, path);
 }
 
+/**
+ * The relative path before the query of a relative module specifier such as
+ * `./worker.ts?worker`, the module a bundler loads; undefined for a specifier with no
+ * query, one that is not relative, and one whose query has a `raw` parameter, which
+ * reads the file as text and so evaluates nothing.
+ */
+export function queriedModulePath(specifier: string): string | undefined {
+  const query = specifier.indexOf("?");
+  if (query < 0 || !(specifier.startsWith("./") || specifier.startsWith("../"))) {
+    return undefined;
+  }
+  const raw = specifier
+    .slice(query + 1)
+    .split("&")
+    .some((parameter) => parameter.split("=")[0] === "raw");
+  return raw ? undefined : specifier.slice(0, query);
+}
+
 /**
  * One path as it reads below a root, or undefined when it is not below the root.
  * Both are normalized first, so a root written with a trailing separator or a `.`

package/src/references.ts

@@ -37,7 +37,8 @@ import { contextualUses, type FlowAt, type LiteralAt } from "./contextual-uses.t
 import { destructuring, propertyReadsOf, type PropertyRead } from "./destructuring.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 +72,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 +87,7 @@ export type Resolution =
   | "syntax"
   | "destructured"
   | "contextual"
+  | "override"
   | "by-name";
 
 /** One use of one declaration by one declaration. */
@@ -112,6 +114,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
@@ -476,6 +480,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
@@ -1000,6 +1022,9 @@ export function references<Brand>(
     const fileId = declaredAt(file) ?? "";
     return { file, fileId, ...sitesOf(file, declarations, fileId, unread) };
   });
+  const fileIdByName = new Map(
+    walked.filter((one) => fileIds.has(one.fileId)).map((one) => [one.file.fileName, one.fileId]),
+  );
   const contextual = contextualUses(
     project,
     held,
@@ -1160,6 +1185,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;
@@ -1298,6 +1334,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) ||