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

package/dist/src/injection-container.js

@@ -10,7 +10,7 @@ import { isClassDeclaration, isClassExpression, isConstructorDeclaration, isGetA
 import { aliasChains } from "./alias-chain.js";
 import { calleeName, callsOf, classesPassed, decoratorsOf, spelledDecorator } from "./calls.js";
 import { classMembers } from "./class-members.js";
-import { entriesAt, namesADeclaration, resolveEntries, spelledEntry, } from "./configured-declarations.js";
+import { entriesAt, namesADeclaration, resolveEntries, spelledEntry, } from "./roots/configured-declarations.js";
 import { isParameterProperty, nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 /** Whether one member declaration is a parameter property, or a property or accessor carrying a decorator. */

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

@@ -1,16 +1,17 @@
 import { isArrayBindingPattern, isArrowFunction, isAssignmentOperator, isAwaitExpression, isBinaryExpression, isBindingElement, isCallExpression, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isComputedPropertyName, isDeleteExpression, isElementAccessExpression, isEqualityOperator, isExpressionStatement, isForOfStatement, isFunctionDeclaration, isFunctionExpression, isFunctionLikeDeclaration, isGetAccessorDeclaration, isIdentifier, isIfStatement, isMetaProperty, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isSetAccessorDeclaration, isShorthandPropertyAssignment, isSourceFile, isSpreadAssignment, isStringLiteral, isTypeOfExpression, isVariableDeclaration, isVariableDeclarationList, isVariableStatement, ModifierFlags, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
 import { componentOf, modifiersOf, } from "../inventory.js";
+import { callsPlatformBy, lexicalBinding, writtenName } from "../platform-calls.js";
 import { spellsNoBinding } from "../spelled-names.js";
 import { unwrapped } from "../unwrap.js";
 /**
  * The export table of a CommonJS file: the module value `module.exports` is assigned and
  * the properties written on it, read from the top-level unconditional statements in order,
  * as Node runs them (https://nodejs.org/api/modules.html#moduleexports). Each entry is
- * keyed by the node that writes it, which is the checker's declaration of the export where
- * it binds one, so the two name one subject. Any other write of the exports opens the
- * table: its entries are kept and the file is listed open.
+ * keyed by the node that writes it, the checker's declaration of the export where it binds
+ * one. Any other write of the exports opens the table: its entries are kept and the file is
+ * listed open. `declarationOf` reads a `require()` call through the file's own scopes.
  */
-export function commonJS(typeIsModule, resolved) {
+export function commonJS(typeIsModule, resolved, declarationOf) {
     return {
         declare(file, owner, into) {
             if (!isCommonJS(file, owner.position.path, typeIsModule)) {
@@ -18,7 +19,7 @@ export function commonJS(typeIsModule, resolved) {
             }
             const bound = boundOccurrences(file, resolved);
             const free = (node) => !bound.has(node);
-            const table = readTable(file, free, topLevelDeclarations(file));
+            const table = readTable(file, free, topLevelDeclarations(file), lexicalBinding(declarationOf));
             const open = table.open || opens(file, free, table.modelled);
             for (const entry of table.entries.values()) {
                 const record = into.declare(entry.node, owner, entry.kind, entry.name, {
@@ -176,24 +177,33 @@ function topLevelDeclarations(file) {
 }
 const DEFAULT = { text: "default", computed: false };
 /** The table one file's top-level unconditional statements write, in order. */
-function readTable(file, isFree, declarations) {
+function readTable(file, isFree, declarations, bindingOf) {
     const entries = new Map();
     const modelled = new Set();
+    // Written inside the closures below, which the compiler's narrowing does not follow.
     let open = false;
     let aliasing = true;
+    let whole;
+    let wholeOpen = false;
     const free = (node, name) => isIdentifier(node) && node.text === name && isFree(node);
     const isModuleExports = (node) => isPropertyAccessExpression(node) &&
         free(node.expression, "module") &&
         node.name.text === "exports";
-    const isRequire = (node) => isCallExpression(node) &&
-        free(node.expression, "require") &&
-        node.arguments.length === 1 &&
-        node.arguments[0] !== undefined &&
-        isLiteralText(node.arguments[0]);
+    const isRequire = (node) => {
+        if (!isCallExpression(node) || node.arguments.length !== 1) {
+            return false;
+        }
+        const [argument] = node.arguments;
+        const callee = writtenName(node.expression);
+        return (argument !== undefined &&
+            isLiteralText(argument) &&
+            callee !== undefined &&
+            callsPlatformBy("require", callee, bindingOf));
+    };
     /** What a value written under one key declares. */
     const entryOf = (component, node, name, value) => {
         const held = value === undefined ? undefined : unwrapped(value);
-        const base = { node, name, component, localName: undefined };
+        const base = { node, name, component, localName: undefined, value };
         if (held === undefined) {
             return { ...base, kind: "variable" };
         }
@@ -245,6 +255,7 @@ function readTable(file, isFree, declarations) {
     /** The module value one assignment writes, placed at the `exports` name it assigns. */
     const moduleValue = (node, name) => {
         entries.clear();
+        whole = node.right;
         const value = unwrapped(node.right);
         if (isRequire(value)) {
             return;
@@ -253,7 +264,7 @@ function readTable(file, isFree, declarations) {
             value.properties.forEach(literalProperty);
             return;
         }
-        const base = { node, name, component: DEFAULT };
+        const base = { node, name, component: DEFAULT, value: node.right };
         const target = isIdentifier(value) ? declarations.get(value.text) : undefined;
         if (target !== undefined) {
             entries.set("default", { ...base, localName: undefined, kind: "export-alias", target });
@@ -273,7 +284,7 @@ function readTable(file, isFree, declarations) {
             });
         }
         else {
-            open = true;
+            wholeOpen = true;
         }
     };
     /** Whether one expression is the exports object a top-level write may name here. */
@@ -300,8 +311,17 @@ function readTable(file, isFree, declarations) {
             }
             else if (isModuleExports(left)) {
                 modelled.add(expression);
-                moduleValue(expression, left.name);
-                aliasing = false;
+                const inner = unwrapped(expression.right);
+                const chained = isBinaryExpression(inner) &&
+                    inner.operatorToken.kind === SyntaxKind.EqualsToken &&
+                    free(inner.left, "exports")
+                    ? inner
+                    : undefined;
+                if (chained !== undefined) {
+                    modelled.add(chained);
+                }
+                moduleValue(chained ?? expression, left.name);
+                aliasing = chained !== undefined;
             }
             else if (isPropertyAccessExpression(left) || isElementAccessExpression(left)) {
                 const object = exportsObject(left.expression);
@@ -332,7 +352,32 @@ function readTable(file, isFree, declarations) {
             }
         }
     }
-    return { entries, open, modelled };
+    return { entries, open: open || wholeOpen, modelled, whole, membersOpen: open };
+}
+/**
+ * The module value one file leaves where Node runs it as CommonJS, read by the one table
+ * the inventory's export table reads, or undefined where the file writes module syntax.
+ * `declarationOf` names the declaration each name resolves to, undefined for none, as a
+ * lexical reading of a file outside every program answers it.
+ */
+export function commonJSModuleValue(file, declarationOf) {
+    if (writesModuleSyntax(file)) {
+        return undefined;
+    }
+    const free = (node) => {
+        const declaration = isIdentifier(node) ? declarationOf(node) : undefined;
+        return declaration === undefined || !bindsOwn(declaration, file);
+    };
+    const table = readTable(file, free, topLevelDeclarations(file), lexicalBinding(declarationOf));
+    const held = table.whole === undefined ? undefined : unwrapped(table.whole);
+    const members = [...table.entries.values()].flatMap((entry) => entry.component === DEFAULT && held !== undefined && !isObjectLiteralExpression(held)
+        ? []
+        : [{ key: entry.component.text, value: entry.value, node: entry.node }]);
+    return {
+        whole: held === undefined || isObjectLiteralExpression(held) ? undefined : table.whole,
+        members,
+        open: table.membersOpen || opens(file, free, table.modelled),
+    };
 }
 /** Whether one node is `Object.defineProperty`. */
 function isDefineProperty(node) {

package/dist/src/inventory/enumerate.js

@@ -4,6 +4,7 @@ import { packageScope, packageTypeIsModule } from "../load/package-scope.js";
 import { relativePath } from "../paths.js";
 import { renderPosition } from "../position.js";
 import { isAnswered, UNANSWERED } from "../query.js";
+import { declarationOf } from "../entries/static-module.js";
 import { commonJS } from "./commonjs.js";
 import { SYNTAX } from "./syntax.js";
 /**
@@ -18,7 +19,7 @@ export function inventory(project, host, targetRoot) {
     const moduleOf = packageScope(host, targetRoot);
     const sources = [
         SYNTAX,
-        commonJS(packageTypeIsModule(host, targetRoot), resolvedIn(project)),
+        commonJS(packageTypeIsModule(host, targetRoot), resolvedIn(project), declarationOf),
     ];
     const into = new Builder(targetRoot);
     for (const file of files) {

package/dist/src/javascript-file.js

@@ -1,26 +1,41 @@
+import { LANGUAGE_ROWS } from "./contract/contract.generated.js";
+import { globExpression } from "./text/glob.js";
 export const JAVASCRIPT_FILE = /\.(?:js|jsx|mjs|cjs)$/u;
-/** A minified file by its name; any other is one by its size and its mean line length. */
-const MINIFIED_NAME = /\.min\.(?:js|mjs|cjs)$/u;
+/** The patterns the TypeScript row of `languages.json` skips files by, each matched against a name alone. */
+const MINIFIED_NAMES = LANGUAGE_ROWS.ts.skippedFiles.map((pattern) => ({
+    pattern,
+    expression: globExpression(pattern),
+}));
 const MINIFIED_BYTES = 10_240;
 const MINIFIED_LINE = 500;
-/** Whether one name is a minified file's, which decides it without its text. */
+/** What a minified file is decided by where its text is not read. */
+const LONG_LINES = "long lines";
+/** The skipped-file pattern one file's name matches, which decides it minified without its text. */
 export function minifiedByName(fileName) {
-    return MINIFIED_NAME.test(fileName);
+    const name = fileName.slice(fileName.lastIndexOf("/") + 1);
+    return MINIFIED_NAMES.find((one) => one.expression.test(name))?.pattern;
 }
-/** Whether one JavaScript file is minified: by its name, or by its text's size and mean line length. */
-export function minified(fileName, text) {
+/**
+ * What decides one JavaScript file minified: the skipped-file pattern its name matches, or
+ * {@link LONG_LINES} for a text of the size whose mean line is longer than the limit;
+ * undefined for a file that is not minified.
+ */
+export function minifiedBy(fileName, text) {
     if (!JAVASCRIPT_FILE.test(fileName)) {
-        return false;
+        return undefined;
     }
-    if (minifiedByName(fileName)) {
-        return true;
+    const named = minifiedByName(fileName);
+    if (named !== undefined) {
+        return named;
     }
     // A UTF-16 unit encodes to at most three UTF-8 bytes, so a shorter text is below the size.
     if (text.length * 3 < MINIFIED_BYTES) {
-        return false;
+        return undefined;
     }
     const lines = text.split(/\r?\n/u).length;
-    return utf8Bytes(text) >= MINIFIED_BYTES && text.length / lines > MINIFIED_LINE;
+    return utf8Bytes(text) >= MINIFIED_BYTES && text.length / lines > MINIFIED_LINE
+        ? LONG_LINES
+        : undefined;
 }
 /** The length of a text in UTF-8, a lone surrogate counting as the three bytes of U+FFFD. */
 function utf8Bytes(text) {

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

@@ -1,9 +1,9 @@
-import { conventionFailuresFor } from "../conventions.js";
+import { conventionFailuresFor } from "../entries/conventions.js";
 import { relativePath, resolvePath } from "../paths.js";
 import { diagnosticsOf, ownedAs } from "../session.js";
 import { skipAt } from "../type-errors.js";
 import { classOf, MISSING_GLOBAL_TYPE, projectErrors, renderDiagnostic, } from "./diagnostics.js";
-import { targetRelative } from "./discover.js";
+import { targetRelative, unreadableDetail, } from "./discover.js";
 import { missingModule, pathsOf } from "./expected-module.js";
 import { FailureExit, failureLine } from "../failure.js";
 import { JAVASCRIPT_FILE } from "../javascript-file.js";
@@ -80,7 +80,7 @@ function classifyTarget(engine, host, run, plan, view, unfound) {
     const raw = projectErrors(diagnosticsOf(project));
     const load = nonEmpty(raw.load);
     if (load !== undefined) {
-        return { kind: "load", errors: load };
+        return { kind: "load", errors: load, unreadable: raw.unreadable };
     }
     const reading = readErrors(project, plan, ownErrors(raw.check, referenceOnly), {
         host,
@@ -134,7 +134,7 @@ function classifyConsumer(engine, host, run, plan, consumer, project) {
     const raw = projectErrors(diagnosticsOf(project));
     const load = nonEmpty(raw.load);
     if (load !== undefined) {
-        return { kind: "load", errors: load };
+        return { kind: "load", errors: load, unreadable: raw.unreadable };
     }
     let faulted;
     const reading = readErrors(project, plan, raw.check, {
@@ -173,7 +173,7 @@ function ending(plan, failed, root) {
     return plan.consumer === undefined
         ? [
             {
-                failureClass: "no-program",
+                failureClass: failed.kind === "load" && failed.unreadable ? "unreadable-configuration" : "no-program",
                 detail: `${what}: correct the configuration, or name the configurations to analyze`,
             },
         ]
@@ -184,6 +184,22 @@ function ending(plan, failed, root) {
             },
         ];
 }
+/** The setup failures a dropped derived configuration counts as, where it counts as any. */
+function droppedFailures(failed, plan, root) {
+    if (failed.kind === "setup") {
+        return { failures: failed.failures };
+    }
+    return failed.kind === "load" && failed.unreadable
+        ? {
+            failures: [
+                {
+                    failureClass: "unreadable-configuration",
+                    detail: unreadableDetail(plan.id, `cannot be read as a compiler configuration: ${droppedBy(failed, root)}`),
+                },
+            ],
+        }
+        : {};
+}
 /** The first line of the error that drops one derived configuration. */
 function droppedBy(failed, root) {
     return failed.kind === "load"
@@ -206,7 +222,6 @@ export function classify(engine, host, run, views) {
     const analyzed = [];
     const consumed = [];
     const ended = new Map();
-    const dropped = [];
     const unopened = run.plans.filter((plan) => !views.has(plan.configFile));
     const outcomes = [
         ...run.plans.flatMap((plan) => {
@@ -237,8 +252,12 @@ export function classify(engine, host, run, views) {
             ended.set(outcome.kind, [...(ended.get(outcome.kind) ?? []), { plan, failed: outcome }]);
         }
         else {
-            dropped.push(outcome);
-            notBuilt.push({ id: plan.id, configFile: plan.configFile, error: droppedBy(outcome, root) });
+            notBuilt.push({
+                id: plan.id,
+                configFile: plan.configFile,
+                error: droppedBy(outcome, root),
+                ...droppedFailures(outcome, plan, root),
+            });
         }
     }
     for (const kind of ["unopened", "setup", "load"]) {
@@ -248,7 +267,7 @@ export function classify(engine, host, run, views) {
             throw new FailureExit(kind === "unopened" ? [failures[0]] : failures, all.flatMap(({ failed }) => (failed.kind === "load" ? failed.errors : [])));
         }
     }
-    const setupDropped = nonEmpty(dropped.flatMap((one) => (one.kind === "setup" ? one.failures : [])));
+    const setupDropped = nonEmpty(notBuilt.flatMap((one) => one.failures ?? []));
     const [first] = notBuilt;
     if (analyzed.length === 0 && first !== undefined) {
         throw new FailureExit(setupDropped ?? [

package/dist/src/load/diagnostics.js

@@ -68,12 +68,19 @@ function locatedIn(diagnostics, locate) {
 export function diagnosticErrors(sets) {
     return [...sets.configParsing, ...sets.syntactic, ...sets.semantic].filter(isError);
 }
+/**
+ * The code of a configuration whose only parse error is that its inputs name no file: it reads
+ * as written and holds no program.
+ */
+const NO_INPUTS = 18003;
 /** The errors one open project carries, each located in the file it names. */
 export function projectErrors(sets) {
     const unplaced = (kind) => sets.unplaced.filter((diagnostic) => classOf(diagnostic, false) === kind);
-    const load = [...sets.configParsing.filter(isError), ...unplaced("load")];
+    const parsing = sets.configParsing.filter(isError);
+    const load = [...parsing, ...unplaced("load")];
     return {
         load: locatedIn(load, sets.locate),
+        unreadable: parsing.some(({ code }) => code !== NO_INPUTS),
         check: load.length > 0 ? [] : locatedIn(diagnosticErrors(sets), sets.locate),
         unfound: load.length > 0 ? [] : locatedIn(unplaced("unfound-library"), sets.locate),
     };