Callable Builder: Do not skip unused type parameters

idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt

@@ -101,7 +101,7 @@ class TypeCandidate(val theType: JetType, scope: JetScope? = null) {
     override fun toString() = theType.toString()
 }
 
-class RenderedTypeParameter(
+data class RenderedTypeParameter(
         val typeParameter: TypeParameterDescriptor,
         val fake: Boolean,
         val text: String
@@ -216,6 +216,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
         val receiverClassDescriptor: ClassDescriptor?
         val typeParameterNameMap: Map<TypeParameterDescriptor, String>
         val receiverTypeCandidate: TypeCandidate?
+        val mandatoryTypeParametersAsCandidates: List<TypeCandidate>
         val substitutions: List<JetTypeSubstitution>
 
         {
@@ -269,9 +270,11 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
                         .subtract(substitutionMap.keySet())
                 fakeFunction = createFakeFunctionDescriptor(scope, typeArgumentsForFakeFunction.size)
                 collectSubstitutionsForCallableTypeParameters(fakeFunction!!, typeArgumentsForFakeFunction, substitutionMap)
+                mandatoryTypeParametersAsCandidates = typeArgumentsForFakeFunction.map { TypeCandidate(substitutionMap[it], scope) }
             }
             else {
                 fakeFunction = null
+                mandatoryTypeParametersAsCandidates = Collections.emptyList()
             }
             substitutions = substitutionMap.map { JetTypeSubstitution(it.key, it.value) }
 
@@ -294,6 +297,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
                 renderTypeCandidates(callableInfo.returnTypeInfo, typeParameterNameMap, fakeFunction)
             }
             receiverTypeCandidate?.render(typeParameterNameMap, fakeFunction)
+            mandatoryTypeParametersAsCandidates.forEach { it.render(typeParameterNameMap, fakeFunction) }
         }
 
         private fun collectSubstitutionsForReceiverTypeParameters(
@@ -454,10 +458,8 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
         private fun getTypeParameterRenames(scope: JetScope): Map<TypeParameterDescriptor, String> {
             val allTypeParametersNotInScope = LinkedHashSet<TypeParameterDescriptor>()
 
-            allTypeParametersNotInScope.addAll(receiverTypeCandidate?.typeParameters?.toList() ?: Collections.emptyList())
+            mandatoryTypeParametersAsCandidates.stream()
-
+                    .plus(callableInfo.parameterInfos.stream().flatMap { typeCandidates[it.typeInfo]!!.stream() })
-            callableInfo.parameterInfos.stream()
-                    .flatMap { typeCandidates[it.typeInfo]!!.stream() }
                     .flatMap { it.typeParameters.stream() }
                     .toCollection(allTypeParametersNotInScope)
 
@@ -584,7 +586,10 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
 
         private fun setupTypeParameterListTemplate(builder: TemplateBuilderImpl, declaration: JetCallableDeclaration): TypeParameterListExpression {
             val typeParameterMap = HashMap<String, List<RenderedTypeParameter>>()
-            val receiverTypeParameterNames = receiverTypeCandidate?.let { it.renderedTypeParameters!! } ?: Collections.emptyList()
+
+            val mandatoryTypeParameters = ArrayList<RenderedTypeParameter>()
+            //receiverTypeCandidate?.let { mandatoryTypeParameters.addAll(it.renderedTypeParameters!!) }
+            mandatoryTypeParametersAsCandidates.stream().flatMapTo(mandatoryTypeParameters) { it.renderedTypeParameters!!.stream() }
 
             callableInfo.parameterInfos.stream().flatMap { typeCandidates[it.typeInfo]!!.stream() }.forEach {
                 typeParameterMap[it.renderedType!!] = it.renderedTypeParameters!!
@@ -597,7 +602,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
             }
             // ((3, 3) is after "fun")
             builder.replaceElement(declaration, TextRange.create(3, 3), TYPE_PARAMETER_LIST_VARIABLE_NAME, null, false)
-            return TypeParameterListExpression(receiverTypeParameterNames, typeParameterMap)
+            return TypeParameterListExpression(mandatoryTypeParameters, typeParameterMap)
         }
 
         private fun setupParameterTypeTemplates(builder: TemplateBuilder, parameterList: List<JetParameter>): List<TypeExpression> {

idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/callableBuilder/templateExpressions.kt

@@ -99,7 +99,7 @@ private class TypeExpression(public val typeCandidates: List<TypeCandidate>) : E
 /**
  * A sort-of dummy <code>Expression</code> for parameter lists, to allow us to update the parameter list as the user makes selections.
  */
-private class TypeParameterListExpression(private val typeParameterNamesFromReceiverType: List<RenderedTypeParameter>,
+private class TypeParameterListExpression(private val mandatoryTypeParameters: List<RenderedTypeParameter>,
                                           private val parameterTypeToTypeParameterNamesMap: Map<String, List<RenderedTypeParameter>>) : Expression() {
     public var currentTypeParameters: List<TypeParameterDescriptor> = Collections.emptyList()
         private set
@@ -117,7 +117,7 @@ private class TypeParameterListExpression(private val typeParameterNamesFromRece
         val parameters = callable.getValueParameterList()?.getParameters() ?: Collections.emptyList<JetParameter>()
 
         val renderedTypeParameters = LinkedHashSet<RenderedTypeParameter>()
-        renderedTypeParameters.addAll(typeParameterNamesFromReceiverType)
+        renderedTypeParameters.addAll(mandatoryTypeParameters)
         for (parameter in parameters) {
             val parameterTypeRef = parameter.getTypeReference()
             if (parameterTypeRef != null) {

idea/testData/quickfix/createFromUsage/createFunction/call/typeArguments/afterNoReceiverExtraArgs.kt

@@ -1,9 +1,9 @@
 // "Create function 'foo'" "true"
 
 fun test(): Int {
-    return foo<String, Int>(2, "2")
+    return foo<String, Int, Boolean>(2, "2")
 }
 
-fun <T, T1> foo(arg: T1, arg1: T): T1 {
+fun <T, T1, T2> foo(arg: T1, arg1: T): T1 {
     throw UnsupportedOperationException("not implemented") //To change body of created functions use File | Settings | File Templates.
 }