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

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/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/load/expected-module.js

@@ -2,7 +2,7 @@ import { isNoSubstitutionTemplateLiteral, isStringLiteral, } from "@typescript/n
 import { packageOfSpecifier } from "../dependencies.js";
 import { MANIFEST } from "../fs/manifest.js";
 import { entriesOf } from "../fs/tree.js";
-import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "../paths.js";
+import { cannotStartPackageName, dirnamePath, joinPath, relativePath, resolvePath, } from "../paths.js";
 import { dependencySpecifiers, installedPackage, manifestsAbove } from "./module-lookup.js";
 /** The string literal holding one offset, innermost first, a doc comment's included. */
 function literalAt(file, offset) {
@@ -77,7 +77,7 @@ function declaringManifest(host, dir, targetRoot, name) {
 function expectedModule(context, importer, specifier) {
     const { host, targetRoot } = context;
     const fix = "run the generator or the build that writes it";
-    if (specifier.startsWith(".") || isAbsolutePath(specifier)) {
+    if (cannotStartPackageName(specifier)) {
         return provided(host, resolvePath(dirnamePath(importer), specifier), false)
             ? undefined
             : `which names no file of the target: ${fix}`;

package/dist/src/load/specifiers.js

@@ -9,12 +9,10 @@ import { isBinaryExpression, isCallExpression, isParenthesizedExpression, isStri
 import { packageOfSpecifier } from "../dependencies.js";
 import { readManifestAt } from "../fs/manifest.js";
 import { JAVASCRIPT_FILE } from "../javascript-file.js";
-import { ancestors, dirnamePath, relativePath, resolvePath } from "../paths.js";
+import { ancestors, dirnamePath, isRelativeSpecifier, relativePath, resolvePath, } from "../paths.js";
 import { renderPosition } from "../position.js";
 import { batched } from "../session.js";
 import { dependencySpecifiers } from "./module-lookup.js";
-/** A relative specifier: `.`, `..`, or one starting `./` or `../`. */
-const RELATIVE = /^\.\.?(?:\/|$)/u;
 /**
  * Whether one specifier is loaded optionally: written inside a `try` block, or as a call whose
  * result an `||` or a `??` falls back from, so the program is written for its absence.
@@ -87,7 +85,7 @@ export function readSpecifiers(engine, host, project, { checked, root, outputs }
         const resolved = (answers[at]?.resolvedFileName ?? "") !== "";
         const specifier = usage.node.text;
         const name = packageOfSpecifier(specifier);
-        if (RELATIVE.test(specifier)) {
+        if (isRelativeSpecifier(specifier)) {
             const named = resolvePath(dirnamePath(usage.file.fileName), specifier);
             if (!resolved && !outputs.some((dir) => relativePath(dir, named) !== undefined)) {
                 unresolved.push({

package/dist/src/load/synthesize.js

@@ -89,6 +89,11 @@ const RUNTIME_OPTIONS = {
     bundler: { module: "preserve", moduleResolution: "bundler" },
     node: { module: "nodenext", moduleResolution: "nodenext" },
 };
+/** Whether one configuration is a program the run formed to resolve its modules as Node does. */
+export function formedForNode(configuration) {
+    const options = configuration.written?.["compilerOptions"];
+    return isRecord(options) && options["moduleResolution"] === RUNTIME_OPTIONS.node.moduleResolution;
+}
 /** The manifest members that say a package is written for Node. */
 const NODE_MEMBERS = ["main", "exports", "bin", "type"];
 /**

package/dist/src/load/workspace-resolution.js

@@ -8,7 +8,7 @@
 import { emittedFrom } from "./emit-map.js";
 import { packageOfSpecifier } from "../dependencies.js";
 import { gitIgnored } from "../git-ignore.js";
-import { ancestors, dirnamePath, joinPath, relativePath, resolvePath } from "../paths.js";
+import { ancestors, cannotStartPackageName, dirnamePath, joinPath, relativePath, resolvePath, } from "../paths.js";
 import { satisfies } from "../version-range.js";
 import { isRecord } from "../json-document.js";
 import { MANIFEST } from "../fs/manifest.js";
@@ -99,7 +99,7 @@ function dependsOn(specifier, member, fromDir) {
     const inRange = (range) => member.version !== undefined && satisfies(member.version, range);
     if (specifier.startsWith("workspace:")) {
         const rest = specifier.slice("workspace:".length);
-        if (rest.startsWith(".") || rest.startsWith("/")) {
+        if (cannotStartPackageName(rest)) {
             return atPath(rest);
         }
         const alias = /^((?:@[^/@]+\/)?[^/@]+)@(.*)$/u.exec(rest);

package/dist/src/matrix.js

@@ -6,7 +6,8 @@
 import { componentsOf } from "./components.js";
 import { graphOf, OUTSIDE } from "./graph.js";
 import { byPosition } from "./position.js";
-import { reachedWithTheTests, sweep, } from "./sweep.js";
+import { edgeWithheldBy } from "./tests/file-class.js";
+import { reachedWithTheTests, splitRefs, sweep, } from "./sweep.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.
@@ -133,12 +134,13 @@ export function sweepMatrix(matrix, input) {
         }
         const held = matrix.heldIn[at] ?? [];
         const admitted = admittedAt(at);
-        const testRefs = union.made[at]?.test ?? 0;
+        const split = splitRefs(union.made[at], input.mode);
+        const testRefs = split.test;
         const heldByTests = heldBy[union.parent[at] ?? OUTSIDE] ??
             (union.support[at] === true && testRefs > 0 && !admitted ? symbol.id : undefined);
         const unreferenced = union.test[at] === true && !admitted && testReached[at] !== true;
         heldBy[at] = heldByTests;
-        const productionRefs = union.made[at]?.production ?? 0;
+        const productionRefs = split.production;
         const counted = all.every((candidate) => candidate.relation === "reference-counting");
         candidates.push({
             id: symbol.id,
@@ -181,7 +183,7 @@ function compiledReferences(matrix, dead, mode) {
                 }
                 for (const edge of edges) {
                     const to = graph.symbols[edge.to]?.id ?? "";
-                    if ((!mode.production || !edge.test) && dead.has(to) && !kept.has(to)) {
+                    if (!edgeWithheldBy(mode, edge) && dead.has(to) && !kept.has(to)) {
                         kept.add(to);
                         changed = true;
                     }

package/dist/src/module-declarations.js

@@ -5,11 +5,12 @@
  * to the same module. One that names it by name or pattern also reads the members it
  * imports, whatever file the specifier resolves to, as a compiler reading no such file does.
  */
-import { isCallExpression, isExportDeclaration, isExternalModuleReference, isImportDeclaration, isImportEqualsDeclaration, isImportTypeNode, isLiteralTypeNode, isModuleDeclaration, isNamespaceExport, isNamespaceImport, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
+import { isCallExpression, isExportDeclaration, isExternalModuleReference, isImportDeclaration, isImportEqualsDeclaration, isImportTypeNode, isLiteralTypeNode, isModuleDeclaration, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
+import { namesImported } from "./import-bindings.js";
 import { nodeKey } from "./inventory.js";
-import { renderPosition } from "./position.js";
 import { UNANSWERED } from "./query.js";
 import { aliasFragment, nameComponent } from "./ref.js";
+import { isPathSpecifier } from "./paths.js";
 /** Whether a node is a specifier's text: a string literal or a template with no substitution. */
 function literalText(node) {
     return node !== undefined && (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node));
@@ -36,32 +37,12 @@ function specifierOf(node) {
     }
     return undefined;
 }
-/**
- * The export names an import or a re-export reads from the module it names: none for a
- * namespace, a star or a bare form.
- */
-export function namesImported(node) {
-    if (isImportDeclaration(node)) {
-        const clause = node.importClause;
-        const bindings = clause?.namedBindings;
-        return [
-            ...(clause?.name === undefined ? [] : ["default"]),
-            ...(bindings === undefined || isNamespaceImport(bindings)
-                ? []
-                : bindings.elements.map((one) => (one.propertyName ?? one.name).text)),
-        ];
-    }
-    const clause = isExportDeclaration(node) ? node.exportClause : undefined;
-    return clause === undefined || isNamespaceExport(clause)
-        ? []
-        : clause.elements.map((one) => (one.propertyName ?? one.name).text);
-}
 /**
  * Whether a specifier matches a declaration's name, the name's one `*` standing for any run.
  * A relative name is resolved against its own file, so no specifier names it by its text.
  */
 function namesModule(specifier, name) {
-    if (/^(?:\.{1,2}(?:\/|$)|\/)/u.test(name)) {
+    if (isPathSpecifier(name)) {
         return false;
     }
     const star = name.indexOf("*");
@@ -107,67 +88,71 @@ function namedBy(held) {
     });
 }
 /**
- * The references the imports of one project's own files make to the module declarations
- * they name, each at the import's specifier.
+ * The reads the imports of a side's files make of the module declarations of the target they
+ * name, each at the import's specifier. A specifier the checker leaves unanswered still names
+ * a declaration by its name or pattern.
  */
-export function moduleDeclarationReferences(project, held, root, testFiles) {
-    const imports = [];
-    const declared = [];
-    for (const file of project.ownSourceFiles()) {
-        const fileId = held.declarations.get(nodeKey(file, file));
-        if (fileId === undefined) {
-            continue;
-        }
-        const visit = (node, from) => {
-            const own = held.declarations.get(nodeKey(file, node));
-            if (isModuleDeclaration(node) && literalText(node.name) && own !== undefined) {
-                declared.push({ id: own, name: node.name });
-            }
-            const specifier = specifierOf(node);
-            if (specifier !== undefined) {
-                imports.push({ file, from, specifier, names: namesImported(node) });
-            }
-            node.forEachChild((child) => {
-                visit(child, own ?? from);
-            });
-        };
-        file.forEachChild((child) => {
-            visit(child, fileId);
-        });
-    }
-    if (declared.length === 0 || imports.length === 0) {
-        return [];
-    }
-    const asked = [...declared.map((one) => one.name), ...imports.map((one) => one.specifier)];
-    const answers = project.symbolsAt(asked.map((node) => project.handle(node)));
-    const moduleOf = (at) => {
-        const symbol = answers[at];
-        return symbol === undefined || symbol === UNANSWERED ? undefined : symbol.id;
-    };
-    const named = namedBy(held);
-    const found = [];
-    imports.forEach((one, index) => {
-        const resolved = moduleOf(declared.length + index);
-        const position = renderPosition(one.file, root, one.specifier.getStart());
-        const read = (to, resolution, test) => {
-            found.push({ from: one.from, to, position, use: "read", resolution, test });
-        };
-        const test = testFiles.has(position.path);
-        const same = new Set(declared
-            .filter((_, at) => resolved !== undefined && resolved === moduleOf(at))
-            .map((declaration) => declaration.id));
-        for (const id of same) {
-            read(id, "batch", test);
-        }
-        for (const declaration of named(one.specifier.text, one.names)) {
-            // A wildcard declaration is how the compiler types the file a matching specifier
-            // names, so the import uses it whoever writes it, a test included.
-            if (declaration.wildcard || !same.has(declaration.id)) {
-                for (const to of [declaration.id, ...declaration.members]) {
-                    read(to, "syntax", test && !declaration.wildcard);
+export const moduleDeclarations = {
+    start() {
+        const imports = [];
+        return {
+            visit(node, { file, from }) {
+                const specifier = specifierOf(node);
+                if (specifier !== undefined) {
+                    imports.push({ file, from, specifier, names: namesImported(node) });
                 }
-            }
-        }
-    });
-    return found;
-}
+            },
+            reads({ project, held }) {
+                const found = [];
+                // A module declaration whose name is a string is written at a file's top level.
+                const declared = project.ownSourceFiles().flatMap((file) => file.statements.flatMap((statement) => {
+                    const id = held.declarations.get(nodeKey(file, statement));
+                    return isModuleDeclaration(statement) && literalText(statement.name) && id !== undefined
+                        ? [{ id, name: statement.name }]
+                        : [];
+                }));
+                if (declared.length === 0 || imports.length === 0) {
+                    return found;
+                }
+                const asked = [...declared.map((one) => one.name), ...imports.map((one) => one.specifier)];
+                const answers = project.symbolsAt(asked.map((node) => project.handle(node)));
+                const moduleOf = (at) => {
+                    const symbol = answers[at];
+                    return symbol === undefined || symbol === UNANSWERED ? undefined : symbol.id;
+                };
+                const named = namedBy(held);
+                imports.forEach((one, index) => {
+                    const resolved = moduleOf(declared.length + index);
+                    const read = (to, via, production) => {
+                        found.push({
+                            kind: "named",
+                            from: one.from,
+                            to,
+                            file: one.file,
+                            at: one.specifier,
+                            use: "read",
+                            via,
+                            ...(production ? { production: true } : {}),
+                        });
+                    };
+                    const same = new Set(declared
+                        .filter((_, at) => resolved !== undefined && resolved === moduleOf(at))
+                        .map((declaration) => declaration.id));
+                    for (const id of same) {
+                        read(id, "batch", false);
+                    }
+                    for (const declaration of named(one.specifier.text, one.names)) {
+                        // A wildcard declaration is how the compiler types the file a matching specifier
+                        // names, so the import uses it whoever writes it, a test included.
+                        if (declaration.wildcard || !same.has(declaration.id)) {
+                            for (const to of [declaration.id, ...declaration.members]) {
+                                read(to, "syntax", declaration.wildcard);
+                            }
+                        }
+                    }
+                });
+                return found;
+            },
+        };
+    },
+};