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

package/dist/src/inventory.js

@@ -1,683 +1,123 @@
-import { isArrayBindingPattern, isBindingElement, isClassDeclaration, isComputedPropertyName, isConstructorDeclaration, isEnumDeclaration, isEnumMember, isExportAssignment, isExportDeclaration, isFunctionDeclaration, isGetAccessorDeclaration, isIdentifier, isInterfaceDeclaration, isIntersectionTypeNode, isMethodDeclaration, isMethodSignatureDeclaration, isModuleBlock, isModuleDeclaration, isNamespaceExport, isObjectBindingPattern, isParameterDeclaration, isParenthesizedTypeNode, isPrivateIdentifier, isPropertyDeclaration, isPropertySignatureDeclaration, isSetAccessorDeclaration, isStringLiteral, isTypeAliasDeclaration, isTypeLiteralNode, isUnionTypeNode, isVariableStatement, ModifierFlags, } from "@typescript/native/ast";
-import { dirnamePath, joinPath, relativePath } from "./paths.js";
-import { byPosition, positionKey, renderPosition, writtenLength, } from "./position.js";
-import { computedComponent, nameComponent, renderRef } from "./ref.js";
-import { isAnswered, UNANSWERED } from "./query.js";
-import { manifestAt } from "./fs/manifest.js";
+import { isClassDeclaration, isComputedPropertyName, isConstructorDeclaration, isEnumMember, isFunctionDeclaration, isGetAccessorDeclaration, isIdentifier, isInterfaceDeclaration, isMethodDeclaration, isMethodSignatureDeclaration, isParameterDeclaration, isPrivateIdentifier, isPropertyDeclaration, isPropertySignatureDeclaration, isSetAccessorDeclaration, isTypeAliasDeclaration, ModifierFlags, SyntaxKind, } from "@typescript/native/ast";
+import { byPosition, positionKey, renderPosition, startLine } from "./position.js";
+import { renderRef, spell } from "./ref.js";
+import { signatureOf } from "./signatures.js";
 /**
- * Resolves each file's package scope: the name of the nearest manifest at or above
- * its directory up to the target root, and the file's path below that manifest.
- * Where no manifest up to the root carries a name, the package is a single dot and
- * the path is read from the root, which cannot collide, because a package name never
- * starts with a dot.
- *
- * One directory is read at most once, because a package holds many files and a
- * manifest read is a filesystem call.
- */
-export function packageScope(host, root) {
-    const named = new Map();
-    const manifestName = (dir) => {
-        const name = manifestAt(host, joinPath(root, dir))?.["name"];
-        return typeof name === "string" && name !== "" ? name : undefined;
-    };
-    const nearest = (dir) => {
-        if (named.has(dir)) {
-            return named.get(dir);
-        }
-        const name = manifestName(dir);
-        const found = name !== undefined ? { name, at: dir } : dir === "" ? undefined : nearest(parentOf(dir));
-        named.set(dir, found);
-        return found;
-    };
-    return (path) => {
-        const found = nearest(parentOf(path));
-        if (found === undefined) {
-            return { package: ".", path };
-        }
-        return { package: found.name, path: found.at === "" ? path : path.slice(found.at.length + 1) };
-    };
-}
-/** The directory one path below the root sits in, and the root itself as the empty path. */
-function parentOf(path) {
-    const dir = dirnamePath(path);
-    return dir === "." ? "" : dir;
-}
-/** The modifier flags one node carries, and zero for a node that carries none. */
-function modifiersOf(node) {
-    return node.modifierFlags ?? 0;
-}
-/** Whether a declaration is ambient: in a declaration file, or under a `declare` modifier. */
-function isAmbient(file, node) {
-    if (file.isDeclarationFile) {
-        return true;
-    }
-    for (let at = node; at !== undefined; at = at.parent) {
-        if ((modifiersOf(at) & ModifierFlags.Ambient) !== 0) {
-            return true;
-        }
-    }
-    return false;
-}
-/** The type parameters one node declares, and none for a node that declares none. */
-function typeParametersOf(node) {
-    if (isFunctionDeclaration(node) ||
-        isMethodDeclaration(node) ||
-        isMethodSignatureDeclaration(node) ||
-        isClassDeclaration(node) ||
-        isInterfaceDeclaration(node) ||
-        isTypeAliasDeclaration(node)) {
-        return node.typeParameters ?? [];
-    }
-    return [];
-}
-/**
- * The reference component one declaration name node spells, and undefined for a
- * name the grammar does not represent: a binding pattern, and a computed key whose
- * source text carries a closing bracket.
- */
-function componentOf(name) {
-    if (name === undefined) {
-        return undefined;
-    }
-    if (isComputedPropertyName(name)) {
-        const text = name.expression.getText();
-        return text.includes("]") ? undefined : { text, computed: true };
-    }
-    if (isIdentifier(name) || isPrivateIdentifier(name)) {
-        return { text: name.getText(), computed: false };
-    }
-    if (isStringOrNumericName(name)) {
-        // A string or numeric key's own text carries its quotes and its numeric
-        // spelling; the reference carries the value, which the component then quotes.
-        return { text: literalTextOf(name), computed: false };
-    }
-    return undefined;
-}
-function isStringOrNumericName(name) {
-    const text = name.getText();
-    return (text.startsWith('"') || text.startsWith("'") || text.startsWith("`") || /^[0-9]/u.test(text));
-}
-/** One member's identity inside its container: its component, and its side of a class. */
-function memberKey(component, isStatic) {
-    return `${component.computed ? "[" : ""}${component.text}${isStatic ? ":static" : ""}`;
-}
-/** The type one node is, through however many parentheses are written around it. */
-function unparenthesizedType(type) {
-    let held = type;
-    while (isParenthesizedTypeNode(held)) {
-        held = held.type;
-    }
-    return held;
-}
-/**
- * The direct constituents of one type. Parentheses are syntax and are not a
- * constituent, so a parenthesized type contributes the constituents it holds: the
- * constituents of `(A | B) & C` are `A`, `B` and `C`. A union or an intersection
- * written without them stays one constituent.
- */
-function constituentsOf(type) {
-    const held = unparenthesizedType(type);
-    if (!isUnionTypeNode(held) && !isIntersectionTypeNode(held)) {
-        return [held];
-    }
-    return held.types.flatMap((member) => isParenthesizedTypeNode(member) ? constituentsOf(member) : [member]);
-}
-/**
- * The members one type alias declares: the members of the object type it writes, and
- * of every object type that is a direct constituent of a union or an intersection it
- * writes. A constituent naming another type declares nothing here, because that
- * declaration carries its own members.
- *
- * A name two constituents both declare is left out of all of them. The alias stands
- * for such a member, because the two declarations are one member of the type and
- * neither of them is the one a reference to it would name.
- */
-function aliasMembers(type) {
-    const literals = constituentsOf(type).filter(isTypeLiteralNode);
-    if (literals.length < 2) {
-        return literals[0]?.members ?? [];
-    }
-    const declaring = new Map();
-    for (const literal of literals) {
-        for (const key of new Set(literal.members.map(keyOf))) {
-            if (key !== undefined) {
-                declaring.set(key, (declaring.get(key) ?? 0) + 1);
-            }
-        }
-    }
-    return literals.flatMap((literal) => literal.members.filter((member) => {
-        const key = keyOf(member);
-        return key !== undefined && declaring.get(key) === 1;
-    }));
-}
-/** One type member's identity, and undefined for a member the grammar cannot name. */
-function keyOf(member) {
-    const component = componentOf(nameNodeOf(member));
-    return component === undefined ? undefined : memberKey(component, false);
-}
-/** The value one string or numeric key denotes, which is what the reference names. */
-function literalTextOf(name) {
-    const text = name.getText();
-    if (text.startsWith('"') || text.startsWith("'") || text.startsWith("`")) {
-        return text.slice(1, -1);
-    }
-    return text;
-}
-/**
- * The component one declaration's reference carries, and its declared name where the
- * two differ.
- *
- * A declaration its module exports as the default is named `default`, because that is
- * its export name and a module has at most one, so the spelling is unambiguous and it
- * holds for an anonymous declaration too. Its declared name is a fact about the source
- * rather than about the export, so it travels beside the component as the display name.
- */
-function exportedAs(node, name) {
-    const declared = componentOf(name);
-    if ((modifiersOf(node) & ModifierFlags.Default) === 0) {
-        return { component: declared, localName: undefined };
-    }
-    return { component: { text: "default", computed: false }, localName: declared?.text };
-}
-/** The visibility one member declaration's modifiers and name give it. */
-function visibilityOf(node, name) {
-    if (name !== undefined && isPrivateIdentifier(name)) {
-        return "private-name";
-    }
-    const flags = modifiersOf(node);
-    if ((flags & ModifierFlags.Private) !== 0) {
-        return "private";
-    }
-    if ((flags & ModifierFlags.Protected) !== 0) {
-        return "protected";
-    }
-    return "public";
-}
-/**
- * The binding elements of a destructuring declaration that each declare a name of their
- * own, at any depth, but one with a default, whose removal skips the default's
- * evaluation, and one beside a rest element of its object pattern, whose removal
- * changes what the rest holds.
- */
-function patternElements(name) {
-    if (!isObjectBindingPattern(name) && !isArrayBindingPattern(name)) {
-        return [];
-    }
-    const rest = isObjectBindingPattern(name) &&
-        name.elements.some((element) => element.dotDotDotToken !== undefined);
-    return name.elements.flatMap((element) => {
-        if (!isBindingElement(element) ||
-            element.initializer !== undefined ||
-            (rest && element.dotDotDotToken === undefined)) {
-            return [];
-        }
-        const bound = element.name;
-        if (bound === undefined) {
-            return [];
-        }
-        return isIdentifier(bound) ? [{ element, name: bound }] : patternElements(bound);
-    });
-}
-/** The name node of one declaration, for the kinds that carry one. */
-function nameNodeOf(node) {
-    return node.name;
-}
-/**
- * The fragment component one declaration's name spells in a reference, as the inventory
- * spells it, or undefined for a name the grammar does not represent.
- */
-export function declaredComponent(node) {
-    const component = componentOf(nameNodeOf(node));
-    if (component === undefined) {
-        return undefined;
-    }
-    return component.computed ? computedComponent(component.text) : nameComponent(component.text);
-}
-/**
- * One node's identity inside one program, which is how two readings of that program
- * name one declaration.
- *
- * The two mechanisms behind the member set resolve a member separately and meet here;
- * so does the reference pass, which starts from a resolved symbol's declaration and
- * needs the declaration this enumeration made for it.
+ * One node's identity inside one program, which is how two readings of that program name
+ * one declaration: the binder's table and the tree meet here, and so does the reference
+ * pass, which starts from a resolved symbol's declaration.
  */
 export function nodeKey(file, node) {
     return `${file.fileName}:${String(node.pos)}:${String(node.end)}:${String(node.kind)}`;
 }
