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

package/dist/src/interface-satisfaction.js

@@ -9,7 +9,7 @@
 import { isCallExpression, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isHeritageClause, isMethodDeclaration, isNewExpression, isObjectLiteralExpression, isSetAccessorDeclaration, isTypeLiteralNode, ModifierFlags, SyntaxKind, } from "@typescript/native/ast";
 import { SymbolFlags } from "@typescript/native/sync";
 import { aliasChains } from "./alias-chain.js";
-import { emptyImplementation } from "./implementations.js";
+import { emptyImplementation } from "./findings/implementations.js";
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 import { must } from "./query.js";

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/keyof-comparisons.js

@@ -4,10 +4,8 @@
  * that holds `keyof X`, the literal the other side has names the member of `X` under that
  * key, because deleting the member makes the comparison a type error.
  */
-import { isBinaryExpression, isCaseClause, isElementAccessExpression, isIdentifier, isPropertyAccessExpression, isSwitchStatement, isTypeOperatorNode, SyntaxKind, } from "@typescript/native/ast";
+import { isBinaryExpression, isCaseClause, isElementAccessExpression, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isPropertyAccessExpression, isStringLiteral, isSwitchStatement, isTypeOperatorNode, SyntaxKind, } from "@typescript/native/ast";
 import { SymbolFlags } from "@typescript/native/sync";
-import { nodeKey } from "./inventory.js";
-import { renderPosition } from "./position.js";
 import { UNANSWERED } from "./query.js";
 import { parenthesesRemoved } from "./unwrap.js";
 /** The operators that compare their operands for equality. */
@@ -55,114 +53,137 @@ function literalNames(parts) {
     return names;
 }
 /**
- * The references the key comparisons of one project's own files make to the members their
- * literal side names, each made by the declaration holding the comparison.
+ * The reads the key comparisons of a side's files make of the members their literal side
+ * names, each made by the declaration holding the comparison. A question the checker leaves
+ * unanswered holds what its answer could have read.
  */
