@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.10

package/dist/src/roots.js

@@ -1,23 +1,26 @@
 /**
- * The root set of one project: every declaration the analysis keeps live without a
- * reference, and why.
- *
- * 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; the published API only supposes a consumer, so a published export is live
- * under reachability and still a candidate under reference counting.
+ * The root set of one project: every declaration kept live without a reference, and why.
+ * Every root seeds reachability and none counts as a reference; a root of a kind that
+ * names a caller is live under reference counting too, which the sweep decides, so a
+ * published export, which only supposes a consumer, stays a reference-counting candidate.
  */
-import { isExpressionWithTypeArguments, isFunctionLikeDeclaration, isPropertyAccessExpression, isQualifiedName, isTypeQueryNode, isTypeReferenceNode, isPropertyDeclaration, isVariableDeclaration, isVariableStatement, } from "@typescript/native/ast";
+import { isArrowFunction, isAssertionExpression, isExpressionWithTypeArguments, isFunctionLikeDeclaration, isIdentifier, isMethodDeclaration, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAssignment, isReturnStatement, isSatisfiesExpression, isPropertyAccessExpression, isQualifiedName, isTypeQueryNode, isTypeReferenceNode, isPropertyDeclaration, isVariableDeclaration, isVariableStatement, SyntaxKind, } from "@typescript/native/ast";
 import { aliasChains } from "./alias-chain.js";
+import { isGlobalBlock } from "./augmentations.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 { ancestors, dirnamePath, relativePath, resolvePath } from "./paths.js";
 import { byPosition } from "./position.js";
 import { UNANSWERED } from "./query.js";
 import { sourceFilesOf } from "./source-files.js";
 import { typeQueryAliases } from "./type-query-alias.js";
+import { bytewise } from "./text/compare.js";
+import { holdsManifest } from "./fs/manifest.js";
+import { globExpression } from "./text/glob.js";
+import { spelledFiles } from "./text/named-files.js";
+import { commandDirectories, workflowCommands } from "./workflow-steps.js";
 /** Whether one declaration is written below the directory of a published workspace member. */
 function inPublishedMember(held, id, root, members) {
     const path = held.symbols.find((symbol) => symbol.id === id)?.position.path;
@@ -43,11 +46,17 @@ 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) {
+    const between = ancestors(dirnamePath(file), dir);
+    return between.length > 0 && !between.slice(0, -1).some((at) => holdsManifest(host, at));
+}
 /**
  * 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 +72,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("?");
@@ -121,13 +159,6 @@ export function matchRef(pattern, ref) {
     }
     return matchGlob(Array.from(pattern), Array.from(ref));
 }
-/** Two strings ordered bytewise, which is the order every set of a run is read in. */
-function compare(a, b) {
-    if (a === b) {
-        return 0;
-    }
-    return a < b ? -1 : 1;
-}
 /** The members of one declaration, indexed by the container that holds them. */
 function childrenOf(held) {
     const byParent = new Map();
@@ -143,15 +174,47 @@ function childrenOf(held) {
     return byParent;
 }
 /**
- * The roots one project holds, and every configured string that named nothing in it.
- *
- * A file a manifest member, an entry-file pattern or a tool's configuration names
- * is a root with everything its module exports: each name of the module's export
- * table, and where a name is a re-export, every link of the chain to the declaration
- * it carries, so a re-exported declaration is a root of the file that publishes it.
- * In a library, what a published file exports is rooted by the published API alone.
- * A file a runtime executes without reading its exports, a test file or a worker, is
- * a root by itself.
+ * Per package, the own files its command strings name as plain text, but those a root enters
+ * with all they export: a command can use no more of such a file than the root keeps live. A
+ * manifest's are its entries' whole command strings, and the target root's package has the
+ * workflow steps, git hooks and makefile recipes beside its own, with the directories its
+ * workflow steps and lefthook commands run in, where a `.` names that directory's index file.
+ */
+function scriptHolds(entries, files, entered, host, targetRoot) {
+    const rooted = new Set(entered.filter((one) => one.exports && one.names === undefined).map((one) => one.file.fileName));
+    const spelled = [...files.byName.values()]
+        .filter((file) => !rooted.has(file.fileName))
+        .map((file) => ({ file, paths: [file.fileName, ...files.writtenAs(file)] }));
+    const cwd = host.workingDirectory();
+    const commands = new Map([
+        [
+            resolvePath(cwd, targetRoot),
+            [...workflowCommands(host, targetRoot), ...commandDirectories(host, targetRoot)],
+        ],
+    ]);
+    for (const entry of entries) {
+        if (entry.command !== undefined) {
+            const dir = resolvePath(cwd, entry.dir);
+            commands.set(dir, [...(commands.get(dir) ?? []), entry.command]);
+        }
+    }
+    const held = [];
+    for (const [dir, texts] of commands) {
+        const named = spelledFiles(texts.join("\n"), dir, spelled);
+        if (named.length > 0) {
+            const paths = named.map((file) => relativePath(targetRoot, file.fileName) ?? file.fileName);
+            held.push({ dir, files: paths });
+        }
+    }
+    return held;
+}
+/**
+ * The roots one project holds, and every configured string that named nothing in it. A
+ * file a manifest member, an entry-file pattern or a tool's configuration names is a root
+ * with each name of its export table and every link of a re-export chain to the
+ * declaration it carries; in a library, the published API alone roots what a published
+ * file exports. A file a runtime executes without reading its exports, a test file or a
+ * worker, is a root by itself.
  */
 export function roots(project, held, targetRoot, options) {
     const files = sourceFilesOf(project, targetRoot);
@@ -168,8 +231,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 = [];
@@ -186,45 +249,83 @@ export function roots(project, held, targetRoot, options) {
                 (options.publishedAPI || options.publishedMembers?.has(entry.dir) === true),
         })),
     ];
