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

package/dist/src/inventory/commonjs.js

@@ -0,0 +1,507 @@
+import { isArrayBindingPattern, isArrowFunction, isAssignmentOperator, isAwaitExpression, isBinaryExpression, isBindingElement, isCallExpression, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isComputedPropertyName, isDeleteExpression, isElementAccessExpression, isEqualityOperator, isExpressionStatement, isForOfStatement, isFunctionDeclaration, isFunctionExpression, isFunctionLikeDeclaration, isGetAccessorDeclaration, isIdentifier, isIfStatement, isMetaProperty, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isSetAccessorDeclaration, isShorthandPropertyAssignment, isSourceFile, isSpreadAssignment, isStringLiteral, isTypeOfExpression, isVariableDeclaration, isVariableDeclarationList, isVariableStatement, ModifierFlags, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
+import { componentOf, modifiersOf, } from "../inventory.js";
+import { callsPlatformBy, lexicalBinding, writtenName } from "../platform-calls.js";
+import { spellsNoBinding } from "../spelled-names.js";
+import { unwrapped } from "../unwrap.js";
+/**
+ * The export table of a CommonJS file: the module value `module.exports` is assigned and
+ * the properties written on it, read from the top-level unconditional statements in order,
+ * as Node runs them (https://nodejs.org/api/modules.html#moduleexports). Each entry is
+ * keyed by the node that writes it, the checker's declaration of the export where it binds
+ * one. Any other write of the exports opens the table: its entries are kept and the file is
+ * listed open. `declarationOf` reads a `require()` call through the file's own scopes.
+ */
+export function commonJS(typeIsModule, resolved, declarationOf) {
+    return {
+        declare(file, owner, into) {
+            if (!isCommonJS(file, owner.position.path, typeIsModule)) {
+                return;
+            }
+            const bound = boundOccurrences(file, resolved);
+            const free = (node) => !bound.has(node);
+            const table = readTable(file, free, topLevelDeclarations(file), lexicalBinding(declarationOf));
+            const open = table.open || opens(file, free, table.modelled);
+            for (const entry of table.entries.values()) {
+                const record = into.declare(entry.node, owner, entry.kind, entry.name, {
+                    component: entry.component,
+                    localName: entry.localName,
+                });
+                record.exported = true;
+                const target = entry.target === undefined ? undefined : into.recordAt(entry.target);
+                if (target !== undefined) {
+                    target.exported = true;
+                }
+                if (entry.members !== undefined) {
+                    into.container({
+                        owner: record,
+                        declaration: entry.members,
+                        nameNode: entry.members.name,
+                        members: entry.members.members,
+                        memberKind: "class-member",
+                    });
+                }
+                // No reference source reads a `require` of the table yet, so whether an entry is
+                // used is unknown, and it is held live and reported by nothing.
+                into.unanswered(record);
+            }
+            if (open) {
+                into.openTable(owner);
+            }
+        },
+    };
+}
+/** The bindings whose free occurrence is the module system's own. */
+const WATCHED = ["module", "exports", "require"];
+/**
+ * Whether Node runs one file as CommonJS: a `.cjs` file, or a `.js` or `.jsx` file outside a
+ * `type: module` package that holds no ECMAScript module syntax
+ * (https://nodejs.org/api/packages.html#determining-module-system).
+ */
+function isCommonJS(file, path, typeIsModule) {
+    if (file.fileName.endsWith(".cjs")) {
+        return true;
+    }
+    return /\.jsx?$/u.test(file.fileName) && !typeIsModule(path) && !writesModuleSyntax(file);
+}
+/** Whether one file holds an import or export declaration, `import.meta` or a top-level `await`. */
+function writesModuleSyntax(file) {
+    const declares = file.statements.some((statement) => (statement.flags & NodeFlags.Reparsed) === 0 &&
+        (statement.kind === SyntaxKind.ImportDeclaration ||
+            statement.kind === SyntaxKind.ExportDeclaration ||
+            statement.kind === SyntaxKind.ExportAssignment ||
+            (modifiersOf(statement) & ModifierFlags.Export) !== 0));
+    let found = declares;
+    const visit = (node, inFunction) => {
+        if (found) {
+            return;
+        }
+        if ((isMetaProperty(node) && node.keywordToken === SyntaxKind.ImportKeyword) ||
+            (!inFunction &&
+                (isAwaitExpression(node) || (isForOfStatement(node) && node.awaitModifier !== undefined)))) {
+            found = true;
+            return;
+        }
+        const inner = inFunction || isFunctionLikeDeclaration(node);
+        node.forEachChild((child) => {
+            visit(child, inner);
+        });
+    };
+    file.forEachChild((child) => {
+        visit(child, false);
+    });
+    return found;
+}
+/**
+ * The occurrences of a watched name that Node binds to a declaration of the file. The
+ * compiler resolves each one, and one it leaves unanswered, or resolves to no such
+ * declaration, is the module system's own.
+ */
+function boundOccurrences(file, resolved) {
+    const occurrences = [];
+    const visit = (node) => {
+        if (isIdentifier(node)) {
+            if (WATCHED.includes(node.text) && !spellsNoBinding(node)) {
+                occurrences.push(node);
+            }
+            return;
+        }
+        node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+    const declarations = resolved(occurrences);
+    const bound = new Set();
+    occurrences.forEach((occurrence, index) => {
+        if (declarations[index]?.some((declaration) => bindsOwn(declaration, file)) === true) {
+            bound.add(occurrence);
+        }
+    });
+    return bound;
+}
+/**
+ * Whether one declaration the compiler resolves a watched name to is a binding Node gives
+ * it in the file. Where the file is the var scope, a `var`, destructured or not, re-declares
+ * a parameter of Node's wrapper, which keeps the module system's value until assigned, and
+ * an `if`-clause function binds only in its clause, as the parameter stops it hoisting; the
+ * compiler gives each its own symbol, so both read as free (Annex B.3.2, B.3.3,
+ * https://tc39.es/ecma262/#sec-functiondeclarationinstantiation).
+ */
+function bindsOwn(declaration, file) {
+    if (isSourceFile(declaration) || declaration.getSourceFile() !== file) {
+        return false;
+    }
+    let named = declaration;
+    while (isBindingElement(named)) {
+        named = named.parent.parent;
+    }
+    const redeclares = (isVariableDeclaration(named) &&
+        isVariableDeclarationList(named.parent) &&
+        (named.parent.flags & NodeFlags.BlockScoped) === 0) ||
+        (isFunctionDeclaration(declaration) && isIfStatement(declaration.parent));
+    return !redeclares || !inFileVarScope(declaration);
+}
+/** Whether no function or class static block encloses one node below its file. */
+function inFileVarScope(node) {
+    for (let at = node.parent; !isSourceFile(at); at = at.parent) {
+        if (isFunctionLikeDeclaration(at) || isClassStaticBlockDeclaration(at)) {
+            return false;
+        }
+    }
+    return true;
+}
+/** The node that declares each name a file's top-level function, class or variable binds. */
+function topLevelDeclarations(file) {
+    const found = new Map();
+    const bind = (name, node) => {
+        if (isIdentifier(name)) {
+            found.set(name.text, node);
+        }
+        else if (isObjectBindingPattern(name) || isArrayBindingPattern(name)) {
+            for (const element of name.elements) {
+                if (isBindingElement(element) && element.name !== undefined) {
+                    bind(element.name, element);
+                }
+            }
+        }
+    };
+    for (const statement of file.statements) {
+        if ((isFunctionDeclaration(statement) || isClassDeclaration(statement)) && statement.name) {
+            found.set(statement.name.text, statement);
+        }
+        else if (isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations) {
+                bind(declaration.name, declaration);
+            }
+        }
+    }
+    return found;
+}
+const DEFAULT = { text: "default", computed: false };
+/** The table one file's top-level unconditional statements write, in order. */
+function readTable(file, isFree, declarations, bindingOf) {
+    const entries = new Map();
+    const modelled = new Set();
+    // Written inside the closures below, which the compiler's narrowing does not follow.
+    let open = false;
+    let aliasing = true;
+    let whole;
+    let wholeOpen = false;
+    const free = (node, name) => isIdentifier(node) && node.text === name && isFree(node);
+    const isModuleExports = (node) => isPropertyAccessExpression(node) &&
+        free(node.expression, "module") &&
+        node.name.text === "exports";
+    const isRequire = (node) => {
+        if (!isCallExpression(node) || node.arguments.length !== 1) {
+            return false;
+        }
+        const [argument] = node.arguments;
+        const callee = writtenName(node.expression);
+        return (argument !== undefined &&
+            isLiteralText(argument) &&
+            callee !== undefined &&
+            callsPlatformBy("require", callee, bindingOf));
+    };
+    /** What a value written under one key declares. */
+    const entryOf = (component, node, name, value) => {
+        const held = value === undefined ? undefined : unwrapped(value);
+        const base = { node, name, component, localName: undefined, value };
+        if (held === undefined) {
+            return { ...base, kind: "variable" };
+        }
+        if ((isIdentifier(held) && declarations.has(held.text)) || isRequire(held)) {
+            return { ...base, kind: "export-alias" };
+        }
+        if (isFunctionExpression(held) || isArrowFunction(held) || isMethodDeclaration(held)) {
+            return { ...base, kind: "function" };
+        }
+        if (isClassExpression(held)) {
+            return { ...base, kind: "class", members: held };
+        }
+        return { ...base, kind: "variable" };
+    };
+    const property = (node, name, value) => {
+        const component = isComputedPropertyName(name) ? undefined : componentOf(name);
+        if (component === undefined) {
+            open = true;
+            return;
+        }
+        if (component.text === "__esModule") {
+            return;
+        }
+        if (component.text === "default" && entries.get("default")?.component === DEFAULT) {
+            // `#default` would name the module value and this property both.
+            open = true;
+            return;
+        }
+        entries.delete(component.text);
+        entries.set(component.text, entryOf(component, node, name, value));
+    };
+    const literalProperty = (element) => {
+        if (isShorthandPropertyAssignment(element)) {
+            property(element, element.name, element.name);
+        }
+        else if (isPropertyAssignment(element)) {
+            property(element, element.name, element.initializer);
+        }
+        else if (isMethodDeclaration(element)) {
+            property(element, element.name, element);
+        }
+        else if (isGetAccessorDeclaration(element) || isSetAccessorDeclaration(element)) {
+            property(element, element.name, undefined);
+        }
+        else if (!isSpreadAssignment(element) || !isRequire(unwrapped(element.expression))) {
+            open = true;
+        }
+    };
+    /** The module value one assignment writes, placed at the `exports` name it assigns. */
+    const moduleValue = (node, name) => {
+        entries.clear();
+        whole = node.right;
+        const value = unwrapped(node.right);
+        if (isRequire(value)) {
+            return;
+        }
+        if (isObjectLiteralExpression(value)) {
+            value.properties.forEach(literalProperty);
+            return;
+        }
+        const base = { node, name, component: DEFAULT, value: node.right };
+        const target = isIdentifier(value) ? declarations.get(value.text) : undefined;
+        if (target !== undefined) {
+            entries.set("default", { ...base, localName: undefined, kind: "export-alias", target });
+        }
+        else if (isFunctionExpression(value)) {
+            entries.set("default", { ...base, localName: value.name?.text, kind: "function" });
+        }
+        else if (isArrowFunction(value)) {
+            entries.set("default", { ...base, localName: undefined, kind: "function" });
+        }
+        else if (isClassExpression(value)) {
+            entries.set("default", {
+                ...base,
+                localName: value.name?.text,
+                kind: "class",
+                members: value,
+            });
+        }
+        else {
+            wholeOpen = true;
+        }
+    };
+    /** Whether one expression is the exports object a top-level write may name here. */
+    const exportsObject = (node) => isModuleExports(node) ? "module" : free(node, "exports") ? "exports" : undefined;
+    for (const statement of file.statements) {
+        if (!isExpressionStatement(statement)) {
+            continue;
+        }
+        const expression = unwrapped(statement.expression);
+        if (isBinaryExpression(expression) &&
+            expression.operatorToken.kind === SyntaxKind.EqualsToken) {
+            const left = expression.left;
+            if (free(left, "exports")) {
+                modelled.add(expression);
+                const inner = unwrapped(expression.right);
+                aliasing = false;
+                if (isBinaryExpression(inner) &&
+                    inner.operatorToken.kind === SyntaxKind.EqualsToken &&
+                    isModuleExports(inner.left)) {
+                    aliasing = true;
+                    modelled.add(inner);
+                    moduleValue(inner, inner.left.name);
+                }
+            }
+            else if (isModuleExports(left)) {
+                modelled.add(expression);
+                const inner = unwrapped(expression.right);
+                const chained = isBinaryExpression(inner) &&
+                    inner.operatorToken.kind === SyntaxKind.EqualsToken &&
+                    free(inner.left, "exports")
+                    ? inner
+                    : undefined;
+                if (chained !== undefined) {
+                    modelled.add(chained);
+                }
+                moduleValue(chained ?? expression, left.name);
+                aliasing = chained !== undefined;
+            }
+            else if (isPropertyAccessExpression(left) || isElementAccessExpression(left)) {
+                const object = exportsObject(left.expression);
+                const key = isPropertyAccessExpression(left) ? left.name : left.argumentExpression;
+                if (object === "exports" && !aliasing) {
+                    // Node discards a write through an `exports` that no longer aliases the module.
+                    modelled.add(expression);
+                }
+                else if (object !== undefined &&
+                    (isPropertyAccessExpression(left) || isLiteralKey(key))) {
+                    modelled.add(expression);
+                    property(expression, key, expression.right);
+                }
+            }
+            continue;
+        }
+        if (isCallExpression(expression) && isDefineProperty(expression.expression)) {
+            const [object, key, descriptor] = expression.arguments;
+            const written = object === undefined ? undefined : exportsObject(object);
+            if (written === "exports" && !aliasing) {
+                modelled.add(expression);
+                continue;
+            }
+            const value = descriptor === undefined ? undefined : describedValue(descriptor);
+            if (written !== undefined && key !== undefined && isLiteralText(key) && value !== undefined) {
+                modelled.add(expression);
+                property(expression, key, value.value);
+            }
+        }
+    }
+    return { entries, open: open || wholeOpen, modelled, whole, membersOpen: open };
+}
+/**
+ * The module value one file leaves where Node runs it as CommonJS, read by the one table
+ * the inventory's export table reads, or undefined where the file writes module syntax.
+ * `declarationOf` names the declaration each name resolves to, undefined for none, as a
+ * lexical reading of a file outside every program answers it.
+ */
+export function commonJSModuleValue(file, declarationOf) {
+    if (writesModuleSyntax(file)) {
+        return undefined;
+    }
+    const free = (node) => {
+        const declaration = isIdentifier(node) ? declarationOf(node) : undefined;
+        return declaration === undefined || !bindsOwn(declaration, file);
+    };
+    const table = readTable(file, free, topLevelDeclarations(file), lexicalBinding(declarationOf));
+    const held = table.whole === undefined ? undefined : unwrapped(table.whole);
+    const members = [...table.entries.values()].flatMap((entry) => entry.component === DEFAULT && held !== undefined && !isObjectLiteralExpression(held)
+        ? []
+        : [{ key: entry.component.text, value: entry.value, node: entry.node }]);
+    return {
+        whole: held === undefined || isObjectLiteralExpression(held) ? undefined : table.whole,
+        members,
+        open: table.membersOpen || opens(file, free, table.modelled),
+    };
+}
+/** Whether one node is `Object.defineProperty`. */
+function isDefineProperty(node) {
+    return (isPropertyAccessExpression(node) &&
+        isIdentifier(node.expression) &&
+        node.expression.text === "Object" &&
+        node.name.text === "defineProperty");
+}
+/** The value a property descriptor literal gives, where it writes a `value` or a `get`. */
+function describedValue(descriptor) {
+    if (!isObjectLiteralExpression(descriptor)) {
+        return undefined;
+    }
+    let found;
+    for (const element of descriptor.properties) {
+        const key = isSpreadAssignment(element) ? undefined : componentOf(element.name)?.text;
+        if (key === "value") {
+            return {
+                value: isPropertyAssignment(element)
+                    ? element.initializer
+                    : isMethodDeclaration(element)
+                        ? element
+                        : undefined,
+            };
+        }
+        if (key === "get") {
+            found = { value: undefined };
+        }
+    }
+    return found;
+}
+/** Whether one node is literal text: a string, or a template with no substitution. */
+function isLiteralText(node) {
+    return isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node);
+}
+/** Whether one element access key is literal: text or a number. */
+function isLiteralKey(node) {
+    return isLiteralText(node) || isNumericLiteral(node);
+}
+/**
+ * Whether one file writes its exports anywhere the table does not model: through `module`,
+ * `module.exports` or the free `exports` written, assigned, passed or stored outside the
+ * statements the scan read, or through a top-level `this`.
+ */
+function opens(file, isFree, modelled) {
+    let open = false;
+    const visit = (node, thisIsExports) => {
+        if (open) {
+            return;
+        }
+        if (isIdentifier(node)) {
+            open = opensAt(node, isFree, modelled);
+            return;
+        }
+        if (node.kind === SyntaxKind.ThisKeyword) {
+            open = thisIsExports && writes(node, modelled);
+            return;
+        }
+        const fn = isFunctionLikeDeclaration(node);
+        const innerThis = thisIsExports &&
+            !(fn && !isArrowFunction(node)) &&
+            !isClassDeclaration(node) &&
+            !isClassExpression(node);
+        node.forEachChild((child) => {
+            visit(child, innerThis);
+        });
+    };
+    file.forEachChild((child) => {
+        visit(child, true);
+    });
+    return open;
+}
+/** Whether one free occurrence of `module` or `exports` opens the table. */
+function opensAt(node, isFree, modelled) {
+    const name = node.text;
+    if ((name !== "module" && name !== "exports") || !isFree(node) || spellsNoBinding(node)) {
+        return false;
+    }
+    if (name === "exports") {
+        return writes(node, modelled);
+    }
+    const parent = node.parent;
+    if (isPropertyAccessExpression(parent) && parent.expression === node) {
+        return parent.name.text === "exports" && writes(parent, modelled);
+    }
+    if (isElementAccessExpression(parent) && parent.expression === node) {
+        return writes(parent, modelled);
+    }
+    return !readOnly(node);
+}
+/**
+ * Whether the exports object one expression names is written, or escapes where it may be
+ * written, other than by a write the scan read: assigned, a property of it assigned,
+ * incremented or deleted, or the value handed anywhere but a `typeof` or a comparison.
+ */
+function writes(object, modelled) {
+    const parent = object.parent;
+    if (assigns(parent, object)) {
+        return !modelled.has(parent);
+    }
+    if ((isPropertyAccessExpression(parent) || isElementAccessExpression(parent)) &&
+        parent.expression === object) {
+        const holder = parent.parent;
+        const written = assigns(holder, parent) ||
+            isDeleteExpression(holder) ||
+            ((isPrefixUnaryExpression(holder) || isPostfixUnaryExpression(holder)) &&
+                (holder.operator === SyntaxKind.PlusPlusToken ||
+                    holder.operator === SyntaxKind.MinusMinusToken));
+        return written && !modelled.has(holder);
+    }
+    if (isCallExpression(parent) && modelled.has(parent)) {
+        return false;
+    }
+    return !readOnly(object);
+}
+/** Whether `holder` assigns to `target`, by any assignment operator. */
+function assigns(holder, target) {
+    return (isBinaryExpression(holder) &&
+        holder.left === target &&
+        isAssignmentOperator(holder.operatorToken.kind));
+}
+/** Whether one value is only read: the operand of a `typeof` or of an equality comparison. */
+function readOnly(node) {
+    const parent = node.parent;
+    return (isTypeOfExpression(parent) ||
+        (isBinaryExpression(parent) && isEqualityOperator(parent.operatorToken.kind)));
+}

