@lzehrung/codegraph 2.3.20 → 2.3.22

package/dist/impact/callCompatibility.js

@@ -1,1023 +0,0 @@
-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/textScanner.js";
-function supportsCallCompatibilityLanguage(languageId) {
-    return getCallCompatibilityProvider(languageId) !== null;
-}
-import { directSignatureParameterNode, findAncestorOfTypes, findFirstDescendantOfTypes, } from "./signature-node-utils.js";
-import { canStartReferenceLookup, recordReferenceLookupOmitted, recordReferenceLookupStarted, } from "./budgets.js";
-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=callCompatibility.js.map