@lzehrung/codegraph 2.4.0 → 3.0.1

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

@@ -1,25 +1,24 @@
 import { SymbolKind } from "../../indexer/types.js";
-import { cppCallableShapeForNode } from "../../indexer/cpp-callables.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, } from "../../indexer/navigation-goto.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 { typescriptSelectOverloadCandidate } from "../../indexer/ts-callables.js";
 import { isSwiftConstrainedExtension, isSwiftExtensionContainer, selectCsharpPartialRepresentative, } from "../../indexer/shared-owner-identity.js";
 import { isJsTsLanguage } from "../../languages/js-family.js";
-import { getCallableArity, getCallArgumentCount, memberLookupBinding } from "../../languages/callable-arity.js";
+import { getCallArgumentCount, memberLookupBinding } from "../../languages/callable-arity.js";
 import { sliceText, toRange } from "../../util/ast.js";
 import { getMemberAccessParts, isMemberAccessNode, rustTokenTreeHoldsExpressions, rustTokenTreeNameFollowsSeparator, } from "../../util/member-access.js";
 import { foldPhpIdentifierCase } from "../../util/identifiers.js";
-import { MEMBER_ACCESS_ROWS, keywordReceiverKind, } from "../../util/member-access-tables.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, declarationMemberArity, findFirstNodeByType, isIdentifierType } from "./ast.js";
-import { CALL_ARGUMENT_NODE_TYPES, classifyReceiver, constructionTypeName, declarationIsStaticEquivalent, declarationNodeIsStatic, cppOutOfLineOwnerPath, cppOutOfLineMemberDeclarationNode, cppQualifiedNameSegments, csharpDottedNameRoot, declaresMembers, isUnprovenHeritageExpression, kotlinExtensionReceiverTypeNode, memberContainerDef, nearestMemberContainer, nodeInStaticMemberContext, phpObjectCreationKeyword, receiverCallAccess, rustImplSelfTypeNode, supportsImplicitSelfMemberCalls, supportsReceiverMemberOverloads, receiverConstructorExpression, importTypeQuerySpecifier, } from "./receiver-calls.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))
@@ -44,40 +43,31 @@ function markMemberArity(context, id, declarationNode) {
     if (node)
         node.memberArity = arity;
 }
-function cppShapeNode(node) {
-    return node.type === "function_declarator" ? node : (findFirstNodeByType(node, "function_declarator") ?? node);
-}
-function mergeCppCallableShapes(...shapes) {
-    const present = shapes.filter((shape) => !!shape);
-    if (!present.length)
-        return undefined;
-    let min = present[0].minArity;
-    let max = present[0].maxArity;
-    for (const shape of present.slice(1)) {
-        min = Math.min(min, shape.minArity);
-        if (max === null || shape.maxArity === null)
-            max = null;
+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
-            max = Math.max(max, shape.maxArity);
+            merged.max = Math.max(merged.max, arity.maxArgs);
     }
-    return { min, max };
+    return merged;
 }
