@cplieger/deadset-ts 5.1.0 → 5.2.0

package/src/roots.ts

@@ -8,7 +8,16 @@
  * under reachability and still a candidate under reference counting.
  */
 
-import type { SourceFile } from "@typescript/native/unstable/ast";
+import {
+  isExpressionWithTypeArguments,
+  isFunctionLikeDeclaration,
+  isPropertyAccessExpression,
+  isQualifiedName,
+  isTypeQueryNode,
+  isTypeReferenceNode,
+  type Node,
+  type SourceFile,
+} from "@typescript/native/unstable/ast";
 import { aliasChains } from "./alias-chain.ts";
 import type { ParseFile } from "./configuration-files.ts";
 import { conventionEntries, type Conventions } from "./conventions.ts";
@@ -17,6 +26,7 @@ import { globExpression } from "./glob.ts";
 import type { Host } from "./host.ts";
 import { nodeKey, type Inventory, type InventorySymbol } from "./inventory.ts";
 import type { Manifest, ManifestEntry } from "./manifest.ts";
+import { relativePath, resolvePath } from "./paths.ts";
 import { byPosition } from "./position.ts";
 import { UNANSWERED } from "./query.ts";
 import type { ProjectView } from "./session.ts";
@@ -88,8 +98,8 @@ export interface Roots {
   readonly unmatched: readonly string[];
   /**
    * Every declaration of the project, where the checker left the module or export table
-   * of an entry or a published file unanswered, and none otherwise: which of them that
-   * file exports is unknown.
+   * of an entry or a published file unanswered, since which of them that file exports is
+   * unknown; otherwise each one an unanswered published type name may name.
    */
   readonly unanswered: readonly string[];
 }
