@lzehrung/codegraph 2.3.20 → 2.3.22

package/dist/impact/call-compatibility.js

@@ -0,0 +1,1023 @@
+import path from "node:path";
+import { findReferences, goToDefinition } from "../indexer/navigation.js";
+import { ensureParsedContext } from "../indexer/parse-context.js";
+import { SymbolKind } from "../indexer/types.js";
+import { supportForFileWithoutHeaderSample } from "../languages.js";
+import { isJsTsLanguage } from "../languages/js-family.js";
+import { sliceText, toRange } from "../util/ast.js";
+import { fileIdentityKey } from "../util/paths.js";
+import { 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 { directSignatureParameterNode, findAncestorOfTypes, findFirstDescendantOfTypes, } from "./signature-node-utils.js";
+import { canStartReferenceLookup, recordReferenceLookupOmitted, recordReferenceLookupStarted, } from "./budgets.js";
+function supportsCallCompatibilityLanguage(languageId) {
+    return getCallCompatibilityProvider(languageId) !== null;
+}
+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;
+}
+function isOptionalParameter(parameter) {
+    const colonIndex = parameter.indexOf(":");
+    let searchText = parameter;
+    if (colonIndex >= 0) {
+        searchText = parameter.slice(0, colonIndex);
+    }
+    return searchText.includes("?") || hasTopLevelEquals(parameter);
+}
+function isThisParameter(parameter) {
+    const colonIndex = parameter.indexOf(":");
+    if (colonIndex < 0) {
+        return parameter.trim() === "this";
+    }
+    return parameter.slice(0, colonIndex).trim() === "this";
+}
+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([
+    "parameters",
+    "parameter_list",
+    "formal_parameters",
+    "function_value_parameters",
+    "method_parameters",
+]);
+function isPythonMethodDeclaration(declaration) {
+    let current = declaration.parent;
+    while (current) {
+        if (current.type === "class_definition") {
+            return true;
+        }
+        if (current.type === "function_definition") {
+            return false;
+        }
+        current = current.parent;
+    }
+    return false;
+}
+function shouldSkipFirstReceiverParameter(languageId, declaration) {
+    if (languageId === "python") {
+        return isPythonMethodDeclaration(declaration);
+    }
+    return true;
+}
+function findSignatureParameterText(request) {
+    if (!request.tree) {
+        return null;
+    }
+    const node = request.tree.rootNode.descendantForIndex(request.symbolStartIndex, request.symbolStartIndex);
+    const declaration = findAncestorOfTypes(node, callableDeclarationTypes);
+    if (!declaration) {
+        return null;
+    }
+    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) {
+        if (request.languageId === "swift") {
+            const parameterNodes = declaration.namedChildren.filter((child) => child.type === "parameter");
+            const first = parameterNodes[0];
+            const last = parameterNodes[parameterNodes.length - 1];
+            if (first && last) {
+                return {
+                    text: request.source.slice(first.startIndex, last.endIndex),
+                    skipFirstReceiver: shouldSkipFirstReceiverParameter(request.languageId, declaration),
+                };
+            }
+        }
+        return {
+            text: "",
+            skipFirstReceiver: shouldSkipFirstReceiverParameter(request.languageId, declaration),
+        };
+    }
+    const text = request.source.slice(params.startIndex, params.endIndex).trim();
+    if (text.startsWith("(") && text.endsWith(")")) {
+        return {
+            text: text.slice(1, -1),
+            skipFirstReceiver: shouldSkipFirstReceiverParameter(request.languageId, declaration),
+        };
+    }
+    return {
+        text,
+        skipFirstReceiver: shouldSkipFirstReceiverParameter(request.languageId, declaration),
+    };
+}
+function isReceiverParameter(languageId, parameter, index, skipFirstReceiver) {
+    if (!skipFirstReceiver) {
+        return false;
+    }
+    const trimmed = parameter.trim();
+    if (!index && (languageId === "python" || languageId === "ruby")) {
+        return trimmed === "self" || trimmed === "cls" || trimmed.startsWith("self:") || trimmed.startsWith("cls:");
+    }
+    if (!index && languageId === "rust") {
+        return trimmed === "self" || trimmed === "&self" || trimmed === "&mut self" || trimmed.startsWith("self:");
+    }
+    if (isJsTsLanguage(languageId)) {
+        return isThisParameter(trimmed);
+    }
+    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 isParameterSeparator(languageId, parameter) {
+    const trimmed = parameter.trim();
+    return languageId === "python" && (trimmed === "/" || trimmed === "*");
+}
+function isRestParameter(languageId, parameter) {
+    const trimmed = parameter.trim();
+    if (!trimmed) {
+        return false;
+    }
+    if (hasTopLevelEllipsis(trimmed)) {
+        return true;
+    }
+    if (languageId === "python" || languageId === "ruby") {
+        return trimmed.startsWith("*") || trimmed.startsWith("**");
+    }
+    if (languageId === "csharp") {
+        return /\bparams\b/.test(trimmed);
+    }
+    if (languageId === "kotlin") {
+        return /\bvararg\b/.test(trimmed);
+    }
+    return false;
+}
+function isOptionalParameterForLanguage(languageId, parameter) {
+    const trimmed = parameter.trim();
+    if (!trimmed) {
+        return false;
+    }
+    if (isJsTsLanguage(languageId)) {
+        return isOptionalParameter(trimmed);
+    }
+    if (languageId === "ruby" && /^[A-Za-z_]\w*:\s*\S/.test(trimmed)) {
+        return true;
+    }
+    return hasTopLevelEquals(trimmed);
+}
+function parameterSlotCount(languageId, parameter) {
+    const trimmed = parameter.trim();
+    if (!trimmed) {
+        return 0;
+    }
+    if ((languageId === "c" || languageId === "cpp") && trimmed === "void") {
+        return 0;
+    }
+    return 1;
+}
+function signatureFromParameterText(languageId, parameterText, angleMode, skipFirstReceiver = true) {
+    const parameters = splitTopLevelCommaGroups(parameterText, angleMode, languageId !== "python");
+    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 ||
+            isParameterSeparator(languageId, trimmed) ||
+            isReceiverParameter(languageId, trimmed, index, skipFirstReceiver)) {
+            return;
+        }
+        if (isRestParameter(languageId, trimmed)) {
+            hasRest = true;
+            return;
+        }
+        if (languageId === "ruby" && /^[A-Za-z_]\w*:/.test(trimmed)) {
+            maxArgs += 1;
+            if (!isOptionalParameterForLanguage(languageId, trimmed)) {
+                minArgs += 1;
+            }
+            return;
+        }
+        const slotCount = parameterSlotCount(languageId, trimmed);
+        if (!slotCount) {
+            return;
+        }
+        positionalArgCount += slotCount;
+        maxArgs += slotCount;
+        if (!isOptionalParameterForLanguage(languageId, trimmed)) {
+            minArgs = positionalArgCount;
+        }
+    });
+    return { minArgs, maxArgs: hasRest ? null : maxArgs, confidence: "high" };
+}
+function extractCallableSignatureFromProvider(request) {
+    if (!supportsCallCompatibilityLanguage(request.languageId)) {
+        return null;
+    }
+    const astParameterText = findSignatureParameterText(request);
+    if (astParameterText !== null) {
+        return signatureFromParameterText(request.languageId, astParameterText.text, "type-context", astParameterText.skipFirstReceiver);
+    }
+    if (!isJsTsLanguage(request.languageId)) {
+        return null;
+    }
+    const openIndex = findSignatureOpeningParen(request.source, request.symbolStartIndex);
+    const balanced = findBalancedParentheses(request.source, openIndex);
+    if (!balanced) {
+        return null;
+    }
+    return signatureFromParameterText(request.languageId, balanced.inner, "type-context");
+}
+function extractCallsiteArgumentsFromProvider(request) {
+    if (!supportsCallCompatibilityLanguage(request.languageId)) {
+        return null;
+    }
+    const astArgumentText = findCallsiteArgumentText(request);
+    if (astArgumentText !== null) {
+        return callsiteFromArgumentText(request.languageId, astArgumentText.text, astArgumentText.trailingArgumentCount);
+    }
+    if (!isJsTsLanguage(request.languageId)) {
+        return null;
+    }
+    const openIndex = findCallOpeningParen(request.source, request.calleeStartIndex, request.calleeEndIndex);
+    const balanced = findBalancedParentheses(request.source, openIndex);
+    if (!balanced) {
+        return null;
+    }
+    return callsiteFromArgumentText(request.languageId, balanced.inner);
+}
+registerCallCompatibilityExtractors({
+    extractSignature: extractCallableSignatureFromProvider,
+    extractCallsite: extractCallsiteArgumentsFromProvider,
+});
+export function extractCallableSignature(request) {
+    const provider = getCallCompatibilityProvider(request.languageId);
+    if (!provider) {
+        return null;
+    }
+    return provider.extractSignature(request);
+}
+export function extractCallsiteArguments(request) {
+    const provider = getCallCompatibilityProvider(request.languageId);
+    if (!provider) {
+        return null;
+    }
+    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) {
+    if (!request.tree) {
+        return null;
+    }
+    const endIndex = request.calleeEndIndex ?? request.calleeStartIndex;
+    const node = request.tree.rootNode.descendantForIndex(request.calleeStartIndex, endIndex);
+    let callNode = findAncestorOfTypes(node, callExpressionTypes);
+    if (!callNode) {
+        return null;
+    }
+    let parentCallNode = callNode.parent;
+    while (parentCallNode && callExpressionTypes.has(parentCallNode.type)) {
+        const trailingText = request.source.slice(callNode.endIndex, parentCallNode.endIndex).trimStart();
+        if (!trailingText.startsWith("{")) {
+            break;
+        }
+        callNode = parentCallNode;
+        parentCallNode = callNode.parent;
+    }
+    if (request.calleeStartIndex < callNode.startIndex || request.calleeStartIndex > callNode.endIndex) {
+        return null;
+    }
+    const targetNode = callTargetNode(callNode);
+    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 (request.languageId === "zig") {
+        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(languageId, arg) {
+    const trimmed = arg.trim();
+    if (trimmed.startsWith("...")) {
+        return true;
+    }
+    if (languageId === "python" || languageId === "ruby") {
+        return trimmed.startsWith("*") || trimmed.startsWith("**");
+    }
+    if (languageId === "php") {
+        return trimmed.startsWith("...");
+    }
+    return false;
+}
+function callsiteFromArgumentText(languageId, argumentText, trailingArgumentCount = 0) {
+    const args = splitTopLevelCommaGroups(argumentText, "type-context");
+    if (!args) {
+        return null;
+    }
+    for (const arg of args) {
+        if (hasUncountableSpreadArgument(languageId, arg)) {
+            return null;
+        }
+    }
+    return { argCount: args.length + trailingArgumentCount, confidence: "high" };
+}
+function isCallableChangedSymbol(symbol) {
+    return (symbol.kind === SymbolKind.Function ||
+        symbol.kind === SymbolKind.Default ||
+        symbol.kind === SymbolKind.Variable ||
+        String(symbol.kind) === "method");
+}
+function sameRangeStart(left, right) {
+    const leftIndex = left.start.index;
+    const rightIndex = right.start.index;
+    return left.start.line === right.start.line && left.start.column === right.start.column && leftIndex === rightIndex;
+}
+function sameDefinition(left, right) {
+    return (fileIdentityKey(left.file) === fileIdentityKey(right.file) &&
+        left.localName === right.localName &&
+        left.kind === right.kind &&
+        left.range.start.index === right.range.start.index);
+}
+function callableDeclarationAt(tree, startIndex) {
+    const node = tree.rootNode.descendantForIndex(startIndex, startIndex);
+    return findAncestorOfTypes(node, callableDeclarationTypes);
+}
+function sameOverloadContainer(left, right) {
+    if (!left || !right || !left.parent || !right.parent) {
+        return false;
+    }
+    return left.parent.id === right.parent.id;
+}
+function hasSameFileOverloadCandidates(index, changedSymbol, languageId, source, tree) {
+    const module = index.byFile.get(fileIdentityKey(changedSymbol.file));
+    if (!module) {
+        return false;
+    }
+    const changedStartIndex = changedSymbol.range.start.index;
+    if (changedStartIndex === undefined) {
+        return false;
+    }
+    const changedDeclaration = callableDeclarationAt(tree, changedStartIndex);
+    for (const local of module.locals) {
+        if (local.localName !== changedSymbol.name || sameRangeStart(local.range, changedSymbol.range)) {
+            continue;
+        }
+        const symbolStartIndex = local.range.start.index;
+        if (symbolStartIndex === undefined) {
+            continue;
+        }
+        const localDeclaration = callableDeclarationAt(tree, symbolStartIndex);
+        if (!sameOverloadContainer(changedDeclaration, localDeclaration)) {
+            continue;
+        }
+        const signature = extractCallableSignature({
+            languageId,
+            source,
+            symbolStartIndex,
+            tree,
+        });
+        if (signature) {
+            return true;
+        }
+    }
+    return false;
+}
+function rangeContainsIndex(range, index) {
+    const startIndex = range.start.index;
+    const endIndex = range.end.index;
+    if (startIndex === undefined || endIndex === undefined) {
+        return false;
+    }
+    return index >= startIndex && index <= endIndex;
+}
+export function buildCallerRangeIndex(index) {
+    const byFile = new Map();
+    for (const module of index.byFile.values()) {
+        const entries = module.locals
+            .flatMap((local) => {
+            const startIndex = local.range.start.index;
+            const endIndex = local.range.end.index;
+            if (startIndex === undefined || endIndex === undefined)
+                return [];
+            return [{ local, maxEndIndex: endIndex }];
+        })
+            .sort((left, right) => {
+            const startDifference = left.local.range.start.index - right.local.range.start.index;
+            if (startDifference !== 0)
+                return startDifference;
+            return left.local.range.end.index - right.local.range.end.index;
+        });
+        let maxEndIndex = Number.NEGATIVE_INFINITY;
+        for (const entry of entries) {
+            maxEndIndex = Math.max(maxEndIndex, entry.local.range.end.index);
+            entry.maxEndIndex = maxEndIndex;
+        }
+        byFile.set(fileIdentityKey(module.file), entries);
+    }
+    return byFile;
+}
+export function findCallerSymbolId(callerRangeIndex, ref) {
+    const startIndex = ref.range.start.index;
+    if (startIndex === undefined)
+        return undefined;
+    const entries = callerRangeIndex.get(fileIdentityKey(ref.file));
+    if (!entries?.length)
+        return undefined;
+    let low = 0;
+    let high = entries.length;
+    while (low < high) {
+        const middle = Math.floor((low + high) / 2);
+        const middleStart = entries[middle].local.range.start.index;
+        if (middleStart <= startIndex) {
+            low = middle + 1;
+        }
+        else {
+            high = middle;
+        }
+    }
+    let best;
+    for (let index = low - 1; index >= 0; index -= 1) {
+        const entry = entries[index];
+        if (entry.maxEndIndex < startIndex)
+            break;
+        if (!rangeContainsIndex(entry.local.range, startIndex))
+            continue;
+        if (!best) {
+            best = entry.local;
+            continue;
+        }
+        const localSpan = (entry.local.range.end.index ?? 0) - (entry.local.range.start.index ?? 0);
+        const bestSpan = (best.range.end.index ?? 0) - (best.range.start.index ?? 0);
+        if (localSpan < bestSpan)
+            best = entry.local;
+    }
+    if (!best)
+        return undefined;
+    const bestStartIndex = best.range.start.index ?? 0;
+    return `${best.file}::${best.localName}::${bestStartIndex}`;
+}
+function callTargetNode(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;
+    }
+    const argumentTypes = new Set(["argument_list", "arguments", "value_arguments", "call_suffix"]);
+    return node.namedChildren.find((child) => !argumentTypes.has(child.type)) ?? null;
+}
+function bestGotoNode(target, symbolName, source) {
+    let best = target;
+    const walk = (node) => {
+        if (sliceText(node, source) === symbolName) {
+            best = node;
+        }
+        for (const child of node.namedChildren ?? []) {
+            walk(child);
+        }
+    };
+    walk(target);
+    return best;
+}
+async function collectVerifiedCallsiteReferences(index, changedSymbol, maxRefs, shouldIncludeReference, diagnostics) {
+    const refs = [];
+    const seen = new Set();
+    for (const module of index.byFile.values()) {
+        const file = module.file;
+        if (refs.length >= maxRefs) {
+            break;
+        }
+        if (!shouldIncludeReference(file)) {
+            continue;
+        }
+        const support = supportForFileWithoutHeaderSample(file, index.languageExtensions);
+        if (!support || !supportsCallCompatibilityLanguage(support.id)) {
+            continue;
+        }
+        const parsed = await tryEnsureParsedContext(file, index.parsed?.get(fileIdentityKey(file)), index.languageExtensions, diagnostics);
+        if (!parsed) {
+            continue;
+        }
+        const walk = async (node) => {
+            if (refs.length >= maxRefs) {
+                return;
+            }
+            if (callExpressionTypes.has(node.type)) {
+                const target = callTargetNode(node);
+                if (target) {
+                    const gotoNode = bestGotoNode(target, changedSymbol.name, parsed.source);
+                    if (sliceText(gotoNode, parsed.source) === changedSymbol.name) {
+                        const result = await goToDefinition(index, {
+                            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)) {
+                                const range = toRange(gotoNode);
+                                const key = `${fileIdentityKey(file)}:${range.start.line}:${range.start.column}`;
+                                if (!seen.has(key)) {
+                                    seen.add(key);
+                                    refs.push({ file, range });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            for (const child of node.namedChildren ?? []) {
+                await walk(child);
+            }
+        };
+        await walk(parsed.tree.rootNode);
+    }
+    return refs;
+}
+function classifyCompatibility(expected, actual) {
+    if (actual.argCount < expected.minArgs) {
+        return { status: "likely_mismatch", reason: "argument_count_below_minimum" };
+    }
+    if (expected.maxArgs !== null && actual.argCount > expected.maxArgs) {
+        return { status: "likely_mismatch", reason: "argument_count_above_maximum" };
+    }
+    return { status: "compatible", reason: "compatible_argument_count" };
+}
+function tryEnsureParsedContext(file, parsedEntry, languageExtensions, diagnostics) {
+    return ensureParsedContext(file, parsedEntry, languageExtensions).catch(() => {
+        incrementSkippedReason(diagnostics, "parse-failed");
+        return null;
+    });
+}
+function incrementSkippedReason(diagnostics, reason) {
+    if (!diagnostics) {
+        return;
+    }
+    diagnostics.skippedByReason[reason] = (diagnostics.skippedByReason[reason] ?? 0) + 1;
+}
+async function buildCallCompatibilityHintForReference(input) {
+    const { index, changedSymbol, signature, ref, callerRangeIndex, diagnostics, projectRoot } = input;
+    if (fileIdentityKey(ref.file) === fileIdentityKey(changedSymbol.file) &&
+        sameRangeStart(ref.range, changedSymbol.range)) {
+        return null;
+    }
+    const calleeStartIndex = ref.range.start.index;
+    if (calleeStartIndex === undefined) {
+        return null;
+    }
+    const parsedCallsite = await tryEnsureParsedContext(ref.file, index.parsed?.get(fileIdentityKey(ref.file)), index.languageExtensions, diagnostics);
+    if (!parsedCallsite) {
+        return null;
+    }
+    const callsiteRequest = {
+        languageId: parsedCallsite.sup.id,
+        source: parsedCallsite.source,
+        calleeStartIndex,
+        tree: parsedCallsite.tree,
+        ...(ref.range.end.index !== undefined ? { calleeEndIndex: ref.range.end.index } : {}),
+    };
+    const actual = extractCallsiteArguments(callsiteRequest);
+    if (!actual) {
+        if (diagnostics) {
+            diagnostics.unknownCallsites += 1;
+        }
+        return null;
+    }
+    const compatibility = classifyCompatibility(signature, actual);
+    const callerSymbolId = findCallerSymbolId(callerRangeIndex, ref);
+    const callsiteFile = projectRoot ? path.relative(projectRoot, ref.file).replace(/\\/g, "/") : ref.file;
+    return {
+        ...compatibility,
+        changedSymbolId: changedSymbol.id,
+        callsiteFile,
+        callsiteRange: ref.range,
+        ...(callerSymbolId ? { callerSymbolId } : {}),
+        expected: signature,
+        actual,
+    };
+}
+function resetCallCompatibilityHints(changedSymbols) {
+    for (const changedSymbol of changedSymbols) {
+        delete changedSymbol.callCompatibility;
+    }
+}
+export async function attachCallCompatibilityHints(index, changedSymbols, options) {
+    resetCallCompatibilityHints(changedSymbols);
+    if (options.maxRefs <= 0) {
+        return;
+    }
+    const callerRangeIndex = buildCallerRangeIndex(index);
+    const diagnostics = options.diagnostics?.callCompatibility;
+    if (diagnostics) {
+        diagnostics.supportedLanguages = [...getCallCompatibilitySupportedLanguages()];
+    }
+    for (const changedSymbol of changedSymbols) {
+        if (!changedSymbol.signatureChanged || !isCallableChangedSymbol(changedSymbol)) {
+            if (changedSymbol.signatureChanged) {
+                incrementSkippedReason(diagnostics, "not_callable");
+            }
+            continue;
+        }
+        if (options.workBudget && !canStartReferenceLookup(options.workBudget)) {
+            recordReferenceLookupOmitted(options.workBudget, 1);
+            continue;
+        }
+        const parsedDefinition = await tryEnsureParsedContext(changedSymbol.file, index.parsed?.get(fileIdentityKey(changedSymbol.file)), index.languageExtensions, diagnostics);
+        if (!parsedDefinition) {
+            continue;
+        }
+        if (!supportsCallCompatibilityLanguage(parsedDefinition.sup.id)) {
+            if (diagnostics && !diagnostics.unsupportedLanguages.includes(parsedDefinition.sup.id)) {
+                diagnostics.unsupportedLanguages.push(parsedDefinition.sup.id);
+            }
+            incrementSkippedReason(diagnostics, "unsupported_language");
+            continue;
+        }
+        const signature = 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)) {
+            incrementSkippedReason(diagnostics, "overload_set");
+            continue;
+        }
+        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);
+        }
+        const referenceResult = await (options.referenceCache
+            ? options.referenceCache.get(index, referenceDef, { maxReferences: referenceScanLimit })
+            : findReferences(index, { def: referenceDef }, { maxReferences: referenceScanLimit }));
+        let refs = [];
+        const shouldIncludeReference = options.shouldIncludeReference ?? (() => true);
+        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 hints = [];
+        let consideredCallsites = 0;
+        const addHintForReference = async (ref) => {
+            if (consideredCallsites >= options.maxRefs) {
+                return;
+            }
+            const hint = await buildCallCompatibilityHintForReference({
+                index,
+                changedSymbol,
+                signature,
+                ref,
+                callerRangeIndex,
+                diagnostics,
+                ...(options.projectRoot ? { projectRoot: options.projectRoot } : {}),
+            });
+            if (!hint) {
+                return;
+            }
+            consideredCallsites += 1;
+            hints.push(hint);
+        };
+        for (const ref of refs) {
+            if (consideredCallsites >= options.maxRefs) {
+                break;
+            }
+            await addHintForReference(ref);
+        }
+        const shouldRunVerifiedScan = consideredCallsites < options.maxRefs && (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);
+                for (const ref of verifiedCallsites) {
+                    if (consideredCallsites >= options.maxRefs) {
+                        break;
+                    }
+                    const key = `${ref.file}:${ref.range.start.line}:${ref.range.start.column}`;
+                    if (seenRefs.has(key)) {
+                        continue;
+                    }
+                    seenRefs.add(key);
+                    await addHintForReference(ref);
+                }
+            }
+        }
+        if (hints.length) {
+            changedSymbol.callCompatibility = hints;
+            if (diagnostics) {
+                diagnostics.emittedHints += hints.length;
+            }
+        }
+    }
+}
+//# sourceMappingURL=call-compatibility.js.map