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

package/dist/src/findings/reads-and-writes.js

@@ -1,6 +1,8 @@
 import { CODE } from "../contract/contract.generated.js";
+import { WORDS } from "../inventory.js";
 import { positionKey } from "../position.js";
 import { declarationKey } from "../ref.js";
+import { reachabilityClasses } from "./completion.js";
 import { bytewise } from "../text/compare.js";
 /** The containers whose type parameters `DS1006` reports: a function, a class method and a type alias. */
 const SIGNATURES = new Set(["function", "method", "type"]);
@@ -70,14 +72,16 @@ function parametersOnlyNamedBy(run, namedBy, member) {
         .map((symbol) => symbol.name);
 }
 /** What one write-only finding says, the declarations its deletion takes with it included. */
-function writeOnlyMessage(run, namedBy, symbol, held) {
+function writeOnlyMessage(run, written, subject) {
+    const { symbol, held } = subject;
     const writes = held.writes.length === 1 ? "once" : `at ${String(held.writes.length)} positions`;
     const read = run.input.stores.readInTests.has(symbol.id)
         ? "read only from test files"
         : "never read";
     const cascade = [
-        ...parametersOnlyNamedBy(run, namedBy, symbol).map((name) => `type parameter ${name}`),
+        ...parametersOnlyNamedBy(run, written.namedBy, symbol).map((name) => `type parameter ${name}`),
         ...[...held.alone].sort(bytewise).map((name) => `import ${name}`),
+        ...(written.named.get(symbol.id) ?? []),
     ];
     const word = SUBJECT_WORDS[symbol.kind] ?? "member";
     const message = `${word} ${symbol.name} is written ${writes} and ${read}`;
@@ -86,16 +90,34 @@ function writeOnlyMessage(run, namedBy, symbol, held) {
         : `${message}, and deleting it with its writes deletes ${cascade.join(" and ")} too`;
 }
 /**
- * `DS1301`: a module-level variable, a type member or a class member the counted
- * references store into and never read, named with every position written.
+ * The kinds of declaration that fall with a write-only subject: a declaration of its own.
+ * A member falls with its container, and a type parameter is the type-parameter clause's.
+ */
+const FALLING = new Set([
+    "function",
+    "class",
+    "interface",
+    "type",
+    "enum",
+    "namespace",
+    "variable",
+]);
+const WRITTEN = new WeakMap();
+/**
+ * `DS1301`'s subjects: a module-level variable, a type member or a class member the
+ * counted references store into and never read.
  *
  * The subject is a live declaration: a store is a reference, so the sweep holds a
  * written one live and its candidates are never this kind's. Every reference that is
  * not a store reads, and so does an exemption record naming the declaration.
  */
-function writeOnlySymbols(run) {
+function writtenOf(run) {
+    const known = WRITTEN.get(run.input);
+    if (known !== undefined) {
+        return known;
+    }
     const { stores } = run.input;
-    const { matrix } = run.input.swept;
+    const { matrix, sweep } = run.input.swept;
     const uses = new Map();
     for (const reference of stores.references) {
         let held = uses.get(reference.to);
@@ -124,22 +146,49 @@ function writeOnlySymbols(run) {
             namedBy.set(reference.to, (namedBy.get(reference.to) ?? new Set()).add(reference.from));
         }
     }
-    const found = [];
-    for (const symbol of matrix.union.symbols) {
+    const subjects = matrix.union.symbols.flatMap((symbol) => {
         const held = uses.get(symbol.id);
-        if (held === undefined ||
+        return held === undefined ||
             held.writes.length === 0 ||
             held.reads > 0 ||
             !writable(run, symbol) ||
             stores.exempt.has(symbol.id) ||
-            run.candidates.has(symbol.id)) {
+            run.candidates.has(symbol.id)
+            ? []
+            : [{ symbol, held }];
+    });
+    const subjectIds = new Set(subjects.map((subject) => subject.symbol.id));
+    const classOf = reachabilityClasses(run.input);
+    const named = new Map();
+    const falls = new Set();
+    for (const symbol of matrix.union.symbols) {
+        const chains = sweep.carried.get(symbol.id);
+        if (chains === undefined ||
+            subjectIds.has(symbol.id) ||
+            !FALLING.has(symbol.kind) ||
+            classOf(symbol.id) !== "certain") {
             continue;
         }
-        found.push(findingAbout(symbol, CODE.writeOnlySymbol, writeOnlyMessage(run, namedBy, symbol, held), {
-            writePositions: held.writes,
-        }));
+        const innermost = chains.map((chain) => chain.find((id) => subjectIds.has(id)));
+        if (innermost.includes(undefined)) {
+            continue;
+        }
+        falls.add(symbol.id);
+        for (const subject of new Set(innermost)) {
+            const name = `${WORDS[symbol.kind]} ${symbol.name}`;
+            named.set(subject ?? "", [...(named.get(subject ?? "") ?? []), name]);
+        }
     }
-    return found;
+    const written = { subjects, namedBy, named, falls };
+    WRITTEN.set(run.input, written);
+    return written;
+}
+/** `DS1301`: each subject, named with every position written and what falls with it. */
+function writeOnlySymbols(run) {
+    const written = writtenOf(run);
+    return written.subjects.map((subject) => findingAbout(subject.symbol, CODE.writeOnlySymbol, writeOnlyMessage(run, written, subject), {
+        writePositions: subject.held.writes,
+    }));
 }
 /**
  * The candidates no reference of any file names whose container is not itself dead, of
@@ -184,7 +233,14 @@ function unusedTypeParameters(run) {
  * supersedes narrowing it.
  */
 export function writeOnlyDeclarations(input) {
-    return new Set(writeOnlySymbols(indexed(input)).map((finding) => declarationKey(finding.symbol.ref, finding.position.path)));
+    return new Set(writtenOf(indexed(input)).subjects.map(({ symbol }) => declarationKey(symbol.ref, symbol.position.path)));
+}
+/**
+ * The declarations that fall with a write-only subject, whatever the severity: a finding
+ * about one would name code its subject's deletion already deletes.
+ */
+export function fallingWithWrites(input) {
+    return writtenOf(indexed(input)).falls;
 }
 /**
  * The findings of the reads-and-writes kinds, `DS1301`, `DS1005` and `DS1006`, in that

package/dist/src/findings/unused-declarations.js

@@ -1,5 +1,5 @@
 import { CODE } from "../contract/contract.generated.js";
-import { testsUnseenAPI } from "./completion.js";
+import { WORDS } from "../inventory.js";
 import { unreachableExports } from "./visibility-narrowing.js";
 /** The kinds of declaration that are members of a class, an interface, a type or an enum. */
 const MEMBERS = new Set([
@@ -19,24 +19,6 @@ const NOT_REPORTED_HERE = new Set([
     "interface-method",
     "type-parameter",
 ]);
-/** The reader's word for each kind of declaration a finding of this emitter names. */
-const WORDS = {
-    file: "file",
-    function: "function",
-    class: "class",
-    interface: "interface",
-    type: "type alias",
-    enum: "enum",
-    namespace: "namespace",
-    variable: "variable",
-    "export-alias": "re-export",
-    method: "method",
-    "class-member": "class member",
-    "interface-method": "interface method",
-    "type-member": "type member",
-    "enum-member": "enum member",
-    "type-parameter": "type parameter",
-};
 /** What the test-of-dead-code kind says, which states the rule it applies. */
 const TEST_OF_DEAD_CODE = "every target symbol this test references is reported dead";
 /**
@@ -50,7 +32,7 @@ const TEST_OF_DEAD_CODE = "every target symbol this test references is reported
 function codeOf(judged) {
     const { candidate, symbol } = judged;
     if (candidate.testOfDeadCode) {
-        return judged.testsUnseenAPI ? undefined : CODE.testOfDeadCode;
+        return CODE.testOfDeadCode;
     }
     if ((judged.test && !candidate.unreferencedTest) || NOT_REPORTED_HERE.has(symbol.kind)) {
         return undefined;
@@ -201,7 +183,6 @@ function emitterFindings(input, fallen) {
     const union = input.swept.matrix.union;
     const dead = new Set(input.swept.sweep.candidates.map((candidate) => candidate.id));
     const unreachable = unreachableExports(input);
-    const unseenAPI = testsUnseenAPI(input);
     let brands;
     const found = [];
     for (const candidate of input.swept.sweep.candidates) {
@@ -220,7 +201,6 @@ function emitterFindings(input, fallen) {
             test: union.test[at] === true,
             deprecated: input.deprecated.has(symbol.id),
             unreachable: unreachable.has(symbol.id),
-            testsUnseenAPI: candidate.testOfDeadCode && unseenAPI(candidate.id),
         };
         const code = codeOf(judged);
         if (code === undefined ||

package/dist/src/findings/visibility-narrowing.js

@@ -1,7 +1,9 @@
 import { CODE } from "../contract/contract.generated.js";
-import { OUTSIDE } from "../graph.js";
+import { OUTSIDE } from "../liveness/graph.js";
+import { WORDS } from "../inventory.js";
 import { declarationKey } from "../ref.js";
-import { runnerCalls } from "../sweep.js";
+import { runnerCalls } from "../liveness/sweep.js";
+import { exposedTypes, exposes } from "../exposure.js";
 import { writeOnlyDeclarations } from "./reads-and-writes.js";
 /**
  * The root kinds by which a consumer importing the package reaches a declaration. A
@@ -9,17 +11,6 @@ import { writeOnlyDeclarations } from "./reads-and-writes.js";
  * from outside the reference graph: a runtime, a tool, a framework or the configuration.
  */
 const PUBLISHING = new Set(["manifest-entry", "published-api"]);
-/** The reader's word for each kind of declaration this emitter reports. */
-const WORDS = {
-    function: "function",
-    class: "class",
-    interface: "interface",
-    type: "type alias",
-    enum: "enum",
-    namespace: "namespace",
-    variable: "variable",
-    "export-alias": "re-export",
-};
 function publishes(kinds) {
     return [...(kinds ?? [])].some((kind) => PUBLISHING.has(kind));
 }
@@ -102,9 +93,6 @@ function topLevelExport(facts, at, symbol) {
     const parent = facts.graph.parent[at] ?? OUTSIDE;
     return symbol.exported && parent !== OUTSIDE && facts.graph.symbols[parent]?.kind === "file";
 }
-function wordOf(symbol) {
-    return WORDS[symbol.kind] ?? symbol.kind;
-}
 /** The visibility each narrowing code names, which only the narrowing codes carry. */
 const NARROWER = {
     [CODE.redundantExportKeyword]: "file",
@@ -145,7 +133,7 @@ function narrowing(facts, at, symbol, world) {
         (facts.named[at] ?? 0) === 0) {
         return undefined;
     }
-    const word = wordOf(symbol);
+    const word = WORDS[symbol.kind];
     switch (facts.reach[at]) {
         case "file":
             if (facts.published[file] === true && !closed) {
@@ -153,7 +141,7 @@ function narrowing(facts, at, symbol, world) {
             }
             return findingOf(symbol, CODE.redundantExportKeyword, `exported ${word} is referenced only inside the file that declares it`);
         case "package":
-            if (!closed || !publishes(facts.rootedBy[at])) {
+            if (!closed || !publishes(facts.rootedBy[at]) || exposes(world.exposed, symbol)) {
                 return undefined;
             }
             return findingOf(symbol, CODE.unnecessaryExport, `exported ${word} is referenced only inside the package that declares it`);
@@ -181,7 +169,7 @@ function unreachable(facts, at, symbol, candidate, input) {
     const found = candidate.relation === "reachability"
         ? "is referenced only from declarations that are themselves dead"
         : "has no reference in the target";
-    return findingOf(symbol, CODE.unreachableExport, `exported ${wordOf(symbol)} ${found}, and nothing outside can import the file that declares it`);
+    return findingOf(symbol, CODE.unreachableExport, `exported ${WORDS[symbol.kind]} ${found}, and nothing outside can import the file that declares it`);
 }
 /**
  * The visibility-narrowing kinds over one run: `DS1501`, `DS1101` and `DS1503`. A finding
@@ -194,7 +182,13 @@ export function narrowings(input) {
     const facts = factsOf(input.swept.matrix.union);
     const { declared, loaded } = input.boundary.consumers;
     const closed = input.config.consumers.complete && declared.every((id) => loaded.includes(id));
-    const world = { closed, writeOnly: writeOnlyDeclarations(input) };
+    const world = {
+        closed,
+        writeOnly: writeOnlyDeclarations(input),
+        exposed: closed
+            ? exposedTypes(facts.graph, facts.reach.map((reach) => reach === "outside"), input.boundary.carriers)
+            : new Set(),
+    };
     const candidates = new Map(input.swept.sweep.candidates.map((candidate) => [candidate.id, candidate]));
     const generated = input.config.analysis.generated_files === "include" ? undefined : input.files.generated;
     const findings = [];

package/dist/src/inventory.js

@@ -2,6 +2,24 @@ import { isClassDeclaration, isComputedPropertyName, isConstructorDeclaration, i
 import { byPosition, positionKey, renderPosition, startLine } from "./position.js";
 import { renderRef, spell } from "./ref.js";
 import { signatureOf } from "./signatures.js";
+/** The reader's word for each kind of declaration, as a finding names it. */
+export const WORDS = {
+    file: "file",
+    function: "function",
+    class: "class",
+    interface: "interface",
+    type: "type alias",
+    enum: "enum",
+    namespace: "namespace",
+    variable: "variable",
+    "export-alias": "re-export",
+    method: "method",
+    "class-member": "class member",
+    "interface-method": "interface method",
+    "type-member": "type member",
+    "enum-member": "enum member",
+    "type-parameter": "type parameter",
+};
 /**
  * One node's identity inside one program, which is how two readings of that program name
  * one declaration: the binder's table and the tree meet here, and so does the reference

package/dist/src/{components.js → liveness/components.js}

@@ -4,7 +4,7 @@
  * and every dead declaration that falls with them, being dead only through them.
  */
 import { OUTSIDE } from "./graph.js";
-import { PRODUCT } from "./product.js";
+import { PRODUCT } from "../product.js";
 /** The fewest digits a component identifier's number is written with. */
 const ID_DIGITS = 4;
 /** The identifier of the component at one place of the run's order, counted from one. */

package/dist/src/{graph.js → liveness/graph.js}

@@ -1,10 +1,10 @@
 /**
- * One project's declarations, the references between them and the roots that seed
- * reachability, indexed for the sweep. The graph reads no file and asks the compiler
- * nothing, so a sweep over it is a function of the values it was built from, and the
- * inventory's order is the order every set a sweep answers reads in.
+ * The run's declarations, the references every configuration makes between them and the
+ * roots that seed reachability, indexed for the sweep. The graph reads no file and asks the
+ * compiler nothing, so a sweep over it is a function of the values it was built from, and
+ * the inventory's order is the order every set a sweep answers reads in.
  */
-import { madeByTestCode } from "./tests/file-class.js";
+import { madeByTestCode } from "../tests/file-class.js";
 /** The position of a declaration the inventory does not hold. */
 export const OUTSIDE = -1;
 /**
@@ -67,49 +67,63 @@ export function swept(kind) {
 export function namesACaller(kind) {
     return NAMES_A_CALLER[kind];
 }
+/** Adds one reference's count to the counts of the declaration it names. */
+function count(counts, test, consumer) {
+    if (test) {
+        counts.test += 1;
+        counts.consumerTest += consumer ? 1 : 0;
+    }
+    else {
+        counts.production += 1;
+    }
+}
 /**
- * Indexes one project's inventory, references and roots. `testFiles` are the paths the
+ * Indexes the run's inventory, references and roots. `testFiles` are the paths the
  * reference pass classified as test files, so a declaration one holds is a test
  * declaration. A reference to a declaration the inventory does not hold is dropped; one
  * from such a declaration still counts toward its target, because reference counting
  * asks whether any declaration names the target. A root naming nothing is dropped.
  */
-export function graphOf(symbols, references, roots, testFiles, supportFiles = [], ambient = new Set()) {
+export function graphOf(symbols, references, roots, testFiles, supportFiles = [], ambient = new Set(), sources = {}) {
     const supports = new Set(supportFiles);
     const index = new Map(symbols.map((symbol, at) => [symbol.id, at]));
     const at = (id) => index.get(id) ?? OUTSIDE;
     const tests = new Set(testFiles);
+    const unjudged = sources.unjudged ?? new Set();
     const out = symbols.map(() => []);
     const made = symbols.map(() => ({ production: 0, test: 0, consumerTest: 0 }));
+    const guessedMade = symbols.map(() => ({ production: 0, test: 0, consumerTest: 0 }));
     const consumed = [];
-    for (const reference of references) {
+    references.forEach((reference, place) => {
         const to = at(reference.to);
         if (to === OUTSIDE) {
-            continue;
+            return;
         }
         const test = madeByTestCode(reference, supports);
+        const consumer = reference.consumer !== undefined;
+        const guessed = reference.guessed === true;
         const counts = made[to];
         if (counts !== undefined) {
-            if (test) {
-                counts.test += 1;
-                counts.consumerTest += reference.consumer === undefined ? 0 : 1;
-            }
-            else {
-                counts.production += 1;
-            }
+            count(counts, test, consumer);
+        }
+        const guesses = guessedMade[to];
+        if (guessed && guesses !== undefined) {
+            count(guesses, test, consumer);
         }
         const edge = {
             to,
+            reference: place,
             test,
+            guessed,
             evaluation: reference.use === "evaluation",
-            consumer: reference.consumer !== undefined,
+            consumer,
         };
-        if (edge.consumer || reference.unheld === true) {
+        if (consumer || reference.unheld === true || unjudged.has(reference.from)) {
             consumed.push(edge);
-            continue;
+            return;
         }
         out[at(reference.from)]?.push(edge);
-    }
+    });
     const parent = symbols.map((symbol) => at(symbol.parent));
     const exportsOf = symbols.map(() => []);
     symbols.forEach((symbol, position) => {
@@ -122,13 +136,16 @@ export function graphOf(symbols, references, roots, testFiles, supportFiles = []
     for (const root of roots) {
         const position = at(root.id);
         if (position !== OUTSIDE) {
-            rooted.push({ at: position, kind: root.kind });
+            rooted.push({ at: position, kind: root.kind, source: root.source });
         }
     }
     return {
         symbols,
         out,
         made,
+        guessedMade,
+        references,
+        configurations: sources.configurations ?? references.map(() => []),
         parent,
         test: symbols.map((symbol) => tests.has(symbol.position.path)),
         support: symbols.map((symbol) => supports.has(symbol.position.path)),

package/dist/src/liveness/matrix.js

@@ -0,0 +1,99 @@
+/**
+ * One run's projects as one matrix: every declaration any project judges, keyed by its
+ * position and carrying the configurations that hold it, and one graph over every
+ * configuration's references and roots, which the sweep judges once (matrix.4, matrix.5).
+ */
+import { graphOf, swept } from "./graph.js";
+import { byPosition } from "../position.js";
+/**
+ * What makes one reference one reference, whichever configuration made it. A consumer's
+ * position is rendered against its own root, so the consumer is part of what it names.
+ */
+export function referenceKey(reference) {
+    const { path, line, column } = reference.position;
+    return [
+        reference.consumer ?? "",
+        reference.from,
+        reference.to,
+        path,
+        String(line),
+        String(column),
+        reference.use,
+    ].join("\u0000");
+}
+/**
+ * Indexes what the passes answered for each configuration of one run, in the run's order.
+ * A declaration is keyed by its rendered position, with the fields of the first
+ * configuration that judges it; one in a file every holder holds only for its references
+ * is judged by none and is not in the union, and a reference it makes enters the union as a
+ * consumer's does. One reference at one position of a file several configurations compile
+ * is one reference; two one configuration makes are two.
+ */
+export function matrixOf(per) {
+    const symbols = [];
+    const holders = new Map();
+    const references = [];
+    const makers = [];
+    const firstSeen = new Map();
+    const judged = new Set();
+    const unjudged = new Set();
+    const dependents = new Map();
+    per.forEach((one, index) => {
+        for (const [id, after] of one.dependents ?? []) {
+            if (!dependents.has(id)) {
+                dependents.set(id, after);
+            }
+        }
+        const referenceOnly = new Set(one.referenceOnly);
+        for (const symbol of one.symbols) {
+            const held = holders.get(symbol.id);
+            if (held === undefined) {
+                holders.set(symbol.id, [one.configuration]);
+            }
+            else if (!held.includes(one.configuration)) {
+                held.push(one.configuration);
+            }
+            if (referenceOnly.has(symbol.position.path)) {
+                if (swept(symbol.kind)) {
+                    unjudged.add(symbol.id);
+                }
+            }
+            else if (!judged.has(symbol.id)) {
+                judged.add(symbol.id);
+                symbols.push(symbol);
+            }
+        }
+        for (const reference of one.references) {
+            const key = referenceKey(reference);
+            const seen = firstSeen.get(key);
+            if (seen !== undefined && seen.index !== index) {
+                for (const place of seen.places) {
+                    const making = makers[place];
+                    if (making !== undefined && !making.includes(one.configuration)) {
+                        making.push(one.configuration);
+                    }
+                }
+                continue;
+            }
+            const places = seen?.places ?? [];
+            if (seen === undefined) {
+                firstSeen.set(key, { index, places });
+            }
+            places.push(references.length);
+            references.push(reference);
+            makers.push([one.configuration]);
+        }
+    });
+    for (const id of judged) {
+        unjudged.delete(id);
+    }
+    symbols.sort((a, b) => byPosition(a.position, b.position));
+    const testUsed = new Set(per.flatMap((one) => one.testUsedFiles ?? []));
+    return {
+        configurations: per.map((one) => one.configuration),
+        union: graphOf(symbols, references, per.flatMap((one) => one.roots), [...new Set(per.flatMap((one) => one.testFiles))], [...new Set(per.flatMap((one) => one.supportFiles ?? []))], new Set(per.flatMap((one) => [...(one.ambient ?? [])])), { unjudged, configurations: makers }),
+        heldIn: symbols.map((symbol) => holders.get(symbol.id) ?? []),
+        testUsed: symbols.map((symbol) => testUsed.has(symbol.position.path)),
+        dependents,
+    };
+}