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

package/dist/src/load/discover.js

@@ -66,11 +66,9 @@ function readConfiguration(engine, configFile) {
     try {
         const parsed = engine.parseConfigFile(configFile);
         const circular = parsed.errors.find(({ code }) => code === CIRCULAR_EXTENDS);
-        // The compiler leaves the message's `{0}` unfilled:
-        // https://github.com/microsoft/TypeScript/pull/64755
         return circular === undefined
             ? { parsed }
-            : { reason: `TS${String(circular.code)}: ${circular.text.replace("{0}", () => configFile)}` };
+            : { reason: `TS${String(circular.code)}: ${circular.text}` };
     }
     catch (error) {
         return { reason: message(error) };
@@ -137,8 +135,12 @@ export function targetWithoutSources(target) {
     return failureExit("no-program", `${target} holds no compiler configuration, no file named ${MARKERS.join(", ")}, and no JavaScript file: run from the directory that holds one, or name the languages to analyze`);
 }
 /** A target configuration a matrix or the invocation names that cannot be built, ending the run. */
-function unbuilt(named, reason) {
-    throw failureExit("no-program", `${named} ${reason}: correct the configuration, or name the configurations to analyze`);
+function unbuilt(named, reason, failureClass = "no-program") {
+    throw failureExit(failureClass, unreadableDetail(named, reason));
+}
+/** What fails and the fix, for a configuration `named` that `reason` keeps from being built. */
+export function unreadableDetail(named, reason) {
+    return `${named} ${reason}: correct the configuration, or name the configurations to analyze`;
 }
 /**
  * The projects a build matrix declares, in its order, each a file below the target root, a
@@ -172,7 +174,7 @@ function declaredProjects(engine, host, targetRoot, entries) {
         }
         const read = readConfiguration(engine, configFile);
         if ("reason" in read) {
-            unbuilt(named, `cannot be read as a compiler configuration: ${read.reason}`);
+            unbuilt(named, `cannot be read as a compiler configuration: ${read.reason}`, "unreadable-configuration");
         }
         references.set(configFile, referencesOf(read.parsed));
         const configuration = {
@@ -212,13 +214,19 @@ function derivedProjects(engine, host, scope) {
     const idOf = (configFile) => relativePath(targetRoot, configFile) ?? configFile;
     const notBuilt = [];
     const found = derivedFrom(engine, host, [...fromScope, ...configFilesUnder(host, targetRoot)], (reference) => relativePath(rootDir, reference) !== undefined, (configFile, reason) => {
+        const why = `cannot be read as a compiler configuration: ${reason}`;
         if (fromScope.includes(configFile)) {
-            unbuilt(configFile, `cannot be read as a compiler configuration: ${reason}`);
+            unbuilt(configFile, why, "unreadable-configuration");
         }
+        const failure = {
+            failureClass: "unreadable-configuration",
+            detail: targetRelative(unreadableDetail(idOf(configFile), why), absoluteRoot),
+        };
         notBuilt.push({
             id: idOf(configFile),
             configFile,
             error: targetRelative(reason, absoluteRoot),
+            failures: [failure],
         });
     });
     const configurations = found.map(({ configFile, parsed }) => ({

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/plan.js

@@ -1,7 +1,7 @@
-import { readConventions } from "../conventions.js";
+import { readConventions, } from "../entries/conventions.js";
 import { holdsManifest, inInstalledPackages, MANIFEST, readManifestAt } from "../fs/manifest.js";
 import { gitIgnored } from "../git-ignore.js";
-import { packageEntries, readManifest } from "../manifest.js";
+import { packageEntries, readManifest, } from "../roots/manifest.js";
 import { ancestors, dirnamePath, joinPath, normalizePath, relativePath, resolvePath, } from "../paths.js";
 import { bytewise } from "../text/compare.js";
 import { globExpression } from "../text/glob.js";

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

@@ -5,12 +5,12 @@
  * is written for.
  */
 import { readCommands } from "../commands/read.js";
-import { CONVENTION_ROWS } from "../convention-rows.js";
+import { CONVENTION_ROWS } from "../entries/convention-rows.js";
 import { holdsManifest, MANIFEST, readManifestAt } from "../fs/manifest.js";
 import { filesBelow } from "../fs/tree.js";
-import { JAVASCRIPT_FILE, minified, minifiedByName } from "../javascript-file.js";
+import { JAVASCRIPT_FILE, minifiedBy, minifiedByName } from "../javascript-file.js";
 import { isRecord } from "../json-document.js";
-import { manifestCommands } from "../manifest.js";
+import { manifestCommands } from "../roots/manifest.js";
 import { ancestors, dirnamePath, joinPath, relativePath } from "../paths.js";
 import { bytewise } from "../text/compare.js";
 import { writtenPath } from "./workspace-programs.js";
@@ -33,11 +33,11 @@ const FORMED_OPTIONS = {
 };
 /** Whether one file is minified build output; one that cannot be read is left to the compiler. */
 function minifiedFile(host, file) {
-    if (minifiedByName(file)) {
+    if (minifiedByName(file) !== undefined) {
         return true;
     }
     try {
-        return minified(file, host.readFile(file));
+        return minifiedBy(file, host.readFile(file)) !== undefined;
     }
     catch {
         return false;
@@ -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-manifests.js

@@ -6,7 +6,7 @@
  * workspace imports, so only its commands are entry points.
  */
 import { emittedFrom } from "./emit-map.js";
-import { readManifest } from "../manifest.js";
+import { readManifest } from "../roots/manifest.js";
 import { joinPath, relativePath } from "../paths.js";
 import { MANIFEST } from "../fs/manifest.js";
 /** The one character a subpath pattern of a manifest's `exports` holds. */

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.
@@ -81,19 +82,12 @@ export function matrixOf(per) {
     };
 }
 /**
- * Answers which declarations of the run are dead in every configuration that holds them.
- *
- * Liveness is a question about one configuration, because a file another configuration
- * does not compile makes no reference there and a root it does not hold seeds nothing
- * there, so each configuration is swept on its own graph under the run's input. A
- * declaration is a candidate when every configuration holding it judged it one: a
- * reference under one configuration is a reference, so what one project uses is never
- * reported, and a configuration that does not hold a declaration says nothing about it.
- * The candidate's relation is reference counting where every configuration found it so,
- * and reachability otherwise; its counts are the union's, one per reference.
- *
- * The components are computed once, over the union and the intersected dead set, so one
- * dead component is one entry of the run with one identifier.
+ * Which declarations of the run are dead in every configuration that holds them. Each
+ * configuration is swept on its own graph, since a file it does not compile references nothing
+ * there and a root it does not hold seeds nothing. A declaration is a candidate when every
+ * configuration holding it judged it one; its relation is reference counting where every one
+ * found it so, else reachability, and its counts are the union's. Components are computed once,
+ * over the union and the intersected dead set, so one dead component has one identifier.
  */
 export function sweepMatrix(matrix, input) {
     const per = matrix.graphs.map((graph) => sweep(graph, input));
@@ -140,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,
@@ -188,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;
+            },
+        };
+    },
+};