@cplieger/deadset-ts 2.3.0 → 3.1.0

package/src/roots.ts

@@ -2,15 +2,15 @@
  * The root set of one project: every declaration the analysis keeps live without a
  * reference, and why.
  *
- * A root makes its declaration live under REACHABILITY and plays no part in
- * reference counting, which asks only whether some declaration of the loaded graph
- * names it. The two relations are different sets, so an exported declaration that
- * something outside the program reaches is live under the first and still a
- * candidate under the second.
+ * Every root seeds REACHABILITY, and no root counts as a reference. A root of a kind
+ * that names a caller is live under reference counting as well, which the sweep
+ * decides; a root that only supposes a consumer is not, so an exported declaration
+ * something outside the program reaches is live under reachability and still a
+ * candidate under reference counting.
  */
 
 import type { SourceFile } from "@typescript/native/unstable/ast";
-import type { Symbol as TSSymbol } from "@typescript/native/unstable/sync";
+import { aliasChains } from "./alias-chain.ts";
 import { REPOSITORY_DOCUMENT } from "./config.ts";
 import { entryPoints, type EntryRule } from "./entry-points.ts";
 import type { Finding } from "./finding.ts";
@@ -63,7 +63,8 @@ export interface Roots {
    * reason it is live.
    *
    * The member says which relation the set feeds: every declaration here is live
-   * under reachability, and nothing here is live under reference counting.
+   * under reachability. A root of a kind that names a caller is also live under
+   * reference counting, which the sweep decides.
    */
   readonly liveUnderReachability: readonly Root[];
   /**
@@ -230,12 +231,10 @@ export function roots<Brand>(
     enter(point.file, point.rule, point.source, point.exports);
   }
 
-  const exportsOf = exportTables(
-    project,
-    held,
-    [...entered.filter((entry) => entry.exports).map((entry) => entry.file), ...published],
-    files.byName,
-  );
+  const exportsOf = exportTables(project, held, [
+    ...entered.filter((entry) => entry.exports).map((entry) => entry.file),
+    ...published,
+  ]);
   for (const entry of entered) {
     const id = fileIds.get(entry.file.fileName);
     if (id === undefined) {
@@ -282,7 +281,6 @@ function exportTables<Brand>(
   project: ProjectView<Brand>,
   held: Inventory,
   wanted: readonly SourceFile[],
-  ownFiles: ReadonlyMap<string, SourceFile>,
 ): ReadonlyMap<string, readonly string[]> {
   const unique = [...new Map(wanted.map((file) => [file.fileName, file])).values()];
   const tables = new Map<string, readonly string[]>();
@@ -290,36 +288,7 @@ function exportTables<Brand>(
     return tables;
   }
   const modules = project.symbolsAt(unique.map((file) => project.handle(file)));
-  const chains = new Map<number, readonly string[]>();
-
-  const chainOf = (symbol: TSSymbol): readonly string[] => {
-    const cached = chains.get(symbol.id);
-    if (cached !== undefined) {
-      return cached;
-    }
-    const ids: string[] = [];
-    const walked = new Set<number>();
-    let at: TSSymbol | undefined = symbol;
-    while (at !== undefined && !walked.has(at.id)) {
-      walked.add(at.id);
-      for (const handle of at.declarations) {
-        if (!ownFiles.has(handle.path)) {
-          continue;
-        }
-        const node = project.declarationAt(handle)?.node;
-        const id =
-          node === undefined
-            ? undefined
-            : held.declarations.get(nodeKey(node.getSourceFile(), node));
-        if (id !== undefined && !ids.includes(id)) {
-          ids.push(id);
-        }
-      }
-      at = project.aliasStepOf(at);
-    }
-    chains.set(symbol.id, ids);
-    return ids;
-  };
+  const chains = aliasChains(project, held);
 
   unique.forEach((file, index) => {
     const module = modules[index];
@@ -329,8 +298,8 @@ function exportTables<Brand>(
     }
     const ids = new Set<string>();
     for (const exported of project.checker.getExportsOfModule(module)) {
-      for (const id of chainOf(exported)) {
-        ids.add(id);
+      for (const target of chains.chainOf(exported)) {
+        ids.add(target.id);
       }
     }
     tables.set(file.fileName, [...ids]);

package/src/run.ts

@@ -9,7 +9,7 @@ import {
 import type { Host } from "./host.ts";
 import { joinPath, resolvePath } from "./paths.ts";
 import { printConfig } from "./print.ts";
-import { resolve } from "./resolve.ts";
+import { resolve, resolveMatrix } from "./resolve.ts";
 import { readScope, ScopeError, scopeForDir, type Scope } from "./scope.ts";
 import { diagnosticsOf, openEngine, runSession, type Engine } from "./session.ts";
 import { CONTRACT_VERSION } from "./version.ts";
@@ -245,8 +245,10 @@ function printConfigVerb(args: readonly string[], out: Writer, err: Writer, host
 }
 
 /**
- * Writes the compiler configuration of every project one run analyzes, one per
- * line, in discovery order, having read each project's diagnostics first.
+ * Writes the name of every project one run analyzes, one per line, having read each
+ * project's diagnostics first: the identifier the build matrix declares for it, or,
+ * where discovery derived the project, its configuration file's path below the
+ * target root.
  */
 function printProjectsVerb(
   args: readonly string[],
@@ -258,14 +260,16 @@ function printProjectsVerb(
   let engine: Engine | undefined;
   try {
     const options = readOptions(args);
+    const matrix = resolveMatrix(inputsOf(host, options));
     const scope = scopeOf(host, options);
     engine = openClient(false);
-    const discovered = discoverProjects(engine, host, scope);
+    const discovered = discoverProjects(engine, host, scope, matrix);
+    const ids = new Map(discovered.projects.map((project) => [project.configFile, project.id]));
     const failures: string[] = [];
     const { projects } = runSession(engine, discovered.configFiles, (project) => {
       const errors = diagnosticErrors(diagnosticsOf(project));
       failures.push(...errors.map(renderDiagnostic));
-      return project.configFile;
+      return ids.get(project.configFile) ?? project.configFile;
     });
     if (failures.length > 0) {
       for (const line of failures) {
@@ -274,8 +278,8 @@ function printProjectsVerb(
       err.write(`deadset-ts: ${String(failures.length)} error(s); no answer was produced\n`);
       return EXIT_FAILURE;
     }
-    for (const configFile of projects) {
-      out.write(`${configFile}\n`);
+    for (const id of projects) {
+      out.write(`${id}\n`);
     }
     return EXIT_CLEAN;
   } catch (error: unknown) {

package/src/schema.ts

@@ -8,7 +8,10 @@ import { ConfigError } from "./config.ts";
  *   holds no value of its own.
  * - `map` is an object whose member names the key list leaves open, its values
  *   scalars: the severity and provenance objects.
- * - `list` is an array whose entries are objects with declared members.
+ * - `list` is an array whose entries are objects with declared members. Where
+ *   the key list admits an entry in more than one shape, the members are every
+ *   shape's together, and which of them one entry may hold is the decoder's
+ *   refusal, not the walk's.
  * - `object` is one setting written as an object: its member names are declared
  *   and a source supplies the object whole.
  */
@@ -44,7 +47,7 @@ export const SCHEMA_ROOT: KeyNode = {
         consumer_tests: leaf,
         configurations: {
           kind: "list",
-          members: { id: leaf, os: leaf, arch: leaf, tags: leaf },
+          members: { id: leaf, os: leaf, arch: leaf, tags: leaf, project: leaf },
         },
         matrix: { kind: "section", members: { complete: leaf } },
         template_dirs: leaf,

package/src/session.ts

@@ -12,6 +12,7 @@ import type {
 } from "@typescript/native/unstable/sync";
 import { isIdentifier } from "@typescript/native/unstable/ast";
 import type { Node, SourceFile } from "@typescript/native/unstable/ast";
+import { DiscoveryError } from "./discover.ts";
 
 /**
  * The compiler the analysis reads through. It is a client over a protocol to a
@@ -218,13 +219,16 @@ export interface SessionResult<Result> {
 
 /**
  * Runs `visit` over every project the compiler configurations name, inside one
- * snapshot of one client.
+ * snapshot of one client, in the order they are named, and answers in that order.
  *
  * The snapshot is opened once with every configuration, so each becomes a project
  * with its own program and checker; it is never updated, because the analysis
- * reads and the tree does not change under it. It is disposed once when the last
- * project has been visited, and the client is released after it, whether the visit
- * completed or threw.
+ * reads and the tree does not change under it. The order the snapshot lists its
+ * projects in is the compiler's own, so each named configuration is looked up in it
+ * instead, and a configuration the snapshot opened no project for ends the run: the
+ * run would otherwise answer for fewer projects than it was asked to analyze. The
+ * snapshot is disposed once when the last project has been visited, and the client
+ * is released after it, whether the visit completed or threw.
  */
 export function runSession<Result>(
   engine: Engine,
@@ -234,7 +238,16 @@ export function runSession<Result>(
   try {
     const snapshot = engine.updateSnapshot(configFiles);
     try {
-      const projects = snapshot.getProjects().map((project) => visit(viewOf(project)));
+      const opened = new Map(
+        snapshot.getProjects().map((project) => [project.configFileName, project]),
+      );
+      const projects = configFiles.map((configFile) => {
+        const project = opened.get(configFile);
+        if (project === undefined) {
+          throw new DiscoveryError(`${configFile} opened no project`, []);
+        }
+        return visit(viewOf(project));
+      });
       return { projects, timing: engine.getTimingInfo() };
     } finally {
       snapshot.dispose();

package/src/sweep.ts

@@ -0,0 +1,224 @@
+/**
+ * Which declarations of one graph are dead, and under which liveness relation.
+ * Reference counting holds a declaration live when any declaration references it,
+ * whatever that one's own liveness, or when it is a root of a kind that names a caller;
+ * reachability holds it live when a path of references reaches it from a root. So a
+ * declaration only unreachable ones reference is live under the first, dead under the second.
+ */
+
+import { namesACaller, OUTSIDE, type Graph } from "./graph.ts";
+
+/** The liveness relation that decided a declaration, as a finding spells it. */
+export type Relation = "reference-counting" | "reachability";
+
+/**
+ * The run's reference mode, decided once by the composition and read by every stage
+ * that counts references.
+ */
+export interface Mode {
+  /**
+   * Counts no reference a test file made, under either relation. Every reference a root
+   * in a test file makes is such a reference, so nothing only a test reaches is live.
+   */
+  readonly production: boolean;
+}
+
+/** What one sweep runs over besides the graph. */
+export interface SweepInput {
+  /**
+   * The declarations a matched suppression names. A mark holds its declaration live
+   * under both relations and seeds reachability through every reference it makes, so
+   * nothing only a marked declaration references is dead.
+   */
+  readonly marked: readonly string[];
+  readonly mode: Mode;
+}
+
+/** One dead declaration, the relation that found it, and the counts a kind reads. */
+export interface Candidate {
+  readonly id: string;
+  /** The references a production file made to the declaration, whatever the mode counts. */
+  readonly productionRefs: number;
+  /** The references a test file made to it. */
+  readonly testRefs: number;
+  /**
+   * Reference counting where the mode counts no reference to the declaration, and
+   * reachability otherwise, so a declaration dead under both carries the stronger claim.
+   */
+  readonly relation: Relation;
+  /**
+   * Whether the test-of-dead-code rule admitted the declaration: a test declaration whose
+   * set of referenced production declarations is non-empty and wholly dead.
+   */
+  readonly testOfDeadCode: boolean;
+}
+
+/** One graph's answer: what each relation holds live, and what is dead. */
+export interface Liveness {
+  /**
+   * Per declaration, the relations that hold it live, reference counting first. A
+   * declaration neither holds live has no entry.
+   */
+  readonly liveUnder: ReadonlyMap<string, readonly Relation[]>;
+  /** The dead declarations, in the order the inventory holds them. */
+  readonly candidates: readonly Candidate[];
+}
+
+/**
+ * Answers which declarations of one graph are dead under the input's mode.
+ *
+ * The order is the order the answers depend on: the callers and the marks are live
+ * before either relation runs, the candidate set is every judged declaration at least
+ * one relation does not hold live, and the tests of dead code join it.
+ */
+export function sweep(graph: Graph, input: SweepInput): Liveness {
+  const marked = graph.symbols.map(() => false);
+  for (const id of input.marked) {
+    const at = graph.at(id);
+    if (at !== OUTSIDE) {
+      marked[at] = true;
+    }
+  }
+  // Every root and every mark seeds reachability. A root of a kind that names a caller,
+  // and a mark, are live under reference counting as well; a root that only supposes a
+  // caller is not.
+  const called = graph.symbols.map(() => false);
+  for (const root of graph.rooted) {
+    if (namesACaller(root.kind)) {
+      called[root.at] = true;
+    }
+  }
+
+  const counted = (at: number): number => {
+    const made = graph.made[at];
+    if (made === undefined) {
+      return 0;
+    }
+    return input.mode.production ? made.production : made.production + made.test;
+  };
+  const reached = reachable(graph, marked, input.mode);
+  const liveUnder = graph.symbols.map((_symbol, at): readonly Relation[] => {
+    const relations: Relation[] = [];
+    if (marked[at] === true || called[at] === true || counted(at) > 0) {
+      relations.push("reference-counting");
+    }
+    if (reached[at] === true) {
+      relations.push("reachability");
+    }
+    return relations;
+  });
+
+  const dead = graph.symbols.map(
+    (_symbol, at) => graph.subject[at] === true && (liveUnder[at]?.length ?? 0) < 2,
+  );
+  const testOfDeadCode = admitTestsOfDeadCode(graph, dead, marked);
+
+  const candidates: Candidate[] = [];
+  const live = new Map<string, readonly Relation[]>();
+  graph.symbols.forEach((symbol, at) => {
+    const relations = liveUnder[at] ?? [];
+    if (relations.length > 0) {
+      live.set(symbol.id, relations);
+    }
+    if (dead[at] !== true) {
+      return;
+    }
+    candidates.push({
+      id: symbol.id,
+      productionRefs: graph.made[at]?.production ?? 0,
+      testRefs: graph.made[at]?.test ?? 0,
+      relation: counted(at) === 0 ? "reference-counting" : "reachability",
+      testOfDeadCode: testOfDeadCode[at] === true,
+    });
+  });
+
+  return { liveUnder: live, candidates };
+}
+
+/**
+ * Per declaration, whether a seed reaches it. The two seeds reach through different
+ * reference sets: a marked declaration is live by a mechanism the analysis cannot see, so
+ * no mode withholds a reference it makes, while a root reaches through the references the
+ * mode counts. The marks run first, so what they reach is expanded under the wider rule.
+ */
+function reachable(graph: Graph, marked: readonly boolean[], mode: Mode): readonly boolean[] {
+  const reached = graph.symbols.map(() => false);
+  const expanded = graph.symbols.map(() => false);
+  const queue: number[] = [];
+
+  // Reaching a file reaches its top level: the references written outside every
+  // declaration it holds. A reference that reads a file reads the module's namespace,
+  // which reaches what the module exports as well. An evaluation runs the top level
+  // and reads no export, and a root does not expand either: a file a runtime runs
+  // without reading its exports is a root by itself.
+  const enter = (at: number, expands: boolean): void => {
+    if (!reached[at]) {
+      reached[at] = true;
+      queue.push(at);
+    }
+    if (!expands || expanded[at] === true) {
+      return;
+    }
+    expanded[at] = true;
+    for (const exported of graph.exportsOf[at] ?? []) {
+      enter(exported, false);
+    }
+  };
+  const walk = (held: boolean): void => {
+    for (let at = queue.pop(); at !== undefined; at = queue.pop()) {
+      for (const edge of graph.out[at] ?? []) {
+        if (!held && mode.production && edge.test) {
+          continue;
+        }
+        enter(edge.to, !edge.evaluation);
+      }
+    }
+  };
+
+  marked.forEach((mark, at) => {
+    if (mark) {
+      enter(at, false);
+    }
+  });
+  walk(true);
+  for (const root of graph.rooted) {
+    enter(root.at, false);
+  }
+  walk(false);
+  return reached;
+}
+
+/**
+ * Admits every test declaration whose set of referenced production declarations is
+ * non-empty and wholly dead, and returns which it admitted. The set is read from every
+ * reference the test makes, not the ones the mode counts: a production sweep counts none,
+ * which is what makes the targets dead. A test referencing one live target is never admitted.
+ */
+function admitTestsOfDeadCode(
+  graph: Graph,
+  dead: boolean[],
+  marked: readonly boolean[],
+): readonly boolean[] {
+  const admitted = graph.symbols.map(() => false);
+  graph.symbols.forEach((_symbol, at) => {
+    if (graph.test[at] !== true || graph.subject[at] !== true || marked[at] === true) {
+      return;
+    }
+    let targets = 0;
+    let live = 0;
+    for (const edge of graph.out[at] ?? []) {
+      if (graph.test[edge.to] === true || graph.subject[edge.to] !== true) {
+        continue;
+      }
+      targets += 1;
+      if (dead[edge.to] !== true) {
+        live += 1;
+      }
+    }
+    if (targets > 0 && live === 0) {
+      dead[at] = true;
+      admitted[at] = true;
+    }
+  });
+  return admitted;
+}

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 = "2.1.0";
+export const CONTRACT_VERSION = "2.2.0";