@cplieger/deadset-ts 3.13.0 → 4.0.0

package/dist/src/configured-declarations.js

@@ -7,6 +7,7 @@
 import { isCallExpression, isExportDeclaration, isExternalModuleReference, isImportDeclaration, isImportEqualsDeclaration, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { SymbolFlags, } from "@typescript/native/unstable/sync";
 import { resolvedTargets } from "./calls.js";
+import { must, Unanswerable } from "./query.js";
 import { nameComponent } from "./ref.js";
 /** The meanings a name of the global scope is looked up under: any of them. */
 const ANY_MEANING = SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace;
@@ -55,7 +56,7 @@ function unaliased(project, symbol) {
     if ((symbol.flags & SymbolFlags.Alias) === 0) {
         return symbol;
     }
-    const target = project.checker.getAliasedSymbol(symbol);
+    const target = must(project.queries.aliased(symbol));
     return target.declarations.length === 0 ? undefined : target;
 }
 /** Whether one symbol is a member a class declares: a property, a method or an accessor. */
@@ -68,20 +69,20 @@ function isClassMember(symbol) {
  * with the static suffix names one of the first and a component without it names an
  * instance member or one of the second.
  */
-function candidatesOf(container, isStatic) {
-    const exported = [...container.getExports().values()];
+function candidatesOf(project, container, isStatic) {
+    const exported = [...must(project.queries.exportsOf(container)).values()];
     if (isStatic) {
         return exported.filter(isClassMember);
     }
     const isClass = (container.flags & SymbolFlags.Class) !== 0;
     return [
-        ...container.getMembers().values(),
+        ...must(project.queries.membersOf(container)).values(),
         ...exported.filter((member) => !isClass || !isClassMember(member)),
     ];
 }
 /** The member of one container a path component spells, followed through any alias. */
 function memberOf(project, container, component, isStatic) {
-    const member = candidatesOf(container, isStatic).find((candidate) => nameComponent(candidate.name) === component);
+    const member = candidatesOf(project, container, isStatic).find((candidate) => nameComponent(candidate.name) === component);
     return member === undefined ? undefined : unaliased(project, member);
 }
 /** The declaration a path names from one starting symbol, component by component. */
@@ -131,7 +132,7 @@ function modulesNamed(project, specifiers) {
         file.forEachChild(visit);
     }
     const specified = [...written];
-    const symbols = project.symbolsAt(specified.map(([, node]) => project.handle(node)));
+    const symbols = project.symbolsAt(specified.map(([, node]) => project.handle(node))).map(must);
     const modules = new Map();
     specified.forEach(([name], index) => {
         const symbol = symbols[index];
@@ -171,7 +172,7 @@ export function resolveEntries(project, held, entries) {
             start = module === undefined ? undefined : memberOf(project, module, first, false);
         }
         else if (nameComponent(first) === first) {
-            const global = project.checker.resolveName(first, ANY_MEANING, undefined, false);
+            const global = must(project.queries.resolveName(first, ANY_MEANING, undefined, false));
             start = global === undefined ? undefined : unaliased(project, global);
         }
         const declared = walkPath(project, start, rest, isStatic);
@@ -247,9 +248,21 @@ export function configuredDeclarations(config) {
         ...config.ts.serializers.map((entry) => ({ key: "ts.serializers", entry })),
     ];
 }
-/** Whether each configured entry names a declaration in one project, in the entries' order. */
+/**
+ * Whether each configured entry names a declaration in one project, in the entries'
+ * order. Where the checker leaves a question of the resolution unanswered, every entry
+ * counts as naming one, so no entry is reported as naming nothing on a gap.
+ */
 export function declarationsNamed(project, held, configured) {
-    return resolveEntries(project, held, configured.map((one) => one.entry)).map(namesADeclaration);
+    try {
+        return resolveEntries(project, held, configured.map((one) => one.entry)).map(namesADeclaration);
+    }
+    catch (error) {
+        if (!(error instanceof Unanswerable)) {
+            throw error;
+        }
+        return configured.map(() => true);
+    }
 }
 /**
  * The reference a finding about a configured entry names it by, the entry as the

package/dist/src/dependencies.js

@@ -8,7 +8,7 @@
 import { isExportDeclaration, isExternalModuleReference, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isNamespaceExport, isShorthandPropertyAssignment, isStringLiteral, isNoSubstitutionTemplateLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { nodeKey, packageScope } from "./inventory.js";
 import { dirnamePath, isAbsolutePath, joinPath, resolvePath } from "./paths.js";
-import { DEFAULT_BATCH_CAP } from "./references.js";
+import { UNANSWERED } from "./query.js";
 const MANIFEST = "package.json";
 const MODULES_DIR = "node_modules";
 const MODULES_SEGMENT = `/${MODULES_DIR}/`;
@@ -207,10 +207,11 @@ export function projectNeeds(project, held, host) {
         }
     };
     use([PROJECT_OWNER], packages);
+    let unanswered = false;
     for (const file of project.ownSourceFiles()) {
-        fileNeeds(project, held, file, programPackages, use);
+        unanswered = fileNeeds(project, held, file, programPackages, use) || unanswered;
     }
-    return { packages, uses };
+    return { packages, uses, unanswered };
 }
 /** The declarations of the inventory a use written at one node belongs to. */
 function ownersOf(file, held, node) {
@@ -235,6 +236,7 @@ function ownersOf(file, held, node) {
     }
     return [PROJECT_OWNER];
 }
+/** Records the needs of one file, and answers whether a specifier of it went unanswered. */
 function fileNeeds(project, held, file, programPackages, use) {
     const specifiers = [...file.imports, ...file.moduleAugmentations].filter(isLiteralText);
     const bindings = [];
@@ -262,13 +264,8 @@ function fileNeeds(project, held, file, programPackages, use) {
         visit(file);
     }
     const asked = [...specifiers, ...bindings.map(({ node }) => node), ...candidates];
-    const resolved = [];
-    for (let at = 0; at < asked.length; at += DEFAULT_BATCH_CAP) {
-        const handles = asked
-            .slice(at, at + DEFAULT_BATCH_CAP)
-            .map((node) => project.handle(node));
-        resolved.push(...project.symbolsAt(handles));
-    }
+    const handles = asked.map((node) => project.handle(node));
+    const resolved = project.symbolsAt(handles);
     const packagesOf = new Map();
     specifiers.forEach((specifier, index) => {
         const named = new Set();
@@ -276,7 +273,8 @@ function fileNeeds(project, held, file, programPackages, use) {
         if (byName !== undefined) {
             named.add(byName);
         }
-        for (const declaration of resolved[index]?.declarations ?? []) {
+        const symbol = resolved[index];
+        for (const declaration of typeof symbol === "object" ? symbol.declarations : []) {
             const byPath = packageOfPath(declaration.path);
             if (byPath !== undefined) {
                 named.add(byPath);
@@ -284,11 +282,20 @@ function fileNeeds(project, held, file, programPackages, use) {
         }
         packagesOf.set(specifier, [...named]);
     });
+    // A name the checker could not resolve counts as a use of every package a binding of
+    // that name brings in, so a gap never makes a dependency read as unused.
     const bySymbol = new Map();
-    bindings.forEach(({ specifier }, index) => {
+    const byName = new Map();
+    const unresolvedNames = new Set();
+    bindings.forEach(({ node, specifier }, index) => {
+        const packages = packagesOf.get(specifier) ?? [];
+        byName.set(node.text, [...(byName.get(node.text) ?? []), ...packages]);
         const symbol = resolved[specifiers.length + index];
-        if (symbol !== undefined) {
-            bySymbol.set(symbol.id, packagesOf.get(specifier) ?? []);
+        if (symbol === UNANSWERED) {
+            unresolvedNames.add(node.text);
+        }
+        else if (symbol !== undefined) {
+            bySymbol.set(symbol.id, packages);
         }
     });
     for (const specifier of specifiers) {
@@ -304,7 +311,12 @@ function fileNeeds(project, held, file, programPackages, use) {
         if (parent !== undefined && isShorthandPropertyAssignment(parent) && parent.name === node) {
             symbol = project.shorthandValueAt(project.handle(node));
         }
-        const named = symbol === undefined ? undefined : bySymbol.get(symbol.id);
+        const named = symbol === UNANSWERED || (unresolvedNames.has(node.text) && symbol === undefined)
+            ? byName.get(node.text)
+            : symbol === undefined
+                ? undefined
+                : (bySymbol.get(symbol.id) ??
+                    (unresolvedNames.has(node.text) ? byName.get(node.text) : undefined));
         if (named !== undefined) {
             use(ownersOf(file, held, node), named);
         }
@@ -312,6 +324,7 @@ function fileNeeds(project, held, file, programPackages, use) {
     for (const reference of file.typeReferenceDirectives) {
         use(ownersOf(file, held, file), typePackages(reference.fileName, programPackages));
     }
+    return resolved.slice(0, specifiers.length).includes(UNANSWERED);
 }
 /** The offset just past the JSON value that starts at `at` in text the parser has accepted. */
 function valueEnd(text, at) {
@@ -470,12 +483,16 @@ export function dependenciesOf(host, targetRoot, perProject, candidates) {
     const needed = new Set();
     const uses = new Map();
     for (const project of perProject) {
-        project.packages.forEach((one) => needed.add(one));
-        for (const [id, used] of project.uses) {
+        // A specifier the checker left unanswered may resolve to any declared dependency,
+        // and what the configuration needs is never deleted, so it is needed there.
+        const unknown = project.unanswered ? declared.map((dependency) => dependency.name) : [];
+        const held = unknown.length === 0 ? [] : [[PROJECT_OWNER, new Set(unknown)]];
+        for (const [id, used] of [...project.uses, ...held]) {
             const merged = uses.get(id) ?? new Set();
             used.forEach((one) => merged.add(one));
             uses.set(id, merged);
         }
+        [...project.packages, ...unknown].forEach((one) => needed.add(one));
     }
     const users = new Map();
     for (const used of uses.values()) {

package/dist/src/deprecation.js

@@ -8,7 +8,7 @@
  */
 import { isVariableStatement, SyntaxKind } from "@typescript/native/unstable/ast";
 import { nodeKey } from "./inventory.js";
-import { DEFAULT_BATCH_CAP } from "./references.js";
+import { isAnswered, UNANSWERED } from "./query.js";
 /** The tag the TypeScript tools recognize as marking a declaration deprecated. */
 const DEPRECATED_TAG = "deprecated";
 /** Whether one node's own documentation carries the deprecation tag. */
@@ -21,15 +21,15 @@ function nameNode(node) {
     return node.name ?? node;
 }
 /**
- * The identifiers of every declaration of one project that carries the deprecation
- * marker, in the inventory's order.
+ * The declarations of one project that carry the deprecation marker.
  *
  * The checker is asked only for a symbol with a declaration in a file whose tree holds
  * the tag, so a project whose files hold none costs no round trip, and one that does
- * costs one batch per file and one request per symbol that could carry the tag.
+ * costs one batch per file and one for the tags of the symbols that could carry it.
  */
 export function deprecatedDeclarations(project, held) {
     const marked = new Set();
+    const unknown = new Set();
     const markedPaths = new Set();
     const declared = [];
     for (const file of project.ownSourceFiles()) {
@@ -56,28 +56,39 @@ export function deprecatedDeclarations(project, held) {
         declared.push(named);
     }
     if (markedPaths.size > 0) {
-        const asked = new Map();
-        const carriesTag = (symbol) => {
-            const known = asked.get(symbol.id);
-            if (known !== undefined) {
-                return known;
+        const pairs = declared.flatMap((named) => {
+            const symbols = project.symbolsAt(named.map((one) => one.handle));
+            return named.flatMap((one, at) => {
+                const symbol = symbols[at];
+                if (symbol === UNANSWERED) {
+                    unknown.add(one.id);
+                }
+                return typeof symbol === "object" &&
+                    symbol.declarations.some((declaration) => markedPaths.has(declaration.path))
+                    ? [{ id: one.id, symbol }]
+                    : [];
+            });
+        });
+        const distinct = [...new Map(pairs.map((one) => [one.symbol.id, one.symbol])).values()];
+        const tags = project.queries.jsDocTags(distinct);
+        const unread = new Set(distinct.filter((_, at) => tags[at] === UNANSWERED).map((one) => one.id));
+        const carries = new Set(distinct.flatMap((symbol, at) => {
+            const read = tags[at];
+            return read !== undefined &&
+                isAnswered(read) &&
+                read.some((tag) => tag.name === DEPRECATED_TAG)
+                ? [symbol.id]
+                : [];
+        }));
+        for (const one of pairs) {
+            if (carries.has(one.symbol.id)) {
+                marked.add(one.id);
             }
-            const carries = symbol.declarations.some((declaration) => markedPaths.has(declaration.path)) &&
-                symbol.getJsDocTags(project.checker).some((tag) => tag.name === DEPRECATED_TAG);
-            asked.set(symbol.id, carries);
-            return carries;
-        };
-        for (const named of declared) {
-            for (let start = 0; start < named.length; start += DEFAULT_BATCH_CAP) {
-                const batch = named.slice(start, start + DEFAULT_BATCH_CAP);
-                project.symbolsAt(batch.map((one) => one.handle)).forEach((symbol, at) => {
-                    const one = batch[at];
-                    if (symbol !== undefined && one !== undefined && carriesTag(symbol)) {
-                        marked.add(one.id);
-                    }
-                });
+            if (unread.has(one.symbol.id)) {
+                unknown.add(one.id);
             }
         }
     }
-    return held.symbols.filter((symbol) => marked.has(symbol.id)).map((symbol) => symbol.id);
+    const inOrder = (ids) => held.symbols.filter((symbol) => ids.has(symbol.id)).map((symbol) => symbol.id);
+    return { deprecated: inOrder(marked), unanswered: inOrder(unknown) };
 }

package/dist/src/destructuring.js

@@ -7,6 +7,7 @@
  */
 import { isArrayLiteralExpression, isBinaryExpression, isForOfStatement, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParameterDeclaration, isParenthesizedExpression, isPropertyAssignment, isShorthandPropertyAssignment, isStringLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { TypeFlags } from "@typescript/native/unstable/sync";
+import { isAnswered, UNANSWERED } from "./query.js";
 /** The text a property name spells, or `undefined` for a computed name. */
 function nameText(node) {
     if (node === undefined) {
@@ -151,29 +152,22 @@ function sourceOf(target) {
  * places and a table answers every name of it.
  */
 export function destructuring(project, cap) {
-    const checker = project.checker;
+    const queries = project.queries;
     const tables = new Map();
     let patternBatches = 0;
     let patternLookups = 0;
-    const typesAt = (nodes) => {
-        const types = [];
-        for (let from = 0; from < nodes.length; from += cap) {
-            types.push(...checker.getTypeAtLocation(nodes.slice(from, from + cap)));
-            patternBatches += 1;
-        }
-        return types;
-    };
     const tableOf = (type) => {
         const known = tables.get(type.id);
         if (known !== undefined) {
             return known;
         }
-        const table = new Map();
+        let table = new Map();
         if ((type.flags & TypeFlags.AnyOrUnknown) === 0) {
             patternLookups += 1;
-            for (const property of checker.getPropertiesOfType(type)) {
-                table.set(property.name, property);
-            }
+            const properties = queries.propertiesOf(type);
+            table = isAnswered(properties)
+                ? new Map(properties.map((property) => [property.name, property]))
+                : UNANSWERED;
         }
         tables.set(type.id, table);
         return table;
@@ -183,7 +177,7 @@ export function destructuring(project, cap) {
             return type;
         }
         patternLookups += 1;
-        return checker.getNonNullableType(type);
+        return queries.nonNullable(type);
     };
     /**
      * The type one element of an array or tuple value has: a tuple's element at `index`,
@@ -193,33 +187,42 @@ export function destructuring(project, cap) {
         if (!type.isTypeReference()) {
             return undefined;
         }
-        patternLookups += 1;
-        if (checker.isTupleType(type)) {
+        if (type.isTupleType()) {
             if (index === undefined) {
                 return undefined;
             }
             patternLookups += 1;
-            return checker.getTypeArguments(type)[index];
+            const elements = queries.typeArguments(type);
+            return isAnswered(elements) ? elements[index] : UNANSWERED;
         }
         patternLookups += 1;
-        if (!checker.isArrayType(type)) {
+        const array = queries.isArray(type);
+        if (!isAnswered(array)) {
+            return UNANSWERED;
+        }
+        if (!array) {
             return undefined;
         }
         patternLookups += 1;
-        return checker.getTypeArguments(type)[0];
+        const elements = queries.typeArguments(type);
+        return isAnswered(elements) ? elements[0] : UNANSWERED;
     };
     const step = (type, next) => {
         const defined = definedOf(type);
-        if (defined === undefined) {
-            return undefined;
+        if (defined === undefined || defined === UNANSWERED) {
+            return defined;
         }
         if (next.kind === "property") {
-            const property = tableOf(defined).get(next.name);
+            const table = tableOf(defined);
+            if (!isAnswered(table)) {
+                return UNANSWERED;
+            }
+            const property = table.get(next.name);
             if (property === undefined) {
                 return undefined;
             }
             patternLookups += 1;
-            return checker.getTypeOfSymbol(property);
+            return queries.typeOfSymbol(property);
         }
         return elementOf(defined, next.kind === "element" ? next.index : undefined);
     };
@@ -238,11 +241,12 @@ export function destructuring(project, cap) {
                 asking.add(source.expression);
             }
         }
-        const answered = new Map();
         const asked = [...asking];
-        typesAt(asked).forEach((type, index) => {
+        patternBatches += Math.ceil(asked.length / cap);
+        const answered = new Map();
+        queries.typesAt(asked, cap).forEach((type, index) => {
             const node = asked[index];
-            if (type !== undefined && node !== undefined) {
+            if (node !== undefined) {
                 answered.set(node, type);
             }
         });
@@ -255,13 +259,17 @@ export function destructuring(project, cap) {
             }
             let type = answered.get(source.expression);
             for (const next of source.steps) {
-                type = type === undefined ? undefined : step(type, next);
+                type = type === undefined || type === UNANSWERED ? type : step(type, next);
             }
-            patternTypes.set(pattern, type === undefined ? undefined : definedOf(type));
+            patternTypes.set(pattern, type === undefined || type === UNANSWERED ? type : definedOf(type));
         }
         return reads.map((read) => {
             const type = patternTypes.get(read.pattern);
-            return type === undefined ? undefined : tableOf(type).get(read.name);
+            if (type === undefined || type === UNANSWERED) {
+                return type;
+            }
+            const table = tableOf(type);
+            return isAnswered(table) ? table.get(read.name) : UNANSWERED;
         });
     };
     return {

package/dist/src/discover.js

@@ -19,14 +19,35 @@ export class DiscoveryError extends Error {
         this.diagnostics = diagnostics;
     }
 }
+/** The category an error diagnostic carries, which the protocol sends as a number. */
+const ERROR_CATEGORY = DiagnosticCategory.Error;
 /** Whether one diagnostic is an error, which is what fails a run closed. */
 export function isError(diagnostic) {
-    return diagnostic.category === DiagnosticCategory.Error;
+    return diagnostic.category === ERROR_CATEGORY;
 }
-/** One diagnostic as a line naming its position, its code and its message. */
-export function renderDiagnostic(diagnostic) {
-    const where = diagnostic.fileName ?? "<no file>";
-    return `${where}:${String(diagnostic.pos)}: TS${String(diagnostic.code)}: ${diagnostic.text}`;
+/**
+ * One diagnostic as a line naming its file, its line and column, its code and its
+ * message: `path:line:column: TScode: message`, the position left out where the
+ * diagnostic names none and the file where it names none. `display` spells the
+ * file's path; it answers the path itself where it is not given.
+ */
+export function renderDiagnostic(located, display = (path) => path) {
+    const { diagnostic, at } = located;
+    const message = `TS${String(diagnostic.code)}: ${diagnostic.text}`;
+    if (diagnostic.fileName === undefined) {
+        return message;
+    }
+    const where = display(diagnostic.fileName);
+    return at === undefined
+        ? `${where}: ${message}`
+        : `${where}:${String(at.line)}:${String(at.column)}: ${message}`;
+}
+/** Each diagnostic with the line and column its offset falls on. */
+function locatedIn(diagnostics, locate) {
+    return diagnostics.map((diagnostic) => ({
+        diagnostic,
+        at: diagnostic.fileName === undefined ? undefined : locate(diagnostic.fileName, diagnostic.pos),
+    }));
 }
 /**
  * Every error a project's three diagnostic sets carry, in the order the compiler
@@ -38,6 +59,32 @@ export function renderDiagnostic(diagnostic) {
 export function diagnosticErrors(sets) {
     return [...sets.configParsing, ...sets.syntactic, ...sets.semantic].filter(isError);
 }
+/** The errors one open project carries, each located in the file it names. */
+export function projectErrors(sets) {
+    const load = sets.configParsing.filter(isError);
+    return {
+        load: locatedIn(load, sets.locate),
+        check: load.length > 0 ? [] : locatedIn(diagnosticErrors(sets), sets.locate),
+    };
+}
+/**
+ * The first line of one error about the target, every mention of the target root
+ * spelled relative to it: a path below the root loses the root and its separator, and
+ * the root itself is `.`.
+ */
+export function targetRelative(text, targetRoot) {
+    const root = targetRoot.endsWith("/") ? targetRoot.slice(0, -1) : targetRoot;
+    const [first = ""] = text.split(/\r?\n/u);
+    const spelled = first.split(`${root}/`).join("").split(root).join(".").trim();
+    return spelled === "" ? "the configuration could not be built" : spelled;
+}
+/**
+ * Whether one configuration is the analyzer's own guess: discovery derived it and the
+ * scope did not name it. A guess that does not load is dropped; any other ends the run.
+ */
+export function isGuess(discovery, configFile) {
+    return discovery.derived && !discovery.fromScope.includes(configFile);
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -130,9 +177,11 @@ function scopeConfigFiles(host, scope) {
 /**
  * Every configuration file reached from `pending`, in the order discovery reads them:
  * each once, each followed by the configurations it references, transitively. A
- * configuration the compiler cannot read ends the run naming it.
+ * configuration the compiler cannot read ends the run naming it, unless `unreadable`
+ * is given, which is then told the configuration and why, and the walk goes on
+ * without it.
  */
-function derivedFrom(engine, host, pending) {
+function derivedFrom(engine, host, pending, unreadable) {
     const seen = new Set();
     const found = [];
     while (pending.length > 0) {
@@ -145,7 +194,14 @@ function derivedFrom(engine, host, pending) {
             continue;
         }
         seen.add(path);
-        parseOrRefuse(engine, path, path);
+        const reason = unreadableReason(engine, path);
+        if (reason !== undefined) {
+            if (unreadable === undefined) {
+                throw new DiscoveryError(`${path} cannot be read as a compiler configuration: ${reason}`, []);
+            }
+            unreadable(path, reason);
+            continue;
+        }
         found.push(path);
         pending.push(...referencesOf(host, path));
     }
@@ -179,18 +235,25 @@ export function consumerProjects(engine, host, root) {
 function derivedId(targetRoot, configFile) {
     return relativePath(targetRoot, configFile) ?? configFile;
 }
+/** Why the compiler cannot read one configuration file, or undefined where it can. */
+function unreadableReason(engine, configFile) {
+    try {
+        engine.parseConfigFile(configFile);
+        return undefined;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
 /**
  * Resolves one compiler configuration file, or ends the run naming it: a project
  * opened from a configuration the compiler cannot read would be analyzed with no
  * type information.
  */
 function parseOrRefuse(engine, configFile, named) {
-    try {
-        engine.parseConfigFile(configFile);
-    }
-    catch (error) {
-        throw new DiscoveryError(`${named} cannot be read as a compiler configuration: ` +
-            (error instanceof Error ? error.message : String(error)), []);
+    const reason = unreadableReason(engine, configFile);
+    if (reason !== undefined) {
+        throw new DiscoveryError(`${named} cannot be read as a compiler configuration: ${reason}`, []);
     }
 }
 /**
@@ -232,25 +295,41 @@ function declaredProjects(engine, host, targetRoot, entries) {
                 "into the program that references it, so the matrix names it too", []);
         }
     }
-    return { projects, configFiles: projects.map((project) => project.configFile), fromScope: [] };
+    return {
+        projects,
+        derived: false,
+        notBuilt: [],
+        configFiles: projects.map((project) => project.configFile),
+        fromScope: [],
+    };
 }
 /**
  * The projects a run derives where the matrix declares none, in the order discovery
  * reads them: the paths the scope names, then every compiler configuration under
  * the target root that is not inside an ignored directory, then the configurations
- * each of those references, transitively. Each configuration appears once.
+ * each of those references, transitively. Each configuration appears once. A
+ * configuration the scope names directly is the caller's own and ends the run where
+ * it cannot be read; one the walk found is dropped and named.
  */
 function derivedProjects(engine, host, scope) {
+    const targetRoot = scope.target.path;
     const fromScope = scopeConfigFiles(host, scope);
-    const configFiles = derivedFrom(engine, host, [
-        ...fromScope,
-        ...configFilesUnder(host, scope.target.path),
-    ]);
+    const notBuilt = [];
+    const configFiles = derivedFrom(engine, host, [...fromScope, ...configFilesUnder(host, targetRoot)], (configFile, reason) => {
+        if (fromScope.includes(configFile)) {
+            throw new DiscoveryError(`${configFile} cannot be read as a compiler configuration: ${reason}`, []);
+        }
+        notBuilt.push({
+            id: derivedId(targetRoot, configFile),
+            configFile,
+            error: targetRelative(reason, resolvePath(host.workingDirectory(), targetRoot)),
+        });
+    });
     const projects = configFiles.map((configFile) => ({
-        id: derivedId(scope.target.path, configFile),
+        id: derivedId(targetRoot, configFile),
         configFile,
     }));
-    return { projects, configFiles, fromScope };
+    return { projects, derived: true, notBuilt, configFiles, fromScope };
 }
 /**
  * Every project one run analyzes.
@@ -262,12 +341,10 @@ function derivedProjects(engine, host, scope) {
  * scope and the target tree. A platform entry names a configuration of another
  * language and plays no part here.
  *
- * A configuration file the compiler cannot read ends the run with the failure code,
- * so a project that would have been analyzed with no type information is never
- * analyzed at all, whether the matrix declared it or discovery derived it. What a
- * configuration's own contents say is refused once its project is open, by
- * {@link diagnosticErrors} over the three sets a program reports, because a
- * resolution carries no diagnostics.
+ * A configuration file the compiler cannot read is never analyzed. One the matrix or
+ * the scope names ends the run with the failure code; a guess is dropped and named in
+ * {@link Discovery.notBuilt}. What a configuration's own contents say is read once its
+ * project is open, by {@link diagnosticErrors}, because a resolution carries none.
  *
  * Nothing reads a build output: a project is the files its configuration names, so a
  * package whose sources ship as TypeScript is analyzed as it stands.

package/dist/src/entry-points.js

@@ -14,6 +14,7 @@ import { isArrayLiteralExpression, isAsExpression, isCallExpression, isExportAss
 import { SymbolFlags } from "@typescript/native/unstable/sync";
 import { globExpression } from "./glob.js";
 import { dirnamePath, relativePath, resolvePath } from "./paths.js";
+import { UNANSWERED } from "./query.js";
 /** The extensions the test runner and the browser-test runner load a configuration from. */
 const MODULE_EXTENSIONS = ["js", "mjs", "cjs", "ts", "mts", "cts"];
 /** The extensions the linter's flat configuration and the mutation tester's are loaded from. */
@@ -331,8 +332,14 @@ function workersOf(project, file, files) {
     const names = sites.flatMap((site) => site.platformNames);
     const symbols = project.symbolsAt(names.map((name) => project.handle(name)));
     const platform = new Set();
+    // A name the checker could not resolve is read as the platform's, so a worker it
+    // stands on is rooted rather than reported.
     names.forEach((name, index) => {
         const symbol = symbols[index];
+        if (symbol === UNANSWERED) {
+            platform.add(name);
+            return;
+        }
         if (symbol !== undefined &&
             (symbol.flags & SymbolFlags.Alias) === 0 &&
             symbol.declarations.length > 0 &&