-/** Whether `node` is written inside `declaration`, compared by file and range. */
-function writtenInside(declaration, node) {
-    return (node.getSourceFile().fileName === declaration.getSourceFile().fileName &&
-        declaration.pos <= node.pos &&
-        node.end <= declaration.end);
-}
-/** `export default`, up to the keyword that stands where an unnamed default export's name would. */
-const DEFAULT_EXPORT = /^export\s+(?=default\b)/u;
-/**
- * Where an unnamed declaration is placed: at `default` when it is the default export, so it
- * never shares the file's own position, else at its first token.
- */
-function unnamedStart(node) {
-    const start = node.getStart();
-    const prefix = DEFAULT_EXPORT.exec(node.getText());
-    return prefix === null ? start : start + prefix[0].length;
-}
 /**
  * Whether one node is a parameter property: a constructor parameter carrying an
- * accessibility, `readonly` or `override` modifier, which also declares an instance
- * member of the class, with the parameter's node as the member's declaration.
+ * accessibility, `readonly` or `override` modifier, which also declares an instance member
+ * of the class, with the parameter's node as the member's declaration.
  */
 export function isParameterProperty(node) {
     return (isParameterDeclaration(node) &&
         isConstructorDeclaration(node.parent) &&
         (modifiersOf(node) & ModifierFlags.ParameterPropertyModifier) !== 0);
 }