-/**
- * Accepted explicit-argument range of a member declaration from the shared callable
- * facts (default parameters, varargs, explicit receivers), or undefined when the
- * declaration shape is unknown or the language does not select members by call arity.
- * The binding follows the call form member lookup resolves (see `memberLookupBinding`).
- */
-function acceptedMemberArityRange(context, declarationNode, source) {
+/** The member call form determines whether a declared receiver takes an argument. */
+function acceptedMemberArityRange(context, def) {
     if (!supportsReceiverMemberOverloads(context.sup.id))
         return undefined;
-    const arity = getCallableArity({
-        languageId: context.sup.id,
-        source,
-        declaration: declarationNode,
-        binding: memberLookupBinding(context.sup.id),
-    });
-    return arity ? { min: arity.minArgs, max: arity.maxArgs } : 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);
@@ -115,6 +105,7 @@ function tryResolveNode(context, node, fromId, label) {
     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);
@@ -141,7 +132,7 @@ function tryResolveNode(context, node, fromId, label) {
  * navigation's refusals inside token trees.
  */
 function recordRustMacroArgumentCalls(context, tokenTree, fromId) {
-    if (context.sup.id !== "rust" || !rustTokenTreeHoldsExpressions(tokenTree))
+    if (!rustTokenTreeHoldsExpressions(tokenTree))
         return;
     const children = tokenTree.namedChildren;
     for (let index = 0; index + 1 < children.length; index += 1) {
@@ -189,8 +180,6 @@ function getNewTarget(node) {
     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");
@@ -293,9 +282,10 @@ export async function emitMemberOwnershipEdges(context, functionNodes, classNode
         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(cppCallableShapeForNode(cppShapeNode(fn.node)), outOfLineDeclaration ? cppCallableShapeForNode(cppShapeNode(outOfLineDeclaration.node)) : undefined)
-            : acceptedMemberArityRange(context, arityNode, outOfLineDeclaration?.source ?? context.source);
+            ? 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);
@@ -493,7 +483,10 @@ function unwrapGoNamedType(node) {
 }
 /** Type-like defs only, so a PHP `use function` alias cannot steal `Example::m()`. */
 function resolveNamedType(context, name, node, rubyConstructed = false) {
-    if (context.sup.id === "go" && context.optionalMemberTypes.has(node.type)) {
+    // 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;
     }
@@ -508,13 +501,109 @@ function resolveNamedType(context, name, node, rubyConstructed = false) {
     const imported = context.aliasToTargetDef.get(name);
     if (imported && declaresMembers(imported))
         return imported;
-    // Only a constructed `Klass.new` type 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.
-    if (!rubyConstructed || typed.length > 1)
+    // 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
@@ -572,18 +661,22 @@ function resolveTypeScriptNamespaceMember(context, call, receiverNode, property)
     const candidates = findTypeScriptNamespaceMemberCandidates(context.moduleEntry.locals, member, receiver, context);
     if (!candidates.length)
         return undefined;
-    return typescriptSelectOverloadCandidate({
-        group: candidates,
-        tree: context.tree,
-        definitionOf: (candidate) => candidate,
-        declarationOf: (candidate) => {
-            const start = candidate.range.start.index ?? 0;
-            return context.tree.rootNode.descendantForIndex(start, candidate.range.end.index ?? start).parent;
-        },
-        source: context.source,
-        languageId: context.sup.id,
+    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);
@@ -608,10 +701,10 @@ function recordTypeScriptNamespaceConstruction(context, node, target, fromId) {
     return true;
 }
 /** A member call on a `typeof import("spec")` binding names that module's export. */
-function recordImportTypeCall(context, access, fromId) {
+function recordImportTypeCall(context, access, fromId, proof) {
     if (!isJsTsLanguage(context.sup.id))
         return false;
-    const importType = receiverConstructorExpression(access.receiver, context.source, context.sup);
+    const importType = proof.kind === "named-type" ? proof.typeNode : null;
     const specifier = importType?.type === "type_query" ? importTypeQuerySpecifier(importType) : null;
     if (!specifier)
         return false;
@@ -623,8 +716,6 @@ function recordImportTypeCall(context, access, fromId) {
 }
 /** Swift `Foo()` / `Worker(name:)` is construction. Record `instantiates` and skip the call path. */
 function recordSwiftCapitalizedConstruction(context, node, fromId) {
-    if (context.sup.id !== "swift")
-        return false;
     const constructed = constructionTypeName(node, context.source, context.sup);
     if (!constructed)
         return false;
@@ -638,7 +729,96 @@ function recordSwiftCapitalizedConstruction(context, node, fromId) {
     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",
+    });
+}
+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.
@@ -654,12 +834,14 @@ export async function emitFunctionBodyEdges(context, functionNodes) {
         "nullsafe_member_call_expression",
         "scoped_call_expression",
     ]);
-    const newNodeTypes = new Set([
-        "new_expression",
-        "object_creation_expression",
-        "struct_expression",
-        "composite_literal",
-    ]);
+    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) => {
@@ -729,13 +911,8 @@ export async function emitFunctionBodyEdges(context, functionNodes) {
                 return;
             let target = context.aliasToTargetDef.get(name) ?? null;
             if (!target) {
-                // A local variable can shadow a Go package alias (`u := LocalU{}` alongside
-                // `import u "pkg"`); aliasToTargetModule is a blind per-file text map, so refuse it
-                // here too whenever a closer, non-namespace scope binding owns the name.
-                const modFile = context.sup.id === "go" && context.hasNonModuleBinding(name, node)
-                    ? undefined
-                    : context.aliasToTargetModule.get(name);
-                if (modFile) {
+                const modFile = context.aliasToTargetModule.get(name);
+                if (modFile && context.moduleAliasIsUnshadowed(name, node)) {
                     let exportedName = null;
                     const parent = node.parent;
                     if (parent &&
@@ -767,28 +944,35 @@ export async 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, forcedMemberScope) => {
+        const recordReceiverCall = (node, access, forcedMemberScope, proof) => {
             const memberName = sliceText(access.property, context.source);
             if (!memberName)
                 return;
-            let binding = classifyReceiver(context.sup, access.receiver, context.source, receiverProofs, fn.node.startIndex, access.accessNode, hasLexicalBinding);
-            if (isJsTsLanguage(context.sup.id) && isIdentifierType(context.sup, access.receiver.type)) {
-                const receiverName = sliceText(access.receiver, context.source);
-                const imported = effectiveExplicitBinding(context.moduleEntry.imports, context.sup.id, (candidate) => candidate.kind === "namespace" && candidate.localNS === receiverName, access.receiver.startIndex) ?? innermostNamespaceImport(context.moduleEntry.imports, receiverName, access.receiver);
-                if (imported?.mechanism === "cjs" && typeof imported.resolved === "string") {
-                    const value = cjsRequireValueBinding(context.index, imported.resolved);
-                    const lexical = value ? context.resolveIdentifier(receiverName, access.receiver) : null;
-                    if (!value || !declaresMembers(value) || !lexical || defNodeId(value) !== defNodeId(lexical))
-                        return;
-                    binding = { kind: "named-type", typeName: receiverName, typeNode: access.receiver, memberScope: "static" };
-                }
-            }
-            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) };
             // Shared call-count facts treat unproven spread expansions as unknown (null),
@@ -903,9 +1087,6 @@ export async function emitFunctionBodyEdges(context, functionNodes) {
             if (access) {
                 if (recordTypeScriptNamespaceCall(context, node, access, fromId))
                     return;
-                if (recordImportTypeCall(context, access, fromId))
-                    return;
-                const receiverName = sliceText(access.receiver, context.source);
                 const typeScopedCppCall = context.sup.id === "cpp" &&
                     context.source.slice(access.receiver.endIndex, access.property.startIndex).includes("::");
                 if (typeScopedCppCall) {
@@ -921,19 +1102,49 @@ export async function emitFunctionBodyEdges(context, functionNodes) {
                     });
                     return;
                 }
-                if (keywordReceiverKind(context.sup.id, receiverName)) {
-                    recordReceiverCall(node, access);
+                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 === "csharp" &&
-                    access.receiver.type === "member_access_expression" &&
-                    csharpDottedNameRoot(access.receiver)) {
+                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);
+                recordReceiverCall(node, access, undefined, receiverProof);
                 return;
             }
             if (!callee)
@@ -948,90 +1159,20 @@ export async function emitFunctionBodyEdges(context, functionNodes) {
                     return;
                 }
             }
-            const implicitOwnerLanguage = context.sup.id === "swift" || context.sup.id === "csharp";
-            if (implicitOwnerLanguage && isIdentifierType(context.sup, callee.type) && nearestMemberContainer(fn.node)) {
-                const name = sliceText(callee, context.source);
-                const lexical = context.resolveIdentifier(name, callee);
-                const importedCsharpMember = context.sup.id === "csharp" &&
-                    !!lexical?.isMember &&
-                    fileIdentityKey(lexical.file) !== fileIdentityKey(context.moduleEntry.file);
-                if (!importedCsharpMember && (!lexical || lexical.isMember || !context.hasNonModuleBinding(name, callee))) {
-                    // A method's local binding wins. Type members require receiver ownership
-                    // and static-scope proof; only a free function can be a fallback.
-                    recordImplicitSelfMemberCall(node, callee, lexical?.isMember ? null : lexical);
-                    return;
-                }
-            }
             if (!tryResolveNode(context, callee, fromId, "calls"))
                 recordImplicitSelfMemberCall(node, callee);
         };
-        const recordRubySuper = (superNode) => {
-            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",
-            });
-        };
         const recordCallOrInstantiation = (node) => {
-            if (context.sup.id === "ruby" && node.type === "super") {
-                recordRubySuper(node);
-                return true;
-            }
-            if (node.type === "token_tree")
-                recordRustMacroArgumentCalls(context, node, fromId);
+            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;
-                    }
-                }
-                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) {
-                        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;
-                }
-                if (recordSwiftCapitalizedConstruction(context, node, fromId))
-                    return true;
+                const callResult = specialized?.onCall?.(context, node, fromId, resolveCallTarget);
+                if (callResult !== undefined)
+                    return callResult;
                 resolveCallTarget(node, getCallTarget(node));
             }
-            if (newNodeTypes.has(node.type)) {
+            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);
@@ -1090,15 +1231,14 @@ export async function emitFunctionBodyEdges(context, functionNodes) {
             }
             else {
                 // Without an implicit `this` of the owner, `Owner::member()` can only name a static member.
-                recordReceiverCall(call.node, call.access, implicitThis ? undefined : "static");
+                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 &&
-            (await memberAcceptsCallAt(context.index, member, access.accessNode, context.source, context.sup.id))) {
+        if (member && memberAcceptsCallAt(context.index, member, access.accessNode, context.source, context.sup.id)) {
             recordDefEdge(context, fromId, member, "calls", access.property);
         }
     }
@@ -1362,8 +1502,6 @@ export async function emitClassInheritanceEdges(context, classNodes) {
     }
 }
 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") ?? [];