-    const scripted = entries.flatMap(({ entry }) => entry.role === "script" ? files.named(entry.path) : []);
+    const scripted = entries.flatMap(({ entry }) => entry.role === "script" && entry.command === undefined ? files.named(entry.path) : []);
     const readBackTo = [
         ...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) {
             published.push(...entryFiles(entry));
         }
     }
-    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));
-        }
+    if (options.publishedAPI) {
+        // A library's bundle hands what its entry exports to every program that loads it.
+        published.push(...points.filter((point) => point.rule === "bundler-entry").map((point) => point.file));
     }
+    const publishedNames = new Set(published.map((file) => 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) {
+        if (entry.command !== undefined) {
+            continue;
+        }
+        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);
     }
+    const heldScripts = scriptHolds(entries.map(({ entry }) => entry), files, entered, options.host, targetRoot);
+    const heldFiles = [...new Set(heldScripts.flatMap((one) => one.files))].flatMap((path) => files.byPath.get(path) ?? []);
     for (const file of files.byPath.values()) {
         for (const alias of typeQueryAliases(file)) {
             const source = alias.type.getText().replace(/\s+/gu, " ");
@@ -236,9 +337,10 @@ 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,
+        ...heldFiles,
     ]);
     for (const entry of entered) {
         const id = fileIds.get(entry.file.fileName);
@@ -247,8 +349,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);
             }
         }
     }
