Replace some of RESOLVED_CALL & REFERENCE_TARGET usages to resolveToCall

2018-02-21 16:00:36 +03:00
parent a7d980a890
commit b436ee6e19
21 changed files with 42 additions and 74 deletions
@@ -23,16 +23,13 @@ import com.android.tools.idea.rendering.GutterIconRenderer
 import com.android.tools.idea.res.ResourceHelper
 import com.intellij.lang.annotation.AnnotationHolder
 import com.intellij.lang.annotation.Annotator
-import com.intellij.openapi.module.ModuleUtilCore
 import com.intellij.psi.PsiElement
 import org.jetbrains.android.AndroidColorAnnotator
 import org.jetbrains.android.facet.AndroidFacet
 import org.jetbrains.kotlin.android.ResourceReferenceAnnotatorUtil.*
-import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.idea.caches.resolve.resolveToCall
 import org.jetbrains.kotlin.load.java.descriptors.JavaPropertyDescriptor
 import org.jetbrains.kotlin.psi.KtReferenceExpression
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode


 class AndroidResourceReferenceAnnotator : Annotator {
@@ -77,5 +74,5 @@ class AndroidResourceReferenceAnnotator : Annotator {
    }

    private fun KtReferenceExpression.getResourceReferenceTargetDescriptor(): JavaPropertyDescriptor? =
-            analyze(BodyResolveMode.PARTIAL)[BindingContext.REFERENCE_TARGET, this] as? JavaPropertyDescriptor
+            resolveToCall()?.resultingDescriptor as? JavaPropertyDescriptor
 }
@@ -26,6 +26,7 @@ import org.jetbrains.kotlin.builtins.PrimitiveType
 import org.jetbrains.kotlin.descriptors.ParameterDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.idea.caches.resolve.resolveToCall
 import org.jetbrains.kotlin.idea.codeInsight.shorten.addToShorteningWaitSet
 import org.jetbrains.kotlin.idea.codeInsight.shorten.performDelayedRefactoringRequests
 import org.jetbrains.kotlin.idea.intentions.getLeftMostReceiverExpression