-export function keyofComparisonReferences(project, held, chains, root, testFiles) {
-    const queries = project.queries;
-    const comparisons = [];
-    for (const file of project.ownSourceFiles()) {
-        const fileId = held.declarations.get(nodeKey(file, file));
-        if (fileId === undefined) {
-            continue;
-        }
-        const visit = (node, from) => {
-            const holder = held.declarations.get(nodeKey(file, node)) ?? from;
-            if (isBinaryExpression(node) && EQUALITIES.has(node.operatorToken.kind)) {
-                comparisons.push({ file, from: holder, keyed: node.left, other: node.right });
-                comparisons.push({ file, from: holder, keyed: node.right, other: node.left });
-            }
-            if (isSwitchStatement(node)) {
-                for (const clause of node.caseBlock.clauses) {
-                    if (isCaseClause(clause)) {
-                        comparisons.push({
-                            file,
-                            from: holder,
-                            keyed: node.expression,
-                            other: clause.expression,
+export const keyofComparisons = {
+    start() {
+        const comparisons = [];
+        return {
+            visit(node, { file, from }) {
+                if (isBinaryExpression(node) && EQUALITIES.has(node.operatorToken.kind)) {
+                    comparisons.push({ file, from, keyed: node.left, other: node.right });
+                    comparisons.push({ file, from, keyed: node.right, other: node.left });
+                }
+                if (isSwitchStatement(node)) {
+                    for (const clause of node.caseBlock.clauses) {
+                        if (isCaseClause(clause)) {
+                            comparisons.push({ file, from, keyed: node.expression, other: clause.expression });
+                        }
+                    }
+                }
+            },
+            reads({ project, chains }) {
+                const queries = project.queries;
+                const found = [];
+                const named = comparisons.flatMap((one) => {
+                    const name = nameOf(one.keyed);
+                    return name === undefined || isElementAccessExpression(parenthesesRemoved(one.other))
+                        ? []
+                        : [{ ...one, name }];
+                });
+                if (named.length === 0) {
+                    return found;
+                }
+                // The operand's own declaration states the key type, which the checker resolves to
+                // the literals it admits and so no longer names the type the key indexes.
+                const symbols = queries.symbolsAt(named.map((one) => one.name));
+                const keyed = named.flatMap((one, at) => {
+                    const asked = symbols[at];
+                    const symbol = asked === UNANSWERED || asked === undefined || (asked.flags & SymbolFlags.Alias) === 0
+                        ? asked
+                        : queries.aliased(asked);
+                    if (symbol === UNANSWERED) {
+                        const text = literalText(one.other);
+                        found.push({
+                            kind: "held",
+                            from: one.from,
+                            ...(text === undefined ? {} : { names: [text] }),
                         });
+                        return [];
                     }
+                    if (symbol === undefined) {
+                        return [];
+                    }
+                    const operands = symbol.declarations.flatMap((handle) => {
+                        const declared = project.declarationAt(handle)?.node?.type;
+                        return declared === undefined ? [] : keyofOperands(declared);
+                    });
+                    return operands.length === 0 ? [] : [{ ...one, operands }];
+                });
+                if (keyed.length === 0) {
+                    return found;
                 }
-            }
-            node.forEachChild((child) => {
-                visit(child, holder);
-            });
-        };
-        file.forEachChild((child) => {
-            visit(child, fileId);
-        });
-    }
-    const named = comparisons.flatMap((one) => {
-        const name = nameOf(one.keyed);
-        return name === undefined || isElementAccessExpression(parenthesesRemoved(one.other))
-            ? []
-            : [{ ...one, name }];
-    });
-    if (named.length === 0) {
-        return [];
-    }
-    // The operand's own declaration states the key type, which the checker resolves to
-    // the literals it admits and so no longer names the type the key indexes.
-    const symbols = queries.symbolsAt(named.map((one) => one.name));
-    const keyed = named.flatMap((one, at) => {
-        const asked = symbols[at];
-        const symbol = asked === UNANSWERED || asked === undefined || (asked.flags & SymbolFlags.Alias) === 0
-            ? asked
-            : queries.aliased(asked);
-        if (symbol === UNANSWERED || symbol === undefined) {
-            return [];
-        }
-        const operands = symbol.declarations.flatMap((handle) => {
-            const declared = project.declarationAt(handle)?.node?.type;
-            return declared === undefined ? [] : keyofOperands(declared);
-        });
-        return operands.length === 0 ? [] : [{ ...one, operands }];
-    });
-    if (keyed.length === 0) {
-        return [];
-    }
-    const nodes = keyed.flatMap((one) => [one.other, ...one.operands]);
-    const types = queries.typesAt(nodes);
-    const typeOf = new Map();
-    nodes.forEach((node, at) => {
-        const type = types[at];
-        if (type !== UNANSWERED && type !== undefined) {
-            typeOf.set(node, type);
-        }
-    });
-    const partsOf = (type) => {
-        const parts = queries.constituents(type);
-        return parts === UNANSWERED ? [type] : parts;
-    };
-    const found = [];
-    for (const one of keyed) {
-        const literal = typeOf.get(one.other);
-        const names = literal === undefined ? [] : literalNames(partsOf(literal));
-        if (names.length === 0) {
-            continue;
-        }
-        const position = renderPosition(one.file, root, one.other.getStart());
-        for (const operand of one.operands) {
-            const object = typeOf.get(operand);
-            for (const part of object === undefined ? [] : partsOf(object)) {
-                const properties = queries.propertiesOf(part);
-                for (const property of properties === UNANSWERED ? [] : properties) {
-                    if (!names.includes(property.name)) {
-                        continue;
+                const nodes = keyed.flatMap((one) => [one.other, ...one.operands]);
+                const types = queries.typesAt(nodes);
+                const typeOf = new Map();
+                nodes.forEach((node, at) => {
+                    const type = types[at];
+                    if (type !== undefined) {
+                        typeOf.set(node, type);
                     }
-                    for (const to of chains.declarationsOf(property)) {
+                });
+                const partsOf = (type) => {
+                    const parts = queries.constituents(type);
+                    return parts === UNANSWERED ? [type] : parts;
+                };
+                for (const one of keyed) {
+                    const literal = typeOf.get(one.other);
+                    const objects = one.operands.map((operand) => typeOf.get(operand));
+                    if (literal === UNANSWERED) {
+                        const known = objects.filter((type) => type !== undefined && type !== UNANSWERED);
                         found.push({
+                            kind: "held",
                             from: one.from,
-                            to,
-                            position,
-                            use: "read",
-                            resolution: "keyed",
-                            test: testFiles.has(position.path),
+                            types: known.flatMap(partsOf),
+                            ...(known.length < objects.length ? { members: true } : {}),
                         });
+                        continue;
+                    }
+                    const names = literal === undefined ? [] : literalNames(partsOf(literal));
+                    if (names.length === 0) {
+                        continue;
+                    }
+                    for (const object of objects) {
+                        if (object === UNANSWERED) {
+                            found.push({ kind: "held", from: one.from, names });
+                            continue;
+                        }
+                        for (const part of object === undefined ? [] : partsOf(object)) {
+                            const properties = queries.propertiesOf(part);
+                            if (properties === UNANSWERED) {
+                                found.push({ kind: "held", from: one.from, names });
+                                continue;
+                            }
+                            for (const property of properties) {
+                                if (!names.includes(property.name)) {
+                                    continue;
+                                }
+                                for (const to of chains.declarationsOf(property)) {
+                                    found.push({
+                                        kind: "named",
+                                        from: one.from,
+                                        to,
+                                        file: one.file,
+                                        at: one.other,
+                                        use: "read",
+                                        via: "keyed",
+                                    });
+                                }
+                            }
+                        }
                     }
                 }
-            }
-        }
-    }
-    return found;
+                return found;
+            },
+        };
+    },
+};
+/** The text a string or number literal operand spells, where it is one. */
+function literalText(node) {
+    const at = parenthesesRemoved(node);
+    return isStringLiteral(at) || isNumericLiteral(at) || isNoSubstitutionTemplateLiteral(at)
+        ? at.text
+        : undefined;
 }

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,9 +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";
 /** The position of a declaration the inventory does not hold. */
 export const OUTSIDE = -1;
 /**
@@ -66,42 +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 }));
+    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 (reference.test) {
-                counts.test += 1;
-            }
-            else {
-                counts.production += 1;
-            }
+            count(counts, test, consumer);
         }
-        const edge = { to, test: reference.test, evaluation: reference.use === "evaluation" };
-        if (reference.consumer !== undefined || reference.unheld === true) {
+        const guesses = guessedMade[to];
+        if (guessed && guesses !== undefined) {
+            count(guesses, test, consumer);
+        }
+        const edge = {
+            to,
+            reference: place,
+            test,
+            guessed,
+            evaluation: reference.use === "evaluation",
+            consumer,
+        };
+        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) => {
@@ -114,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,
+    };
+}