@cplieger/deadset-ts 3.0.0 → 3.1.0

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

@@ -1,12 +1,11 @@
 /**
- * Which declarations of one graph are dead, under which liveness relation, and which
- * dead component each belongs to. Reference counting holds a declaration live when any
- * declaration references it, whatever that one's own liveness, and no root plays a part;
+ * 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 { componentsOf, type Component } from "./components.ts";
 import { namesACaller, OUTSIDE, type Graph } from "./graph.ts";
 
 /** The liveness relation that decided a declaration, as a finding spells it. */
@@ -54,8 +53,8 @@ export interface Candidate {
   readonly testOfDeadCode: boolean;
 }
 
-/** One sweep's answer. */
-export interface SweepResult {
+/** 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.
@@ -63,8 +62,6 @@ export interface SweepResult {
   readonly liveUnder: ReadonlyMap<string, readonly Relation[]>;
   /** The dead declarations, in the order the inventory holds them. */
   readonly candidates: readonly Candidate[];
-  /** The dead components, each before every component it reaches. */
-  readonly components: readonly Component[];
 }
 
 /**
@@ -72,10 +69,9 @@ export interface SweepResult {
  *
  * 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, the tests of dead code join it, and the components
- * are computed over the set that results.
+ * one relation does not hold live, and the tests of dead code join it.
  */
-export function sweep(graph: Graph, input: SweepInput): SweepResult {
+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);
@@ -136,11 +132,7 @@ export function sweep(graph: Graph, input: SweepInput): SweepResult {
     });
   });
 
-  return {
-    liveUnder: live,
-    candidates,
-    components: componentsOf(graph, dead, testOfDeadCode),
-  };
+  return { liveUnder: live, candidates };
 }
 
 /**
@@ -154,15 +146,17 @@ function reachable(graph: Graph, marked: readonly boolean[], mode: Mode): readon
   const expanded = graph.symbols.map(() => false);
   const queue: number[] = [];
 
-  // A reference to a file is a reference to the module's namespace, which reaches what
-  // the module exports as well as its top level. A root does not expand: a file a
-  // runtime runs without reading its exports is a root by itself.
-  const enter = (at: number, viaReference: boolean): void => {
+  // 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 (!viaReference || expanded[at] === true) {
+    if (!expands || expanded[at] === true) {
       return;
     }
     expanded[at] = true;
@@ -176,7 +170,7 @@ function reachable(graph: Graph, marked: readonly boolean[], mode: Mode): readon
         if (!held && mode.production && edge.test) {
           continue;
         }
-        enter(edge.to, true);
+        enter(edge.to, !edge.evaluation);
       }
     }
   };