Refactoring

idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/SmartCompletion.kt

@@ -39,6 +39,7 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.types.typeUtil.makeNotNullable
+import org.jetbrains.kotlin.utils.addToStdlib.check
 import org.jetbrains.kotlin.utils.addToStdlib.singletonOrEmptySet
 import java.util.ArrayList
 import java.util.HashSet
@@ -67,57 +68,10 @@ class SmartCompletion(
 
     public val smartCastCalculator: SmartCastCalculator = SmartCastCalculator(bindingContext, moduleDescriptor, expression)
 
-    public class Result(
+    public val descriptorFilter: ((DeclarationDescriptor) -> Collection<LookupElement>)?
-            val declarationFilter: ((DeclarationDescriptor) -> Collection<LookupElement>)?,
+            = { descriptor: DeclarationDescriptor -> filterDescriptor(descriptor).map { postProcess(it) } }.check { expectedInfos.isNotEmpty() }
-            val additionalItems: Collection<LookupElement>,
-            val inheritanceSearcher: InheritanceItemsSearcher?)
 
-    public fun execute(): Result? {
+    private fun filterDescriptor(descriptor: DeclarationDescriptor): Collection<LookupElement> {
-        fun postProcess(item: LookupElement): LookupElement {
-            return if (item.getUserData(KEEP_OLD_ARGUMENT_LIST_ON_TAB_KEY) == null) {
-                object : LookupElementDecorator<LookupElement>(item) {
-                    override fun handleInsert(context: InsertionContext) {
-                        if (context.getCompletionChar() == Lookup.REPLACE_SELECT_CHAR) {
-                            val offset = context.getOffsetMap().getOffset(OLD_ARGUMENTS_REPLACEMENT_OFFSET)
-                            if (offset != -1) {
-                                context.getDocument().deleteString(context.getTailOffset(), offset)
-                            }
-                        }
-
-                        super.handleInsert(context)
-                    }
-                }
-            }
-            else {
-                item
-            }
-        }
-
-        val result = executeInternal() ?: return null
-        // TODO: code could be more simple, see KT-5726
-        val additionalItems = result.additionalItems.map(::postProcess)
-        val inheritanceSearcher = result.inheritanceSearcher?.let {
-            object : InheritanceItemsSearcher {
-                override fun search(nameFilter: (String) -> Boolean, consumer: (LookupElement) -> Unit) {
-                    it.search(nameFilter, { consumer(postProcess(it)) })
-                }
-            }
-        }
-        val filter = result.declarationFilter
-        return if (filter != null)
-            Result({ filter(it).map(::postProcess) }, additionalItems, inheritanceSearcher)
-        else
-            Result(null, additionalItems, inheritanceSearcher)
-    }
-
-    private fun executeInternal(): Result? {
-        val (additionalItems, inheritanceSearcher) = additionalItems()
-
-        if (expectedInfos.isEmpty()) {
-            return Result(null, additionalItems, inheritanceSearcher)
-        }
-
-        fun filterDeclaration(descriptor: DeclarationDescriptor): Collection<LookupElement> {
         if (descriptor in descriptorsToSkip) return emptyList()
 
         val result = SmartList<LookupElement>()
@@ -141,10 +95,20 @@ class SmartCompletion(
         return result
     }
 
-        return Result(::filterDeclaration, additionalItems, inheritanceSearcher)
+    public fun additionalItems(): Pair<Collection<LookupElement>, InheritanceItemsSearcher?> {
+        val (items, inheritanceSearcher) = additionalItemsNoPostProcess()
+        val postProcessedItems = items.map { postProcess(it) }
+        val postProcessedSearcher = inheritanceSearcher?.let {
+            object : InheritanceItemsSearcher {
+                override fun search(nameFilter: (String) -> Boolean, consumer: (LookupElement) -> Unit) {
+                    it.search(nameFilter, { consumer(postProcess(it)) })
+                }
+            }
+        }
+        return postProcessedItems to postProcessedSearcher
     }
 
-    public fun additionalItems(): Pair<Collection<LookupElement>, InheritanceItemsSearcher?> {
+    private fun additionalItemsNoPostProcess(): Pair<Collection<LookupElement>, InheritanceItemsSearcher?> {
         val asTypePositionItems = buildForAsTypePosition()
         if (asTypePositionItems != null) {
             assert(expectedInfos.isEmpty())
@@ -185,6 +149,28 @@ class SmartCompletion(
         return Pair(items, inheritanceSearcher)
     }
 
+    private fun postProcess(item: LookupElement): LookupElement {
+        if (forBasicCompletion) return item
+
+        return if (item.getUserData(KEEP_OLD_ARGUMENT_LIST_ON_TAB_KEY) == null) {
+            object : LookupElementDecorator<LookupElement>(item) {
+                override fun handleInsert(context: InsertionContext) {
+                    if (context.getCompletionChar() == Lookup.REPLACE_SELECT_CHAR) {
+                        val offset = context.getOffsetMap().getOffset(OLD_ARGUMENTS_REPLACEMENT_OFFSET)
+                        if (offset != -1) {
+                            context.getDocument().deleteString(context.getTailOffset(), offset)
+                        }
+                    }
+
+                    super.handleInsert(context)
+                }
+            }
+        }
+        else {
+            item
+        }
+    }
+
     private fun MutableCollection<LookupElement>.addThisItems(place: JetExpression, expectedInfos: Collection<ExpectedInfo>, smartCastCalculator: SmartCastCalculator) {
         if (shouldCompleteThisItems(prefixMatcher)) {
             val items = thisExpressionItems(bindingContext, place, prefixMatcher.getPrefix())

idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/SmartCompletionSession.kt

@@ -50,12 +50,12 @@ class SmartCompletionSession(configuration: CompletionSessionConfiguration, para
             val completion = SmartCompletion(expression, resolutionFacade, moduleDescriptor,
                                              bindingContext, isVisibleFilter, inDescriptor, prefixMatcher, originalSearchScope,
                                              toFromOriginalFileMapper, lookupElementFactory)
-            val result = completion.execute()
+
-            if (result != null) {
+            val (additionalItems, inheritanceSearcher) = completion.additionalItems()
-                collector.addElements(result.additionalItems)
+            collector.addElements(additionalItems)
 
             if (nameExpression != null) {
-                    val filter = result.declarationFilter
+                val filter = completion.descriptorFilter
                 if (filter != null) {
                     referenceVariants.forEach { collector.addElements(filter(it)) }
                     flushToResultSet()
@@ -72,14 +72,13 @@ class SmartCompletionSession(configuration: CompletionSessionConfiguration, para
                 }
 
                 // it makes no sense to search inheritors if there is no reference because it means that we have prefix like "this@"
-                    result.inheritanceSearcher?.search({ prefixMatcher.prefixMatches(it) }) {
+                inheritanceSearcher?.search({ prefixMatcher.prefixMatches(it) }) {
                     collector.addElement(it)
                     flushToResultSet()
                 }
             }
         }
     }
-    }
 
     // special completion for outside parenthesis lambda argument
     private fun addFunctionLiteralArgumentCompletions() {