KT-28898: Optimize type-alias extensions and type-alias expansions lookup

#KT-28898 Fixed

idea/idea-core/src/org/jetbrains/kotlin/idea/core/KotlinIndicesHelper.kt

@@ -27,7 +27,6 @@ import org.jetbrains.kotlin.asJava.elements.KtLightElement
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.idea.caches.KotlinShortNamesCache
 import org.jetbrains.kotlin.idea.caches.resolve.resolveImportReference
-import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptorIfAny
 import org.jetbrains.kotlin.idea.caches.resolve.unsafeResolveToDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.util.getJavaMemberDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.util.resolveToDescriptor
@@ -190,23 +189,40 @@ class KotlinIndicesHelper(
         fun searchRecursively(typeName: String) {
             ProgressManager.checkCanceled()
             index[typeName, project, scope].asSequence()
-                    .map { it.resolveToDescriptorIfAny() as? TypeAliasDescriptor }
+                .filter { it in scope }
-                    .filterNotNull()
+                .flatMap { it.resolveToDescriptors<TypeAliasDescriptor>().asSequence() }
-                    .filter { it.expandedType.constructor == typeConstructor }
+                .filter { it.expandedType.constructor == typeConstructor }
-                    .filter { out.putIfAbsent(it.fqNameSafe, it) == null }
+                .filter { out.putIfAbsent(it.fqNameSafe, it) == null }
-                    .map { it.name.asString() }
+                .map { it.name.asString() }
-                    .forEach(::searchRecursively)
+                .forEach(::searchRecursively)
         }
 
         searchRecursively(originalTypeName)
         return out.values.toSet()
     }
 
+    private fun possibleTypeAliasExpansionNames(originalTypeName: String): Set<String> {
+        val index = KotlinTypeAliasByExpansionShortNameIndex.INSTANCE
+        val out = mutableSetOf<String>()
+
+        fun searchRecursively(typeName: String) {
+            ProgressManager.checkCanceled()
+            index[typeName, project, scope].asSequence()
+                .filter { it in scope }
+                .mapNotNull { it.name }
+                .filter { out.add(it) }
+                .forEach(::searchRecursively)
+        }
+
+        searchRecursively(originalTypeName)
+        return out
+    }
+
     private fun MutableCollection<String>.addTypeNames(type: KotlinType) {
         val constructor = type.constructor
         constructor.declarationDescriptor?.name?.asString()?.let { typeName ->
             add(typeName)
-            resolveTypeAliasesUsingIndex(type, typeName).mapTo(this, { it.name.asString() })
+            addAll(possibleTypeAliasExpansionNames(typeName))
         }
         constructor.supertypes.forEach { addTypeNames(it) }
     }