Fixed completion to not render functional types with parameter names in lookup items

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

@@ -40,6 +40,11 @@ class BasicLookupElementFactory(
         private val project: Project,
         val insertHandlerProvider: InsertHandlerProvider
 ) {
+    companion object {
+        // we skip parameter names in functional types in most of cases for shortness
+        val SHORT_NAMES_RENDERER = DescriptorRenderer.SHORT_NAMES_IN_TYPES.withOptions { parameterNamesInFunctionalTypes = false }
+    }
+
     fun createLookupElement(
             descriptor: DeclarationDescriptor,
             qualifyNestedClasses: Boolean = false,
@@ -155,18 +160,18 @@ class BasicLookupElementFactory(
         when (descriptor) {
             is FunctionDescriptor -> {
                 val returnType = descriptor.returnType
-                element = element.withTypeText(if (returnType != null) DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(returnType) else "", parametersAndTypeGrayed)
+                element = element.withTypeText(if (returnType != null) SHORT_NAMES_RENDERER.renderType(returnType) else "", parametersAndTypeGrayed)
 
                 val insertsLambda = (insertHandler as? KotlinFunctionInsertHandler.Normal)?.lambdaInfo != null
                 if (insertsLambda) {
                     element = element.appendTailText(" {...} ", parametersAndTypeGrayed)
                 }
 
-                element = element.appendTailText(DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderFunctionParameters(descriptor), parametersAndTypeGrayed || insertsLambda)
+                element = element.appendTailText(SHORT_NAMES_RENDERER.renderFunctionParameters(descriptor), parametersAndTypeGrayed || insertsLambda)
             }
 
             is VariableDescriptor -> {
-                element = element.withTypeText(DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(descriptor.type), parametersAndTypeGrayed)
+                element = element.withTypeText(SHORT_NAMES_RENDERER.renderType(descriptor.type), parametersAndTypeGrayed)
             }
 
             is ClassifierDescriptorWithTypeParameters -> {
@@ -178,7 +183,7 @@ class BasicLookupElementFactory(
                 var container = descriptor.containingDeclaration
 
                 if (qualifyNestedClasses) {
-                    element = element.withPresentableText(DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderClassifierName(descriptor))
+                    element = element.withPresentableText(SHORT_NAMES_RENDERER.renderClassifierName(descriptor))
 
                     while (container is ClassDescriptor) {
                         val containerName = container.name
@@ -194,12 +199,13 @@ class BasicLookupElementFactory(
                 }
 
                 if (descriptor is TypeAliasDescriptor) {
+                    // here we render with DescriptorRenderer.SHORT_NAMES_IN_TYPES to include parameter names in functional types
                     element = element.withTypeText(DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(descriptor.underlyingType), false)
                 }
             }
 
             else -> {
-                element = element.withTypeText(DescriptorRenderer.SHORT_NAMES_IN_TYPES.render(descriptor), parametersAndTypeGrayed)
+                element = element.withTypeText(SHORT_NAMES_RENDERER.render(descriptor), parametersAndTypeGrayed)
             }
         }
 
@@ -242,7 +248,7 @@ class BasicLookupElementFactory(
             }
 
             extensionReceiver != null -> {
-                val receiverPresentation = DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(extensionReceiver.type)
+                val receiverPresentation = SHORT_NAMES_RENDERER.renderType(extensionReceiver.type)
                 appendTailText(" for $receiverPresentation")
 
                 val container = descriptor.containingDeclaration

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

@@ -168,7 +168,7 @@ fun shouldCompleteThisItems(prefixMatcher: PrefixMatcher): Boolean {
 class ThisItemLookupObject(val receiverParameter: ReceiverParameterDescriptor, val labelName: Name?) : KeywordLookupObject()
 
 fun ThisItemLookupObject.createLookupElement() = createKeywordElement("this", labelName.labelNameToTail(), lookupObject = this)
-        .withTypeText(DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(receiverParameter.type))
+        .withTypeText(BasicLookupElementFactory.SHORT_NAMES_RENDERER.renderType(receiverParameter.type))
 
 fun thisExpressionItems(bindingContext: BindingContext, position: KtExpression, prefix: String, resolutionFacade: ResolutionFacade): Collection<ThisItemLookupObject> {
     val scope = position.getResolutionScope(bindingContext, resolutionFacade)
@@ -381,7 +381,7 @@ fun LookupElement.decorateAsStaticMember(
             }
 
             if (presentation.typeText.isNullOrEmpty()) {
-                presentation.typeText = DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(classDescriptor.defaultType)
+                presentation.typeText = BasicLookupElementFactory.SHORT_NAMES_RENDERER.renderType(classDescriptor.defaultType)
             }
         }
 

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

@@ -167,7 +167,7 @@ class LookupElementFactory(
         val lambdaPresentation = lambdaPresentation(if (explicitLambdaParameters) parameterType else null)
 
         // render only the last parameter because all other should be optional and will be omitted
-        var parametersRenderer = DescriptorRenderer.SHORT_NAMES_IN_TYPES
+        var parametersRenderer = BasicLookupElementFactory.SHORT_NAMES_RENDERER
         if (descriptor.valueParameters.size > 1) {
             parametersRenderer = parametersRenderer.withOptions {
                 valueParametersHandler = object: DescriptorRenderer.ValueParametersHandler by this.valueParametersHandler {

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

@@ -59,7 +59,7 @@ object NamedArgumentCompletion {
         }
 
         for ((name, types) in nameToParameterType) {
-            val typeText = types.singleOrNull()?.let { DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(it) } ?: "..."
+            val typeText = types.singleOrNull()?.let { BasicLookupElementFactory.SHORT_NAMES_RENDERER.renderType(it) } ?: "..."
             val nameString = name.asString()
             val lookupElement = LookupElementBuilder.create(nameString)
                     .withPresentableText("$nameString =")

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

@@ -211,7 +211,7 @@ class TypeInstantiationItems(
                     val constructor = visibleConstructors.single()
                     val substitutor = TypeSubstitutor.create(fuzzyType.presentationType())
                     val substitutedConstructor = constructor.substitute(substitutor)
-                    DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderFunctionParameters(substitutedConstructor)
+                    BasicLookupElementFactory.SHORT_NAMES_RENDERER.renderFunctionParameters(substitutedConstructor)
                 }
 
                 else -> "(...)"