@lzehrung/codegraph 2.3.30 → 2.4.0

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

@@ -1,29 +1,14 @@
 import { readFileSync } from "node:fs";
+import { findCommentEnd } from "../../impact/call-compatibility/text-scanner.js";
+import { isGoExportedMemberName } from "../../indexer/declaration-visibility.js";
 import { SymbolKind } from "../../indexer/types.js";
+import { isJsTsLanguage } from "../../languages/js-family.js";
 import { sliceText } from "../../util/ast.js";
-import { XID_IDENTIFIER_SOURCE } from "../../util/identifiers.js";
-import { getMemberAccessParts, getNavigationExpressionProperty, isMemberAccessNode, isMemberReferencePropertyIdentifier, isReceiverNameNode, } from "../../util/member-access.js";
-const THIS_SUPER_RECEIVERS = { own: ["this"], supertype: ["super"] };
-const SELF_RECEIVERS = { own: ["self"], supertype: ["super"] };
-const RECEIVER_KEYWORDS = {
-    cpp: { own: ["this"], supertype: [] },
-    csharp: { own: ["this"], supertype: ["base"] },
-    go: { own: [], supertype: [] },
-    java: THIS_SUPER_RECEIVERS,
-    js: THIS_SUPER_RECEIVERS,
-    kotlin: THIS_SUPER_RECEIVERS,
-    php: { own: ["$this", "self", "static"], supertype: ["parent"] },
-    python: { own: ["self", "cls"], supertype: [] },
-    ruby: { own: ["self"], supertype: [] },
-    rust: { own: ["self", "Self"], supertype: [] },
-    swift: SELF_RECEIVERS,
-    ts: THIS_SUPER_RECEIVERS,
-    tsx: THIS_SUPER_RECEIVERS,
-    zig: { own: ["self"], supertype: [] },
-};
-const INSTANCE_RECEIVER_KEYWORDS = new Set(["this", "$this"]);
-/** Every language that declares receiver keywords, guarded by the registry-consistency test. */
-export const receiverKeywordLanguageIds = Object.keys(RECEIVER_KEYWORDS);
+import { foldPhpIdentifierCase, XID_IDENTIFIER_SOURCE } from "../../util/identifiers.js";
+import { fileIdentityKey } from "../../util/paths.js";
+import { keywordReceiverKind, ownReceiverMemberScope } from "../../util/member-access-tables.js";
+import { getMemberAccessParts, getNavigationExpressionProperty, isMemberAccessNode, isMemberReferencePropertyIdentifier, isReceiverNameNode, receiverKeywordText, } from "../../util/member-access.js";
+import { declarationMemberArity, findFirstNodeByType, isIdentifierType, PARAMETER_LIST_NODE_TYPES } from "./ast.js";
 /** Languages whose grammar distinguishes static members from instance members. */
 const STATIC_MEMBER_LANGUAGES = {
     cpp: true,
@@ -35,24 +20,68 @@ const STATIC_MEMBER_LANGUAGES = {
     ts: true,
     tsx: true,
 };
+const MEMBER_OVERLOAD_LANGUAGE_IDS = {
+    cpp: true,
+    csharp: true,
+    java: true,
+    kotlin: true,
+    swift: true,
+    ts: true,
+    tsx: true,
+};
+/** Bare calls inside members can target a proven member even without an explicit receiver. */
+const IMPLICIT_SELF_MEMBER_CALL_LANGUAGES = {
+    csharp: true,
+    swift: true,
+};
+/** Whether a bare, receiver-less call inside a member function may target `this`/an inherited member. */
+export function supportsImplicitSelfMemberCalls(languageId) {
+    return !!IMPLICIT_SELF_MEMBER_CALL_LANGUAGES[languageId];
+}
+/** Whether member lookup uses call arity to select or reject same-name declarations. */
+export function supportsReceiverMemberOverloads(languageId) {
+    return !!MEMBER_OVERLOAD_LANGUAGE_IDS[languageId];
+}
 /** Every language with a static-member distinction, guarded by the registry-consistency test. */
 export const staticMemberLanguageIds = Object.keys(STATIC_MEMBER_LANGUAGES);
-/** Languages that emit proven receiver `calls` edges from the shared keyword table. */
-export function supportsReceiverCallEdges(languageId) {
-    return RECEIVER_KEYWORDS[languageId] !== undefined;
-}
-/** Languages where goto and references require proven receivers and do not fall back to a bare name. */
-export function supportsReceiverMemberNavigation(languageId) {
-    return RECEIVER_KEYWORDS[languageId] !== undefined;
+export function hasStaticMemberDistinction(languageId) {
+    return STATIC_MEMBER_LANGUAGES[languageId] !== undefined;
 }
-export function isKeywordReceiver(languageId, receiverName) {
-    const keywords = RECEIVER_KEYWORDS[languageId];
-    if (!keywords)
+/**
+ * Languages whose grammar gives members a static-equivalent scope without a `static` keyword:
+ * a Kotlin member of a `companion object` or a named `object` declaration is reachable as
+ * `Outer.member()`. Member lookup classifies those members "static" and every other member
+ * "instance", matching the keyword-`static` languages.
+ */
+const STATIC_EQUIVALENT_MEMBER_CONTAINERS = {
+    kotlin: { companion_object: true, object_declaration: true },
+};
+/**
+ * Whether `node` is lexically declared inside its language's static-equivalent member
+ * container. The nearest enclosing member container decides: a nested type's members belong
+ * to that type, not to an outer `object`.
+ */
+export function declarationIsStaticEquivalent(languageId, node) {
+    const containers = STATIC_EQUIVALENT_MEMBER_CONTAINERS[languageId];
+    if (!containers)
         return false;
-    return keywords.own.includes(receiverName) || keywords.supertype.includes(receiverName);
+    let current = node.parent;
+    while (current) {
+        if (containers[current.type] === true)
+            return true;
+        if (MEMBER_CONTAINER_TYPES[current.type] === true)
+            return false;
+        current = current.parent;
+    }
+    return false;
 }
-export function hasStaticMemberDistinction(languageId) {
-    return STATIC_MEMBER_LANGUAGES[languageId] !== undefined;
+/**
+ * Whether member lookup for `languageId` distinguishes static-equivalent members from
+ * instance members. A bare type-name receiver restricts lookup to the static-equivalent
+ * scope exactly when this holds; otherwise every member must stay reachable.
+ */
+export function supportsStaticMemberScope(languageId) {
+    return (STATIC_MEMBER_LANGUAGES[languageId] !== undefined || STATIC_EQUIVALENT_MEMBER_CONTAINERS[languageId] !== undefined);
 }
 /**
  * Call nodes that carry the receiver and the member name on the call node itself
@@ -84,6 +113,25 @@ const MEMBER_CONTAINER_TYPES = {
     struct_specifier: true,
     trait_declaration: true,
     trait_item: true,
+    type_alias_declaration: true,
+    // C/C++ unions declare members exactly like structs (tree-sitter-cpp captures
+    // union names and classifies them as classes).
+    union_specifier: true,
+};
+const CPP_MEMBER_CONTAINER_TYPES = {
+    class_specifier: true,
+    struct_specifier: true,
+    union_specifier: true,
+};
+/**
+ * Container nodes whose declared members belong to the *enclosing* member container for
+ * direct-member lookup, rather than forming a separate nested type. Kotlin's unnamed
+ * `companion object { ... }` block is the language's static-member mechanism: `create()`
+ * declared inside one is a member of the enclosing class, reachable as `Outer.create()`,
+ * not a member of a distinct "Companion" type the indexer would need to name separately.
+ */
+export const TRANSPARENT_MEMBER_CONTAINER_TYPES = {
+    companion_object: true,
 };
 /** Nodes holding a call's argument list across the supported grammars. */
 export const CALL_ARGUMENT_NODE_TYPES = {
@@ -99,6 +147,16 @@ const HIERARCHY_LABELS = {
     mixin: true,
     trait: true,
 };
+const UNPROVEN_HERITAGE_EXPRESSION_TYPES = new Set([
+    "binary_expression",
+    "call_expression",
+    "new_expression",
+    "subscript_expression",
+    "ternary_expression",
+]);
+export function isUnprovenHeritageExpression(node) {
+    return UNPROVEN_HERITAGE_EXPRESSION_TYPES.has(node.type);
+}
 /**
  * Nodes that bind a value name across the supported grammars: locals, parameters,
  * and assignment targets. A receiver naming one of these is a value, not a type.
@@ -108,6 +166,9 @@ const VALUE_BINDING_TYPES = {
     assignment_expression: true,
     assignment_statement: true,
     class_parameter: true,
+    // C/C++ local variable statement (`Box b;`, `Box* p = raw;`); the declared type sits
+    // beside the declarator, unlike other grammars' dedicated `variable_declaration` node.
+    declaration: true,
     formal_parameter: true,
     init_declarator: true,
     let_declaration: true,
@@ -123,21 +184,6 @@ const VALUE_BINDING_TYPES = {
     variable_declaration: true,
     variable_declarator: true,
 };
-/**
- * Parameter lists whose identifier children are value bindings (Ruby has no wrapping param node).
- * Union of the receiver-call and call-compatibility lists so Kotlin `function_value_parameters`
- * and Ruby `block_parameters` are both recognized.
- */
-export const PARAMETER_LIST_NODE_TYPES = {
-    block_parameters: true,
-    formal_parameters: true,
-    function_parameter_clause: true,
-    function_value_parameters: true,
-    lambda_parameters: true,
-    method_parameters: true,
-    parameter_list: true,
-    parameters: true,
-};
 /**
  * Access nodes whose syntax is type-scoped (`::`), not dotted member access.
  * A dotted identifier is never itself proof of a type.
@@ -213,6 +259,8 @@ const BINDING_DECLARATION_TYPES = new Set([
     "property_declaration",
     "local_variable_declaration",
     "local_declaration_statement",
+    // C/C++ local variable statement, e.g. `Box b;`, `Box* p = raw;`, `Box w{5};`.
+    "declaration",
 ]);
 const RUBY_CONSTANT_SOURCE = String.raw `(?=\p{Lu})${XID_IDENTIFIER_SOURCE}`;
 /** Proven construction forms that name a receiver's type, keyed by language. */
@@ -226,7 +274,7 @@ const LANGUAGE_CONSTRUCTION_FORMS = {
     php: { newExpression: true },
     python: { capitalizedCall: true },
     ruby: { rubyNew: true },
-    rust: { capitalizedCall: true, rustUnitStruct: true },
+    rust: { capitalizedCall: true, rustUnitStruct: true, compositeLiteral: true },
     swift: { capitalizedCall: true },
     ts: { newExpression: true },
     tsx: { newExpression: true },
@@ -270,12 +318,13 @@ export function receiverCallAccess(sup, callNode, callee) {
     return { accessNode, receiver, property };
 }
 /**
- * Identifier a binding node declares: a `name` field, a nested C/C++ declarator,
- * an assignment left-hand side, or the last identifier child (C++ parameters hide
- * the name after the type).
+ * Identifier a binding node declares: a `name` or `pattern` field, a nested C/C++
+ * declarator, an assignment left-hand side, or the last identifier child (C++
+ * parameters hide the name after the type). Rust spells parameter and `let` names in
+ * the `pattern` field, where the last-identifier fallback would pick the declared type.
  */
 function bindingIdentifier(node, sup) {
-    const named = node.childForFieldName("name");
+    const named = node.childForFieldName("name") ?? node.childForFieldName("pattern");
     if (named && (isReceiverNameNode(sup, named.type) || named.type === "field_identifier")) {
         return named;
     }
@@ -356,6 +405,17 @@ function containsIndex(node, index) {
     return node.startIndex <= index && node.endIndex >= index;
 }
 function constructorNameNode(node, sup) {
+    // A dedicated `type` field (C#'s `object_creation_expression`, C/C++'s `new_expression`) can
+    // wrap a qualified (`Outer.Inner`) or generic (`Box<int>`) shape the fallback scan below never
+    // matches; a language without that field (TS/PHP's `constructor` field, or none) falls through.
+    const typeField = node.childForFieldName("type");
+    if (typeField) {
+        if (isMemberAccessNode(sup, typeField))
+            return typeField;
+        const unwrapped = unwrapNamedType(typeField, sup);
+        if (unwrapped)
+            return unwrapped;
+    }
     const constructor = node.childForFieldName("constructor") ?? node.child(0);
     if (constructor && isReceiverNameNode(sup, constructor.type)) {
         return constructor;
@@ -367,14 +427,85 @@ function constructorNameNode(node, sup) {
     }
     return null;
 }
+const PHP_OBJECT_CREATION_KEYWORDS = {
+    self: "self",
+    static: "static",
+    parent: "parent",
+};
+export function phpObjectCreationKeyword(node, source, sup) {
+    if (sup.id !== "php")
+        return null;
+    let creation = node;
+    while (creation && creation.type !== "object_creation_expression") {
+        if (creation.type === "method_declaration" ||
+            creation.type === "function_definition" ||
+            creation.type === "class_declaration") {
+            return null;
+        }
+        creation = creation.parent;
+    }
+    if (!creation)
+        return null;
+    const nameNode = constructorNameNode(creation, sup);
+    if (!nameNode)
+        return null;
+    const onName = node === creation || (node.startIndex >= nameNode.startIndex && node.endIndex <= nameNode.endIndex);
+    if (!onName)
+        return null;
+    const keyword = PHP_OBJECT_CREATION_KEYWORDS[foldPhpIdentifierCase(sliceText(nameNode, source))];
+    if (!keyword)
+        return null;
+    const container = nearestMemberContainer(creation);
+    const classNode = container?.type === "class_declaration" ? container : null;
+    return { keyword, nameNode, classNode };
+}
+/** Members-declaring symbol whose name node is this container's name, when that match is unique. */
+export function memberContainerDef(mod, container) {
+    const nameNode = container.childForFieldName("name");
+    if (!nameNode)
+        return null;
+    const matches = mod.locals.filter((local) => declaresMembers(local) && local.range.start.index === nameNode.startIndex);
+    return matches.length === 1 ? (matches[0] ?? null) : null;
+}
 function rubyNewReceiverNameNode(node, source, sup) {
     if (!new RegExp(String.raw `^(?:${RUBY_CONSTANT_SOURCE})\.new$`, "u").test(sliceText(node, source)))
         return null;
     return node.namedChildren.find((child) => isReceiverNameNode(sup, child.type) || child.type === "constant") ?? null;
 }
+const NULLISH_TYPE_TEXT = new Set(["undefined", "null", "void"]);
+/**
+ * The `typeof import("spec")` type query a TypeScript annotation names, ignoring `| undefined` and
+ * `| null`: such a binding holds the module namespace of `spec`.
+ */
+export function typescriptImportTypeQuery(annotation) {
+    let current = annotation;
+    while (current?.type === "type_annotation")
+        current = current.namedChildren[0] ?? null;
+    if (current?.type === "union_type") {
+        const members = current.namedChildren.filter((member) => !NULLISH_TYPE_TEXT.has(member.text.trim()));
+        current = members.length === 1 ? members[0] : null;
+    }
+    if (current?.type !== "type_query")
+        return null;
+    const call = current.namedChildren[0];
+    return call?.type === "call_expression" && call.childForFieldName("function")?.type === "import" ? current : null;
+}
+/** The module specifier of a `typeof import("spec")` type query. */
+export function importTypeQuerySpecifier(typeQuery) {
+    const argument = typeQuery.namedChildren[0]?.childForFieldName("arguments")?.namedChildren[0];
+    if (argument?.type !== "string")
+        return null;
+    return argument.namedChildren.find((child) => child.type === "string_fragment")?.text ?? null;
+}
 export function unwrapNamedType(node, sup) {
     let current = node;
     while (current) {
+        if (current.type === "union_type") {
+            // `Store | undefined` and `Store | null` still prove `Store` for a member call.
+            const members = current.namedChildren.filter((member) => !NULLISH_TYPE_TEXT.has(member.text.trim()));
+            current = members.length === 1 ? members[0] : null;
+            continue;
+        }
         if (current.type === "type_annotation" ||
             current.type === "named_type" ||
             current.type === "user_type" ||
@@ -391,6 +522,16 @@ export function unwrapNamedType(node, sup) {
             current = current.childForFieldName("type") ?? current.namedChildren[0] ?? null;
             continue;
         }
+        if (current.type === "qualified_name") {
+            // C#'s `Outer.Inner` names the nested type by its last segment. PHP also parses a
+            // namespaced name as `qualified_name`, but as one flat token with no `name` field, so an
+            // absent field leaves `current` as that whole node instead of nulling the result out.
+            const segment = current.childForFieldName("name");
+            if (!segment)
+                break;
+            current = segment;
+            continue;
+        }
         break;
     }
     if (!current)
@@ -400,6 +541,34 @@ export function unwrapNamedType(node, sup) {
     }
     return null;
 }
+/**
+ * Kotlin extension-function receiver type, e.g. `Widget` in `fun Widget.describe(): String`.
+ * The receiver type is an unfielded `user_type` positioned before the function's own `name`;
+ * an ordinary function or class member declares no such node.
+ */
+export function kotlinExtensionReceiverTypeNode(node, sup) {
+    if (node.type !== "function_declaration")
+        return null;
+    const nameNode = node.childForFieldName("name");
+    if (!nameNode)
+        return null;
+    const receiverType = node.namedChildren.find((child) => child.startIndex < nameNode.startIndex && (child.type === "user_type" || child.type === "nullable_type"));
+    return receiverType ? unwrapNamedType(receiverType, sup) : null;
+}
+/**
+ * Self-type name node of a Rust `impl` block: `Circle` in `impl Circle`, `impl Shape for
+ * Circle`, `impl<T> Box<T>`, or `impl Shape for &Circle`. The `type` field always names the
+ * self type (the `trait` field names the implemented trait), and `unwrapNamedType` strips
+ * generic and reference wrappers down to the base type identifier. Shared by member
+ * ownership in the detailed graph and receiver-member navigation so both attribute an
+ * impl method to the same owner.
+ */
+export function rustImplSelfTypeNode(implItem, sup) {
+    if (implItem.type !== "impl_item")
+        return null;
+    const typeNode = implItem.childForFieldName("type");
+    return typeNode ? unwrapNamedType(typeNode, sup) : null;
+}
 function capitalizedCallTypeName(expr, source, sup) {
     if (expr.type !== "call" && expr.type !== "call_expression")
         return null;
@@ -428,11 +597,21 @@ function compositeLiteralTypeName(expr, source, sup) {
             return null;
         current = operand;
     }
-    if (current.type !== "composite_literal" && current.type !== "struct_initializer")
+    // tree-sitter-go composite_literal, tree-sitter-zig struct_initializer, tree-sitter-rust
+    // struct_expression: `Type { field: value }` / `Type{ .field = value }`.
+    if (current.type !== "composite_literal" &&
+        current.type !== "struct_initializer" &&
+        current.type !== "struct_expression") {
         return null;
+    }
     const typeNode = current.childForFieldName("type") ??
-        current.namedChildren.find((child) => child.type === "type_identifier" || child.type === "identifier") ??
+        current.namedChildren.find((child) => child.type === "type_identifier" ||
+            child.type === "identifier" ||
+            child.type === sup.nodeTypes.memberExpression) ??
         null;
+    // A qualified literal type (Zig `ns.Struct{...}`) has no dedicated `type` field and is not a
+    // simple named type either; `unwrapNamedType` rejects it, so the member-access node itself is
+    // kept so the caller can resolve it the same way as any other qualified expression.
     return typeNode ? (unwrapNamedType(typeNode, sup) ?? typeNode) : null;
 }
 /**
@@ -491,13 +670,13 @@ function bindingValueExpression(node) {
 function declaredTypeNameNode(node, sup) {
     const typeField = node.childForFieldName("type");
     if (typeField)
-        return unwrapNamedType(typeField, sup);
+        return unwrapNamedType(typeField, sup) ?? typeField;
     const typedChild = node.namedChildren.find((child) => child.type === "named_type" ||
         child.type === "user_type" ||
         child.type === "type_annotation" ||
         child.type === "type");
     if (typedChild)
-        return unwrapNamedType(typedChild, sup);
+        return unwrapNamedType(typedChild, sup) ?? typedChild;
     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);
@@ -575,6 +754,10 @@ function bindingProof(node, receiverName, source, sup) {
         return { status: "none" };
     if (!bindingDeclaresReceiverName(node, receiverName, source, sup))
         return { status: "none" };
+    const annotation = isJsTsLanguage(sup.id) ? node.childForFieldName("type") : null;
+    const annotated = annotation ? (unwrapNamedType(annotation, sup) ?? typescriptImportTypeQuery(annotation)) : null;
+    if (annotated)
+        return { status: "declared", node: annotated };
     const typeNode = constructionTypeFromBinding(node, receiverName, source, sup);
     if (typeNode)
         return { status: "type", node: typeNode };
@@ -586,12 +769,21 @@ function isSkippableBindingContainer(node, receiver) {
 function findPriorConstructorInContainer(node, receiver, receiverName, source, sup) {
     let constructor = null;
     let sawUnproven = false;
+    let declared = false;
     const visit = (current) => {
         if (current.startIndex >= receiver.startIndex)
             return true;
         if (current !== node && isSkippableBindingContainer(current, receiver))
             return true;
         const proof = bindingProof(current, receiverName, source, sup);
+        if (proof.status === "declared") {
+            constructor = proof.node;
+            declared = true;
+            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;
@@ -627,7 +819,10 @@ function bindingContainerDeclaresNameBefore(node, receiver, receiverName, source
             return false;
         if (current !== node && isSkippableBindingContainer(current, receiver))
             return false;
-        if (BINDING_DECLARATION_TYPES.has(current.type) &&
+        // A JavaScript/TypeScript assignment updates an existing binding; it declares nothing.
+        const declaresNewBinding = !(isJsTsLanguage(sup.id) && current.type === "assignment_expression");
+        if (declaresNewBinding &&
+            BINDING_DECLARATION_TYPES.has(current.type) &&
             bindingDeclaresReceiverName(current, receiverName, source, sup)) {
             return true;
         }
@@ -662,33 +857,290 @@ function findVisiblePriorConstructor(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) {
     const direct = constructionTypeName(obj, source, sup);
-    if (direct)
-        return direct;
     if (!isReceiverNameNode(sup, obj.type))
-        return null;
+        return direct;
     const receiverName = sliceText(obj, source);
+    if (direct && !bindsLocalValue(obj, receiverName, source, sup))
+        return direct;
     return findVisiblePriorConstructor(obj, receiverName, source, sup);
 }
-function ownTypeMemberScope(receiverName) {
-    return INSTANCE_RECEIVER_KEYWORDS.has(receiverName) ? "instance" : "any";
+/** Identifier segments in a C++ qualified name, excluding template arguments. */
+export function cppQualifiedNameSegments(node, source) {
+    return cppQualifiedTextSegments(sliceText(node, source));
+}
+/** `::`-separated segments of a C++ qualified name, ignoring `::` inside template arguments and dropping them. */
+export function cppQualifiedTextSegments(text) {
+    const segments = [];
+    let segmentStart = 0;
+    let templateDepth = 0;
+    for (let index = 0; index < text.length; index += 1) {
+        const char = text[index];
+        if (char === "<") {
+            templateDepth += 1;
+            continue;
+        }
+        if (char === ">") {
+            templateDepth = Math.max(0, templateDepth - 1);
+            continue;
+        }
+        if (char !== ":" || text[index + 1] !== ":" || templateDepth !== 0)
+            continue;
+        const segment = text.slice(segmentStart, index).trim();
+        if (segment)
+            segments.push(segment.replace(/<.*$/u, "").trim());
+        segmentStart = index + 2;
+        index += 1;
+    }
+    const finalSegment = text.slice(segmentStart).trim();
+    if (finalSegment)
+        segments.push(finalSegment.replace(/<.*$/u, "").trim());
+    return segments.filter(Boolean);
+}
+/** Exact namespace/type path that qualifies a C++ out-of-line function definition. */
+export function cppOutOfLineOwnerPath(node, source, sup) {
+    if (sup.id !== "cpp")
+        return null;
+    let current = node;
+    while (current) {
+        if (current.type === "function_definition") {
+            let declarator = current.childForFieldName("declarator");
+            while (declarator) {
+                if (declarator.type === "qualified_identifier") {
+                    const path = cppQualifiedNameSegments(declarator, source);
+                    path.pop();
+                    if (!sliceText(declarator, source).trimStart().startsWith("::")) {
+                        const namespaces = [];
+                        let parent = current.parent;
+                        while (parent) {
+                            if (parent.type === "namespace_definition") {
+                                const name = parent.childForFieldName("name");
+                                if (name)
+                                    namespaces.push(cppQualifiedNameSegments(name, source));
+                            }
+                            parent = parent.parent;
+                        }
+                        for (const namespace of namespaces.reverse())
+                            path.unshift(...namespace);
+                    }
+                    return path.length ? path : null;
+                }
+                const nested = declarator.childForFieldName("declarator") ?? declarator.namedChildren.at(-1);
+                if (!nested || nested.id === declarator.id)
+                    break;
+                declarator = nested;
+            }
+            return null;
+        }
+        current = current.parent;
+    }
+    return null;
+}
+/** Unqualified member name from a C++ out-of-line function definition. */
+export function cppOutOfLineMemberName(node, source, sup) {
+    if (sup.id !== "cpp")
+        return null;
+    let current = node;
+    while (current) {
+        if (current.type === "function_definition") {
+            const nameNode = cppFunctionDeclaratorName(current, sup);
+            return nameNode ? sliceText(nameNode, source) : null;
+        }
+        current = current.parent;
+    }
+    return null;
+}
+function sameSyntaxNode(left, right) {
+    if (!left)
+        return false;
+    if (left.id !== undefined && right.id !== undefined)
+        return left.id === right.id;
+    return left.type === right.type && left.startIndex === right.startIndex && left.endIndex === right.endIndex;
+}
+function cppFunctionDeclaratorName(node, sup) {
+    const functionDeclarator = node.type === "function_declarator" ? node : findFirstNodeByType(node, "function_declarator");
+    let current = functionDeclarator?.childForFieldName("declarator") ?? null;
+    while (current) {
+        if (isIdentifierType(sup, current.type) || current.type === "operator_name" || current.type === "destructor_name") {
+            return current;
+        }
+        let name = current.childForFieldName("name");
+        while (name?.childForFieldName("name"))
+            name = name.childForFieldName("name");
+        if (name &&
+            (isIdentifierType(sup, name.type) || name.type === "operator_name" || name.type === "destructor_name")) {
+            return name;
+        }
+        const nested = current.childForFieldName("declarator");
+        if (!nested || nested.id === current.id)
+            return null;
+        current = nested;
+    }
+    return null;
+}
+function cppMemberArityFromAncestor(node) {
+    let current = node;
+    while (current) {
+        const arity = declarationMemberArity(current, "cpp");
+        if (arity !== undefined)
+            return arity;
+        current = current.parent;
+    }
+    return undefined;
+}
+function collectCppMemberDeclarations(node, ownerNode, localName, ownerSource, sup, expectedArity, out) {
+    if ((node.type === "field_declaration" || node.type === "declaration") &&
+        sameSyntaxNode(nearestMemberContainer(node), ownerNode)) {
+        const nameNode = cppFunctionDeclaratorName(node, sup);
+        if (nameNode &&
+            sup.normalizeIdentifier(sliceText(nameNode, ownerSource)) === sup.normalizeIdentifier(localName) &&
+            declarationMemberArity(node, sup.id) === expectedArity) {
+            out.push({ node, nameNode });
+        }
+        return;
+    }
+    for (const child of node.namedChildren) {
+        collectCppMemberDeclarations(child, ownerNode, localName, ownerSource, sup, expectedArity, out);
+    }
+}
+/**
+ * Finds the unique in-class declaration corresponding to a C++ out-of-line member
+ * definition. Name and arity must both match so overloads do not collapse.
+ */
+export function cppOutOfLineMemberDeclarationNode(definitionNameNode, localName, ownerNameNode, ownerSource, sup) {
+    if (sup.id !== "cpp")
+        return null;
+    const ownerNode = nearestMemberContainer(ownerNameNode);
+    if (!ownerNode)
+        return null;
+    const expectedArity = cppMemberArityFromAncestor(definitionNameNode);
+    const declarations = [];
+    collectCppMemberDeclarations(ownerNode, ownerNode, localName, ownerSource, sup, expectedArity, declarations);
+    return declarations.length === 1 ? declarations[0] : null;
+}
+export function nodeDeclaresStatic(node, source) {
+    if (node.type === "static" || node.type === "static_modifier")
+        return true;
+    if (node.type === "storage_class_specifier" || node.type === "modifier" || node.type === "property_modifier") {
+        return sliceText(node, source).trim() === "static";
+    }
+    if (node.type === "class") {
+        const parentType = node.parent?.type;
+        return (parentType === "function_declaration" ||
+            parentType === "property_declaration" ||
+            parentType === "subscript_declaration");
+    }
+    if (node.type === "modifiers") {
+        for (let childIndex = 0;; childIndex += 1) {
+            const child = node.child(childIndex);
+            if (!child)
+                break;
+            if (nodeDeclaresStatic(child, source))
+                return true;
+        }
+    }
+    return false;
+}
+export function declarationNodeIsStatic(node, source) {
+    if (nodeDeclaresStatic(node, source))
+        return true;
+    for (let childIndex = 0;; childIndex += 1) {
+        const child = node.child(childIndex);
+        if (!child)
+            return false;
+        if (nodeDeclaresStatic(child, source))
+            return true;
+    }
+}
+export function nodeInStaticMemberContext(node, source) {
+    const container = nearestMemberContainer(node);
+    if (!container)
+        return false;
+    let current = node;
+    while (current && current !== container) {
+        if (declarationNodeIsStatic(current, source))
+            return true;
+        current = current.parent;
+    }
+    return false;
+}
+const JS_TS_DYNAMIC_THIS_FUNCTION_TYPES = {
+    function: true,
+    function_declaration: true,
+    function_expression: true,
+    generator_function: true,
+    generator_function_declaration: true,
+    method_definition: true,
+};
+/**
+ * Ordinary JS/TS functions and object-literal methods own `this`/`super`; arrows preserve the
+ * enclosing class member's receiver. Crossing one of those dynamic boundaries makes the class
+ * receiver unproven.
+ */
+export function keywordReceiverCrossesDynamicBoundary(sup, node) {
+    if (!isJsTsLanguage(sup.id))
+        return false;
+    const container = nearestMemberContainer(node);
+    if (!container)
+        return false;
+    let current = node.parent;
+    while (current && current !== container) {
+        if (JS_TS_DYNAMIC_THIS_FUNCTION_TYPES[current.type]) {
+            const directlyOwnedClassMethod = current.type === "method_definition" &&
+                current.parent?.type === "class_body" &&
+                current.parent.parent?.startIndex === container.startIndex;
+            return !directlyOwnedClassMethod;
+        }
+        current = current.parent;
+    }
+    return false;
+}
+export function keywordReceiverMemberScope(sup, receiverName, node, source) {
+    if (!hasStaticMemberDistinction(sup.id))
+        return "any";
+    if (nodeInStaticMemberContext(node, source))
+        return "static";
+    const kind = keywordReceiverKind(sup.id, receiverName);
+    if (kind === "supertype")
+        return "instance";
+    return ownReceiverMemberScope(sup.id, receiverName) ?? "any";
+}
+/**
+ * The leftmost identifier of a C# chain of plain identifiers joined by `.` (`P` in `P.Inner.Mix`),
+ * or `null` when `node` has a call, index, keyword, or type arguments. When that identifier binds
+ * nothing, the chain is a namespace-qualified type name.
+ */
+export function csharpDottedNameRoot(node) {
+    if (node.type === "identifier")
+        return node;
+    if (node.type !== "member_access_expression")
+        return null;
+    const object = node.childForFieldName("expression");
+    if (!object || node.childForFieldName("name")?.type !== "identifier")
+        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) {
-    const keywords = RECEIVER_KEYWORDS[sup.id];
-    const text = sliceText(receiver, source).trim();
+export function classifyReceiver(sup, receiver, source, proofCache, cacheScope, accessNode, hasLexicalBinding) {
+    const text = receiverKeywordText(sup, receiver, source, hasLexicalBinding);
     if (!text)
         return null;
-    if (keywords?.own.includes(text))
-        return { kind: "own-type", memberScope: ownTypeMemberScope(text) };
-    if (keywords?.supertype.includes(text))
-        return { kind: "supertype", memberScope: "any" };
+    const keywordKind = keywordReceiverKind(sup.id, text);
+    if (keywordKind) {
+        if (keywordReceiverCrossesDynamicBoundary(sup, accessNode))
+            return null;
+        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);
@@ -704,7 +1156,9 @@ export function classifyReceiver(sup, receiver, source, proofCache, cacheScope,
         return {
             kind: "named-type",
             typeName: sliceText(proof.constructed, source),
+            typeNode: proof.constructed,
             memberScope: hasStaticMemberDistinction(sup.id) ? "instance" : "any",
+            constructed: true,
         };
     }
     if (!receiverIsName)
@@ -713,24 +1167,83 @@ export function classifyReceiver(sup, receiver, source, proofCache, cacheScope,
     // `Example::shared()` would still be attributed to a colliding parameter named Example.
     if (proof.locallyBound)
         return null;
-    // Dotted `Cfg.load()` is not proof: the identifier may be a value. Type-scoped `::`
-    // is the remaining named-type proof. Ruby capitalized names are `constant` tokens
-    // even when they name a parameter, so `constant` is not itself type proof.
+    // 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
+    // capitalized names are `constant` tokens even when they name a parameter, so
+    // `constant` is not itself type proof.
     const property = getMemberAccessParts(sup, accessNode).property;
     const between = property ? source.slice(receiver.endIndex, property.startIndex) : "";
     const typeScoped = TYPE_SCOPED_ACCESS_TYPES[accessNode.type] === true || between.includes("::");
-    if (receiver.type !== "type_identifier" && !typeScoped)
-        return null;
+    if (receiver.type !== "type_identifier" && !typeScoped) {
+        // A capitalized bare name is type proof where construction already types
+        // `Box()` as a Box, and for static type-name receivers (`Box.Left()`).
+        // 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: "named-type",
+            typeName: text,
+            typeNode: receiver,
+            memberScope: UNBOUND_INSTANCE_CALL_LANGUAGE_IDS[sup.id] ? "any" : "static",
+        };
+    }
     return {
         kind: "named-type",
         typeName: text,
+        typeNode: receiver,
         memberScope: hasStaticMemberDistinction(sup.id) && typeScoped ? "static" : "any",
     };
 }
+/**
+ * Languages whose runtime allows an instance member to be invoked through a type
+ * name (`Box.instanceMethod(args)` is a real unbound call), so a type-named
+ * receiver restricts nothing about static versus instance members.
+ */
+const UNBOUND_INSTANCE_CALL_LANGUAGE_IDS = {
+    python: true,
+};
+/**
+ * Languages whose dotted type-name receivers (`Box.Left()`) name the type itself.
+ * Distinct from `capitalizedCall`, which also treats `Box()` as construction.
+ */
+const STATIC_TYPE_NAME_RECEIVER_LANGUAGE_IDS = {
+    csharp: true,
+    java: true,
+    js: true,
+    kotlin: true,
+    ts: true,
+    tsx: true,
+};
+/** Whether a receiver name is capitalized like a type in a capitalized-name language. */
+function capitalizedTypeReceiverName(sup, receiver, text) {
+    if (LANGUAGE_CONSTRUCTION_FORMS[sup.id]?.capitalizedCall !== true &&
+        !STATIC_TYPE_NAME_RECEIVER_LANGUAGE_IDS[sup.id]) {
+        return false;
+    }
+    if (!isReceiverNameNode(sup, receiver.type))
+        return false;
+    const first = text[0];
+    return !!first && first === first.toUpperCase() && first !== first.toLowerCase();
+}
 /** Whether a resolved definition can declare callable members. */
 export function declaresMembers(def) {
     return def.kind === SymbolKind.Class || def.kind === SymbolKind.Interface || def.kind === SymbolKind.TypeAlias;
 }
+/** Whether a C++ definition denotes a class, struct, or union that can own methods. */
+export function isCppMemberContainerDefinition(tree, def) {
+    const position = {
+        row: Math.max(0, def.range.start.line - 1),
+        column: Math.max(0, def.range.start.column - 1),
+    };
+    const nameNode = tree.rootNode.descendantForPosition(position, position);
+    const container = nearestMemberContainer(nameNode);
+    if (!container || CPP_MEMBER_CONTAINER_TYPES[container.type] === undefined)
+        return false;
+    const containerName = container.childForFieldName("name");
+    return containerName?.startPosition.row === position.row && containerName.startPosition.column === position.column;
+}
 /** Nearest enclosing declaration that lexically owns `node` as a member. */
 export function nearestMemberContainer(node) {
     let current = node.parent;
@@ -741,29 +1254,168 @@ export function nearestMemberContainer(node) {
     }
     return null;
 }
-/** Positional argument count of a call, ignoring comments. */
-export function callArgumentCount(callNode) {
-    const explicit = callNode.childForFieldName("arguments") ?? callNode.childForFieldName("argument_list");
-    let argumentNode = explicit ?? (callNode.namedChildren ?? []).find((child) => CALL_ARGUMENT_NODE_TYPES[child.type]) ?? null;
+/** Positional argument count of a call, including Kotlin/Swift trailing lambdas. */
+export function callArgumentCount(callNode, source) {
+    // Kotlin wraps `pick(1) { }` in an outer call node whose only other child is the
+    // callee call; the trailing lambda belongs to the inner call's argument list.
+    let scope = callNode;
+    for (let wrapper = trailingLambdaWrapper(scope); wrapper; wrapper = trailingLambdaWrapper(scope)) {
+        scope = wrapper;
+    }
+    let argumentNode = callNode.childForFieldName("arguments") ??
+        callNode.childForFieldName("argument_list") ??
+        (callNode.namedChildren ?? []).find((child) => CALL_ARGUMENT_NODE_TYPES[child.type]) ??
+        null;
     if (argumentNode?.type === "call_suffix") {
         argumentNode = (argumentNode.namedChildren ?? []).find((child) => child.type === "value_arguments") ?? null;
     }
-    if (!argumentNode)
-        return 0;
-    return (argumentNode.namedChildren ?? []).filter((argument) => argument.type !== "comment").length;
+    if (!argumentNode) {
+        // Swift allows a call suffix with only a trailing lambda (`pick { }`), and Kotlin
+        // `pick { }` keeps the lambda directly on the call node: no argument list exists.
+        const suffix = (callNode.namedChildren ?? []).find((child) => child.type === "call_suffix");
+        return ((suffix ?? scope).namedChildren ?? []).filter((child) => TRAILING_LAMBDA_NODE_TYPES[child.type] && child.startIndex >= callNode.startIndex).length;
+    }
+    let count = (argumentNode.namedChildren ?? []).filter((argument) => argument.type !== "comment").length;
+    const trailingEnd = argumentNode.parent?.type === "call_suffix" ? argumentNode.parent.endIndex : scope.endIndex;
+    if (trailingEnd > argumentNode.endIndex && containsTrailingLambdaNode(scope, argumentNode.endIndex, trailingEnd)) {
+        const trailing = countTrailingClosureArguments(source.slice(argumentNode.endIndex, trailingEnd));
+        // A null scan means the trailing-closure count is unknown, so the whole call
+        // arity is unknown rather than the parenthesized count alone.
+        if (trailing === null)
+            return null;
+        count += trailing;
+    }
+    return count;
 }
-function parseDefNodeId(id) {
-    const indexSep = id.lastIndexOf("::");
-    if (indexSep <= 0)
+/** Trailing lambda nodes across the supported grammars. */
+const TRAILING_LAMBDA_NODE_TYPES = {
+    annotated_lambda: true, // Kotlin wraps the lambda on the outer call node.
+    lambda_literal: true, // Swift keeps trailing lambdas inside `call_suffix`.
+};
+/** Call nodes that can wrap a callee call plus a Kotlin trailing lambda. */
+const TRAILING_LAMBDA_WRAPPER_TYPES = {
+    call: true,
+    call_expression: true,
+};
+/**
+ * The outer call node attaching a trailing lambda to `node`, or null. The wrapper
+ * never carries its own argument list, which distinguishes it from a chained call.
+ */
+function trailingLambdaWrapper(node) {
+    const parent = node.parent;
+    if (!parent || !TRAILING_LAMBDA_WRAPPER_TYPES[parent.type])
         return null;
-    const index = Number(id.slice(indexSep + 2));
-    if (!Number.isFinite(index))
+    const children = parent.namedChildren ?? [];
+    if (children.some((child) => CALL_ARGUMENT_NODE_TYPES[child.type]))
         return null;
-    const rest = id.slice(0, indexSep);
-    const nameSep = rest.lastIndexOf("::");
-    if (nameSep <= 0)
+    return children.some((child) => TRAILING_LAMBDA_NODE_TYPES[child.type]) ? parent : null;
+}
+/** Whether a trailing lambda node overlaps `[start, end)` anywhere under `node`. */
+function containsTrailingLambdaNode(node, start, end) {
+    for (const child of node.namedChildren ?? []) {
+        if (child.endIndex <= start || child.startIndex >= end)
+            continue;
+        if (TRAILING_LAMBDA_NODE_TYPES[child.type])
+            return true;
+        if (containsTrailingLambdaNode(child, start, end))
+            return true;
+    }
+    return false;
+}
+/** End index after a Swift trailing-closure label and its colon, or null when absent. */
+function trailingClosureLabelEnd(text, startIndex) {
+    if (text[startIndex] === "`") {
+        const escapedEnd = text.indexOf("`", startIndex + 1);
+        if (escapedEnd < 0 || text[escapedEnd + 1] !== ":")
+            return null;
+        return escapedEnd + 2;
+    }
+    const identifier = /^[_\p{ID_Start}][_\p{ID_Continue}]*/u.exec(text.slice(startIndex));
+    if (!identifier)
         return null;
-    return { file: rest.slice(0, nameSep), name: rest.slice(nameSep + 2), index };
+    const colonIndex = startIndex + identifier[0].length;
+    return text[colonIndex] === ":" ? colonIndex + 1 : null;
+}
+/**
+ * Counts the top-level `{ ... }` blocks in trailing call text, one per trailing
+ * closure, or null when the text is not a well-formed trailing-closure run.
+ * Shared with call-compatibility extraction so both paths count identically.
+ */
+export function countTrailingClosureArguments(text) {
+    let startIndex = 0;
+    let count = 0;
+    while (startIndex < text.length) {
+        while (/\s/.test(text[startIndex] ?? "")) {
+            startIndex += 1;
+        }
+        if (startIndex === text.length) {
+            return count;
+        }
+        if (text[startIndex] !== "{") {
+            const labelEnd = trailingClosureLabelEnd(text, startIndex);
+            if (labelEnd === null)
+                return null;
+            startIndex = labelEnd;
+            while (/\s/.test(text[startIndex] ?? "")) {
+                startIndex += 1;
+            }
+            if (text[startIndex] !== "{")
+                return null;
+        }
+        let braceDepth = 0;
+        let quote = null;
+        let escaped = false;
+        let closed = false;
+        for (let index = startIndex; index < text.length; index += 1) {
+            const char = text[index];
+            if (quote) {
+                if (escaped) {
+                    escaped = false;
+                    continue;
+                }
+                if (char === "\\") {
+                    escaped = true;
+                    continue;
+                }
+                if (char === quote) {
+                    quote = null;
+                }
+                continue;
+            }
+            const commentEnd = findCommentEnd(text, index);
+            if (commentEnd !== null) {
+                if (commentEnd < 0) {
+                    return null;
+                }
+                index = commentEnd - 1;
+                continue;
+            }
+            if (char === '"' || char === "'" || char === "`") {
+                quote = char;
+                continue;
+            }
+            if (char === "{") {
+                braceDepth += 1;
+                continue;
+            }
+            if (char === "}") {
+                braceDepth -= 1;
+                if (braceDepth < 0) {
+                    return null;
+                }
+                if (!braceDepth) {
+                    startIndex = index + 1;
+                    count += 1;
+                    closed = true;
+                    break;
+                }
+            }
+        }
+        if (!closed) {
+            return null;
+        }
+    }
+    return count;
 }
 function loadSource(file, cache) {
     const cached = cache.get(file);
@@ -779,20 +1431,6 @@ function loadSource(file, cache) {
         return "";
     }
 }
-function memberIdLooksStatic(memberId, sourceCache) {
-    const parsed = parseDefNodeId(memberId);
-    if (!parsed)
-        return false;
-    const source = loadSource(parsed.file, sourceCache);
-    if (!source)
-        return false;
-    const beforeBrace = source.lastIndexOf("{", parsed.index);
-    const beforeSemi = source.lastIndexOf(";", parsed.index);
-    const beforeClose = source.lastIndexOf("}", parsed.index);
-    const declStart = Math.max(beforeBrace, beforeSemi, beforeClose);
-    const prefix = source.slice(declStart + 1, parsed.index);
-    return /(?:^|[^\w$])static(?:$|[^\w$])/.test(prefix) || /(?:^|[^\w$])def\s+self\s*\./.test(prefix);
-}
 function inferCallMemberScope(site, sourceCache) {
     const source = loadSource(site.file, sourceCache);
     if (!source)
@@ -807,22 +1445,25 @@ function inferCallMemberScope(site, sourceCache) {
         return "instance";
     if (/\)\s*\.\s*$/.test(before))
         return "instance";
-    // HeritageEdges does not yet copy classifyReceiver.memberScope onto candidates.
-    // A lowercase dotted receiver is an instance value (`c.StaticMethod()`), not a type.
+    // Older serialized candidates lack memberScope. Infer the common dotted-receiver cases.
     if (/(?:^|[^A-Za-z0-9_$])[a-z_][A-Za-z0-9_]*\s*\.\s*$/.test(before))
         return "instance";
     if (/(?:^|[^A-Za-z0-9_$])[A-Z][A-Za-z0-9_]*\s*\.\s*$/.test(before))
         return "static";
     return "any";
 }
+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 ?? ""}`;
+}
 /**
  * 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) {
+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) {
     if (!candidates.length)
-        return;
+        return [];
     const membersByOwner = new Map();
     const ownerByMember = new Map();
     const supertypesByOwner = new Map();
@@ -847,27 +1488,75 @@ export function emitReceiverCallEdges(graph, candidates, recordEdge) {
         if (label === "extends")
             pushUnique(classAncestorsByOwner, edge.from, edge.to);
     }
+    // Receiver-local access does not change the nominal type's membership edges.
+    for (const [ownerId, memberIds] of accessibleMembers) {
+        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");
     };
+    const callTargetsBySite = new Map();
+    for (const edge of graph.edges) {
+        if (edge.label !== "calls" || !edge.site)
+            continue;
+        const key = callSiteKey(edge.from, edge.site);
+        const targets = callTargetsBySite.get(key);
+        if (targets)
+            targets.add(edge.to);
+        else
+            callTargetsBySite.set(key, new Set([edge.to]));
+    }
+    const rejectedCallSites = new Set();
     const sourceCache = new Map();
     for (const candidate of candidates) {
-        const owner = candidate.ownerId ?? ownerByMember.get(candidate.callerId);
-        if (!owner)
+        const siteKey = callSiteKey(candidate.callerId, candidate.site);
+        const existingTargets = callTargetsBySite.get(siteKey) ?? new Set();
+        if (existingTargets.size > 1) {
+            rejectedCallSites.add(siteKey);
+            continue;
+        }
+        const rawOwner = candidate.ownerId ?? ownerByMember.get(candidate.callerId);
+        if (!rawOwner)
             continue;
+        // Shared-owner anchors redirect Swift extension and C# partial owners to the
+        // 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, sourceCache);
+            const lookup = provenMemberTarget(graph, membersByOwner, level, candidate, memberScope, memberScopes, nodeAliases, memberArities, fileHiddenMemberIds, candidate.site.file);
             if (lookup.status === "unique") {
-                recordEdge(candidate.callerId, lookup.memberId, "calls", candidate.site);
+                if (acceptsCallTarget && !acceptsCallTarget(lookup.memberId, candidate)) {
+                    receiverDisposition = "ambiguous";
+                    if (existingTargets.size)
+                        rejectedCallSites.add(siteKey);
+                    break;
+                }
+                receiverDisposition = "resolved";
+                const combinedTargets = new Set(existingTargets);
+                combinedTargets.add(lookup.memberId);
+                if (combinedTargets.size === 1) {
+                    if (existingTargets.size === 0 && recordEdge(candidate.callerId, lookup.memberId, "calls", candidate.site)) {
+                        existingTargets.add(lookup.memberId);
+                        callTargetsBySite.set(siteKey, existingTargets);
+                    }
+                }
+                else {
+                    rejectedCallSites.add(siteKey);
+                }
                 break;
             }
-            if (lookup.status === "ambiguous")
+            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)) {
@@ -879,7 +1568,46 @@ export function emitReceiverCallEdges(graph, candidates, recordEdge) {
             }
             level = next;
         }
+        if (receiverDisposition === "none") {
+            if (candidate.fallbackTargetId && !existingTargets.size) {
+                recordEdge(candidate.callerId, candidate.fallbackTargetId, "calls", candidate.site);
+            }
+            else if (existingTargets.size) {
+                rejectedCallSites.add(siteKey);
+            }
+        }
+    }
+    const removed = [];
+    if (rejectedCallSites.size) {
+        let writeIndex = 0;
+        for (const edge of graph.edges) {
+            if (edge.label === "calls" && edge.site && rejectedCallSites.has(callSiteKey(edge.from, edge.site))) {
+                removed.push(edge);
+                continue;
+            }
+            graph.edges[writeIndex] = edge;
+            writeIndex += 1;
+        }
+        graph.edges.length = writeIndex;
+    }
+    return removed;
+}
+function canonicalMemberId(id, aliases) {
+    let current = id;
+    const seen = new Set();
+    while (aliases.has(current) && !seen.has(current)) {
+        seen.add(current);
+        current = aliases.get(current);
     }
+    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`.
@@ -887,27 +1615,46 @@ export function emitReceiverCallEdges(graph, candidates, recordEdge) {
  * `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, sourceCache) {
+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 node = graph.nodes.get(memberId);
-            if (!node || node.kind !== "function" || node.name !== candidate.memberName)
+            const canonicalId = canonicalMemberId(memberId, nodeAliases);
+            const node = graph.nodes.get(memberId) ?? graph.nodes.get(canonicalId);
+            if (!node || (node.kind !== "function" && !node.callable))
                 continue;
-            if (memberScope === "static" && !memberIdLooksStatic(memberId, sourceCache))
+            if ((fileHiddenMemberIds.has(memberId) || fileHiddenMemberIds.has(canonicalId)) &&
+                fileIdentityKey(node.file) !== fileIdentityKey(useFile)) {
                 continue;
-            if (memberScope === "instance" && memberIdLooksStatic(memberId, sourceCache))
+            }
+            const nameMatches = candidate.caseInsensitiveMemberName
+                ? foldPhpIdentifierCase(node.name) === foldPhpIdentifierCase(candidate.memberName)
+                : node.name === candidate.memberName;
+            if (!nameMatches)
                 continue;
-            matches.add(memberId);
+            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;
-        return { status: "unique", memberId: memberId };
+        if (memberArityMatches(memberId, candidate.argumentCount, memberArities)) {
+            return { status: "unique", memberId: memberId };
+        }
+        return { status: "ambiguous" };
     }
-    const byArity = [...matches].filter((memberId) => graph.nodes.get(memberId)?.memberArity === candidate.argumentCount);
+    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" };