@@ -101,10 +111,10 @@ export interface RootOptions {
   /** The target's own manifest. */
   readonly manifest: Manifest;
   /**
-   * The entry points the other packages of the target's workspace name, each already
-   * marked published or not by its own manifest's rule.
+   * The entry points the target's other packages name, its workspace's members and the
+   * packages below it, each already marked published or not by its own manifest's rule.
    */
-  readonly workspaceEntries?: readonly ManifestEntry[] | undefined;
+  readonly otherPackages?: readonly ManifestEntry[] | undefined;
   /** `roots.patterns` from the resolved configuration. */
   readonly patterns: readonly string[];
   /** `ts.entry_files` from the resolved configuration. */
@@ -126,6 +136,50 @@ const ENTRY_KINDS = {
   script: "script",
 } as const satisfies Record<ManifestEntry["role"], RootKind>;
 
+/** The rules whose rooted files a manifest target is read back to by name. */
+const READ_BACK_RULES: ReadonlySet<EntryRule> = new Set([
+  "configuration-file",
+  "configuration-string",
+  "html-entry",
+]);
+
+/** The extensions a manifest target's name drops: the ones a build writes. */
+const OUTPUT_EXTENSION = /\.(?:d\.ts|d\.mts|d\.cts|js|mjs|cjs|jsx)$/u;
+
+/** The extension a source file's name drops. */
+const SOURCE_EXTENSION = /\.(?:d\.)?[cm]?[jt]sx?$/u;
+
+/**
+ * The rooted files one manifest target reads back to by name: its path below the
+ * manifest's directory, past its first directory where it names one, without its output
+ * extension, is the name, and a rooted file is one whose path below the same directory,
+ * without its source extension, ends with that name at a directory boundary.
+ */
+function readBackByName(
+  host: Host,
+  entry: ManifestEntry,
+  rooted: readonly SourceFile[],
+): readonly SourceFile[] {
+  const dir = resolvePath(host.workingDirectory(), entry.dir);
+  const below = relativePath(dir, resolvePath(host.workingDirectory(), entry.path));
+  if (below === undefined || below === "") {
+    return [];
+  }
+  const cut = below.indexOf("/");
+  const name = (cut === -1 ? below : below.slice(cut + 1)).replace(OUTPUT_EXTENSION, "");
+  if (name === "") {
+    return [];
+  }
+  const found = new Map<string, SourceFile>();
+  for (const file of rooted) {
+    const path = relativePath(dir, file.fileName)?.replace(SOURCE_EXTENSION, "");
+    if (path !== undefined && (path === name || path.endsWith(`/${name}`))) {
+      found.set(file.fileName, file);
+    }
+  }
+  return [...found.values()];
+}
+
 /** Whether a configured string carries either special character. */
 function isPattern(text: string): boolean {
   return text.includes("*") || text.includes("?");
@@ -236,6 +290,14 @@ export function roots<Brand>(
     entered.push({ file, kind, source, exports });
   };
 
+  const points = entryPoints(
+    project,
+    files,
+    options.testFiles,
+    options.host,
+    targetRoot,
+    options.parse,
+  );
   const published: SourceFile[] = [];
   const entries = [
     ...options.manifest.entries.map((entry) => ({
@@ -244,16 +306,29 @@ export function roots<Brand>(
         entry.published &&
         (options.manifest.declaresExports ? entry.member.startsWith("exports") : true),
     })),
-    ...(options.workspaceEntries ?? []).map((entry) => ({ entry, publishes: entry.published })),
+    ...(options.otherPackages ?? []).map((entry) => ({ entry, publishes: entry.published })),
+  ];
+  const scripted = entries.flatMap(({ entry }) =>
+    entry.role === "script" ? files.named(entry.path) : [],
+  );
+  const readBackTo = [
+    ...scripted,
+    ...points.filter((point) => READ_BACK_RULES.has(point.rule)).map((point) => point.file),
   ];
+  const entryFiles = (entry: ManifestEntry): readonly SourceFile[] => {
+    const named = files.named(entry.path);
+    return named.length > 0 || entry.role === "script"
+      ? named
+      : readBackByName(options.host, entry, readBackTo);
+  };
   for (const { entry, publishes } of entries) {
     if (options.publishedAPI && publishes) {
-      published.push(...files.named(entry.path));
+      published.push(...entryFiles(entry));
     }
   }
   const publishedNames = new Set(published.map((file) => file.fileName));
   for (const { entry } of entries) {
-    for (const file of files.named(entry.path)) {
+    for (const file of entryFiles(entry)) {
       const kind = ENTRY_KINDS[entry.role];
       enter(file, kind, entry.member, !publishedNames.has(file.fileName));
     }
@@ -271,14 +346,7 @@ export function roots<Brand>(
     : conventionEntries(options.conventions, files)) {
     enter(file, "convention", row, true);
   }
-  for (const point of entryPoints(
-    project,
-    files,
-    options.testFiles,
-    options.host,
-    targetRoot,
-    options.parse,
-  )) {
+  for (const point of points) {
     enter(point.file, point.rule, point.source, point.exports);
   }
   for (const file of files.byPath.values()) {
@@ -310,10 +378,11 @@ export function roots<Brand>(
     }
   }
 
-  if (options.publishedAPI) {
-    for (const id of publishedAPI(published, exportsOf, held)) {
-      add(id, "published-api", "");
-    }
+  const api = options.publishedAPI
+    ? publishedAPI(project, published, exportsOf, held, files.byPath)
+    : { ids: [], guessed: [] };
+  for (const id of api.ids) {
+    add(id, "published-api", "");
   }
 
   const unmatched = configured(held, options.patterns, add);
@@ -330,7 +399,7 @@ export function roots<Brand>(
     configFile: project.configFile,
     liveUnderReachability: ordered,
     unmatched,
-    unanswered: answered ? [] : held.symbols.map((symbol) => symbol.id),
+    unanswered: answered ? api.guessed : held.symbols.map((symbol) => symbol.id),
   };
 }
 
@@ -388,55 +457,143 @@ function exportTables<Brand>(
 const EXPORTING_CONTAINERS: ReadonlySet<string> = new Set(["file", "namespace"]);
 
 /**
- * Every declaration a consumer of the library can name: what the published files
- * export, and below each, the members a consumer reaches through it.
- *
- * The published files are the ones `exports` reaches where the manifest declares
- * one, because a package that declares `exports` has said exactly what a consumer may
- * import; where it declares none, they are the ones the members that preceded it
- * name. Below a published module or namespace the walk follows what its export table
- * names; below any other published declaration it follows every member a consumer
- * can write: a public one, and a protected one, which a consumer's subclass names. A
- * private member is not published, nor is anything below one, and a type parameter
- * is not published either, because a consumer supplies a type argument by position.
- *
- * A published file is not itself published. A consumer imports a module and names
- * what it exports; the file is a root because the manifest names it, which is a
- * different reason.
+ * Every declaration a consumer of the library can name: what the published files export
+ * and, below each, the members a consumer writes: a namespace's exported ones, any other
+ * declaration's public and protected ones, never a private one or a type parameter. A
+ * declaration a published one's type names is published too, exported or not. A type name
+ * the checker leaves unanswered publishes every declaration spelled as it is, and those are
+ * `guessed`. A published file is not itself published.
  */
-function publishedAPI(
+function publishedAPI<Brand>(
+  project: ProjectView<Brand>,
   published: readonly SourceFile[],
   exportsOf: ReadonlyMap<string, readonly string[]>,
   held: Inventory,
-): readonly string[] {
+  byPath: ReadonlyMap<string, SourceFile>,
+): { readonly ids: readonly string[]; readonly guessed: readonly string[] } {
   const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
   const children = childrenOf(held);
+  const nodes = declarationNodes(held, byPath);
+  const chains = aliasChains(project, held);
   const reached = new Set<string>();
+  const guessed = new Set<string>();
   const pending: string[] = [];
+  const reach = (id: string): void => {
+    if (!reached.has(id) && byId.get(id)?.kind !== "file") {
+      reached.add(id);
+      pending.push(id);
+    }
+  };
   for (const file of published) {
     for (const id of exportsOf.get(file.fileName) ?? []) {
       if (byId.get(id)?.kind === "file") {
         pending.push(id);
-      } else if (!reached.has(id)) {
-        reached.add(id);
-        pending.push(id);
+      } else {
+        reach(id);
       }
     }
   }
-  for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
-    const exporting = EXPORTING_CONTAINERS.has(byId.get(next)?.kind ?? "");
-    for (const member of children.get(next) ?? []) {
-      const reachable = exporting
-        ? member.exported
-        : member.visibility !== "private" && member.visibility !== "private-name";
-      if (member.kind === "type-parameter" || reached.has(member.id) || !reachable) {
-        continue;
+  while (pending.length > 0) {
+    const round: string[] = [];
+    for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
+      round.push(next);
+      const exporting = EXPORTING_CONTAINERS.has(byId.get(next)?.kind ?? "");
+      for (const member of children.get(next) ?? []) {
+        const reachable = exporting
+          ? member.exported
+          : member.visibility !== "private" && member.visibility !== "private-name";
+        if (member.kind !== "type-parameter" && reachable) {
+          reach(member.id);
+        }
       }
-      reached.add(member.id);
-      pending.push(member.id);
     }
+    const named = round.flatMap((id) => {
+      const symbol = byId.get(id);
+      return symbol === undefined || symbol.kind === "file" ? [] : nodes.typeNamesOf(symbol);
+    });
+    project.symbolsAt(named.map((node) => project.handle(node))).forEach((symbol, index) => {
+      if (symbol === UNANSWERED) {
+        for (const id of held.byName.get(named[index]?.getText() ?? "") ?? []) {
+          guessed.add(id);
+          reach(id);
+        }
+      } else if (symbol !== undefined) {
+        for (const target of chains.chainOf(symbol)) {
+          reach(target.id);
+        }
+      }
+    });
   }
-  return [...reached];
+  return { ids: [...reached], guessed: [...guessed] };
+}
+
+/** The type names declarations of the inventory write, each file walked once, when first asked. */
+function declarationNodes(
+  held: Inventory,
+  byPath: ReadonlyMap<string, SourceFile>,
+): { typeNamesOf(symbol: InventorySymbol): readonly Node[] } {
+  const walked = new Map<string, { byId: Map<string, Node>; nodes: Set<Node> }>();
+  const nodesIn = (path: string): { byId: Map<string, Node>; nodes: Set<Node> } => {
+    const known = walked.get(path);
+    if (known !== undefined) {
+      return known;
+    }
+    const found = { byId: new Map<string, Node>(), nodes: new Set<Node>() };
+    const file = byPath.get(path);
+    if (file !== undefined) {
+      const visit = (node: Node): void => {
+        const id = held.declarations.get(nodeKey(file, node));
+        if (id !== undefined) {
+          found.nodes.add(node);
+          if (!found.byId.has(id)) {
+            found.byId.set(id, node);
+          }
+        }
+        node.forEachChild(visit);
+      };
+      visit(file);
+    }
+    walked.set(path, found);
+    return found;
+  };
+  return {
+    typeNamesOf: (symbol) => {
+      const { byId, nodes } = nodesIn(symbol.position.path);
+      const declaration = byId.get(symbol.id);
+      return declaration === undefined ? [] : typeNamesOf(declaration, nodes);
+    },
+  };
+}
+
+/**
+ * The names of types one declaration's own syntax writes: in a type reference, a
+ * heritage clause or a type query. A function body is not read, and neither is a
+ * declaration nested in this one, which `nested` holds and which is read on its own.
+ */
+function typeNamesOf(declaration: Node, nested: ReadonlySet<Node>): readonly Node[] {
+  const found: Node[] = [];
+  const visit = (node: Node): void => {
+    if (node !== declaration && nested.has(node)) {
+      return;
+    }
+    if (isTypeReferenceNode(node)) {
+      found.push(isQualifiedName(node.typeName) ? node.typeName.right : node.typeName);
+    } else if (isExpressionWithTypeArguments(node)) {
+      found.push(
+        isPropertyAccessExpression(node.expression) ? node.expression.name : node.expression,
+      );
+    } else if (isTypeQueryNode(node)) {
+      found.push(isQualifiedName(node.exprName) ? node.exprName.right : node.exprName);
+    }
+    const body = isFunctionLikeDeclaration(node) ? node.body : undefined;
+    node.forEachChild((child) => {
+      if (child !== body) {
+        visit(child);
+      }
+    });
+  };
+  visit(declaration);
+  return found;
 }
 
 /**

package/src/session.ts

@@ -485,8 +485,8 @@ function projectsOf(
  * snapshot of one client, and answers in their order. A configuration `programs` describes is
  * built as that program, or opened from the configuration it writes, instead of as a project.
  * One the snapshot holds nothing for ends the run under `"refuse"` and is named in the result
- * under `"record"`. The snapshot is disposed after the last visit and the client released
- * after it, whether the visit completed or threw.
+ * under `"record"`. `last` runs after the last visit while the client still answers; the
+ * snapshot is disposed and the client released after it, whether the visit completed or threw.
  */
 export function runSession<Result>(
   engine: Engine,
@@ -494,6 +494,7 @@ export function runSession<Result>(
   visit: ProjectVisitor<Result>,
   unopened: Unopened = "refuse",
   programs: ReadonlyMap<string, WorkspaceProgram> = new Map(),
+  last: () => void = () => undefined,
 ): SessionResult<Result> {
   try {
     const built: string[] = [];
@@ -531,6 +532,7 @@ export function runSession<Result>(
         }
         projects.push(visit(viewOf(project, configFile, engine, log)));
       }
+      last();
       return {
         projects,
         unopened: missing,

package/src/sweep.ts

@@ -166,6 +166,25 @@ export function sweep(graph: Graph, input: SweepInput): Liveness {
   return { liveUnder: live, candidates };
 }
 
+/**
+ * Per declaration of the graph, whether the run that counts test references reaches it.
+ * That run's roots are the graph's own and each test file, being the file's top level
+ * and every declaration it exports, which a test runner may call; `held` seeds it as a
+ * mark or an exemption seeds a sweep.
+ */
+export function reachedWithTheTests(graph: Graph, held: readonly string[]): readonly boolean[] {
+  const tests = graph.symbols.flatMap((symbol, at) => {
+    const top =
+      symbol.kind === "file" || graph.symbols[graph.parent[at] ?? OUTSIDE]?.kind === "file";
+    return graph.test[at] === true && top && (symbol.kind === "file" || symbol.exported)
+      ? [{ at, kind: "test-runner" as const }]
+      : [];
+  });
+  return reachable({ ...graph, rooted: [...graph.rooted, ...tests] }, flagged(graph, held), {
+    production: false,
+  });
+}
+
 /**
  * The references a loaded consumer makes that the mode counts. A production mode counts
  * none a consumer's test file made, as it counts none of the target's.

package/src/template-field.ts

@@ -125,12 +125,74 @@ function stringEnd(text: string, from: number): number {
   return at + 1;
 }
 
-/** The identifiers one action's inner text writes outside a quoted string, with their offsets in it. */
-function identifiersOf(inner: string): readonly { name: string; offset: number }[] {
+/** The end of the `${` substitution whose expression starts at `from`, past its closing brace. */
+function substitutionEnd(text: string, from: number): number {
+  let depth = 1;
+  let at = from;
+  while (at < text.length) {
+    const char = text[at];
+    if (char === '"' || char === "'") {
+      at = stringEnd(text, at);
+      continue;
+    }
+    if (char === "`") {
+      at = templateEnd(text, at, () => undefined);
+      continue;
+    }
+    if (char === "{") {
+      depth += 1;
+    } else if (char === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return at + 1;
+      }
+    }
+    at += 1;
+  }
+  return at;
+}
+
+/** The end of the template literal at `from`; each `${…}` expression goes to `substitution`. */
+function templateEnd(
+  text: string,
+  from: number,
+  substitution: (expression: string, offset: number) => void,
+): number {
+  let at = from + 1;
+  while (at < text.length && text[at] !== "`") {
+    if (text[at] === "\\") {
+      at += 2;
+      continue;
+    }
+    if (text[at] === "$" && text[at + 1] === "{") {
+      const start = at + 2;
+      const end = substitutionEnd(text, start);
+      substitution(text.slice(start, end - 1), start);
+      at = end;
+      continue;
+    }
+    at += 1;
+  }
+  return at + 1;
+}
+
+/**
+ * The identifiers one action's inner text writes outside a quoted string, with their offsets
+ * in it. In `script` text, a component's markup, a template literal's substitutions are code.
+ */
+function identifiersOf(inner: string, script = false): readonly { name: string; offset: number }[] {
   const found: { name: string; offset: number }[] = [];
   let at = 0;
   while (at < inner.length) {
     const char = inner[at] ?? "";
+    if (char === "`" && script) {
+      at = templateEnd(inner, at, (expression, offset) => {
+        for (const one of identifiersOf(expression, true)) {
+          found.push({ name: one.name, offset: offset + one.offset });
+        }
+      });
+      continue;
+    }
     if (char === '"' || char === "'" || char === "`") {
       at = stringEnd(inner, at);
       continue;
@@ -183,7 +245,7 @@ function namesOf(text: string, delimiters: TemplateDelimiters): readonly Named[]
 /** Every identifier the markup of one component file writes in an action. */
 function markupNamesOf(text: string): readonly Named[] {
   return readComponent(text).markup.flatMap((one) =>
-    identifiersOf(one.text).map(({ name, offset }) => ({
+    identifiersOf(one.text, true).map(({ name, offset }) => ({
       name,
       offset: one.start + offset,
       action: one.action,

package/src/test-support.ts

@@ -1,8 +1,8 @@
 /**
- * Test-support code: a file that is not a test file by name and that only test code
- * imports. At least one test file reaches it, directly or through other such files, and
- * nothing else does, so it is judged with the tests: what it references is referenced by
- * test code, and a declaration of it is live while test code references it.
+ * Test-support code: the files only tests reach. A test reaches each one through a chain
+ * of references, and every reference to a declaration of one, an import for its effects
+ * included, is written in a test file or in another such file, so it is judged with the
+ * tests: what it references is referenced by test code.
  */
 
 import type { InventorySymbol } from "./inventory.ts";
@@ -13,10 +13,11 @@ import type { Root } from "./roots.ts";
 const SKIP_ROOT = "type-error";
 
 /**
- * The files of one project that are test-support code, below the target root. A file
- * holding a root is not one, because a root has a caller outside the import graph: a
- * runtime, a tool, a configuration, or a consumer of a library's published API.
- * `testFiles` are the files the test-file rules classified.
+ * The files of one project that are test-support code, below the target root: the
+ * largest set of files a test file reaches, none of them a test file or holding a root,
+ * whose every user outside the set is a test file. A root has a caller outside the
+ * reference graph: a runtime, a tool, a configuration, or a consumer of a library's
+ * published API. `testFiles` are the files the test-file rules classified.
  */
 export function testSupportFiles(
   symbols: readonly InventorySymbol[],
@@ -26,34 +27,45 @@ export function testSupportFiles(
 ): ReadonlySet<string> {
   const fileOf = new Map(symbols.map((symbol) => [symbol.id, symbol.position.path]));
   const users = new Map<string, Set<string>>();
+  const uses = new Map<string, Set<string>>();
+  const add = (map: Map<string, Set<string>>, key: string, value: string): void => {
+    const held = map.get(key);
+    if (held === undefined) {
+      map.set(key, new Set([value]));
+    } else {
+      held.add(value);
+    }
+  };
   for (const reference of references) {
     const used = fileOf.get(reference.to);
     const from = reference.position.path;
     if (reference.consumer !== undefined || used === undefined || used === from) {
       continue;
     }
-    const held = users.get(used);
-    if (held === undefined) {
-      users.set(used, new Set([from]));
-    } else {
-      held.add(from);
-    }
+    add(users, used, from);
+    add(uses, from, used);
   }
   const tests = new Set(testFiles);
   const rooted = new Set(
     roots.filter((root) => root.kind !== SKIP_ROOT).flatMap((root) => fileOf.get(root.id) ?? []),
   );
-  const candidates = [...users.keys()].filter((path) => !tests.has(path) && !rooted.has(path));
-  const support = new Set<string>();
+  const reached = new Set<string>();
+  const queue = [...tests];
+  for (let path = queue.pop(); path !== undefined; path = queue.pop()) {
+    for (const next of uses.get(path) ?? []) {
+      if (!reached.has(next) && !tests.has(next)) {
+        reached.add(next);
+        queue.push(next);
+      }
+    }
+  }
+  const support = new Set([...reached].filter((path) => !rooted.has(path)));
   for (let changed = true; changed;) {
     changed = false;
-    for (const path of candidates) {
-      if (support.has(path)) {
-        continue;
-      }
+    for (const path of support) {
       const from = users.get(path) ?? new Set<string>();
-      if ([...from].every((one) => tests.has(one) || support.has(one))) {
-        support.add(path);
+      if (![...from].every((one) => tests.has(one) || support.has(one))) {
+        support.delete(path);
         changed = true;
       }
     }

package/src/version.ts

@@ -4,4 +4,4 @@
  * independently of the analyzer's own version, which is the one the host answers
  * from the package the analyzer was installed from.
  */
-export const CONTRACT_VERSION = "5.2.0";
+export const CONTRACT_VERSION = "5.3.0";