@@ -265,12 +371,22 @@ export function roots(project, held, targetRoot, options) {
         const left = sites.get(a.id);
         const right = sites.get(b.id);
         const site = left === undefined || right === undefined ? 0 : byPosition(left, right);
-        return site || compare(a.kind, b.kind) || compare(a.source, b.source);
+        return site || bytewise(a.kind, b.kind) || bytewise(a.source, b.source);
     });
     return {
         liveUnderReachability: ordered,
         unmatched,
-        unanswered: answered ? api.guessed : held.symbols.map((symbol) => symbol.id),
+        unanswered: [
+            ...(answered ? api.guessed : held.symbols.map((symbol) => symbol.id)),
+            // A command runs a held file and may read any export of it, so the file, which reaches its
+            // top level, and its exports are held; a declaration neither reaches is still dead.
+            ...heldFiles.flatMap((file) => {
+                const id = fileIds.get(file.fileName);
+                return [...(id === undefined ? [] : [id]), ...(exportsOf.get(file.fileName) ?? [])];
+            }),
+        ],
+        unmappedEntries,
+        heldScripts,
     };
 }
 /**
@@ -284,9 +400,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 +424,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;
@@ -357,12 +477,12 @@ function releaseTagged(held, files) {
 /** The kinds of container whose export table, not its members' visibility, says what it publishes. */
 const EXPORTING_CONTAINERS = new Set(["file", "namespace"]);
 /**
- * Every declaration a consumer of the library can name: what the published files export,
- * and below each the members a consumer writes, a namespace's exported ones and any other
- * declaration's public and protected ones. A declaration a published one's type names is
- * published too, and so is an exported declaration a release tag marks. A type name the
- * checker leaves unanswered publishes every declaration spelled as it is, as `guessed`. A
- * published file is not itself published.
+ * Every declaration a consumer of the library can name, a published file itself excluded:
+ * what the published files export, with a namespace's exported members and any other
+ * declaration's public and protected ones; a declaration a published one's type names; an
+ * exported declaration a release tag marks; each declaration a `declare global` block holds
+ * in a published file or one holding a published declaration; and, as `guessed`, each
+ * declaration spelled as a type name the checker leaves unanswered.
  */
 function publishedAPI(project, published, exportsOf, held, byPath, tagged) {
     const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
@@ -370,11 +490,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,55 +505,83 @@ 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) {
-        const round = [];
-        for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
-            round.push(next);
-            const exporting = EXPORTING_CONTAINERS.has(byId.get(next)?.kind ?? "");
-            for (const member of children.get(next) ?? []) {
-                const reachable = exporting
-                    ? member.exported
-                    : member.visibility !== "private" && member.visibility !== "private-name";
-                if (member.kind !== "type-parameter" && reachable) {
+    const files = new Set(held.symbols.filter((one) => one.kind === "file").map((one) => one.id));
+    const blocks = held.symbols.filter((one) => isGlobalBlock(one, held, files));
+    const fileOf = (id) => {
+        let at = byId.get(id);
+        while (at !== undefined && at.kind !== "file") {
+            at = byId.get(at.parent);
+        }
+        return at?.id;
+    };
+    const publishedFiles = published.flatMap((file) => held.declarations.get(nodeKey(file, file)) ?? []);
+    const globalsReached = () => {
+        const typed = new Set([...publishedFiles, ...[...reached].flatMap((id) => fileOf(id) ?? [])]);
+        const before = pending.length;
+        for (const block of blocks.filter((one) => typed.has(one.parent))) {
+            reach(block.id);
+            for (const member of children.get(block.id) ?? []) {
+                if (member.kind !== "type-parameter") {
                     reach(member.id);
                 }
             }
         }
-        const named = round.flatMap((id) => {
-            const symbol = byId.get(id);
-            return symbol === undefined || symbol.kind === "file" ? [] : nodes.typeNamesOf(symbol);
-        });
-        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];
-        }))) {
-            for (const target of chains.chainOf(symbol)) {
-                reach(target.id);
-            }
-        }
-        project.symbolsAt(named.map((node) => project.handle(node))).forEach((symbol, index) => {
-            if (symbol === UNANSWERED) {
-                for (const id of held.byName.get(named[index]?.getText() ?? "") ?? []) {
-                    guessed.add(id);
-                    reach(id);
+        return pending.length > before;
+    };
+    do {
+        while (pending.length > 0) {
+            const round = [];
+            for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
+                round.push(next);
+                const exporting = EXPORTING_CONTAINERS.has(byId.get(next)?.kind ?? "");
+                for (const member of children.get(next) ?? []) {
+                    const reachable = exporting
+                        ? member.exported
+                        : member.visibility !== "private" && member.visibility !== "private-name";
+                    if (member.kind !== "type-parameter" && reachable) {
+                        reach(member.id);
+                    }
                 }
             }
-            else if (symbol !== undefined) {
+            const named = round.flatMap((id) => {
+                const symbol = byId.get(id);
+                return symbol === undefined || symbol.kind === "file" ? [] : nodes.typeNamesOf(symbol);
+            });
+            const inferred = inferredTypeSymbols(project, round.flatMap((id) => {
+                const symbol = byId.get(id);
+                return symbol === undefined ? [] : nodes.nodesOf(symbol);
+            }));
+            for (const symbol of inferred.types) {
                 for (const target of chains.chainOf(symbol)) {
                     reach(target.id);
                 }
             }
-        });
-    }
+            for (const symbol of inferred.members) {
+                for (const target of chains.chainOf(symbol)) {
+                    const member = byId.get(target.id);
+                    if (member?.visibility === "public" || member?.visibility === "protected") {
+                        reach(target.id);
+                    }
+                }
+            }
+            project.symbolsAt(named.map((node) => project.handle(node))).forEach((symbol, index) => {
+                if (symbol === UNANSWERED) {
+                    for (const id of held.byName.get(named[index]?.getText() ?? "") ?? []) {
+                        guessed.add(id);
+                        reach(id);
+                    }
+                }
+                else if (symbol !== undefined) {
+                    for (const target of chains.chainOf(symbol)) {
+                        reach(target.id);
+                    }
+                }
+            });
+        }
+    } while (globalsReached());
     return { ids: [...reached], guessed: [...guessed] };
 }
 /** The type names declarations of the inventory write, each file walked once, when first asked. */
