public interface KaResolverMixIn : KaSessionMixIn {
    @Deprecated(
        message = "The API will be changed soon. Use 'resolveCallOld()' in a transit period",
        replaceWith = ReplaceWith("resolveCallOld()"),
    )
    public fun KtElement.resolveCall(): KaCallInfo? = resolveCallOld()

    public fun KtElement.resolveCallOld(): KaCallInfo? = withValidityAssertion {
        analysisSession.resolver.resolveCall(this)
    }

    @Deprecated(

    override fun generateResolveOutput(mainElement: KtElement, testServices: TestServices): String = analyseForTest(mainElement) {
        val call = mainElement.resolveCallOld()
        val secondCall = mainElement.resolveCallOld()

        ignoreStabilityIfNeeded(testServices.moduleStructure.allDirectives) {
            assertStableResult(testServices, call, secondCall)
        }

internal class KaFirInvokeFunctionReference(expression: KtCallExpression) : KtInvokeFunctionReference(expression), KaFirReference {
    override fun KaSession.resolveToSymbols(): Collection<KaSymbol> {
        return expression.resolveCallOld()?.calls.orEmpty().mapNotNull { call ->
            (call as? KaSimpleFunctionCall)
                ?.takeIf { it.isImplicitInvoke }
                ?.partiallyAppliedSymbol
                ?.symbol

    private fun KaSession.checkConsistencyWithResolveCall(
        mainElement: KtElement,
        candidates: List<KaCallCandidateInfo>,
        testServices: TestServices,
    ) {
        val resolvedCall = mainElement.resolveCallOld()?.successfulCallOrNull<KaCallableMemberCall<*, *>>()
        if (candidates.isEmpty()) {
            testServices.assertions.assertEquals(null, resolvedCall) {

        analyze(ktFile) {
            val ktCallExpression = ktFile.findDescendantOfType<KtCallExpression>()!!
            val ktCallInfo = ktCallExpression.resolveCallOld()
            Assertions.assertInstanceOf(KaSuccessCallInfo::class.java, ktCallInfo); ktCallInfo as KaSuccessCallInfo
            val symbol = ktCallInfo.successfulFunctionCallOrNull()?.symbol

    return Paths.get("analysis/analysis-api-standalone/testData/sessionBuilder").resolve(path)
}

fun KtCallExpression.assertIsCallOf(callableId: CallableId) {
    analyze(this) {
        val ktCallInfo = resolveCallOld()
        Assertions.assertInstanceOf(KaSuccessCallInfo::class.java, ktCallInfo); ktCallInfo as KaSuccessCallInfo
        val symbol = ktCallInfo.successfulFunctionCallOrNull()?.symbol

        }
    else ->
        false
}


private fun KaSession.isSimpleVariableAccessCall(reference: KtReferenceExpression): Boolean =
    when (val resolution = reference.resolveCallOld()) {
        is KaSuccessCallInfo ->
            resolution.call is KaSimpleVariableAccessCall
        else ->
            false
    }

private fun returnsUnit(declaration: KtDeclaration): Boolean {