Better formatting of BasicCompletionSession

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

@@ -127,11 +127,9 @@ class BasicCompletionSession(
         return ALL
     }
 
-    fun shouldDisableAutoPopup(): Boolean
+    fun shouldDisableAutoPopup(): Boolean = completionKind.shouldDisableAutoPopup()
-            = completionKind.shouldDisableAutoPopup()
 
-    override fun shouldCompleteTopLevelCallablesFromIndex()
+    override fun shouldCompleteTopLevelCallablesFromIndex() = super.shouldCompleteTopLevelCallablesFromIndex() && prefix.isNotEmpty()
-            = super.shouldCompleteTopLevelCallablesFromIndex() && prefix.isNotEmpty()
 
     override fun doComplete() {
         assert(parameters.completionType == CompletionType.BASIC)
@@ -167,10 +165,13 @@ class BasicCompletionSession(
         var sorter = super.createSorter()
 
         if (smartCompletion != null) {
-            val smartCompletionInBasicWeigher = SmartCompletionInBasicWeigher(smartCompletion, callTypeAndReceiver, resolutionFacade, bindingContext)
+            val smartCompletionInBasicWeigher =
-            sorter = sorter.weighBefore(KindWeigher.toString(),
+                SmartCompletionInBasicWeigher(smartCompletion, callTypeAndReceiver, resolutionFacade, bindingContext)
+            sorter = sorter.weighBefore(
+                KindWeigher.toString(),
                 smartCompletionInBasicWeigher,
-                                        CallableReferenceWeigher(callTypeAndReceiver.callType))
+                CallableReferenceWeigher(callTypeAndReceiver.callType)
+            )
         }
 
         sorter = completionKind.addWeighers(sorter)
@@ -214,7 +215,9 @@ class BasicCompletionSession(
 
             fun completeWithSmartCompletion(lookupElementFactory: LookupElementFactory) {
                 if (smartCompletion != null) {
-                    val (additionalItems, @Suppress("UNUSED_VARIABLE") inheritanceSearcher) = smartCompletion.additionalItems(lookupElementFactory)
+                    val (additionalItems, @Suppress("UNUSED_VARIABLE") inheritanceSearcher) = smartCompletion.additionalItems(
+                        lookupElementFactory
+                    )
 
                     // all additional items should have SMART_COMPLETION_ITEM_PRIORITY_KEY to be recognized by SmartCompletionInBasicWeigher
                     for (item in additionalItems) {
@@ -290,7 +293,8 @@ class BasicCompletionSession(
                     ExtensionFunctionTypeValueCompletion(receiverTypes, callTypeAndReceiver.callType, lookupElementFactory)
                         .processVariables(contextVariablesProvider)
                         .forEach {
-                                val lookupElements = it.factory.createStandardLookupElementsForDescriptor(it.invokeDescriptor, useReceiverTypes = true)
+                            val lookupElements =
+                                it.factory.createStandardLookupElementsForDescriptor(it.invokeDescriptor, useReceiverTypes = true)
                             collector.addElements(lookupElements)
                         }
                 }
@@ -310,7 +314,8 @@ class BasicCompletionSession(
                     resolutionFacade,
                     lookupElementFactory,
                     referenceVariantsCollector!!.allCollected.imported,
-                        isJvmModule)
+                    isJvmModule
+                )
                 if (callTypeAndReceiver is CallTypeAndReceiver.DEFAULT) {
                     staticMembersCompletion.completeFromImports(file, collector)
                 }
@@ -324,7 +329,12 @@ class BasicCompletionSession(
                         val variants = variantsAndFactory.first
                         @Suppress("NAME_SHADOWING") val lookupElementFactory = variantsAndFactory.second
                         collector.addDescriptorElements(variants.imported, lookupElementFactory, withReceiverCast = true)
-                        collector.addDescriptorElements(variants.notImportedExtensions, lookupElementFactory, withReceiverCast = true, notImported = true)
+                        collector.addDescriptorElements(
+                            variants.notImportedExtensions,
+                            lookupElementFactory,
+                            withReceiverCast = true,
+                            notImported = true
+                        )
                         flushToResultSet()
                     }
                 }
@@ -370,8 +380,7 @@ class BasicCompletionSession(
                         prefixMatcher
                     addClassesFromIndex(classKindFilter, includeTypeAliases, prefixMatcher)
                 }
-            }
+            } else if (callTypeAndReceiver is CallTypeAndReceiver.DOT) {
-            else if (callTypeAndReceiver is CallTypeAndReceiver.DOT) {
                 val qualifier = bindingContext[BindingContext.QUALIFIER, callTypeAndReceiver.receiver]
                 if (qualifier != null) return
                 val receiver = callTypeAndReceiver.receiver as? KtSimpleNameExpression ?: return
@@ -388,7 +397,8 @@ class BasicCompletionSession(
                     }
                 }
 
-                AllClassesCompletion(parameters.withPosition(receiver, receiver.startOffset), helper, fullTextPrefixMatcher, resolutionFacade,
+                AllClassesCompletion(
+                    parameters.withPosition(receiver, receiver.startOffset), helper, fullTextPrefixMatcher, resolutionFacade,
                     { true }, true, configuration.javaClassesNotToBeUsed
                 ).collect({ descriptors += it }, { descriptors.addIfNotNull(it.resolveToDescriptor(resolutionFacade)) })
 
@@ -409,14 +419,18 @@ class BasicCompletionSession(
 
                         val newContext = (nameExpression.parent as KtExpression).analyzeInContext(newScope)
 
-                            val rvHelper = ReferenceVariantsHelper(newContext,
+                        val rvHelper = ReferenceVariantsHelper(
+                            newContext,
                             resolutionFacade,
                             moduleDescriptor,
                             isVisibleFilter,
-                                                                   NotPropertiesService.getNotProperties(position))
+                            NotPropertiesService.getNotProperties(position)
-                            val rvCollector = ReferenceVariantsCollector(rvHelper, indicesHelper(true), prefixMatcher,
+                        )
+                        val rvCollector = ReferenceVariantsCollector(
+                            rvHelper, indicesHelper(true), prefixMatcher,
                             nameExpression, callTypeAndReceiver, resolutionFacade, newContext,
-                                                                         importableFqNameClassifier, configuration)
+                            importableFqNameClassifier, configuration
+                        )
 
                         val receiverTypes = detectReceiverTypes(newContext, nameExpression, callTypeAndReceiver)
 
@@ -430,7 +444,8 @@ class BasicCompletionSession(
 
                             if (lookupDescriptor is CallableMemberDescriptor &&
                                 lookupDescriptor.isExtension &&
-                                    lookupDescriptor.extensionReceiverParameter?.importableFqName != desc.fqNameSafe) {
+                                lookupDescriptor.extensionReceiverParameter?.importableFqName != desc.fqNameSafe
+                            ) {
                                 return@copy lookupElement
                             }
 
@@ -445,7 +460,9 @@ class BasicCompletionSession(
                                     context.commitDocument()
                                     val file = context.file as? KtFile
                                     if (file != null) {
-                                            val receiverInFile = file.findElementAt(receiver.startOffset)?.getParentOfType<KtSimpleNameExpression>(false) ?: return
+                                        val receiverInFile =
+                                            file.findElementAt(receiver.startOffset)?.getParentOfType<KtSimpleNameExpression>(false)
+                                                    ?: return
                                         receiverInFile.mainReference.bindToFqName(fqNameToImport, FORCED_SHORTENING)
                                     }
                                 }
@@ -508,7 +525,12 @@ class BasicCompletionSession(
             val keywordsToSkip = HashSet<String>()
 
             val keywordValueConsumer = object : KeywordValues.Consumer {
-                override fun consume(lookupString: String, expectedInfoMatcher: (ExpectedInfo) -> ExpectedInfoMatch, priority: SmartCompletionItemPriority, factory: () -> LookupElement) {
+                override fun consume(
+                    lookupString: String,
+                    expectedInfoMatcher: (ExpectedInfo) -> ExpectedInfoMatch,
+                    priority: SmartCompletionItemPriority,
+                    factory: () -> LookupElement
+                ) {
                     keywordsToSkip.add(lookupString)
                     val lookupElement = factory()
                     val matched = expectedInfos.any {
@@ -523,7 +545,14 @@ class BasicCompletionSession(
                     collector.addElement(lookupElement)
                 }
             }
-            KeywordValues.process(keywordValueConsumer, callTypeAndReceiver, bindingContext, resolutionFacade, moduleDescriptor, isJvmModule)
+            KeywordValues.process(
+                keywordValueConsumer,
+                callTypeAndReceiver,
+                bindingContext,
+                resolutionFacade,
+                moduleDescriptor,
+                isJvmModule
+            )
 
             val keywordsPrefix = prefix.substringBefore('@') // if there is '@' in the prefix - use shorter prefix to not loose 'this' etc
             val isUseSiteAnnotationTarget = position.prevLeaf()?.node?.elementType == KtTokens.AT
@@ -535,9 +564,14 @@ class BasicCompletionSession(
                 // if "this" is parsed correctly in the current context - insert it and all this@xxx items
                     "this" -> {
                         if (expression != null) {
-                            collector.addElements(thisExpressionItems(bindingContext, expression, prefix, resolutionFacade).map { it.createLookupElement() })
+                            collector.addElements(
-                        }
+                                thisExpressionItems(
-                        else {
+                                    bindingContext,
+                                    expression,
+                                    prefix,
+                                    resolutionFacade
+                                ).map { it.createLookupElement() })
+                        } else {
                             // for completion in secondary constructor delegation call
                             collector.addElement(lookupElement)
                         }
@@ -573,7 +607,14 @@ class BasicCompletionSession(
 
                         if (!isUseSiteAnnotationTarget) {
                             collector.addElement(createKeywordConstructLookupElement(project, keyword, "val v:Int get()=caret"))
-                            collector.addElement(createKeywordConstructLookupElement(project, keyword, "val v:Int get(){caret}", trimSpacesAroundCaret = true))
+                            collector.addElement(
+                                createKeywordConstructLookupElement(
+                                    project,
+                                    keyword,
+                                    "val v:Int get(){caret}",
+                                    trimSpacesAroundCaret = true
+                                )
+                            )
                         }
                     }
 
@@ -582,7 +623,14 @@ class BasicCompletionSession(
 
                         if (!isUseSiteAnnotationTarget) {
                             collector.addElement(createKeywordConstructLookupElement(project, keyword, "var v:Int set(value)=caret"))
-                            collector.addElement(createKeywordConstructLookupElement(project, keyword, "var v:Int set(value){caret}", trimSpacesAroundCaret = true))
+                            collector.addElement(
+                                createKeywordConstructLookupElement(
+                                    project,
+                                    keyword,
+                                    "var v:Int set(value){caret}",
+                                    trimSpacesAroundCaret = true
+                                )
+                            )
                         }
                     }
 
@@ -609,7 +657,8 @@ class BasicCompletionSession(
             if (nameExpression == null || nameExpression != expression) return false
             val func = position.getParentOfType<KtNamedFunction>(strict = false) ?: return false
             val funcNameIdentifier = func.nameIdentifier ?: return false
-            val identifierInNameExpression = nameExpression.nextLeaf { it is LeafPsiElement && it.elementType == KtTokens.IDENTIFIER } ?: return false
+            val identifierInNameExpression =
+                nameExpression.nextLeaf { it is LeafPsiElement && it.elementType == KtTokens.IDENTIFIER } ?: return false
             if (!func.hasModifier(KtTokens.OPERATOR_KEYWORD) || identifierInNameExpression != funcNameIdentifier) return false
             val originalFunc = toFromOriginalFileMapper.toOriginalFile(func) ?: return false
             return !originalFunc.isTopLevel || (originalFunc.isExtensionDeclaration())
@@ -708,8 +757,7 @@ class BasicCompletionSession(
     private fun completeDeclarationNameFromUnresolvedOrOverride(declaration: KtNamedDeclaration) {
         if (declaration is KtCallableDeclaration && declaration.hasModifier(KtTokens.OVERRIDE_KEYWORD)) {
             OverridesCompletion(collector, basicLookupElementFactory).complete(position, declaration)
-        }
+        } else {
-        else {
             val referenceScope = referenceScope(declaration) ?: return
             val originalScope = toFromOriginalFileMapper.toOriginalFile(referenceScope) ?: return
             val afterOffset = if (referenceScope is KtBlockExpression) parameters.offset else null
@@ -727,8 +775,7 @@ class BasicCompletionSession(
                 val classOrObject = parent.parent as KtClassOrObject
                 if (classOrObject is KtObjectDeclaration && classOrObject.isCompanion()) {
                     classOrObject.containingClassOrObject
-                }
+                } else {
-                else {
                     classOrObject
                 }
             }
@@ -748,7 +795,8 @@ class BasicCompletionSession(
         val javaClassCollector = { javaClass: PsiClass ->
             collector.addElement(basicLookupElementFactory.createLookupElementForJavaClass(javaClass), notImported = true)
         }
-        AllClassesCompletion(parameters, indicesHelper(true), prefixMatcher, resolutionFacade,
+        AllClassesCompletion(
+            parameters, indicesHelper(true), prefixMatcher, resolutionFacade,
             kindFilter, includeTypeAliases, configuration.javaClassesNotToBeUsed
         ).collect(classifierDescriptorCollector, javaClassCollector)
     }
@@ -793,10 +841,14 @@ class BasicCompletionSession(
     }
 }
 
-private val USUALLY_START_UPPER_CASE = DescriptorKindFilter(DescriptorKindFilter.CLASSIFIERS_MASK or DescriptorKindFilter.FUNCTIONS_MASK,
+private val USUALLY_START_UPPER_CASE = DescriptorKindFilter(
-                                                            listOf(NonSamConstructorFunctionExclude, DescriptorKindExclude.Extensions /* needed for faster getReferenceVariants */))
+    DescriptorKindFilter.CLASSIFIERS_MASK or DescriptorKindFilter.FUNCTIONS_MASK,
-private val USUALLY_START_LOWER_CASE = DescriptorKindFilter(DescriptorKindFilter.CALLABLES_MASK or DescriptorKindFilter.PACKAGES_MASK,
+    listOf(NonSamConstructorFunctionExclude, DescriptorKindExclude.Extensions /* needed for faster getReferenceVariants */)
-                                                            listOf(SamConstructorDescriptorKindExclude))
+)
+private val USUALLY_START_LOWER_CASE = DescriptorKindFilter(
+    DescriptorKindFilter.CALLABLES_MASK or DescriptorKindFilter.PACKAGES_MASK,
+    listOf(SamConstructorDescriptorKindExclude)
+)
 
 private object NonSamConstructorFunctionExclude : DescriptorKindExclude() {
     override fun excludes(descriptor: DeclarationDescriptor) = descriptor is FunctionDescriptor && descriptor !is SamConstructorDescriptor