@lzehrung/codegraph 2.3.31 → 3.0.0

package/dist/graphs/symbol-graph-detailed/edge-passes.js

@@ -1,17 +1,32 @@
+import { SymbolKind } from "../../indexer/types.js";
+import { getCompilationUnitPeers } from "../../indexer/compilation-units.js";
+import { isExportedDeclaration, isGoExportedMemberName, isSwiftCrossFileHiddenSharedOwnerMember, isSwiftFileHiddenSharedOwnerMember, } from "../../indexer/declaration-visibility.js";
+import { resolveCppQualifiedMemberContainer } from "../../indexer/navigation-cpp.js";
+import { cppQualifiedOwnerHasImplicitThis, findTypeScriptNamespaceMemberCandidates, innermostNamespaceImport, isDirectKeywordMemberDeclaration, memberAcceptsCallAt, resolvePhpObjectCreationTarget, resolveRubyVisibleConstant, resolveSharedOwnerContainers, supportsDeclaredFieldChains, } from "../../indexer/navigation-goto.js";
+import { findClosestScopeBinding } from "../../indexer/navigation-local.js";
+import { findPhpImportAlias, inferPhpQualifiedReferenceImportType } from "../../indexer/navigation-php.js";
+import { cjsRequireValueBinding, resolveImportTypeMember, resolvePhpExportByImportType, } from "../../indexer/navigation-resolve.js";
+import { selectMember } from "../../indexer/member-selection.js";
+import { effectiveExplicitBinding } from "../../indexer/star-import-precedence.js";
+import { isSwiftConstrainedExtension, isSwiftExtensionContainer, selectCsharpPartialRepresentative, } from "../../indexer/shared-owner-identity.js";
+import { isJsTsLanguage } from "../../languages/js-family.js";
+import { getCallArgumentCount, memberLookupBinding } from "../../languages/callable-arity.js";
 import { sliceText, toRange } from "../../util/ast.js";
-import { getMemberAccessParts } from "../../util/member-access.js";
+import { getMemberAccessParts, isMemberAccessNode, rustTokenTreeHoldsExpressions, rustTokenTreeNameFollowsSeparator, } from "../../util/member-access.js";
+import { foldPhpIdentifierCase } from "../../util/identifiers.js";
+import { MEMBER_ACCESS_ROWS, } from "../../util/member-access-tables.js";
 import { fileIdentityKey } from "../../util/paths.js";
 import { defNodeId, nodeForDef } from "../symbol-graph.js";
-import { collectNodesByType, findFirstNodeByType, isIdentifierType } from "./ast.js";
-import { CALL_ARGUMENT_NODE_TYPES, callArgumentCount, classifyReceiver, declaresMembers, nearestMemberContainer, receiverCallAccess, } from "./receiver-calls.js";
+import { collectNodesByType, declarationMemberArity, findFirstNodeByType, isIdentifierType } from "./ast.js";
+import { CALL_ARGUMENT_NODE_TYPES, classifyReceiver, constructionTypeName, declarationIsStaticEquivalent, declarationNodeIsStatic, cppOutOfLineOwnerPath, cppOutOfLineMemberDeclarationNode, cppQualifiedNameSegments, declaresMembers, isUnprovenHeritageExpression, kotlinExtensionReceiverTypeNode, memberContainerDef, nearestMemberContainer, nodeInStaticMemberContext, phpObjectCreationKeyword, receiverCallAccess, rustImplSelfTypeNode, supportsImplicitSelfMemberCalls, supportsReceiverMemberOverloads, importTypeQuerySpecifier, } from "./receiver-calls.js";
 function ensureNode(context, def) {
     const id = defNodeId(def);
     if (!context.nodes.has(id))
         context.nodes.set(id, nodeForDef(def));
     return id;
 }
