From e363809b3719e937b6e507541452f250dcaee5b4 Mon Sep 17 00:00:00 2001
From: Valentin Kipyatkov <valentin@jetbrains.com>
Date: Wed, 31 Aug 2016 19:11:04 +0300
Subject: [PATCH] Minor changes

---
 .../destructuringDeclarationUsages.kt         | 53 +++++++++----------
 1 file changed, 26 insertions(+), 27 deletions(-)

diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/destructuringDeclarationUsages.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/destructuringDeclarationUsages.kt
index 09dad6941c9..d7888118cb6 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/destructuringDeclarationUsages.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/destructuringDeclarationUsages.kt
@@ -287,7 +287,7 @@ private class Processor(
     }
 
     private fun addSamInterfaceToProcess(psiClass: PsiClass) {
-        data class SamInterfaceTask(val psiClass: PsiClass) : Task {
+        data class ProcessSamInterfaceTask(val psiClass: PsiClass) : Task {
             override fun perform() {
                 //TODO: what about other JVM languages?
                 val scope = GlobalSearchScope.getScopeRestrictedByFileTypes(GlobalSearchScope.projectScope(project), JavaFileType.INSTANCE)
@@ -302,7 +302,7 @@ private class Processor(
                 }
             }
         }
-        addTask(SamInterfaceTask(psiClass))
+        addTask(ProcessSamInterfaceTask(psiClass))
     }
 
     /**
@@ -474,28 +474,8 @@ private class Processor(
         for (parent in element.parents) {
             when (parent) {
                 is PsiCodeBlock,
-                is PsiExpression,
-                is PsiImportStatement ->
-                    break@ParentsLoop // ignore local usages and usages in imports
-
-                //TODO: if Java parameter has Kotlin functional type then we should process method usages
-                is PsiParameter -> {
-                    if (prev == parent.typeElement) {
-                        val method = parent.declarationScope as? PsiMethod
-                        if (method != null && method.hasModifierProperty(PsiModifier.ABSTRACT)) {
-                            val psiClass = method.containingClass
-                            if (psiClass != null) {
-                                testLog?.add("Resolved java class to descriptor: ${psiClass.qualifiedName}")
-
-                                val classDescriptor = psiClass.resolveToDescriptor(target.getResolutionFacade())
-                                if (classDescriptor != null && SingleAbstractMethodUtils.getSingleAbstractMethodOrNull(classDescriptor) != null) {
-                                    addSamInterfaceToProcess(psiClass)
-                                }
-                            }
-                        }
-                    }
-                    break@ParentsLoop
-                }
+                is PsiExpression ->
+                    break@ParentsLoop // ignore local usages
 
                 is PsiMethod -> {
                     if (prev == parent.returnTypeElement && !parent.isPrivateOrLocal()) {
@@ -520,6 +500,25 @@ private class Processor(
                     }
                     break@ParentsLoop
                 }
+
+                //TODO: if Java parameter has Kotlin functional type then we should process method usages
+                is PsiParameter -> {
+                    if (prev == parent.typeElement) {
+                        val method = parent.declarationScope as? PsiMethod
+                        if (method != null && method.hasModifierProperty(PsiModifier.ABSTRACT)) {
+                            val psiClass = method.containingClass
+                            if (psiClass != null) {
+                                testLog?.add("Resolved java class to descriptor: ${psiClass.qualifiedName}")
+
+                                val classDescriptor = psiClass.resolveToDescriptor(target.getResolutionFacade())
+                                if (classDescriptor != null && SingleAbstractMethodUtils.getSingleAbstractMethodOrNull(classDescriptor) != null) {
+                                    addSamInterfaceToProcess(psiClass)
+                                }
+                            }
+                        }
+                    }
+                    break@ParentsLoop
+                }
             }
 
             prev = parent
@@ -610,9 +609,9 @@ private class Processor(
         }
     }
 
-    private fun usePlainSearch(scopeElement: KtElement) {
-        val file = scopeElement.getContainingKtFile()
-        val restricted = LocalSearchScope(scopeElement).intersectWith(searchScope) as LocalSearchScope
+    private fun usePlainSearch(scope: KtElement) {
+        val file = scope.getContainingKtFile()
+        val restricted = LocalSearchScope(scope).intersectWith(searchScope) as LocalSearchScope
         ScopeLoop@
         for (element in restricted.scope) {
             val prevElements = scopesToUsePlainSearch.getOrPut(file) { ArrayList() }