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

package/dist/src/overrides.js

@@ -24,121 +24,136 @@ function nameOf(entry) {
     }
     return isQualifiedName(entry.typeName) ? entry.typeName.right : entry.typeName;
 }
-/** Each class of the target whose `extends` clause names a class, with the name node. */
-function extending(project, held) {
-    const found = [];
-    for (const file of project.ownSourceFiles()) {
-        const visit = (node) => {
-            if (isClassDeclaration(node) || isClassExpression(node)) {
-                const id = held.declarations.get(nodeKey(file, node));
-                const clause = node.heritageClauses?.find((one) => one.token === SyntaxKind.ExtendsKeyword);
-                const base = clause?.types[0];
-                if (id !== undefined && base !== undefined) {
-                    found.push({ id, base: nameOf(base) });
-                }
-            }
-            node.forEachChild(visit);
-        };
-        file.forEachChild(visit);
-    }
-    return found;
-}
 /**
- * The references each base class member makes to its overrides, for the classes of one
- * project that extend another class of the target, and each class makes to its members
- * that override a member of a class declared outside the target. A member a nearer base
- * already overrides is reached through that override. A private member is not
- * overridden. Each reference is placed at the override and made by its file.
+ * The reads each base class member makes of its overrides, for the classes of the target that
+ * extend another class of the target, and each class makes of its members that override a
+ * member of a class declared outside the target. A member a nearer base already overrides is
+ * reached through that override. A private member is not overridden. Each read is placed at
+ * the override. A class whose base the checker leaves unanswered holds every member it could
+ * override.
  */
