@lzehrung/codegraph 2.3.20 → 2.3.22

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

@@ -0,0 +1,676 @@
+import { sliceText, toRange } from "../../util/ast.js";
+import { getMemberAccessParts } from "../../util/member-access.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";
+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);
+    const nameIndex = declaration.indexOf(def.localName);
+    const prefix = nameIndex >= 0 ? declaration.slice(0, nameIndex) : declaration;
+    if (!/\b(?:abstract|virtual|override)\b/.test(prefix))
+        return;
+    const node = context.nodes.get(id);
+    if (node)
+        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)
+        return;
+    const arity = (parameters.namedChildren ?? []).filter((child) => child.type !== "comment").length;
+    const node = context.nodes.get(id);
+    if (node)
+        node.memberArity = arity;
+}
+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);
+}
+function tryResolveChain(context, node, fromId, label = "uses") {
+    const targetDef = context.resolveMemberChainTarget(node);
+    if (targetDef && fromId) {
+        recordDefEdge(context, fromId, targetDef, label, node);
+        return true;
+    }
+    return !!targetDef;
+}
+/** 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") {
+        const name = sliceText(node, context.source);
+        const target = context.resolveIdentifier(name, node);
+        if (target) {
+            recordDefEdge(context, fromId, target, label, node);
+            return true;
+        }
+    }
+    if (context.optionalMemberTypes.has(node.type)) {
+        return tryResolveChain(context, node, fromId, label);
+    }
+    return false;
+}
+function getCallTarget(node) {
+    const explicitTarget = node.childForFieldName("function") ??
+        node.childForFieldName("callee") ??
+        node.childForFieldName("name") ??
+        node.childForFieldName("method") ??
+        node.childForFieldName("member") ??
+        node.childForFieldName("expression");
+    if (explicitTarget)
+        return explicitTarget;
+    // Kotlin and Swift calls name no callee field, so the sole non-argument child is it.
+    const nonArgumentChildren = node.namedChildren.filter((child) => !CALL_ARGUMENT_NODE_TYPES[child.type]);
+    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));
+}
+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");
+            if (fn)
+                addDecoratorUses(fn);
+            for (const decoratorChild of node.namedChildren) {
+                if (decoratorChild.type !== "decorator")
+                    continue;
+                const nameNode = fn?.childForFieldName("name");
+                if (!nameNode)
+                    continue;
+                const name = sliceText(nameNode, context.source);
+                const def = context.moduleEntry.locals.find((local) => local.localName === name);
+                if (!def)
+                    continue;
+                const fromId = ensureNode(context, def);
+                const expr = decoratorChild.childForFieldName?.("name") ?? decoratorChild.namedChildren?.[0] ?? decoratorChild.child(1);
+                if (expr)
+                    tryResolveNode(context, expr, fromId, "decorates");
+            }
+        }
+        else if (node.type === "function_definition") {
+            const nameNode = node.childForFieldName("name");
+            if (nameNode) {
+                const name = sliceText(nameNode, context.source);
+                const def = context.moduleEntry.locals.find((local) => local.localName === name);
+                if (def) {
+                    const fromId = ensureNode(context, def);
+                    let prev = node.previousSibling;
+                    while (prev) {
+                        if (prev.type === "decorated_definition") {
+                            for (const decoratorChild of prev.namedChildren) {
+                                if (decoratorChild.type === "decorator") {
+                                    const expr = decoratorChild.childForFieldName?.("name") ??
+                                        decoratorChild.namedChildren?.[0] ??
+                                        decoratorChild.child(1);
+                                    if (expr)
+                                        tryResolveNode(context, expr, fromId, "decorates");
+                                }
+                                else if (decoratorChild.type === "attribute") {
+                                    tryResolveNode(context, decoratorChild, fromId, "decorates");
+                                }
+                            }
+                        }
+                        else if (prev.type === "decorator") {
+                            const expr = prev.childForFieldName?.("name") ?? prev.namedChildren?.[0] ?? prev.child(1);
+                            if (expr)
+                                tryResolveNode(context, expr, fromId, "decorates");
+                        }
+                        prev = prev.previousSibling;
+                    }
+                }
+            }
+        }
+        for (const child of node.namedChildren)
+            addDecoratorUses(child);
+    };
+    addDecoratorUses(rootNode);
+}
+export function emitMemberOwnershipEdges(context, functionNodes, classNodes) {
+    for (const fn of functionNodes) {
+        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));
+        const owner = owners[0];
+        if (!owner)
+            continue;
+        const memberId = ensureNode(context, fn.def);
+        markImplementationTarget(context, memberId, fn.node, fn.def);
+        markMemberArity(context, memberId, fn.node);
+        recordDefEdge(context, memberId, owner.def, "member_of");
+    }
+}
+/** Type-like defs only, so a PHP `use function` alias cannot steal `Example::m()`. */
+function resolveNamedType(context, name, node) {
+    const target = context.resolveIdentifier(name, node);
+    return target && declaresMembers(target) ? target : null;
+}
+export function emitFunctionBodyEdges(context, functionNodes) {
+    const callNodeTypes = new Set([
+        "call_expression",
+        "call",
+        "method_invocation",
+        "invocation_expression",
+        // PHP models plain calls and receiver calls as three distinct call nodes.
+        "function_call_expression",
+        "member_call_expression",
+        "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.
+    let membersByContainer;
+    const lexicalMembers = (container) => {
+        if (!membersByContainer) {
+            membersByContainer = new Map();
+            for (const candidate of functionNodes) {
+                const owner = nearestMemberContainer(candidate.node);
+                if (!owner)
+                    continue;
+                const members = membersByContainer.get(owner.startIndex);
+                if (members)
+                    members.push(candidate);
+                else
+                    membersByContainer.set(owner.startIndex, [candidate]);
+            }
+        }
+        return membersByContainer.get(container.startIndex) ?? [];
+    };
+    const receiverProofs = new Map();
+    for (const fn of functionNodes) {
+        const fromId = ensureNode(context, fn.def);
+        const seenAliases = new Set();
+        const nestedFunctions = new Set(functionNodes
+            .filter((candidate) => candidate.node !== fn.node &&
+            candidate.node.startIndex >= fn.node.startIndex &&
+            candidate.node.endIndex <= fn.node.endIndex)
+            .map((candidate) => candidate.node));
+        const recordAliasUse = (node) => {
+            if (context.membersOnly || !isIdentifierType(context.sup, node.type))
+                return;
+            const name = sliceText(node, context.source);
+            if (seenAliases.has(name))
+                return;
+            let target = context.aliasToTargetDef.get(name) ?? null;
+            if (!target) {
+                const modFile = context.aliasToTargetModule.get(name);
+                if (modFile) {
+                    let exportedName = null;
+                    const parent = node.parent;
+                    if (parent &&
+                        (parent.type === context.memberExpressionType || parent.type === "optional_member_expression")) {
+                        const { property: prop } = getMemberAccessParts(context.sup, parent);
+                        if (prop && context.propertyIdentifierTypes.includes(prop.type)) {
+                            exportedName = sliceText(prop, context.source);
+                        }
+                    }
+                    if (exportedName) {
+                        target = context.resolveExportFrom(modFile, exportedName);
+                        if (!target) {
+                            const targetModule = context.index.byFile.get(fileIdentityKey(modFile));
+                            target = (targetModule?.locals ?? []).find((local) => local.localName === exportedName) ?? null;
+                        }
+                    }
+                }
+            }
+            if (!target)
+                return;
+            seenAliases.add(name);
+            recordDefEdge(context, fromId, target, "uses");
+        };
+        const recordMemberUse = (node) => {
+            if (!context.optionalMemberTypes.has(node.type))
+                return;
+            const targetDef = context.resolveMemberChainTarget(node);
+            if (targetDef) {
+                recordDefEdge(context, fromId, targetDef, "uses");
+            }
+        };
+        /**
+         * 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 memberName = sliceText(access.property, context.source);
+            if (!memberName || !context.hasCallableNamed(memberName))
+                return;
+            const binding = classifyReceiver(context.sup, access.receiver, context.source, receiverProofs, fn.node.startIndex, access.accessNode);
+            if (!binding)
+                return;
+            const site = { file: context.moduleEntry.file, range: toRange(access.property) };
+            const argumentCount = callArgumentCount(node);
+            if (binding.kind === "named-type") {
+                const typeDef = resolveNamedType(context, binding.typeName, access.receiver);
+                if (!typeDef)
+                    return;
+                context.receiverCalls.push({
+                    callerId: fromId,
+                    ownerId: ensureNode(context, typeDef),
+                    viaSupertypes: false,
+                    memberName,
+                    argumentCount,
+                    site,
+                });
+                return;
+            }
+            if (binding.kind === "own-type") {
+                const container = nearestMemberContainer(fn.node);
+                const declared = container
+                    ? lexicalMembers(container).filter((candidate) => candidate.def.localName === memberName)
+                    : [];
+                if (declared.length === 1) {
+                    recordDefEdge(context, fromId, declared[0].def, "calls", access.property);
+                    return;
+                }
+            }
+            context.receiverCalls.push({
+                callerId: fromId,
+                ownerId: null,
+                viaSupertypes: binding.kind === "supertype",
+                memberName,
+                argumentCount,
+                site,
+            });
+        };
+        /**
+         * Records the `calls` edge for one call node. A call with a receiver is resolved
+         * only through its import chain or its receiver's type: matching the bare member
+         * name against module locals and import aliases would attribute `$this->helper()`
+         * to an unrelated imported `helper`.
+         */
+        const resolveCallTarget = (node, callee) => {
+            const access = receiverCallAccess(context.sup, node, callee);
+            if (access) {
+                if (!tryResolveChain(context, access.accessNode, fromId, "calls"))
+                    recordReceiverCall(node, access);
+                return;
+            }
+            if (callee)
+                tryResolveNode(context, callee, fromId, "calls");
+        };
+        const recordCallOrInstantiation = (node) => {
+            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) {
+                        tryResolveNode(context, receiverNode, fromId, "instantiates");
+                        return false;
+                    }
+                    if (methodNode) {
+                        resolveCallTarget(node, methodNode);
+                        return false;
+                    }
+                }
+                resolveCallTarget(node, getCallTarget(node));
+            }
+            if (newNodeTypes.has(node.type)) {
+                const target = getNewTarget(node);
+                if (target)
+                    tryResolveNode(context, target, fromId, "instantiates");
+            }
+            return true;
+        };
+        const walkFunctionBody = (node, allowCallProcessing) => {
+            if (node !== fn.node && nestedFunctions.has(node))
+                return;
+            recordAliasUse(node);
+            recordMemberUse(node);
+            const allowChildCallProcessing = allowCallProcessing ? recordCallOrInstantiation(node) : false;
+            for (const child of node.namedChildren ?? [])
+                walkFunctionBody(child, allowChildCallProcessing);
+        };
+        walkFunctionBody(fn.node, true);
+    }
+}
+/** Qualifiers name a container, not another base type. */
+const QUALIFIER_NAME_FIELD = {
+    qualified_name: "name", // C#: Namespace.Base, Outer.Inner
+    qualified_identifier: "name", // C++: ns::Base
+    scope_resolution: "name", // Ruby: Module::Base
+};
+/** Generic wrappers contribute the base name, not their type arguments. */
+const GENERIC_WRAPPER_TYPES = {
+    generic_name: true,
+    generic_type: true,
+    user_type: true,
+    template_type: true,
+};
+const GENERIC_ARGUMENT_CHILD_TYPES = {
+    type_argument_list: true, // C#: generic_name
+    type_arguments: true, // Java/TypeScript generic_type, Kotlin/Swift user_type
+    template_argument_list: true, // C++: template_type
+    type_modifiers: true, // Kotlin/Swift user_type nullability/variance modifiers
+};
+/** Kotlin delegation-specifier forms that wrap the base type with call syntax. */
+const CALL_LIKE_WRAPPER_SKIP_TYPES = {
+    constructor_invocation: { value_arguments: true }, // Base(args)
+    explicit_delegation: { primary_expression: true }, // Interface by delegate
+};
+/** Python base-list entries that are never base types. */
+const BASE_TYPE_IGNORED_TYPES = {
+    keyword_argument: true,
+    dictionary_splat: true,
+    list_splat: true,
+};
+/** Remove type arguments and wrapper syntax before resolving a direct base. */
+function narrowBaseSpecifierNode(node) {
+    let current = node;
+    for (;;) {
+        const qualifierField = QUALIFIER_NAME_FIELD[current.type];
+        if (qualifierField) {
+            const named = current.childForFieldName(qualifierField);
+            if (!named || named === current)
+                return current;
+            current = named;
+            continue;
+        }
+        if (current.type === "scoped_type_identifier") {
+            let named = current.childForFieldName("name");
+            if (!named) {
+                const parts = current.namedChildren ?? [];
+                for (let index = parts.length - 1; index >= 0; index -= 1) {
+                    const part = parts[index];
+                    if (part.type !== "annotation" && part.type !== "marker_annotation") {
+                        named = part;
+                        break;
+                    }
+                }
+            }
+            if (!named || named === current)
+                return current;
+            current = named;
+            continue;
+        }
+        if (GENERIC_WRAPPER_TYPES[current.type]) {
+            const named = current.childForFieldName("name") ??
+                (current.namedChildren ?? []).find((child) => !GENERIC_ARGUMENT_CHILD_TYPES[child.type]);
+            if (!named || named === current)
+                return current;
+            current = named;
+            continue;
+        }
+        if (current.type === "subscript") {
+            // Python `Base[Payload]` generic base: `value` names the base type.
+            const value = current.childForFieldName("value");
+            if (!value)
+                return current;
+            current = value;
+            continue;
+        }
+        const callSkipTypes = CALL_LIKE_WRAPPER_SKIP_TYPES[current.type];
+        if (callSkipTypes) {
+            const named = (current.namedChildren ?? []).find((child) => !callSkipTypes[child.type]);
+            if (!named)
+                return current;
+            current = named;
+            continue;
+        }
+        return current;
+    }
+}
+/** Collect one type identifier per direct base or interface specifier. */
+function collectBaseSpecifierIdentifiers(node, sup, out) {
+    if (BASE_TYPE_IGNORED_TYPES[node.type])
+        return;
+    const narrowed = narrowBaseSpecifierNode(node);
+    if (isIdentifierType(sup, narrowed.type) || narrowed.type === "type_identifier") {
+        out.push(narrowed);
+        return;
+    }
+    for (const child of narrowed.namedChildren ?? [])
+        collectBaseSpecifierIdentifiers(child, sup, out);
+}
+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);
+        if (!target)
+            continue;
+        const targetId = defNodeId(target);
+        if (seen.has(targetId))
+            continue;
+        seen.add(targetId);
+        recordDefEdge(context, fromId, target, relationForTarget(target, index), identifier);
+    }
+}
+const RUBY_NESTED_SCOPE_TYPES = new Set(["class", "module", "method", "singleton_method", "block", "do_block"]);
+/** Collects `call` nodes directly in a Ruby class/module body, not inside a nested class, module, method, or block. */
+function collectDirectCallsExcludingNestedScopes(node, out) {
+    for (const child of node.namedChildren ?? []) {
+        if (child.type === "call")
+            out.push(child);
+        if (RUBY_NESTED_SCOPE_TYPES.has(child.type))
+            continue;
+        collectDirectCallsExcludingNestedScopes(child, out);
+    }
+}
+export function emitClassInheritanceEdges(context, classNodes) {
+    const interfaceIds = new Set(classNodes
+        .filter((candidate) => candidate.node.type === "interface_declaration" ||
+        candidate.node.type === "protocol_declaration" ||
+        candidate.node.type === "trait_item" ||
+        /^(?:interface|protocol|trait)\b/.test(sliceText(candidate.node, context.source).trimStart()))
+        .map((candidate) => defNodeId(candidate.def)));
+    for (const cls of classNodes) {
+        const fromId = ensureNode(context, cls.def);
+        markImplementationTarget(context, fromId, cls.node, cls.def);
+        if (context.sup.id === "java") {
+            const superClass = findFirstNodeByType(cls.node, "superclass");
+            const rawSuperNode = superClass?.childForFieldName("name") ?? superClass?.namedChildren?.[0] ?? null;
+            const superNode = rawSuperNode ? narrowBaseSpecifierNode(rawSuperNode) : null;
+            if (superNode)
+                tryResolveNode(context, superNode, fromId, "extends");
+            const interfaces = findFirstNodeByType(cls.node, "super_interfaces");
+            if (interfaces) {
+                const interfaceIdentifiers = [];
+                collectBaseSpecifierIdentifiers(interfaces, context.sup, interfaceIdentifiers);
+                for (const identifier of interfaceIdentifiers) {
+                    const target = context.resolveIdentifier(sliceText(identifier, context.source), identifier);
+                    if (target)
+                        recordDefEdge(context, fromId, target, "implements", interfaces);
+                }
+            }
+            continue;
+        }
+        if (context.sup.id === "csharp") {
+            const baseList = findFirstNodeByType(cls.node, "base_list");
+            if (baseList) {
+                recordIdentifierRelations(context, fromId, baseList, (target, index) => interfaceIds.has(defNodeId(target)) || index > 0 ? "implements" : "extends");
+            }
+            continue;
+        }
+        if (context.sup.id === "python") {
+            const bases = cls.node.childForFieldName("superclasses") ?? findFirstNodeByType(cls.node, "argument_list");
+            if (bases)
+                recordIdentifierRelations(context, fromId, bases, () => "extends");
+            continue;
+        }
+        if (context.sup.id === "php") {
+            const base = findFirstNodeByType(cls.node, "base_clause");
+            if (base)
+                recordIdentifierRelations(context, fromId, base, () => "extends");
+            const interfaces = findFirstNodeByType(cls.node, "class_interface_clause");
+            if (interfaces)
+                recordIdentifierRelations(context, fromId, interfaces, () => "implements");
+            const traitUses = [];
+            collectNodesByType(cls.node, "use_declaration", traitUses);
+            for (const traitUse of traitUses)
+                recordIdentifierRelations(context, fromId, traitUse, () => "trait");
+            continue;
+        }
+        if (context.sup.id === "ruby") {
+            const superclass = findFirstNodeByType(cls.node, "superclass");
+            if (superclass)
+                recordIdentifierRelations(context, fromId, superclass, () => "extends");
+            const calls = [];
+            collectDirectCallsExcludingNestedScopes(cls.node, calls);
+            for (const call of calls) {
+                if (call.childForFieldName("receiver"))
+                    continue;
+                const methodNode = call.childForFieldName("method");
+                const methodName = methodNode ? sliceText(methodNode, context.source) : undefined;
+                if (methodName !== "include" && methodName !== "extend" && methodName !== "prepend")
+                    continue;
+                const args = call.childForFieldName("arguments");
+                if (args)
+                    recordIdentifierRelations(context, fromId, args, () => "mixin");
+            }
+            continue;
+        }
+        if (context.sup.id === "cpp") {
+            const bases = findFirstNodeByType(cls.node, "base_class_clause");
+            if (bases)
+                recordIdentifierRelations(context, fromId, bases, () => "extends");
+            continue;
+        }
+        if (context.sup.id === "kotlin") {
+            const bases = findFirstNodeByType(cls.node, "delegation_specifiers");
+            if (bases) {
+                recordIdentifierRelations(context, fromId, bases, (target, index) => interfaceIds.has(defNodeId(target)) || index > 0 ? "implements" : "extends");
+            }
+            continue;
+        }
+        if (context.sup.id === "swift") {
+            const bases = [];
+            collectNodesByType(cls.node, "inheritance_specifier", bases);
+            for (const [index, base] of bases.entries()) {
+                recordIdentifierRelations(context, fromId, base, (target) => interfaceIds.has(defNodeId(target)) || index > 0 ? "implements" : "extends");
+            }
+            continue;
+        }
+        const superClause = findFirstNodeByType(cls.node, "extends_clause");
+        const rawSuperNode = superClause?.namedChildren?.[0] ?? superClause?.child(1);
+        const superNode = rawSuperNode ? narrowBaseSpecifierNode(rawSuperNode) : null;
+        if (superNode)
+            tryResolveNode(context, superNode, fromId, "extends");
+        const implementsClauses = [];
+        collectNodesByType(cls.node, "implements_clause", implementsClauses);
+        for (const clause of implementsClauses) {
+            const interfaceIdentifiers = [];
+            collectBaseSpecifierIdentifiers(clause, context.sup, interfaceIdentifiers);
+            for (const identifier of interfaceIdentifiers) {
+                const target = context.resolveIdentifier(sliceText(identifier, context.source), identifier);
+                if (target)
+                    recordDefEdge(context, fromId, target, "implements", clause);
+            }
+        }
+    }
+}
+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") ?? [];
+            if (typeIdentifiers.length >= 2) {
+                const traitName = sliceText(typeIdentifiers[0], context.source);
+                const typeName = sliceText(typeIdentifiers[1], context.source);
+                const typeDef = context.resolveIdentifier(typeName, typeIdentifiers[1]);
+                const traitDef = context.resolveIdentifier(traitName, typeIdentifiers[0]);
+                if (typeDef && traitDef) {
+                    const fromId = ensureNode(context, typeDef);
+                    recordDefEdge(context, fromId, traitDef, "implements", node);
+                }
+            }
+        }
+        for (const child of node.namedChildren ?? [])
+            walkImpls(child);
+    };
+    walkImpls(rootNode);
+}
+export function emitMemberImplementationEdges(graph, recordEdge) {
+    const membersByOwner = new Map();
+    for (const edge of graph.edges) {
+        if (edge.label !== "member_of")
+            continue;
+        const members = membersByOwner.get(edge.to) ?? [];
+        members.push(edge.from);
+        membersByOwner.set(edge.to, members);
+    }
+    const hierarchyByKey = new Map();
+    for (const edge of graph.edges) {
+        if (edge.label !== "extends" && edge.label !== "implements" && edge.label !== "trait" && edge.label !== "mixin")
+            continue;
+        const key = `${edge.from}->${edge.to}::${edge.label}`;
+        const existing = hierarchyByKey.get(key);
+        if (!existing || (!existing.site && edge.site))
+            hierarchyByKey.set(key, edge);
+    }
+    const hierarchyEdges = [...hierarchyByKey.values()];
+    for (const hierarchyEdge of hierarchyEdges) {
+        const parentMembers = membersByOwner.get(hierarchyEdge.to) ?? [];
+        const childMembers = membersByOwner.get(hierarchyEdge.from) ?? [];
+        for (const parentMemberId of parentMembers) {
+            const parentMember = graph.nodes.get(parentMemberId);
+            if (!parentMember)
+                continue;
+            if (parentMember.memberArity === undefined)
+                continue;
+            const parentIdentityMatches = parentMembers.filter((memberId) => {
+                const candidate = graph.nodes.get(memberId);
+                return candidate?.name === parentMember.name && candidate.memberArity === parentMember.memberArity;
+            });
+            if (parentIdentityMatches.length !== 1)
+                continue;
+            const isContractMember = hierarchyEdge.label !== "extends" || parentMember.implementationTarget;
+            if (!isContractMember)
+                continue;
+            const compatibleMembers = childMembers.filter((memberId) => {
+                const childMember = graph.nodes.get(memberId);
+                return childMember?.name === parentMember.name && childMember.memberArity === parentMember.memberArity;
+            });
+            if (compatibleMembers.length !== 1)
+                continue;
+            recordEdge(compatibleMembers[0], parentMemberId, hierarchyEdge.label === "extends" ? "overrides" : "implements_member", hierarchyEdge.site);
+        }
+    }
+}
+//# sourceMappingURL=edge-passes.js.map