@lzehrung/codegraph 2.3.31 → 2.4.0

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

@@ -1,19 +1,126 @@
+import { definitionWithoutDeferredSteps, nameResolutionPreloadFiles, phpImportTypeAtPosition, resolveBareName, settleNameResolution, } from "../indexer/name-resolution.js";
+import { recoverIncludedCallableStar } from "../indexer/navigation.js";
 import { isUnsupportedParserInputError, prepareSourceInput } from "../languages/file-prep.js";
+import { supportForFileWithoutHeaderSample } from "../languages.js";
 import { logWithLevel } from "../logging.js";
 import { ProjectedSyntaxTree } from "../native/projected-tree.js";
 import { assertNativeRequiredAvailable, getNativeSyntaxTreeExecution, isNativeRequiredUnavailableError, } from "../native/tree-sitter-native.js";
-import { resolveExport } from "../indexer/navigation-resolve.js";
+import { cppCallableIsDefinition, cppEquivalentCallableBindings } from "../indexer/cpp-callables.js";
+import { cjsRequireValueBinding, resolveExport } from "../indexer/navigation-resolve.js";
+import { typescriptCollapsedOverloadTarget, typescriptCallableContainerKey, typescriptCallableRoleAt, typescriptOverloadImplementationAcceptsCount, } from "../indexer/ts-callables.js";
+import { isJsTsLanguage } from "../languages/js-family.js";
+import { isGoExportedMemberName, languageHasDeclarationVisibility } from "../indexer/declaration-visibility.js";
+import { innermostNamespaceImport, resolveMemberAccessDefinition } from "../indexer/navigation-goto.js";
+import { inferPhpQualifiedReferenceImportType } from "../indexer/navigation-php.js";
+import { ensurePhpNamespaceSymbolIndex } from "../indexer/php-namespace-symbols.js";
 import { findClosestScopeBinding, getOrBuildScopeIndex } from "../indexer/navigation-local.js";
-import { SymbolKind } from "../indexer/types.js";
+import { ensureParsedContext } from "../indexer/parse-context.js";
+import { SymbolKind, } from "../indexer/types.js";
 import { fileIdentityKey, normalizePath } from "../util/paths.js";
-import { buildSymbolGraph } from "./symbol-graph.js";
+import { foldPhpIdentifierCase } from "../util/identifiers.js";
+import { buildSymbolGraph, defNodeId } from "./symbol-graph.js";
 import { collectDetailedDeclarations } from "./symbol-graph-detailed/ast.js";
 import { emitClassInheritanceEdges, emitFunctionBodyEdges, emitMemberOwnershipEdges, emitMemberImplementationEdges, emitPythonDecoratorEdges, emitRustImplEdges, } from "./symbol-graph-detailed/edge-passes.js";
 import { buildImportAliasMaps } from "./symbol-graph-detailed/import-aliases.js";
 import { createMemberChainResolver } from "./symbol-graph-detailed/member-chains.js";