-export function overrideReferences(project, held, chains, testFiles) {
-    const classes = extending(project, held);
-    if (classes.length === 0) {
-        return [];
-    }
-    const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
-    const members = new Map();
-    for (const symbol of held.symbols) {
-        const component = memberComponent(symbol, byId);
-        if (component === undefined ||
-            !OVERRIDABLE.has(symbol.kind) ||
-            symbol.visibility === "private" ||
-            symbol.visibility === "private-name") {
-            continue;
-        }
-        const own = members.get(symbol.parent) ?? new Map();
-        own.set(component, symbol);
-        members.set(symbol.parent, own);
-    }
-    const bases = new Map();
-    const outsideBases = new Map();
-    const own = project.ownPaths();
-    const symbols = project.symbolsAt(classes.map((one) => project.handle(one.base)));
-    classes.forEach(({ id }, index) => {
-        const symbol = symbols[index];
-        if (symbol !== undefined && symbol !== UNANSWERED) {
-            const inTarget = chains
-                .chainOf(symbol)
-                .map((target) => target.id)
-                .filter((target) => byId.get(target)?.kind === "class" && target !== id);
-            bases.set(id, inTarget);
-            const declared = (symbol.flags & SymbolFlags.Alias) === 0 ? symbol : project.queries.aliased(symbol);
-            if (inTarget.length === 0 &&
-                declared !== UNANSWERED &&
-                (((declared.flags & SymbolFlags.Class) !== 0 &&
-                    // The target's augmentation of an outside class merges an interface into it,
-                    // so only a class declaration says where the class is.
-                    declared.declarations.some((handle) => CLASS_DECLARATIONS.has(handle.kind) && !own.has(handle.path))) ||
-                    ((declared.flags & SymbolFlags.Interface) !== 0 &&
-                        declared.declarations.some((handle) => handle.kind === SyntaxKind.VariableDeclaration && !own.has(handle.path))))) {
-                outsideBases.set(id, declared);
-            }
-        }
-    });
-    /** The nearest member of one component the class or a class it extends declares. */
-    const declaredAbove = (classId, component, seen) => {
-        if (seen.has(classId)) {
-            return [];
-        }
-        seen.add(classId);
-        const own = members.get(classId)?.get(component);
-        if (own !== undefined) {
-            return [own.id];
-        }
-        return (bases.get(classId) ?? []).flatMap((base) => declaredAbove(base, component, seen));
-    };
-    const found = [];
-    const outsideNames = outsideMemberNames(project, bases, outsideBases);
-    for (const [classId, names] of outsideNames) {
-        for (const [component, member] of members.get(classId) ?? []) {
-            if (names.has(component)) {
-                found.push({
-                    from: classId,
-                    to: member.id,
-                    position: member.position,
-                    use: "read",
-                    resolution: "override",
-                    test: testFiles.has(member.position.path),
+export const overrides = {
+    start() {
+        const extending = [];
+        return {
+            visit(node, { file }) {
+                if (isClassDeclaration(node) || isClassExpression(node)) {
+                    const clause = node.heritageClauses?.find((one) => one.token === SyntaxKind.ExtendsKeyword);
+                    const base = clause?.types[0];
+                    if (base !== undefined) {
+                        extending.push({ node, file, base: nameOf(base) });
+                    }
+                }
+            },
+            reads({ project, held, chains }) {
+                const found = [];
+                const classes = extending.flatMap((one) => {
+                    const id = held.declarations.get(nodeKey(one.file, one.node));
+                    return id === undefined ? [] : [{ ...one, id }];
                 });
-            }
-        }
-    }
-    for (const [classId, baseIds] of bases) {
-        for (const [component, member] of members.get(classId) ?? []) {
-            const seen = new Set([classId]);
-            for (const base of baseIds.flatMap((one) => declaredAbove(one, component, seen))) {
-                found.push({
-                    from: base,
-                    to: member.id,
-                    position: member.position,
-                    use: "read",
-                    resolution: "override",
-                    test: testFiles.has(member.position.path),
+                if (classes.length === 0) {
+                    return found;
+                }
+                const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
+                const members = new Map();
+                for (const symbol of held.symbols) {
+                    const component = memberComponent(symbol, byId);
+                    if (component === undefined ||
+                        !OVERRIDABLE.has(symbol.kind) ||
+                        symbol.visibility === "private" ||
+                        symbol.visibility === "private-name") {
+                        continue;
+                    }
+                    const own = members.get(symbol.parent) ?? new Map();
+                    own.set(component, symbol);
+                    members.set(symbol.parent, own);
+                }
+                const bases = new Map();
+                const outsideBases = new Map();
+                const fileOf = new Map(classes.map((one) => [one.id, one.file]));
+                const own = project.ownPaths();
+                const unanswered = new Set();
+                const symbols = project.symbolsAt(classes.map((one) => project.handle(one.base)));
+                classes.forEach(({ id }, index) => {
+                    const symbol = symbols[index];
+                    if (symbol === UNANSWERED) {
+                        unanswered.add(id);
+                        return;
+                    }
+                    if (symbol === undefined) {
+                        return;
+                    }
+                    const inTarget = chains
+                        .chainOf(symbol)
+                        .map((target) => target.id)
+                        .filter((target) => byId.get(target)?.kind === "class" && target !== id);
+                    bases.set(id, inTarget);
+                    const declared = (symbol.flags & SymbolFlags.Alias) === 0 ? symbol : project.queries.aliased(symbol);
+                    if (declared === UNANSWERED) {
+                        unanswered.add(id);
+                        return;
+                    }
+                    if (inTarget.length === 0 &&
+                        (((declared.flags & SymbolFlags.Class) !== 0 &&
+                            // The target's augmentation of an outside class merges an interface into it,
+                            // so only a class declaration says where the class is.
+                            declared.declarations.some((handle) => CLASS_DECLARATIONS.has(handle.kind) && !own.has(handle.path))) ||
+                            ((declared.flags & SymbolFlags.Interface) !== 0 &&
+                                declared.declarations.some((handle) => handle.kind === SyntaxKind.VariableDeclaration && !own.has(handle.path))))) {
+                        outsideBases.set(id, declared);
+                    }
                 });
-            }
-        }
-    }
-    return found;
-}
+                /** The nearest member of one component the class or a class it extends declares. */
+                const declaredAbove = (classId, component, seen) => {
+                    if (seen.has(classId)) {
+                        return [];
+                    }
+                    seen.add(classId);
+                    const member = members.get(classId)?.get(component);
+                    if (member !== undefined) {
+                        return [member.id];
+                    }
+                    return (bases.get(classId) ?? []).flatMap((base) => declaredAbove(base, component, seen));
+                };
+                const read = (classId, from, member) => {
+                    const file = fileOf.get(classId);
+                    if (file !== undefined) {
+                        found.push({
+                            kind: "named",
+                            from,
+                            to: member.id,
+                            file,
+                            at: member.position,
+                            use: "read",
+                            via: "override",
+                        });
+                    }
+                };
+                const outside = outsideMemberNames(project, bases, outsideBases);
+                for (const classId of [...unanswered, ...outside.unanswered]) {
+                    const ids = [...(members.get(classId)?.values() ?? [])].map((member) => member.id);
+                    found.push({ kind: "held", from: classId, ids });
+                }
+                for (const [classId, names] of outside.names) {
+                    for (const [component, member] of members.get(classId) ?? []) {
+                        if (names.has(component)) {
+                            read(classId, classId, member);
+                        }
+                    }
+                }
+                for (const [classId, baseIds] of bases) {
+                    for (const [component, member] of members.get(classId) ?? []) {
+                        const seen = new Set([classId]);
+                        for (const base of baseIds.flatMap((one) => declaredAbove(one, component, seen))) {
+                            read(classId, base, member);
+                        }
+                    }
+                }
+                return found;
+            },
+        };
+    },
+};
 /**
  * Per class of the target with a class declared outside the target in its `extends`
  * chain, the member components that outside class's instances and constructor carry, a
@@ -146,10 +161,17 @@ export function overrideReferences(project, held, chains, testFiles) {
  */
 function outsideMemberNames(project, bases, outsideBases) {
     const direct = new Map();
+    const unanswered = [];
     const error = errorType(project);
     for (const [classId, base] of outsideBases) {
         const instance = project.queries.declaredTypeOf(base);
         const statics = project.queries.typeOfSymbol(base);
+        if (instance === UNANSWERED ||
+            statics === UNANSWERED ||
+            project.queries.propertiesOf(instance) === UNANSWERED ||
+            (statics !== undefined && project.queries.propertiesOf(statics) === UNANSWERED)) {
+            unanswered.push(classId);
+        }
         const components = [
             ...namesOf(project, instance === UNANSWERED ? undefined : instance).map(nameComponent),
             ...(instance !== UNANSWERED && reaches(project, instance, error) ? ["toString"] : []),
@@ -176,7 +198,7 @@ function outsideMemberNames(project, bases, outsideBases) {
             names.set(classId, found);
         }
     }
-    return names;
+    return { names, unanswered };
 }
 /** The global `Error` instance type's identifier, where the program's library declares one. */
 function errorType(project) {

package/dist/src/paths.js

@@ -8,6 +8,50 @@ const SEPARATOR = "/";
 export function isAbsolutePath(path) {
     return path.startsWith(SEPARATOR);
 }
+/** Whether a specifier starts a path relative to the file that writes it: `./` or `../`. */
+export function startsRelativePath(specifier) {
+    return specifier.startsWith("./") || specifier.startsWith("../");
+}
+/** Whether a specifier names a path relative to the file that writes it: `.`, `..`, `./` or `../` first. */
+export function isRelativeSpecifier(specifier) {
+    return specifier === "." || specifier === ".." || startsRelativePath(specifier);
+}
+/**
+ * Whether a module specifier names a path rather than a package, as the compiler reads one:
+ * a relative specifier or an absolute path.
+ */
+export function isPathSpecifier(specifier) {
+    return isRelativeSpecifier(specifier) || isAbsolutePath(specifier);
+}
+/**
+ * Whether a string starts with `./`, `../` or `/`, the specifiers a browser reads as a URL
+ * rather than a bare name, so a bare `.` or `..` stays a request:
+ * https://html.spec.whatwg.org/multipage/webappapis.html#resolve-a-url-like-module-specifier
+ */
+export function isExplicitPath(text) {
+    return startsRelativePath(text) || isAbsolutePath(text);
+}
+/**
+ * Whether a string starts with `.` or `/`, which no npm package name does, so a reader that
+ * takes any other string as a package's takes it as a path:
+ * https://docs.npmjs.com/cli/v11/configuring-npm/package-json#name
+ */
+export function cannotStartPackageName(text) {
+    return text.startsWith(".") || isAbsolutePath(text);
+}
+/** A URL scheme, `file:` and `node:` among them: https://url.spec.whatwg.org/#url-scheme-string */
+const URL_SCHEME = /^[a-z][a-z\d+.-]*:/iu;
+/** Whether a string starts with a URL scheme. */
+export function hasURLScheme(text) {
+    return URL_SCHEME.test(text);
+}
+/**
+ * Whether a URL reference is a relative one that does not start with a solidus, the bare
+ * name included: https://url.spec.whatwg.org/#relative-url-string
+ */
+export function isPathRelativeURL(reference) {
+    return reference !== "" && !reference.startsWith(SEPARATOR) && !hasURLScheme(reference);
+}
 /**
  * One path with `.` removed, `..` applied to the segment before it, and repeated
  * separators collapsed. A `..` that walks past the root of an absolute path is
@@ -88,6 +132,17 @@ export function extensionOf(path) {
 export function resolvePath(against, path) {
     return isAbsolutePath(path) ? normalizePath(path) : joinPath(against, path);
 }
+/**
+ * The path a relative URL reference names against `dir`, its query and its fragment
+ * removed, which name no part of the file; undefined where the reference is not relative.
+ */
+export function relativeURLPath(dir, reference) {
+    if (!isPathRelativeURL(reference)) {
+        return undefined;
+    }
+    const cut = reference.search(/[?#]/u);
+    return resolvePath(dir, cut < 0 ? reference : reference.slice(0, cut));
+}
 /**
  * The relative path before the query of a relative module specifier such as
  * `./worker.ts?worker`, the module a bundler loads; undefined for a specifier with no
@@ -96,7 +151,7 @@ export function resolvePath(against, path) {
  */
 export function queriedModulePath(specifier) {
     const query = specifier.indexOf("?");
-    if (query < 0 || !(specifier.startsWith("./") || specifier.startsWith("../"))) {
+    if (query < 0 || !startsRelativePath(specifier)) {
         return undefined;
     }
     const raw = specifier

package/dist/src/platform-calls.js

@@ -0,0 +1,78 @@
+/**
+ * Which calls are the platform's `require` or AMD's `define` and which constructions its `URL`
+ * (roots.23, references-ts.37, references-ts.1), decided once over the bindings of the names a callee is written with: the
+ * checker's in a program, the file's own scopes in a module read outside every program.
+ */
+import { isBindingElement, isCallExpression, isExportSpecifier, isIdentifier, isImportSpecifier, isPropertyAccessExpression, isStringLiteral, isVariableDeclaration, } from "@typescript/native/ast";
+import { parenthesesRemoved, unwrapped } from "./unwrap.js";
+/** The name one declaration carries a binding by beside its own: the export an import or a re-export names, or the property a destructuring reads. */
+export function carriedNames(node) {
+    if (isImportSpecifier(node) || isExportSpecifier(node)) {
+        return [(node.propertyName ?? node.name).text];
+    }
+    const property = isBindingElement(node) ? node.propertyName : undefined;
+    return property !== undefined && (isIdentifier(property) || isStringLiteral(property))
+        ? [property.text]
+        : [];
+}
+/**
+ * A written name's binding as a file states it, with no checker to ask, so nothing is
+ * proven the target's own (conventions.3): `declarationOf` names the declaration a name
+ * resolves to, and a property is read by how it is written alone.
+ */
+export function lexicalBinding(declarationOf) {
+    return (written) => {
+        const parent = written.parent;
+        if (isPropertyAccessExpression(parent) && parent.name === written) {
+            return undefined;
+        }
+        const declaration = declarationOf(written);
+        return {
+            names: new Set([
+                written.text,
+                ...(declaration === undefined ? [] : carriedNames(declaration)),
+            ]),
+            own: declaration === undefined ? [] : [declaration],
+            provenOwn: false,
+        };
+    };
+}
+/** The name a callee or a constructor is written with, parentheses removed: an identifier or a property name. */
+export function writtenName(expression) {
+    const at = parenthesesRemoved(expression);
+    if (isIdentifier(at)) {
+        return at;
+    }
+    return isPropertyAccessExpression(at) && isIdentifier(at.name) ? at.name : undefined;
+}
+/**
+ * Whether a call or construction through `callee` is one of the platform's `name`: never
+ * where its binding is proven the target's own; otherwise where it is written or carried
+ * by that name, or resolves to a variable of the target whose initializer is such a
+ * callee or, for `require`, a call of a `createRequire`. A callee nothing binds is read by
+ * how it is written.
+ */
+export function callsPlatformBy(name, callee, bindingOf, seen = new Set()) {
+    const bound = bindingOf(callee);
+    if (bound?.provenOwn === true) {
+        return false;
+    }
+    if (callee.text === name || bound?.names.has(name) === true) {
+        return true;
+    }
+    return (bound?.own ?? []).some((node) => {
+        if (seen.has(node) || !isVariableDeclaration(node) || node.initializer === undefined) {
+            return false;
+        }
+        seen.add(node);
+        const value = unwrapped(node.initializer);
+        if (isCallExpression(value)) {
+            const called = writtenName(value.expression);
+            return (name === "require" &&
+                called !== undefined &&
+                callsPlatformBy("createRequire", called, bindingOf, seen));
+        }
+        const written = writtenName(value);
+        return written !== undefined && callsPlatformBy(name, written, bindingOf, seen);
+    });
+}

package/dist/src/platform-symbols.js

@@ -0,0 +1,134 @@
+/**
+ * The platform's names read through a program's checker: its `require` and `URL`, as
+ * `platform-calls.ts` decides them, its worker constructors and `navigator`, and Node's
+ * `Worker`.
+ */
+import { isArrowFunction, isClassDeclaration, isClassExpression, isFunctionDeclaration, isFunctionExpression, isMethodDeclaration, isModuleDeclaration, isPropertyAssignment, isPropertyDeclaration, isSourceFile, isStringLiteralLikeNode, isVariableDeclaration, } from "@typescript/native/ast";
+import { SymbolFlags } from "@typescript/native/sync";
+import { UNANSWERED } from "./query.js";
+import { boundExports, NAMESPACE } from "./entries/static-module.js";
+import { isAmbient } from "./inventory.js";
+import { callsPlatformBy, carriedNames } from "./platform-calls.js";
+import { unwrapped } from "./unwrap.js";
+/** The symbol one symbol names through its aliases, or the symbol itself where it is none. */
+function dealiased(project, symbol) {
+    if ((symbol.flags & SymbolFlags.Alias) === 0) {
+        return symbol;
+    }
+    return project.queries.aliased(symbol);
+}
+/** Each declaration of `symbol` in a file of the target, read in this project's program. */
+function ownDeclarations(project, symbol) {
+    const own = project.ownPaths();
+    return symbol.declarations.flatMap((handle) => {
+        const node = own.has(handle.path) ? project.declarationAt(handle)?.node : undefined;
+        return node === undefined ? [] : [node];
+    });
+}
+/**
+ * Whether one declaration writes a function or a class with a body (roots.23): a function
+ * or method declaration with a body, a class declaration, or a variable, a property or a
+ * class field whose initializer is a function, an arrow function or a class expression,
+ * under no `declare` modifier and in no declaration file.
+ */
+function writesBody(node) {
+    const value = (isVariableDeclaration(node) || isPropertyAssignment(node) || isPropertyDeclaration(node)) &&
+        node.initializer !== undefined
+        ? unwrapped(node.initializer)
+        : node;
+    return ((isFunctionDeclaration(value) || isMethodDeclaration(value)
+        ? value.body !== undefined
+        : isFunctionExpression(value) ||
+            isArrowFunction(value) ||
+            isClassDeclaration(value) ||
+            isClassExpression(value)) && !isAmbient(value.getSourceFile(), value));
+}
+/**
+ * What the checker binds `symbol` to, one alias step at a time: every name a step of the
+ * chain carries it by, and the declarations of the target its last step reaches, which
+ * prove it the target's own where one {@link writesBody}. A chain that ends at no
+ * declaration, or that the checker leaves unanswered, reaches none.
+ */
+function boundBy(project, symbol) {
+    if (typeof symbol !== "object") {
+        return undefined;
+    }
+    const names = new Set();
+    const stepped = new Set();
+    for (let at = symbol; at !== undefined && !stepped.has(at.id);) {
+        stepped.add(at.id);
+        names.add(at.name);
+        const own = ownDeclarations(project, at);
+        for (const node of own) {
+            carriedNames(node).forEach((one) => names.add(one));
+        }
+        if ((at.flags & SymbolFlags.Alias) === 0) {
+            return { names, own, provenOwn: own.some(writesBody) };
+        }
+        const next = project.aliasStepOf(at);
+        at = typeof next === "object" ? next : undefined;
+    }
+    return { names, own: [], provenOwn: false };
+}
+/** Each written name's binding, as this project's checker answers it. */
+function checkerBinding(project) {
+    return (written) => boundBy(project, project.symbolsAt([project.handle(written)])[0]);
+}
+/**
+ * Whether a call or construction through `callee`, the batch's answer for which is `symbol`,
+ * is one of the platform's `require`, AMD's `define` or `URL` (roots.23, references-ts.37,
+ * references-ts.1), as {@link callsPlatformBy} decides it over this project's checker.
+ */
+export function callsPlatform(project, name, callee, symbol) {
+    const others = checkerBinding(project);
+    return callsPlatformBy(name, callee, (written) => written === callee ? boundBy(project, symbol) : others(written));
+}
+/**
+ * Whether a worker's constructor or `navigator`, the batch's answer for which is `symbol`, is
+ * the platform's (references-ts.2): a name the checker leaves unanswered, or one whose symbol
+ * is no alias and has a declaration outside the target's files.
+ */
+export function isPlatformGlobal(project, symbol) {
+    if (symbol === UNANSWERED) {
+        return true;
+    }
+    const own = project.ownPaths();
+    return (symbol !== undefined &&
+        (symbol.flags & SymbolFlags.Alias) === 0 &&
+        symbol.declarations.some((handle) => !own.has(handle.path)));
+}
+/** The module names Node's worker threads are imported by. */
+const THREADS = new Set(["worker_threads", "node:worker_threads"]);
+function namesThreads(node) {
+    return node !== undefined && isStringLiteralLikeNode(node) && THREADS.has(node.text);
+}
+/** Whether one declaration is written in the body of `declare module "worker_threads"`. */
+function inThreadsModule(node) {
+    for (let at = node; !isSourceFile(at); at = at.parent) {
+        if (isModuleDeclaration(at) && namesThreads(at.name)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Whether a `Worker` constructor, the batch's answer for which is `symbol`, is Node's
+ * (references-ts.2): its symbol resolves to a declaration of `worker_threads`, or one of its
+ * own declarations binds the module's `Worker`, or `holder`, the namespace it is read
+ * through, binds the module, each binding read as {@link boundExports} reads one, which
+ * decides where the module has no declaration.
+ */
+export function startsThread(project, symbol, holder) {
+    const bindingOf = checkerBinding(project);
+    const declared = (one, member) => typeof one === "object" &&
+        ownDeclarations(project, one).some((node) => boundExports(node, (specifier) => THREADS.has(specifier), bindingOf).includes(member));
+    if (declared(symbol, "Worker") || declared(holder, NAMESPACE)) {
+        return true;
+    }
+    const named = typeof symbol === "object" ? dealiased(project, symbol) : undefined;
+    return (typeof named === "object" &&
+        named.declarations.some((handle) => {
+            const node = project.declarationAt(handle)?.node;
+            return node !== undefined && inThreadsModule(node);
+        }));
+}

package/dist/src/references/read-rule.js

@@ -0,0 +1 @@
+export {};

package/dist/src/references/read-rules.js

@@ -0,0 +1,48 @@
+import { elementAccess } from "../element-access.js";
+import { indexedAccess } from "../indexed-access.js";
+import { keyofComparisons } from "../keyof-comparisons.js";
+import { moduleDeclarations } from "../module-declarations.js";
+import { overrides } from "../overrides.js";
+import { isAnswered } from "../query.js";
+import { iteration } from "../symbol-keys.js";
+import { typeParameterReads } from "../type-parameter-reads.js";
+import { unimplementedCallees } from "../unimplemented-callees.js";
+/** The member kinds a hold of every member names. */
+const MEMBER_KINDS = new Set([
+    "method",
+    "class-member",
+    "interface-method",
+    "type-member",
+    "enum-member",
+]);
+/**
+ * Every read rule, each run over every side's walked files with the reference sources:
+ * a consumer's read of a target member is a reference as the target's own is.
+ */
+export const READ_RULES = [
+    overrides,
+    indexedAccess,
+    elementAccess,
+    keyofComparisons,
+    iteration,
+    typeParameterReads,
+    unimplementedCallees,
+    moduleDeclarations,
+];
+/** The declarations one hold names, with the declaration whose read it is. */
+export function heldBy(read, { project, held, chains }) {
+    const ids = [...(read.from === "" ? [] : [read.from]), ...(read.ids ?? [])];
+    for (const name of read.names ?? []) {
+        ids.push(...(held.byName.get(name) ?? []));
+    }
+    for (const type of read.types ?? []) {
+        const properties = project.queries.propertiesOf(type);
+        for (const property of isAnswered(properties) ? properties : []) {
+            ids.push(...chains.declarationsOf(property));
+        }
+    }
+    if (read.members === true) {
+        ids.push(...held.symbols.filter((one) => MEMBER_KINDS.has(one.kind)).map((one) => one.id));
+    }
+    return ids;
+}