@cplieger/deadset-ts 2.2.1 → 3.0.0

package/src/source-files.ts

@@ -0,0 +1,157 @@
+/**
+ * The target's own source files of one project, looked up the ways a path written
+ * in a document or a string names one: as the file itself, or as a file the
+ * compiler emits from it.
+ */
+
+import type { SourceFile } from "@typescript/native/unstable/ast";
+import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.ts";
+import type { ProjectView } from "./session.ts";
+
+/** The source extensions the compiler emits each output extension from. */
+const EMITTED: readonly { readonly emitted: string; readonly sources: readonly string[] }[] = [
+  { emitted: ".d.ts", sources: [".ts", ".tsx"] },
+  { emitted: ".d.mts", sources: [".mts"] },
+  { emitted: ".d.cts", sources: [".cts"] },
+  { emitted: ".js", sources: [".ts", ".tsx"] },
+  { emitted: ".jsx", sources: [".tsx"] },
+  { emitted: ".mjs", sources: [".mts"] },
+  { emitted: ".cjs", sources: [".cts"] },
+];
+
+/** The one character a subpath pattern of a manifest's `exports` holds. */
+const SUBPATH_WILDCARD = "*";
+
+/** One path with its extension replaced, where it carries the one named. */
+function reExtended(path: string, emitted: string, source: string): string | undefined {
+  return path.endsWith(emitted) ? path.slice(0, path.length - emitted.length) + source : undefined;
+}
+
+/**
+ * The longest directory every path shares, which is the directory the compiler
+ * emits from where the configuration declares no root directory.
+ */
+function commonDirectory(paths: readonly string[]): string {
+  const first = paths[0];
+  if (first === undefined) {
+    return "";
+  }
+  let common = dirnamePath(first).split("/");
+  for (const path of paths.slice(1)) {
+    const segments = dirnamePath(path).split("/");
+    let shared = 0;
+    while (
+      shared < common.length &&
+      shared < segments.length &&
+      common[shared] === segments[shared]
+    ) {
+      shared += 1;
+    }
+    common = common.slice(0, shared);
+  }
+  return common.join("/");
+}
+
+/**
+ * Whether one path is what a subpath pattern stands for: the text before the
+ * wildcard, any run of characters including the solidus, then the text after it.
+ */
+function matchesSubpath(pattern: string, path: string): boolean {
+  const at = pattern.indexOf(SUBPATH_WILDCARD);
+  const before = pattern.slice(0, at);
+  const after = pattern.slice(at + SUBPATH_WILDCARD.length);
+  return (
+    path.length >= before.length + after.length && path.startsWith(before) && path.endsWith(after)
+  );
+}
+
+/** One project's own source files, and the lookups a written path is resolved through. */
+export interface SourceFiles {
+  /** Every own file, by its path below the target root, in the order the program holds them. */
+  readonly byPath: ReadonlyMap<string, SourceFile>;
+  /** Every own file, by the absolute path the program names it by. */
+  readonly byName: ReadonlyMap<string, SourceFile>;
+  /**
+   * The own files one absolute path names: the file at that path, or the source the
+   * project would emit a file at that path from. A path holding the wildcard of a
+   * subpath pattern names every file it stands for. A path no rule reaches names
+   * nothing.
+   */
+  named(path: string): readonly SourceFile[];
+}
+
+/**
+ * The lookups over one project's own files.
+ *
+ * A path that names an emitted file is read back to the source the project would
+ * emit it from through the project's own emit mapping and nothing else: the
+ * extension is one the compiler emits from a source extension, and a path below the
+ * output directory is read below the directory the compiler emits from, which the
+ * configuration declares or which is the directory every input file shares.
+ */
+export function sourceFilesOf<Brand>(project: ProjectView<Brand>, targetRoot: string): SourceFiles {
+  const byName = new Map<string, SourceFile>();
+  const byPath = new Map<string, SourceFile>();
+  for (const file of project.ownSourceFiles()) {
+    byName.set(file.fileName, file);
+    const path = relativePath(targetRoot, file.fileName);
+    if (path !== undefined) {
+      byPath.set(path, file);
+    }
+  }
+
+  const options = project.program.getCompilerOptions();
+  const configDir = dirnamePath(project.configFile);
+  const at = (option: string | undefined): string | undefined =>
+    option === undefined ? undefined : resolvePath(configDir, option);
+  const outDir = at(options.outDir);
+  const declarationDir = at(options.declarationDir);
+  const sourceDir = at(options.rootDir) ?? commonDirectory([...byName.keys()]);
+
+  /** One path read below the directory the compiler emits from, where it is below the one it emits to. */
+  const fromEmit = (path: string, emitted: string): string | undefined => {
+    const emitDir = emitted.startsWith(".d.") ? (declarationDir ?? outDir) : outDir;
+    if (emitDir === undefined) {
+      return undefined;
+    }
+    const below = relativePath(emitDir, path);
+    return below === undefined ? undefined : joinPath(sourceDir, below);
+  };
+
+  /** The source paths one written path may stand for, the path itself first. */
+  const candidates = (path: string): readonly string[] => {
+    const found = [path];
+    for (const { emitted, sources } of EMITTED) {
+      const mapped = fromEmit(path, emitted);
+      for (const source of sources) {
+        for (const from of [path, mapped]) {
+          const candidate = from === undefined ? undefined : reExtended(from, emitted, source);
+          if (candidate !== undefined) {
+            found.push(candidate);
+          }
+        }
+      }
+    }
+    return found;
+  };
+
+  return {
+    byPath,
+    byName,
+    named: (path) => {
+      if (!path.includes(SUBPATH_WILDCARD)) {
+        for (const candidate of candidates(path)) {
+          const held = byName.get(candidate);
+          if (held !== undefined) {
+            return [held];
+          }
+        }
+        return [];
+      }
+      const patterns = candidates(path).filter((candidate) => candidate.includes(SUBPATH_WILDCARD));
+      return [...byName.values()].filter((file) =>
+        patterns.some((pattern) => matchesSubpath(pattern, file.fileName)),
+      );
+    },
+  };
+}

package/src/sweep.ts

@@ -0,0 +1,230 @@
+/**
+ * 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;
+ * 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. */
+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 sweep's answer. */
+export interface SweepResult {
+  /**
+   * 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[];
+  /** The dead components, each before every component it reaches. */
+  readonly components: readonly Component[];
+}
+
+/**
+ * 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, the tests of dead code join it, and the components
+ * are computed over the set that results.
+ */
+export function sweep(graph: Graph, input: SweepInput): SweepResult {
+  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,
+    components: componentsOf(graph, dead, testOfDeadCode),
+  };
+}
+
+/**
+ * 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[] = [];
+
+  // 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 => {
+    if (!reached[at]) {
+      reached[at] = true;
+      queue.push(at);
+    }
+    if (!viaReference || 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, true);
+      }
+    }
+  };
+
+  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";