Rewrite fetching methods in KotlinShortNamesCache with processor

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/KotlinShortNamesCache.kt

@@ -43,7 +43,7 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtNamedDeclaration
-import org.jetbrains.kotlin.utils.addToStdlib.sequenceOfLazyValues
+import org.jetbrains.kotlin.psi.KtNamedFunction
 
 class KotlinShortNamesCache(private val project: Project) : PsiShortNamesCache() {
     //region Classes
@@ -153,35 +153,75 @@ class KotlinShortNamesCache(private val project: Project) : PsiShortNamesCache()
         }
     }
 
-    override fun getMethodsByName(name: String, scope: GlobalSearchScope): Array<PsiMethod> {
+    override fun processMethodsWithName(
-        return getMethodSequenceByName(name, scope).toList().toTypedArray()
+        name: String,
+        processor: Processor<in PsiMethod>,
+        scope: GlobalSearchScope,
+        filter: IdFilter?
+    ): Boolean {
+        val allFunctionsProcessed = StubIndex.getInstance().processElements(
+            KotlinFunctionShortNameIndex.getInstance().key,
+            name,
+            project,
+            scope,
+            filter,
+            KtNamedFunction::class.java
+        ) { ktNamedFunction ->
+            val methods = LightClassUtil.getLightClassMethods(ktNamedFunction).filter { it.name == name }
+            return@processElements methods.all { method ->
+                processor.process(method)
+            }
+        }
+        if (!allFunctionsProcessed) {
+            return false
+        }
+
+        for (propertyName in getPropertyNamesCandidatesByAccessorName(Name.identifier(name))) {
+            val allProcessed = StubIndex.getInstance().processElements(
+                KotlinPropertyShortNameIndex.getInstance().key,
+                propertyName.asString(),
+                project,
+                scope,
+                filter,
+                KtNamedDeclaration::class.java
+            ) { ktNamedDeclaration ->
+                val methods = ktNamedDeclaration.getAccessorLightMethods()
+                    .asSequence()
+                    .filter { it.name == name }
+                    .map { it as? PsiMethod }
+                    .filterNotNull()
+
+                return@processElements methods.all { method ->
+                    processor.process(method)
+                }
+            }
+            if (!allProcessed) {
+                return false
+            }
+        }
+
+        return true
     }
 
-    private fun getMethodSequenceByName(name: String, scope: GlobalSearchScope): Sequence<PsiMethod> {
+    override fun getMethodsByName(name: String, scope: GlobalSearchScope): Array<PsiMethod> {
-        val propertiesIndex = KotlinPropertyShortNameIndex.getInstance()
+        return CancelableArrayCollectProcessor<PsiMethod>().also { processor ->
-        val functionIndex = KotlinFunctionShortNameIndex.getInstance()
+            processMethodsWithName(name, processor, scope, null)
-
+        }.toArray(arrayOf())
-        val kotlinFunctionsPsi = functionIndex.get(name, project, scope).asSequence()
-            .flatMap { LightClassUtil.getLightClassMethods(it).asSequence() }
-            .filter { it.name == name }
-
-        val propertyAccessorsPsi = sequenceOfLazyValues({ getPropertyNamesCandidatesByAccessorName(Name.identifier(name)) })
-            .flatMap { it.asSequence() }
-            .flatMap { propertiesIndex.get(it.asString(), project, scope).asSequence() }
-            .flatMap { it.getAccessorLightMethods().allDeclarations.asSequence() }
-            .filter { it.name == name }
-            .map { it as? PsiMethod }
-
-        return sequenceOfLazyValues({ kotlinFunctionsPsi }, { propertyAccessorsPsi }).flatMap { it }.filterNotNull()
     }
 
     override fun getMethodsByNameIfNotMoreThan(name: String, scope: GlobalSearchScope, maxCount: Int): Array<PsiMethod> {
         require(maxCount >= 0)
-        val psiMethods = getMethodSequenceByName(name, scope)
+
-        val limitedByMaxCount = psiMethods.take(maxCount).toList()
+        return CancelableArrayCollectProcessor<PsiMethod>().also { processor ->
-        if (limitedByMaxCount.size == 0)
+            processMethodsWithName(
-            return PsiMethod.EMPTY_ARRAY
+                name,
-        return limitedByMaxCount.toTypedArray()
+                { psiMethod ->
+                    processor.size != maxCount && processor.process(psiMethod)
+                },
+                scope,
+                null
+            )
+        }.toArray(PsiMethod.EMPTY_ARRAY)
     }
 
     override fun processMethodsWithName(name: String, scope: GlobalSearchScope, processor: Processor<PsiMethod>): Boolean =