package/dist/src/inventory/enumerate.js

@@ -0,0 +1,167 @@
+import { isShorthandPropertyAssignment, ModifierFlags } from "@typescript/native/ast";
+import { Builder, modifiersOf, } from "../inventory.js";
+import { packageScope, packageTypeIsModule } from "../load/package-scope.js";
+import { relativePath } from "../paths.js";
+import { renderPosition } from "../position.js";
+import { isAnswered, UNANSWERED } from "../query.js";
+import { declarationOf } from "../entries/static-module.js";
+import { commonJS } from "./commonjs.js";
+import { SYNTAX } from "./syntax.js";
+/**
+ * Every declaration one project's own files hold, in rendered position order.
+ *
+ * `targetRoot` is the absolute path every position is rendered against; a file the program
+ * holds that is not below it ends the enumeration. `host` is the filesystem the manifests
+ * that name each file's package are read through, and nothing else is read from it.
+ */
+export function inventory(project, host, targetRoot) {
+    const files = project.ownSourceFiles();
+    const moduleOf = packageScope(host, targetRoot);
+    const sources = [
+        SYNTAX,
+        commonJS(packageTypeIsModule(host, targetRoot), resolvedIn(project), declarationOf),
+    ];
+    const into = new Builder(targetRoot);
+    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 owner = into.file(file, moduleOf(path), path);
+        for (const source of sources) {
+            source.declare(file, owner, into);
+        }
+    }
+    return into.build(readTables(project, into, new Set(files.map((file) => file.fileName))));
+}
+/** The declarations of this program each occurrence resolves to, asked in one batch. */
+function resolvedIn(project) {
+    return (occurrences) => {
+        const symbols = project.symbolsAt(occurrences.map((occurrence) => project.handle(occurrence)));
+        return occurrences.map((occurrence, index) => {
+            // A shorthand property's name resolves to the property it declares, not the binding.
+            const symbol = isShorthandPropertyAssignment(occurrence.parent)
+                ? project.shorthandValueAt(project.handle(occurrence.parent))
+                : symbols[index];
+            return typeof symbol === "object"
+                ? symbol.declarations.flatMap((declaration) => project.declarationAt(declaration)?.node ?? [])
+                : [];
+        });
+    };
+}
+/**
+ * The binder's half: which declarations each module and namespace exports, and the members
+ * each container's symbol tables hold, then the members only its tree holds. One batch
+ * resolves every scope and container, because an accessor with an array overload costs one
+ * round trip for the batch and one per node without it.
+ */
+function readTables(project, into, ownFiles) {
+    const scopes = into.exportScopes;
+    const named = into.containers.filter((container) => container.nameNode !== undefined);
+    const batched = [
+        ...scopes.map((scope) => scope.nameNode),
+        ...named.flatMap((container) => container.nameNode ?? []),
+    ];
+    const handles = batched.map((node) => project.handle(node));
+    const resolved = project.symbolsAt(handles);
+    const symbolOf = new Map();
+    batched.forEach((node, index) => {
+        const symbol = resolved[index];
+        if (typeof symbol === "object") {
+            symbolOf.set(node, symbol);
+        }
+    });
+    // A scope or a container whose symbol or table went unanswered keeps what its syntax
+    // declares, and everything under it is recorded unanswered.
+    scopes.forEach((scope, index) => {
+        if (resolved[index] === UNANSWERED) {
+            into.unanswered(scope.owner);
+        }
+    });
+    named.forEach((container, index) => {
+        if (resolved[scopes.length + index] === UNANSWERED) {
+            into.unanswered(container.owner);
+        }
+    });
+    let exportTables = 0;
+    for (const scope of scopes) {
+        const symbol = symbolOf.get(scope.nameNode);
+        if (symbol === undefined) {
+            continue;
+        }
+        exportTables += 1;
+        const table = project.queries.exportsOf(symbol);
+        if (!isAnswered(table)) {
+            into.unanswered(scope.owner);
+            continue;
+        }
+        for (const [, exported] of table) {
+            for (const declaration of exported.declarations) {
+                const held = project.declarationAt(declaration);
+                const record = held === undefined ? undefined : into.recordAt(held.node);
+                if (record !== undefined) {
+                    record.exported = true;
+                }
+            }
+        }
+    }
+    let memberTables = 0;
+    const readTable = (container, table, seen, areStatic) => {
+        for (const [, member] of table) {
+            const declarations = member.declarations.flatMap((handle) => project.declarationAt(handle) ?? []);
+            // 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. 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 declarations) {
+                const node = held.node;
+                if (ownFiles.has(node.getSourceFile().fileName) &&
+                    writtenInside(container.declaration, node)) {
+                    into.member(container, node, seen, areStatic);
+                }
+            }
+        }
+    };
+    for (const container of into.containers) {
+        const symbol = container.nameNode === undefined ? undefined : symbolOf.get(container.nameNode);
+        const seen = new Map();
+        const isClass = container.memberKind === "class-member";
+        const isEnum = container.memberKind === "enum-member";
+        if (symbol !== undefined) {
+            if (!isEnum) {
+                memberTables += 1;
+                const table = project.queries.membersOf(symbol);
+                if (isAnswered(table)) {
+                    readTable(container, table, seen, false);
+                }
+                else {
+                    into.unanswered(container.owner);
+                }
+            }
+            if (isEnum || isClass) {
+                memberTables += 1;
+                const table = project.queries.exportsOf(symbol);
+                if (isAnswered(table)) {
+                    readTable(container, table, seen, isClass);
+                }
+                else {
+                    into.unanswered(container.owner);
+                }
+            }
+        }
+        // A member whose key is computed is bound to the container's type later than the
+        // table is built, so only the container's own declaration names it.
+        for (const member of container.members) {
+            into.member(container, member, seen, (modifiersOf(member) & ModifierFlags.Static) !== 0);
+        }
+    }
+    return { batches: 1, exportTables, memberTables };
+}
+/** 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);
+}