replaceWith = ReplaceWith("resolveCallOld()"),
    )
    public fun KtElement.resolveCall(): KaCallInfo? = resolveCallOld()

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

    @Deprecated(
        message = "The API will be changed soon. Use 'collectCallCandidatesOld()' in a transit period",

            return resolveCall(parentBinaryExpression)
        }

        when (psi) {
            is KtCallableReferenceExpression -> return resolveCall(psi.callableReference)
            is KtWhenConditionInRange -> return psi.operationReference.let(::resolveCall)
            is KtConstructorDelegationReferenceExpression -> return (psi.parent as? KtElement)?.let(::resolveCall)
        }

        ) {
            withPsiEntry("reference", reference.element)
        }

        with(reference) {
            return analysisSession.resolveToSymbols()
        }
    }

    override fun resolveCall(psi: KtElement): KaCallInfo? {
        return wrapError(psi) {
            val ktCallInfos = getCallInfo(
                psi,
                getErrorCallInfo = { psiToResolve ->

    private val reifiedInlineFunctionsOnly: Boolean,
    private val acceptDeclaration: (KtDeclarationWithBody) -> Unit
) {
    fun checkResolveCall(resolvedCall: ResolvedCall<*>?) {
        if (resolvedCall == null) return

        val descriptor = resolvedCall.resultingDescriptor
        if (descriptor is DeserializedSimpleFunctionDescriptor) return

        analyzeNextIfInline(descriptor)

                val call = bindingContext.get(BindingContext.CALL, expression) ?: return
                val resolvedCall = bindingContext.get(BindingContext.RESOLVED_CALL, call)
                collector.checkResolveCall(resolvedCall)
            }

            override fun visitDestructuringDeclaration(destructuringDeclaration: KtDestructuringDeclaration) {

                        stringRepresentation(resolvedCall)
            }
        } else {
            if (resolvedCall == null) return
            val resolvedSymbol = stringRepresentation(resolvedCall.symbol)
            val candidatesRepresentation = candidates.mapNotNull {
                if (it.isInBestCandidates) {
                    stringRepresentation((it.candidate as KaCallableMemberCall<*, *>).symbol)
                } else {

import org.jetbrains.kotlin.psi.KtElement
import org.jetbrains.kotlin.resolve.BindingContext
import org.jetbrains.kotlin.resolve.calls.CallResolver
import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
import org.jetbrains.kotlin.resolve.calls.results.OverloadingConflictResolver
import org.jetbrains.kotlin.resolve.calls.tower.KotlinToResolvedCallTransformer
import org.jetbrains.kotlin.resolve.deprecation.DeprecationResolver

        val resolvedCall = bindingContext[BindingContext.RESOLVED_CALL, call] ?: return emptyList()
        return listOfNotNull(
            smartCastedImplicitReceiver(smartCasts.receiverTypes[resolvedCall.dispatchReceiver], KaImplicitReceiverSmartCastKind.DISPATCH),
            smartCastedImplicitReceiver(smartCasts.receiverTypes[resolvedCall.extensionReceiver], KaImplicitReceiverSmartCastKind.EXTENSION)

                            attribute(Attribute.of('other', String), 'foobar')
                        }
                    }.files)
                }
                
                tasks.register('resolveAll', Resolve) {
                    artifacts.from(configurations.producerArtifacts)
                    artifacts.from(configurations.producerArtifacts.incoming.artifactView {
                        withVariantReselection()

                val resolvedCall = analyze(assignment) {
                    with((this as KaFe10Session).analysisContext.analyze(assignment, Fe10AnalysisFacade.AnalysisMode.PARTIAL)) {
                        assignment.getCall(this)?.getResolvedCall(this) ?: return ReferenceAccess.READ_WRITE to assignment
                    }
                }