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

package/dist/src/references/sink.js

@@ -13,12 +13,15 @@ export class Sink {
     #testFile;
     #consumer;
     #found = [];
+    #declaredAt;
     #valued = new Map();
+    #named = new Map();
     #held = new Set();
-    constructor(root, testFile, consumer) {
+    constructor(root, testFile, consumer, declaredAt) {
         this.#root = root;
         this.#testFile = testFile;
         this.#consumer = consumer;
+        this.#declaredAt = declaredAt;
     }
     /** Whether a test file wrote one walked file's uses. */
     isTest(file) {
@@ -47,6 +50,11 @@ export class Sink {
                 test,
                 ...(target.guessed === true ? { guessed: true } : {}),
             });
+            if (this.#consumer === undefined && !("column" in at)) {
+                const named = this.#named.get(file) ?? [];
+                named.push({ index: this.#found.length - 1, at, annotated: this.#annotates(at, from) });
+                this.#named.set(file, named);
+            }
             if (use === "write" && value !== undefined) {
                 const valued = this.#valued.get(file) ?? [];
                 valued.push({ index: this.#found.length - 1, value });
@@ -54,6 +62,26 @@ export class Sink {
             }
         }
     }
+    /**
+     * Whether a name sits in the annotation of `from`'s own declaration. An annotation holds
+     * no block, so the walk stops at the first declaration or block above the name.
+     */
+    #annotates(name, from) {
+        if (name.kind === SyntaxKind.SourceFile) {
+            return false;
+        }
+        let child = name;
+        let parent = name.parent;
+        while (parent.kind !== SyntaxKind.Block && parent.kind !== SyntaxKind.SourceFile) {
+            const id = this.#declaredAt(parent);
+            if (id !== undefined) {
+                return id === from && parent.type === child;
+            }
+            child = parent;
+            parent = parent.parent;
+        }
+        return false;
+    }
     /** Holds declarations an unanswered question could have made live, and the one whose read asked it. */
     hold(ids) {
         for (const id of ids) {
@@ -83,6 +111,14 @@ export class Sink {
                 }
             }
         }
+        for (const [file, named] of this.#named) {
+            for (const { index, carriers } of carriersIn(named, this.#valued.get(file) ?? [], found)) {
+                const reference = found[index];
+                if (reference !== undefined) {
+                    found[index] = { ...reference, carriers };
+                }
+            }
+        }
         found.sort((a, b) => byPosition(a.position, b.position) ||
             bytewise(a.to, b.to) ||
             bytewise(a.from, b.from) ||
@@ -149,3 +185,53 @@ function aloneIn(file, uses, writes, found) {
     }
     return result;
 }
+/**
+ * The carriers of each named record of one file: `from` where its own annotation holds the
+ * name, then the target of each write whose stored value holds it and that names another
+ * declaration, the innermost value first. Values nest or are disjoint.
+ */
+function carriersIn(named, writes, found) {
+    const byStart = [...named].sort((a, b) => a.at.pos - b.at.pos);
+    const holding = new Map();
+    for (const write of writes) {
+        let low = 0;
+        let high = byStart.length;
+        while (low < high) {
+            const middle = (low + high) >>> 1;
+            if ((byStart[middle]?.at.pos ?? 0) < write.value.pos) {
+                low = middle + 1;
+            }
+            else {
+                high = middle;
+            }
+        }
+        for (let at = low; at < byStart.length; at += 1) {
+            const one = byStart[at];
+            if (one === undefined || one.at.pos >= write.value.end) {
+                break;
+            }
+            if (one.at.end <= write.value.end) {
+                holding.set(one.index, [...(holding.get(one.index) ?? []), write]);
+            }
+        }
+    }
+    const result = [];
+    for (const one of named) {
+        const reference = found[one.index];
+        if (reference === undefined) {
+            continue;
+        }
+        const carriers = one.annotated ? [reference.from] : [];
+        const values = [...(holding.get(one.index) ?? [])].sort((a, b) => a.value.end - a.value.pos - (b.value.end - b.value.pos));
+        for (const write of values) {
+            const to = found[write.index]?.to;
+            if (to !== undefined && to !== reference.to && !carriers.includes(to)) {
+                carriers.push(to);
+            }
+        }
+        if (carriers.length > 0) {
+            result.push({ index: one.index, carriers });
+        }
+    }
+    return result;
+}

package/dist/src/references.js

@@ -49,10 +49,10 @@ export function references(project, held, targetRoot, options) {
             .ownSourceFiles()
             .filter((file) => relativePath(consumer.root, file.fileName) !== undefined &&
             relativePath(targetRoot, file.fileName) === undefined);
-    const sink = new Sink(consumer?.root ?? targetRoot, options.testFile, consumer);
     const ownPaths = project.ownPaths();
     const fileIds = new Set(held.symbols.filter((symbol) => symbol.kind === "file").map((symbol) => symbol.id));
     const declaredAt = (node) => declarations.get(nodeKey(node.getSourceFile(), node));
+    const sink = new Sink(consumer?.root ?? targetRoot, options.testFile, consumer, declaredAt);
     let moduleBodies;
     /**
      * The declarations one module holds directly: a file's top level, or the body of a

package/dist/src/roots/published-reach.js

@@ -182,7 +182,7 @@ function declarationNodes(held, byPath) {
     return {
         typeNamesOf: (symbol) => {
             const { byId, nodes } = nodesIn(symbol.position.path);
-            return (byId.get(symbol.id) ?? []).flatMap((declaration) => typeNamesOf(declaration, nodes));
+            return (byId.get(symbol.id) ?? []).flatMap((declaration) => typeNamesOf(declaration, (nested) => nodes.has(nested)));
         },
         nodesOf: (symbol) => nodesIn(symbol.position.path).byId.get(symbol.id) ?? [],
     };
@@ -369,12 +369,12 @@ function inferredTypeSymbols(project, declarations) {
 /**
  * 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.
+ * declaration nested in this one that `readAlone` says is read on its own.
  */
-function typeNamesOf(declaration, nested) {
+export function typeNamesOf(declaration, readAlone) {
     const found = [];
     const visit = (node) => {
-        if (node !== declaration && nested.has(node)) {
+        if (node !== declaration && readAlone(node)) {
             return;
         }
         if (isTypeReferenceNode(node)) {

package/dist/src/verbs/explain.js

@@ -1,12 +1,11 @@
 import { EXIT_CLEAN, EXIT_USAGE } from "../contract/contract.generated.js";
 import { productionMode, runAnalysis } from "../analysis.js";
-import { listing } from "../components.js";
-import { OUTSIDE, swept as judged } from "../graph.js";
-import { referenceKey } from "../matrix.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, withheldBy } from "../tests/file-class.js";
+import { madeByTestCode } from "../tests/file-class.js";
 import { resolve } from "../resolve.js";
 import {} from "./verb.js";
 import { UsageError } from "../usage.js";
@@ -80,172 +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, a loaded consumer or a test file no project holds to one
- * declaration, walked breadth first from every root at once in the order the run names them,
- * a reference of a consumer or of such a file being the first hop of a path of its own, as
- * the sweep seeds them, 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, mode, support) {
-    const graph = analysis.swept.matrix.union;
-    const out = new Map();
-    const consumed = [];
-    for (const reference of referencesOf(analysis.configured)) {
-        if (withheldBy(mode, reference, support)) {
-            continue;
-        }
-        const { consumer } = reference;
-        if (consumer !== undefined) {
-            consumed.push({ reference, origin: { k: "consumer", consumer } });
-            continue;
-        }
-        if (reference.unheld === true) {
-            consumed.push({
-                reference,
-                origin: { k: "unheld", file: reference.from.replace(/#$/u, "") },
-            });
-            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 consumed 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, origin } of consumed) {
-                follow(reference, -1, origin);
-            }
-        }
-        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);
-        }
-    }
-    return undefined;
-}
 /** Where a path starts, as a line names it. */
-function originText(origin) {
+function originText(origin, graph) {
+    const id = (at) => graph.symbols[at]?.id ?? "";
     switch (origin.k) {
         case "root":
-            return `root ${origin.root.kind} ${origin.root.id}`;
-        case "consumer":
-            return `consumer ${origin.consumer}`;
-        case "unheld":
-            return `test file no project holds ${origin.file}`;
+            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 ?? ""}`;
+        }
+        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)}`;
     }
 }
 /** 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}`;
 }
-/** One reference of an answer, marked where test code made it, a test-support file's included. */
-function referenceLine(reference, tail, support) {
-    return `  reference: ${positionKey(reference.position)}\t${reference.use}\t${tail}${madeByTestCode(reference, support) ? "\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, mode) {
-    const { sweep } = analysis.swept;
+function liveness(analysis, subject, cascade) {
+    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 support = new Set(analysis.configured.flatMap((one) => one.supportFiles ?? []));
-    const found = shortestPath(analysis, subject.id, mode, support) ??
-        shortestPath(analysis, subject.id, { production: false }, support);
-    if (found !== undefined && found.path.length > 0) {
-        const { origin } = found;
-        text += `  reached from: ${originText(origin)}\n`;
-        for (const hop of found.path) {
-            text += referenceLine(hop.reference, `${madeBy(hop.reference)} -> ${hop.reference.to}`, support);
+    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);
+        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)}`, support);
+        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) {
@@ -294,7 +215,7 @@ function namedElsewhere(findings, subject) {
         .join("");
 }
 /** The one explanation that applies to a declaration, built whole before it is written. */
-function explanation(analysis, subject, cascade, mode) {
+function explanation(analysis, subject, cascade) {
     const graph = analysis.swept.matrix.union;
     const at = graph.at(subject.id);
     let text = `symbol: ${subject.ref}\n`;
@@ -302,7 +223,7 @@ function explanation(analysis, subject, cascade, mode) {
     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);
     }
@@ -312,22 +233,22 @@ function explanation(analysis, subject, cascade, mode) {
             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";
     }
     else {
-        text += liveness(analysis, subject, cascade, mode);
+        text += liveness(analysis, subject, cascade);
     }
     return text + namedElsewhere(analysis.result.findings, subject);
 }
 /**
  * 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, a loaded consumer or a test file no project holds, 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.
+ * 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);
@@ -351,7 +272,7 @@ export const explainVerb = ({ out, err, host, inputs, scope, openClient, option
         }
     }
     else {
-        out.write(explanation(analysis, subject, config.reporters.cascade, mode));
+        out.write(explanation(analysis, subject, config.reporters.cascade));
     }
     for (const note of notes) {
         diagnose(err, note);

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

@@ -20,7 +20,7 @@ export const printRetainedVerb = ({ out, err, host, inputs, scope, openClient })
         marked: [],
         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.17",
+  "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.17",
+  "version": "8.0.0-dev.18",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",