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

package/dist/src/symbol-keys.js

@@ -7,9 +7,7 @@
  */
 import { isComputedPropertyName, isForOfStatement, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isPropertyAccessExpression, isSpreadElement, isStringLiteral, } from "@typescript/native/ast";
 import { parenthesesRemoved } from "./unwrap.js";
-import { nodeKey } from "./inventory.js";
-import { renderPosition } from "./position.js";
-import { isAnswered } from "./query.js";
+import { isAnswered, UNANSWERED } from "./query.js";
 /** The identifier an element access's argument names its key by, where it is a name. */
 export function keyNameOf(argument) {
     const at = parenthesesRemoved(argument);
@@ -127,87 +125,95 @@ function wellKnownName(name) {
         : undefined;
 }
 /**
- * The references the iterations of one project's own files make to the iteration members
- * of the values they iterate: a `for…of` statement and a spread element read
- * `[Symbol.iterator]`, and a `for await…of` statement reads `[Symbol.asyncIterator]` and,
- * which it falls back to, `[Symbol.iterator]`. Each is made by the declaration holding it.
+ * The reads the iterations of a side's files make of the iteration members of the values they
+ * iterate: a `for…of` statement and a spread element read `[Symbol.iterator]`, and a
+ * `for await…of` statement reads `[Symbol.asyncIterator]` and, which it falls back to,
+ * `[Symbol.iterator]`. Each is made by the declaration holding it. A value whose type or
+ * members the checker leaves unanswered holds the members those names could spell.
  */
-export function iterationReferences(project, held, chains, root, testFiles) {
-    const queries = project.queries;
-    const ownPaths = project.ownPaths();
-    const iterated = [];
-    for (const file of project.ownSourceFiles()) {
-        const fileId = held.declarations.get(nodeKey(file, file));
-        if (fileId === undefined) {
-            continue;
-        }
-        const visit = (node, from) => {
-            const holder = held.declarations.get(nodeKey(file, node)) ?? from;
-            if (isForOfStatement(node)) {
-                const protocols = node.awaitModifier === undefined ? ["iterator"] : ["asyncIterator", "iterator"];
-                iterated.push({ file, from: holder, operand: node.expression, protocols });
-            }
-            else if (isSpreadElement(node)) {
-                iterated.push({ file, from: holder, operand: node.expression, protocols: ["iterator"] });
-            }
-            node.forEachChild((child) => {
-                visit(child, holder);
-            });
-        };
-        file.forEachChild((child) => {
-            visit(child, fileId);
-        });
-    }
-    if (iterated.length === 0) {
-        return [];
-    }
-    const types = queries.typesAt(iterated.map((one) => one.operand));
-    const members = new Map();
-    const membersOf = (type) => {
-        const known = members.get(type.id);
-        if (known !== undefined) {
-            return known;
-        }
-        const keyed = [];
-        const properties = queries.propertiesOf(type);
-        for (const property of isAnswered(properties) ? properties : []) {
-            for (const handle of property.declarations) {
-                const node = ownPaths.has(handle.path) ? project.declarationAt(handle)?.node : undefined;
-                const name = wellKnownName(node?.name);
-                if (name !== undefined) {
-                    keyed.push({ name, ids: chains.declarationsOf(property) });
-                    break;
+export const iteration = {
+    start() {
+        const iterated = [];
+        return {
+            visit(node, { file, from }) {
+                if (isForOfStatement(node)) {
+                    const protocols = node.awaitModifier === undefined ? ["iterator"] : ["asyncIterator", "iterator"];
+                    iterated.push({ file, from, operand: node.expression, protocols });
                 }
-            }
-        }
-        members.set(type.id, keyed);
-        return keyed;
-    };
-    const found = [];
-    iterated.forEach((one, index) => {
-        const type = types[index];
-        if (type === undefined || !isAnswered(type)) {
-            return;
-        }
-        const parts = type.isUnionType() || type.isIntersectionType() ? queries.constituents(type) : [type];
-        const position = renderPosition(one.file, root, one.operand.getStart());
-        for (const part of isAnswered(parts) ? parts : []) {
-            for (const member of membersOf(part)) {
-                if (!one.protocols.includes(member.name)) {
-                    continue;
+                else if (isSpreadElement(node)) {
+                    iterated.push({ file, from, operand: node.expression, protocols: ["iterator"] });
                 }
-                for (const to of member.ids) {
-                    found.push({
-                        from: one.from,
-                        to,
-                        position,
-                        use: "read",
-                        resolution: "keyed",
-                        test: testFiles.has(position.path),
-                    });
+            },
+            reads({ project, chains }) {
+                const found = [];
+                if (iterated.length === 0) {
+                    return found;
                 }
-            }
-        }
-    });
-    return found;
-}
+                const queries = project.queries;
+                const ownPaths = project.ownPaths();
+                const types = queries.typesAt(iterated.map((one) => one.operand));
+                const members = new Map();
+                const membersOf = (type) => {
+                    const known = members.get(type.id);
+                    if (known !== undefined) {
+                        return known;
+                    }
+                    const properties = queries.propertiesOf(type);
+                    const keyed = [];
+                    for (const property of isAnswered(properties) ? properties : []) {
+                        for (const handle of property.declarations) {
+                            const node = ownPaths.has(handle.path)
+                                ? project.declarationAt(handle)?.node
+                                : undefined;
+                            const name = wellKnownName(node?.name);
+                            if (name !== undefined) {
+                                keyed.push({ name, ids: chains.declarationsOf(property) });
+                                break;
+                            }
+                        }
+                    }
+                    const result = isAnswered(properties) ? keyed : UNANSWERED;
+                    members.set(type.id, result);
+                    return result;
+                };
+                // A member a well-known symbol keys is named by the symbol's computed name.
+                const spelled = (protocols) => protocols.map((protocol) => `Symbol.${protocol}`);
+                iterated.forEach((one, index) => {
+                    const type = types[index];
+                    if (type === UNANSWERED) {
+                        found.push({ kind: "held", from: one.from, names: spelled(one.protocols) });
+                        return;
+                    }
+                    if (type === undefined) {
+                        return;
+                    }
+                    const parts = type.isUnionType() || type.isIntersectionType() ? queries.constituents(type) : [type];
+                    for (const part of isAnswered(parts) ? parts : [type]) {
+                        const keyed = membersOf(part);
+                        if (keyed === UNANSWERED) {
+                            found.push({ kind: "held", from: one.from, names: spelled(one.protocols) });
+                            continue;
+                        }
+                        for (const member of keyed) {
+                            if (!one.protocols.includes(member.name)) {
+                                continue;
+                            }
+                            for (const to of member.ids) {
+                                found.push({
+                                    kind: "named",
+                                    from: one.from,
+                                    to,
+                                    file: one.file,
+                                    at: one.operand,
+                                    use: "read",
+                                    via: "keyed",
+                                });
+                            }
+                        }
+                    }
+                });
+                return found;
+            },
+        };
+    },
+};

package/dist/src/tests/file-class.js

@@ -0,0 +1,76 @@
+/**
+ * The file classes the run counts references by. A test file is one a `ts.test_files`
+ * pattern or a test runner's row names (the test-runner entry source decides which), a test
+ * file no project holds, or a consumer's file a pattern names below the consumer's root.
+ * A test-support file is test code as well, decided once the references are known
+ * (`support.ts`), so a reference carries only whether a test file made it and the counters
+ * read the support class beside it.
+ */
+import { renderPosition } from "../position.js";
+import { bytewise } from "../text/compare.js";
+import { globExpression } from "../text/glob.js";
+/** The test files of the target: each file the test-runner source names, by its file name. */
+export function targetTestFile(named) {
+    return (file) => named.has(file.fileName);
+}
+/** The test files a pattern names, each by its path below `root`: a consumer's, below the consumer's root. */
+export function patternTestFile(patterns, root) {
+    const expressions = patterns.map(globExpression);
+    return (file) => {
+        const path = renderPosition(file, root, 0).path;
+        return expressions.some((expression) => expression.test(path));
+    };
+}
+/** The own files of a project that are test files, by their path below `root`, ascending. */
+export function testFilePaths(project, root, testFile) {
+    return project
+        .ownSourceFiles()
+        .filter(testFile)
+        .map((file) => renderPosition(file, root, 0).path)
+        .sort(bytewise);
+}
+/** Whether test code made one reference: a test file, or a test-support file of the target. */
+export function madeByTestCode(reference, support) {
+    return (reference.test || (reference.consumer === undefined && support.has(reference.position.path)));
+}
+/** Whether the mode classes a reference test code made as a test one: any but a loaded consumer's it classes as production. */
+export function classedAsTest(test, consumer, mode) {
+    return test && !(consumer && mode.consumerTestsProduction === true);
+}
+/** Whether a production mode counts no reference of this one: test code made it, as the mode classes it. */
+export function withheldBy(mode, reference, support) {
+    return (mode.production &&
+        classedAsTest(madeByTestCode(reference, support), reference.consumer !== undefined, mode));
+}
+/** Whether a production mode follows no edge like this one: {@link withheldBy} for a graph edge. */
+export function edgeWithheldBy(mode, edge) {
+    return mode.production && classedAsTest(edge.test, edge.consumer, mode);
+}
+/** The rule a file the analysis classified as test-support code is counted under. */
+const TEST_SUPPORT_RULE = "test-support";
+/**
+ * The name one test-file rule takes. A rule's name is a word list the report's own
+ * vocabulary spells, which cannot carry a pattern, so a rule is named by the place of
+ * its pattern in the configured list.
+ */
+function patternRule(index) {
+    return `test-file-pattern-${String(index + 1)}`;
+}
+/**
+ * The rules over the test files of several projects at once, ordered by rule: a file two
+ * projects hold is one file, so each rule counts the distinct paths it matches.
+ */
+export function testFileRulesOf(testFiles, paths, supportFiles = []) {
+    const distinct = [...new Set(paths)];
+    const support = new Set(supportFiles).size;
+    return [
+        ...testFiles.map((pattern, index) => {
+            const expression = globExpression(pattern);
+            return {
+                rule: patternRule(index),
+                matched: distinct.filter((path) => expression.test(path)).length,
+            };
+        }),
+        ...(support === 0 ? [] : [{ rule: TEST_SUPPORT_RULE, matched: support }]),
+    ].sort((a, b) => bytewise(a.rule, b.rule));
+}

package/dist/src/{outside-tests.js → tests/outside.js}

@@ -7,15 +7,15 @@
  * it names is not known.
  */
 import { isCallExpression, isExportDeclaration, isImportDeclaration, isNamespaceExport, isNamespaceImport, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
-import { RESOLVED_EXTENSIONS } from "./configuration-files.js";
-import { emittedFrom } from "./load/emit-map.js";
-import { namesImported } from "./module-declarations.js";
-import { dirnamePath, joinPath, normalizePath, queriedModulePath } from "./paths.js";
-import { renderPosition } from "./position.js";
-import { nameComponent } from "./ref.js";
+import { RESOLVED_EXTENSIONS } from "../entries/configuration-files.js";
+import { emittedFrom } from "../load/emit-map.js";
+import { namesImported } from "../import-bindings.js";
+import { dirnamePath, joinPath, normalizePath, queriedModulePath, startsRelativePath, } from "../paths.js";
+import { renderPosition } from "../position.js";
+import { nameComponent } from "../ref.js";
 /** The paths below the target root one relative specifier may name, written path first. */
 function candidates(dir, specifier) {
-    if (!specifier.startsWith("./") && !specifier.startsWith("../")) {
+    if (!startsRelativePath(specifier)) {
         return [];
     }
     const path = normalizePath(dir === "" ? specifier : `${dir}/${specifier}`);

package/dist/src/{test-support.js → tests/support.js}

@@ -5,8 +5,8 @@
  * another such file, so it is judged with the tests: what it references is referenced by
  * test code.
  */
-import { CONVENTION_ROWS, TEST_LIBRARIES, TEST_LIBRARY_SCOPES } from "./convention-rows.js";
-import { packageOfSpecifier } from "./dependencies.js";
+import { CONVENTION_ROWS, TEST_LIBRARIES, TEST_LIBRARY_SCOPES, } from "../entries/convention-rows.js";
+import { packageOfSpecifier } from "../dependencies.js";
 /** The root kind that never takes a file out of test-support code: the skip only withholds. */
 const SKIP_ROOT = "type-error";
 /**
@@ -14,7 +14,9 @@ const SKIP_ROOT = "type-error";
  * convention row reads test files for, and the convention table's test libraries.
  */
 const TEST_PACKAGES = new Set([
-    ...CONVENTION_ROWS.filter((row) => row.testFiles !== undefined).map((row) => row.package),
+    ...CONVENTION_ROWS.filter((row) => row.testFiles !== undefined ||
+        row.testDirectories !== undefined ||
+        row.testRunner !== undefined).map((row) => row.package),
     ...TEST_LIBRARIES,
 ]);
 /**
@@ -161,12 +163,3 @@ export function testSupportFiles(symbols, references, roots, testFiles, evidence
     const support = withoutOutsideUsers(new Set([...onlyTests].filter((path) => carries(onlyTests, path))));
     return { support, testUsed: new Set([...onlyTests].filter((path) => !support.has(path))) };
 }
-/** The references with every one a test-support file makes counted as a test reference. */
-export function supportReferences(references, support) {
-    if (support.size === 0) {
-        return references;
-    }
-    return references.map((reference) => !reference.test && support.has(reference.position.path)
-        ? { ...reference, test: true }
-        : reference);
-}

package/dist/src/type-parameter-reads.js

@@ -5,11 +5,9 @@
  * call's value is what the read reads, whatever member of the constraint the name resolves
  * to. A class's members a constraint requires are interface satisfaction's.
  */
-import { isBinaryExpression, isCallExpression, isIdentifier, isNewExpression, isPropertyAccessExpression, isTypeParameterDeclaration, SyntaxKind, } from "@typescript/native/ast";
+import { isBinaryExpression, isCallExpression, isIdentifier, isNewExpression, isPropertyAccessExpression, isSourceFile, isTypeParameterDeclaration, SyntaxKind, } from "@typescript/native/ast";
 import { SymbolFlags } from "@typescript/native/sync";
-import { nodeKey } from "./inventory.js";
-import { renderPosition } from "./position.js";
-import { isAnswered } from "./query.js";
+import { isAnswered, UNANSWERED } from "./query.js";
 /** How deep a parameter's type is matched against the type a call passes: `readonly T[]` is one level. */
 const MATCH_DEPTH = 3;
 /** The name a call reaches one generic by: its own, or that of what holds it. */
@@ -26,147 +24,188 @@ function assignedTo(access) {
         parent.operatorToken.kind === SyntaxKind.EqualsToken &&
         parent.left === access);
 }
-/**
- * The references the reads through type-parameter-typed values of one project's own files
- * make to the members of the types its calls pass, each made by the declaration holding
- * the read.
- */
-export function typeParameterReads(project, held, chains, root, testFiles) {
-    const queries = project.queries;
-    const reads = [];
-    const calls = [];
-    for (const file of project.ownSourceFiles()) {
-        const fileId = held.declarations.get(nodeKey(file, file));
-        if (fileId === undefined) {
-            continue;
+/** Whether one node is written inside a declaration that declares type parameters, itself included. */
+function inGeneric(node) {
+    for (let at = node; !isSourceFile(at); at = at.parent) {
+        if (at.typeParameters !== undefined) {
+            return true;
         }
-        const visit = (node, from, generic) => {
-            const holder = held.declarations.get(nodeKey(file, node)) ?? from;
-            const inside = generic ||
-                node.typeParameters !== undefined;
-            if (inside &&
-                isPropertyAccessExpression(node) &&
-                isIdentifier(node.name) &&
-                !assignedTo(node)) {
-                reads.push({ file, from: holder, access: node });
-            }
-            if (isCallExpression(node) || isNewExpression(node)) {
-                calls.push(node);
-            }
-            node.forEachChild((child) => {
-                visit(child, holder, inside);
-            });
-        };
-        file.forEachChild((child) => {
-            visit(child, fileId, false);
-        });
     }
-    if (reads.length === 0) {
-        return [];
-    }
-    // The reads whose receiver the checker types as a type parameter, by the generic declaring it.
-    const receivers = queries.typesAt(reads.map((read) => read.access.expression));
-    const byGeneric = new Map();
-    reads.forEach((read, at) => {
-        const type = receivers[at];
-        if (type === undefined || !isAnswered(type) || !type.isTypeParameter()) {
-            return;
-        }
-        const symbol = queries.symbolOfType(type);
-        const declaration = symbol === undefined || !isAnswered(symbol)
-            ? undefined
-            : symbol.declarations
-                .map((handle) => project.declarationAt(handle)?.node)
-                .find((node) => node !== undefined && isTypeParameterDeclaration(node));
-        const generic = declaration?.parent;
-        if (generic !== undefined) {
-            byGeneric.set(generic, [...(byGeneric.get(generic) ?? []), { read, parameter: type }]);
-        }
-    });
-    if (byGeneric.size === 0) {
-        return [];
-    }
-    /** The types `instantiated` holds where `declared` holds `parameter`, matched part for part. */
-    const passedFor = (parameter, declared, instantiated, depth) => {
-        if (declared.id === parameter.id) {
-            return [instantiated];
-        }
-        if (depth >= MATCH_DEPTH) {
-            return [];
-        }
-        const a = queries.typeArguments(declared);
-        const b = queries.typeArguments(instantiated);
-        if (!isAnswered(a) || !isAnswered(b) || a.length !== b.length) {
-            return [];
-        }
-        return a.flatMap((one, at) => {
-            const other = b[at];
-            return other === undefined ? [] : passedFor(parameter, one, other, depth + 1);
-        });
-    };
-    // Only a call spelling a generic's name is resolved: one request each.
-    const spelled = new Set([...byGeneric.keys()].flatMap((generic) => nameOf(generic) ?? []));
-    const found = new Map();
-    for (const call of calls) {
-        const callee = call.expression;
-        const written = isIdentifier(callee)
-            ? callee.text
-            : isPropertyAccessExpression(callee) && isIdentifier(callee.name)
-                ? callee.name.text
-                : undefined;
-        if (written === undefined || !spelled.has(written)) {
-            continue;
-        }
-        const resolved = queries.resolvedSignature(call);
-        if (resolved === undefined || !isAnswered(resolved) || resolved.declaration === undefined) {
-            continue;
-        }
-        const generic = project.declarationAt(resolved.declaration)?.node;
-        const pending = generic === undefined ? undefined : byGeneric.get(generic);
-        const declared = pending === undefined ? undefined : queries.genericOf(resolved);
-        if (pending === undefined || declared === undefined || !isAnswered(declared)) {
-            continue;
-        }
-        const count = (generic?.parameters ?? []).length;
-        for (const { read, parameter } of pending) {
-            const passed = [];
-            for (let at = 0; at < count; at += 1) {
-                const own = queries.parameterType(declared, at);
-                const given = queries.typeAtPosition(resolved, at);
-                if (own !== undefined && isAnswered(own) && isAnswered(given)) {
-                    passed.push(...passedFor(parameter, own, given, 0));
+    return false;
+}
+/**
+ * The reads the reads through type-parameter-typed values of a side's files make of the
+ * members of the types its calls pass, each made by the declaration holding the read. A
+ * question the checker leaves unanswered holds every member the read's name spells.
+ */
+export const typeParameterReads = {
+    start() {
+        const reads = [];
+        const calls = [];
+        return {
+            visit(node, { file, from }) {
+                if (isPropertyAccessExpression(node) &&
+                    isIdentifier(node.name) &&
+                    !assignedTo(node) &&
+                    inGeneric(node)) {
+                    reads.push({ file, from, access: node });
                 }
-            }
-            const name = read.access.name.text;
-            const position = renderPosition(read.file, root, read.access.name.getStart());
-            for (const type of passed) {
-                const parts = type.isUnionType() ? queries.constituents(type) : [type];
-                for (const part of isAnswered(parts) ? parts : []) {
-                    const owner = queries.symbolOfType(part);
-                    if (!isAnswered(owner) ||
-                        owner === undefined ||
-                        (owner.flags & SymbolFlags.Class) !== 0) {
+                if (isCallExpression(node) || isNewExpression(node)) {
+                    calls.push(node);
+                }
+            },
+            reads({ project, chains }) {
+                const out = [];
+                if (reads.length === 0) {
+                    return out;
+                }
+                const queries = project.queries;
+                const hold = (read) => {
+                    out.push({ kind: "held", from: read.from, names: [read.access.name.text] });
+                };
+                // The reads whose receiver the checker types as a type parameter, by the generic declaring it.
+                const receivers = queries.typesAt(reads.map((read) => read.access.expression));
+                const byGeneric = new Map();
+                reads.forEach((read, at) => {
+                    const type = receivers[at];
+                    if (type === UNANSWERED) {
+                        hold(read);
+                        return;
+                    }
+                    if (type?.isTypeParameter() !== true) {
+                        return;
+                    }
+                    const symbol = queries.symbolOfType(type);
+                    if (symbol === UNANSWERED) {
+                        hold(read);
+                        return;
+                    }
+                    const declaration = symbol === undefined
+                        ? undefined
+                        : symbol.declarations
+                            .map((handle) => project.declarationAt(handle)?.node)
+                            .find((node) => node !== undefined && isTypeParameterDeclaration(node));
+                    const generic = declaration?.parent;
+                    if (generic !== undefined) {
+                        byGeneric.set(generic, [...(byGeneric.get(generic) ?? []), { read, parameter: type }]);
+                    }
+                });
+                if (byGeneric.size === 0) {
+                    return out;
+                }
+                /** The types `instantiated` holds where `declared` holds `parameter`, matched part for part. */
+                const passedFor = (read, parameter, declared, instantiated, depth) => {
+                    if (declared.id === parameter.id) {
+                        return [instantiated];
+                    }
+                    if (depth >= MATCH_DEPTH) {
+                        return [];
+                    }
+                    const a = queries.typeArguments(declared);
+                    const b = queries.typeArguments(instantiated);
+                    if (!isAnswered(a) || !isAnswered(b)) {
+                        hold(read);
+                        return [];
+                    }
+                    if (a.length !== b.length) {
+                        return [];
+                    }
+                    return a.flatMap((one, at) => {
+                        const other = b[at];
+                        return other === undefined ? [] : passedFor(read, parameter, one, other, depth + 1);
+                    });
+                };
+                // Only a call spelling a generic's name is resolved: one request each.
+                const bySpelling = new Map();
+                for (const [generic, pending] of byGeneric) {
+                    const name = nameOf(generic);
+                    if (name !== undefined) {
+                        bySpelling.set(name, [
+                            ...(bySpelling.get(name) ?? []),
+                            ...pending.map((one) => one.read),
+                        ]);
+                    }
+                }
+                const found = new Map();
+                for (const call of calls) {
+                    const callee = call.expression;
+                    const written = isIdentifier(callee)
+                        ? callee.text
+                        : isPropertyAccessExpression(callee) && isIdentifier(callee.name)
+                            ? callee.name.text
+                            : undefined;
+                    const spelledBy = written === undefined ? undefined : bySpelling.get(written);
+                    if (spelledBy === undefined) {
+                        continue;
+                    }
+                    const resolved = queries.resolvedSignature(call);
+                    if (resolved === UNANSWERED) {
+                        spelledBy.forEach(hold);
                         continue;
                     }
-                    const properties = queries.propertiesOf(part);
-                    for (const property of isAnswered(properties) ? properties : []) {
-                        if (property.name !== name) {
-                            continue;
+                    if (resolved?.declaration === undefined) {
+                        continue;
+                    }
+                    const generic = project.declarationAt(resolved.declaration)?.node;
+                    const pending = generic === undefined ? undefined : byGeneric.get(generic);
+                    const declared = pending === undefined ? undefined : queries.genericOf(resolved);
+                    if (declared === UNANSWERED) {
+                        pending?.forEach((one) => {
+                            hold(one.read);
+                        });
+                        continue;
+                    }
+                    if (pending === undefined || declared === undefined) {
+                        continue;
+                    }
+                    const count = (generic?.parameters ?? []).length;
+                    for (const { read, parameter } of pending) {
+                        const passed = [];
+                        for (let at = 0; at < count; at += 1) {
+                            const own = queries.parameterType(declared, at);
+                            const given = queries.typeAtPosition(resolved, at);
+                            if (own === UNANSWERED || given === UNANSWERED) {
+                                hold(read);
+                            }
+                            else if (own !== undefined) {
+                                passed.push(...passedFor(read, parameter, own, given, 0));
+                            }
                         }
-                        for (const to of chains.declarationsOf(property)) {
-                            found.set(`${read.from}\u0000${to}\u0000${String(read.access.name.pos)}`, {
-                                from: read.from,
-                                to,
-                                position,
-                                use: "read",
-                                resolution: "batch",
-                                test: testFiles.has(position.path),
-                            });
+                        const name = read.access.name.text;
+                        for (const type of passed) {
+                            const parts = type.isUnionType() ? queries.constituents(type) : [type];
+                            for (const part of isAnswered(parts) ? parts : [type]) {
+                                const owner = queries.symbolOfType(part);
+                                const properties = queries.propertiesOf(part);
+                                if (owner === UNANSWERED || properties === UNANSWERED) {
+                                    hold(read);
+                                    continue;
+                                }
+                                if (owner === undefined || (owner.flags & SymbolFlags.Class) !== 0) {
+                                    continue;
+                                }
+                                for (const property of properties) {
+                                    if (property.name !== name) {
+                                        continue;
+                                    }
+                                    for (const to of chains.declarationsOf(property)) {
+                                        found.set(`${read.from}\u0000${to}\u0000${String(read.access.name.pos)}`, {
+                                            kind: "named",
+                                            from: read.from,
+                                            to,
+                                            file: read.file,
+                                            at: read.access.name,
+                                            use: "read",
+                                            via: "batch",
+                                        });
+                                    }
+                                }
+                            }
                         }
                     }
                 }
-            }
-        }
-    }
-    return [...found.values()];
-}
+                return [...out, ...found.values()];
+            },
+        };
+    },
+};