@@ -449,9 +599,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,20 +611,109 @@ 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. */
 const INFERRED_DEPTH = 4;
 /**
- * The declarations of the types the compiler infers where a declaration writes none: the
- * type of a variable or a property with no annotation, and the result of a function or a
- * method with no result annotation, each with the types its type arguments and its union
- * or intersection constituents name, to a fixed depth. A question the checker leaves
- * unanswered names nothing.
+ * The values one function body returns, each through the type assertions around it: the
+ * value a caller receives carries the operand's type whatever type the assertion or the
+ * signature names. A nested function's returns are its own.
+ */
+function returnedValues(body) {
+    const found = [];
+    const add = (value) => {
+        for (let at = value; at !== undefined;) {
+            found.push(at);
+            at =
+                isAssertionExpression(at) || isSatisfiesExpression(at) || isParenthesizedExpression(at)
+                    ? at.expression
+                    : undefined;
+        }
+    };
+    if (!isFunctionLikeDeclaration(body.parent) || body.parent.body !== body) {
+        return found;
+    }
+    if (isArrowFunction(body.parent) && body.kind !== SyntaxKind.Block) {
+        add(body);
+        return found;
+    }
+    const visit = (node) => {
+        if (isFunctionLikeDeclaration(node)) {
+            return;
+        }
+        if (isReturnStatement(node) && node.expression !== undefined) {
+            add(node.expression);
+        }
+        node.forEachChild(visit);
+    };
+    body.forEachChild(visit);
+    return found;
+}
+/** The object literal one returned value is, written there or as the initializer of a variable `body` declares. */
+function returnedLiteral(value, body) {
+    if (isObjectLiteralExpression(value)) {
+        return value;
+    }
+    if (!isIdentifier(value)) {
+        return undefined;
+    }
+    let found;
+    const visit = (node) => {
+        if (isVariableDeclaration(node) &&
+            isIdentifier(node.name) &&
+            node.name.text === value.text &&
+            node.initializer !== undefined) {
+            let at = node.initializer;
+            while (isAssertionExpression(at) ||
+                isSatisfiesExpression(at) ||
+                isParenthesizedExpression(at)) {
+                at = at.expression;
+            }
+            found = isObjectLiteralExpression(at) ? at : found;
+        }
+        if (!isFunctionLikeDeclaration(node)) {
+            node.forEachChild(visit);
+        }
+    };
+    body.forEachChild(visit);
+    return found;
+}
+/**
+ * The values one function body returns, and those each method of an object literal it
+ * returns returns, to a fixed depth: a caller holding the literal calls its methods, and
+ * receives what they return.
+ */
+function returnedThroughLiterals(body, depth = 0) {
+    const values = returnedValues(body);
+    if (depth >= INFERRED_DEPTH) {
+        return values;
+    }
+    const found = [...values];
+    for (const value of values) {
+        for (const property of returnedLiteral(value, body)?.properties ?? []) {
+            const fn = isMethodDeclaration(property)
+                ? property
+                : isPropertyAssignment(property) && isFunctionLikeDeclaration(property.initializer)
+                    ? property.initializer
+                    : undefined;
+            if (fn?.body !== undefined) {
+                found.push(...returnedThroughLiterals(fn.body, depth + 1));
+            }
+        }
+    }
+    return found;
+}
+/**
+ * The declarations of the types the compiler infers where a declaration writes none, and
+ * of the values a function returns: the type of a variable or a property with no
+ * annotation, the result of a function or a method with no result annotation, and the type
+ * of each value its body returns, each with the types its type arguments and its union or
+ * intersection constituents name, to a fixed depth; and as `members` the properties of each
+ * returned value's type. A question the checker leaves unanswered names nothing.
  */
 function inferredTypeSymbols(project, declarations) {
     const { queries } = project;
@@ -485,12 +722,24 @@ function inferredTypeSymbols(project, declarations) {
         !isFunctionLikeDeclaration(node.initializer ?? node)
         ? [node.name]
         : []);
+    const returned = declarations.flatMap((node) => {
+        const signature = isFunctionLikeDeclaration(node)
+            ? node
+            : isVariableDeclaration(node) &&
+                node.initializer !== undefined &&
+                isFunctionLikeDeclaration(node.initializer)
+                ? node.initializer
+                : undefined;
+        return signature?.body === undefined ? [] : returnedThroughLiterals(signature.body);
+    });
     const types = [];
-    queries.typesAt(valued).forEach((type) => {
+    const returnedTypes = [];
+    queries.typesAt([...valued, ...returned]).forEach((type, at) => {
         if (type !== UNANSWERED && type !== undefined) {
-            types.push(type);
+            (at < valued.length ? types : returnedTypes).push(type);
         }
     });
+    types.push(...returnedTypes);
     for (const node of declarations) {
         const signature = isFunctionLikeDeclaration(node)
             ? node
@@ -532,7 +781,19 @@ function inferredTypeSymbols(project, declarations) {
     types.forEach((type) => {
         visit(type, 0);
     });
-    return [...found.values()];
+    // A returned value carries each property of its type, one an anonymous type declares or
+    // an intersection merges included, which no type name reaches.
+    const members = new Map();
+    for (const type of returnedTypes) {
+        const parts = queries.constituents(type);
+        for (const one of [type, ...(parts === UNANSWERED ? [] : parts)]) {
+            const properties = queries.propertiesOf(one);
+            for (const property of properties === UNANSWERED ? [] : properties) {
+                members.set(property.id, property);
+            }
+        }
+    }
+    return { types: [...found.values()], members: [...members.values()] };
 }
 /**
  * The names of types one declaration's own syntax writes: in a type reference, a
@@ -587,13 +848,10 @@ function configured(held, patterns, add) {
     return unmatched;
 }
 /**
- * Every configured string that named no declaration in ANY project of the run, in
- * configuration order and each once.
- *
- * A finding about a configured root is about the configuration and not about a
- * declaration, so there is one per run: a string that names a declaration of one
- * project has named something, and the projects it named nothing in are not a
- * finding. A run with no project names nothing with any of them.
+ * Every configured string that named no declaration in any project of the run, in
+ * configuration order and each once. The finding is about the configuration, so a string
+ * naming a declaration of one project has named something, and a run with no project
+ * names nothing with any of them.
  */
 export function unmatchedEverywhere(patterns, perProject) {
     return [...new Set(patterns)].filter((pattern) => perProject.every((project) => project.unmatched.includes(pattern)));