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

package/dist/src/roots.js

@@ -1,865 +0,0 @@
-/**
- * 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 { 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 { nodeKey } from "./inventory.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 { commandFileTexts, workflowCommands } from "./workflow-steps.js";
-import { readCommands } from "./commands/read.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;
-    if (path === undefined || members === undefined) {
-        return false;
-    }
-    const file = resolvePath(root, path);
-    return [...members].some((dir) => file.startsWith(`${dir}/`));
-}
-/** The kind of root each role of a manifest entry makes. */
-const ENTRY_KINDS = {
-    import: "manifest-entry",
-    run: "manifest-binary",
-    script: "script",
-};
-/** The rules whose rooted files a manifest target is read back to by name. */
-const READ_BACK_RULES = new Set([
-    "configuration-file",
-    "configuration-string",
-    "html-entry",
-]);
-/** The extensions a manifest target's name drops: the ones a build writes. */
-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 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);
-    const below = relativePath(dir, resolvePath(host.workingDirectory(), entry.path));
-    if (below === undefined || below === "") {
-        return [];
-    }
-    const cut = below.indexOf("/");
-    const name = (cut === -1 ? below : below.slice(cut + 1)).replace(OUTPUT_EXTENSION, "");
-    if (name === "") {
-        return [];
-    }
-    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}`)) &&
-            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("?");
-}
-/**
- * Whether ref matches a pattern whose only special characters are `*`, which stands
- * for any run of characters including the solidus, and `?`, which stands for exactly
- * one character counted as a code point. A star keeps the position it last stood at,
- * so the shortest run it can stand for is tried first.
- */
-function matchGlob(pattern, ref) {
-    let next = 0;
-    let star = -1;
-    let resume = 0;
-    let at = 0;
-    while (at < ref.length) {
-        if (next < pattern.length && (pattern[next] === "?" || pattern[next] === ref[at])) {
-            next += 1;
-            at += 1;
-        }
-        else if (next < pattern.length && pattern[next] === "*") {
-            star = next;
-            resume = at;
-            next += 1;
-        }
-        else if (star >= 0) {
-            resume += 1;
-            next = star + 1;
-            at = resume;
-        }
-        else {
-            return false;
-        }
-    }
-    while (next < pattern.length && pattern[next] === "*") {
-        next += 1;
-    }
-    return next === pattern.length;
-}
-/**
- * Whether one configured string names the symbol reference ref. A string carrying
- * neither special character names only the reference it spells.
- *
- * Both sides are read as code points: a character outside the basic plane is two
- * string units, and `?` stands for one character.
- */
-export function matchRef(pattern, ref) {
-    if (!isPattern(pattern)) {
-        return pattern === ref;
-    }
-    return matchGlob(Array.from(pattern), Array.from(ref));
-}
-/** The members of one declaration, indexed by the container that holds them. */
-function childrenOf(held) {
-    const byParent = new Map();
-    for (const symbol of held.symbols) {
-        const siblings = byParent.get(symbol.parent);
-        if (siblings === undefined) {
-            byParent.set(symbol.parent, [symbol]);
-        }
-        else {
-            siblings.push(symbol);
-        }
-    }
-    return byParent;
-}
-/**
- * Per package, the own files its held texts name, as `spelledFiles` reads them, 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' held texts, and the target root's package has the
- * workflow steps, git hooks and makefile recipes beside its own, with the whole text of each
- * file `commandFileTexts` reads.
- */
-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).flatMap(({ text, dir, writtenDirectory }) => [
-                    readCommands(text, dir).held,
-                    ...(writtenDirectory === undefined ? [] : [writtenDirectory]),
-                ]),
-                ...commandFileTexts(host, targetRoot),
-            ],
-        ],
-    ]);
-    for (const entry of entries) {
-        if (entry.held !== undefined) {
-            const dir = resolvePath(cwd, entry.dir);
-            commands.set(dir, [...(commands.get(dir) ?? []), entry.held]);
-        }
-    }
-    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);
-    const declared = held.declarations;
-    const fileIds = new Map();
-    for (const file of files.byName.values()) {
-        const id = declared.get(nodeKey(file, file));
-        if (id !== undefined) {
-            fileIds.set(file.fileName, id);
-        }
-    }
-    const found = new Map();
-    const add = (id, kind, source) => {
-        found.set([id, kind, source].join("\u0000"), { id, kind, source });
-    };
-    const entered = [];
-    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 = [];
-    const entries = [
-        ...options.manifest.entries.map((entry) => ({
-            entry,
-            publishes: options.publishedAPI &&
-                entry.published &&
-                (options.manifest.declaresExports ? entry.member.startsWith("exports") : true),
-        })),
-        ...(options.otherPackages ?? []).map((entry) => ({
-            entry,
-            publishes: entry.published &&
-                (options.publishedAPI || options.publishedMembers?.has(entry.dir) === true),
-        })),
-    ];
-    const scripted = entries.flatMap(({ entry }) => entry.role === "script" && entry.held === 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);
-        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));
-        }
-    }
-    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)) {
-                patterned.push({ file, pattern });
-            }
-        }
-    }
-    const unmapped = [];
-    const mapped = patterned.map(({ file }) => file);
-    for (const { entry } of entries) {
-        if (entry.held !== 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, 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, " ");
-            for (const node of [alias.declaration, ...alias.containers]) {
-                const id = declared.get(nodeKey(file, node));
-                if (id !== undefined) {
-                    add(id, "type-query-alias", source);
-                }
-            }
-        }
-    }
-    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);
-        if (id === undefined) {
-            continue;
-        }
-        add(id, entry.kind, entry.source);
-        if (entry.exports) {
-            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);
-            }
-        }
-    }
-    const tagged = releaseTagged(held, files).filter((id) => options.publishedAPI || inPublishedMember(held, id, targetRoot, options.publishedMembers));
-    const api = published.length > 0 || tagged.length > 0
-        ? publishedAPI(project, published, exportsOf, held, files.byPath, tagged)
-        : { ids: [], guessed: [] };
-    for (const id of api.ids) {
-        add(id, "published-api", "");
-    }
-    const unmatched = configured(held, options.patterns, add);
-    const sites = new Map(held.symbols.map((symbol) => [symbol.id, symbol.position]));
-    const ordered = [...found.values()].sort((a, b) => {
-        const left = sites.get(a.id);
-        const right = sites.get(b.id);
-        const site = left === undefined || right === undefined ? 0 : byPosition(left, right);
-        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)),
-            // 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,
-    };
-}
-/**
- * Every declaration each file's module exports, by the file's name: the declaration
- * each name of the export table is, and every link of a re-export's chain. A name
- * whose declaration is outside the project's own files names nothing here. One batch
- * resolves every file to its module and one request per module reads its export
- * table, star re-exports resolved into it. A file that is no module exports nothing.
- * `answered` is false where the checker left a table or a link of a chain unanswered.
- */
-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, named, answered };
-    }
-    const modules = project.symbolsAt(unique.map((file) => project.handle(file)));
-    const chains = aliasChains(project, held);
-    const topLevel = (file) => {
-        const fileId = held.declarations.get(nodeKey(file, file));
-        return held.symbols.filter((symbol) => symbol.parent === fileId).map((symbol) => symbol.id);
-    };
-    unique.forEach((file, index) => {
-        const module = modules[index];
-        if (module === undefined) {
-            tables.set(file.fileName, []);
-            return;
-        }
-        const table = module === UNANSWERED ? UNANSWERED : project.queries.exportsOfModule(module);
-        if (table === UNANSWERED) {
-            answered = false;
-            tables.set(file.fileName, topLevel(file));
-            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, 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;
-/**
- * Whether the documentation comment of the statement that starts at `start`, the last
- * `/** *\/` comment before it with only white space between the two, holds a release tag.
- */
-function releaseTagIn(text, from, start) {
-    const leading = text.slice(from, start);
-    const open = leading.lastIndexOf("/**");
-    const close = open < 0 ? -1 : leading.indexOf("*/", open + 3);
-    if (close < 0 || leading.slice(close + 2).trim() !== "") {
-        return false;
-    }
-    return RELEASE_TAG.test(leading.slice(open + 3, close));
-}
-/** The exported top-level declarations of the program's files a release tag marks. */
-function releaseTagged(held, files) {
-    const exported = new Set(held.symbols.filter((symbol) => symbol.exported).map((one) => one.id));
-    const found = [];
-    for (const file of files.byPath.values()) {
-        for (const statement of file.statements) {
-            if (!releaseTagIn(file.text, statement.pos, statement.getStart())) {
-                continue;
-            }
-            const nodes = isVariableStatement(statement)
-                ? statement.declarationList.declarations
-                : [statement];
-            for (const node of nodes) {
-                const id = held.declarations.get(nodeKey(file, node));
-                if (id !== undefined && exported.has(id)) {
-                    found.push(id);
-                }
-            }
-        }
-    }
-    return found;
-}
-/** 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, 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]));
-    const children = childrenOf(held);
-    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) => {
-        const file = byId.get(id)?.kind === "file";
-        if (!(file ? entered : reached).has(id)) {
-            (file ? entered : reached).add(id);
-            pending.push(id);
-        }
-    };
-    for (const id of tagged) {
-        reach(id);
-    }
-    for (const file of published) {
-        for (const id of exportsOf.get(file.fileName) ?? []) {
-            reach(id);
-        }
-    }
-    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);
-                }
-            }
-        }
-        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);
-                    }
-                }
-            }
-            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. */
-function declarationNodes(held, byPath) {
-    const walked = new Map();
-    const nodesIn = (path) => {
-        const known = walked.get(path);
-        if (known !== undefined) {
-            return known;
-        }
-        const found = { byId: new Map(), nodes: new Set() };
-        const file = byPath.get(path);
-        if (file !== undefined) {
-            const visit = (node) => {
-                const id = held.declarations.get(nodeKey(file, node));
-                if (id !== undefined) {
-                    found.nodes.add(node);
-                    found.byId.set(id, [...(found.byId.get(id) ?? []), node]);
-                }
-                node.forEachChild(visit);
-            };
-            visit(file);
-        }
-        walked.set(path, found);
-        return found;
-    };
-    return {
-        typeNamesOf: (symbol) => {
-            const { byId, nodes } = nodesIn(symbol.position.path);
-            return (byId.get(symbol.id) ?? []).flatMap((declaration) => typeNamesOf(declaration, nodes));
-        },
-        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 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;
-    const valued = declarations.flatMap((node) => (isVariableDeclaration(node) || isPropertyDeclaration(node)) &&
-        node.type === undefined &&
-        !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 = [];
-    const returnedTypes = [];
-    queries.typesAt([...valued, ...returned]).forEach((type, at) => {
-        if (type !== UNANSWERED && type !== undefined) {
-            (at < valued.length ? types : returnedTypes).push(type);
-        }
-    });
-    types.push(...returnedTypes);
-    for (const node of declarations) {
-        const signature = isFunctionLikeDeclaration(node)
-            ? node
-            : isVariableDeclaration(node) &&
-                node.type === undefined &&
-                node.initializer !== undefined &&
-                isFunctionLikeDeclaration(node.initializer)
-                ? node.initializer
-                : undefined;
-        if (signature === undefined || signature.type !== undefined || signature.body === undefined) {
-            continue;
-        }
-        const typed = queries.signatureOf(signature);
-        const result = typed === UNANSWERED || typed === undefined ? undefined : queries.returnTypeOf(typed);
-        if (result !== UNANSWERED && result !== undefined) {
-            types.push(result);
-        }
-    }
-    const found = new Map();
-    const seen = new Set();
-    const visit = (type, depth) => {
-        if (depth > INFERRED_DEPTH || seen.has(type)) {
-            return;
-        }
-        seen.add(type);
-        const symbol = queries.symbolOfType(type);
-        if (symbol !== UNANSWERED && symbol !== undefined) {
-            found.set(symbol.id, symbol);
-        }
-        const parts = queries.constituents(type);
-        const args = queries.typeArguments(type);
-        for (const next of [
-            ...(parts === UNANSWERED || (parts.length === 1 && parts[0] === type) ? [] : parts),
-            ...(args === UNANSWERED ? [] : args),
-        ]) {
-            visit(next, depth + 1);
-        }
-    };
-    types.forEach((type) => {
-        visit(type, 0);
-    });
-    // 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
- * heritage clause or a type query. A function body is not read, and neither is a
- * declaration nested in this one, which `nested` holds and which is read on its own.
- */
-function typeNamesOf(declaration, nested) {
-    const found = [];
-    const visit = (node) => {
-        if (node !== declaration && nested.has(node)) {
-            return;
-        }
-        if (isTypeReferenceNode(node)) {
-            found.push(isQualifiedName(node.typeName) ? node.typeName.right : node.typeName);
-        }
-        else if (isExpressionWithTypeArguments(node)) {
-            found.push(isPropertyAccessExpression(node.expression) ? node.expression.name : node.expression);
-        }
-        else if (isTypeQueryNode(node)) {
-            found.push(isQualifiedName(node.exprName) ? node.exprName.right : node.exprName);
-        }
-        const body = isFunctionLikeDeclaration(node) ? node.body : undefined;
-        node.forEachChild((child) => {
-            if (child !== body) {
-                visit(child);
-            }
-        });
-    };
-    visit(declaration);
-    return found;
-}
-/**
- * Keeps every declaration the configuration names and returns every string that
- * named none, in configuration order. A string the configuration lists twice is one
- * configured root.
- */
-function configured(held, patterns, add) {
-    const unmatched = [];
-    for (const pattern of new Set(patterns)) {
-        const kind = isPattern(pattern) ? "pattern" : "configured";
-        let matched = false;
-        for (const symbol of held.symbols) {
-            if (matchRef(pattern, symbol.ref)) {
-                add(symbol.id, kind, pattern);
-                matched = true;
-            }
-        }
-        if (!matched) {
-            unmatched.push(pattern);
-        }
-    }
-    return unmatched;
-}
-/**
- * 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)));
-}