@cplieger/deadset-ts 7.2.0-dev.3 → 8.0.0-dev.1

package/dist/src/roots.js

@@ -9,11 +9,12 @@
  */
 import { isExpressionWithTypeArguments, isFunctionLikeDeclaration, isPropertyAccessExpression, isQualifiedName, isTypeQueryNode, isTypeReferenceNode, isPropertyDeclaration, isVariableDeclaration, isVariableStatement, } from "@typescript/native/ast";
 import { aliasChains } from "./alias-chain.js";
+import { filesNamedBy, outsideChain, relativeSpecifiers, } from "./configuration-files.js";
 import { conventionEntries } from "./conventions.js";
 import { entryPoints } from "./entry-points.js";
 import { globExpression } from "./glob.js";
 import { nodeKey } from "./inventory.js";
-import { relativePath, resolvePath } from "./paths.js";
+import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
 import { byPosition } from "./position.js";
 import { UNANSWERED } from "./query.js";
 import { sourceFilesOf } from "./source-files.js";
@@ -43,11 +44,22 @@ const READ_BACK_RULES = new Set([
 const OUTPUT_EXTENSION = /\.(?:d\.ts|d\.mts|d\.cts|js|mjs|cjs|jsx)$/u;
 /** The extension a source file's name drops. */
 const SOURCE_EXTENSION = /\.(?:d\.)?[cm]?[jt]sx?$/u;
+/** Whether no `package.json` sits between one file and the manifest's directory, which holds it. */
+function ofPackage(host, dir, file) {
+    for (let at = dirnamePath(file); at !== dir; at = dirnamePath(at)) {
+        if (relativePath(dir, at) === undefined ||
+            host.kindOf(joinPath(at, "package.json")) === "file") {
+            return false;
+        }
+    }
+    return true;
+}
 /**
  * The rooted files one manifest target reads back to by name: its path below the
  * manifest's directory, past its first directory where it names one, without its output
- * extension, is the name, and a rooted file is one whose path below the same directory,
- * without its source extension, ends with that name at a directory boundary.
+ * extension, is the name, and a rooted file of the manifest's own package is one whose
+ * path below the same directory, without its source extension, ends with that name at a
+ * directory boundary.
  */
 function readBackByName(host, entry, rooted) {
     const dir = resolvePath(host.workingDirectory(), entry.dir);
@@ -63,12 +75,41 @@ function readBackByName(host, entry, rooted) {
     const found = new Map();
     for (const file of rooted) {
         const path = relativePath(dir, file.fileName)?.replace(SOURCE_EXTENSION, "");
-        if (path !== undefined && (path === name || path.endsWith(`/${name}`))) {
+        if (path !== undefined &&
+            (path === name || path.endsWith(`/${name}`)) &&
+            ofPackage(host, dir, file.fileName)) {
             found.set(file.fileName, file);
         }
     }
     return [...found.values()];
 }
+/**
+ * The program files a manifest target no program holds reaches: the target is a file
+ * read as a configuration file outside the program is, and each file of the chain it
+ * starts loads the program files its relative specifiers name, read through the emit
+ * mapping, as a command's shim loads the compiled entry it runs.
+ */
+function throughOutside(options, targetRoot, files, entry) {
+    const cwd = options.host.workingDirectory();
+    const path = resolvePath(cwd, entry.path);
+    if (options.parse === undefined ||
+        options.runFiles?.has(path) === true ||
+        options.host.kindOf(path) !== "file") {
+        return [];
+    }
+    const chain = outsideChain(options.host, targetRoot, files, options.parse, [
+        { path, manifestDir: resolvePath(cwd, entry.dir) },
+    ]);
+    const found = new Map();
+    for (const { file } of chain) {
+        for (const specifier of relativeSpecifiers(file)) {
+            for (const named of filesNamedBy(files, dirnamePath(file.fileName), specifier)) {
+                found.set(named.fileName, named);
+            }
+        }
+    }
+    return [...found.values()];
+}
 /** Whether a configured string carries either special character. */
 function isPattern(text) {
     return text.includes("*") || text.includes("?");
@@ -168,8 +209,8 @@ export function roots(project, held, targetRoot, options) {
         found.set([id, kind, source].join("\u0000"), { id, kind, source });
     };
     const entered = [];
-    const enter = (file, kind, source, exports) => {
-        entered.push({ file, kind, source, exports });
+    const enter = (file, kind, source, exports, names) => {
+        entered.push({ file, kind, source, exports, ...(names === undefined ? {} : { names }) });
     };
     const points = entryPoints(project, files, options.testFiles, options.host, targetRoot, options.parse, options.conventions?.selected);
     const published = [];
@@ -191,11 +232,28 @@ export function roots(project, held, targetRoot, options) {
         ...scripted,
         ...points.filter((point) => READ_BACK_RULES.has(point.rule)).map((point) => point.file),
     ];
+    const entryFilesOf = new Map();
     const entryFiles = (entry) => {
+        const known = entryFilesOf.get(entry);
+        if (known !== undefined) {
+            return known;
+        }
+        const found = readEntryFiles(entry);
+        entryFilesOf.set(entry, found);
+        return found;
+    };
+    const readEntryFiles = (entry) => {
         const named = files.named(entry.path);
-        return named.length > 0 || entry.role === "script"
-            ? named
-            : readBackByName(options.host, entry, readBackTo);
+        if (named.length > 0 || entry.role === "script") {
+            return named;
+        }
+        const cwd = options.host.workingDirectory();
+        const shipped = files.namedAsOutput(resolvePath(cwd, entry.dir), resolvePath(cwd, entry.path));
+        if (shipped.length > 0) {
+            return shipped;
+        }
+        const byName = readBackByName(options.host, entry, readBackTo);
+        return byName.length > 0 ? byName : throughOutside(options, targetRoot, files, entry);
     };
     for (const { entry, publishes } of entries) {
         if (publishes) {
@@ -203,27 +261,39 @@ export function roots(project, held, targetRoot, options) {
         }
     }
     const publishedNames = new Set(published.map((file) => file.fileName));
-    for (const { entry } of entries) {
-        for (const file of entryFiles(entry)) {
-            const kind = ENTRY_KINDS[entry.role];
-            enter(file, kind, entry.member, !publishedNames.has(file.fileName));
-        }
-    }
+    const patterned = [];
     for (const pattern of options.entryFiles) {
         const expression = globExpression(pattern);
         for (const [path, file] of files.byPath) {
             if (expression.test(path)) {
-                enter(file, "entry-file", pattern, true);
+                patterned.push({ file, pattern });
             }
         }
     }
+    const unmapped = [];
+    const mapped = patterned.map(({ file }) => file);
+    for (const { entry } of entries) {
+        const named = entryFiles(entry);
+        if (named.length === 0 && entry.role !== "script") {
+            unmapped.push(entry);
+        }
+        mapped.push(...named);
+        for (const file of named) {
+            const kind = ENTRY_KINDS[entry.role];
+            enter(file, kind, entry.member, !publishedNames.has(file.fileName));
+        }
+    }
+    const unmappedEntries = unmapped.filter((entry) => readBackByName(options.host, entry, mapped).length === 0);
+    for (const { file, pattern } of patterned) {
+        enter(file, "entry-file", pattern, true);
+    }
     for (const { file, row } of options.conventions === undefined
         ? []
         : conventionEntries(options.conventions, files)) {
         enter(file, "convention", row, true);
     }
     for (const point of points) {
-        enter(point.file, point.rule, point.source, point.exports);
+        enter(point.file, point.rule, point.source, point.exports, point.names);
     }
     for (const file of files.byPath.values()) {
         for (const alias of typeQueryAliases(file)) {
@@ -236,7 +306,7 @@ export function roots(project, held, targetRoot, options) {
             }
         }
     }
-    const { tables: exportsOf, answered } = exportTables(project, held, [
+    const { tables: exportsOf, named, answered, } = exportTables(project, held, [
         ...entered.filter((entry) => entry.exports).map((entry) => entry.file),
         ...published,
     ]);
@@ -247,8 +317,12 @@ export function roots(project, held, targetRoot, options) {
         }
         add(id, entry.kind, entry.source);
         if (entry.exports) {
-            for (const exported of exportsOf.get(entry.file.fileName) ?? []) {
-                add(exported, entry.kind, entry.source);
+            const byName = named.get(entry.file.fileName);
+            const exported = entry.names === undefined || byName === undefined
+                ? (exportsOf.get(entry.file.fileName) ?? [])
+                : entry.names.flatMap((name) => byName.get(name) ?? []);
+            for (const one of exported) {
+                add(one, entry.kind, entry.source);
             }
         }
     }
@@ -271,6 +345,7 @@ export function roots(project, held, targetRoot, options) {
         liveUnderReachability: ordered,
         unmatched,
         unanswered: answered ? api.guessed : held.symbols.map((symbol) => symbol.id),
+        unmappedEntries,
     };
 }
 /**
@@ -284,9 +359,10 @@ export function roots(project, held, targetRoot, options) {
 function exportTables(project, held, wanted) {
     const unique = [...new Map(wanted.map((file) => [file.fileName, file])).values()];
     const tables = new Map();
+    const named = new Map();
     let answered = true;
     if (unique.length === 0) {
-        return { tables, answered };
+        return { tables, named, answered };
     }
     const modules = project.symbolsAt(unique.map((file) => project.handle(file)));
     const chains = aliasChains(project, held);
@@ -307,15 +383,18 @@ function exportTables(project, held, wanted) {
             return;
         }
         const ids = new Set();
+        const byName = new Map();
         for (const exported of table) {
             for (const target of chains.chainOf(exported)) {
                 answered &&= !target.guessed;
                 ids.add(target.id);
+                byName.set(exported.name, [...(byName.get(exported.name) ?? []), target.id]);
             }
         }
         tables.set(file.fileName, [...ids]);
+        named.set(file.fileName, byName);
     });
-    return { tables, answered };
+    return { tables, named, answered };
 }
 /** A release tag of a documentation comment: `@` and its name, between white space or the ends. */
 const RELEASE_TAG = /(?:^|\s)@(?:public|beta|alpha)(?=\s|$)/u;
@@ -370,11 +449,13 @@ function publishedAPI(project, published, exportsOf, held, byPath, tagged) {
     const nodes = declarationNodes(held, byPath);
     const chains = aliasChains(project, held);
     const reached = new Set();
+    const entered = new Set();
     const guessed = new Set();
     const pending = [];
     const reach = (id) => {
-        if (!reached.has(id) && byId.get(id)?.kind !== "file") {
-            reached.add(id);
+        const file = byId.get(id)?.kind === "file";
+        if (!(file ? entered : reached).has(id)) {
+            (file ? entered : reached).add(id);
             pending.push(id);
         }
     };
@@ -383,12 +464,7 @@ function publishedAPI(project, published, exportsOf, held, byPath, tagged) {
     }
     for (const file of published) {
         for (const id of exportsOf.get(file.fileName) ?? []) {
-            if (byId.get(id)?.kind === "file") {
-                pending.push(id);
-            }
-            else {
-                reach(id);
-            }
+            reach(id);
         }
     }
     while (pending.length > 0) {
@@ -411,8 +487,7 @@ function publishedAPI(project, published, exportsOf, held, byPath, tagged) {
         });
         for (const symbol of inferredTypeSymbols(project, round.flatMap((id) => {
             const symbol = byId.get(id);
-            const node = symbol === undefined ? undefined : nodes.nodeOf(symbol);
-            return node === undefined ? [] : [node];
+            return symbol === undefined ? [] : nodes.nodesOf(symbol);
         }))) {
             for (const target of chains.chainOf(symbol)) {
                 reach(target.id);
@@ -449,9 +524,7 @@ function declarationNodes(held, byPath) {
                 const id = held.declarations.get(nodeKey(file, node));
                 if (id !== undefined) {
                     found.nodes.add(node);
-                    if (!found.byId.has(id)) {
-                        found.byId.set(id, node);
-                    }
+                    found.byId.set(id, [...(found.byId.get(id) ?? []), node]);
                 }
                 node.forEachChild(visit);
             };
@@ -463,10 +536,9 @@ function declarationNodes(held, byPath) {
     return {
         typeNamesOf: (symbol) => {
             const { byId, nodes } = nodesIn(symbol.position.path);
-            const declaration = byId.get(symbol.id);
-            return declaration === undefined ? [] : typeNamesOf(declaration, nodes);
+            return (byId.get(symbol.id) ?? []).flatMap((declaration) => typeNamesOf(declaration, nodes));
         },
-        nodeOf: (symbol) => nodesIn(symbol.position.path).byId.get(symbol.id),
+        nodesOf: (symbol) => nodesIn(symbol.position.path).byId.get(symbol.id) ?? [],
     };
 }
 /** How deep the type arguments and constituents of an inferred type are followed. */

package/dist/src/schema.js

@@ -82,6 +82,7 @@ export const SCHEMA_ROOT = {
                     members: { components: declarations, bases: declarations, members: leaf },
                 },
                 serializers: declarations,
+                roots_complete: leaf,
             },
         },
         provenance: { kind: "map" },

package/dist/src/serialization-contract.js

@@ -1,10 +1,10 @@
 /**
  * The serialization-contract class: the data members and `toJSON` of every type a value's
  * static type reaches, where the value reaches `JSON.stringify` or a call `ts.serializers`
- * names, and `toString` too where it reaches an `unknown` or `any` parameter of a function
- * outside the analysis or an erased property of a type the program does not declare. A
- * function of the project handing such a parameter to a destination is one, to a fixpoint,
- * and a function invoked through `call`, `apply` or `bind` is the callee.
+ * names, and `toString` too where it reaches an erased parameter of a function outside the
+ * analysis, or an erased property of a type the program does not declare. A function of
+ * the project handing such a parameter to a destination is one, to a fixpoint, and a
+ * function invoked through `call`, `apply` or `bind` is the callee.
  */
 import { isArrayLiteralExpression, isArrowFunction, isAsExpression, isCallExpression, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isInterfaceDeclaration, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyDeclaration, isSatisfiesExpression, isSetAccessorDeclaration, isSpreadElement, isStringLiteral, isTypeLiteralNode, isVariableDeclaration, ModifierFlags, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
 import { SignatureKind, SymbolFlags, TypeFlags, } from "@typescript/native/sync";
@@ -16,7 +16,7 @@ import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 import { must } from "./query.js";
 import { erasedStores } from "./erased-stores.js";
-import { checkedTypes, valueReach } from "./value-reach.js";
+import { checkedTypes, CONVERSION_MEMBERS, valueReach } from "./value-reach.js";
 /** The serializer every run reads, whatever the configuration names. */
 const JSON_STRINGIFY = { shape: "global", global: "JSON.stringify" };
 /** The methods a serializer and a formatter resolve by name on a value that left the analysis. */
@@ -25,6 +25,8 @@ const CONVERSIONS = new Set(["toJSON", "toString"]);
 const SERIALIZED_CONVERSION = "toJSON";
 /** The parameter types that keep nothing of the value they are given. */
 const ERASED = TypeFlags.Any | TypeFlags.Unknown;
+/** How deep a callee's result is searched for a type parameter: `Promise<Box<T>>` is two levels. */
+const MENTION_DEPTH = 3;
 /** The wider of two reaches, where either may be absent. */
 function wider(a, b) {
     return a === "conversions" || b === "conversions" ? "conversions" : (a ?? b);
@@ -313,13 +315,14 @@ function destinations(input, chains, walked) {
     const inAnalysis = (path) => own.has(path) || input.consumers.some((root) => path === root || path.startsWith(`${root}/`));
     const implemented = implementedOwners(project, inAnalysis);
     /**
-     * Whether every declaration of a callee is outside the analysis or ambient. An ambient
-     * declaration has no body, so the code that runs is outside the analysis, unless it is a
-     * member of an interface or an object type a class or a typed object literal of the
-     * analysis implements; `settled` false skips that question, which asks the checker.
+     * Whether every one of `declarations`, all of the callee's by default, is outside the
+     * analysis or ambient. An ambient declaration has no body, so the code that runs is
+     * outside the analysis, unless it is a member of an interface or an object type a class
+     * or a typed object literal of the analysis implements; `settled` false skips that
+     * question, which asks the checker.
      */
-    const outside = (target, settled) => target.declarations.length > 0 &&
-        target.declarations.every((handle) => {
+    const outside = (target, settled, declarations = target.declarations) => declarations.length > 0 &&
+        declarations.every((handle) => {
             if (!inAnalysis(handle.path)) {
                 return true;
             }
@@ -333,6 +336,12 @@ function destinations(input, chains, walked) {
             const owner = must(queries.parentOf(target));
             return owner === undefined || !implemented().has(owner.id);
         });
+    /**
+     * Whether some one declaration of a callee is outside the analysis or ambient, without
+     * asking the checker. A project's declaration merged into a library's symbol leaves the
+     * library's beside it, so a call can still resolve to the library's.
+     */
+    const mayBeOutside = (target) => target.declarations.some((handle) => outside(target, false, [handle]));
     const invocation = (call) => {
         const form = forms.get(call);
         const method = form === undefined ? undefined : callees.get(form.method);
@@ -340,7 +349,7 @@ function destinations(input, chains, walked) {
         // program's own `call` and `Reflect.apply` invoke nothing here.
         if (form !== undefined &&
             method !== undefined &&
-            outside(method, false) &&
+            mayBeOutside(method) &&
             FUNCTION_INTERFACES.has(must(project.queries.parentOf(method))?.name ?? "")) {
             return form.invocation;
         }
@@ -350,6 +359,52 @@ function destinations(input, chains, walked) {
         const name = calleeName(invocation(call).callee);
         return name === undefined ? undefined : callees.get(name);
     };
+    const signatures = new Map();
+    const resolvedOf = (call) => {
+        if (!signatures.has(call)) {
+            signatures.set(call, must(queries.resolvedSignature(call)));
+        }
+        return signatures.get(call);
+    };
+    /**
+     * The declarations of a callee that the declaration of a direct call's resolved
+     * signature lies in, or all of them where it lies in none: a declaration merged into
+     * the callee's symbol that the call does not resolve to does not decide where it runs.
+     */
+    const calledDeclarations = (call, target) => {
+        const declaration = invocation(call).indirect ? undefined : resolvedOf(call)?.declaration;
+        const signature = declaration === undefined ? undefined : project.declarationAt(declaration)?.node;
+        if (declaration === undefined || signature === undefined) {
+            return target.declarations;
+        }
+        const containing = target.declarations.filter((handle) => {
+            const node = handle.path === declaration.path ? project.declarationAt(handle)?.node : undefined;
+            return node !== undefined && node.pos <= signature.pos && signature.end <= node.end;
+        });
+        return containing.length === 0 ? target.declarations : containing;
+    };
+    /** Whether a type names a type parameter, through constituents, type arguments and call signatures. */
+    const mentions = (type, parameter, depth) => {
+        // A conditional type an alias names, `Awaited<T>` among them, carries its arguments
+        // only on the alias the client's type object reports.
+        const aliased = type
+            .aliasTypeArguments;
+        if (type.id === parameter.id || aliased?.includes(parameter.id) === true) {
+            return true;
+        }
+        if (depth >= MENTION_DEPTH) {
+            return false;
+        }
+        const inner = [
+            ...(type.isUnionType() || type.isIntersectionType() ? must(queries.constituents(type)) : []),
+            ...must(queries.typeArguments(type)),
+            ...must(queries.signaturesOf(type, SignatureKind.Call)).flatMap((signature) => [
+                ...signature.parameters.map((_parameter, at) => must(queries.typeAtPosition(signature, at))),
+                ...[must(queries.returnTypeOf(signature))].filter((one) => one !== undefined),
+            ]),
+        ];
+        return inner.some((one) => mentions(one, parameter, depth + 1));
+    };
     const erasedArguments = new Map();
     const erasedAt = (call, argument) => {
         let indexes = erasedArguments.get(call);
@@ -362,11 +417,33 @@ function destinations(input, chains, walked) {
                 ? type === undefined
                     ? []
                     : must(queries.signaturesOf(type, SignatureKind.Call))
-                : [must(queries.resolvedSignature(call))].filter((one) => one !== undefined);
-            indexes = new Set(invoked.arguments.flatMap((_unused, index) => signatures.some((signature) => {
-                const parameter = must(queries.parameterType(signature, index));
-                return parameter !== undefined && (parameter.flags & ERASED) !== 0;
-            })
+                : [resolvedOf(call)].filter((one) => one !== undefined);
+            // A type parameter of the callee that nothing constrains and its result does not name
+            // keeps nothing of the value either: the instantiated signature names the value's own
+            // type there instead, and a result that names it hands the value back.
+            const generic = invoked.indirect ? undefined : resolvedOf(call);
+            const declared = generic === undefined ? undefined : must(queries.genericOf(generic));
+            const unconstrained = (index) => {
+                const parameter = declared === undefined ? undefined : must(queries.parameterType(declared, index));
+                const parts = parameter === undefined
+                    ? []
+                    : parameter.isUnionType()
+                        ? must(queries.constituents(parameter))
+                        : [parameter];
+                const result = declared === undefined ? undefined : must(queries.returnTypeOf(declared));
+                return parts.some((part) => {
+                    if (!part.isTypeParameter() || (result !== undefined && mentions(result, part, 0))) {
+                        return false;
+                    }
+                    const constraint = must(queries.constraintOf(part));
+                    return constraint === undefined || (constraint.flags & ERASED) !== 0;
+                });
+            };
+            indexes = new Set(invoked.arguments.flatMap((_unused, index) => unconstrained(index) ||
+                signatures.some((signature) => {
+                    const parameter = must(queries.parameterType(signature, index));
+                    return parameter !== undefined && (parameter.flags & ERASED) !== 0;
+                })
                 ? [index]
                 : []));
             erasedArguments.set(call, indexes);
@@ -384,7 +461,7 @@ function destinations(input, chains, walked) {
         if (entry !== undefined) {
             return { reach: "properties", callee: spelledEntry(entry.entry, held) };
         }
-        if (outside(target, true)) {
+        if (outside(target, true, calledDeclarations(call, target))) {
             return erasedAt(call, argument)
                 ? {
                     reach: "conversions",
@@ -419,7 +496,7 @@ function destinations(input, chains, walked) {
         if (target === undefined) {
             return false;
         }
-        if (named.some((one) => names(one, target, chains)) || outside(target, false)) {
+        if (named.some((one) => names(one, target, chains)) || mayBeOutside(target)) {
             return true;
         }
         return chains
@@ -509,7 +586,7 @@ export function serializationContract(input) {
     // A destination holds back a data member and `toJSON`, and `toString` as well where
     // the value left the analysis.
     const holdsBack = (flags, name, to) => (flags & SymbolFlags.Property) !== 0 ||
-        ((flags & SymbolFlags.Method) !== 0 &&
+        ((flags & CONVERSION_MEMBERS) !== 0 &&
             (name === SERIALIZED_CONVERSION || (to.reach === "conversions" && CONVERSIONS.has(name))));
     const found = [];
     for (const flow of flows) {

package/dist/src/session.js

@@ -31,6 +31,7 @@ export function openEngine(options) {
         ...(mapper === undefined ? {} : { runExternalCode: true }),
     });
     let closed = false;
+    const parsed = new Map();
     return {
         parseConfigFile: (file) => api.parseConfigFile(file),
         parseConfigJson: (json, configFile) => api.parseJsonConfigFileContent(json, { configFileName: configFile }),
@@ -54,8 +55,14 @@ export function openEngine(options) {
             moduleResolutions: { fallback: "resolve", entries: [...entries] },
         }),
         parseSourceFile: (fileName, text) => {
+            // Every project of a run reads the same files outside its program, so one parse serves all.
+            const known = parsed.get(fileName);
+            if (known?.text === text) {
+                return known.file;
+            }
             const retained = api.createSourceFile(fileName, text);
             try {
+                parsed.set(fileName, { text, file: retained.sourceFile });
                 return retained.sourceFile;
             }
             finally {
@@ -189,12 +196,30 @@ export function ownedAs(project, own) {
         },
     };
 }
-/** The three diagnostic sets one project carries, read before any analysis. */
+/**
+ * The program's diagnostics placed in no file. The per-file sets never carry one; the
+ * client answers its `fileName` as `null`, and the global set repeats the program set:
+ * https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/api/session.go#L3726-L3752
+ */
+function unplacedOf(program) {
+    const seen = new Set();
+    return [...program.getGlobalDiagnostics(), ...program.getProgramDiagnostics()]
+        .filter((diagnostic) => diagnostic.fileName == null)
+        .filter((diagnostic) => {
+        const key = `${String(diagnostic.code)}\u0000${diagnostic.text}`;
+        const fresh = !seen.has(key);
+        seen.add(key);
+        return fresh;
+    })
+        .map((diagnostic) => ({ ...diagnostic, fileName: undefined }));
+}
+/** The diagnostic sets one project carries, read before any analysis. */
 export function diagnosticsOf(project) {
     return {
         syntactic: project.program.getSyntacticDiagnostics(),
         semantic: project.program.getSemanticDiagnostics(),
         configParsing: project.program.getConfigFileParsingDiagnostics(),
+        unplaced: unplacedOf(project.program),
         locate: (fileName, offset) => {
             const file = project.program.getSourceFile(fileName);
             if (file === undefined || offset < 0 || offset > file.text.length) {

package/dist/src/source-files.js

@@ -4,9 +4,13 @@
  * compiler emits from it.
  */
 import { commonDirectory, emittedFrom } from "./emit-map.js";
-import { dirnamePath, relativePath, resolvePath } from "./paths.js";
+import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
 /** The one character a subpath pattern of a manifest's `exports` holds. */
 const SUBPATH_WILDCARD = "*";
+/** The extension a source file's name drops when the project writes it out. */
+const SOURCE_EXTENSION = /\.[cm]?[jt]sx?$/u;
+/** The extensions the project may write a source file's output under. */
+const OUTPUT_EXTENSIONS = [".js", ".mjs", ".cjs", ".jsx", ".d.ts", ".d.mts", ".d.cts"];
 /**
  * Whether one path is what a subpath pattern stands for: the text before the
  * wildcard, any run of characters including the solidus, then the text after it.
@@ -17,6 +21,27 @@ function matchesSubpath(pattern, path) {
     const after = pattern.slice(at + SUBPATH_WILDCARD.length);
     return (path.length >= before.length + after.length && path.startsWith(before) && path.endsWith(after));
 }
+/** The first own file of the paths given that the project holds, or none. */
+function heldAt(byName, paths) {
+    for (const candidate of paths) {
+        const file = byName.get(candidate);
+        if (file !== undefined) {
+            return [file];
+        }
+    }
+    return [];
+}
+/** Where one project writes its output, and the directory it writes it from, absolute. */
+function layoutOf(project, fileNames) {
+    const options = project.program.getCompilerOptions();
+    const configDir = dirnamePath(project.configFile);
+    const at = (option) => option === undefined ? undefined : resolvePath(configDir, option);
+    return {
+        outDir: at(options.outDir),
+        declarationDir: at(options.declarationDir),
+        sourceDir: at(options.rootDir) ?? commonDirectory(fileNames),
+    };
+}
 /**
  * The lookups over one project's own files.
  *
@@ -36,12 +61,7 @@ export function sourceFilesOf(project, targetRoot) {
             byPath.set(path, file);
         }
     }
-    const options = project.program.getCompilerOptions();
-    const configDir = dirnamePath(project.configFile);
-    const at = (option) => option === undefined ? undefined : resolvePath(configDir, option);
-    const outDir = at(options.outDir);
-    const declarationDir = at(options.declarationDir);
-    const sourceDir = at(options.rootDir) ?? commonDirectory([...byName.keys()]);
+    const { outDir, declarationDir, sourceDir } = layoutOf(project, [...byName.keys()]);
     const layout = { outDir, declarationDir, sourceDirs: [sourceDir] };
     /** The source paths one written path may stand for, the path itself first. */
     const candidates = (path) => [path, ...emittedFrom(path, layout)];
@@ -49,15 +69,20 @@ export function sourceFilesOf(project, targetRoot) {
         byPath,
         byName,
         outputDirs: [...new Set([outDir, declarationDir])].filter((dir) => dir !== undefined),
+        writtenAs: (file) => {
+            const below = relativePath(sourceDir, file.fileName);
+            if (below === undefined) {
+                return [];
+            }
+            const written = [outDir, declarationDir].flatMap((dir) => dir === undefined
+                ? []
+                : OUTPUT_EXTENSIONS.map((extension) => joinPath(dir, below.replace(SOURCE_EXTENSION, extension))));
+            return [...new Set(written)].filter((path) => heldAt(byName, candidates(path))[0] === file);
+        },
+        namedAsOutput: (outputDir, path) => heldAt(byName, emittedFrom(path, { outDir: outputDir, sourceDirs: [sourceDir] })),
         named: (path) => {
             if (!path.includes(SUBPATH_WILDCARD)) {
-                for (const candidate of candidates(path)) {
-                    const held = byName.get(candidate);
-                    if (held !== undefined) {
-                        return [held];
-                    }
-                }
-                return [];
+                return heldAt(byName, candidates(path));
             }
             const patterns = candidates(path).filter((candidate) => candidate.includes(SUBPATH_WILDCARD));
             return [...byName.values()].filter((file) => patterns.some((pattern) => matchesSubpath(pattern, file.fileName)));