@lzehrung/codegraph 2.3.31 → 3.0.0

package/dist/impact/call-compatibility.js

@@ -1,14 +1,17 @@
 import path from "node:path";
-import { findUsageReferences, goToDefinition } from "../indexer/navigation.js";
+import { findUsageReferences, getCppEquivalentCallableDefinitions, goToDefinition } from "../indexer/navigation.js";
 import { ensureParsedContext } from "../indexer/parse-context.js";
+import { findClosestScopeBinding, getOrBuildScopeIndex, resolveNamedDefinition } from "../indexer/navigation-local.js";
+import { cppEquivalentCallableBindings } from "../indexer/cpp-callables.js";
+import { getCachedReferenceCandidateFiles } from "../indexer/navigation-references.js";
 import { SymbolKind } from "../indexer/types.js";
 import { supportForFileWithoutHeaderSample } from "../languages.js";
+import { CALLABLE_DECLARATION_NODE_TYPES, CALLABLE_VARIABLE_VALUE_NODE_TYPES, getCallableArity, getCallableArityFromParameterText, getCallableDeclarationKind, getCallArgumentCount, getCallArgumentCountFromArgumentText, memberLookupBinding, } from "../languages/callable-arity.js";
 import { sliceText, toRange } from "../util/ast.js";
 import { fileIdentityKey } from "../util/paths.js";
 import { getCallCompatibilityLanguageProfile, getCallCompatibilityProvider, getCallCompatibilitySupportedLanguages, registerCallCompatibilityExtractors, } from "./call-compatibility/providers/index.js";
