Performance optimization for completion after "ge", "se", etc

idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionSession.kt

@@ -120,16 +120,7 @@ abstract class CompletionSession(
 
     protected val prefixMatcher = CamelHumpMatcher(prefix)
 
-    private val descriptorStringNameFilter: (String) -> Boolean = run {
+    protected val descriptorNameFilter: (String) -> Boolean = prefixMatcher.asStringNameFilter()
-        val nameFilter = prefixMatcher.asStringNameFilter()
-        val getOrSetPrefix = listOf("get", "set", "ge", "se", "g", "s").firstOrNull { prefix.startsWith(it) }
-        if (getOrSetPrefix != null)
-            prefixMatcher.cloneWithPrefix(prefix.removePrefix(getOrSetPrefix).decapitalizeSmart()).asStringNameFilter() or nameFilter
-        else
-            nameFilter
-    }
-
-    protected val descriptorNameFilter: (Name) -> Boolean = descriptorStringNameFilter.toNameFilter()
 
     protected val isVisibleFilter: (DeclarationDescriptor) -> Boolean = { isVisibleDescriptor(it, completeNonAccessible = configuration.nonAccessibleDeclarations) }
     protected val isVisibleFilterCheckAlways: (DeclarationDescriptor) -> Boolean = { isVisibleDescriptor(it, completeNonAccessible = false) }
@@ -307,23 +298,45 @@ abstract class CompletionSession(
         referenceVariants?.let { ReferenceVariants(referenceVariantsHelper.excludeNonInitializedVariable(it.imported, position), it.notImportedExtensions) }
     }
 
-    private fun collectReferenceVariants(descriptorKindFilter: DescriptorKindFilter, nameExpression: KtSimpleNameExpression, runtimeReceiver: ExpressionReceiver? = null): ReferenceVariants {
+    private fun collectReferenceVariants(
-        var variants = referenceVariantsHelper.getReferenceVariants(
+            descriptorKindFilter: DescriptorKindFilter,
-                nameExpression,
+            nameExpression: KtSimpleNameExpression,
-                descriptorKindFilter,
+            runtimeReceiver: ExpressionReceiver? = null
-                descriptorNameFilter,
+    ): ReferenceVariants {
-                filterOutJavaGettersAndSetters = false,
+        fun getReferenceVariants(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): Collection<DeclarationDescriptor> {
-                filterOutShadowed = false,
+            return referenceVariantsHelper.getReferenceVariants(
-                excludeNonInitializedVariable = false,
+                    nameExpression,
-                useReceiverType = runtimeReceiver?.type)
+                    kindFilter,
+                    nameFilter,
+                    filterOutJavaGettersAndSetters = false,
+                    filterOutShadowed = false,
+                    excludeNonInitializedVariable = false,
+                    useReceiverType = runtimeReceiver?.type)
+        }
+
+        var variants = getReferenceVariants(descriptorKindFilter, descriptorNameFilter.toNameFilter())
+
+        val getOrSetPrefix = listOf("get", "set", "ge", "se", "g", "s").firstOrNull { prefix.startsWith(it) }
+        val additionalPropertyNameFilter: ((String) -> Boolean)? = run {
+            getOrSetPrefix?.let { prefixMatcher.cloneWithPrefix(prefix.removePrefix(getOrSetPrefix).decapitalizeSmart()).asStringNameFilter() }
+        }
+        if (additionalPropertyNameFilter != null) {
+            variants += getReferenceVariants(descriptorKindFilter.intersect(DescriptorKindFilter.VARIABLES),
+                                             additionalPropertyNameFilter.toNameFilter())
+            variants = variants.distinct()
+        }
 
         var notImportedExtensions: Collection<CallableDescriptor> = emptyList()
         if (callTypeAndReceiver.shouldCompleteCallableExtensions()) {
             val indicesHelper = indicesHelper(true)
-            val extensions = if (runtimeReceiver != null)
+            val nameFilter = if (additionalPropertyNameFilter != null)
-                indicesHelper.getCallableTopLevelExtensions(callTypeAndReceiver, listOf(runtimeReceiver.type), descriptorStringNameFilter)
+                descriptorNameFilter or additionalPropertyNameFilter
             else
-                indicesHelper.getCallableTopLevelExtensions(callTypeAndReceiver, expression!!, bindingContext, descriptorStringNameFilter)
+                descriptorNameFilter
+            val extensions = if (runtimeReceiver != null)
+                indicesHelper.getCallableTopLevelExtensions(callTypeAndReceiver, listOf(runtimeReceiver.type), nameFilter)
+            else
+                indicesHelper.getCallableTopLevelExtensions(callTypeAndReceiver, expression!!, bindingContext, nameFilter)
 
             val pair = extensions.partition { isImportableDescriptorImported(it) }
             variants += pair.first

idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KDocCompletionContributor.kt

@@ -116,7 +116,7 @@ class KDocNameCompletionSession(
             return true
         }
 
-        scope.collectDescriptorsFiltered(nameFilter = descriptorNameFilter).filter(::isApplicable).forEach {
+        scope.collectDescriptorsFiltered(nameFilter = descriptorNameFilter.toNameFilter()).filter(::isApplicable).forEach {
             val element = basicLookupElementFactory.createLookupElement(it, parametersAndTypeGrayed = true)
             collector.addElement(object: LookupElementDecorator<LookupElement>(element) {
                 override fun handleInsert(context: InsertionContext?) {