-import { emitReceiverCallEdges } from "./symbol-graph-detailed/receiver-calls.js";
+import { emitReceiverCallEdges, } from "./symbol-graph-detailed/receiver-calls.js";
+const CPP_CLASS_DECLARATION_TYPES = new Set(["class_specifier", "struct_specifier", "union_specifier"]);
+function symbolDefForBinding(moduleEntry, binding) {
+    const bindingRange = binding.def;
+    if (!bindingRange)
+        return null;
+    return (moduleEntry.locals.find((candidate) => candidate.kind === SymbolKind.Function &&
+        candidate.range.start.index === bindingRange.start.index &&
+        candidate.range.end.index === bindingRange.end.index) ?? null);
+}
+function recordCallableDeclarationAliases(moduleEntry, languageId, bindings, nodeAliases) {
+    const recordGroup = (group) => {
+        if (group.length < 2)
+            return;
+        const canonicalBinding = group.find((binding) => !cppCallableIsDefinition(binding.node)) ?? group[0];
+        const canonicalDef = symbolDefForBinding(moduleEntry, canonicalBinding);
+        if (!canonicalDef)
+            return;
+        const canonicalId = defNodeId(canonicalDef);
+        for (const binding of group) {
+            const def = symbolDefForBinding(moduleEntry, binding);
+            if (!def)
+                continue;
+            const id = defNodeId(def);
+            if (id !== canonicalId)
+                nodeAliases.set(id, canonicalId);
+        }
+    };
+    if (languageId === "c") {
+        const byName = new Map();
+        for (const binding of bindings) {
+            if (binding.kind !== "function" || !binding.def)
+                continue;
+            const group = byName.get(binding.canonicalName) ?? [];
+            group.push(binding);
+            byName.set(binding.canonicalName, group);
+        }
+        for (const group of byName.values())
+            recordGroup(group);
+        return;
+    }
+    if (languageId !== "cpp")
+        return;
+    const handled = new Set();
+    for (const binding of bindings) {
+        if (binding.kind !== "function" || handled.has(binding))
+            continue;
+        const group = cppEquivalentCallableBindings(binding);
+        for (const candidate of group)
+            handled.add(candidate);
+        recordGroup(group);
+    }
+}
+function recordTypeScriptCallableAliases(moduleEntry, languageId, tree, nodeAliases) {
+    if (languageId !== "ts" && languageId !== "tsx")
+        return;
+    const groups = new Map();
+    for (const local of moduleEntry.locals) {
+        if (local.kind !== SymbolKind.Function)
+            continue;
+        const start = local.range.start.index ?? 0;
+        const end = local.range.end.index ?? start;
+        const role = typescriptCallableRoleAt(tree, start, end);
+        if (role === "other")
+            continue;
+        const key = `${typescriptCallableContainerKey(tree, start, end)}\0${local.localName}`;
+        const group = groups.get(key) ?? [];
+        group.push(local);
+        groups.set(key, group);
+    }
+    for (const group of groups.values()) {
+        if (group.length < 2)
+            continue;
+        // Signature-only and multiply implemented groups keep their distinct declarations.
+        const canonical = typescriptCollapsedOverloadTarget(group, tree, (local) => local);
+        if (!canonical)
+            continue;
+        const canonicalId = defNodeId(canonical);
+        for (const local of group) {
+            const id = defNodeId(local);
+            if (id !== canonicalId)
+                nodeAliases.set(id, canonicalId);
+        }
+    }
+}
+/**
+ * The indexed symbol a definition names (with its member metadata), or null for a parameter or
+ * block local, which has no graph node.
+ */
+function indexedSymbolFor(index, def) {
+    const module = index.byFile.get(fileIdentityKey(def.file));
+    return (module?.locals.find((local) => local.localName === def.localName &&
+        local.range.start.index === def.range.start.index &&
+        local.range.end.index === def.range.end.index) ?? null);
+}
 export async function buildSymbolGraphDetailed(index, opts) {
     assertNativeRequiredAvailable(index.nativeMode);
+    await ensurePhpNamespaceSymbolIndex(index);
     const base = await buildSymbolGraph(index, opts?.files ? { files: opts.files } : undefined);
     const configuredMaxEdges = typeof opts?.maxEdges === "number" && opts.maxEdges > 0 ? Math.floor(opts.maxEdges) : undefined;
     const maxEdges = configuredMaxEdges ?? Number.POSITIVE_INFINITY;
@@ -49,15 +156,23 @@ export async function buildSymbolGraphDetailed(index, opts) {
         edgeCount++;
         return true;
     };
-    const recordEdge = (fromId, toId, label, site) => {
+    const edgeKey = (fromId, toId, label, site) => {
         const siteKey = site ? `${site.file}:${site.range.start.index ?? ""}:${site.range.end.index ?? ""}` : "";
-        const key = `${fromId}->${toId}::${label ?? ""}::${siteKey}`;
+        return `${fromId}->${toId}::${label ?? ""}::${siteKey}`;
+    };
+    const recordEdge = (fromId, toId, label, site) => {
+        const key = edgeKey(fromId, toId, label, site);
         if (added.has(key))
             return true;
         added.add(key);
         return maybePushEdge(fromId, toId, label, site);
     };
-    const resolveExportNamespace = (file, exportedName) => resolveExport(index, file, exportedName);
+    const resolveExportNamespace = (file, exportedName) => {
+        const languageId = supportForFileWithoutHeaderSample(file, index.languageExtensions)?.id;
+        if (!isGoExportedMemberName(languageId, exportedName))
+            return null;
+        return resolveExport(index, file, exportedName);
+    };
     const resolveExportDef = (file, exportedName) => {
         const resolved = resolveExportNamespace(file, exportedName);
         return resolved?.kind === "resolved" ? resolved.def : null;
@@ -68,7 +183,10 @@ export async function buildSymbolGraphDetailed(index, opts) {
         for (const segment of [...names].reverse()) {
             if (!file)
                 break;
-            const resolved = resolveExportNamespace(file, segment);
+            const languageId = supportForFileWithoutHeaderSample(file, index.languageExtensions)?.id;
+            const resolved = languageId && isJsTsLanguage(languageId)
+                ? resolveExport(index, file, segment, { allowLocalFallback: false })
+                : resolveExportNamespace(file, segment);
             if (!resolved) {
                 targetDef = null;
                 break;
@@ -81,32 +199,70 @@ export async function buildSymbolGraphDetailed(index, opts) {
             targetDef = resolved.def;
             file = normalizePath(targetDef.file);
         }
-        if (targetDef) {
+        if (targetDef)
             return targetDef;
-        }
+        const languageId = supportForFileWithoutHeaderSample(file ?? startFile, index.languageExtensions)?.id;
+        if (languageId === "c" ||
+            languageId === "cpp" ||
+            (languageId && (isJsTsLanguage(languageId) || languageHasDeclarationVisibility(languageId))))
+            return null;
         const fileKey = typeof file === "string" ? fileIdentityKey(file) : null;
         const moduleEntry = fileKey ? index.byFile.get(fileKey) : undefined;
         const lastName = names[0];
+        if (languageId === "go" && (!lastName || !isGoExportedMemberName(languageId, lastName)))
+            return null;
         return moduleEntry?.locals.find((entry) => entry.localName === lastName) ?? null;
     };
     const resolveExportFrom = (file, exportedName) => resolveExportDef(file, exportedName);
     const receiverCalls = [];
-    // Every receiver call resolves to a callable declared somewhere in the project, so
-    // this set short-circuits receiver typing for calls into runtime and dependency
-    // APIs, which dominate real call sites. Built on first use because a scoped graph
-    // may never reach a receiver call.
+    const fileHiddenMemberIds = new Set();
+    const receiverMemberScopes = new Map();
+    const receiverMemberArities = new Map();
+    const sharedOwnerPeers = new Map();
+    const sharedOwnerAnchors = new Map();
+    const sharedOwnerAccessibleMembers = new Map();
+    const nodeAliases = new Map();
+    const ownershipParsedContexts = new Map();
+    const loadParsedFile = (file) => {
+        const fileKey = fileIdentityKey(file);
+        const cached = ownershipParsedContexts.get(fileKey);
+        if (cached)
+            return cached;
+        const pending = ensureParsedContext(file, index.parsed?.get(fileKey), index.languageExtensions).catch(() => null);
+        ownershipParsedContexts.set(fileKey, pending);
+        return pending;
+    };
+    // Receiver calls into runtime and dependency APIs dominate real call sites. Build these
+    // indexes lazily so a scoped graph that has no receiver calls pays no allocation cost.
     let callableNames;
-    const hasCallableNamed = (name) => {
+    const ensureCallableNames = () => {
         if (!callableNames) {
-            callableNames = new Set();
+            callableNames = { exact: new Set(), phpFolded: new Set() };
             for (const entry of index.byFile.values()) {
+                const isPhp = supportForFileWithoutHeaderSample(entry.file, index.languageExtensions)?.id === "php";
                 for (const local of entry.locals) {
-                    if (local.kind === SymbolKind.Function)
-                        callableNames.add(local.localName);
+                    if (local.kind !== SymbolKind.Function)
+                        continue;
+                    callableNames.exact.add(local.localName);
+                    if (isPhp)
+                        callableNames.phpFolded.add(foldPhpIdentifierCase(local.localName));
                 }
             }
         }
-        return callableNames.has(name);
+        return callableNames;
+    };
+    const hasCallableNamed = (name, phpCaseInsensitive = false) => {
+        const names = ensureCallableNames();
+        return phpCaseInsensitive ? names.phpFolded.has(foldPhpIdentifierCase(name)) : names.exact.has(name);
+    };
+    // Function-valued bindings (`const helper = () => 1`) index as variables, so the
+    // kind scan above cannot see them; the detailed pass mirrors each name it proves
+    // callable here as its files are processed.
+    const noteCallableName = (name, phpCaseInsensitive = false) => {
+        const names = ensureCallableNames();
+        names.exact.add(name);
+        if (phpCaseInsensitive)
+            names.phpFolded.add(foldPhpIdentifierCase(name));
     };
     const optionFileKeys = opts?.files ? new Set(Array.from(opts.files, fileIdentityKey)) : undefined;
     for (const moduleEntry of index.byFile.values()) {
@@ -147,7 +303,19 @@ export async function buildSymbolGraphDetailed(index, opts) {
             if (!sup || src === undefined || !tree) {
                 throw new Error(`Failed to parse ${file}`);
             }
-            const { aliasToTargetDef, aliasToTargetModule } = buildImportAliasMaps(index, moduleEntry, resolveExportNamespace, resolveExportFrom);
+            ownershipParsedContexts.set(fileIdentityKey(file), Promise.resolve({ source: src, tree, sup }));
+            const scopeIndex = getOrBuildScopeIndex(index, file, src, sup, moduleEntry, tree);
+            const { aliasToTargetDef, aliasToTargetModule } = buildImportAliasMaps(index, moduleEntry, resolveExportNamespace, resolveExportFrom, scopeIndex);
+            if (sup.id === "c" || sup.id === "cpp") {
+                for (const [alias, def] of [...aliasToTargetDef]) {
+                    const exported = resolveExport(index, def.file, alias, {
+                        allowLocalFallback: false,
+                        ...(sup.id === "c" ? { cNamespace: "ordinary" } : {}),
+                    });
+                    if (exported?.kind !== "resolved")
+                        aliasToTargetDef.delete(alias);
+                }
+            }
             const { functionNodes, classNodes, constStringOf } = collectDetailedDeclarations(tree.rootNode, sup, src, moduleEntry.locals);
             const memberResolver = createMemberChainResolver({
                 sup,
@@ -155,27 +323,100 @@ export async function buildSymbolGraphDetailed(index, opts) {
                 constStringOf,
                 aliasToTargetModule,
                 resolveMemberPathFromModule,
+                ...(sup.id === "zig" || sup.id === "csharp" || isJsTsLanguage(sup.id)
+                    ? {
+                        resolveNamespaceAlias: (alias, useNode) => {
+                            if (sup.id === "zig") {
+                                const binding = findClosestScopeBinding(scopeIndex, alias, useNode, sup);
+                                if (binding && binding.kind !== "namespace")
+                                    return undefined;
+                            }
+                            const imported = innermostNamespaceImport(moduleEntry.imports, alias, useNode, sup.normalizeIdentifier);
+                            if (isJsTsLanguage(sup.id) &&
+                                imported?.mechanism === "cjs" &&
+                                typeof imported.resolved === "string" &&
+                                cjsRequireValueBinding(index, imported.resolved)) {
+                                return undefined;
+                            }
+                            if (typeof imported?.resolved === "string")
+                                return imported.resolved;
+                            if (isJsTsLanguage(sup.id))
+                                return aliasToTargetModule.get(alias);
+                            return undefined;
+                        },
+                    }
+                    : {}),
+                // Go has no `resolveNamespaceAlias` override otherwise, so a local variable that
+                // shadows a package alias (`u := LocalU{}; u.Square()` alongside `import u "pkg"`)
+                // would still resolve `u.Square` through the blind `aliasToTargetModule` text map.
+                // Refuse the package alias whenever a closer, non-namespace scope binding owns the
+                // name at this exact use site, matching how the receiver-proof path already treats
+                // the local as the real receiver instead.
+                ...(sup.id === "go"
+                    ? {
+                        resolveNamespaceAlias: (alias, useNode) => {
+                            const binding = findClosestScopeBinding(scopeIndex, alias, useNode, sup);
+                            if (binding && binding.kind !== "namespace")
+                                return undefined;
+                            return aliasToTargetModule.get(alias);
+                        },
+                    }
+                    : {}),
             });
             const { memberExpressionType, optionalMemberTypes, propertyIdentifierTypes, resolveMemberChainTarget } = memberResolver;
-            const scopeIndex = getOrBuildScopeIndex(index, file, src, sup, moduleEntry, tree);
-            const resolveIdentifier = (name, node) => {
-                const binding = findClosestScopeBinding(scopeIndex, name, node, sup);
-                if (binding) {
-                    if (!binding.def)
-                        return aliasToTargetDef.get(binding.name) ?? null;
-                    return (moduleEntry.locals.find((local) => sup.normalizeIdentifier(local.localName) === binding.canonicalName &&
-                        local.range.start.index === binding.def?.start.index &&
-                        local.range.end.index === binding.def?.end.index) ?? null);
-                }
-                const localCandidates = moduleEntry.locals.filter((local) => sup.normalizeIdentifier(local.localName) === sup.normalizeIdentifier(name));
-                if (localCandidates.length === 1)
-                    return localCandidates[0] ?? null;
-                return aliasToTargetDef.get(name) ?? null;
+            recordCallableDeclarationAliases(moduleEntry, sup.id, scopeIndex.all, nodeAliases);
+            recordTypeScriptCallableAliases(moduleEntry, sup.id, tree, nodeAliases);
+            // Files the shared name lookup reads synchronously for this module (imports, C++ includes).
+            const parsedForResolution = new Map([
+                [fileIdentityKey(file), { source: src, tree, sup }],
+            ]);
+            for (const preload of nameResolutionPreloadFiles(index, moduleEntry, sup.id)) {
+                const key = fileIdentityKey(preload);
+                if (parsedForResolution.has(key))
+                    continue;
+                const parsedFile = await loadParsedFile(preload);
+                if (parsedFile)
+                    parsedForResolution.set(key, parsedFile);
+            }
+            const resolutionFiles = {
+                get: (target) => parsedForResolution.get(fileIdentityKey(target)) ?? null,
+            };
+            const moduleParsed = { source: src, tree, sup };
+            const bareNameUse = (name, node) => {
+                const phpImportType = sup.id === "php"
+                    ? (phpImportTypeAtPosition(moduleEntry.imports, node.startPosition.row, node.startPosition.column) ??
+                        inferPhpQualifiedReferenceImportType(node))
+                    : undefined;
+                return {
+                    index,
+                    mod: moduleEntry,
+                    file,
+                    parsed: moduleParsed,
+                    scopeIndex,
+                    files: resolutionFiles,
+                    node,
+                    name,
+                    ...(phpImportType ? { phpImportType } : {}),
+                };
+            };
+            // The graph has nodes only for indexed symbols; a parameter or function-local binding
+            // that navigation resolves has no node, so it gets no edge.
+            const indexedOrNull = (definition) => definition ? indexedSymbolFor(index, definition) : null;
+            const resolveName = (name, node) => resolveBareName(bareNameUse(name, node));
+            const resolveIdentifier = (name, node) => indexedOrNull(definitionWithoutDeferredSteps(resolveName(name, node)));
+            const settleName = async (name, node, resolution) => {
+                const settled = await settleNameResolution(bareNameUse(name, node), resolution, {
+                    // A member that cannot accept the call's argument count gets no edge and no fallback.
+                    requireAcceptedArity: true,
+                    recoverIncludedStar: (lookupName, cNamespace) => recoverIncludedCallableStar(index, moduleEntry, sup.id, lookupName, cNamespace, node, src),
+                });
+                return indexedOrNull(settled?.status === "ok" ? settled.definition : null);
             };
             const edgePassContext = {
                 index,
                 sup,
                 source: src,
+                tree,
                 moduleEntry,
                 nodes,
                 membersOnly,
@@ -185,16 +426,57 @@ export async function buildSymbolGraphDetailed(index, opts) {
                 aliasToTargetDef,
                 aliasToTargetModule,
                 resolveIdentifier,
+                resolveName,
+                settleName,
+                hasNonModuleBinding: (name, node) => {
+                    const binding = findClosestScopeBinding(scopeIndex, name, node, sup);
+                    return !!binding && scopeIndex.allScopes[0]?.map.get(binding.canonicalName) !== binding;
+                },
                 resolveExportFrom,
                 resolveMemberChainTarget,
+                cppDeclaresClass: (def) => {
+                    const parsed = parsedForResolution.get(fileIdentityKey(def.file));
+                    if (!parsed)
+                        return false;
+                    const start = def.range.start.index ?? 0;
+                    const nameNode = parsed.tree.rootNode.descendantForIndex(start, def.range.end.index ?? start);
+                    return CPP_CLASS_DECLARATION_TYPES.has(nameNode.parent?.type ?? "");
+                },
+                resolveMemberAccessTarget: async (node) => {
+                    const useNode = tree.rootNode.descendantForIndex(node.startIndex, node.endIndex);
+                    const resolved = await resolveMemberAccessDefinition({
+                        index,
+                        mod: moduleEntry,
+                        node: useNode,
+                        source: src,
+                        tree,
+                        sup,
+                        resolveLexicalBinding: (expression) => {
+                            const name = src.slice(expression.startIndex, expression.endIndex);
+                            const imported = aliasToTargetDef.get(name);
+                            if (imported)
+                                return imported;
+                            return resolveIdentifier(name, expression);
+                        },
+                    });
+                    return resolved?.status === "ok" ? resolved.definition : null;
+                },
                 recordEdge,
                 receiverCalls,
-                hasCallableNamed,
+                receiverMemberScopes,
+                receiverMemberArities,
+                sharedOwnerPeers,
+                sharedOwnerAnchors,
+                sharedOwnerAccessibleMembers,
+                fileHiddenMemberIds,
+                nodeAliases,
+                noteCallableName,
+                loadParsedFile,
             };
             emitPythonDecoratorEdges(edgePassContext, tree.rootNode);
-            emitFunctionBodyEdges(edgePassContext, functionNodes);
-            emitMemberOwnershipEdges(edgePassContext, functionNodes, classNodes);
-            emitClassInheritanceEdges(edgePassContext, classNodes);
+            await emitFunctionBodyEdges(edgePassContext, functionNodes);
+            await emitMemberOwnershipEdges(edgePassContext, functionNodes, classNodes);
+            await emitClassInheritanceEdges(edgePassContext, classNodes);
             emitRustImplEdges(edgePassContext, tree.rootNode);
         }
         catch (error) {
@@ -207,12 +489,121 @@ export async function buildSymbolGraphDetailed(index, opts) {
             logWithLevel(opts?.logLevel, "warn", `Warning: Failed to build detailed symbol edges for ${file}:`, error);
         }
     }
-    emitReceiverCallEdges({ nodes, edges }, receiverCalls, recordEdge);
+    // Function-valued bindings are proven while each file is processed. Apply the callable-name
+    // prefilter only after that pass so receiver calls do not depend on file iteration order.
+    const callableReceiverCalls = receiverCalls.filter((candidate) => hasCallableNamed(candidate.memberName, candidate.caseInsensitiveMemberName));
+    let typeScriptReceiverFiles;
+    let typeScriptReceiverNames;
+    for (const candidate of callableReceiverCalls) {
+        if (candidate.argumentCount === null)
+            continue;
+        const languageId = supportForFileWithoutHeaderSample(candidate.site.file, index.languageExtensions)?.id;
+        if (languageId !== "ts" && languageId !== "tsx")
+            continue;
+        (typeScriptReceiverFiles ??= new Set()).add(fileIdentityKey(candidate.site.file));
+        (typeScriptReceiverNames ??= new Set()).add(candidate.memberName);
+    }
+    const typeScriptReceiverTargets = typeScriptReceiverNames?.size
+        ? new Map()
+        : undefined;
+    if (typeScriptReceiverTargets && typeScriptReceiverNames) {
+        for (const node of nodes.values()) {
+            if (!typeScriptReceiverNames.has(node.name))
+                continue;
+            const targetLanguageId = supportForFileWithoutHeaderSample(node.file, index.languageExtensions)?.id;
+            if (targetLanguageId !== "ts" && targetLanguageId !== "tsx")
+                continue;
+            const module = index.byFile.get(fileIdentityKey(node.file));
+            const def = module?.locals.find((candidate) => defNodeId(candidate) === node.id);
+            if (!module || !def || def.kind !== SymbolKind.Function)
+                continue;
+            if (!module.locals.some((candidate) => candidate.kind === SymbolKind.Function &&
+                candidate.localName === def.localName &&
+                candidate.range.start.index !== def.range.start.index)) {
+                continue;
+            }
+            const parsed = await loadParsedFile(def.file);
+            typeScriptReceiverTargets.set(node.id, { def, module, parsed });
+        }
+    }
+    const removedReceiverEdges = emitReceiverCallEdges({ nodes, edges }, callableReceiverCalls, recordEdge, receiverMemberScopes, nodeAliases, receiverMemberArities, sharedOwnerAnchors, sharedOwnerAccessibleMembers, fileHiddenMemberIds, (targetId, candidate) => {
+        if (candidate.argumentCount === null || !typeScriptReceiverFiles?.has(fileIdentityKey(candidate.site.file))) {
+            return true;
+        }
+        const target = typeScriptReceiverTargets?.get(targetId);
+        if (!target)
+            return true;
+        if (!target.parsed)
+            return false;
+        return typescriptOverloadImplementationAcceptsCount({
+            implementation: target.def,
+            locals: target.module.locals,
+            tree: target.parsed.tree,
+            source: target.parsed.source,
+            languageId: target.parsed.sup.id,
+            argumentCount: candidate.argumentCount,
+        });
+    });
+    edgeCount -= removedReceiverEdges.length;
+    for (const edge of removedReceiverEdges)
+        added.delete(edgeKey(edge.from, edge.to, edge.label, edge.site));
+    const canonicalNodeId = (id) => {
+        let current = id;
+        const seen = new Set();
+        while (nodeAliases.has(current) && !seen.has(current)) {
+            seen.add(current);
+            current = nodeAliases.get(current);
+        }
+        return current;
+    };
+    for (const [aliasId] of nodeAliases) {
+        const canonicalId = canonicalNodeId(aliasId);
+        nodeAliases.set(aliasId, canonicalId);
+        if (canonicalId === aliasId)
+            continue;
+        const aliasNode = nodes.get(aliasId);
+        const canonicalNode = nodes.get(canonicalId);
+        if (aliasNode && canonicalNode) {
+            if (!canonicalNode.docstring && aliasNode.docstring)
+                canonicalNode.docstring = aliasNode.docstring;
+            canonicalNode.lineSpan = Math.max(canonicalNode.lineSpan ?? 0, aliasNode.lineSpan ?? 0);
+            canonicalNode.complexity = Math.max(canonicalNode.complexity ?? 0, aliasNode.complexity ?? 0);
+            if (aliasNode.callable)
+                canonicalNode.callable = true;
+            if (aliasNode.implementationTarget)
+                canonicalNode.implementationTarget = true;
+            if (canonicalNode.memberArity === undefined && aliasNode.memberArity !== undefined) {
+                canonicalNode.memberArity = aliasNode.memberArity;
+            }
+        }
+        nodes.delete(aliasId);
+    }
+    if (nodeAliases.size) {
+        const reconciledEdges = [];
+        const reconciledEdgeKeys = new Set();
+        for (const edge of edges) {
+            const reconciled = {
+                ...edge,
+                from: canonicalNodeId(edge.from),
+                to: canonicalNodeId(edge.to),
+            };
+            const key = edgeKey(reconciled.from, reconciled.to, reconciled.label, reconciled.site);
+            if (reconciledEdgeKeys.has(key))
+                continue;
+            reconciledEdgeKeys.add(key);
+            reconciledEdges.push(reconciled);
+        }
+        edges.splice(0, edges.length, ...reconciledEdges);
+        added.clear();
+        for (const edge of edges)
+            added.add(edgeKey(edge.from, edge.to, edge.label, edge.site));
+        edgeCount = edges.length;
+    }
     emitMemberImplementationEdges({ nodes, edges }, recordEdge);
     if (skippedSyntaxTreeFiles > 0) {
         logWithLevel(opts?.logLevel, "warn", `Warning: Skipped detailed symbol edges for ${skippedSyntaxTreeFiles} file(s) because no syntax-tree backend was available.`);
     }
-    return {
+    const graph = {
         nodes,
         edges,
         ...(configuredMaxEdges !== undefined
@@ -223,5 +614,8 @@ export async function buildSymbolGraphDetailed(index, opts) {
             }
             : {}),
     };
+    if (nodeAliases.size)
+        Object.defineProperty(graph, "nodeAliases", { value: nodeAliases });
+    return graph;
 }
 //# sourceMappingURL=symbol-graph-detailed.js.map