-import { findOpeningParen, findSignatureOpeningParen, findCommentEnd, findCallOpeningParen, findBalancedParentheses, canStartRegexLiteral, findRegexLiteralEnd, splitTopLevelCommaGroups, } from "./call-compatibility/text-scanner.js";
-import { PARAMETER_LIST_NODE_TYPES } from "../graphs/symbol-graph-detailed/receiver-calls.js";
-import { directSignatureParameterNode, findAncestorOfTypes, findFirstDescendantOfTypes, } from "./signature-node-utils.js";
+import { findSignatureOpeningParen, findCallOpeningParen, findBalancedParentheses, } from "./call-compatibility/text-scanner.js";
+import { findAncestorOfTypes } from "./signature-node-utils.js";
 import { canStartReferenceLookup, recordReferenceLookupOmitted, recordReferenceLookupStarted, } from "./budgets.js";
 function supportsCallCompatibilityLanguage(languageId) {
     return getCallCompatibilityProvider(languageId) !== null;
@@ -16,365 +19,31 @@ function supportsCallCompatibilityLanguage(languageId) {
 function referenceScanLimitForCallsites(maxRefs) {
     return Math.max(maxRefs + 50, maxRefs * 4);
 }
-function hasTopLevelEquals(text) {
-    let parenDepth = 0;
-    let bracketDepth = 0;
-    let braceDepth = 0;
-    let angleDepth = 0;
-    let quote = null;
-    let escaped = false;
-    for (let index = 0; index < text.length; index += 1) {
-        const char = text[index];
-        if (quote) {
-            if (escaped) {
-                escaped = false;
-                continue;
-            }
-            if (char === "\\") {
-                escaped = true;
-                continue;
-            }
-            if (char === quote) {
-                quote = null;
-            }
-            continue;
-        }
-        const commentEnd = findCommentEnd(text, index);
-        if (commentEnd !== null) {
-            if (commentEnd < 0) {
-                return false;
-            }
-            index = commentEnd - 1;
-            continue;
-        }
-        if (char === '"' || char === "'" || char === "`") {
-            quote = char;
-            continue;
-        }
-        if (char === "(") {
-            parenDepth += 1;
-            continue;
-        }
-        if (char === ")") {
-            parenDepth -= 1;
-            if (parenDepth < 0) {
-                return false;
-            }
-            continue;
-        }
-        if (char === "[") {
-            bracketDepth += 1;
-            continue;
-        }
-        if (char === "]") {
-            bracketDepth -= 1;
-            if (bracketDepth < 0) {
-                return false;
-            }
-            continue;
-        }
-        if (char === "{") {
-            braceDepth += 1;
-            continue;
-        }
-        if (char === "}") {
-            braceDepth -= 1;
-            if (braceDepth < 0) {
-                return false;
-            }
-            continue;
-        }
-        const atTopLevel = !parenDepth && !bracketDepth && !braceDepth;
-        if (char === "<" && atTopLevel) {
-            angleDepth += 1;
-            continue;
-        }
-        if (char === ">" && text[index - 1] !== "=" && atTopLevel && angleDepth) {
-            angleDepth -= 1;
-            continue;
-        }
-        if (char === "=" && text[index + 1] !== ">" && atTopLevel && !angleDepth) {
-            return true;
-        }
-    }
-    return false;
-}
-const callableDeclarationTypes = new Set([
-    "function_declaration",
-    "function_definition",
-    "function_item",
-    "method",
-    "singleton_method",
-    "method_declaration",
-    "constructor_declaration",
-    "init_declaration",
-    "protocol_function_declaration",
-    "arrow_function",
-    "function",
-    "function_expression",
-    "variable_declarator",
-    "declaration",
-]);
-const callableVariableValueTypes = new Set(["arrow_function", "function_expression", "function"]);
-const parameterListTypes = new Set(Object.keys(PARAMETER_LIST_NODE_TYPES));
-function shouldSkipFirstReceiverParameter(profile, declaration) {
-    if (profile.receiver.skipFirst !== "class-methods") {
-        return true;
-    }
-    let current = declaration.parent;
-    while (current) {
-        if (profile.receiver.methodScopeTypes.includes(current.type)) {
-            return true;
-        }
-        if (profile.receiver.nonMethodScopeTypes.includes(current.type)) {
-            return false;
-        }
-        current = current.parent;
-    }
-    return false;
-}
-function findSignatureParameterText(request, profile) {
-    if (!request.tree) {
-        return null;
-    }
-    const node = request.tree.rootNode.descendantForIndex(request.symbolStartIndex, request.symbolStartIndex);
-    const declaration = findAncestorOfTypes(node, callableDeclarationTypes);
-    if (!declaration) {
-        return null;
-    }
-    const skipFirstReceiver = shouldSkipFirstReceiverParameter(profile, declaration);
-    let params = directSignatureParameterNode(declaration);
-    if (!params && declaration.type === "variable_declarator") {
-        const valueNode = declaration.childForFieldName("value");
-        if (!valueNode || !callableVariableValueTypes.has(valueNode.type)) {
-            return null;
-        }
-        params = directSignatureParameterNode(valueNode) ?? findFirstDescendantOfTypes(valueNode, parameterListTypes);
-    }
-    if (!params) {
-        params = findFirstDescendantOfTypes(declaration, parameterListTypes);
-    }
-    if (!params) {
-        const directParameterChildType = profile.directParameterChildType;
-        if (directParameterChildType !== null) {
-            const parameterNodes = declaration.namedChildren.filter((child) => child.type === directParameterChildType);
-            const first = parameterNodes[0];
-            const last = parameterNodes[parameterNodes.length - 1];
-            if (first && last) {
-                return {
-                    text: request.source.slice(first.startIndex, last.endIndex),
-                    skipFirstReceiver,
-                };
-            }
-        }
-        return { text: "", skipFirstReceiver };
-    }
-    const text = request.source.slice(params.startIndex, params.endIndex).trim();
-    if (text.startsWith("(") && text.endsWith(")")) {
-        return { text: text.slice(1, -1), skipFirstReceiver };
-    }
-    return { text, skipFirstReceiver };
-}
-function isReceiverParameter(profile, parameter, index, skipFirstReceiver) {
-    if (!skipFirstReceiver) {
-        return false;
-    }
-    const trimmed = parameter.trim();
-    if (!index) {
-        if (profile.receiver.firstPositionExact.includes(trimmed)) {
-            return true;
-        }
-        if (profile.receiver.firstPositionTypedPrefixes.some((prefix) => trimmed.startsWith(prefix))) {
-            return true;
-        }
-    }
-    const thisKeyword = profile.receiver.thisKeyword;
-    if (thisKeyword !== null) {
-        const colonIndex = trimmed.indexOf(":");
-        const namePortion = colonIndex >= 0 ? trimmed.slice(0, colonIndex).trim() : trimmed;
-        return namePortion === thisKeyword;
-    }
-    return false;
-}
-function hasTopLevelEllipsis(text) {
-    let parenDepth = 0;
-    let bracketDepth = 0;
-    let braceDepth = 0;
-    let angleDepth = 0;
-    let quote = null;
-    let escaped = false;
-    for (let index = 0; index < text.length; index += 1) {
-        const char = text[index];
-        if (quote) {
-            if (escaped) {
-                escaped = false;
-                continue;
-            }
-            if (char === "\\") {
-                escaped = true;
-                continue;
-            }
-            if (char === quote) {
-                quote = null;
-            }
-            continue;
-        }
-        const commentEnd = findCommentEnd(text, index);
-        if (commentEnd !== null) {
-            if (commentEnd < 0) {
-                return false;
-            }
-            index = commentEnd - 1;
-            continue;
-        }
-        if (canStartRegexLiteral(text, index, 0)) {
-            const regexEnd = findRegexLiteralEnd(text, index);
-            if (regexEnd === null || regexEnd < 0) {
-                return false;
-            }
-            index = regexEnd - 1;
-            continue;
-        }
-        if (char === '"' || char === "'" || char === "`") {
-            quote = char;
-            continue;
-        }
-        if (char === "(") {
-            parenDepth += 1;
-            continue;
-        }
-        if (char === ")") {
-            parenDepth -= 1;
-            if (parenDepth < 0) {
-                return false;
-            }
-            continue;
-        }
-        if (char === "[") {
-            bracketDepth += 1;
-            continue;
-        }
-        if (char === "]") {
-            bracketDepth -= 1;
-            if (bracketDepth < 0) {
-                return false;
-            }
-            continue;
-        }
-        if (char === "{") {
-            braceDepth += 1;
-            continue;
-        }
-        if (char === "}") {
-            braceDepth -= 1;
-            if (braceDepth < 0) {
-                return false;
-            }
-            continue;
-        }
-        const atDelimiterTopLevel = !parenDepth && !bracketDepth && !braceDepth;
-        if (char === "<" && atDelimiterTopLevel) {
-            angleDepth += 1;
-            continue;
-        }
-        if (char === ">" && angleDepth && atDelimiterTopLevel && text[index - 1] !== "=") {
-            angleDepth -= 1;
-            continue;
-        }
-        if (!angleDepth && atDelimiterTopLevel && text.startsWith("...", index)) {
-            return true;
-        }
-    }
-    return false;
-}
-function isRestParameter(profile, parameter) {
-    const trimmed = parameter.trim();
-    if (!trimmed) {
-        return false;
-    }
-    if (hasTopLevelEllipsis(trimmed)) {
-        return true;
-    }
-    if (profile.restPrefixes.some((prefix) => trimmed.startsWith(prefix))) {
-        return true;
-    }
-    return profile.restWordPatterns.some((pattern) => pattern.test(trimmed));
-}
-function isOptionalParameter(profile, parameter) {
-    const trimmed = parameter.trim();
-    if (!trimmed) {
-        return false;
-    }
-    const nameMarker = profile.optionalNameMarker;
-    if (nameMarker !== null) {
-        const colonIndex = trimmed.indexOf(":");
-        const namePortion = colonIndex >= 0 ? trimmed.slice(0, colonIndex) : trimmed;
-        if (namePortion.includes(nameMarker)) {
-            return true;
-        }
-    }
-    if (profile.keywordParameterValuePattern?.test(trimmed)) {
-        return true;
-    }
-    return hasTopLevelEquals(trimmed);
-}
-function parameterSlotCount(profile, parameter) {
-    const trimmed = parameter.trim();
-    if (!trimmed) {
-        return 0;
-    }
-    if (profile.zeroSlotParameters.includes(trimmed)) {
-        return 0;
-    }
-    return 1;
-}
-function signatureFromParameterText(profile, parameterText, angleMode, skipFirstReceiver = true) {
-    const parameters = splitTopLevelCommaGroups(parameterText, angleMode, profile.signatureCommaScanDetectsRegexLiterals);
-    if (!parameters) {
-        return null;
-    }
-    let minArgs = 0;
-    let maxArgs = 0;
-    let positionalArgCount = 0;
-    let hasRest = false;
-    parameters.forEach((parameter, index) => {
-        const trimmed = parameter.trim();
-        if (!trimmed ||
-            profile.parameterSeparators.includes(trimmed) ||
-            isReceiverParameter(profile, trimmed, index, skipFirstReceiver)) {
-            return;
-        }
-        if (isRestParameter(profile, trimmed)) {
-            hasRest = true;
-            return;
-        }
-        if (profile.keywordParameterPattern?.test(trimmed)) {
-            maxArgs += 1;
-            if (!isOptionalParameter(profile, trimmed)) {
-                minArgs += 1;
-            }
-            return;
-        }
-        const slotCount = parameterSlotCount(profile, trimmed);
-        if (!slotCount) {
-            return;
-        }
-        positionalArgCount += slotCount;
-        maxArgs += slotCount;
-        if (!isOptionalParameter(profile, trimmed)) {
-            minArgs = positionalArgCount;
-        }
-    });
-    return { minArgs, maxArgs: hasRest ? null : maxArgs, confidence: "high" };
-}
+const callableDeclarationTypes = new Set(Object.keys(CALLABLE_DECLARATION_NODE_TYPES));
 function extractCallableSignatureFromProvider(request) {
     const profile = getCallCompatibilityLanguageProfile(request.languageId);
     if (!profile) {
         return null;
     }
-    const astParameterText = findSignatureParameterText(request, profile);
-    if (astParameterText !== null) {
-        return signatureFromParameterText(profile, astParameterText.text, "type-context", astParameterText.skipFirstReceiver);
+    const binding = request.binding ?? "bound";
+    if (request.tree) {
+        const node = request.tree.rootNode.descendantForIndex(request.symbolStartIndex, request.symbolStartIndex);
+        const declaration = findAncestorOfTypes(node, callableDeclarationTypes);
+        if (declaration) {
+            const arity = getCallableArity({ languageId: request.languageId, source: request.source, declaration, binding });
+            if (arity) {
+                return { ...arity, confidence: "high" };
+            }
+            // A tree-proven declaration with no provable parameter structure is unknown, except a
+            // variable declarator whose value is not callable: that shape always fell back to the
+            // source scan, and the fallback must not change for it.
+            const valueNode = declaration.type === "variable_declarator" ? declaration.childForFieldName("value") : null;
+            const fallsThroughToSource = declaration.type === "variable_declarator" &&
+                (!valueNode || !CALLABLE_VARIABLE_VALUE_NODE_TYPES[valueNode.type]);
+            if (!fallsThroughToSource) {
+                return null;
+            }
+        }
     }
     if (!profile.sourceFallback) {
         return null;
@@ -384,16 +53,22 @@ function extractCallableSignatureFromProvider(request) {
     if (!balanced) {
         return null;
     }
-    return signatureFromParameterText(profile, balanced.inner, "type-context");
+    const arity = getCallableArityFromParameterText({
+        languageId: request.languageId,
+        parameterText: balanced.inner,
+        binding,
+    });
+    return arity ? { ...arity, confidence: "high" } : null;
 }
 function extractCallsiteArgumentsFromProvider(request) {
     const profile = getCallCompatibilityLanguageProfile(request.languageId);
     if (!profile) {
         return null;
     }
-    const astArgumentText = findCallsiteArgumentText(request, profile);
-    if (astArgumentText !== null) {
-        return callsiteFromArgumentText(profile, astArgumentText.text, astArgumentText.trailingArgumentCount);
+    const callNode = request.tree ? locateCallsiteCallNode(request) : null;
+    if (callNode) {
+        const argCount = getCallArgumentCount({ languageId: request.languageId, source: request.source, call: callNode });
+        return argCount === null ? null : { argCount, confidence: "high" };
     }
     if (!profile.sourceFallback) {
         return null;
@@ -403,7 +78,11 @@ function extractCallsiteArgumentsFromProvider(request) {
     if (!balanced) {
         return null;
     }
-    return callsiteFromArgumentText(profile, balanced.inner);
+    const argCount = getCallArgumentCountFromArgumentText({
+        languageId: request.languageId,
+        argumentText: balanced.inner,
+    });
+    return argCount === null ? null : { argCount, confidence: "high" };
 }
 registerCallCompatibilityExtractors({
     extractSignature: extractCallableSignatureFromProvider,
@@ -423,84 +102,26 @@ export function extractCallsiteArguments(request) {
     }
     return provider.extractCallsite(request);
 }
-const callExpressionTypes = new Set([
-    "call_expression",
-    "call",
-    "method_invocation",
-    "invocation_expression",
-    "function_call_expression",
-    "object_creation_expression",
-]);
-const argumentListTypes = new Set(["argument_list", "arguments", "value_arguments", "call_suffix"]);
-function countTrailingClosureArguments(text) {
-    let startIndex = 0;
-    let count = 0;
-    while (startIndex < text.length) {
-        while (/\s/.test(text[startIndex] ?? "")) {
-            startIndex += 1;
-        }
-        if (startIndex === text.length) {
-            return count;
-        }
-        if (text[startIndex] !== "{") {
-            return null;
-        }
-        let braceDepth = 0;
-        let quote = null;
-        let escaped = false;
-        let closed = false;
-        for (let index = startIndex; index < text.length; index += 1) {
-            const char = text[index];
-            if (quote) {
-                if (escaped) {
-                    escaped = false;
-                    continue;
-                }
-                if (char === "\\") {
-                    escaped = true;
-                    continue;
-                }
-                if (char === quote) {
-                    quote = null;
-                }
-                continue;
-            }
-            const commentEnd = findCommentEnd(text, index);
-            if (commentEnd !== null) {
-                if (commentEnd < 0) {
-                    return null;
-                }
-                index = commentEnd - 1;
-                continue;
-            }
-            if (char === '"' || char === "'" || char === "`") {
-                quote = char;
-                continue;
-            }
-            if (char === "{") {
-                braceDepth += 1;
-                continue;
-            }
-            if (char === "}") {
-                braceDepth -= 1;
-                if (braceDepth < 0) {
-                    return null;
-                }
-                if (!braceDepth) {
-                    startIndex = index + 1;
-                    count += 1;
-                    closed = true;
-                    break;
-                }
-            }
-        }
-        if (!closed) {
-            return null;
-        }
-    }
-    return count;
-}
-function findCallsiteArgumentText(request, profile) {
+/**
+ * Call node types recognized at a callee range. PHP member and scoped call forms stay excluded:
+ * callsite extraction for them remains the documented limitation it was before the shared arity
+ * facts existed, so no caller sees a newly counted or newly dropped callsite here.
+ */
+const CALL_EXPRESSION_NODE_TYPES = {
+    call: true,
+    call_expression: true,
+    function_call_expression: true,
+    invocation_expression: true,
+    method_invocation: true,
+    object_creation_expression: true,
+};
+const callExpressionTypes = new Set(Object.keys(CALL_EXPRESSION_NODE_TYPES));
+/**
+ * Locate and validate the call node for a callee range. The callee must sit inside the call's
+ * target expression, so a non-callee reference inside a call (an argument, for example) is not a
+ * callsite, and a trailing-closure wrapper call counts as the callsite.
+ */
+function locateCallsiteCallNode(request) {
     if (!request.tree) {
         return null;
     }
@@ -526,58 +147,7 @@ function findCallsiteArgumentText(request, profile) {
     if (!targetNode || request.calleeStartIndex < targetNode.startIndex || endIndex > targetNode.endIndex) {
         return null;
     }
-    const argumentNode = callNode.childForFieldName("arguments") ??
-        callNode.namedChildren.find((child) => argumentListTypes.has(child.type)) ??
-        findFirstDescendantOfTypes(callNode, argumentListTypes);
-    if (argumentNode) {
-        let text = request.source.slice(argumentNode.startIndex, argumentNode.endIndex).trim();
-        let trailingArgumentCount = 0;
-        const callSuffix = argumentNode.type === "call_suffix"
-            ? argumentNode
-            : findFirstDescendantOfTypes(callNode, new Set(["call_suffix"]));
-        const valueArguments = argumentNode.type === "value_arguments"
-            ? argumentNode
-            : findFirstDescendantOfTypes(callSuffix ?? argumentNode, new Set(["value_arguments"]));
-        if (valueArguments) {
-            const trailingEndIndex = callSuffix?.endIndex ?? callNode.endIndex;
-            const trailingText = request.source.slice(valueArguments.endIndex, trailingEndIndex).trim();
-            const count = countTrailingClosureArguments(trailingText);
-            if (count === null) {
-                return null;
-            }
-            text = request.source.slice(valueArguments.startIndex, valueArguments.endIndex).trim();
-            trailingArgumentCount = count;
-        }
-        if (text.startsWith("(") && text.endsWith(")")) {
-            return { text: text.slice(1, -1), trailingArgumentCount };
-        }
-        return { text, trailingArgumentCount };
-    }
-    if (profile.callsiteParenthesesFallback) {
-        const openIndex = findOpeningParen(request.source, callNode.startIndex);
-        const balanced = findBalancedParentheses(request.source, openIndex);
-        return balanced ? { text: balanced.inner, trailingArgumentCount: 0 } : null;
-    }
-    return null;
-}
-function hasUncountableSpreadArgument(profile, arg) {
-    const trimmed = arg.trim();
-    if (trimmed.startsWith("...")) {
-        return true;
-    }
-    return profile.spreadPrefixes.some((prefix) => trimmed.startsWith(prefix));
-}
-function callsiteFromArgumentText(profile, argumentText, trailingArgumentCount = 0) {
-    const args = splitTopLevelCommaGroups(argumentText, "type-context");
-    if (!args) {
-        return null;
-    }
-    for (const arg of args) {
-        if (hasUncountableSpreadArgument(profile, arg)) {
-            return null;
-        }
-    }
-    return { argCount: args.length + trailingArgumentCount, confidence: "high" };
+    return callNode;
 }
 function isCallableChangedSymbol(symbol) {
     return (symbol.kind === SymbolKind.Function ||
@@ -606,7 +176,18 @@ function sameOverloadContainer(left, right) {
     }
     return left.parent.id === right.parent.id;
 }
-function hasSameFileOverloadCandidates(index, changedSymbol, languageId, source, tree) {
+function changedCppCallableBinding(index, changedSymbol, parsed) {
+    if (parsed.sup.id !== "cpp")
+        return undefined;
+    const module = index.byFile.get(fileIdentityKey(changedSymbol.file));
+    if (!module)
+        return undefined;
+    const scope = getOrBuildScopeIndex(index, module.file, parsed.source, parsed.sup, module, parsed.tree);
+    return scope.bindings
+        .get(parsed.sup.normalizeIdentifier(changedSymbol.name))
+        ?.find((binding) => binding.kind === "function" && binding.def && sameRangeStart(binding.def, changedSymbol.range));
+}
+function hasSameFileOverloadCandidates(index, changedSymbol, parsed) {
     const module = index.byFile.get(fileIdentityKey(changedSymbol.file));
     if (!module) {
         return false;
@@ -615,6 +196,7 @@ function hasSameFileOverloadCandidates(index, changedSymbol, languageId, source,
     if (changedStartIndex === undefined) {
         return false;
     }
+    const { source, tree, sup } = parsed;
     const changedDeclaration = callableDeclarationAt(tree, changedStartIndex);
     for (const local of module.locals) {
         if (local.localName !== changedSymbol.name || sameRangeStart(local.range, changedSymbol.range)) {
@@ -629,7 +211,7 @@ function hasSameFileOverloadCandidates(index, changedSymbol, languageId, source,
             continue;
         }
         const signature = extractCallableSignature({
-            languageId,
+            languageId: sup.id,
             source,
             symbolStartIndex,
             tree,
@@ -740,11 +322,62 @@ function bestGotoNode(target, symbolName, source) {
     walk(target);
     return best;
 }
-async function collectVerifiedCallsiteReferences(index, changedSymbol, maxRefs, shouldIncludeReference, diagnostics) {
+function cppUnqualifiedCallTarget(index, file, parsed, target) {
+    if (parsed.sup.id !== "cpp" || target.type !== "identifier")
+        return null;
+    const module = index.byFile.get(fileIdentityKey(file));
+    if (!module)
+        return null;
+    const name = sliceText(target, parsed.source);
+    const scope = getOrBuildScopeIndex(index, file, parsed.source, parsed.sup, module, parsed.tree);
+    const binding = findClosestScopeBinding(scope, name, target, parsed.sup);
+    if (binding?.kind === "function") {
+        const equivalents = cppEquivalentCallableBindings(binding);
+        if (equivalents.length !== (binding.sameScopeFunctionBindings?.length ?? 1))
+            return null;
+        const canonical = equivalents.find((candidate) => candidate.callable?.definition) ?? equivalents[0];
+        const range = canonical?.def;
+        if (!range)
+            return null;
+        return module.locals.find((local) => sameRangeStart(local.range, range)) ?? null;
+    }
+    // A local variable or parameter shadows the function; member expressions and
+    // ambiguous overload sets cannot be recovered as unqualified calls.
+    if (binding && !binding.import)
+        return null;
+    const resolved = resolveNamedDefinition(index, module, file, parsed.sup, name);
+    if (resolved?.status !== "ok" || resolved.definition.kind !== SymbolKind.Function)
+        return null;
+    return resolved.definition;
+}
+async function collectVerifiedCallsiteReferences(index, changedSymbol, maxRefs, shouldIncludeReference, diagnostics, parsedDefinition, equivalentDefinitions, excludedReferences) {
     const refs = [];
     const seen = new Set();
+    const languageId = parsedDefinition.sup.id;
+    const def = {
+        file: changedSymbol.file,
+        localName: changedSymbol.name,
+        kind: changedSymbol.kind,
+        range: changedSymbol.range,
+    };
+    let candidateFiles;
+    if ((languageId === "c" || languageId === "cpp") && changedSymbol.kind === SymbolKind.Function) {
+        candidateFiles = new Set();
+        for (const definition of equivalentDefinitions ?? [def]) {
+            const module = index.byFile.get(fileIdentityKey(definition.file));
+            const exportedNames = module?.exports.flatMap((entry) => entry.type === "local" && sameDefinition(entry.target, definition) ? [entry.exportedAs] : []) ?? [];
+            if (!exportedNames.length)
+                exportedNames.push(definition.localName);
+            candidateFiles.add(fileIdentityKey(definition.file));
+            for (const file of getCachedReferenceCandidateFiles(index, definition, exportedNames, false, languageId)) {
+                candidateFiles.add(fileIdentityKey(file));
+            }
+        }
+    }
     for (const module of index.byFile.values()) {
         const file = module.file;
+        if (candidateFiles && !candidateFiles.has(fileIdentityKey(file)))
+            continue;
         if (refs.length >= maxRefs) {
             break;
         }
@@ -772,18 +405,16 @@ async function collectVerifiedCallsiteReferences(index, changedSymbol, maxRefs,
                             file,
                             line: gotoNode.startPosition.row + 1,
                             column: gotoNode.startPosition.column + 1,
-                        });
-                        if (result.status === "ok") {
-                            const def = {
-                                file: changedSymbol.file,
-                                localName: changedSymbol.name,
-                                kind: changedSymbol.kind,
-                                range: changedSymbol.range,
-                            };
-                            if (sameDefinition(result.definition, def)) {
+                        }, parsed);
+                        // Navigation rejects invalid C++ arity. Compatibility diagnostics need
+                        // the unique lexical/import binding before judging the argument count.
+                        const definition = result.status === "ok" ? result.definition : cppUnqualifiedCallTarget(index, file, parsed, target);
+                        if (definition) {
+                            if (sameDefinition(definition, def) ||
+                                equivalentDefinitions?.some((candidate) => sameDefinition(definition, candidate))) {
                                 const range = toRange(gotoNode);
                                 const key = `${fileIdentityKey(file)}:${range.start.line}:${range.start.column}`;
-                                if (!seen.has(key)) {
+                                if (!seen.has(key) && !excludedReferences.has(key)) {
                                     seen.add(key);
                                     refs.push({ file, range });
                                 }
@@ -821,8 +452,82 @@ function incrementSkippedReason(diagnostics, reason) {
     }
     diagnostics.skippedByReason[reason] = (diagnostics.skippedByReason[reason] ?? 0) + 1;
 }
+/** Declaration containers whose `name` field names the receiver type at a member call. */
+const OWNER_CONTAINER_TYPES = {
+    class_declaration: true,
+    class_definition: true,
+    class_specifier: true,
+    impl_item: true,
+    interface_declaration: true,
+    object_declaration: true,
+    struct_specifier: true,
+    trait_item: true,
+};
+function ownerTypeNameOf(declaration, source) {
+    let current = declaration.parent;
+    while (current) {
+        if (OWNER_CONTAINER_TYPES[current.type]) {
+            const name = current.childForFieldName("name");
+            return name ? sliceText(name, source) : null;
+        }
+        current = current.parent;
+    }
+    return null;
+}
+/**
+ * Resolve which receiver binding form a callsite uses. Python bare calls reach the plain function
+ * and pass the receiver explicitly; Python member calls on a provably class-valued receiver do the
+ * same only for instance methods, because class and static methods bind (or declare) no instance
+ * receiver. Rust `Type::target(...)` calls are unbound UFCS forms. C# follows the shared member
+ * lookup rule: resolved extension callsites are static-class (`Ext.M(value)`, `Alias.Ext.M(value)`)
+ * or bare calls inside the class, all of which pass the `this` receiver explicitly.
+ * Everything else supplies the receiver through the call form.
+ */
+function callBindingForm(input) {
+    const { languageId, callNode, source, parsedCallsite, file, index, declarationKind, ownerTypeName } = input;
+    const callee = callTargetNode(callNode);
+    if (languageId === "rust") {
+        return callee?.type === "scoped_identifier" ? "unbound" : "bound";
+    }
+    if (languageId === "csharp") {
+        return memberLookupBinding(languageId);
+    }
+    if (languageId !== "python" || !callee) {
+        return "bound";
+    }
+    if (callee.type === "identifier") {
+        return "unbound";
+    }
+    if (callee.type !== "attribute") {
+        return "bound";
+    }
+    const receiver = callee.namedChildren[0] ?? null;
+    if (!receiver) {
+        return "bound";
+    }
+    const receiverText = sliceText(receiver, source).trim();
+    if (receiverText === "self" || receiverText === "cls" || receiverText === "super()") {
+        return "bound";
+    }
+    if (declarationKind !== "instance-method") {
+        return "bound";
+    }
+    if (ownerTypeName && receiverText === ownerTypeName) {
+        return "unbound";
+    }
+    if (receiver.type === "identifier") {
+        const module = index.byFile.get(fileIdentityKey(file));
+        if (module) {
+            const resolved = resolveNamedDefinition(index, module, file, parsedCallsite.sup, receiverText);
+            if (resolved?.status === "ok" && resolved.definition.kind === SymbolKind.Class) {
+                return "unbound";
+            }
+        }
+    }
+    return "bound";
+}
 async function buildCallCompatibilityHintForReference(input) {
-    const { index, changedSymbol, signature, ref, callerRangeIndex, diagnostics, projectRoot } = input;
+    const { index, changedSymbol, signature, unboundSignature, declarationKind, ownerTypeName, ref, callerRangeIndex, diagnostics, projectRoot, } = input;
     if (fileIdentityKey(ref.file) === fileIdentityKey(changedSymbol.file) &&
         sameRangeStart(ref.range, changedSymbol.range)) {
         return null;
@@ -849,7 +554,30 @@ async function buildCallCompatibilityHintForReference(input) {
         }
         return null;
     }
-    const compatibility = classifyCompatibility(signature, actual);
+    // Pick the arity for the call form: an unbound call passes the receiver as its first argument,
+    // so it must be compared against the receiver-inclusive range instead of the bound one.
+    let expected = signature;
+    const hasDistinctUnboundForm = unboundSignature !== null &&
+        (unboundSignature.minArgs !== signature.minArgs || unboundSignature.maxArgs !== signature.maxArgs);
+    if (hasDistinctUnboundForm) {
+        const callNode = parsedCallsite.tree ? locateCallsiteCallNode(callsiteRequest) : null;
+        const binding = callNode
+            ? callBindingForm({
+                languageId: parsedCallsite.sup.id,
+                callNode,
+                source: parsedCallsite.source,
+                parsedCallsite,
+                file: ref.file,
+                index,
+                declarationKind,
+                ownerTypeName,
+            })
+            : "bound";
+        if (binding === "unbound" && unboundSignature) {
+            expected = unboundSignature;
+        }
+    }
+    const compatibility = classifyCompatibility(expected, actual);
     const callerSymbolId = findCallerSymbolId(callerRangeIndex, ref);
     const callsiteFile = projectRoot ? path.relative(projectRoot, ref.file).replace(/\\/g, "/") : ref.file;
     return {
@@ -858,7 +586,7 @@ async function buildCallCompatibilityHintForReference(input) {
         callsiteFile,
         callsiteRange: ref.range,
         ...(callerSymbolId ? { callerSymbolId } : {}),
-        expected: signature,
+        expected,
         actual,
     };
 }
@@ -899,27 +627,82 @@ export async function attachCallCompatibilityHints(index, changedSymbols, option
             incrementSkippedReason(diagnostics, "unsupported_language");
             continue;
         }
-        const signature = extractCallableSignature({
-            languageId: parsedDefinition.sup.id,
-            source: parsedDefinition.source,
-            symbolStartIndex: changedSymbol.range.start.index ?? 0,
-            tree: parsedDefinition.tree,
-        });
+        const module = index.byFile.get(fileIdentityKey(changedSymbol.file));
+        const referenceDef = module?.locals.find((local) => local.kind === changedSymbol.kind && sameRangeStart(local.range, changedSymbol.range)) ?? {
+            file: changedSymbol.file,
+            localName: changedSymbol.name,
+            kind: changedSymbol.kind,
+            range: changedSymbol.range,
+        };
+        const signature = referenceDef.callable?.arity
+            ? { ...referenceDef.callable.arity, confidence: "high" }
+            : extractCallableSignature({
+                languageId: parsedDefinition.sup.id,
+                source: parsedDefinition.source,
+                symbolStartIndex: changedSymbol.range.start.index ?? 0,
+                tree: parsedDefinition.tree,
+            });
         if (!signature) {
             incrementSkippedReason(diagnostics, "signature_unknown");
             continue;
         }
-        if (hasSameFileOverloadCandidates(index, changedSymbol, parsedDefinition.sup.id, parsedDefinition.source, parsedDefinition.tree)) {
+        // Receiver-bearing declarations accept different argument counts per call form: a bound call
+        // never passes the receiver, an unbound call does. Both arities are merged below so prototype
+        // defaults apply to each.
+        const unboundSignature = referenceDef.callable?.arity
+            ? { ...(referenceDef.callable.unboundArity ?? referenceDef.callable.arity), confidence: "high" }
+            : extractCallableSignature({
+                languageId: parsedDefinition.sup.id,
+                source: parsedDefinition.source,
+                symbolStartIndex: changedSymbol.range.start.index ?? 0,
+                tree: parsedDefinition.tree,
+                binding: "unbound",
+            });
+        const hasDistinctUnboundForm = unboundSignature !== null &&
+            (unboundSignature.minArgs !== signature.minArgs || unboundSignature.maxArgs !== signature.maxArgs);
+        const arityTargets = hasDistinctUnboundForm && unboundSignature ? [signature, unboundSignature] : [signature];
+        const cppBinding = changedCppCallableBinding(index, changedSymbol, parsedDefinition);
+        const equivalentBindings = cppBinding ? cppEquivalentCallableBindings(cppBinding) : undefined;
+        const hasOverloads = cppBinding && equivalentBindings
+            ? equivalentBindings.length !== (cppBinding.sameScopeFunctionBindings?.length ?? 1)
+            : hasSameFileOverloadCandidates(index, changedSymbol, parsedDefinition);
+        if (hasOverloads) {
             incrementSkippedReason(diagnostics, "overload_set");
             continue;
         }
+        const equivalentDefinitions = parsedDefinition.sup.id === "cpp"
+            ? await getCppEquivalentCallableDefinitions(index, referenceDef, parsedDefinition)
+            : undefined;
+        // Default arguments can live on a prototype rather than its definition.
+        // Both sites describe the same accepted range.
+        if (equivalentDefinitions) {
+            for (const definition of equivalentDefinitions) {
+                const arity = definition.callable?.arity;
+                if (!arity)
+                    continue;
+                for (const target of arityTargets) {
+                    target.minArgs = Math.min(target.minArgs, arity.minArgs);
+                    if (target.maxArgs === null || arity.maxArgs === null) {
+                        target.maxArgs = null;
+                    }
+                    else {
+                        target.maxArgs = Math.max(target.maxArgs, arity.maxArgs);
+                    }
+                }
+            }
+        }
+        const changedStartIndex = changedSymbol.range.start.index;
+        const declarationNode = changedStartIndex === undefined ? null : callableDeclarationAt(parsedDefinition.tree, changedStartIndex);
+        const declarationKind = referenceDef.callable?.kind ??
+            (declarationNode
+                ? getCallableDeclarationKind({
+                    languageId: parsedDefinition.sup.id,
+                    source: parsedDefinition.source,
+                    declaration: declarationNode,
+                })
+                : null);
+        const ownerTypeName = declarationNode ? ownerTypeNameOf(declarationNode, parsedDefinition.source) : null;
         const referenceScanLimit = referenceScanLimitForCallsites(options.maxRefs);
-        const referenceDef = {
-            file: changedSymbol.file,
-            localName: changedSymbol.name,
-            kind: changedSymbol.kind,
-            range: changedSymbol.range,
-        };
         if (options.workBudget) {
             recordReferenceLookupStarted(options.workBudget);
         }
@@ -931,7 +714,7 @@ export async function attachCallCompatibilityHints(index, changedSymbols, option
         if (referenceResult.status === "ok") {
             refs = referenceResult.references.filter((ref) => shouldIncludeReference(ref.file));
         }
-        const seenRefs = new Set(refs.map((ref) => `${ref.file}:${ref.range.start.line}:${ref.range.start.column}`));
+        const seenRefs = new Set(refs.map((ref) => `${fileIdentityKey(ref.file)}:${ref.range.start.line}:${ref.range.start.column}`));
         const hints = [];
         let consideredCallsites = 0;
         const addHintForReference = async (ref) => {
@@ -942,6 +725,9 @@ export async function attachCallCompatibilityHints(index, changedSymbols, option
                 index,
                 changedSymbol,
                 signature,
+                unboundSignature: hasDistinctUnboundForm ? unboundSignature : null,
+                declarationKind,
+                ownerTypeName,
                 ref,
                 callerRangeIndex,
                 diagnostics,
@@ -959,16 +745,20 @@ export async function attachCallCompatibilityHints(index, changedSymbols, option
             }
             await addHintForReference(ref);
         }
-        const shouldRunVerifiedScan = consideredCallsites < options.maxRefs && (referenceResult.status !== "ok" || !consideredCallsites);
+        const shouldRunVerifiedScan = consideredCallsites < options.maxRefs &&
+            (parsedDefinition.sup.id === "c" ||
+                parsedDefinition.sup.id === "cpp" ||
+                referenceResult.status !== "ok" ||
+                !consideredCallsites);
         if (shouldRunVerifiedScan) {
             const verifiedScanLimit = Math.max(0, Math.min(referenceScanLimit - refs.length, options.maxRefs - consideredCallsites));
             if (verifiedScanLimit) {
-                const verifiedCallsites = await collectVerifiedCallsiteReferences(index, changedSymbol, verifiedScanLimit, shouldIncludeReference, diagnostics);
+                const verifiedCallsites = await collectVerifiedCallsiteReferences(index, changedSymbol, verifiedScanLimit, shouldIncludeReference, diagnostics, parsedDefinition, equivalentDefinitions, seenRefs);
                 for (const ref of verifiedCallsites) {
                     if (consideredCallsites >= options.maxRefs) {
                         break;
                     }
-                    const key = `${ref.file}:${ref.range.start.line}:${ref.range.start.column}`;
+                    const key = `${fileIdentityKey(ref.file)}:${ref.range.start.line}:${ref.range.start.column}`;
                     if (seenRefs.has(key)) {
                         continue;
                     }