-function markImplementationTarget(context, id, declarationNode, def) {
-    const declaration = sliceText(declarationNode, context.source);
+function markImplementationTarget(context, id, declarationNode, declarationSource, def) {
+    const declaration = sliceText(declarationNode, declarationSource);
     const nameIndex = declaration.indexOf(def.localName);
     const prefix = nameIndex >= 0 ? declaration.slice(0, nameIndex) : declaration;
     if (!/\b(?:abstract|virtual|override)\b/.test(prefix))
@@ -21,27 +36,49 @@ function markImplementationTarget(context, id, declarationNode, def) {
         node.implementationTarget = true;
 }
 function markMemberArity(context, id, declarationNode) {
-    let parameters = declarationNode.childForFieldName("parameters");
-    if (!parameters) {
-        for (const type of [
-            "formal_parameters",
-            "parameter_list",
-            "parameters",
-            "method_parameters",
-            "function_parameter_clause",
-        ]) {
-            parameters = findFirstNodeByType(declarationNode, type);
-            if (parameters)
-                break;
-        }
-    }
-    if (!parameters)
+    const arity = declarationMemberArity(declarationNode, context.sup.id);
+    if (arity === undefined)
         return;
-    const arity = (parameters.namedChildren ?? []).filter((child) => child.type !== "comment").length;
     const node = context.nodes.get(id);
     if (node)
         node.memberArity = arity;
 }
+function mergeCppCallableShapes(...defs) {
+    let merged;
+    for (const def of defs) {
+        const arity = def?.callable?.arity;
+        if (!arity)
+            continue;
+        if (!merged) {
+            merged = { min: arity.minArgs, max: arity.maxArgs };
+            continue;
+        }
+        merged.min = Math.min(merged.min, arity.minArgs);
+        if (merged.max === null || arity.maxArgs === null)
+            merged.max = null;
+        else
+            merged.max = Math.max(merged.max, arity.maxArgs);
+    }
+    return merged;
+}
+/** The member call form determines whether a declared receiver takes an argument. */
+function acceptedMemberArityRange(context, def) {
+    if (!supportsReceiverMemberOverloads(context.sup.id))
+        return undefined;
+    const callable = def.callable;
+    const range = memberLookupBinding(context.sup.id) === "unbound" ? (callable?.unboundArity ?? callable?.arity) : callable?.arity;
+    return range ? { min: range.minArgs, max: range.maxArgs } : undefined;
+}
+function recordMemberLookupIdentity(context, definitionId, memberId, memberScope, arityRange) {
+    context.receiverMemberScopes.set(definitionId, memberScope);
+    if (memberId !== definitionId)
+        context.receiverMemberScopes.set(memberId, memberScope);
+    if (!arityRange)
+        return;
+    context.receiverMemberArities.set(definitionId, arityRange);
+    if (memberId !== definitionId)
+        context.receiverMemberArities.set(memberId, arityRange);
+}
 function recordDefEdge(context, fromId, target, label, siteNode) {
     const toId = ensureNode(context, target);
     return context.recordEdge(fromId, toId, label, siteNode ? { file: context.moduleEntry.file, range: toRange(siteNode) } : undefined);
@@ -56,10 +93,27 @@ function tryResolveChain(context, node, fromId, label = "uses") {
 }
 /** Records an edge for a resolvable target node. Returns whether a target was resolved. */
 function tryResolveNode(context, node, fromId, label) {
-    if (isIdentifierType(context.sup, node.type) || node.type === "type_identifier") {
+    if (context.sup.id === "cpp" && node.type === "qualified_identifier") {
+        const name = cppQualifiedNameSegments(node, context.source).join("::");
+        const target = context.resolveIdentifier(name, node);
+        if (target) {
+            recordDefEdge(context, fromId, target, label, node);
+            return true;
+        }
+        return false;
+    }
+    if (isIdentifierType(context.sup, node.type) ||
+        node.type === "type_identifier" ||
+        (context.sup.id === "csharp" && (node.type === "qualified_name" || node.type === "alias_qualified_name")) ||
+        (context.sup.id === "php" && (node.type === "qualified_name" || node.type === "relative_name")) ||
+        (context.sup.id === "cpp" && (node.type === "operator_name" || node.type === "destructor_name"))) {
         const name = sliceText(node, context.source);
         const target = context.resolveIdentifier(name, node);
         if (target) {
+            // Zig struct declarations require an explicit type receiver (`Self.helper()`).
+            // An unqualified identifier is not a call to a member of its enclosing struct.
+            if (label === "calls" && context.sup.id === "zig" && target.isMember)
+                return false;
             recordDefEdge(context, fromId, target, label, node);
             return true;
         }
@@ -69,6 +123,32 @@ function tryResolveNode(context, node, fromId, label) {
     }
     return false;
 }
+/**
+ * Rust macro arguments stay unparsed token trees, so `println!("{}", greet())` never forms a
+ * call node even though goto resolves the identifier. An `identifier` directly followed by a
+ * `(` group is a call in the argument list, resolved like a bare call. The macro's own name
+ * sits outside the token tree and is never a call; a `!` gap marks a nested macro invocation,
+ * and a `.` or `::` gap marks a member or path receiver that raw tokens cannot prove, matching
+ * navigation's refusals inside token trees.
+ */
+function recordRustMacroArgumentCalls(context, tokenTree, fromId) {
+    if (!rustTokenTreeHoldsExpressions(tokenTree))
+        return;
+    const children = tokenTree.namedChildren;
+    for (let index = 0; index + 1 < children.length; index += 1) {
+        const name = children[index];
+        const args = children[index + 1];
+        if (name.type !== "identifier" || args.type !== "token_tree")
+            continue;
+        if (!args.text.startsWith("("))
+            continue;
+        if (context.source.slice(name.endIndex, args.startIndex).trim())
+            continue;
+        if (rustTokenTreeNameFollowsSeparator(name))
+            continue;
+        tryResolveNode(context, name, fromId, "calls");
+    }
+}
 function getCallTarget(node) {
     const explicitTarget = node.childForFieldName("function") ??
         node.childForFieldName("callee") ??
@@ -76,6 +156,11 @@ function getCallTarget(node) {
         node.childForFieldName("method") ??
         node.childForFieldName("member") ??
         node.childForFieldName("expression");
+    // tree-sitter-typescript parses `await f<T>(x)` as a call whose callee is `await f`; the awaited
+    // value is the call's result, so the callee is `f`.
+    if (explicitTarget?.type === "await_expression" && node.childForFieldName("type_arguments")) {
+        return explicitTarget.namedChildren[0] ?? null;
+    }
     if (explicitTarget)
         return explicitTarget;
     // Kotlin and Swift calls name no callee field, so the sole non-argument child is it.
@@ -83,15 +168,18 @@ function getCallTarget(node) {
     return nonArgumentChildren.length === 1 ? (nonArgumentChildren[0] ?? null) : null;
 }
 function getNewTarget(node) {
-    return (node.childForFieldName("constructor") ??
-        node.childForFieldName("type") ??
-        node.childForFieldName("name") ??
-        node.namedChildren.find((child) => child.type === "type_identifier") ??
-        node.child(0));
+    const field = node.childForFieldName("constructor") ?? node.childForFieldName("type") ?? node.childForFieldName("name");
+    if (field)
+        return field;
+    // PHP `new Base()` has no type field; the type is a `name` / `qualified_name` child and
+    // `child(0)` is the `new` keyword, which is not a type.
+    const namedType = node.namedChildren.find((child) => child.type === "type_identifier" ||
+        child.type === "name" ||
+        child.type === "qualified_name" ||
+        child.type === "relative_name");
+    return namedType ?? node.child(0);
 }
 export function emitPythonDecoratorEdges(context, rootNode) {
-    if (context.sup.id !== "python")
-        return;
     const addDecoratorUses = (node) => {
         if (node.type === "decorated_definition") {
             const fn = node.namedChildren.find((child) => child.type === "function_definition");
@@ -151,34 +239,220 @@ export function emitPythonDecoratorEdges(context, rootNode) {
     };
     addDecoratorUses(rootNode);
 }
-export function emitMemberOwnershipEdges(context, functionNodes, classNodes) {
+/** Whether a function declaration can participate in class member lookup and ownership. */
+function isClassMemberFunction(fn) {
+    return fn.node.type !== "local_function_statement";
+}
+export async function emitMemberOwnershipEdges(context, functionNodes, classNodes) {
     for (const fn of functionNodes) {
-        const ownerDef = memberOwnerDef(context, fn, classNodes);
-        if (!ownerDef)
+        const owner = await memberOwner(context, fn, classNodes);
+        if (!owner)
             continue;
-        const memberId = ensureNode(context, fn.def);
-        markImplementationTarget(context, memberId, fn.node, fn.def);
-        markMemberArity(context, memberId, fn.node);
-        recordDefEdge(context, memberId, ownerDef, "member_of");
+        const outOfLineDeclaration = owner.cppOutOfLine
+            ? await cppOutOfLineMemberDeclaration(context, fn, owner.def)
+            : null;
+        const definitionId = ensureNode(context, fn.def);
+        let memberDef = fn.def;
+        if (outOfLineDeclaration) {
+            const declarationModule = context.index.byFile.get(fileIdentityKey(owner.def.file));
+            const declarationDef = declarationModule?.locals.find((candidate) => candidate.localName === fn.def.localName &&
+                candidate.kind === fn.def.kind &&
+                candidate.range.start.index === outOfLineDeclaration.nameNode.startIndex &&
+                candidate.range.end.index === outOfLineDeclaration.nameNode.endIndex);
+            if (declarationDef)
+                memberDef = declarationDef;
+        }
+        const memberId = ensureNode(context, memberDef);
+        if (definitionId !== memberId)
+            context.nodeAliases.set(definitionId, memberId);
+        if (context.sup.id === "java" || context.sup.id === "kotlin" || context.sup.id === "swift") {
+            const declarationNode = outOfLineDeclaration?.node ?? fn.node;
+            const hidden = context.sup.id === "swift"
+                ? isSwiftFileHiddenSharedOwnerMember(context.sup.id, declarationNode)
+                : !isExportedDeclaration(context.sup.id, declarationNode);
+            if (hidden) {
+                context.fileHiddenMemberIds.add(memberId);
+                if (definitionId !== memberId)
+                    context.fileHiddenMemberIds.add(definitionId);
+            }
+        }
+        markImplementationTarget(context, memberId, outOfLineDeclaration?.node ?? fn.node, outOfLineDeclaration?.source ?? context.source, fn.def);
+        const arityNode = outOfLineDeclaration?.node ?? fn.node;
+        markMemberArity(context, definitionId, arityNode);
+        if (memberId !== definitionId)
+            markMemberArity(context, memberId, arityNode);
+        const memberScope = memberScopeForDefinition(context, fn, owner.cppOutOfLine, outOfLineDeclaration);
+        const outOfLineMember = outOfLineDeclaration ? memberDef : undefined;
+        const arityRange = context.sup.id === "cpp"
+            ? mergeCppCallableShapes(fn.def, outOfLineMember)
+            : acceptedMemberArityRange(context, memberDef);
+        recordMemberLookupIdentity(context, definitionId, memberId, memberScope, arityRange);
+        recordDefEdge(context, definitionId, owner.def, "member_of");
+        await emitSharedOwnerMembershipEdges(context, owner, definitionId, fn.node);
+    }
+}
+/** Owner def of a shared-owner container, matched by its declaration name range. */
+function sharedOwnerPeerDef(peer, callerFile) {
+    const nameNode = peer.container.childForFieldName("name");
+    if (!nameNode)
+        return null;
+    const def = peer.module.locals.find((local) => declaresMembers(local) && local.range.start.index === nameNode.startIndex);
+    if (!def)
+        return null;
+    if (!callerFile)
+        return { def, isExtension: isSwiftExtensionContainer(peer.container, peer.context.source) };
+    const visibleMemberIds = [];
+    for (const local of peer.module.locals) {
+        const start = local.range.start.index;
+        if (start === undefined || start < peer.container.startIndex || start >= peer.container.endIndex)
+            continue;
+        const name = peer.context.tree.rootNode.descendantForIndex(start, start);
+        if (!isDirectKeywordMemberDeclaration(name, peer.container))
+            continue;
+        if (isSwiftCrossFileHiddenSharedOwnerMember("swift", callerFile, peer.file, name))
+            continue;
+        visibleMemberIds.push(defNodeId(local));
+    }
+    return { def, isExtension: isSwiftExtensionContainer(peer.container, peer.context.source), visibleMemberIds };
+}
+/**
+ * C# partial declarations and unconstrained Swift extensions share type membership
+ * across proven peers. Constrained Swift extensions instead retain their own members
+ * and record only the peer members their lexical owner can use. This keeps unproven
+ * receivers from inheriting constrained members while preserving calls inside the
+ * extension. Same-named types in other namespaces or paths remain separate.
+ */
+async function emitSharedOwnerMembershipEdges(context, owner, definitionId, memberNode) {
+    const container = owner.container;
+    if (!container)
+        return;
+    if (context.sup.id !== "csharp" && context.sup.id !== "swift")
+        return;
+    const isExtension = context.sup.id === "swift" && isSwiftExtensionContainer(container, context.source);
+    // Swift base types already own their full member set; only extensions and C#
+    // partials reach across owner declarations. Non-partial C# containers resolve
+    // to no peers inside the shared-owner relation.
+    // Constrained extensions can use nominal members but cannot donate their own
+    // members to every instance of the nominal type without proving the where clause.
+    const constrained = context.sup.id === "swift" && isSwiftConstrainedExtension(container, context.source);
+    if (constrained && context.sharedOwnerAccessibleMembers.has(defNodeId(owner.def)))
+        return;
+    const cacheKey = `${fileIdentityKey(context.moduleEntry.file)}\u0000${container.startIndex}\u0000${container.endIndex}`;
+    let peers = context.sharedOwnerPeers.get(cacheKey);
+    if (!peers) {
+        peers = resolveSharedOwnerContainers({
+            index: context.index,
+            ownerFile: context.moduleEntry.file,
+            ownerContainer: container,
+            ownerSource: context.source,
+            languageId: context.sup.id,
+        }).then((resolved) => resolved
+            .map((peer) => sharedOwnerPeerDef(peer, constrained ? context.moduleEntry.file : undefined))
+            .filter((peer) => !!peer));
+        context.sharedOwnerPeers.set(cacheKey, peers);
+    }
+    const peerDefs = await peers;
+    if (constrained) {
+        const ownerId = defNodeId(owner.def);
+        const accessible = context.sharedOwnerAccessibleMembers.get(ownerId) ?? new Set();
+        for (const peer of peerDefs)
+            for (const memberId of peer.visibleMemberIds ?? [])
+                accessible.add(memberId);
+        context.sharedOwnerAccessibleMembers.set(ownerId, accessible);
+        return;
+    }
+    for (const peer of peerDefs) {
+        if (isSwiftCrossFileHiddenSharedOwnerMember(context.sup.id, peer.def.file, context.moduleEntry.file, memberNode)) {
+            continue;
+        }
+        recordDefEdge(context, definitionId, peer.def, "member_of");
+    }
+    if (isExtension) {
+        const anchor = peerDefs.find((peer) => !peer.isExtension);
+        context.sharedOwnerAnchors.set(defNodeId(owner.def), defNodeId(anchor ? anchor.def : owner.def));
+        return;
+    }
+    if (context.sup.id === "csharp" && peerDefs.length) {
+        const representative = selectCsharpPartialRepresentative([owner.def, ...peerDefs.map((peer) => peer.def)]);
+        context.sharedOwnerAnchors.set(defNodeId(owner.def), defNodeId(representative));
+    }
+}
+function memberScopeForDefinition(context, fn, cppOutOfLine, outOfLineDeclaration) {
+    if (outOfLineDeclaration) {
+        return declarationNodeIsStatic(outOfLineDeclaration.node, outOfLineDeclaration.source) ? "static" : "instance";
     }
+    if (cppOutOfLine)
+        return "any";
+    // Kotlin has no `static` keyword; a member of a `companion object` or a named `object`
+    // declaration is the language's static-equivalent mechanism (reachable as `Outer.member()`).
+    if (declarationIsStaticEquivalent(context.sup.id, fn.node))
+        return "static";
+    const declarationNode = fn.node.parent?.type === "public_field_definition" || fn.node.parent?.type === "field_definition"
+        ? fn.node.parent
+        : fn.node;
+    return declarationNodeIsStatic(declarationNode, context.source) ? "static" : "instance";
 }
-/** Lexical class body, or the named Go receiver type for an out-of-line method. */
-function memberOwnerDef(context, fn, classNodes) {
+/** Lexical type body, named Go receiver type, or named C++ out-of-line owner. */
+async function memberOwner(context, fn, classNodes) {
+    if (!isClassMemberFunction(fn))
+        return null;
     if (context.sup.id === "go" && fn.node.type === "method_declaration") {
-        return goMethodReceiverTypeDef(context, fn.node);
+        const def = goMethodReceiverTypeDef(context, fn.node);
+        return def ? { def, container: null, cppOutOfLine: false } : null;
     }
     const owners = classNodes
         .filter((candidate) => candidate.node.startIndex <= fn.node.startIndex && candidate.node.endIndex >= fn.node.endIndex)
         .sort((left, right) => left.node.endIndex - left.node.startIndex - (right.node.endIndex - right.node.startIndex));
-    if (owners[0]?.def)
-        return owners[0].def;
+    if (owners[0]?.def) {
+        if (!isDirectKeywordMemberDeclaration(fn.node, owners[0].node))
+            return null;
+        return { def: owners[0].def, container: owners[0].node, cppOutOfLine: false };
+    }
+    if (context.sup.id === "cpp") {
+        const ownerPath = cppOutOfLineOwnerPath(fn.node, context.source, context.sup);
+        const def = ownerPath
+            ? await resolveCppQualifiedMemberContainer(context.index, context.moduleEntry, ownerPath, context.loadParsedFile)
+            : null;
+        return def ? { def, container: null, cppOutOfLine: true } : null;
+    }
+    if (context.sup.id === "kotlin") {
+        // `fun Widget.describe()` is a top-level declaration outside Widget's own body, so it is
+        // never one of `owners` above; its receiver-type prefix is the only proof of ownership.
+        const receiverTypeNode = kotlinExtensionReceiverTypeNode(fn.node, context.sup);
+        if (!receiverTypeNode)
+            return null;
+        const def = resolveNamedType(context, sliceText(receiverTypeNode, context.source), receiverTypeNode);
+        return def ? { def, container: null, cppOutOfLine: false } : null;
+    }
+    if (context.sup.id === "rust") {
+        // A Rust impl method sits beside its self type, not inside it (like Go's receiver type);
+        // the `impl` block's self type is the owner, and only direct impl members count.
+        const container = nearestMemberContainer(fn.node);
+        if (!container || container.type !== "impl_item" || !isDirectKeywordMemberDeclaration(fn.node, container)) {
+            return null;
+        }
+        const nameNode = rustImplSelfTypeNode(container, context.sup);
+        const def = nameNode ? resolveNamedType(context, sliceText(nameNode, context.source), nameNode) : null;
+        return def ? { def, container, cppOutOfLine: false } : null;
+    }
     if (context.sup.id !== "zig")
         return null;
     const container = nearestMemberContainer(fn.node);
     if (container?.type !== "struct_declaration")
         return null;
     const name = container.parent?.namedChildren.find((child) => child.type === "identifier");
-    return name ? resolveNamedType(context, sliceText(name, context.source), name) : null;
+    const def = name ? resolveNamedType(context, sliceText(name, context.source), name) : null;
+    return def ? { def, container, cppOutOfLine: false } : null;
+}
+async function cppOutOfLineMemberDeclaration(context, fn, ownerDef) {
+    const parsed = await context.loadParsedFile(ownerDef.file);
+    const startIndex = ownerDef.range.start.index;
+    const endIndex = ownerDef.range.end.index;
+    if (!parsed || startIndex === undefined || endIndex === undefined)
+        return null;
+    const ownerNameNode = parsed.tree.rootNode.descendantForIndex(startIndex, endIndex);
+    const declaration = cppOutOfLineMemberDeclarationNode(fn.node, fn.def.localName, ownerNameNode, parsed.source, context.sup);
+    return declaration ? { node: declaration.node, nameNode: declaration.nameNode, source: parsed.source } : null;
 }
 /** Receiver type of `func (b *T) M()` / `func (b T) M()`, unwrapped through pointers. */
 function goMethodReceiverTypeDef(context, methodNode) {
@@ -208,16 +482,347 @@ function unwrapGoNamedType(node) {
     return current?.type === "type_identifier" ? current : null;
 }
 /** Type-like defs only, so a PHP `use function` alias cannot steal `Example::m()`. */
-function resolveNamedType(context, name, node) {
+function resolveNamedType(context, name, node, rubyConstructed = false) {
+    // A Go composite literal or Zig struct initializer can name a qualified cross-file type
+    // (`pkg.Type{}` / `ns.Type{}`); the receiver's typeName is then dotted text, not one
+    // identifier, so resolve the chain directly instead of treating it as a plain name.
+    if ((context.sup.id === "go" || context.sup.id === "zig") && context.optionalMemberTypes.has(node.type)) {
+        const qualified = context.resolveMemberChainTarget(node);
+        return qualified && declaresMembers(qualified) ? qualified : null;
+    }
     const target = context.resolveIdentifier(name, node);
     if (target && declaresMembers(target))
         return target;
     // A parameter/annotation type name is a closer scope binding than the class it names.
     const normalized = context.sup.normalizeIdentifier(name);
     const typed = context.moduleEntry.locals.filter((local) => context.sup.normalizeIdentifier(local.localName) === normalized && declaresMembers(local));
-    return typed.length === 1 ? typed[0] : null;
+    if (typed.length === 1)
+        return typed[0];
+    const imported = context.aliasToTargetDef.get(name);
+    if (imported && declaresMembers(imported))
+        return imported;
+    // A constructed `Klass.new` type, or (Ruby only) a bare capitalized constant receiver
+    // (`Calc.add(1, 2)`), uses Ruby's bare-constant visibility, and only when this file does not
+    // already have several classes of that name. Inheritance names stay on resolveIdentifier so
+    // an unproven superclass is not invented.
+    const triesRubyVisibleConstant = rubyConstructed || context.sup.id === "ruby";
+    if (!triesRubyVisibleConstant || typed.length > 1)
+        return null;
+    return resolveRubyVisibleConstant(context.index, context.moduleEntry, context.sup, name);
+}
+/**
+ * Zig's static-receiver call form (`module.Type.member()`): the receiver is itself a qualified
+ * member-access node naming a type through another file's export (`counter.Counter` in
+ * `counter.Counter.zero()`). `classifyReceiver` only proves an identifier or keyword receiver,
+ * so this resolves the receiver's own chain directly and defers the member lookup through the
+ * same cross-file receiver-call pipeline every other member call uses.
+ */
+function recordZigQualifiedTypeReceiverCall(context, node, access, fromId) {
+    const typeDef = context.resolveMemberChainTarget(access.receiver);
+    if (!typeDef || !declaresMembers(typeDef))
+        return false;
+    const memberName = sliceText(access.property, context.source);
+    if (!memberName)
+        return false;
+    const argumentCount = supportsReceiverMemberOverloads(context.sup.id)
+        ? getCallArgumentCount({ languageId: context.sup.id, source: context.source, call: node })
+        : null;
+    context.receiverCalls.push({
+        callerId: fromId,
+        ownerId: ensureNode(context, typeDef),
+        viaSupertypes: false,
+        memberName,
+        argumentCount,
+        site: { file: context.moduleEntry.file, range: toRange(access.property) },
+        memberScope: "any",
+    });
+    return true;
+}
+/**
+ * Go's `d.Base.Run()`: `d.Base` explicitly names an embedded field to reach a promoted method
+ * that a derived type's own same-named method would otherwise shadow, Go's equivalent of
+ * `super`/`base`. `classifyReceiver` only proves an identifier or keyword receiver, so a
+ * dotted `d.Base` receiver is never classified. This resolves `d`'s own type, confirms `Base`
+ * is really a nameless embedded field declared on it (not an unrelated named field that merely
+ * shares the name), then defers the member lookup through the same cross-file receiver-call
+ * pipeline every other member call uses. Limited to a same-file owner declaration: the AST
+ * needed to read the field list is only synchronously available there.
+ */
+function recordGoEmbeddedFieldReceiverCall(context, access, fromId, hasLexicalBinding) {
+    const parts = getMemberAccessParts(context.sup, access.receiver);
+    const objectNode = parts.object;
+    const fieldNode = parts.property;
+    if (!objectNode || !fieldNode || !isIdentifierType(context.sup, fieldNode.type))
+        return false;
+    const ownerBinding = classifyReceiver(context.sup, objectNode, context.source, null, 0, access.receiver, hasLexicalBinding);
+    if (ownerBinding?.kind !== "named-type")
+        return false;
+    const ownerDef = resolveNamedType(context, ownerBinding.typeName, ownerBinding.typeNode, ownerBinding.constructed);
+    if (!ownerDef || fileIdentityKey(ownerDef.file) !== fileIdentityKey(context.moduleEntry.file))
+        return false;
+    const embeds = MEMBER_ACCESS_ROWS.go?.receiverAncestry?.embeds;
+    if (!embeds)
+        return false;
+    const start = ownerDef.range.start.index ?? 0;
+    const nameNode = context.tree.rootNode.descendantForIndex(start, ownerDef.range.end.index ?? start);
+    const declaration = nameNode.parent;
+    const declaredType = declaration?.childForFieldName("type");
+    if (!declaration || !declaredType)
+        return false;
+    const fieldName = sliceText(fieldNode, context.source);
+    for (const rule of embeds) {
+        if (declaredType.type !== rule.body)
+            continue;
+        const list = rule.memberList ? findFirstNodeByType(declaredType, rule.memberList) : declaredType;
+        if (!list)
+            continue;
+        for (const member of list.namedChildren ?? []) {
+            if (member.type !== rule.member)
+                continue;
+            if (rule.nameless && member.childForFieldName("name"))
+                continue;
+            const specifier = rule.typeField ? member.childForFieldName(rule.typeField) : member;
+            if (!specifier || sliceText(specifier, context.source) !== fieldName)
+                continue;
+            const embeddedDef = context.resolveIdentifier(fieldName, specifier);
+            if (!embeddedDef || !declaresMembers(embeddedDef))
+                return false;
+            const memberName = sliceText(access.property, context.source);
+            if (!memberName)
+                return false;
+            context.receiverCalls.push({
+                callerId: fromId,
+                ownerId: ensureNode(context, embeddedDef),
+                viaSupertypes: false,
+                memberName,
+                argumentCount: null,
+                site: { file: context.moduleEntry.file, range: toRange(access.property) },
+                memberScope: "any",
+            });
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Collection can attach an arrow to any same-name local when the binding site is
+ * not that local (`obj.helper = () => 1` beside `const helper = 1`). Prove that
+ * this function is the value of `fn.def` itself: the declarator name is that
+ * definition, or an identifier assignment resolves to it. Member and pattern
+ * left-hand sides do not prove a local binding.
+ */
+function provesCallableBinding(context, fn) {
+    const parent = fn.node.parent;
+    if (!parent)
+        return false;
+    const start = fn.def.range.start.index;
+    const end = fn.def.range.end.index;
+    if (start === undefined || end === undefined)
+        return false;
+    const sameNodeRange = (candidate) => !!candidate && candidate.startIndex === fn.node.startIndex && candidate.endIndex === fn.node.endIndex;
+    if ((parent.type === "variable_declarator" ||
+        parent.type === "public_field_definition" ||
+        parent.type === "field_definition") &&
+        sameNodeRange(parent.childForFieldName("value"))) {
+        const bindingName = parent.childForFieldName("name") ?? parent.childForFieldName("property");
+        return (!!bindingName &&
+            (isIdentifierType(context.sup, bindingName.type) || context.propertyIdentifierTypes.includes(bindingName.type)) &&
+            bindingName.startIndex === start &&
+            bindingName.endIndex === end);
+    }
+    if (parent.type === "assignment_expression" && sameNodeRange(parent.childForFieldName("right"))) {
+        const left = parent.childForFieldName("left");
+        if (!left || !isIdentifierType(context.sup, left.type))
+            return false;
+        const resolved = context.resolveIdentifier(sliceText(left, context.source), left);
+        return !!resolved && defNodeId(resolved) === defNodeId(fn.def);
+    }
+    return false;
+}
+/**
+ * Whether a resolved member can be a `calls` target: a function, a class, or a binding the
+ * declaration pass proved holds a function. A plain value (`export const value = 1`) is not.
+ */
+/** A JS/TS class is not callable without `new`; construction is an `instantiates` edge instead. */
+function isCallTarget(context, def) {
+    return def.kind === SymbolKind.Function || !!context.nodes.get(defNodeId(def))?.callable;
+}
+/**
+ * A member of a proven same-file TS namespace receiver, selected with navigation's container and
+ * overload rules. `undefined` means the receiver is not such a namespace.
+ */
+function resolveTypeScriptNamespaceMember(context, call, receiverNode, property) {
+    if ((context.sup.id !== "ts" && context.sup.id !== "tsx") || !isIdentifierType(context.sup, receiverNode.type))
+        return undefined;
+    const receiver = context.resolveIdentifier(sliceText(receiverNode, context.source), receiverNode);
+    if (!receiver || fileIdentityKey(receiver.file) !== fileIdentityKey(context.moduleEntry.file))
+        return undefined;
+    const member = sliceText(property, context.source);
+    const candidates = findTypeScriptNamespaceMemberCandidates(context.moduleEntry.locals, member, receiver, context);
+    if (!candidates.length)
+        return undefined;
+    const selected = selectMember([receiver], {
+        ownerKey: (def) => def.callable?.owner ?? fileIdentityKey(def.file),
+        members: () => candidates,
+        supertypes: () => [],
+        name: (def) => def.localName,
+        key: (def) => def.callable?.key ?? `${fileIdentityKey(def.file)}:${def.range.start.index}`,
+        callable: (def) => def.callable,
+        scope: () => "any",
+        visible: () => true,
+    }, {
+        name: member,
+        argumentCount: getCallArgumentCount({ languageId: context.sup.id, source: context.source, call }),
+        scope: "any",
+        useFile: context.moduleEntry.file,
+    });
+    return selected.status === "unique" ? selected.member : null;
+}
+function recordTypeScriptNamespaceCall(context, call, access, fromId) {
+    const selected = resolveTypeScriptNamespaceMember(context, call, access.receiver, access.property);
+    if (selected === undefined)
+        return false;
+    if (selected && isCallTarget(context, selected))
+        recordDefEdge(context, fromId, selected, "calls", access.property);
+    return true;
+}
+/** `new N.C()` on a same-file TS namespace constructs the namespace's class. */
+function recordTypeScriptNamespaceConstruction(context, node, target, fromId) {
+    if (!isMemberAccessNode(context.sup, target))
+        return false;
+    const { object, property } = getMemberAccessParts(context.sup, target);
+    if (!object || !property)
+        return false;
+    const selected = resolveTypeScriptNamespaceMember(context, node, object, property);
+    if (selected === undefined)
+        return false;
+    if (selected?.kind === SymbolKind.Class)
+        recordDefEdge(context, fromId, selected, "instantiates", property);
+    return true;
+}
+/** A member call on a `typeof import("spec")` binding names that module's export. */
+function recordImportTypeCall(context, access, fromId, proof) {
+    if (!isJsTsLanguage(context.sup.id))
+        return false;
+    const importType = proof.kind === "named-type" ? proof.typeNode : null;
+    const specifier = importType?.type === "type_query" ? importTypeQuerySpecifier(importType) : null;
+    if (!specifier)
+        return false;
+    const member = sliceText(access.property, context.source);
+    const target = resolveImportTypeMember(context.index, context.moduleEntry.file, specifier, member);
+    if (target && isCallTarget(context, target))
+        recordDefEdge(context, fromId, target, "calls", access.property);
+    return true;
+}
+/** Swift `Foo()` / `Worker(name:)` is construction. Record `instantiates` and skip the call path. */
+function recordSwiftCapitalizedConstruction(context, node, fromId) {
+    const constructed = constructionTypeName(node, context.source, context.sup);
+    if (!constructed)
+        return false;
+    const name = sliceText(constructed, context.source);
+    // An inherited method can share a type's name; a deferred member lookup decides after the walk.
+    if (context.resolveName(name, constructed)?.status === "deferred")
+        return false;
+    const target = context.resolveIdentifier(name, constructed);
+    if (!target || !declaresMembers(target))
+        return false;
+    recordDefEdge(context, fromId, target, "instantiates", constructed);
+    return true;
+}
+function recordGoBuiltinConstruction(context, node, fromId) {
+    const callTarget = getCallTarget(node);
+    const calleeName = callTarget && isIdentifierType(context.sup, callTarget.type) ? sliceText(callTarget, context.source) : null;
+    if (calleeName !== "new" && calleeName !== "make")
+        return undefined;
+    const argList = node.childForFieldName("arguments") ?? node.childForFieldName("argument_list");
+    const typeNode = argList?.namedChildren?.find((child) => child.type === "type_identifier") ?? null;
+    if (typeNode)
+        tryResolveNode(context, typeNode, fromId, "instantiates");
+    return false;
+}
+function recordRubySuper(context, fn, superNode, fromId) {
+    const container = nearestMemberContainer(fn.node);
+    if (!container || container.type !== "class")
+        return;
+    const owner = memberContainerDef(context.moduleEntry, container);
+    if (!owner)
+        return;
+    context.receiverCalls.push({
+        callerId: fromId,
+        ownerId: ensureNode(context, owner),
+        viaSupertypes: true,
+        memberName: fn.def.localName,
+        argumentCount: null,
+        site: { file: context.moduleEntry.file, range: toRange(superNode) },
+        memberScope: "any",
+    });
 }
-export function emitFunctionBodyEdges(context, functionNodes) {
+function recordRubyCall(context, node, fromId, resolveCallTarget) {
+    if (node.type !== "call")
+        return undefined;
+    const methodNode = node.childForFieldName("method");
+    const receiverNode = node.childForFieldName("receiver");
+    const methodName = methodNode ? sliceText(methodNode, context.source) : null;
+    if (methodName === "new" && receiverNode) {
+        const recorded = tryResolveNode(context, receiverNode, fromId, "instantiates");
+        if (!recorded) {
+            const rubyType = resolveRubyVisibleConstant(context.index, context.moduleEntry, context.sup, sliceText(receiverNode, context.source));
+            if (rubyType)
+                recordDefEdge(context, fromId, rubyType, "instantiates", receiverNode);
+        }
+        return false;
+    }
+    if (methodNode?.type === "super")
+        return true;
+    if (methodNode) {
+        resolveCallTarget(node, methodNode);
+        return false;
+    }
+    const callee = getCallTarget(node);
+    if (callee?.type === "super")
+        return true;
+    resolveCallTarget(node, callee);
+    return false;
+}
+/** Specialized syntax stays with its language; the common walker only dispatches these hooks. */
+export const SPECIALIZED_EDGE_PASSES = {
+    python: { beforeModule: emitPythonDecoratorEdges },
+    rust: {
+        afterModule: emitRustImplEdges,
+        onNode(context, _fn, node, fromId) {
+            if (node.type === "token_tree")
+                recordRustMacroArgumentCalls(context, node, fromId);
+            return undefined;
+        },
+    },
+    go: {
+        onReceiverCall(context, access, fromId, hasLexicalBinding) {
+            return (context.optionalMemberTypes.has(access.receiver.type) &&
+                recordGoEmbeddedFieldReceiverCall(context, access, fromId, hasLexicalBinding));
+        },
+        onCall: recordGoBuiltinConstruction,
+    },
+    ruby: {
+        onNode(context, fn, node, fromId) {
+            if (node.type !== "super")
+                return undefined;
+            recordRubySuper(context, fn, node, fromId);
+            return true;
+        },
+        onCall: recordRubyCall,
+    },
+    swift: {
+        onCall(context, node, fromId) {
+            return recordSwiftCapitalizedConstruction(context, node, fromId) ? true : undefined;
+        },
+    },
+};
+export async function emitFunctionBodyEdges(context, functionNodes) {
+    const specialized = SPECIALIZED_EDGE_PASSES[context.sup.id];
+    const qualifiedConstructionTargets = [];
+    // C# calls through a dotted receiver (`P.Mix.M()`, `Imported.Outer.Inner.M()`): navigation's
+    // member-access resolution decides the target after the walk, so both consumers agree.
+    const dottedReceiverCalls = [];
     const callNodeTypes = new Set([
         "call_expression",
         "call",
@@ -229,21 +834,29 @@ export function emitFunctionBodyEdges(context, functionNodes) {
         "nullsafe_member_call_expression",
         "scoped_call_expression",
     ]);
-    const newNodeTypes = new Set([
-        "new_expression",
-        "object_creation_expression",
-        "struct_expression",
-        "composite_literal",
-    ]);
-    // Receiver typing and lexical member lookup are only needed once a receiver call
-    // fails the cheaper identifier and import-chain resolution, so both are lazy.
+    const newNodeTypes = {
+        new_expression: true,
+        object_creation_expression: true,
+        struct_expression: true,
+        composite_literal: true,
+        // tree-sitter-zig's own struct-literal node, e.g. `Widget{}` or a qualified `ns.Widget{}`.
+        struct_initializer: true,
+    };
+    // Receiver typing and lexical member lookup are initialized only for receiver calls.
+    const receiverProofs = new Map();
+    const hasLexicalBinding = (callee) => {
+        const scope = context.index.scopeCache.get(fileIdentityKey(context.moduleEntry.file));
+        return !scope || !!findClosestScopeBinding(scope, sliceText(callee, context.source), callee, context.sup);
+    };
     let membersByContainer;
     const lexicalMembers = (container) => {
         if (!membersByContainer) {
             membersByContainer = new Map();
             for (const candidate of functionNodes) {
+                if (!isClassMemberFunction(candidate))
+                    continue;
                 const owner = nearestMemberContainer(candidate.node);
-                if (!owner)
+                if (!owner || !isDirectKeywordMemberDeclaration(candidate.node, owner))
                     continue;
                 const members = membersByContainer.get(owner.startIndex);
                 if (members)
@@ -254,10 +867,21 @@ export function emitFunctionBodyEdges(context, functionNodes) {
         }
         return membersByContainer.get(container.startIndex) ?? [];
     };
-    const receiverProofs = new Map();
     for (const fn of functionNodes) {
+        const phpCaseInsensitive = context.sup.id === "php";
         const fromId = ensureNode(context, fn.def);
+        const provenNode = context.nodes.get(fromId);
+        // Function-valued bindings (`const helper = () => 1`) keep their `variable` kind;
+        // the callable metadata records that this binding was proven to hold a function.
+        if (provenNode && provenNode.kind !== "function" && provesCallableBinding(context, fn)) {
+            provenNode.callable = true;
+            context.noteCallableName(fn.name, context.sup.id === "php");
+        }
         const seenAliases = new Set();
+        // Calls whose target needs an async member lookup (C++ out-of-line owner members, included
+        // C/C++ declarations of one callable); settled after the walk.
+        const deferredCalls = [];
+        const qualifiedCppCalls = [];
         const nestedFunctions = new Set(functionNodes
             .filter((candidate) => candidate.node !== fn.node &&
             candidate.node.startIndex >= fn.node.startIndex &&
@@ -267,12 +891,28 @@ export function emitFunctionBodyEdges(context, functionNodes) {
             if (context.membersOnly || !isIdentifierType(context.sup, node.type))
                 return;
             const name = sliceText(node, context.source);
+            if (context.sup.id === "php") {
+                // Resolve the occurrence's namespace; a plain-name map cannot distinguish PHP roles.
+                const importType = inferPhpQualifiedReferenceImportType(node) ?? "const";
+                const aliasName = importType === "const" ? name : foldPhpIdentifierCase(name);
+                const seenKey = `${importType}:${aliasName}`;
+                if (seenAliases.has(seenKey))
+                    return;
+                seenAliases.add(seenKey);
+                const phpImport = findPhpImportAlias(context.moduleEntry.imports, name, importType);
+                if (!phpImport || typeof phpImport.resolved !== "string")
+                    return;
+                const resolved = resolvePhpExportByImportType(context.index, phpImport.resolved, phpImport.imported, importType);
+                if (resolved?.kind === "resolved")
+                    recordDefEdge(context, fromId, resolved.def, "uses");
+                return;
+            }
             if (seenAliases.has(name))
                 return;
             let target = context.aliasToTargetDef.get(name) ?? null;
             if (!target) {
                 const modFile = context.aliasToTargetModule.get(name);
-                if (modFile) {
+                if (modFile && context.moduleAliasIsUnshadowed(name, node)) {
                     let exportedName = null;
                     const parent = node.parent;
                     if (parent &&
@@ -284,7 +924,7 @@ export function emitFunctionBodyEdges(context, functionNodes) {
                     }
                     if (exportedName) {
                         target = context.resolveExportFrom(modFile, exportedName);
-                        if (!target) {
+                        if (!target && (context.sup.id !== "go" || isGoExportedMemberName(context.sup.id, exportedName))) {
                             const targetModule = context.index.byFile.get(fileIdentityKey(modFile));
                             target = (targetModule?.locals ?? []).find((local) => local.localName === exportedName) ?? null;
                         }
@@ -304,22 +944,44 @@ export function emitFunctionBodyEdges(context, functionNodes) {
                 recordDefEdge(context, fromId, targetDef, "uses");
             }
         };
+        const classifyImport = (name, node) => {
+            if (isJsTsLanguage(context.sup.id) && isIdentifierType(context.sup, node.type)) {
+                const imported = effectiveExplicitBinding(context.moduleEntry.imports, context.sup.id, (candidate) => candidate.kind === "namespace" && candidate.localNS === name, node.startIndex) ?? innermostNamespaceImport(context.moduleEntry.imports, name, node);
+                if (imported?.mechanism === "cjs" && typeof imported.resolved === "string") {
+                    const value = cjsRequireValueBinding(context.index, imported.resolved);
+                    const lexical = value ? context.resolveIdentifier(name, node) : null;
+                    if (value && declaresMembers(value) && lexical && defNodeId(value) === defNodeId(lexical)) {
+                        return "static-type";
+                    }
+                    return "module-import";
+                }
+            }
+            if (context.aliasToTargetModule.has(name) && context.moduleAliasIsUnshadowed(name, node)) {
+                return "module-import";
+            }
+            return null;
+        };
         /**
          * Resolves a receiver method call against the receiver's type. Members declared
          * alongside the caller resolve here; anything needing another module's members
          * becomes a deferred candidate.
          */
-        const recordReceiverCall = (node, access) => {
+        const recordReceiverCall = (node, access, forcedMemberScope, proof) => {
             const memberName = sliceText(access.property, context.source);
-            if (!memberName || !context.hasCallableNamed(memberName))
+            if (!memberName)
                 return;
-            const binding = classifyReceiver(context.sup, access.receiver, context.source, receiverProofs, fn.node.startIndex, access.accessNode);
-            if (!binding)
+            const binding = proof ??
+                classifyReceiver(context.sup, access.receiver, context.source, receiverProofs, fn.node.startIndex, access.accessNode, hasLexicalBinding, classifyImport);
+            if (binding.kind === "module-import" || binding.kind === "unknown")
                 return;
             const site = { file: context.moduleEntry.file, range: toRange(access.property) };
-            const argumentCount = callArgumentCount(node);
+            // Shared call-count facts treat unproven spread expansions as unknown (null),
+            // so overload selection never fabricates an argument count.
+            const argumentCount = supportsReceiverMemberOverloads(context.sup.id)
+                ? getCallArgumentCount({ languageId: context.sup.id, source: context.source, call: node })
+                : null;
             if (binding.kind === "named-type") {
-                const typeDef = resolveNamedType(context, binding.typeName, access.receiver);
+                const typeDef = resolveNamedType(context, binding.typeName, binding.typeNode, binding.constructed);
                 if (!typeDef)
                     return;
                 context.receiverCalls.push({
@@ -329,26 +991,89 @@ export function emitFunctionBodyEdges(context, functionNodes) {
                     memberName,
                     argumentCount,
                     site,
+                    memberScope: forcedMemberScope ?? binding.memberScope,
+                    ...(context.sup.id === "go" && !isGoExportedMemberName(context.sup.id, memberName)
+                        ? { goPackagePeerFiles: getCompilationUnitPeers(context.index, context.moduleEntry.file).files }
+                        : {}),
+                    caseInsensitiveMemberName: phpCaseInsensitive,
                 });
                 return;
             }
             if (binding.kind === "own-type") {
                 const container = nearestMemberContainer(fn.node);
                 const declared = container
-                    ? lexicalMembers(container).filter((candidate) => candidate.def.localName === memberName)
+                    ? lexicalMembers(container).filter((candidate) => {
+                        const candidateName = candidate.def.localName;
+                        const nameMatches = phpCaseInsensitive
+                            ? foldPhpIdentifierCase(candidateName) === foldPhpIdentifierCase(memberName)
+                            : candidateName === memberName;
+                        if (!nameMatches)
+                            return false;
+                        if (binding.memberScope === "any")
+                            return true;
+                        return declarationNodeIsStatic(candidate.node, context.source) === (binding.memberScope === "static");
+                    })
                     : [];
                 if (declared.length === 1) {
-                    recordDefEdge(context, fromId, declared[0].def, "calls", access.property);
-                    return;
+                    const unique = declared[0];
+                    recordDefEdge(context, fromId, unique.def, "calls", access.property);
+                    // File-hidden Swift members stay off cross-file shared owners. Skipping the
+                    // coalesced deferred lookup keeps a same-container private call from being stripped.
+                    if (isSwiftFileHiddenSharedOwnerMember(context.sup.id, unique.node))
+                        return;
                 }
             }
+            const receiverContainer = nearestMemberContainer(access.accessNode);
+            const receiverContainerName = receiverContainer?.childForFieldName("name");
+            const receiverOwnerDef = receiverContainerName
+                ? context.moduleEntry.locals.find((local) => local.range.start.index === receiverContainerName.startIndex && declaresMembers(local))
+                : undefined;
             context.receiverCalls.push({
                 callerId: fromId,
-                ownerId: null,
+                ownerId: receiverOwnerDef ? ensureNode(context, receiverOwnerDef) : null,
                 viaSupertypes: binding.kind === "supertype",
                 memberName,
                 argumentCount,
                 site,
+                memberScope: binding.memberScope,
+                caseInsensitiveMemberName: phpCaseInsensitive,
+            });
+        };
+        /**
+         * A bare call inside a member function carries no receiver syntax, but in
+         * languages where that implicitly targets `this` it can still name an
+         * inherited member. Deferred like `recordReceiverCall`'s own-type/supertype
+         * candidates so cross-file base-type members resolve once every module's
+         * `member_of` and hierarchy edges are known.
+         */
+        const recordImplicitSelfMemberCall = (node, callee, fallbackDef = null) => {
+            if (!supportsImplicitSelfMemberCalls(context.sup.id) || !isIdentifierType(context.sup, callee.type))
+                return;
+            const container = nearestMemberContainer(fn.node);
+            const containerName = container?.childForFieldName("name");
+            const ownerDef = containerName
+                ? context.moduleEntry.locals.find((local) => local.range.start.index === containerName.startIndex && declaresMembers(local))
+                : undefined;
+            if (!ownerDef)
+                return;
+            const memberName = sliceText(callee, context.source);
+            if (!memberName)
+                return;
+            const argumentCount = supportsReceiverMemberOverloads(context.sup.id)
+                ? getCallArgumentCount({ languageId: context.sup.id, source: context.source, call: node })
+                : null;
+            context.receiverCalls.push({
+                callerId: fromId,
+                ownerId: ensureNode(context, ownerDef),
+                viaSupertypes: false,
+                memberName,
+                argumentCount,
+                site: { file: context.moduleEntry.file, range: toRange(callee) },
+                // A static caller can only reach a static bare member; an instance caller
+                // may bare-call either, matching C#'s unqualified invocation rules.
+                memberScope: nodeInStaticMemberContext(fn.node, context.source) ? "static" : "any",
+                caseInsensitiveMemberName: phpCaseInsensitive,
+                fallbackTargetId: fallbackDef ? ensureNode(context, fallbackDef) : undefined,
             });
         };
         /**
@@ -360,46 +1085,116 @@ export function emitFunctionBodyEdges(context, functionNodes) {
         const resolveCallTarget = (node, callee) => {
             const access = receiverCallAccess(context.sup, node, callee);
             if (access) {
-                if (!tryResolveChain(context, access.accessNode, fromId, "calls"))
-                    recordReceiverCall(node, access);
+                if (recordTypeScriptNamespaceCall(context, node, access, fromId))
+                    return;
+                const typeScopedCppCall = context.sup.id === "cpp" &&
+                    context.source.slice(access.receiver.endIndex, access.property.startIndex).includes("::");
+                if (typeScopedCppCall) {
+                    const qualifiedName = cppQualifiedNameSegments(access.accessNode, context.source).join("::");
+                    const qualifiedTarget = context.resolveIdentifier(qualifiedName, access.property);
+                    // Whether the owner is a class, and whether the caller has an implicit `this` of that class,
+                    // needs the exact qualified path, so the decision waits until the function body is walked.
+                    qualifiedCppCalls.push({
+                        node,
+                        access,
+                        target: qualifiedTarget,
+                        ownerPath: qualifiedName.split("::").slice(0, -1),
+                    });
+                    return;
+                }
+                const receiverProof = classifyReceiver(context.sup, access.receiver, context.source, receiverProofs, fn.node.startIndex, access.accessNode, hasLexicalBinding, classifyImport);
+                if (recordImportTypeCall(context, access, fromId, receiverProof))
+                    return;
+                if (supportsDeclaredFieldChains(context.sup.id) && isMemberAccessNode(context.sup, access.receiver)) {
+                    dottedReceiverCalls.push({ fromId, access });
+                    return;
+                }
+                if (receiverProof.kind === "own-type" || receiverProof.kind === "supertype") {
+                    recordReceiverCall(node, access, undefined, receiverProof);
+                    return;
+                }
+                if (context.sup.id === "swift" &&
+                    isIdentifierType(context.sup, access.receiver.type) &&
+                    context.resolveIdentifier(sliceText(access.receiver, context.source), access.receiver)?.kind ===
+                        SymbolKind.TypeAlias) {
+                    dottedReceiverCalls.push({ fromId, access });
+                    return;
+                }
+                if (tryResolveChain(context, access.accessNode, fromId, "calls"))
+                    return;
+                if (context.sup.id === "zig" &&
+                    context.optionalMemberTypes.has(access.receiver.type) &&
+                    recordZigQualifiedTypeReceiverCall(context, node, access, fromId)) {
+                    return;
+                }
+                if (specialized?.onReceiverCall?.(context, access, fromId, hasLexicalBinding))
+                    return;
+                const javaConstructionType = context.sup.id === "java" && access.receiver.type === "object_creation_expression"
+                    ? constructionTypeName(access.receiver, context.source, context.sup)
+                    : null;
+                if (context.sup.id === "java" &&
+                    javaConstructionType &&
+                    isMemberAccessNode(context.sup, javaConstructionType)) {
+                    dottedReceiverCalls.push({ fromId, access });
+                    return;
+                }
+                if (context.sup.id === "kotlin" &&
+                    (isIdentifierType(context.sup, access.receiver.type) || access.receiver.type === "navigation_expression") &&
+                    !context.resolveIdentifier(sliceText(access.receiver, context.source), access.receiver)) {
+                    dottedReceiverCalls.push({ fromId, access });
+                    return;
+                }
+                recordReceiverCall(node, access, undefined, receiverProof);
                 return;
             }
-            if (callee)
-                tryResolveNode(context, callee, fromId, "calls");
+            if (!callee)
+                return;
+            // A name whose lookup waits on an async member step (implicit `this`/`self`, C++ out-of-line
+            // owners, included C/C++ declarations) settles after the walk exactly as navigation does.
+            if (isIdentifierType(context.sup, callee.type)) {
+                const name = sliceText(callee, context.source);
+                const resolution = context.resolveName(name, callee);
+                if (resolution?.status === "deferred") {
+                    deferredCalls.push({ callee, name, resolution });
+                    return;
+                }
+            }
+            if (!tryResolveNode(context, callee, fromId, "calls"))
+                recordImplicitSelfMemberCall(node, callee);
         };
         const recordCallOrInstantiation = (node) => {
+            const nodeResult = specialized?.onNode?.(context, fn, node, fromId);
+            if (nodeResult !== undefined)
+                return nodeResult;
             if (callNodeTypes.has(node.type)) {
-                if (context.sup.id === "go") {
-                    const callTarget = getCallTarget(node);
-                    const calleeName = callTarget && isIdentifierType(context.sup, callTarget.type) ? sliceText(callTarget, context.source) : null;
-                    if (calleeName === "new" || calleeName === "make") {
-                        const argList = node.childForFieldName("arguments") ?? node.childForFieldName("argument_list");
-                        const typeNode = argList?.namedChildren?.find((child) => child.type === "type_identifier") ?? null;
-                        if (typeNode) {
-                            tryResolveNode(context, typeNode, fromId, "instantiates");
-                        }
-                        return false;
-                    }
+                const callResult = specialized?.onCall?.(context, node, fromId, resolveCallTarget);
+                if (callResult !== undefined)
+                    return callResult;
+                resolveCallTarget(node, getCallTarget(node));
+            }
+            if (newNodeTypes[node.type]) {
+                const keyword = phpObjectCreationKeyword(node, context.source, context.sup);
+                if (keyword) {
+                    const created = resolvePhpObjectCreationTarget(context.index, context.moduleEntry, keyword, context.source, context.sup);
+                    if (created)
+                        recordDefEdge(context, fromId, created, "instantiates", keyword.nameNode);
                 }
-                if (context.sup.id === "ruby" && node.type === "call") {
-                    const methodNode = node.childForFieldName("method");
-                    const receiverNode = node.childForFieldName("receiver");
-                    const methodName = methodNode ? sliceText(methodNode, context.source) : null;
-                    if (methodName === "new" && receiverNode) {
-                        tryResolveNode(context, receiverNode, fromId, "instantiates");
-                        return false;
-                    }
-                    if (methodNode) {
-                        resolveCallTarget(node, methodNode);
-                        return false;
+                else {
+                    const target = constructionTypeName(node, context.source, context.sup) ?? getNewTarget(node);
+                    if (target) {
+                        if (recordTypeScriptNamespaceConstruction(context, node, target, fromId))
+                            return true;
+                        const property = isMemberAccessNode(context.sup, target)
+                            ? getMemberAccessParts(context.sup, target).property
+                            : null;
+                        if ((context.sup.id === "java" || context.sup.id === "csharp") && property) {
+                            qualifiedConstructionTargets.push({ fromId, member: property, target });
+                        }
+                        else {
+                            tryResolveNode(context, target, fromId, "instantiates");
+                        }
                     }
                 }
-                resolveCallTarget(node, getCallTarget(node));
-            }
-            if (newNodeTypes.has(node.type)) {
-                const target = getNewTarget(node);
-                if (target)
-                    tryResolveNode(context, target, fromId, "instantiates");
             }
             return true;
         };
@@ -413,11 +1208,54 @@ export function emitFunctionBodyEdges(context, functionNodes) {
                 walkFunctionBody(child, allowChildCallProcessing);
         };
         walkFunctionBody(fn.node, true);
+        for (const call of deferredCalls) {
+            const target = await context.settleName(call.name, call.callee, call.resolution);
+            // Swift `Foo()` whose deferred lookup settles on a type is construction.
+            const label = context.sup.id === "swift" && target && declaresMembers(target) ? "instantiates" : "calls";
+            if (target)
+                recordDefEdge(context, fromId, target, label, call.callee);
+        }
+        for (const call of qualifiedCppCalls) {
+            const owner = call.ownerPath.length
+                ? await resolveCppQualifiedMemberContainer(context.index, context.moduleEntry, call.ownerPath, context.loadParsedFile)
+                : null;
+            if (!owner) {
+                // A namespace (or no) qualifier names the free function directly.
+                if (call.target)
+                    recordDefEdge(context, fromId, call.target, "calls", call.access.property);
+                continue;
+            }
+            const implicitThis = await cppQualifiedOwnerHasImplicitThis(context.index, context.moduleEntry, call.access.accessNode, context.source, context.sup, owner);
+            if (implicitThis && call.target) {
+                recordDefEdge(context, fromId, call.target, "calls", call.access.property);
+            }
+            else {
+                // Without an implicit `this` of the owner, `Owner::member()` can only name a static member.
+                recordReceiverCall(call.node, call.access, implicitThis ? "any" : "static");
+            }
+        }
+    }
+    for (const { fromId, access } of dottedReceiverCalls) {
+        const member = await context.resolveMemberAccessTarget(access.property);
+        // The graph records no edge for a call its target cannot accept, as for other member calls.
+        if (member && memberAcceptsCallAt(context.index, member, access.accessNode, context.source, context.sup.id)) {
+            recordDefEdge(context, fromId, member, "calls", access.property);
+        }
+    }
+    for (const target of qualifiedConstructionTargets) {
+        const resolved = await context.resolveMemberAccessTarget(target.member);
+        if (resolved) {
+            recordDefEdge(context, target.fromId, resolved, "instantiates", target.member);
+        }
+        else {
+            tryResolveNode(context, target.target, target.fromId, "instantiates");
+        }
     }
 }
 /** Qualifiers name a container, not another base type. */
 const QUALIFIER_NAME_FIELD = {
     qualified_name: "name", // C#: Namespace.Base, Outer.Inner
+    alias_qualified_name: "name", // C#: X::Base, global::Namespace.Base
     qualified_identifier: "name", // C++: ns::Base
     scope_resolution: "name", // Ruby: Module::Base
     qualified_type: "name", // Go: pkg.Base
@@ -504,9 +1342,19 @@ function narrowBaseSpecifierNode(node) {
 }
 /** Collect one type identifier per direct base or interface specifier. */
 function collectBaseSpecifierIdentifiers(node, sup, out) {
+    if (isUnprovenHeritageExpression(node))
+        return;
     if (BASE_TYPE_IGNORED_TYPES[node.type])
         return;
+    if (sup.id === "cpp" && node.type === "qualified_identifier") {
+        out.push(node);
+        return;
+    }
     const narrowed = narrowBaseSpecifierNode(node);
+    if ((sup.id === "ts" || sup.id === "tsx") && narrowed.type === "member_expression") {
+        out.push(narrowed);
+        return;
+    }
     if (isIdentifierType(sup, narrowed.type) || narrowed.type === "type_identifier") {
         out.push(narrowed);
         return;
@@ -514,19 +1362,39 @@ function collectBaseSpecifierIdentifiers(node, sup, out) {
     for (const child of narrowed.namedChildren ?? [])
         collectBaseSpecifierIdentifiers(child, sup, out);
 }
-function recordIdentifierRelations(context, fromId, container, relationForTarget) {
+async function recordIdentifierRelations(context, fromId, container, relationForTarget) {
     const identifiers = [];
     collectBaseSpecifierIdentifiers(container, context.sup, identifiers);
     const seen = new Set();
     for (const [index, identifier] of identifiers.entries()) {
-        const target = context.resolveIdentifier(sliceText(identifier, context.source), identifier);
+        let target;
+        if (context.sup.id === "cpp" && identifier.type === "qualified_identifier") {
+            const qualifiedPath = cppQualifiedNameSegments(identifier, context.source);
+            target = await resolveCppQualifiedMemberContainer(context.index, context.moduleEntry, qualifiedPath, context.loadParsedFile);
+            if (!target && qualifiedPath.length > 1) {
+                target = context.resolveIdentifier(qualifiedPath.join("::"), identifier);
+            }
+        }
+        else if ((context.sup.id === "ts" || context.sup.id === "tsx") && identifier.type === "member_expression") {
+            const qualified = context.resolveMemberChainTarget(identifier);
+            target = qualified && declaresMembers(qualified) ? qualified : null;
+        }
+        else {
+            const name = sliceText(identifier, context.source);
+            target = context.resolveIdentifier(name, identifier);
+            // Ruby `require` publishes a top-level constant, not a nested one. Reuse the
+            // same visibility as goto so `class Worker < Base` follows the required class.
+            if (!target && context.sup.id === "ruby") {
+                target = resolveRubyVisibleConstant(context.index, context.moduleEntry, context.sup, name);
+            }
+        }
         if (!target)
             continue;
         const targetId = defNodeId(target);
         if (seen.has(targetId))
             continue;
         seen.add(targetId);
-        recordDefEdge(context, fromId, target, relationForTarget(target, index), identifier);
+        recordDefEdge(context, fromId, target, relationForTarget(target, index, identifier), identifier);
     }
 }
 const RUBY_NESTED_SCOPE_TYPES = new Set(["class", "module", "method", "singleton_method", "block", "do_block"]);
@@ -540,68 +1408,24 @@ function collectDirectCallsExcludingNestedScopes(node, out) {
         collectDirectCallsExcludingNestedScopes(child, out);
     }
 }
-const TYPESCRIPT_INHERITANCE_RULES = {
-    clauses: [
-        // The value field is the superclass expression; the sibling type_arguments
-        // field holds super-call type arguments, which are not base types.
-        { type: "extends_clause", label: "extends", field: "value" },
-        { type: "implements_clause", label: "implements" },
-    ],
-};
-/**
- * Per-language class hierarchy forms. The grammar and the language runtime are
- * the only sources of these node names: JavaScript emits `class_heritage` for
- * `extends`, while TypeScript emits `extends_clause` and `implements_clause`.
- */
-const INHERITANCE_RULES = {
-    js: { clauses: [{ type: "class_heritage", label: "extends" }] },
-    ts: TYPESCRIPT_INHERITANCE_RULES,
-    tsx: TYPESCRIPT_INHERITANCE_RULES,
-    java: {
-        clauses: [
-            { type: "superclass", label: "extends" },
-            { type: "super_interfaces", label: "implements" },
-        ],
-    },
-    csharp: { clauses: [{ type: "base_list", label: "superclass-first" }] },
-    kotlin: { clauses: [{ type: "delegation_specifiers", label: "superclass-first" }] },
-    swift: { clauses: [{ type: "inheritance_specifier", label: "superclass-first", each: true }] },
-    python: { clauses: [{ type: "argument_list", label: "extends" }] },
-    php: {
-        clauses: [
-            { type: "base_clause", label: "extends" },
-            { type: "class_interface_clause", label: "implements" },
-            { type: "use_declaration", label: "trait", each: true },
-        ],
-    },
-    ruby: {
-        clauses: [{ type: "superclass", label: "extends" }],
-        mixinCalls: ["include", "extend", "prepend"],
-    },
-    cpp: { clauses: [{ type: "base_class_clause", label: "extends" }] },
-    go: {
-        clauses: [],
-        embeds: [
-            { body: "interface_type", member: "type_elem" },
-            {
-                body: "struct_type",
-                memberList: "field_declaration_list",
-                member: "field_declaration",
-                typeField: "type",
-                nameless: true,
-            },
-        ],
-    },
-};
-function baseClauseRelation(label, target, index, interfaceIds) {
+function baseClauseRelation(label, target, index, interfaceIds, identifier, kotlin) {
     if (label !== "superclass-first")
         return label;
+    if (kotlin) {
+        let current = identifier.parent;
+        while (current && current.type !== "delegation_specifiers") {
+            if (current.type === "constructor_invocation")
+                return "extends";
+            current = current.parent;
+        }
+        return "implements";
+    }
     if (interfaceIds.has(defNodeId(target)) || index > 0)
         return "implements";
     return "extends";
 }
 /** Records `implements` for every embedded type of a Go interface or struct declaration. */
-function recordEmbedRelations(context, fromId, declaration, embeds) {
+async function recordEmbedRelations(context, fromId, declaration, embeds) {
     const declaredType = declaration.childForFieldName("type");
     if (!declaredType)
         return;
@@ -619,12 +1443,12 @@ function recordEmbedRelations(context, fromId, declaration, embeds) {
             const specifier = rule.typeField ? member.childForFieldName(rule.typeField) : member;
             if (!specifier)
                 continue;
-            recordIdentifierRelations(context, fromId, specifier, () => "implements");
+            await recordIdentifierRelations(context, fromId, specifier, () => "implements");
         }
     }
 }
-export function emitClassInheritanceEdges(context, classNodes) {
-    const rules = INHERITANCE_RULES[context.sup.id];
+export async function emitClassInheritanceEdges(context, classNodes) {
+    const rules = MEMBER_ACCESS_ROWS[context.sup.id]?.receiverAncestry;
     if (!rules)
         return;
     const interfaceIds = new Set(classNodes
@@ -635,20 +1459,27 @@ export function emitClassInheritanceEdges(context, classNodes) {
         .map((candidate) => defNodeId(candidate.def)));
     for (const cls of classNodes) {
         const fromId = ensureNode(context, cls.def);
-        markImplementationTarget(context, fromId, cls.node, cls.def);
+        markImplementationTarget(context, fromId, cls.node, context.source, cls.def);
+        if ((context.sup.id === "ts" || context.sup.id === "tsx") && cls.node.type === "class_declaration") {
+            const heritage = cls.node.namedChildren.find((child) => child.type === "class_heritage");
+            const superclass = heritage?.namedChildren.find((child) => child.type === "extends_clause");
+            // TypeScript classes have one superclass. Invalid multi-base syntax proves neither target.
+            if (superclass && superclass.namedChildren.length > 1)
+                continue;
+        }
         for (const rule of rules.clauses) {
             const clauses = [];
             if (rule.each) {
-                collectNodesByType(cls.node, rule.type, clauses);
+                collectNodesByType(cls.node, rule.nodeType, clauses);
             }
             else {
-                const found = findFirstNodeByType(cls.node, rule.type);
+                const found = findFirstNodeByType(cls.node, rule.nodeType);
                 if (found)
                     clauses.push(found);
             }
             for (const clause of clauses) {
                 const specifiers = rule.field ? (clause.childForFieldName(rule.field) ?? clause) : clause;
-                recordIdentifierRelations(context, fromId, specifiers, (target, index) => baseClauseRelation(rule.label, target, index, interfaceIds));
+                await recordIdentifierRelations(context, fromId, specifiers, (target, index, identifier) => baseClauseRelation(rule.relation, target, index, interfaceIds, identifier, context.sup.id === "kotlin"));
             }
         }
         if (rules.mixinCalls) {
@@ -663,16 +1494,14 @@ export function emitClassInheritanceEdges(context, classNodes) {
                     continue;
                 const args = call.childForFieldName("arguments");
                 if (args)
-                    recordIdentifierRelations(context, fromId, args, () => "mixin");
+                    await recordIdentifierRelations(context, fromId, args, () => "mixin");
             }
         }
         if (rules.embeds)
-            recordEmbedRelations(context, fromId, cls.node, rules.embeds);
+            await recordEmbedRelations(context, fromId, cls.node, rules.embeds);
     }
 }
 export function emitRustImplEdges(context, rootNode) {
-    if (context.sup.id !== "rust")
-        return;
     const walkImpls = (node) => {
         if (node.type === "impl_item") {
             const typeIdentifiers = node.namedChildren?.filter((child) => child.type === "type_identifier") ?? [];