@cplieger/deadset-ts 8.0.0-dev.16 → 8.0.0-dev.18

package/dist/src/verbs/explain.js

@@ -1,11 +1,11 @@
 import { EXIT_CLEAN, EXIT_USAGE } from "../contract/contract.generated.js";
-import { runAnalysis } from "../analysis.js";
-import { listing } from "../components.js";
-import { OUTSIDE, swept as judged } from "../graph.js";
-import { referenceKey } from "../matrix.js";
+import { productionMode, runAnalysis } from "../analysis.js";
+import { listing } from "../liveness/components.js";
+import { swept as judged } from "../liveness/graph.js";
 import { partialNotes } from "../partial.js";
 import { resolvePath } from "../paths.js";
 import { positionKey } from "../position.js";
+import { madeByTestCode } from "../tests/file-class.js";
 import { resolve } from "../resolve.js";
 import {} from "./verb.js";
 import { UsageError } from "../usage.js";
@@ -79,150 +79,94 @@ function subjectOf(symbols, named) {
         .sort(bytewise);
     return { candidates: partial.slice(0, MAX_PARTIAL_MATCHES) };
 }
-/** Every reference of the run once, a reference several configurations make counted once. */
-function referencesOf(configured) {
-    const seen = new Set();
-    const held = [];
-    for (const reference of configured.flatMap((one) => one.references)) {
-        const key = referenceKey(reference);
-        if (!seen.has(key)) {
-            seen.add(key);
-            held.push(reference);
-        }
-    }
-    return held;
-}
-/** Every root of the run once per reason, in the order the projects name them. */
-function rootsOf(configured) {
-    const seen = new Set();
-    return configured
-        .flatMap((one) => one.roots)
-        .filter((root) => {
-        const key = [root.id, root.kind, root.source].join("\u0000");
-        if (seen.has(key)) {
-            return false;
-        }
-        seen.add(key);
-        return true;
-    });
-}
-/**
- * The shortest path from a root or a loaded consumer to one declaration, walked breadth first
- * from every root at once in the order the run names them, a consumer's reference being the
- * first hop of a path of its own, and following the references the sweep follows: a
- * reference that reads a module reaches what the module exports, and an evaluation or a root
- * reaches the module alone. Under `production` no reference a test file made is followed,
- * which is the set the report's sweep counts.
- */
-function shortestPath(analysis, to, production) {
-    const graph = analysis.swept.matrix.union;
-    const out = new Map();
-    const consumed = [];
-    for (const reference of referencesOf(analysis.configured)) {
-        if (production && reference.test) {
-            continue;
-        }
-        const { consumer } = reference;
-        if (consumer !== undefined) {
-            consumed.push({ ...reference, consumer });
-            continue;
-        }
-        const held = out.get(reference.from);
-        if (held === undefined) {
-            out.set(reference.from, [reference]);
-        }
-        else {
-            held.push(reference);
-        }
-    }
-    const steps = [];
-    const seen = new Set();
-    const expanded = new Set();
-    const enter = (step) => {
-        if (!seen.has(step.at)) {
-            seen.add(step.at);
-            steps.push(step);
-        }
-    };
-    const follow = (reference, previous, origin) => {
-        enter({ at: reference.to, hop: { k: "reference", reference }, previous, origin });
-        const target = graph.at(reference.to);
-        if (reference.use === "evaluation" || target === OUTSIDE || expanded.has(reference.to)) {
-            return;
-        }
-        expanded.add(reference.to);
-        for (const exported of graph.exportsOf[target] ?? []) {
-            const id = graph.symbols[exported]?.id;
-            if (id !== undefined) {
-                enter({ at: id, hop: { k: "export", reference, to: id }, previous, origin });
-            }
-        }
-    };
-    for (const root of rootsOf(analysis.configured)) {
-        enter({ at: root.id, hop: undefined, previous: -1, origin: { k: "root", root } });
-    }
-    // A consumer's reference is one hop long, so it joins the walk where the roots' first
-    // hops do.
-    const firstHops = steps.length;
-    for (let head = 0;; head += 1) {
-        if (head === firstHops) {
-            for (const reference of consumed) {
-                follow(reference, -1, { k: "consumer", consumer: reference.consumer });
+/** Where a path starts, as a line names it. */
+function originText(origin, graph) {
+    const id = (at) => graph.symbols[at]?.id ?? "";
+    switch (origin.k) {
+        case "root":
+            return `root ${origin.rooted.kind} ${id(origin.rooted.at)}`;
+        case "consumed": {
+            const reference = graph.references[origin.edge.reference];
+            if (reference?.consumer !== undefined) {
+                return `consumer ${reference.consumer}`;
             }
+            return reference?.unheld === true
+                ? `test file no project holds ${reference.from.replace(/#$/u, "")}`
+                : `declaration no configuration judges ${reference?.from ?? ""}`;
         }
-        const step = steps[head];
-        if (step === undefined) {
-            break;
-        }
-        if (step.at === to) {
-            const path = [];
-            for (let at = step; at?.hop !== undefined; at = steps[at.previous]) {
-                path.unshift(at.hop);
-            }
-            return { origin: step.origin, path };
-        }
-        for (const reference of out.get(step.at) ?? []) {
-            follow(reference, head, step.origin);
-        }
+        case "exemption":
+            return `exemption ${origin.record.class} ${positionKey(origin.record.site)}`;
+        case "mark":
+            return `suppression of ${id(origin.at)}`;
+        case "unanswered":
+            return `unanswered question about ${id(origin.at)}`;
     }
-    return undefined;
 }
 /** What made a reference: a declaration of the target, or a loaded consumer. */
 function madeBy(reference) {
     return reference.consumer === undefined ? reference.from : `consumer ${reference.consumer}`;
 }
-function referenceLine(reference, tail) {
-    return `  reference: ${positionKey(reference.position)}\t${reference.use}\t${tail}${reference.test ? "\tfrom a test file" : ""}\n`;
+/**
+ * One reference of an answer, marked where test code made it, a test-support file's included,
+ * and naming the configurations that make it where they are not every one of the run.
+ */
+function referenceLine(reference, tail, support, configurations) {
+    const partial = configurations.making.length < configurations.run.length;
+    return `  reference: ${positionKey(reference.position)}\t${reference.use}\t${tail}${madeByTestCode(reference, support) ? "\tfrom a test file" : ""}${partial ? `\tmade in ${configurations.making.join(" ")}` : ""}\n`;
 }
 /** Why a declaration no finding names and no exemption held back is live, or how it fell. */
 function liveness(analysis, subject, cascade) {
-    const { sweep } = analysis.swept;
+    const { matrix, sweep } = analysis.swept;
+    const graph = matrix.union;
     const candidate = sweep.candidates.find((one) => one.id === subject.id);
     if (candidate === undefined && !judged(subject.kind)) {
         return `answer: unjudged\n  unjudged: neither liveness relation judges a ${subject.kind}\n`;
     }
     let text = `answer: ${candidate === undefined ? "live" : "dead"}\n`;
     text += `  live under: ${listed(sweep.liveUnder.get(subject.id) ?? [])}\n`;
-    for (const root of rootsOf(analysis.configured).filter((one) => one.id === subject.id)) {
-        text += `  root: ${root.kind}${root.source === "" ? "" : `\tnamed by ${root.source}`}\n`;
+    const at = graph.at(subject.id);
+    const seen = new Set();
+    for (const root of graph.rooted.filter((one) => one.at === at)) {
+        const key = `${root.kind}\u0000${root.source}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            text += `  root: ${root.kind}${root.source === "" ? "" : `\tnamed by ${root.source}`}\n`;
+        }
     }
-    const found = shortestPath(analysis, subject.id, true) ?? shortestPath(analysis, subject.id, false);
-    if (found !== undefined && found.path.length > 0) {
-        const { origin } = found;
-        text += `  reached from: ${origin.k === "root" ? `root ${origin.root.kind} ${origin.root.id}` : `consumer ${origin.consumer}`}\n`;
-        for (const hop of found.path) {
-            text += referenceLine(hop.reference, `${madeBy(hop.reference)} -> ${hop.reference.to}`);
+    const support = new Set(analysis.configured.flatMap((one) => one.supportFiles ?? []));
+    const line = (edge, tail) => {
+        const reference = graph.references[edge.reference];
+        return reference === undefined
+            ? ""
+            : referenceLine(reference, tail(reference), support, {
+                making: graph.configurations[edge.reference] ?? [],
+                run: matrix.configurations,
+            });
+    };
+    const found = sweep.path(subject.id);
+    if (found !== undefined && found.hops.length > 0) {
+        text += `  reached from: ${originText(found.origin, graph)}\n`;
+        for (const hop of found.hops) {
+            text += line(hop.edge, (reference) => `${madeBy(reference)} -> ${reference.to}`);
             if (hop.k === "export") {
-                text += `  export: ${hop.reference.to} -> ${hop.to}\n`;
+                const reference = graph.references[hop.edge.reference];
+                text += `  export: ${reference?.to ?? ""} -> ${graph.symbols[hop.to]?.id ?? ""}\n`;
             }
         }
     }
     else if (found === undefined) {
-        const references = referencesOf(analysis.configured).filter((one) => one.to === subject.id);
-        text += "  unreachable: no path of references reaches it from a root or a loaded consumer\n";
+        const references = graph.references.flatMap((one, place) => one.to === subject.id ? [place] : []);
+        text +=
+            "  unreachable: no path of references reaches it from a root, a loaded consumer or a test file no project holds\n";
         text += `  references: ${String(references.length)}\n`;
-        for (const reference of references) {
-            text += referenceLine(reference, `from ${madeBy(reference)}`);
+        for (const place of references) {
+            const reference = graph.references[place];
+            if (reference !== undefined) {
+                text += referenceLine(reference, `from ${madeBy(reference)}`, support, {
+                    making: graph.configurations[place] ?? [],
+                    run: matrix.configurations,
+                });
+            }
         }
     }
     if (candidate !== undefined) {
@@ -279,7 +223,7 @@ function explanation(analysis, subject, cascade) {
     text += `position: ${subject.id}\n`;
     text += `configurations: ${listed(analysis.swept.matrix.heldIn[at] ?? [])}\n`;
     const found = analysis.result.findings.find((one) => positionKey(one.position) === subject.id);
-    const retained = analysis.swept.retained.filter((one) => one.id === subject.id);
+    const retained = analysis.swept.sweep.retained.filter((one) => one.id === subject.id);
     if (found !== undefined) {
         text += reported(found);
     }
@@ -289,7 +233,7 @@ function explanation(analysis, subject, cascade) {
             text += `  class: ${one.class}\t${positionKey(one.site)}\t${one.detail}\n`;
         }
     }
-    else if (analysis.swept.heldByUnanswered.includes(subject.id)) {
+    else if (analysis.swept.sweep.held.includes(subject.id)) {
         text +=
             "answer: held\n  held by: a question the checker did not answer, which could have kept it live, so no finding names it\n";
     }
@@ -301,18 +245,17 @@ function explanation(analysis, subject, cascade) {
 /**
  * Explains one symbol from the analysis the report is built from: why a reported symbol is
  * reported, which exemption classes held a retained one back, that an unanswered question held
- * a held one, and for any other declaration the relations that hold it live and the shortest
- * path from a root or a loaded consumer, or the references it has where no path reaches it. A
- * request naming no one declaration exits with the usage code and names what partially
+ * a held one, and for any other declaration the relations that hold it live and the path the
+ * sweep's strongest tier reaching it follows, or the references it has where no path reaches
+ * it. A request naming no one declaration exits with the usage code and names what partially
  * matches it. Where the analysis was partial, the error stream says so.
  */
 export const explainVerb = ({ out, err, host, inputs, scope, openClient, option }) => {
     const named = namedSymbol(option);
     const { config, provenance } = resolve(inputs());
     const scoped = scope();
-    const analysis = runAnalysis(openClient(config), host, scoped, config, provenance, {
-        production: true,
-    });
+    const mode = productionMode(config);
+    const analysis = runAnalysis(openClient(config), host, scoped, config, provenance, mode);
     const { subject, candidates } = subjectOf(analysis.swept.matrix.union.symbols, named);
     const notes = partialNotes({
         notBuilt: analysis.run.notBuilt,

package/dist/src/verbs/print-retained.js

@@ -1,5 +1,5 @@
 import { EXIT_CLEAN } from "../contract/contract.generated.js";
-import { runSweep } from "../analysis.js";
+import { productionMode, runSweep } from "../analysis.js";
 import { retainedLines } from "../exempt.js";
 import { partialNotes } from "../partial.js";
 import { resolvePath } from "../paths.js";
@@ -18,9 +18,9 @@ export const printRetainedVerb = ({ out, err, host, inputs, scope, openClient })
     const scoped = scope();
     const swept = runSweep(openClient(config), host, scoped, config, {
         marked: [],
-        mode: { production: true },
+        mode: productionMode(config),
     });
-    for (const line of retainedLines(swept.matrix.union.symbols, swept.retained)) {
+    for (const line of retainedLines(swept.matrix.union.symbols, swept.sweep.retained)) {
         out.write(`${line}\n`);
     }
     for (const note of partialNotes({

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "8.0.0-dev.16",
+  "version": "8.0.0-dev.18",
   "license": "GPL-3.0-or-later",
   "exports": {
     ".": "./src/index.ts"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "8.0.0-dev.16",
+  "version": "8.0.0-dev.18",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",
@@ -48,7 +48,7 @@
     "prettier": "3.9.10",
     "typescript": "npm:@typescript/typescript6@6.0.2",
     "typescript-eslint": "8.72.1",
-    "vitest": "5.0.5"
+    "vitest": "5.1.0"
   },
   "publishConfig": {
     "access": "public"

package/src/alias-chain.ts

@@ -49,8 +49,6 @@ export interface AliasChains {
    * link is declared.
    */
   nextDeclared(symbol: TSSymbol): readonly ChainTarget[];
-  /** How many steps the compiler was asked for: one per alias, whatever the chains it heads. */
-  readonly steps: number;
 }
 
 /**
@@ -65,7 +63,6 @@ export function aliasChains<Brand>(project: ProjectView<Brand>, held: Inventory)
   const ownFiles = project.ownPaths();
   const steps = new Map<number, Answer<TSSymbol | undefined>>();
   const chains = new Map<number, readonly ChainTarget[]>();
-  let asked = 0;
 
   const declarationsOf = (symbol: TSSymbol): string[] => {
     const ids: string[] = [];
@@ -102,7 +99,6 @@ export function aliasChains<Brand>(project: ProjectView<Brand>, held: Inventory)
       return steps.get(symbol.id);
     }
     const next = project.aliasStepOf(symbol);
-    asked += 1;
     steps.set(symbol.id, next);
     return next;
   };
@@ -197,8 +193,5 @@ export function aliasChains<Brand>(project: ProjectView<Brand>, held: Inventory)
     declarationsOf,
     chainOf,
     nextDeclared,
-    get steps() {
-      return asked;
-    },
   };
 }

package/src/amd.ts

@@ -0,0 +1,130 @@
+/**
+ * AMD's module forms (references-ts.37), read from the syntax because the binder declares
+ * none of them: `define([<ids>], factory)`, `define("<name>", [<ids>], factory)` and
+ * `require([<ids>], callback)` (https://github.com/amdjs/amdjs-api/blob/master/AMD.md).
+ */
+
+import {
+  isArrayLiteralExpression,
+  isArrowFunction,
+  isFunctionExpression,
+  isCallExpression,
+  isIdentifier,
+  isNoSubstitutionTemplateLiteral,
+  isStringLiteral,
+  type Identifier,
+  type Node,
+  type StringLiteralLikeNode,
+} from "@typescript/native/ast";
+import { hasURLScheme, isAbsolutePath, resolvePath, startsRelativePath } from "./paths.ts";
+import { parenthesesRemoved } from "./unwrap.ts";
+
+/** The platform function an AMD call is written as. */
+type AmdPlatform = "define" | "require";
+
+/** One AMD call's dependency list. */
+export interface AmdLoad {
+  /** The name the call is written with; {@link callsPlatform} owns whether it is AMD's. */
+  readonly callee: Identifier;
+  /** Each dependency id written as literal text, AMD's own `require`, `exports` and `module` left out. */
+  readonly ids: readonly AmdDependency[];
+  /** Whether the list, or an element of it, is computed, so the call may load any module. */
+  readonly computed: boolean;
+}
+
+/** One dependency id of an AMD call. */
+interface AmdDependency {
+  readonly id: StringLiteralLikeNode;
+  /**
+   * Whether the factory may receive the module's value: it declares a parameter at the id's
+   * place, a rest parameter included, or it is written as anything but a function.
+   */
+  readonly received: boolean;
+}
+
+/** The ids AMD binds to the factory's CommonJS parameters, which load no module. */
+const FREE_VARIABLES: ReadonlySet<string> = new Set(["require", "exports", "module"]);
+
+/** The platform function `callee` is written as. */
+export function amdPlatform(callee: Identifier): AmdPlatform {
+  return callee.text === "define" ? "define" : "require";
+}
+
+/**
+ * The dependency list one call writes, where it is a call of a bare `define` or `require` in
+ * one of AMD's forms. A `define` with no list, of a factory or a value alone, loads nothing;
+ * a `require` whose first argument is no array literal is CommonJS's.
+ */
+export function amdLoadOf(node: Node): AmdLoad | undefined {
+  if (!isCallExpression(node)) {
+    return undefined;
+  }
+  const callee = parenthesesRemoved(node.expression);
+  if (!isIdentifier(callee) || (callee.text !== "define" && callee.text !== "require")) {
+    return undefined;
+  }
+  const written = node.arguments.map((one) => parenthesesRemoved(one));
+  const [first] = written;
+  if (first === undefined) {
+    return undefined;
+  }
+  const define = callee.text === "define";
+  const named = define && isLiteralText(first);
+  const list = written[named ? 1 : 0];
+  if (list !== undefined && isArrayLiteralExpression(list)) {
+    const elements = list.elements.map((one) => parenthesesRemoved(one));
+    const factory = written[named ? 2 : 1];
+    const ids = elements.flatMap((one, at) =>
+      isLiteralText(one) && !FREE_VARIABLES.has(one.text)
+        ? [{ id: one, received: receives(factory, at) }]
+        : [],
+    );
+    return { callee, ids, computed: elements.some((one) => !isLiteralText(one)) };
+  }
+  if (!define) {
+    return undefined;
+  }
+  // A factory after the list's place makes what stands there a list, here a computed one.
+  return { callee, ids: [], computed: written.length > (named ? 2 : 1) };
+}
+
+function isLiteralText(node: Node): node is StringLiteralLikeNode {
+  return isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node);
+}
+
+/** Whether a factory may receive the dependency at place `at` of its list. */
+function receives(factory: Node | undefined, at: number): boolean {
+  if (factory === undefined) {
+    return false;
+  }
+  if (!isFunctionExpression(factory) && !isArrowFunction(factory)) {
+    return true;
+  }
+  const { parameters } = factory;
+  return at < parameters.length || parameters.some((one) => one.dotDotDotToken !== undefined);
+}
+
+/**
+ * The path a dependency id names against the calling file's directory: a relative module id,
+ * `./` or `../` with no `.js` ending, with `.js` appended. RequireJS reads any other id
+ * through its configuration or as a URL against the page, which the analysis does not know.
+ */
+export function amdPath(dir: string, id: string): string | undefined {
+  return startsRelativePath(id) && !id.endsWith(".js") ? resolvePath(dir, `${id}.js`) : undefined;
+}
+
+/**
+ * Whether one call may load a file the analysis cannot name: a computed list, or an id that
+ * RequireJS reads as a URL, one ending in `.js`, starting with `/` or carrying a scheme. Any
+ * other id {@link amdPath} reads no path from is a package's.
+ */
+export function amdUnresolved(load: AmdLoad): boolean {
+  return (
+    load.computed ||
+    load.ids.some(
+      ({ id }) =>
+        amdPath("/", id.text) === undefined &&
+        (id.text.endsWith(".js") || isAbsolutePath(id.text) || hasURLScheme(id.text)),
+    )
+  );
+}