-/** The parameter properties every constructor of one class declares. */
-function parameterPropertiesOf(node) {
-    return node.members.flatMap((member) => isConstructorDeclaration(member) ? member.parameters.filter(isParameterProperty) : []);
-}
-/** The kind a class element takes: a method, or a property or accessor. */
-function classMemberKind(node) {
-    return isMethodDeclaration(node) ? "method" : "class-member";
-}
-/** The kind a type element takes: a method of an interface, or any other member. */
-function typeMemberKind(node, inInterface) {
-    return inInterface && isMethodSignatureDeclaration(node) ? "interface-method" : "type-member";
+/**
+ * The fragment component one declaration's name spells in a reference, as the inventory
+ * spells it, or undefined for a name the grammar does not represent.
+ */
+export function declaredComponent(node) {
+    const component = componentOf(nameNodeOf(node));
+    return component === undefined ? undefined : spell(component);
 }
 /**
- * Every declaration one project's own files hold.
- *
- * `targetRoot` is the absolute path every position is rendered against; a file the
- * program holds that is not below it ends the enumeration rather than being passed
- * over. `host` is the filesystem the manifests that name each file's package are
- * read through, and nothing else is read from it.
- *
- * The order is by rendered position, so two enumerations of one project return the
- * same list whatever order the program reported its files in.
+ * Collects one project's declarations, from every {@link DeclarationSource} and from the
+ * binder's tables, and renders them. A member is kept once per container, by its
+ * component and its side of a class, whichever mechanism names it first.
  */
-export function inventory(project, host, targetRoot) {
-    const files = project.ownSourceFiles();
-    const ownFiles = new Set(files.map((file) => file.fileName));
-    const moduleOf = packageScope(host, targetRoot);
-    const building = [];
-    const byNode = new Map();
-    const exportScopes = [];
-    const containers = [];
-    const modules = [];
-    const keep = (record) => {
-        building.push(record);
-        byNode.set(nodeKey(record.file, record.node), record);
-        return record;
-    };
-    for (const file of files) {
-        const path = relativePath(targetRoot, file.fileName);
-        if (path === undefined) {
-            // renderPosition states the refusal, with the root it was rendered against.
-            renderPosition(file, targetRoot, 0);
-            continue;
-        }
-        const module = moduleOf(path);
-        const fileRecord = keep({
-            file,
-            node: file,
+export class Builder {
+    #targetRoot;
+    #records = [];
+    #byNode = new Map();
+    #exportScopes = [];
+    #containers = [];
+    #modules = [];
+    #unansweredOwners = new Set();
+    #openTables = new Set();
+    constructor(targetRoot) {
+        this.#targetRoot = targetRoot;
+    }
+    get exportScopes() {
+        return this.#exportScopes;
+    }
+    get containers() {
+        return this.#containers;
+    }
+    /** One file's own record, which is also the export scope of its module. */
+    file(file, module, path) {
+        const record = this.#keep(file, file, 0, {
             module,
-            position: renderPosition(file, targetRoot, 0),
-            endLine: renderPosition(file, targetRoot, Math.max(file.end - 1, 0)).line,
             kind: "file",
             parentChain: [],
-            // A file's reference names its module, so no component of it is ever spelled;
-            // the path is what a text line renders for it.
+            // A file's reference names its module, so no component of it is ever spelled; the
+            // path is what a text line renders for it.
             component: { text: path, computed: false },
             localName: path,
             parent: undefined,
-            visibility: "public",
-            static: false,
-            exported: false,
-            typeParameter: undefined,
         });
-        exportScopes.push({ owner: fileRecord, nameNode: file });
-        // A statement a component file's module appends is not written in the file.
-        const written = writtenLength(file);
-        walkStatements(file.statements.filter((statement) => statement.end <= written), fileRecord);
-    }
-    /** One declaration of a module, a namespace or a container body. */
-    function walkStatements(statements, owner) {
-        for (const statement of statements) {
-            walkStatement(statement, owner);
-        }
+        this.#exportScopes.push({ owner: record, nameNode: file });
+        return record;
     }
-    function declare(node, owner, kind, name, named) {
-        const record = keep({
-            file: owner.file,
-            node,
+    /** One declaration written under `owner`, placed at its name, and its type parameters. */
+    declare(node, owner, kind, name, named) {
+        const record = this.#keep(owner.file, node, name?.getStart() ?? unnamedStart(node), {
             module: owner.module,
-            position: renderPosition(owner.file, targetRoot, name?.getStart() ?? unnamedStart(node)),
-            endLine: renderPosition(owner.file, targetRoot, Math.max(node.end - 1, 0)).line,
             kind,
             parentChain: owner.kind === "file" ? [] : chainOf(owner),
-            component: named.component,
-            localName: named.localName,
+            ...named,
             parent: owner,
             visibility: visibilityOf(node, name),
             static: (modifiersOf(node) & ModifierFlags.Static) !== 0,
-            exported: false,
-            typeParameter: undefined,
         });
-        declareTypeParameters(node, record);
+        this.#declareTypeParameters(node, record);
         return record;
     }
-    function declareTypeParameters(node, owner) {
-        for (const parameter of typeParametersOf(node)) {
-            const name = nameNodeOf(parameter);
-            if (name === undefined) {
-                continue;
-            }
-            keep({
-                file: owner.file,
-                node: parameter,
-                module: owner.module,
-                position: renderPosition(owner.file, targetRoot, name.getStart()),
-                endLine: renderPosition(owner.file, targetRoot, Math.max(parameter.end - 1, 0)).line,
-                kind: "type-parameter",
-                parentChain: owner.parentChain,
-                component: owner.component,
-                localName: undefined,
-                parent: owner,
-                visibility: "public",
-                static: owner.static,
-                exported: false,
-                typeParameter: name.getText(),
-            });
-        }
-    }
-    function walkStatement(node, owner) {
-        if (isFunctionDeclaration(node)) {
-            const named = exportedAs(node, node.name);
-            if (named.component !== undefined) {
-                declare(node, owner, "function", node.name, { ...named, component: named.component });
-            }
-            return;
-        }
-        if (isClassDeclaration(node)) {
-            const named = exportedAs(node, node.name);
-            if (named.component === undefined) {
-                return;
-            }
-            const record = declare(node, owner, "class", node.name, {
-                ...named,
-                component: named.component,
-            });
-            containers.push({
-                owner: record,
-                declaration: node,
-                nameNode: node.name,
-                members: [...node.members, ...parameterPropertiesOf(node)],
-                memberKind: "class-member",
-                isClass: true,
-                membersAreExports: false,
-            });
-            return;
-        }
-        if (isInterfaceDeclaration(node)) {
-            const named = exportedAs(node, node.name);
-            if (named.component === undefined) {
-                return;
-            }
-            const record = declare(node, owner, "interface", node.name, {
-                ...named,
-                component: named.component,
-            });
-            containers.push({
-                owner: record,
-                declaration: node,
-                nameNode: node.name,
-                members: node.members,
-                memberKind: "interface-method",
-                isClass: false,
-                membersAreExports: false,
-            });
-            return;
-        }
-        if (isTypeAliasDeclaration(node)) {
-            const named = exportedAs(node, node.name);
-            if (named.component === undefined) {
-                return;
-            }
-            const record = declare(node, owner, "type", node.name, {
-                ...named,
-                component: named.component,
-            });
-            // A type alias keeps no member table of its own: the members belong to the
-            // object types its declaration writes, so the declaration is what carries them.
-            const members = aliasMembers(node.type);
-            if (members.length > 0) {
-                containers.push({
-                    owner: record,
-                    declaration: node,
-                    nameNode: undefined,
-                    members,
-                    memberKind: "type-member",
-                    isClass: false,
-                    membersAreExports: false,
-                });
-            }
-            return;
-        }
-        if (isEnumDeclaration(node)) {
-            const named = exportedAs(node, node.name);
-            if (named.component === undefined) {
-                return;
-            }
-            const record = declare(node, owner, "enum", node.name, {
-                ...named,
-                component: named.component,
-            });
-            containers.push({
-                owner: record,
-                declaration: node,
-                nameNode: node.name,
-                members: node.members,
-                memberKind: "enum-member",
-                isClass: false,
-                membersAreExports: true,
-            });
+    /** A container of members; a class's constructors are where its parts are bound. */
+    container(container) {
+        this.#containers.push(container);
+        if (container.memberKind !== "class-member") {
             return;
         }
-        if (isModuleDeclaration(node)) {
-            const component = componentOf(node.name);
-            if (component === undefined) {
-                return;
-            }
-            const record = declare(node, owner, "namespace", node.name, {
-                component,
-                localName: undefined,
-            });
-            exportScopes.push({ owner: record, nameNode: node.name });
-            if (isStringLiteral(node.name)) {
-                modules.push([record, node.name.text]);
-            }
-            const body = node.body;
-            if (body === undefined) {
-                return;
+        for (const member of container.members.filter(isConstructorDeclaration)) {
+            for (const at of [member, ...member.parameters.filter((one) => !isParameterProperty(one))]) {
+                container.owner.partLines.add(startLine(container.owner.file, at.pos));
             }
-            if (isModuleBlock(body)) {
-                walkStatements(body.statements, record);
-                return;
-            }
-            walkStatement(body, record);
-            return;
-        }
-        if (isVariableStatement(node)) {
-            for (const declaration of node.declarationList.declarations) {
-                const component = componentOf(declaration.name);
-                if (component !== undefined) {
-                    declare(declaration, owner, "variable", declaration.name, {
-                        component,
-                        localName: undefined,
-                    });
-                    continue;
-                }
-                for (const { element, name } of patternElements(declaration.name)) {
-                    declare(element, owner, "variable", name, {
-                        component: { text: name.text, computed: false },
-                        localName: undefined,
-                    });
-                }
-            }
-            return;
-        }
-        if (isExportDeclaration(node)) {
-            walkExportDeclaration(node, owner);
-            return;
-        }
-        if (isExportAssignment(node) && !node.isExportEquals) {
-            declare(node, owner, "export-alias", undefined, {
-                component: { text: "default", computed: false },
-                localName: undefined,
-            });
         }
     }
-    function walkExportDeclaration(node, owner) {
-        const clause = node.exportClause;
-        // A bare star re-export declares nothing: the names it carries are the named module's.
-        if (clause === undefined) {
-            return;
-        }
-        if (isNamespaceExport(clause)) {
-            const component = componentOf(clause.name);
-            if (component !== undefined) {
-                declare(clause, owner, "export-alias", clause.name, { component, localName: undefined });
-            }
-            return;
-        }
-        for (const element of clause.elements ?? []) {
-            const name = nameNodeOf(element);
-            const component = componentOf(name);
-            if (component !== undefined) {
-                declare(element, owner, "export-alias", name, { component, localName: undefined });
-            }
-        }
+    /** A namespace whose export table says which of its declarations it exports. */
+    exportScope(owner, nameNode) {
+        this.#exportScopes.push({ owner, nameNode });
     }
-    // One batch for every module and every container the walk found, because a
-    // checker accessor with an array overload costs one round trip for the batch and
-    // one per node without it.
-    const batched = [
-        ...exportScopes.map((scope) => scope.nameNode),
-        ...containers.map((container) => container.nameNode).filter((node) => node !== undefined),
-    ];
-    const handles = batched.map((node) => project.handle(node));
-    const resolved = project.symbolsAt(handles);
-    const symbolOf = new Map();
-    // A scope or a container whose symbol or table went unanswered keeps what its syntax
-    // declares, and everything under it is recorded unanswered.
-    const unansweredOwners = new Set();
-    batched.forEach((node, index) => {
-        const symbol = resolved[index];
-        if (typeof symbol === "object") {
-            symbolOf.set(node, symbol);
-        }
-    });
-    resolved.slice(0, exportScopes.length).forEach((symbol, index) => {
-        const scope = exportScopes[index];
-        if (symbol === UNANSWERED && scope !== undefined) {
-            unansweredOwners.add(scope.owner);
-        }
-    });
-    containers
-        .filter((container) => container.nameNode !== undefined)
-        .forEach((container, index) => {
-        if (resolved[exportScopes.length + index] === UNANSWERED) {
-            unansweredOwners.add(container.owner);
-        }
-    });
-    let exportTables = 0;
-    for (const scope of exportScopes) {
-        const symbol = symbolOf.get(scope.nameNode);
-        if (symbol === undefined) {
-            continue;
-        }
-        exportTables += 1;
-        const table = project.queries.exportsOf(symbol);
-        if (!isAnswered(table)) {
-            unansweredOwners.add(scope.owner);
-        }
-        for (const [, exported] of isAnswered(table) ? table : []) {
-            for (const declaration of exported.declarations) {
-                const held = project.declarationAt(declaration);
-                if (held === undefined) {
-                    continue;
-                }
-                const record = byNode.get(nodeKey(held.node.getSourceFile(), held.node));
-                if (record === undefined) {
-                    continue;
-                }
-                record.exported = true;
-            }
-        }
+    /** A `declare module` declaration named by a string literal. */
+    module(record, name) {
+        this.#modules.push([record, name]);
     }
-    let memberTables = 0;
-    for (const container of containers) {
-        const symbol = container.nameNode === undefined ? undefined : symbolOf.get(container.nameNode);
-        const seen = new Map();
-        if (symbol !== undefined) {
-            if (!container.membersAreExports) {
-                memberTables += 1;
-                const table = project.queries.membersOf(symbol);
-                if (isAnswered(table)) {
-                    readTable(container, table, seen, false);
-                }
-                else {
-                    unansweredOwners.add(container.owner);
-                }
-            }
-            if (container.membersAreExports || container.isClass) {
-                memberTables += 1;
-                const table = project.queries.exportsOf(symbol);
-                if (isAnswered(table)) {
-                    readTable(container, table, seen, container.isClass);
-                }
-                else {
-                    unansweredOwners.add(container.owner);
-                }
-            }
-        }
-        completeFromTree(container, seen);
+    /** The declaration enumerated at one node, where one is. */
+    recordAt(node) {
+        return this.#byNode.get(nodeKey(node.getSourceFile(), node));
     }
-    /**
-     * One container's members as its symbol table holds them, each positioned at the
-     * declaration the table names. A member with no declaration is the language's own
-     * (a class's `prototype`), and a member declared outside the target's own files
-     * belongs to another program; neither is a declaration of the target.
-     */
-    function readTable(container, table, seen, areStatic) {
-        for (const [, member] of table) {
-            const declarations = member.declarations
-                .map((handle) => project.declarationAt(handle))
-                .filter((held) => held !== undefined);
-            if (declarations.length === 0) {
-                continue;
-            }
-            const own = declarations.filter((held) => ownFiles.has(held.node.getSourceFile().fileName));
-            if (own.length === 0) {
-                continue;
-            }
-            // A merged symbol's table holds the members every one of its declarations writes,
-            // and each member is kept once, by the declaration that writes it.
-            for (const held of own.filter((one) => writtenInside(container.declaration, one.node))) {
-                keepMember(container, held.node, seen, areStatic);
-            }
-        }
+    /** Records that a table of `owner` is unknown, which leaves everything under it unknown. */
+    unanswered(owner) {
+        this.#unansweredOwners.add(owner);
+    }
+    /** Records that one file writes its exports in a form its table does not model. */
+    openTable(file) {
+        this.#openTables.add(file);
     }
     /**
-     * One container's members as its own declaration writes them, for the members its
-     * symbol table does not hold: a member whose key is computed is bound to the
-     * container's type later than the table is built.
+     * One member of a container. A getter and a setter of one name are one symbol and one
+     * reference, so the second declaration widens the first record rather than making a
+     * second, and both nodes name that record.
      */
-    function completeFromTree(container, seen) {
-        for (const member of container.members) {
-            keepMember(container, member, seen, (modifiersOf(member) & ModifierFlags.Static) !== 0);
-        }
-    }
-    function keepMember(container, node, seen, areStatic) {
+    member(container, node, seen, areStatic) {
         const kind = memberKindOf(container, node);
         if (kind === undefined) {
             return;
@@ -690,61 +130,234 @@ export function inventory(project, host, targetRoot) {
         const file = node.getSourceFile();
         const key = memberKey(component, areStatic);
         const held = seen.get(key);
-        const endLine = renderPosition(file, targetRoot, Math.max(node.end - 1, 0)).line;
+        const endLine = this.#endOf(file, node);
         if (held !== undefined) {
-            // A getter and a setter of one name are one symbol and one reference, so the
-            // second declaration widens the first record rather than making a second. Both
-            // nodes name that record, so a reading that starts from either one finds it.
             held.endLine = Math.max(held.endLine, endLine);
-            byNode.set(nodeKey(file, node), held);
+            this.#byNode.set(nodeKey(file, node), held);
+            placeAt(held, node);
             return;
         }
-        const at = name ?? node;
-        const record = keep({
-            file,
-            node,
+        const record = this.#keep(file, node, (name ?? node).getStart(), {
             module: container.owner.module,
-            position: renderPosition(file, targetRoot, at.getStart()),
-            endLine,
             kind,
             parentChain: chainOf(container.owner),
             component,
-            localName: undefined,
             parent: container.owner,
             visibility: visibilityOf(node, name),
             static: areStatic,
-            exported: false,
-            typeParameter: undefined,
+            holder: isParameterProperty(node) ? container.owner : undefined,
         });
         seen.set(key, record);
-        declareTypeParameters(node, record);
-    }
-    function memberKindOf(container, node) {
-        if (container.isClass) {
-            if (isPropertyDeclaration(node) ||
-                isMethodDeclaration(node) ||
-                isGetAccessorDeclaration(node) ||
-                isSetAccessorDeclaration(node) ||
-                isParameterProperty(node)) {
-                return classMemberKind(node);
+        this.#declareTypeParameters(node, record);
+    }
+    /** The inventory of everything collected. */
+    build(cost) {
+        const byId = new Map(this.#records.map((record) => [positionKey(record.position), record]));
+        const symbols = this.#records.map(render).sort((a, b) => byPosition(a.position, b.position));
+        return {
+            symbols,
+            declarations: new Map([...this.#byNode].map(([key, record]) => [key, positionKey(record.position)])),
+            cost,
+            unanswered: symbols
+                .filter((symbol) => underUnanswered(byId.get(symbol.id), this.#unansweredOwners))
+                .map((symbol) => symbol.id),
+            byName: namesOf(this.#records),
+            modules: new Map(this.#modules.map(([record, name]) => [positionKey(record.position), name])),
+            ambient: new Set(this.#records
+                .filter((record) => isAmbient(record.file, record.node))
+                .map((record) => positionKey(record.position))),
+            dependents: dependentsOf(this.#containers, (node) => this.recordAt(node)),
+            placement: placementOf(this.#records),
+            openTables: new Set([...this.#openTables].map((file) => positionKey(file.position))),
+        };
+    }
+    #keep(file, node, at, fields) {
+        const kept = {
+            file,
+            node,
+            position: renderPosition(file, this.#targetRoot, at),
+            endLine: this.#endOf(file, node),
+            localName: undefined,
+            visibility: "public",
+            static: false,
+            exported: false,
+            typeParameter: undefined,
+            holder: undefined,
+            ...fields,
+            startLines: new Set(),
+            partLines: new Set(),
+        };
+        this.#records.push(kept);
+        this.#byNode.set(nodeKey(kept.file, kept.node), kept);
+        if (kept.kind !== "file") {
+            placeAt(kept, kept.node);
+        }
+        return kept;
+    }
+    #declareTypeParameters(node, owner) {
+        for (const parameter of typeParametersOf(node)) {
+            const name = nameNodeOf(parameter);
+            if (name === undefined) {
+                continue;
             }
-            return undefined;
-        }
-        if (container.memberKind === "enum-member") {
-            return isEnumMember(node) ? "enum-member" : undefined;
+            this.#keep(owner.file, parameter, name.getStart(), {
+                module: owner.module,
+                kind: "type-parameter",
+                parentChain: owner.parentChain,
+                component: owner.component,
+                parent: owner,
+                static: owner.static,
+                typeParameter: name.getText(),
+            });
         }
-        if (isPropertySignatureDeclaration(node) || isMethodSignatureDeclaration(node)) {
-            return typeMemberKind(node, container.memberKind === "interface-method");
+    }
+    #endOf(file, node) {
+        return renderPosition(file, this.#targetRoot, Math.max(node.end - 1, 0)).line;
+    }
+}
+/** The lines one declaring node binds its declaration on. */
+function placeAt(record, node) {
+    const file = record.file;
+    record.startLines.add(startLine(file, node.pos));
+    for (const parameter of signatureOf(node)?.parameters ?? []) {
+        record.startLines.add(startLine(file, parameter.pos));
+    }
+    const list = node.parent;
+    if (node.kind === SyntaxKind.VariableDeclaration &&
+        list?.kind === SyntaxKind.VariableDeclarationList &&
+        list.parent.kind === SyntaxKind.VariableStatement) {
+        record.startLines.add(startLine(file, list.parent.pos));
+    }
+}
+/** The modifier flags one node carries, and zero for a node that carries none. */
+export function modifiersOf(node) {
+    return node.modifierFlags ?? 0;
+}
+/** The name node of one declaration, for the kinds that carry one. */
+export function nameNodeOf(node) {
+    return node.name;
+}
+/**
+ * The reference component one declaration name node spells, and undefined for a name the
+ * grammar does not represent: a binding pattern, and a computed key whose source text
+ * carries a closing bracket.
+ */
+export function componentOf(name) {
+    if (name === undefined) {
+        return undefined;
+    }
+    if (isComputedPropertyName(name)) {
+        const text = name.expression.getText();
+        return text.includes("]") ? undefined : { text, computed: true };
+    }
+    if (isIdentifier(name) || isPrivateIdentifier(name)) {
+        return { text: name.getText(), computed: false };
+    }
+    const text = name.getText();
+    if (text.startsWith('"') || text.startsWith("'") || text.startsWith("`")) {
+        // A string key's own text carries its quotes; the reference carries the value.
+        return { text: text.slice(1, -1), computed: false };
+    }
+    return /^[0-9]/u.test(text) ? { text, computed: false } : undefined;
+}
+/**
+ * The component one declaration's reference carries, and its declared name where the two
+ * differ. A declaration its module exports as the default is named `default`, its export
+ * name, which a module has at most one of and an anonymous declaration has too.
+ */
+export function exportedAs(node, name) {
+    const declared = componentOf(name);
+    if ((modifiersOf(node) & ModifierFlags.Default) === 0) {
+        return { component: declared, localName: undefined };
+    }
+    return { component: { text: "default", computed: false }, localName: declared?.text };
+}
+/** One member's identity inside its container: its component, and its side of a class. */
+export function memberKey(component, isStatic) {
+    return `${component.computed ? "[" : ""}${component.text}${isStatic ? ":static" : ""}`;
+}
+/** The visibility one member declaration's modifiers and name give it. */
+function visibilityOf(node, name) {
+    if (name !== undefined && isPrivateIdentifier(name)) {
+        return "private-name";
+    }
+    const flags = modifiersOf(node);
+    if ((flags & ModifierFlags.Private) !== 0) {
+        return "private";
+    }
+    if ((flags & ModifierFlags.Protected) !== 0) {
+        return "protected";
+    }
+    return "public";
+}
+/** Whether a declaration is ambient: in a declaration file, or under a `declare` modifier. */
+export function isAmbient(file, node) {
+    if (file.isDeclarationFile) {
+        return true;
+    }
+    for (let at = node; at !== undefined; at = at.parent) {
+        if ((modifiersOf(at) & ModifierFlags.Ambient) !== 0) {
+            return true;
         }
-        if (isGetAccessorDeclaration(node) || isSetAccessorDeclaration(node)) {
-            return "type-member";
+    }
+    return false;
+}
+/** The type parameters one node declares, and none for a node that declares none. */
+function typeParametersOf(node) {
+    if (isFunctionDeclaration(node) ||
+        isMethodDeclaration(node) ||
+        isMethodSignatureDeclaration(node) ||
+        isClassDeclaration(node) ||
+        isInterfaceDeclaration(node) ||
+        isTypeAliasDeclaration(node)) {
+        return node.typeParameters ?? [];
+    }
+    return [];
+}
+/** `export default`, up to the keyword that stands where an unnamed default export's name would. */
+const DEFAULT_EXPORT = /^export\s+(?=default\b)/u;
+/**
+ * Where an unnamed declaration is placed: at `default` when it is the default export, so it
+ * never shares the file's own position, else at its first token.
+ */
+function unnamedStart(node) {
+    const start = node.getStart();
+    const prefix = DEFAULT_EXPORT.exec(node.getText());
+    return prefix === null ? start : start + prefix[0].length;
+}
+/** The kind one member of a container takes, and undefined for a node that is no member. */
+function memberKindOf(container, node) {
+    if (container.memberKind === "class-member") {
+        if (isPropertyDeclaration(node) ||
+            isGetAccessorDeclaration(node) ||
+            isSetAccessorDeclaration(node) ||
+            isParameterProperty(node)) {
+            return "class-member";
         }
-        return undefined;
+        return isMethodDeclaration(node) ? "method" : undefined;
+    }
+    if (container.memberKind === "enum-member") {
+        return isEnumMember(node) ? "enum-member" : undefined;
     }
+    if (isMethodSignatureDeclaration(node)) {
+        return container.memberKind === "interface-method" ? "interface-method" : "type-member";
+    }
+    if (isPropertySignatureDeclaration(node) ||
+        isGetAccessorDeclaration(node) ||
+        isSetAccessorDeclaration(node)) {
+        return "type-member";
+    }
+    return undefined;
+}
+/**
+ * Each enum member's dependents: the later members of its declaration with no initializer,
+ * up to the first one with an initializer.
+ */
+function dependentsOf(containers, recordAt) {
     const dependents = new Map();
     for (const container of containers.filter((one) => one.memberKind === "enum-member")) {
         const ids = container.members.map((member) => {
-            const record = byNode.get(nodeKey(member.getSourceFile(), member));
+            const record = recordAt(member);
             return record === undefined ? undefined : positionKey(record.position);
         });
         container.members.forEach((_member, index) => {
@@ -765,22 +378,21 @@ export function inventory(project, host, targetRoot) {
             }
         });
     }
-    const byId = new Map(building.map((record) => [positionKey(record.position), record]));
-    const symbols = building.map(render).sort((a, b) => byPosition(a.position, b.position));
-    return {
-        symbols,
-        declarations: new Map([...byNode].map(([key, record]) => [key, positionKey(record.position)])),
-        cost: { batches: 1, exportTables, memberTables },
-        unanswered: symbols
-            .filter((symbol) => underUnanswered(byId.get(symbol.id), unansweredOwners))
-            .map((symbol) => symbol.id),
-        byName: namesOf(building),
-        modules: new Map(modules.map(([record, name]) => [positionKey(record.position), name])),
-        ambient: new Set(building
-            .filter((record) => isAmbient(record.file, record.node))
-            .map((record) => positionKey(record.position))),
-        dependents,
-    };
+    return dependents;
+}
+/** Each declaration but a file to where a directive binds it. */
+function placementOf(records) {
+    const ascending = (lines) => [...lines].sort((a, b) => a - b);
+    return new Map(records
+        .filter((record) => record.kind !== "file")
+        .map((record) => [
+        positionKey(record.position),
+        {
+            startLines: ascending(record.startLines),
+            holder: positionKey((record.holder ?? record).position),
+            partLines: ascending(record.partLines),
+        },
+    ]));
 }
 /** Whether one declaration is, or is declared under, a scope or container left unanswered. */
 function underUnanswered(record, owners) {
@@ -792,9 +404,9 @@ function underUnanswered(record, owners) {
     return false;
 }
 /** Every declaration but a file, by each name a use may spell it with. */
-function namesOf(building) {
+function namesOf(records) {
     const byName = new Map();
-    for (const record of building) {
+    for (const record of records) {
         if (record.kind === "file") {
             continue;
         }
@@ -823,21 +435,17 @@ function chainOf(record) {
 }
 /**
  * One declaration as the inventory reports it. The display name is the chain in the
- * spelling a reference gives it, except where the declaration carries a name of its
- * own the reference does not: a file, whose reference names its module, and a default
- * export, whose reference carries its export name.
+ * spelling a reference gives it, except where the declaration carries a name of its own
+ * the reference does not: a file, whose reference names its module, and a default export.
  */
 function render(record) {
     const chain = chainOf(record);
-    const spelled = chain
-        .map((component) => component.computed ? computedComponent(component.text) : nameComponent(component.text))
-        .join(".");
-    const name = record.localName ??
-        (record.typeParameter === undefined ? spelled : `${spelled}<${record.typeParameter}>`);
+    const spelled = chain.map(spell).join(".");
     return {
         id: positionKey(record.position),
         ref: refOf(record, chain),
-        name,
+        name: record.localName ??
+            (record.typeParameter === undefined ? spelled : `${spelled}<${record.typeParameter}>`),
         kind: record.kind,
         position: record.position,
         endLine: record.endLine,
@@ -866,11 +474,3 @@ function refOf(record, chain) {
         ...(record.typeParameter === undefined ? {} : { typeParameter: record.typeParameter }),
     });
 }
-/**
- * Every declaration of an inventory other than a file, by each name a use may spell it
- * with. It is how a reference the checker could not resolve is still counted, as a
- * reference to every declaration that bears the name it spells.
- */
-export function declarationsByName(held) {
-    return held.byName;
-}