Renamed parameters + slightly more correct logic

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

@@ -34,7 +34,7 @@ class InsertHandlerProvider(expectedInfosCalculator: () -> Collection<ExpectedIn
                 val needTypeArguments = needTypeArguments(descriptor)
                 val parameters = descriptor.valueParameters
                 when (parameters.size()) {
-                    0 -> KotlinFunctionInsertHandler(needTypeArguments, needValueArguments = false)
+                    0 -> KotlinFunctionInsertHandler(needTypeArguments, inputValueArguments = false)
 
                     1 -> {
                         val parameterType = parameters.single().getType()
@@ -42,13 +42,13 @@ class InsertHandlerProvider(expectedInfosCalculator: () -> Collection<ExpectedIn
                             val parameterCount = KotlinBuiltIns.getParameterTypeProjectionsFromFunctionType(parameterType).size()
                             if (parameterCount <= 1) {
                                 // otherwise additional item with lambda template is to be added
-                                return KotlinFunctionInsertHandler(needTypeArguments, needValueArguments = true, lambdaInfo = GenerateLambdaInfo(parameterType, false))
+                                return KotlinFunctionInsertHandler(needTypeArguments, inputValueArguments = false, lambdaInfo = GenerateLambdaInfo(parameterType, false))
                             }
                         }
-                        KotlinFunctionInsertHandler(needTypeArguments, needValueArguments = true)
+                        KotlinFunctionInsertHandler(needTypeArguments, inputValueArguments = true)
                     }
 
-                    else -> KotlinFunctionInsertHandler(needTypeArguments, needValueArguments = true)
+                    else -> KotlinFunctionInsertHandler(needTypeArguments, inputValueArguments = true)
                 }
             }
 

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

@@ -77,7 +77,7 @@ object KeywordCompletion {
                         .withInsertHandler(if (keywordToken !in FUNCTION_KEYWORDS)
                                                KotlinKeywordInsertHandler
                                            else
-                                               KotlinFunctionInsertHandler(needTypeArguments = false, needValueArguments = false))
+                                               KotlinFunctionInsertHandler(inputTypeArguments = false, inputValueArguments = false))
                 consumer(element)
             }
         }

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

