@lzehrung/codegraph 2.4.0 → 3.0.1

package/dist/graphs/symbol-graph-detailed/receiver-calls.js

@@ -1,7 +1,9 @@
 import { readFileSync } from "node:fs";
 import { findCommentEnd } from "../../impact/call-compatibility/text-scanner.js";
 import { isGoExportedMemberName } from "../../indexer/declaration-visibility.js";
+import { hasSeparateMemberScopes, inheritsMemberOverloads, selectMember, } from "../../indexer/member-selection.js";
 import { SymbolKind } from "../../indexer/types.js";
+import { supportForFileWithoutHeaderSample } from "../../languages.js";
 import { isJsTsLanguage } from "../../languages/js-family.js";
 import { sliceText } from "../../util/ast.js";
 import { foldPhpIdentifierCase, XID_IDENTIFIER_SOURCE } from "../../util/identifiers.js";
@@ -16,6 +18,7 @@ const STATIC_MEMBER_LANGUAGES = {
     java: true,
     js: true,
     php: true,
+    ruby: true,
     swift: true,
     ts: true,
     tsx: true,
@@ -280,8 +283,6 @@ const LANGUAGE_CONSTRUCTION_FORMS = {
     tsx: { newExpression: true },
     zig: { compositeLiteral: true },
 };
-/** Guards against a cyclic or pathological declared hierarchy. */
-const MAX_SUPERTYPE_DEPTH = 16;
 /**
  * Resolves the receiver and member-name nodes of a call, or null when the call has no
  * receiver or its shape is not a member access. `callee` is the call's resolved callee
@@ -667,7 +668,7 @@ function bindingValueExpression(node) {
     ]);
     return node.namedChildren.find((child) => expressionTypes.has(child.type)) ?? null;
 }
-function declaredTypeNameNode(node, sup) {
+export function declaredTypeNameNode(node, sup) {
     const typeField = node.childForFieldName("type");
     if (typeField)
         return unwrapNamedType(typeField, sup) ?? typeField;
@@ -677,6 +678,8 @@ function declaredTypeNameNode(node, sup) {
         child.type === "type");
     if (typedChild)
         return unwrapNamedType(typedChild, sup) ?? typedChild;
+    if (node.type === "let_declaration")
+        return null;
     const ids = node.namedChildren.filter((child) => isReceiverNameNode(sup, child.type) || child.type === "type_identifier" || child.type === "name");
     if (ids.length >= 2)
         return unwrapNamedType(ids[0], sup);
@@ -758,6 +761,9 @@ function bindingProof(node, receiverName, source, sup) {
     const annotated = annotation ? (unwrapNamedType(annotation, sup) ?? typescriptImportTypeQuery(annotation)) : null;
     if (annotated)
         return { status: "declared", node: annotated };
+    const declared = declaredTypeNameNode(node, sup);
+    if (declared)
+        return { status: "declared", node: declared };
     const typeNode = constructionTypeFromBinding(node, receiverName, source, sup);
     if (typeNode)
         return { status: "type", node: typeNode };
@@ -767,7 +773,7 @@ function isSkippableBindingContainer(node, receiver) {
     return BINDING_CONTAINER_TYPES.has(node.type) && !containsIndex(node, receiver.startIndex);
 }
 function findPriorConstructorInContainer(node, receiver, receiverName, source, sup) {
-    let constructor = null;
+    let typeEvidence = null;
     let sawUnproven = false;
     let declared = false;
     const visit = (current) => {
@@ -777,16 +783,16 @@ function findPriorConstructorInContainer(node, receiver, receiverName, source, s
             return true;
         const proof = bindingProof(current, receiverName, source, sup);
         if (proof.status === "declared") {
-            constructor = proof.node;
-            declared = true;
+            typeEvidence = { typeNode: proof.node, origin: "declared-type" };
+            declared = isJsTsLanguage(sup.id);
             return true;
         }
         // A later assignment to an annotated binding cannot change its declared type.
         if (declared && proof.status !== "none")
             return true;
         if (proof.status === "unproven") {
-            if (constructor) {
-                constructor = null;
+            if (typeEvidence) {
+                typeEvidence = null;
                 return false;
             }
             sawUnproven = true;
@@ -794,14 +800,14 @@ function findPriorConstructorInContainer(node, receiver, receiverName, source, s
         }
         if (proof.status === "type") {
             if (sawUnproven) {
-                constructor = null;
+                typeEvidence = null;
                 return false;
             }
-            if (constructor && sliceText(constructor, source) !== sliceText(proof.node, source)) {
-                constructor = null;
+            if (typeEvidence && sliceText(typeEvidence.typeNode, source) !== sliceText(proof.node, source)) {
+                typeEvidence = null;
                 return false;
             }
-            constructor = proof.node;
+            typeEvidence = { typeNode: proof.node, origin: "constructor" };
             return true;
         }
         for (const child of current.namedChildren) {
@@ -811,7 +817,7 @@ function findPriorConstructorInContainer(node, receiver, receiverName, source, s
         return true;
     };
     visit(node);
-    return constructor;
+    return typeEvidence;
 }
 function bindingContainerDeclaresNameBefore(node, receiver, receiverName, source, sup) {
     const visit = (current) => {
@@ -853,23 +859,21 @@ function findVisiblePriorConstructor(receiver, receiverName, source, sup) {
     }
     return findPriorConstructorInContainer(rootOf(receiver), receiver, receiverName, source, sup);
 }
-/**
- * Resolves the node naming the type a receiver expression was constructed from, or
- * null when no constructor is proven for it. Shared with detailed symbol-graph call
- * extraction so `goto` and resolved `calls` edges accept the same receiver forms.
- * A bare name is unit-struct construction only while no local binding of the same
- * name shadows it; a shadowing binding is a value whose type must come from the
- * binding, never from the type the name also spells.
- */
-export function receiverConstructorExpression(obj, source, sup) {
+/** Constructor or declared type visible at a receiver, without resolving its owner. */
+function receiverTypeEvidence(obj, source, sup) {
     const direct = constructionTypeName(obj, source, sup);
     if (!isReceiverNameNode(sup, obj.type))
-        return direct;
+        return direct ? { typeNode: direct, origin: "constructor" } : null;
     const receiverName = sliceText(obj, source);
-    if (direct && !bindsLocalValue(obj, receiverName, source, sup))
-        return direct;
+    if (direct && !bindsLocalValue(obj, receiverName, source, sup)) {
+        return { typeNode: direct, origin: "constructor" };
+    }
     return findVisiblePriorConstructor(obj, receiverName, source, sup);
 }
+/** Syntax naming the type of a constructed or declared receiver. */
+export function receiverConstructorExpression(obj, source, sup) {
+    return receiverTypeEvidence(obj, source, sup)?.typeNode ?? null;
+}
 /** Identifier segments in a C++ qualified name, excluding template arguments. */
 export function cppQualifiedNameSegments(node, source) {
     return cppQualifiedTextSegments(sliceText(node, source));
@@ -1024,6 +1028,10 @@ export function cppOutOfLineMemberDeclarationNode(definitionNameNode, localName,
     return declarations.length === 1 ? declarations[0] : null;
 }
 export function nodeDeclaresStatic(node, source) {
+    if (node.type === "singleton_method") {
+        const receiver = node.childForFieldName("object") ?? node.childForFieldName("receiver") ?? node.namedChildren[0];
+        return !!receiver && sliceText(receiver, source).trim() === "self";
+    }
     if (node.type === "static" || node.type === "static_modifier")
         return true;
     if (node.type === "storage_class_specifier" || node.type === "modifier" || node.type === "property_modifier") {
@@ -1125,48 +1133,48 @@ export function csharpDottedNameRoot(node) {
         return null;
     return csharpDottedNameRoot(object);
 }
-/**
- * Classifies a receiver as the declaring type, a supertype, or a named/constructed type.
- * Returns null when the receiver cannot be proven.
- * Named-local constructor lookup is memoized per enclosing function and receiver text.
- */
-export function classifyReceiver(sup, receiver, source, proofCache, cacheScope, accessNode, hasLexicalBinding) {
+/** Classify a receiver from syntax and consumer-proven import bindings. */
+export function classifyReceiver(sup, receiver, source, proofCache, cacheScope, accessNode, hasLexicalBinding, classifyImport) {
     const text = receiverKeywordText(sup, receiver, source, hasLexicalBinding);
     if (!text)
-        return null;
+        return { kind: "unknown", receiver };
     const keywordKind = keywordReceiverKind(sup.id, text);
     if (keywordKind) {
         if (keywordReceiverCrossesDynamicBoundary(sup, accessNode))
-            return null;
+            return { kind: "unknown", receiver };
         const memberScope = keywordReceiverMemberScope(sup, text, accessNode, source);
         return keywordKind === "own" ? { kind: "own-type", memberScope } : { kind: "supertype", memberScope };
     }
     const receiverIsName = isReceiverNameNode(sup, receiver.type);
-    const cacheKey = `${cacheScope}\u0000${text}`;
-    let proof = proofCache.get(cacheKey);
+    const importProof = receiverIsName ? classifyImport?.(text, receiver) : null;
+    if (importProof === "module-import")
+        return { kind: "module-import", receiver };
+    const cacheKey = proofCache ? cacheScope + "\u0000" + text : "";
+    let proof = proofCache?.get(cacheKey);
     if (!proof) {
-        const constructed = receiverConstructorExpression(receiver, source, sup);
+        const typeEvidence = receiverTypeEvidence(receiver, source, sup);
         proof = {
-            constructed,
-            locallyBound: !constructed && receiverIsName && bindsLocalValue(receiver, text, source, sup),
+            typeEvidence,
+            locallyBound: !typeEvidence && receiverIsName && bindsLocalValue(receiver, text, source, sup),
         };
-        proofCache.set(cacheKey, proof);
+        proofCache?.set(cacheKey, proof);
     }
-    if (proof.constructed) {
+    if (proof.typeEvidence) {
+        const { typeNode, origin } = proof.typeEvidence;
         return {
             kind: "named-type",
-            typeName: sliceText(proof.constructed, source),
-            typeNode: proof.constructed,
+            proof: origin,
+            typeName: sliceText(typeNode, source),
+            typeNode,
             memberScope: hasStaticMemberDistinction(sup.id) ? "instance" : "any",
-            constructed: true,
+            constructed: origin === "constructor",
         };
     }
-    if (!receiverIsName)
-        return null;
-    // A name bound by a local or parameter is a value, not a type. Without this guard
-    // `Example::shared()` would still be attributed to a colliding parameter named Example.
-    if (proof.locallyBound)
-        return null;
+    if (importProof === "static-type") {
+        return { kind: "named-type", proof: "static-type", typeName: text, typeNode: receiver, memberScope: "static" };
+    }
+    if (!receiverIsName || proof.locallyBound)
+        return { kind: "unknown", receiver };
     // Dotted `Cfg.load()` is not proof in languages where the identifier may be a
     // value. Type-scoped `::` is one named-type proof; C# `Box.Left()` is another
     // because a capitalized unbound name is the static type receiver. Ruby
@@ -1181,9 +1189,10 @@ export function classifyReceiver(sup, receiver, source, proofCache, cacheScope,
         // The named type must still resolve to a members-declaring definition
         // before any call edge is recorded, so a name alone never invents a target.
         if (!capitalizedTypeReceiverName(sup, receiver, text))
-            return null;
+            return { kind: "unknown", receiver };
         return {
             kind: "named-type",
+            proof: "static-type",
             typeName: text,
             typeNode: receiver,
             memberScope: UNBOUND_INSTANCE_CALL_LANGUAGE_IDS[sup.id] ? "any" : "static",
@@ -1191,6 +1200,7 @@ export function classifyReceiver(sup, receiver, source, proofCache, cacheScope,
     }
     return {
         kind: "named-type",
+        proof: "static-type",
         typeName: text,
         typeNode: receiver,
         memberScope: hasStaticMemberDistinction(sup.id) && typeScoped ? "static" : "any",
@@ -1214,6 +1224,7 @@ const STATIC_TYPE_NAME_RECEIVER_LANGUAGE_IDS = {
     js: true,
     kotlin: true,
     ts: true,
+    ruby: true,
     tsx: true,
 };
 /** Whether a receiver name is capitalized like a type in a capitalized-name language. */
@@ -1456,12 +1467,95 @@ function callSiteKey(callerId, site) {
     const { start, end } = site.range;
     return `${callerId}\u0000${site.file}\u0000${start.line}:${start.column}:${start.index ?? ""}-${end.line}:${end.column}:${end.index ?? ""}`;
 }
+/** Prove overriding member pairs only for hierarchy receiver calls. */
+export async function inheritedReceiverMemberSignatures(graph, candidates, definitions, ownerAnchors, accessibleMembers, languageExtensions, sameParameterTypes) {
+    const signatures = new Map();
+    const membersByOwner = new Map();
+    const ownerByMember = new Map();
+    const parentsByOwner = new Map();
+    for (const edge of graph.edges) {
+        if (edge.label === "member_of") {
+            ownerByMember.set(edge.from, edge.to);
+            if (definitions.has(edge.from)) {
+                const members = membersByOwner.get(edge.to) ?? [];
+                members.push(edge.from);
+                membersByOwner.set(edge.to, members);
+            }
+        }
+        else if (edge.label && HIERARCHY_LABELS[edge.label]) {
+            const parents = parentsByOwner.get(edge.from) ?? [];
+            parents.push(edge.to);
+            parentsByOwner.set(edge.from, parents);
+        }
+    }
+    for (const [owner, accessible] of accessibleMembers) {
+        const members = membersByOwner.get(owner) ?? [];
+        for (const id of accessible)
+            if (definitions.has(id) && !members.includes(id))
+                members.push(id);
+        membersByOwner.set(owner, members);
+    }
+    const checkedPairs = new Set();
+    const checkedGroups = new Set();
+    const separator = "\0";
+    for (const candidate of candidates) {
+        if (!inheritsMemberOverloads(supportForFileWithoutHeaderSample(candidate.site.file, languageExtensions)?.id ?? "")) {
+            continue;
+        }
+        const rawOwner = candidate.ownerId ?? ownerByMember.get(candidate.callerId);
+        if (!rawOwner)
+            continue;
+        const owner = ownerAnchors.get(rawOwner) ?? rawOwner;
+        // Override pairs are a fact of the declarations, not of this call: an override that rejects
+        // the argument count still hides the base declaration it overrides.
+        const group = `${owner}\0${candidate.memberName}\0${candidate.viaSupertypes}`;
+        if (checkedGroups.has(group))
+            continue;
+        checkedGroups.add(group);
+        let level = candidate.viaSupertypes ? (parentsByOwner.get(owner) ?? []) : [owner];
+        const seen = new Set([owner]);
+        const shallower = [];
+        for (let depth = 0; depth < 16 && level.length; depth += 1) {
+            const current = [];
+            const next = [];
+            for (const id of level) {
+                for (const memberId of membersByOwner.get(id) ?? []) {
+                    if (graph.nodes.get(memberId)?.name === candidate.memberName)
+                        current.push(memberId);
+                }
+                for (const parent of parentsByOwner.get(id) ?? []) {
+                    if (seen.has(parent))
+                        continue;
+                    seen.add(parent);
+                    next.push(parent);
+                }
+            }
+            for (const derivedId of shallower) {
+                const derived = definitions.get(derivedId);
+                for (const inheritedId of current) {
+                    const pair = derivedId + separator + inheritedId;
+                    if (checkedPairs.has(pair))
+                        continue;
+                    checkedPairs.add(pair);
+                    if (!(await sameParameterTypes(derived, definitions.get(inheritedId))))
+                        continue;
+                    const inherited = signatures.get(derivedId) ?? new Set();
+                    inherited.add(inheritedId);
+                    signatures.set(derivedId, inherited);
+                }
+            }
+            shallower.push(...current);
+            level = next;
+        }
+    }
+    return signatures;
+}
 /**
  * Records proven `calls` edges for deferred receiver invocations.
  * Ambiguous names at a level stop the walk.
  * `super`/`base`/`parent` follow class `extends` ancestors only.
  */
-export function emitReceiverCallEdges(graph, candidates, recordEdge, memberScopes = new Map(), nodeAliases = new Map(), memberArities = new Map(), ownerAnchors = new Map(), accessibleMembers = new Map(), fileHiddenMemberIds = new Set(), acceptsCallTarget) {
+export function emitReceiverCallEdges(graph, candidates, recordEdge, memberScopes = new Map(), nodeAliases = new Map(), memberArities = new Map(), ownerAnchors = new Map(), accessibleMembers = new Map(), fileHiddenMemberIds = new Set(), acceptsCallTarget, callableIdentities = new Map(), languageExtensions, overridingSignatures, isReceiverMemberVisible) {
     if (!candidates.length)
         return [];
     const membersByOwner = new Map();
@@ -1493,10 +1587,49 @@ export function emitReceiverCallEdges(graph, candidates, recordEdge, memberScope
         for (const memberId of memberIds)
             pushUnique(membersByOwner, ownerId, memberId);
     }
-    const nextOwners = (ownerId, viaSupertypes) => {
-        if (!viaSupertypes)
-            return supertypesByOwner.get(ownerId) ?? [];
-        return (classAncestorsByOwner.get(ownerId) ?? []).filter((id) => graph.nodes.get(id)?.kind === "class");
+    let activeCandidate;
+    const facts = new Map();
+    for (const [ownerId, ids] of membersByOwner) {
+        for (const id of ids) {
+            const canonicalId = canonicalMemberId(id, nodeAliases);
+            const indexed = callableIdentities.get(id) ?? callableIdentities.get(canonicalId);
+            const bounds = memberArities.get(id) ?? memberArities.get(canonicalId);
+            facts.set(id, {
+                key: indexed?.key ?? canonicalId,
+                owner: indexed?.owner ?? ownerId,
+                kind: indexed?.kind ?? "function",
+                arity: bounds ? { minArgs: bounds.min, maxArgs: bounds.max } : null,
+                ...(indexed?.role ? { role: indexed.role } : {}),
+            });
+        }
+    }
+    const model = {
+        ownerKey: (id) => id,
+        members: (id) => membersByOwner.get(id) ?? [],
+        supertypes: (id, classOnly) => {
+            if (!classOnly)
+                return supertypesByOwner.get(id) ?? [];
+            return (classAncestorsByOwner.get(id) ?? []).filter((base) => graph.nodes.get(base)?.kind === "class");
+        },
+        name: (id) => graph.nodes.get(id)?.name ?? graph.nodes.get(canonicalMemberId(id, nodeAliases))?.name ?? "",
+        key: (id) => facts.get(id)?.key ?? canonicalMemberId(id, nodeAliases),
+        callable: (id) => facts.get(id),
+        scope: (id) => memberScopes.get(id) ?? memberScopes.get(canonicalMemberId(id, nodeAliases)) ?? "any",
+        visible: (id, useFile) => {
+            const canonicalId = canonicalMemberId(id, nodeAliases);
+            const node = graph.nodes.get(id) ?? graph.nodes.get(canonicalId);
+            if (!node || (node.kind !== "function" && !node.callable))
+                return false;
+            if (isReceiverMemberVisible && !isReceiverMemberVisible(canonicalId, useFile))
+                return false;
+            if ((fileHiddenMemberIds.has(id) || fileHiddenMemberIds.has(canonicalId)) &&
+                fileIdentityKey(node.file) !== fileIdentityKey(useFile))
+                return false;
+            return (!activeCandidate.goPackagePeerFiles ||
+                isGoExportedMemberName("go", node.name) ||
+                activeCandidate.goPackagePeerFiles.has(node.file));
+        },
+        sameSignature: (a, b) => overridingSignatures?.get(a)?.has(b) ?? false,
     };
     const callTargetsBySite = new Map();
     for (const edge of graph.edges) {
@@ -1525,48 +1658,42 @@ export function emitReceiverCallEdges(graph, candidates, recordEdge, memberScope
         // coalesced type identity so lookup starts on the whole member set.
         const owner = ownerAnchors.get(rawOwner) ?? rawOwner;
         const memberScope = candidate.memberScope ?? inferCallMemberScope(candidate.site, sourceCache);
-        let level = candidate.viaSupertypes ? nextOwners(owner, true) : [owner];
-        const visited = new Set(level);
-        let receiverDisposition = "none";
-        for (let depth = 0; depth < MAX_SUPERTYPE_DEPTH && level.length; depth += 1) {
-            const lookup = provenMemberTarget(graph, membersByOwner, level, candidate, memberScope, memberScopes, nodeAliases, memberArities, fileHiddenMemberIds, candidate.site.file);
-            if (lookup.status === "unique") {
-                if (acceptsCallTarget && !acceptsCallTarget(lookup.memberId, candidate)) {
-                    receiverDisposition = "ambiguous";
-                    if (existingTargets.size)
-                        rejectedCallSites.add(siteKey);
-                    break;
-                }
+        const languageId = supportForFileWithoutHeaderSample(candidate.site.file, languageExtensions)?.id ?? "";
+        activeCandidate = candidate;
+        const lookup = selectMember([owner], model, {
+            name: candidate.memberName,
+            argumentCount: candidate.argumentCount,
+            scope: memberScope,
+            useFile: candidate.site.file,
+            phpCaseInsensitive: !!candidate.caseInsensitiveMemberName,
+            separateMemberScopes: hasSeparateMemberScopes(languageId),
+            startAtAncestor: candidate.viaSupertypes,
+            inheritOverloads: inheritsMemberOverloads(languageId),
+        });
+        let receiverDisposition = lookup.status === "unique" ? "resolved" : lookup.status;
+        if (lookup.status === "unique") {
+            const memberId = canonicalMemberId(lookup.member, nodeAliases);
+            if (acceptsCallTarget && !acceptsCallTarget(memberId, candidate)) {
+                receiverDisposition = "ambiguous";
+                if (existingTargets.size)
+                    rejectedCallSites.add(siteKey);
+            }
+            else {
                 receiverDisposition = "resolved";
                 const combinedTargets = new Set(existingTargets);
-                combinedTargets.add(lookup.memberId);
+                combinedTargets.add(memberId);
                 if (combinedTargets.size === 1) {
-                    if (existingTargets.size === 0 && recordEdge(candidate.callerId, lookup.memberId, "calls", candidate.site)) {
-                        existingTargets.add(lookup.memberId);
+                    if (!existingTargets.size && recordEdge(candidate.callerId, memberId, "calls", candidate.site)) {
+                        existingTargets.add(memberId);
                         callTargetsBySite.set(siteKey, existingTargets);
                     }
                 }
-                else {
+                else
                     rejectedCallSites.add(siteKey);
-                }
-                break;
             }
-            if (lookup.status === "ambiguous") {
-                receiverDisposition = "ambiguous";
-                if (existingTargets.size)
-                    rejectedCallSites.add(siteKey);
-                break;
-            }
-            const next = [];
-            for (const ownerId of level) {
-                for (const supertype of nextOwners(ownerId, candidate.viaSupertypes)) {
-                    if (visited.has(supertype))
-                        continue;
-                    visited.add(supertype);
-                    next.push(supertype);
-                }
-            }
-            level = next;
+        }
+        else if (lookup.status === "ambiguous" && existingTargets.size) {
+            rejectedCallSites.add(siteKey);
         }
         if (receiverDisposition === "none") {
             if (candidate.fallbackTargetId && !existingTargets.size) {
@@ -1601,62 +1728,4 @@ function canonicalMemberId(id, aliases) {
     }
     return current;
 }
-function memberArityMatches(memberId, argumentCount, memberArities) {
-    if (argumentCount === null)
-        return true;
-    const range = memberArities.get(memberId);
-    // Declaration parameter counts do not prove required/default/variadic call bounds.
-    // An unknown range cannot reject a unique target or eliminate an overload.
-    return !range || (argumentCount >= range.min && (range.max === null || argumentCount <= range.max));
-}
-/**
- * The single callable member named by `candidate` across `owners`.
- * `none` means this depth has no name match and the walk may continue.
- * `ambiguous` means this depth matched the name but could not prove one member,
- * including arity ambiguity, and the walk must stop.
- */
-function provenMemberTarget(graph, membersByOwner, owners, candidate, memberScope, memberScopes, nodeAliases, memberArities, fileHiddenMemberIds, useFile) {
-    const matches = new Set();
-    for (const ownerId of owners) {
-        for (const memberId of membersByOwner.get(ownerId) ?? []) {
-            const canonicalId = canonicalMemberId(memberId, nodeAliases);
-            const node = graph.nodes.get(memberId) ?? graph.nodes.get(canonicalId);
-            if (!node || (node.kind !== "function" && !node.callable))
-                continue;
-            if ((fileHiddenMemberIds.has(memberId) || fileHiddenMemberIds.has(canonicalId)) &&
-                fileIdentityKey(node.file) !== fileIdentityKey(useFile)) {
-                continue;
-            }
-            const nameMatches = candidate.caseInsensitiveMemberName
-                ? foldPhpIdentifierCase(node.name) === foldPhpIdentifierCase(candidate.memberName)
-                : node.name === candidate.memberName;
-            if (!nameMatches)
-                continue;
-            if (candidate.goPackagePeerFiles &&
-                !isGoExportedMemberName("go", node.name) &&
-                !candidate.goPackagePeerFiles.has(node.file)) {
-                continue;
-            }
-            const scope = memberScopes.get(memberId) ?? memberScopes.get(canonicalId);
-            if (memberScope !== "any" && scope !== memberScope)
-                continue;
-            matches.add(canonicalId);
-        }
-    }
-    if (!matches.size)
-        return { status: "none" };
-    if (matches.size === 1) {
-        const [memberId] = matches;
-        if (memberArityMatches(memberId, candidate.argumentCount, memberArities)) {
-            return { status: "unique", memberId: memberId };
-        }
-        return { status: "ambiguous" };
-    }
-    const byArity = candidate.argumentCount === null
-        ? []
-        : [...matches].filter((memberId) => memberArityMatches(memberId, candidate.argumentCount, memberArities));
-    if (byArity.length === 1)
-        return { status: "unique", memberId: byArity[0] };
-    return { status: "ambiguous" };
-}
 //# sourceMappingURL=receiver-calls.js.map