@@ -161,7 +162,7 @@ private fun KtExpression.isReadFromParcelPropertyAssignment(): Boolean {
 private fun KtExpression.isReadFromParcel(): Boolean {
    val reference = firstChild as? KtReferenceExpression
                    ?: (firstChild as? KtDotQualifiedExpression)?.getLeftMostReceiverExpression() as? KtReferenceExpression ?: return false
-    val target = reference.analyze(BodyResolveMode.PARTIAL)[BindingContext.REFERENCE_TARGET, reference] ?: return false
+    val target = reference.resolveToCall()?.resultingDescriptor ?: return false
    return (target as? ParameterDescriptor)?.type?.fqNameEquals(CLASS_PARCEL) ?: false
 }

@@ -29,7 +29,7 @@ import com.intellij.psi.search.searches.ReferencesSearch
 import com.intellij.ui.GuiUtils
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.idea.caches.resolve.resolveToCall
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptorIfAny
 import org.jetbrains.kotlin.idea.core.targetDescriptors
 import org.jetbrains.kotlin.idea.intentions.ConvertReferenceToLambdaIntention
@@ -43,8 +43,6 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.collectDescendantsOfType
 import org.jetbrains.kotlin.psi.psiUtil.forEachDescendantOfType
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode

 interface UsageReplacementStrategy {
    fun createReplacer(usage: KtSimpleNameExpression): (() -> KtElement?)?
@@ -189,8 +187,7 @@ private fun UsageReplacementStrategy.doRefactoringInside(
 ) {
    element.forEachDescendantOfType<KtSimpleNameExpression> { usage ->
        if (usage.isValid && usage.getReferencedName() == targetName) {
-            val context = usage.analyze(BodyResolveMode.PARTIAL)
-            if (targetDescriptor == context[BindingContext.REFERENCE_TARGET, usage]) {
+            if (targetDescriptor == usage.resolveToCall()?.candidateDescriptor) {
                createReplacer(usage)?.invoke()
            }
        }
@@ -24,6 +24,7 @@ import com.intellij.psi.search.searches.ReferencesSearch
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.idea.caches.resolve.resolveToCall
 import org.jetbrains.kotlin.idea.core.NewDeclarationNameValidator
 import org.jetbrains.kotlin.idea.refactoring.inline.KotlinInlineValHandler
 import org.jetbrains.kotlin.psi.*
@@ -33,6 +34,7 @@ import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.resolve.BindingContext.DECLARATION_TO_DESCRIPTOR
 import org.jetbrains.kotlin.resolve.BindingContext.REFERENCE_TARGET
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
+import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode

 class UnnecessaryVariableInspection : AbstractApplicabilityBasedInspection<KtProperty>(KtProperty::class.java) {

@@ -69,8 +71,8 @@ class UnnecessaryVariableInspection : AbstractApplicabilityBasedInspection<KtPro

            fun isExactCopy(): Boolean {
                if (!property.isVar && initializer is KtNameReferenceExpression && property.typeReference == null) {
-                    val context = property.analyze()
-                    val initializerDescriptor = context[REFERENCE_TARGET, initializer] as? VariableDescriptor ?: return false
+                    val initializerDescriptor = initializer.resolveToCall(BodyResolveMode.FULL)?.resultingDescriptor as? VariableDescriptor
+                            ?: return false
                    if (initializerDescriptor.isVar) return false
                    if (initializerDescriptor.containingDeclaration !is FunctionDescriptor) return false

@@ -55,9 +55,7 @@ open class ConvertLambdaToReferenceIntention(text: String) :

    private fun KtLambdaArgument.outerCalleeDescriptor(): FunctionDescriptor? {
        val outerCallExpression = parent as? KtCallExpression ?: return null
-        val context = outerCallExpression.analyze()
-        val outerCallee = outerCallExpression.calleeExpression as? KtReferenceExpression ?: return null
-        return context[REFERENCE_TARGET, outerCallee] as? FunctionDescriptor
+        return outerCallExpression.resolveToCall()?.resultingDescriptor as? FunctionDescriptor
    }

    private fun isConvertibleCallInLambda(
@@ -25,6 +25,7 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.idea.caches.resolve.resolveToCall
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptorIfAny
 import org.jetbrains.kotlin.idea.core.ShortenReferences
 import org.jetbrains.kotlin.idea.core.moveCaret
@@ -167,7 +168,7 @@ class DeprecatedCallableAddReplaceWithIntention : SelfTargetingRangeIntention<Kt
            }

            override fun visitSimpleNameExpression(expression: KtSimpleNameExpression) {
-                val target = expression.analyze()[BindingContext.REFERENCE_TARGET, expression] as? DeclarationDescriptorWithVisibility ?: return
+                val target = expression.resolveToCall()?.resultingDescriptor as? DeclarationDescriptorWithVisibility ?: return
                if (Visibilities.isPrivate((target.visibility))) {
                    isGood = false
                }
@@ -19,8 +19,8 @@ package org.jetbrains.kotlin.idea.intentions
 import com.intellij.openapi.editor.Editor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.descriptors.impl.SyntheticFieldDescriptor
-import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
+import org.jetbrains.kotlin.idea.caches.resolve.resolveToCall
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
@@ -115,8 +115,7 @@ class IntroduceBackingPropertyIntention : SelfTargetingIntention<KtProperty>(KtP
        private fun replaceFieldReferences(element: KtElement, propertyName: String) {
            element.acceptChildren(object : KtTreeVisitorVoid() {
                override fun visitSimpleNameExpression(expression: KtSimpleNameExpression) {
-                    val bindingContext = expression.analyze()
-                    val target = bindingContext.get(BindingContext.REFERENCE_TARGET, expression)
+                    val target = expression.resolveToCall()?.resultingDescriptor
                    if (target is SyntheticFieldDescriptor) {
                        expression.replace(KtPsiFactory(element).createSimpleName("_$propertyName"))
                    }
@@ -127,8 +127,7 @@ class MovePropertyToConstructorIntention :

    private fun KtProperty.findConstructorParameter(): KtParameter? {
        val reference = initializer as? KtReferenceExpression ?: return null
-        val parameterDescriptor = reference.analyze(BodyResolveMode.PARTIAL)[BindingContext.REFERENCE_TARGET, reference]
-                                          as? ParameterDescriptor ?: return null
+        val parameterDescriptor = reference.resolveToCall()?.resultingDescriptor as? ParameterDescriptor ?: return null
        return parameterDescriptor.source.getPsi() as? KtParameter
    }

@@ -23,6 +23,7 @@ import com.intellij.psi.search.searches.ReferencesSearch
 import org.jetbrains.kotlin.KtNodeTypes
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.idea.caches.resolve.resolveToCall
 import org.jetbrains.kotlin.idea.core.replaced
 import org.jetbrains.kotlin.idea.intentions.getLeftMostReceiverExpression
 import org.jetbrains.kotlin.idea.intentions.replaceFirstReceiver
@@ -39,7 +40,6 @@ import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.calls.callUtil.getType
 import org.jetbrains.kotlin.resolve.calls.resolvedCallUtil.getImplicitReceiverValue
 import org.jetbrains.kotlin.resolve.calls.smartcasts.isStableValue
-import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.scopes.receivers.ImplicitReceiver
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.types.typeUtil.isSubtypeOf
@@ -80,9 +80,8 @@ fun KtExpression?.isNullExpressionOrEmptyBlock(): Boolean =
 fun KtThrowExpression.throwsNullPointerExceptionWithNoArguments(): Boolean {
    val thrownExpression = this.thrownExpression as? KtCallExpression ?: return false

-    val context = this.analyze(BodyResolveMode.PARTIAL)
    val nameExpression = thrownExpression.calleeExpression as? KtNameReferenceExpression ?: return false
-    val descriptor = context[BindingContext.REFERENCE_TARGET, nameExpression]
+    val descriptor = nameExpression.resolveToCall()?.resultingDescriptor
    val declDescriptor = descriptor?.containingDeclaration ?: return false

    val exceptionName = DescriptorUtils.getFqName(declDescriptor).asString()
@@ -7,16 +7,12 @@ package org.jetbrains.kotlin.idea.parameterInfo

 import com.intellij.codeInsight.hints.InlayInfo
 import org.jetbrains.kotlin.backend.common.descriptors.isSuspend
-import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.idea.caches.resolve.resolveToCall
 import org.jetbrains.kotlin.psi.KtCallExpression
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode

 fun provideSuspendingCallHint(callExpression: KtCallExpression): InlayInfo? {
-    val bindingContext = callExpression.analyze(BodyResolveMode.PARTIAL)
-    val call = bindingContext[BindingContext.CALL, callExpression.calleeExpression] ?: return null
-    val resolvedCall = bindingContext[BindingContext.RESOLVED_CALL, call] ?: return null
+    val resolvedCall = callExpression.resolveToCall() ?: return null
    if (resolvedCall.candidateDescriptor.isSuspend) {
        return InlayInfo(TYPE_INFO_PREFIX + "#", callExpression.calleeExpression?.startOffset ?: callExpression.startOffset)
    }
@@ -27,7 +27,7 @@ import com.intellij.psi.search.searches.ReferencesSearch
 import org.jetbrains.kotlin.asJava.LightClassUtil
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
 import org.jetbrains.kotlin.diagnostics.Diagnostic
-import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.idea.caches.resolve.resolveToCall
 import org.jetbrains.kotlin.idea.intentions.SelfTargetingIntention
 import org.jetbrains.kotlin.idea.search.allScope
 import org.jetbrains.kotlin.idea.search.usagesSearch.descriptor
@@ -39,9 +39,7 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtProperty
 import org.jetbrains.kotlin.psi.KtReferenceExpression
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
-import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.checkers.ConstModifierChecker
-import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.source.PsiSourceElement

 class AddConstModifierFix(val property: KtProperty) : AddModifierFix(property, KtTokens.CONST_KEYWORD), CleanupFix {
@@ -86,8 +84,7 @@ class AddConstModifierIntention : SelfTargetingIntention<KtProperty>(KtProperty:
 object ConstFixFactory : KotlinSingleIntentionActionFactory() {
    override fun createAction(diagnostic: Diagnostic): IntentionAction? {
        val expr = diagnostic.psiElement as? KtReferenceExpression ?: return null
-        val bindingContext = expr.analyze(BodyResolveMode.PARTIAL)
-        val targetDescriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, expr) as? VariableDescriptor ?: return null
+        val targetDescriptor = expr.resolveToCall()?.resultingDescriptor as? VariableDescriptor ?: return null
        val declaration = (targetDescriptor.source as? PsiSourceElement)?.psi as? KtProperty ?: return null
        if (ConstModifierChecker.canBeConst(declaration, declaration, targetDescriptor)) {
            return AddConstModifierFix(declaration)
@@ -21,12 +21,10 @@ import org.jetbrains.kotlin.builtins.isFunctionType
 import org.jetbrains.kotlin.cfg.pseudocode.containingDeclarationForPseudocode
 import org.jetbrains.kotlin.descriptors.ValueDescriptor
 import org.jetbrains.kotlin.diagnostics.Diagnostic
-import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.idea.caches.resolve.resolveToCall
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
-import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode

 class AddSuspendModifierFix(
        element: KtModifierListOwner,
@@ -62,8 +60,7 @@ class AddSuspendModifierFix(
            if (callParent !== qualifiedGrandParent.selectorExpression || refExpr !== callParent.calleeExpression) return null
            val receiver = qualifiedGrandParent.receiverExpression as? KtNameReferenceExpression ?: return null

-            val context = receiver.analyze(BodyResolveMode.PARTIAL)
-            val receiverDescriptor = context[BindingContext.REFERENCE_TARGET, receiver] as? ValueDescriptor ?: return null
+            val receiverDescriptor = receiver.resolveToCall()?.resultingDescriptor as? ValueDescriptor ?: return null
            if (!receiverDescriptor.type.isFunctionType) return null
            val declaration = DescriptorToSourceUtils.descriptorToDeclaration(receiverDescriptor) as? KtCallableDeclaration
                              ?: return null
@@ -294,6 +294,7 @@ class MoveConflictChecker(
            if (declaration.module == targetModule) continue

            declaration.forEachDescendantOfType<KtReferenceExpression> { refExpr ->
+                // NB: for unknown reason, refExpr.resolveToCall() does not work here
                val targetDescriptor = refExpr.analyze(BodyResolveMode.PARTIAL)[BindingContext.REFERENCE_TARGET, refExpr] ?: return@forEachDescendantOfType

                if (KotlinBuiltIns.isBuiltIn(targetDescriptor)) return@forEachDescendantOfType
@@ -467,10 +468,10 @@ class MoveConflictChecker(
            val rootClassDescriptor: ClassDescriptor
            if (elementToMove is KtClass && elementToMove.isSealed()) {
                rootClass = elementToMove
-                rootClassDescriptor = rootClass.resolveToDescriptorIfAny() as? ClassDescriptor ?: return
+                rootClassDescriptor = rootClass.resolveToDescriptorIfAny() ?: return
            }
            else {
-                val classDescriptor = elementToMove.resolveToDescriptorIfAny() as? ClassDescriptor ?: return
+                val classDescriptor = elementToMove.resolveToDescriptorIfAny() ?: return
                val superClassDescriptor = classDescriptor.getSuperClassNotAny() ?: return
                if (superClassDescriptor.modality != Modality.SEALED) return
                rootClassDescriptor = superClassDescriptor
@@ -23,16 +23,15 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFile
 import com.intellij.refactoring.rename.inplace.VariableInplaceRenameHandler
 import org.jetbrains.kotlin.descriptors.impl.SyntheticFieldDescriptor
-import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.idea.caches.resolve.resolveToCall
 import org.jetbrains.kotlin.idea.codeInsight.CodeInsightUtils
 import org.jetbrains.kotlin.psi.KtSimpleNameExpression
-import org.jetbrains.kotlin.resolve.BindingContext

 class RenameBackingFieldReferenceHandler: VariableInplaceRenameHandler() {
    override fun isAvailable(element: PsiElement?, editor: Editor, file: PsiFile): Boolean {
        val refExpression = file.findElementForRename<KtSimpleNameExpression>(editor.caretModel.offset) ?: return false
        if (refExpression.text != "field") return false
-        return refExpression.analyze()[BindingContext.REFERENCE_TARGET, refExpression] is SyntheticFieldDescriptor
+        return refExpression.resolveToCall()?.resultingDescriptor is SyntheticFieldDescriptor
    }

    override fun invoke(project: Project, editor: Editor, file: PsiFile, dataContext: DataContext?) {
@@ -25,8 +25,7 @@ import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.actionSystem.DataContext
 import org.jetbrains.kotlin.idea.codeInsight.CodeInsightUtils
-import org.jetbrains.kotlin.idea.caches.resolve.analyze
-import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.idea.caches.resolve.resolveToCall
 import org.jetbrains.kotlin.resolve.calls.tasks.isDynamic

 class RenameDynamicMemberHandler: VariableInplaceRenameHandler() {
@@ -34,7 +33,7 @@ class RenameDynamicMemberHandler: VariableInplaceRenameHandler() {
        val callee = PsiTreeUtil.findElementOfClassAtOffset(
                file, editor.caretModel.offset, KtSimpleNameExpression::class.java, false
        ) ?: return false
-        val calleeDescriptor = callee.analyze()[BindingContext.REFERENCE_TARGET, callee] ?: return false
+        val calleeDescriptor = callee.resolveToCall()?.resultingDescriptor ?: return false
        return calleeDescriptor.isDynamic()
    }

@@ -25,12 +25,10 @@ import com.intellij.psi.impl.light.LightElement
 import com.intellij.psi.search.SearchScope
 import com.intellij.refactoring.rename.RenamePsiElementProcessor
 import org.jetbrains.kotlin.idea.KotlinLanguage
-import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.idea.caches.resolve.resolveToCall
 import org.jetbrains.kotlin.idea.refactoring.project
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.load.java.JvmAbi
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.source.getPsi
 import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor

@@ -70,8 +68,7 @@ class RenameJavaSyntheticPropertyHandler : AbstractReferenceSubstitutionRenameHa

    override fun getElementToRename(dataContext: DataContext): PsiElement? {
        val refExpr = getReferenceExpression(dataContext) ?: return null
-        val descriptor = refExpr.analyze(BodyResolveMode.PARTIAL)[BindingContext.REFERENCE_TARGET, refExpr] as? SyntheticJavaPropertyDescriptor
-                         ?: return null
+        val descriptor = refExpr.resolveToCall()?.resultingDescriptor as? SyntheticJavaPropertyDescriptor ?: return null
        return SyntheticPropertyWrapper(PsiManager.getInstance(dataContext.project), descriptor)
    }
 }
@@ -24,13 +24,12 @@ import com.intellij.refactoring.safeDelete.usageInfo.SafeDeleteReferenceSimpleDe
 import com.intellij.usageView.UsageInfo
 import org.jetbrains.kotlin.asJava.unwrapped
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.idea.references.KtReference
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 import org.jetbrains.kotlin.psi.psiUtil.isAncestor
 import org.jetbrains.kotlin.psi.psiUtil.parameterIndex
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
-import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.idea.caches.resolve.resolveToCall

 class KotlinJavaSafeDeleteDelegate : JavaSafeDeleteDelegate {
    override fun createUsageInfoForParameter(
@@ -45,9 +44,7 @@ class KotlinJavaSafeDeleteDelegate : JavaSafeDeleteDelegate {
        val calleeExpression = callExpression.calleeExpression
        if (!(calleeExpression is KtReferenceExpression && calleeExpression.isAncestor(element))) return

-        val bindingContext = element.analyze()
-
-        val descriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, calleeExpression) ?: return
+        val descriptor = calleeExpression.resolveToCall()?.resultingDescriptor ?: return

        val originalDeclaration = method.unwrapped
        if (originalDeclaration !is PsiMethod && originalDeclaration !is KtDeclaration) return
@@ -306,7 +306,7 @@ class InflowSlicer(
    private fun KtExpression.isBackingFieldReference(): Boolean {
        return this is KtSimpleNameExpression &&
               getReferencedName() == SyntheticFieldDescriptor.NAME.asString() &&
-               analyze()[BindingContext.REFERENCE_TARGET, this] is SyntheticFieldDescriptor
+               resolveToCall()?.resultingDescriptor is SyntheticFieldDescriptor
    }

    private fun KtExpression.processExpression() {
@@ -24,14 +24,12 @@ import com.intellij.psi.search.searches.ReferencesSearch
 import com.intellij.psi.xml.XmlAttributeValue
 import com.intellij.util.Processor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
-import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.idea.caches.resolve.resolveToCall
 import org.jetbrains.kotlin.idea.references.KtSimpleNameReference
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtReferenceExpression
 import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.psi.KtTreeVisitorVoid
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.source.getPsi


@@ -59,5 +57,5 @@ class AndroidExtensionsReferenceSearchExecutor : QueryExecutorBase<PsiReference,
            getTargetPropertyDescriptor()?.source?.getPsi() == element

    private fun KtReferenceExpression.getTargetPropertyDescriptor(): PropertyDescriptor? =
-            analyze(BodyResolveMode.PARTIAL)[BindingContext.REFERENCE_TARGET, this] as? PropertyDescriptor
+            resolveToCall()?.resultingDescriptor as? PropertyDescriptor
 }
@@ -26,11 +26,9 @@ import com.intellij.psi.xml.XmlAttribute
 import org.jetbrains.kotlin.android.synthetic.res.AndroidLayoutXmlFileManager
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.idea.caches.project.ModuleSourceInfo
-import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.caches.project.getModuleInfo
+import org.jetbrains.kotlin.idea.caches.resolve.resolveToCall
 import org.jetbrains.kotlin.psi.KtSimpleNameExpression
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode

 class AndroidGotoDeclarationHandler : GotoDeclarationHandler {
    override fun getGotoDeclarationTargets(sourceElement: PsiElement?, offset: Int, editor: Editor?): Array<PsiElement>? {
@@ -48,9 +46,7 @@ class AndroidGotoDeclarationHandler : GotoDeclarationHandler {
    }

    private fun resolvePropertyDescriptor(simpleNameExpression: KtSimpleNameExpression): PropertyDescriptor? {
-        val bindingContext = simpleNameExpression.analyze(BodyResolveMode.PARTIAL)
-        val call = bindingContext[BindingContext.CALL, simpleNameExpression]
-        val resolvedCall = bindingContext[BindingContext.RESOLVED_CALL, call]
+        val resolvedCall = simpleNameExpression.resolveToCall()
        return resolvedCall?.resultingDescriptor as? PropertyDescriptor
    }

@@ -20,9 +20,8 @@ import com.intellij.codeInsight.TargetElementUtil
 import com.intellij.codeInsight.navigation.actions.GotoDeclarationAction
 import com.intellij.psi.xml.XmlAttributeValue
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
-import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.idea.caches.resolve.resolveToCall
 import org.jetbrains.kotlin.psi.KtElement
-import org.jetbrains.kotlin.resolve.BindingContext

 abstract class AbstractAndroidGotoTest : KotlinAndroidTestCase() {

@@ -32,8 +31,7 @@ abstract class AbstractAndroidGotoTest : KotlinAndroidTestCase() {
        myFixture.configureFromExistingVirtualFile(virtualFile)

        val expression = TargetElementUtil.findReference(myFixture.editor, myFixture.caretOffset)!!.element as KtElement
-        val bindingContext = expression.analyze()
-        val resolvedCall = bindingContext[BindingContext.RESOLVED_CALL, bindingContext[BindingContext.CALL, expression]]!!
+        val resolvedCall = expression.resolveToCall()!!
        val property = resolvedCall.resultingDescriptor as? PropertyDescriptor ?: throw AssertionError("PropertyDescriptor expected")

        val targetElement = GotoDeclarationAction.findTargetElement(myFixture.project, myFixture.editor, myFixture.caretOffset)!!