@@ -115,7 +115,7 @@ class LookupElementFactory(
 
     private fun createFunctionCallElementWithExplicitLambdaParameters(descriptor: FunctionDescriptor, parameterType: JetType, useReceiverTypes: Boolean): LookupElement {
         var lookupElement = createLookupElement(descriptor, useReceiverTypes)
-        val needTypeArguments = (insertHandlerProvider.insertHandler(descriptor) as KotlinFunctionInsertHandler).needTypeArguments
+        val needTypeArguments = (insertHandlerProvider.insertHandler(descriptor) as KotlinFunctionInsertHandler).inputTypeArguments
         val lambdaInfo = GenerateLambdaInfo(parameterType, true)
 
         lookupElement = object : LookupElementDecorator<LookupElement>(lookupElement) {
@@ -129,7 +129,7 @@ class LookupElementFactory(
             }
 
             override fun handleInsert(context: InsertionContext) {
-                KotlinFunctionInsertHandler(needTypeArguments, needValueArguments = true, lambdaInfo = lambdaInfo).handleInsert(context, this)
+                KotlinFunctionInsertHandler(needTypeArguments, inputValueArguments = false, lambdaInfo = lambdaInfo).handleInsert(context, this)
             }
         }
 
@@ -143,7 +143,7 @@ class LookupElementFactory(
     private fun createFunctionCallElementWithArgument(descriptor: FunctionDescriptor, argumentText: String, useReceiverTypes: Boolean): LookupElement {
         var lookupElement = createLookupElement(descriptor, useReceiverTypes)
 
-        val needTypeArguments = (insertHandlerProvider.insertHandler(descriptor) as KotlinFunctionInsertHandler).needTypeArguments
+        val needTypeArguments = (insertHandlerProvider.insertHandler(descriptor) as KotlinFunctionInsertHandler).inputTypeArguments
         lookupElement = FunctionCallWithArgumentLookupElement(lookupElement, descriptor, argumentText, needTypeArguments)
 
         if (contextType == ContextType.STRING_TEMPLATE_AFTER_DOLLAR) {
@@ -172,7 +172,7 @@ class LookupElementFactory(
         }
 
         override fun handleInsert(context: InsertionContext) {
-            KotlinFunctionInsertHandler(needTypeArguments = needTypeArguments, needValueArguments = false, argumentText = argumentText).handleInsert(context, this)
+            KotlinFunctionInsertHandler(inputTypeArguments = needTypeArguments, inputValueArguments = false, argumentText = argumentText).handleInsert(context, this)
         }
     }
 

idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/KotlinFunctionInsertHandler.kt

@@ -38,8 +38,8 @@ import org.jetbrains.kotlin.types.JetType
 class GenerateLambdaInfo(val lambdaType: JetType, val explicitParameters: Boolean)
 
 class KotlinFunctionInsertHandler(
-        val needTypeArguments: Boolean,
-        val needValueArguments: Boolean,
+        val inputTypeArguments: Boolean,
+        val inputValueArguments: Boolean,
         val argumentText: String = "",
         val lambdaInfo: GenerateLambdaInfo? = null
 ) : KotlinCallableInsertHandler() {
@@ -100,7 +100,7 @@ class KotlinFunctionInsertHandler(
         val openingBracket = if (insertLambda) '{' else '('
         val closingBracket = if (insertLambda) '}' else ')'
 
-        var insertTypeArguments = needTypeArguments && (completionChar == '\n' || completionChar == '\r')
+        var insertTypeArguments = inputTypeArguments && (completionChar == '\n' || completionChar == '\r')
 
         if (completionChar == Lookup.REPLACE_SELECT_CHAR) {
             val offset1 = chars.skipSpaces(offset)
@@ -160,6 +160,11 @@ class KotlinFunctionInsertHandler(
             closeBracketOffset = chars.indexOfSkippingSpace(closingBracket, openingBracketOffset + 1)!!
         }
 
+        if (insertLambda && lambdaInfo!!.explicitParameters) {
+            insertLambdaTemplate(context, TextRange(openingBracketOffset, closeBracketOffset!! + 1), lambdaInfo!!.lambdaType)
+            return
+        }
+
         document.insertString(openingBracketOffset + 1, argumentText)
         if (closeBracketOffset != null) {
             closeBracketOffset += argumentText.length()
@@ -168,24 +173,20 @@ class KotlinFunctionInsertHandler(
         if (!insertTypeArguments) {
             if (shouldPlaceCaretInBrackets(completionChar) || closeBracketOffset == null) {
                 editor.caretModel.moveToOffset(openingBracketOffset + 1 + inBracketsShift)
-                AutoPopupController.getInstance(project)?.autoPopupParameterInfo(editor, offsetElement)
+                if (!insertLambda) {
+                    AutoPopupController.getInstance(project)?.autoPopupParameterInfo(editor, offsetElement)
+                }
             }
             else {
                 editor.caretModel.moveToOffset(closeBracketOffset + 1)
             }
         }
-
-        PsiDocumentManager.getInstance(project).commitDocument(document)
-
-        if (insertLambda && lambdaInfo!!.explicitParameters) {
-            insertLambdaTemplate(context, TextRange(openingBracketOffset, closeBracketOffset!! + 1), lambdaInfo!!.lambdaType)
-        }
     }
 
     private fun shouldPlaceCaretInBrackets(completionChar: Char): Boolean {
         if (completionChar == ',' || completionChar == '.' || completionChar == '=') return false
         if (completionChar == '(') return true
-        return needValueArguments
+        return inputValueArguments || lambdaInfo != null
     }
 
     private fun isInsertSpacesInOneLineFunctionEnabled(project: Project)

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

@@ -184,9 +184,9 @@ class TypeInstantiationItems(
             }
 
             val baseInsertHandler = when (visibleConstructors.size()) {
-                0 -> KotlinFunctionInsertHandler(needTypeArguments = false, needValueArguments = false)
+                0 -> KotlinFunctionInsertHandler(inputTypeArguments = false, inputValueArguments = false)
                 1 -> lookupElementFactory.insertHandlerProvider.insertHandler(visibleConstructors.single()) as KotlinFunctionInsertHandler
-                else -> KotlinFunctionInsertHandler(needTypeArguments = false, needValueArguments = true)
+                else -> KotlinFunctionInsertHandler(inputTypeArguments = false, inputValueArguments = true)
             }
 
             insertHandler = object : InsertHandler<LookupElement> {
@@ -199,7 +199,7 @@ class TypeInstantiationItems(
                     shortenReferences(context, context.getStartOffset(), context.getTailOffset())
                 }
             }
-            if (baseInsertHandler.needValueArguments) {
+            if (baseInsertHandler.inputValueArguments) {
                 lookupElement = lookupElement.keepOldArgumentListOnTab()
             }
             if (baseInsertHandler.lambdaInfo != null) {