@cplieger/deadset-ts 2.3.0 → 3.1.0

package/dist/src/references.js

@@ -1,5 +1,5 @@
-import { isArrayLiteralExpression, isBinaryExpression, isDeleteExpression, isElementAccessExpression, isForInStatement, isForOfStatement, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, SyntaxKind, } from "@typescript/native/unstable/ast";
-import { SymbolFlags } from "@typescript/native/unstable/sync";
+import { isArrayLiteralExpression, isBinaryExpression, isCallExpression, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isExternalModuleReference, isForInStatement, isForOfStatement, isImportDeclaration, isImportEqualsDeclaration, isNamespaceExport, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { aliasChains } from "./alias-chain.js";
 import { globExpression } from "./glob.js";
 import { nodeKey } from "./inventory.js";
 import { byPosition, renderPosition } from "./position.js";
@@ -126,18 +126,87 @@ function markStores(node, writes) {
         }
     }
 }
+/** Whether one node is a string literal or a template literal with no substitution. */
+function isLiteralText(node) {
+    return node !== undefined && (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node));
+}
+/**
+ * The module specifier of the module one node evaluates, if it evaluates one: an import
+ * declaration, an import-equals declaration of an external module, an export
+ * declaration that names a module, and an `import()` call whose argument is literal
+ * text. A type-only form evaluates nothing. An `import()` of a computed argument names
+ * no module this pass can know.
+ */
+function evaluatedBy(node) {
+    if (isImportDeclaration(node)) {
+        return node.importClause?.phaseModifier === SyntaxKind.TypeKeyword
+            ? undefined
+            : node.moduleSpecifier;
+    }
+    if (isExportDeclaration(node)) {
+        return node.isTypeOnly ? undefined : node.moduleSpecifier;
+    }
+    if (isImportEqualsDeclaration(node)) {
+        const reference = node.moduleReference;
+        return !node.isTypeOnly && isExternalModuleReference(reference)
+            ? reference.expression
+            : undefined;
+    }
+    if (isCallExpression(node) && node.expression.kind === SyntaxKind.ImportKeyword) {
+        const [argument] = node.arguments;
+        return isLiteralText(argument) ? argument : undefined;
+    }
+    return undefined;
+}
+/**
+ * The re-exports one node writes, if it is an export declaration. A specifier and a
+ * namespace export are declarations whose names are where they are written, so no use is
+ * read from them; each references what it carries forward instead. A bare star declares
+ * nothing, so the declaration enclosing it, at the top level the file, references the
+ * module it names.
+ */
+function linksOf(file, node, declarations, enclosing) {
+    if (!isExportDeclaration(node)) {
+        return [];
+    }
+    const clause = node.exportClause;
+    const specifier = node.moduleSpecifier;
+    if (clause === undefined) {
+        return specifier === undefined
+            ? []
+            : [{ node: specifier, at: specifier, from: enclosing, alias: false }];
+    }
+    if (isNamespaceExport(clause)) {
+        const from = declarations.get(nodeKey(file, clause));
+        return from === undefined
+            ? []
+            : [{ node: clause.name, at: specifier ?? clause.name, from, alias: true }];
+    }
+    const found = [];
+    for (const element of clause.elements) {
+        const from = declarations.get(nodeKey(file, element));
+        if (from !== undefined) {
+            found.push({
+                node: element.name,
+                at: element.propertyName ?? element.name,
+                from,
+                alias: true,
+            });
+        }
+    }
+    return found;
+}
 /**
  * Every name node one file holds that is a use rather than a declaration, in source
- * order, each with the declaration that encloses it and the use it makes.
- *
- * One walk answers all three, because the three facts are positional and a second walk
- * would have to agree with this one about which nodes are names. A name that is the
- * declared name of the declaration it belongs to is left out: it is where that
- * declaration is written rather than a use of it, which is what makes a declaration
- * referenced only from its own site an unreferenced declaration.
+ * order, each with its enclosing declaration and its use, and every re-export the file
+ * writes. One walk answers all of it, because a second would have to agree with this one
+ * about which nodes are names. A declaration's own declared name is left out, which is
+ * what makes a declaration referenced only from its own site an unreferenced one.
  */
 function sitesOf(file, declarations, fileId) {
     const found = [];
+    const links = [];
+    const evaluations = [];
     const writes = new Set();
     const declared = new Set();
     const shorthands = new Map();
@@ -173,6 +242,11 @@ function sitesOf(file, declarations, fileId) {
         }
         markNames(node);
         markStores(node, writes);
+        links.push(...linksOf(file, node, declarations, enclosing));
+        const evaluated = evaluatedBy(node);
+        if (evaluated !== undefined) {
+            evaluations.push({ node: evaluated, from: enclosing });
+        }
         const held = declarations.get(nodeKey(file, node));
         const outer = enclosing;
         if (held !== undefined) {
@@ -182,7 +256,7 @@ function sitesOf(file, declarations, fileId) {
         enclosing = outer;
     };
     file.forEachChild(visit);
-    return found;
+    return { uses: found, links, evaluations };
 }
 /**
  * The name one test-file rule takes. A rule's name is a word list the report's own
@@ -210,7 +284,8 @@ function compare(a, b) {
  * The order is by the referencing position, then by the declaration named, the
  * declaration referencing it and the use. That is a total order because one name
  * references one declaration once from one declaration, while a chain of aliases reaches
- * several declarations at one position.
+ * several declarations at one position and a bare star re-export's specifier both reads
+ * and evaluates the module it names.
  */
 export function references(project, held, targetRoot, options) {
     const cap = options.batchCap ?? DEFAULT_BATCH_CAP;
@@ -218,73 +293,31 @@ export function references(project, held, targetRoot, options) {
     const patterns = options.testFiles.map(globExpression);
     const matched = options.testFiles.map(() => 0);
     const found = [];
-    const reached = new Map();
+    const tests = [];
+    const chains = aliasChains(project, held);
     let batched = 0;
     let fileBatches = 0;
     let residueFallbacks = 0;
     let shorthandLookups = 0;
-    let aliasSteps = 0;
     const files = project.ownSourceFiles();
-    const ownFiles = new Set(files.map((file) => file.fileName));
+    const fileIds = new Set(held.symbols.filter((symbol) => symbol.kind === "file").map((symbol) => symbol.id));
     /** The identifier of the declaration one node of this program is, where it is one. */
     const declaredAt = (node) => declarations.get(nodeKey(node.getSourceFile(), node));
     /**
-     * The declarations one symbol names: the declaration it is, and every link of the
-     * alias chain it stands at the head of. A re-export something imports is used and so
-     * is the declaration behind it, so both are named; a link this project does not
-     * declare is stepped over rather than recorded.
-     *
-     * A symbol is asked to step only where the binder flagged it an alias, which is the
-     * same condition the step itself asserts on. The declaration's syntax is not that
-     * condition and does not stand in for it: a default export of an expression is
-     * written as one of the alias forms and names nothing declared elsewhere, so it is
-     * recorded as the declaration it is and the chain ends there.
-     *
-     * A declaration handle carries the file it is in, so the question the walk asks of a
-     * declaration is answered before it is resolved: a declaration outside the project's
-     * own files belongs to another program and is never read, which is what keeps the
-     * pass from fetching a library file to discover that the inventory does not hold what
-     * is in it.
+     * The declarations one re-export carries forward: for an alias, the first link along
+     * its chain that the inventory declares, stepping over the links it does not, such as
+     * an import the re-export is written against; for a bare star, the module it names.
+     * Each later link is a declaration of its own that references the next, so one link
+     * per re-export is what lets a chain be followed one declaration at a time.
      */
-    const targetsOf = (symbol) => {
-        const cached = reached.get(symbol.id);
-        if (cached !== undefined) {
-            return cached;
-        }
-        const targets = [];
-        const walked = new Set();
-        let at = symbol;
-        let stepped = false;
-        while (at !== undefined && !walked.has(at.id)) {
-            walked.add(at.id);
-            const alias = (at.flags & SymbolFlags.Alias) !== 0;
-            for (const handle of at.declarations) {
-                if (!ownFiles.has(handle.path)) {
-                    continue;
-                }
-                const node = project.declarationAt(handle)?.node;
-                const id = node === undefined ? undefined : declaredAt(node);
-                if (id !== undefined && !targets.some((target) => target.id === id)) {
-                    targets.push({ id, stepped });
-                }
-            }
-            if (!alias) {
-                break;
-            }
-            at = project.aliasStepOf(at);
-            aliasSteps += 1;
-            stepped = true;
-        }
-        reached.set(symbol.id, targets);
-        return targets;
-    };
+    const carriedBy = (link, symbol) => link.alias ? chains.nextDeclared(symbol) : chains.declarationsOf(symbol);
     /** The symbol one site resolves to, asking only the accessor the site's form names. */
     const symbolFor = (site, answered) => {
         if (site.shorthand !== undefined) {
             shorthandLookups += 1;
             return project.shorthandValueAt(project.handle(site.shorthand));
         }
-        const batched = answered.get(site.node.pos);
+        const batched = answered.get(site.node);
         if (batched !== undefined) {
             return batched;
         }
@@ -293,35 +326,82 @@ export function references(project, held, targetRoot, options) {
     };
     for (const file of files) {
         const path = renderPosition(file, targetRoot, 0).path;
-        let test = false;
-        patterns.forEach((pattern, index) => {
-            if (pattern.test(path)) {
+        const hits = patterns.map((pattern) => pattern.test(path));
+        hits.forEach((hit, index) => {
+            if (hit) {
                 matched[index] = (matched[index] ?? 0) + 1;
-                test = true;
             }
         });
-        const sites = sitesOf(file, declarations, declaredAt(file) ?? "");
-        // One batch per capped run of the file's name nodes. A shorthand is left out of
-        // the batch: its name resolves to the property the literal declares, so the batch's
-        // answer for it would name something this project's inventory never holds.
-        const batching = sites.filter((site) => site.shorthand === undefined);
+        const test = hits.includes(true);
+        if (test) {
+            tests.push(path);
+        }
+        const { uses, links, evaluations } = sitesOf(file, declarations, declaredAt(file) ?? "");
+        // One batch per capped run of the file's name nodes, the re-exports' nodes after
+        // the uses and the evaluated modules' specifiers last, each node once: a bare star
+        // re-export's specifier is a link and an evaluation both. A shorthand is left out
+        // of the batch: its name resolves to the property the literal declares, so the
+        // batch's answer for it would name something this project's inventory never holds.
+        const batching = [
+            ...new Set([
+                ...uses.filter((site) => site.shorthand === undefined).map((site) => site.node),
+                ...links.map((link) => link.node),
+                ...evaluations.map((evaluation) => evaluation.node),
+            ]),
+        ];
         const answered = new Map();
         batched += batching.length;
         for (let from = 0; from < batching.length; from += cap) {
             const run = batching.slice(from, from + cap);
-            const answers = project.symbolsAt(run.map((site) => project.handle(site.node)));
+            const answers = project.symbolsAt(run.map((node) => project.handle(node)));
             fileBatches += 1;
-            run.forEach((site, index) => {
+            run.forEach((node, index) => {
                 const symbol = answers[index];
                 if (symbol !== undefined) {
-                    answered.set(site.node.pos, symbol);
+                    answered.set(node, symbol);
                 }
             });
         }
-        for (const site of sites) {
+        for (const link of links) {
+            const symbol = answered.get(link.node);
+            if (symbol === undefined) {
+                continue;
+            }
+            const position = renderPosition(file, targetRoot, link.at.getStart());
+            for (const id of carriedBy(link, symbol)) {
+                found.push({
+                    from: link.from,
+                    to: id,
+                    position,
+                    use: "read",
+                    resolution: link.alias ? "alias" : "batch",
+                    test,
+                });
+            }
+        }
+        for (const evaluation of evaluations) {
+            const module = answered.get(evaluation.node);
+            if (module === undefined) {
+                continue;
+            }
+            const position = renderPosition(file, targetRoot, evaluation.node.getStart());
+            for (const id of chains.declarationsOf(module)) {
+                if (fileIds.has(id)) {
+                    found.push({
+                        from: evaluation.from,
+                        to: id,
+                        position,
+                        use: "evaluation",
+                        resolution: "batch",
+                        test,
+                    });
+                }
+            }
+        }
+        for (const site of uses) {
             const direct = site.shorthand !== undefined
                 ? "shorthand"
-                : answered.has(site.node.pos)
+                : answered.has(site.node)
                     ? "batch"
                     : "resolved-symbol";
             const symbol = symbolFor(site, answered);
@@ -329,7 +409,9 @@ export function references(project, held, targetRoot, options) {
                 continue;
             }
             const position = renderPosition(file, targetRoot, site.node.getStart());
-            for (const target of targetsOf(symbol)) {
+            // A re-export something imports is used and so is the declaration behind it, so
+            // the use names every link of the chain its name stands at the head of.
+            for (const target of chains.chainOf(symbol)) {
                 found.push({
                     from: site.from,
                     to: target.id,
@@ -351,6 +433,7 @@ export function references(project, held, targetRoot, options) {
         testFileRules: options.testFiles
             .map((_pattern, index) => ({ rule: patternRule(index), matched: matched[index] ?? 0 }))
             .sort((a, b) => compare(a.rule, b.rule)),
-        cost: { batched, fileBatches, residueFallbacks, shorthandLookups, aliasSteps },
+        testFilePaths: tests.sort(compare),
+        cost: { batched, fileBatches, residueFallbacks, shorthandLookups, aliasSteps: chains.steps },
     };
 }

package/dist/src/resolve.js

@@ -8,6 +8,20 @@ const FAMILY_KEY_LENGTH = 4;
 const SEVERITY_KEY = /^DS[0-9]{2}([0-9]{2})?$/u;
 const EXEMPTION_CLASS = /^[a-z][a-z0-9-]*$/u;
 const CONTRACT_VERSION_PATTERN = /^[0-9]+\.[0-9]+\.[0-9]+$/u;
+/** The members only a platform build configuration carries. */
+const PLATFORM_MEMBERS = ["os", "arch", "tags"];
+/** The member only a project build configuration carries. */
+const PROJECT_MEMBER = "project";
+/**
+ * One segment of a project path: not empty, not `.` or `..`, and holding no
+ * solidus, backslash or line break.
+ */
+const PROJECT_SEGMENT = String.raw `(?:[^/\\.\r\n][^/\\\r\n]*|\.[^/\\.\r\n][^/\\\r\n]*|\.\.[^/\\\r\n]+)`;
+/**
+ * A project path: segments joined by a solidus, so the path is relative, below
+ * the root it is read against, and spelled one way on every machine.
+ */
+const PROJECT_PATH = new RegExp(`^${PROJECT_SEGMENT}(?:/${PROJECT_SEGMENT})*$`, "u");
 const TARGET_KINDS = ["application", "library"];
 const CONFIDENCES = ["certain", "probable", "possible"];
 const GENERATED_FILES = ["exclude", "include"];
@@ -135,10 +149,52 @@ function requireMember(value, path, label) {
     }
     return value;
 }
+/** One build configuration entry as a platform: an identifier, an operating system and an architecture. */
+function readPlatform(entry, at, label) {
+    return {
+        shape: "platform",
+        id: requireMember(readString(entry, "id", `${at}.id`, label), `${at}.id`, label),
+        os: requireMember(readString(entry, "os", `${at}.os`, label), `${at}.os`, label),
+        arch: requireMember(readString(entry, "arch", `${at}.arch`, label), `${at}.arch`, label),
+        tags: readStrings(entry, "tags", `${at}.tags`, label, 0) ?? [],
+    };
+}
+/** One build configuration entry as a project: an identifier and a configuration file below the target root. */
+function readProject(entry, at, label) {
+    const id = requireMember(readString(entry, "id", `${at}.id`, label), `${at}.id`, label);
+    const path = `${at}.${PROJECT_MEMBER}`;
+    const project = requireMember(readString(entry, PROJECT_MEMBER, path, label), path, label);
+    if (!PROJECT_PATH.test(project)) {
+        throw malformed(label, path, `${JSON.stringify(project)} is not a path below the target root: segments joined by /, ` +
+            "none empty, . or .., and no backslash or line break");
+    }
+    return { shape: "project", id, project };
+}
 /**
- * The build matrix: every entry names an identifier, an operating system and an
- * architecture.
+ * One build configuration entry, read as the one shape its members name: a member
+ * only a platform carries makes it a platform, the member only a project carries
+ * makes it a project, and an entry naming members of both, or of neither, is
+ * refused at the entry, because the two shapes are exclusive.
  */
+function readConfiguration(entry, at, label) {
+    if (!isRecord(entry)) {
+        throw malformed(label, at, "is not an object");
+    }
+    const platform = PLATFORM_MEMBERS.filter((name) => Object.hasOwn(entry, name));
+    const project = Object.hasOwn(entry, PROJECT_MEMBER);
+    if (platform.length > 0 && project) {
+        throw malformed(label, at, `carries ${spell(platform)} of a platform and ${JSON.stringify(PROJECT_MEMBER)} of a ` +
+            "project, and an entry is one shape or the other");
+    }
+    if (project) {
+        return readProject(entry, at, label);
+    }
+    if (platform.length === 0) {
+        throw malformed(label, at, `names neither a platform's "os" and "arch" nor a project's ${JSON.stringify(PROJECT_MEMBER)}`);
+    }
+    return readPlatform(entry, at, label);
+}
+/** The build matrix, one entry in one shape at a time. */
 function readConfigurations(analysis, label) {
     const value = member(analysis, "configurations");
     if (value === undefined) {
@@ -147,18 +203,7 @@ function readConfigurations(analysis, label) {
     if (!Array.isArray(value)) {
         throw malformed(label, "analysis.configurations", "is not an array");
     }
-    return value.map((entry, index) => {
-        const at = `analysis.configurations[${String(index)}]`;
-        if (!isRecord(entry)) {
-            throw malformed(label, at, "is not an object");
-        }
-        return {
-            id: requireMember(readString(entry, "id", `${at}.id`, label), `${at}.id`, label),
-            os: requireMember(readString(entry, "os", `${at}.os`, label), `${at}.os`, label),
-            arch: requireMember(readString(entry, "arch", `${at}.arch`, label), `${at}.arch`, label),
-            tags: readStrings(entry, "tags", `${at}.tags`, label, 0) ?? [],
-        };
-    });
+    return value.map((entry, index) => readConfiguration(entry, `analysis.configurations[${String(index)}]`, label));
 }
 /**
  * The action delimiter pair: once a document names the object both members are
@@ -439,6 +484,29 @@ function checkLabels(provenance) {
  * the usage exit code.
  */
 export function resolve(inputs) {
+    const { config, provenance } = settleAll(inputs);
+    if (config.targetKind === "") {
+        throw new ConfigError("missing-target-kind", "target.kind", "target.kind is not set, it has no default and is never inferred: searched " +
+            `${describeSource("the repository configuration", inputs.repository, inputs.repositoryLabel)} and ` +
+            describeSource("the central configuration", inputs.central, inputs.centralLabel));
+    }
+    checkLabels(provenance);
+    return { config, provenance };
+}
+/**
+ * The build matrix the configuration documents resolve to, every document read and
+ * refused as {@link resolve} refuses it, and nothing else required of them: which
+ * projects a run analyzes depends on the matrix alone, so a question about the
+ * projects asks no target kind.
+ */
+export function resolveMatrix(inputs) {
+    return settleAll(inputs).config.analysis.configurations;
+}
+/**
+ * Every setting the documents supply, each from the highest-ranked source carrying
+ * it, with the origin of each. The target kind is empty where no source names one.
+ */
+function settleAll(inputs) {
     const sources = readSources(inputs);
     const defaults = defaultConfig();
     const provenance = new Map();
@@ -472,11 +540,5 @@ export function resolve(inputs) {
             entryFiles: at("ts.entry_files", defaults.ts.entryFiles, (doc) => doc.entryFiles),
         },
     };
-    if (config.targetKind === "") {
-        throw new ConfigError("missing-target-kind", "target.kind", "target.kind is not set, it has no default and is never inferred: searched " +
-            `${describeSource("the repository configuration", inputs.repository, inputs.repositoryLabel)} and ` +
-            describeSource("the central configuration", inputs.central, inputs.centralLabel));
-    }
-    checkLabels(provenance);
     return { config, provenance };
 }

package/dist/src/roots.js

@@ -2,12 +2,13 @@
  * The root set of one project: every declaration the analysis keeps live without a
  * reference, and why.
  *
- * A root makes its declaration live under REACHABILITY and plays no part in
- * reference counting, which asks only whether some declaration of the loaded graph
- * names it. The two relations are different sets, so an exported declaration that
- * something outside the program reaches is live under the first and still a
- * candidate under the second.
+ * Every root seeds REACHABILITY, and no root counts as a reference. A root of a kind
+ * that names a caller is live under reference counting as well, which the sweep
+ * decides; a root that only supposes a consumer is not, so an exported declaration
+ * something outside the program reaches is live under reachability and still a
+ * candidate under reference counting.
  */
+import { aliasChains } from "./alias-chain.js";
 import { REPOSITORY_DOCUMENT } from "./config.js";
 import { entryPoints } from "./entry-points.js";
 import { globExpression } from "./glob.js";
@@ -143,7 +144,10 @@ export function roots(project, held, targetRoot, options) {
     for (const point of entryPoints(project, files, options.testFiles)) {
         enter(point.file, point.rule, point.source, point.exports);
     }
-    const exportsOf = exportTables(project, held, [...entered.filter((entry) => entry.exports).map((entry) => entry.file), ...published], files.byName);
+    const exportsOf = exportTables(project, held, [
+        ...entered.filter((entry) => entry.exports).map((entry) => entry.file),
+        ...published,
+    ]);
     for (const entry of entered) {
         const id = fileIds.get(entry.file.fileName);
         if (id === undefined) {
@@ -181,41 +185,14 @@ export function roots(project, held, targetRoot, options) {
  * its export table, star re-exports resolved into it. A file that is no module
  * exports nothing.
  */
-function exportTables(project, held, wanted, ownFiles) {
+function exportTables(project, held, wanted) {
     const unique = [...new Map(wanted.map((file) => [file.fileName, file])).values()];
     const tables = new Map();
     if (unique.length === 0) {
         return tables;
     }
     const modules = project.symbolsAt(unique.map((file) => project.handle(file)));
-    const chains = new Map();
-    const chainOf = (symbol) => {
-        const cached = chains.get(symbol.id);
-        if (cached !== undefined) {
-            return cached;
-        }
-        const ids = [];
-        const walked = new Set();
-        let at = symbol;
-        while (at !== undefined && !walked.has(at.id)) {
-            walked.add(at.id);
-            for (const handle of at.declarations) {
-                if (!ownFiles.has(handle.path)) {
-                    continue;
-                }
-                const node = project.declarationAt(handle)?.node;
-                const id = node === undefined
-                    ? undefined
-                    : held.declarations.get(nodeKey(node.getSourceFile(), node));
-                if (id !== undefined && !ids.includes(id)) {
-                    ids.push(id);
-                }
-            }
-            at = project.aliasStepOf(at);
-        }
-        chains.set(symbol.id, ids);
-        return ids;
-    };
+    const chains = aliasChains(project, held);
     unique.forEach((file, index) => {
         const module = modules[index];
         if (module === undefined) {
@@ -224,8 +201,8 @@ function exportTables(project, held, wanted, ownFiles) {
         }
         const ids = new Set();
         for (const exported of project.checker.getExportsOfModule(module)) {
-            for (const id of chainOf(exported)) {
-                ids.add(id);
+            for (const target of chains.chainOf(exported)) {
+                ids.add(target.id);
             }
         }
         tables.set(file.fileName, [...ids]);

package/dist/src/run.js

@@ -3,7 +3,7 @@ import { ConfigError, REPOSITORY_DOCUMENT } from "./config.js";
 import { diagnosticErrors, discoverProjects, DiscoveryError, renderDiagnostic, } from "./discover.js";
 import { joinPath, resolvePath } from "./paths.js";
 import { printConfig } from "./print.js";
-import { resolve } from "./resolve.js";
+import { resolve, resolveMatrix } from "./resolve.js";
 import { readScope, ScopeError, scopeForDir } from "./scope.js";
 import { diagnosticsOf, openEngine, runSession } from "./session.js";
 import { CONTRACT_VERSION } from "./version.js";
@@ -197,21 +197,25 @@ function printConfigVerb(args, out, err, host) {
     }
 }
 /**
- * Writes the compiler configuration of every project one run analyzes, one per
- * line, in discovery order, having read each project's diagnostics first.
+ * Writes the name of every project one run analyzes, one per line, having read each
+ * project's diagnostics first: the identifier the build matrix declares for it, or,
+ * where discovery derived the project, its configuration file's path below the
+ * target root.
  */
 function printProjectsVerb(args, out, err, host, openClient) {
     let engine;
     try {
         const options = readOptions(args);
+        const matrix = resolveMatrix(inputsOf(host, options));
         const scope = scopeOf(host, options);
         engine = openClient(false);
-        const discovered = discoverProjects(engine, host, scope);
+        const discovered = discoverProjects(engine, host, scope, matrix);
+        const ids = new Map(discovered.projects.map((project) => [project.configFile, project.id]));
         const failures = [];
         const { projects } = runSession(engine, discovered.configFiles, (project) => {
             const errors = diagnosticErrors(diagnosticsOf(project));
             failures.push(...errors.map(renderDiagnostic));
-            return project.configFile;
+            return ids.get(project.configFile) ?? project.configFile;
         });
         if (failures.length > 0) {
             for (const line of failures) {
@@ -220,8 +224,8 @@ function printProjectsVerb(args, out, err, host, openClient) {
             err.write(`deadset-ts: ${String(failures.length)} error(s); no answer was produced\n`);
             return EXIT_FAILURE;
         }
-        for (const configFile of projects) {
-            out.write(`${configFile}\n`);
+        for (const id of projects) {
+            out.write(`${id}\n`);
         }
         return EXIT_CLEAN;
     }

package/dist/src/schema.js

@@ -19,7 +19,7 @@ export const SCHEMA_ROOT = {
                 consumer_tests: leaf,
                 configurations: {
                     kind: "list",
-                    members: { id: leaf, os: leaf, arch: leaf, tags: leaf },
+                    members: { id: leaf, os: leaf, arch: leaf, tags: leaf, project: leaf },
                 },
                 matrix: { kind: "section", members: { complete: leaf } },
                 template_dirs: leaf,

package/dist/src/session.js

@@ -1,5 +1,6 @@
 import { API, SymbolFlags } from "@typescript/native/unstable/sync";
 import { isIdentifier } from "@typescript/native/unstable/ast";
+import { DiscoveryError } from "./discover.js";
 /**
  * Opens the compiler client the analysis reads through.
  *
@@ -81,19 +82,29 @@ export function diagnosticsOf(project) {
 }
 /**
  * Runs `visit` over every project the compiler configurations name, inside one
- * snapshot of one client.
+ * snapshot of one client, in the order they are named, and answers in that order.
  *
  * The snapshot is opened once with every configuration, so each becomes a project
  * with its own program and checker; it is never updated, because the analysis
- * reads and the tree does not change under it. It is disposed once when the last
- * project has been visited, and the client is released after it, whether the visit
- * completed or threw.
+ * reads and the tree does not change under it. The order the snapshot lists its
+ * projects in is the compiler's own, so each named configuration is looked up in it
+ * instead, and a configuration the snapshot opened no project for ends the run: the
+ * run would otherwise answer for fewer projects than it was asked to analyze. The
+ * snapshot is disposed once when the last project has been visited, and the client
+ * is released after it, whether the visit completed or threw.
  */
 export function runSession(engine, configFiles, visit) {
     try {
         const snapshot = engine.updateSnapshot(configFiles);
         try {
-            const projects = snapshot.getProjects().map((project) => visit(viewOf(project)));
+            const opened = new Map(snapshot.getProjects().map((project) => [project.configFileName, project]));
+            const projects = configFiles.map((configFile) => {
+                const project = opened.get(configFile);
+                if (project === undefined) {
+                    throw new DiscoveryError(`${configFile} opened no project`, []);
+                }
+                return visit(viewOf(project));
+            });
             return { projects, timing: engine.getTimingInfo() };
         }
         finally {