From 6f2fb3f9aaaa915bfc28d6e10fe63ae71ed2d545 Mon Sep 17 00:00:00 2001
From: Dmitry Jemerov <yole@jetbrains.com>
Date: Wed, 11 Nov 2015 13:44:28 +0100
Subject: [PATCH] don't analyze class repeatedly if we already found an
 annotated member there  #KT-8557 Fixed

---
 .../KotlinAnnotatedElementsSearcher.kt          | 17 +++++++++++------
 ...KotlinClassesWithAnnotatedMembersSearcher.kt | 10 ++++++----
 2 files changed, 17 insertions(+), 10 deletions(-)

diff --git a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinAnnotatedElementsSearcher.kt b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinAnnotatedElementsSearcher.kt
index 86dd7ffe274..618a97372fa 100644
--- a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinAnnotatedElementsSearcher.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinAnnotatedElementsSearcher.kt
@@ -60,22 +60,27 @@ public class KotlinAnnotatedElementsSearcher : QueryExecutor<PsiModifierListOwne
     companion object {
         private val LOG = Logger.getInstance("#com.intellij.psi.impl.search.AnnotatedMembersSearcher")
 
-        public fun processAnnotatedMembers(annClass: PsiClass, useScope: SearchScope, consumer: (KtDeclaration) -> Boolean): Boolean {
+        public fun processAnnotatedMembers(annClass: PsiClass,
+                                           useScope: SearchScope,
+                                           preFilter: (KtAnnotationEntry) -> Boolean = { true },
+                                           consumer: (KtDeclaration) -> Boolean): Boolean {
             assert(annClass.isAnnotationType()) { "Annotation type should be passed to annotated members search" }
 
             val annotationFQN = annClass.getQualifiedName()
             assert(annotationFQN != null)
 
-            for (elt in getKotlinAnnotationCandidates(annClass, useScope)) {
+            val candidates = getKotlinAnnotationCandidates(annClass, useScope)
+            for (elt in candidates) {
                 if (notKtAnnotationEntry(elt)) continue
 
                 val result = runReadAction(fun(): Boolean {
+                    if (elt !is KtAnnotationEntry) return true
+                    if (!preFilter(elt)) return true
+
                     val declaration = elt.getStrictParentOfType<KtDeclaration>() ?: return true
 
-                    val annotationEntry = elt as KtAnnotationEntry
-
-                    val context = annotationEntry.analyze(BodyResolveMode.PARTIAL)
-                    val annotationDescriptor = context.get(BindingContext.ANNOTATION, annotationEntry) ?: return true
+                    val context = elt.analyze(BodyResolveMode.PARTIAL)
+                    val annotationDescriptor = context.get(BindingContext.ANNOTATION, elt) ?: return true
 
                     val descriptor = annotationDescriptor.getType().getConstructor().getDeclarationDescriptor() ?: return true
                     if (!(DescriptorUtils.getFqName(descriptor).asString() == annotationFQN)) return true
diff --git a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinClassesWithAnnotatedMembersSearcher.kt b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinClassesWithAnnotatedMembersSearcher.kt
index c20bd81590c..e5052fb3a1c 100644
--- a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinClassesWithAnnotatedMembersSearcher.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinClassesWithAnnotatedMembersSearcher.kt
@@ -34,10 +34,12 @@ class KotlinClassesWithAnnotatedMembersSearcher : ScopedQueryExecutor<PsiClass,
 
     override fun execute(queryParameters: ClassesWithAnnotatedMembersSearch.Parameters, consumer: Processor<PsiClass>): Boolean {
         val processed = hashSetOf<KtClassOrObject>()
-        return KotlinAnnotatedElementsSearcher.processAnnotatedMembers(queryParameters.annotationClass, queryParameters.scope) { declaration ->
-            val jetClass = declaration.getNonStrictParentOfType<KtClassOrObject>()
-            if (jetClass != null && processed.add(jetClass)) {
-                val lightClass = LightClassUtil.getPsiClass(jetClass)
+        return KotlinAnnotatedElementsSearcher.processAnnotatedMembers(queryParameters.annotationClass,
+                                                                       queryParameters.scope,
+                                                                       { it.getNonStrictParentOfType<KtClassOrObject>() !in processed}) { declaration ->
+            val ktClass = declaration.getNonStrictParentOfType<KtClassOrObject>()
+            if (ktClass != null && processed.add(ktClass)) {
+                val lightClass = LightClassUtil.getPsiClass(ktClass)
                 if (lightClass != null) consumer.process(lightClass) else true
             }
             else