simplify to avoid possible inconsistencies (part of KTIJ-28926 K2: Create Function From Usage Fix)

GitOrigin-RevId: a3ccd56038e80ab9dc61c05f0d8dc2dd867c45b6

plugins/kotlin/code-insight/kotlin.code-insight.k2/src/org/jetbrains/kotlin/idea/k2/codeinsight/quickFixes/createFromUsage/CreateKotlinCallableAction.kt

@@ -38,23 +38,16 @@ internal class CreateKotlinCallableAction(
     private val myText: String,
     pointerToContainer: SmartPsiElementPointer<*>,
 ) : CreateKotlinElementAction(request, pointerToContainer), JvmGroupIntentionAction {
-    private val candidatesOfParameterNames: List<Collection<String>> = request.expectedParameters.map { it.semanticNames }
-
-    private val candidatesOfRenderedParameterTypes: List<List<String>> = renderCandidatesOfParameterTypes()
-
+    data class ParamCandidate(val names: Collection<String>, val renderedTypes: List<String>)
+    private val parameterCandidates: List<ParamCandidate> = renderCandidatesOfParameterTypes()
     private val candidatesOfRenderedReturnType: List<String> = renderCandidatesOfReturnType()
-
     private val containerClassFqName: FqName? = (getContainer() as? KtClassOrObject)?.fqName
+
     private val call: PsiElement? = when (request) {
         is CreateMethodFromKotlinUsageRequest -> request.call
         is CreateExecutableFromJavaUsageRequest<*> -> request.call
         else -> null
     }
-    private val isAbstract: Boolean? = when (request) {
-        is CreateMethodFromKotlinUsageRequest -> request.isAbstractClassOrInterface
-        is CreateExecutableFromJavaUsageRequest<*> -> false
-        else -> null
-    }
     private val isForCompanion: Boolean = (request as? CreateMethodFromKotlinUsageRequest)?.isForCompanion == true
 
     // Note that this property must be initialized after initializing above properties, because it has dependency on them.
@@ -84,8 +77,7 @@ internal class CreateKotlinCallableAction(
         if (callableDefinitionAsString != null) {
             val callableInfo = NewCallableInfo(
                 callableDefinitionAsString,
-                candidatesOfParameterNames,
-                candidatesOfRenderedParameterTypes,
+                parameterCandidates,
                 candidatesOfRenderedReturnType,
                 containerClassFqName,
                 isForCompanion
@@ -103,21 +95,23 @@ internal class CreateKotlinCallableAction(
         return element
     }
 
-    private fun renderCandidatesOfParameterTypes(): List<List<String>> {
-        val container = getContainer() ?: return List(request.expectedParameters.size) { listOf("Any") }
-        return analyze(container) {
-            request.expectedParameters.map { expectedParameter ->
-                expectedParameter.expectedTypes.map {
-                    val parameterType =
-                    if (it is ExpectedTypeWithNullability) {
-                        toKtTypeWithNullability(it, container)
+    private fun renderCandidatesOfParameterTypes(): List<ParamCandidate> {
+        request.expectedParameters.map { it.semanticNames }
+        val container = getContainer()
+        return request.expectedParameters.map { expectedParameter ->
+            val types = if (container == null) listOf("Any") else
+                analyze(container) {
+                    expectedParameter.expectedTypes.map {
+                        val parameterType =
+                            if (it is ExpectedTypeWithNullability) {
+                                toKtTypeWithNullability(it, container)
+                            } else {
+                                it.theType.toKtType(container)
+                            }
+                        parameterType?.render(renderer = WITH_TYPE_NAMES_FOR_CREATE_ELEMENTS, position = Variance.INVARIANT) ?: "Any"
                     }
-                    else{
-                        it.theType.toKtType(container)
-                    }
-                    parameterType?.render(renderer = WITH_TYPE_NAMES_FOR_CREATE_ELEMENTS, position = Variance.INVARIANT) ?: "Any"
                 }
-            }
+            ParamCandidate(expectedParameter.semanticNames, types)
         }
     }
 
@@ -149,7 +143,7 @@ internal class CreateKotlinCallableAction(
             append(" ")
 
             val (receiver, receiverTypeText) = if (request is CreateMethodFromKotlinUsageRequest) CreateKotlinCallableActionTextBuilder.renderReceiver(request) else "" to ""
-            append(renderTypeParameterDeclarations(request, receiver, receiverTypeText));
+            append(renderTypeParameterDeclarations(request, receiver, receiverTypeText))
             append(request.methodName)
             append("(")
             append(renderParameterList())
@@ -174,10 +168,10 @@ internal class CreateKotlinCallableAction(
     }
 
     private fun renderParameterList(): String {
-        assert(candidatesOfParameterNames.size == candidatesOfRenderedParameterTypes.size)
-        return candidatesOfParameterNames.mapIndexed { index, candidates ->
-            val candidatesOfTypes = candidatesOfRenderedParameterTypes[index]
-            "${candidates.firstOrNull() ?: "p$index"}: ${candidatesOfTypes.firstOrNull() ?: "Any"}"
+        return parameterCandidates.mapIndexed { index, candidate ->
+            val typeNames = candidate.renderedTypes
+            val names = candidate.names
+            "${names.firstOrNull() ?: "p$index"}: ${typeNames.firstOrNull() ?: "Any"}"
         }.joinToString()
     }
 

plugins/kotlin/code-insight/kotlin.code-insight.k2/src/org/jetbrains/kotlin/idea/k2/codeinsight/quickFixes/createFromUsage/CreateKotlinCallablePsiEditor.kt

@@ -39,8 +39,7 @@ import org.jetbrains.kotlin.psi.psiUtil.startOffset
  */
 internal data class NewCallableInfo(
     val definitionAsString: String,
-    val candidatesOfParameterNames: List<Collection<String>>,
-    val candidatesOfRenderedParameterTypes: List<List<String>>,
+    val parameterCandidates: List<CreateKotlinCallableAction.ParamCandidate>,
     val candidatesOfRenderedReturnType: List<String>,
     val containerClassFqName: FqName?,
     val isForCompanion: Boolean,
@@ -111,21 +110,12 @@ internal class CreateKotlinCallablePsiEditor(
         // Set up template for the parameter name:
         val nameIdentifier = parameter.nameIdentifier ?: return
         replaceElement(
-            nameIdentifier, ParameterNameExpression(parameterIndex, callableInfo.candidatesOfParameterNames[parameterIndex].toList())
+            nameIdentifier, ParameterNameExpression(parameterIndex, callableInfo.parameterCandidates[parameterIndex].names.toList())
         )
 
         // Set up template for the parameter type:
         val parameterTypeElement = parameter.typeReference ?: return
-        replaceElement(parameterTypeElement, ExpressionForCreateCallable(callableInfo.candidatesOfRenderedParameterTypes[parameterIndex]))
-    }
-
-    private fun KtElement.addToContainer(container: PsiElement): PsiElement = when (container) {
-        is KtClassOrObject -> {
-            val classBody = container.getOrCreateBody()
-            classBody.addBefore(this, classBody.rBrace)
-        }
-
-        else -> container.add(this)
+        replaceElement(parameterTypeElement, ExpressionForCreateCallable(callableInfo.parameterCandidates[parameterIndex].renderedTypes))
     }
 
     private fun buildTemplateListener(editor: Editor, file: KtFile, functionMarker: RangeMarker): TemplateEditingAdapter {