Revert "cleanup: get rid of mutable stuff (part of KTIJ-26893 K2: Create*FromUsageFix fix)"

This reverts commit c9d8c5845babc20e58a38f0dc2d83363ff7378d3.

GitOrigin-RevId: 1fd74bfc8c347e5ed633f662f2e19978d25c7d64

java/java-analysis-api/src/com/intellij/lang/jvm/actions/ExpectedParameter.java

@@ -13,7 +13,7 @@ public interface ExpectedParameter {
   List<ExpectedType> getExpectedTypes();
 
   /**
-   * For example, for unresolved call in Java {@code a.foo(bars)} this method will return 'bars' string,
+   * For example for unresolved call in Java {@code a.foo(bars)} this method will return 'bars' string,
    * which then will be used to suggest parameter names
    * taking code style parameter prefix into consideration as well as its type.
    */

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

@@ -17,9 +17,12 @@ internal abstract class CreateExecutableFromKotlinUsageRequest<out T : KtCallEle
     call: T,
     private val modifiers: Collection<JvmModifier>,
 ) : CreateExecutableRequest {
-    private val project = call.project
+
+    private val psiManager = call.manager
+    private val project = psiManager.project
     private val callPointer: SmartPsiElementPointer<T> = call.createSmartPointer()
-    private val expectedParameterInfo: MutableList<ParameterInfo> = mutableListOf()
+
+    private val expectedParameterInfo = mutableListOf<ParameterInfo>()
 
     init {
         analyze(call) {
@@ -42,11 +45,11 @@ internal abstract class CreateExecutableFromKotlinUsageRequest<out T : KtCallEle
 
     override fun getExpectedParameters(): List<ExpectedParameter> = expectedParameterInfo.map { parameterInfo ->
         object : ExpectedParameter {
-            override fun getExpectedTypes(): List<ExpectedType> =
-                listOf(parameterInfo.type?.let { ExpectedKotlinType.createExpectedKotlinType(it) }
+            override fun getExpectedTypes(): MutableList<ExpectedType> =
+                mutableListOf(parameterInfo.type?.let { ExpectedKotlinType.createExpectedKotlinType(it) }
                                   ?: ExpectedKotlinType.INVALID_TYPE)
 
-            override fun getSemanticNames(): Collection<String> = parameterInfo.nameCandidates
+            override fun getSemanticNames(): MutableCollection<String> = parameterInfo.nameCandidates
         }
     }
 }

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

@@ -34,7 +34,7 @@ internal class CreateKotlinCallableAction(
     private val myText: String,
     private val pointerToContainer: SmartPsiElementPointer<*>,
 ) : CreateKotlinElementAction(request, pointerToContainer), JvmGroupIntentionAction {
-    private val candidatesOfParameterNames: List<Collection<String>> = request.expectedParameters.map { it.semanticNames }
+    private val candidatesOfParameterNames: List<MutableCollection<String>> = request.expectedParameters.map { it.semanticNames }
 
     private val candidatesOfRenderedParameterTypes: List<List<String>> = renderCandidatesOfParameterTypes()
 

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

@@ -34,7 +34,7 @@ import org.jetbrains.kotlin.psi.psiUtil.startOffset
  */
 internal data class NewCallableInfo(
     val definitionAsString: String,
-    val candidatesOfParameterNames: List<Collection<String>>,
+    val candidatesOfParameterNames: List<MutableCollection<String>>,
     val candidatesOfRenderedParameterTypes: List<List<String>>,
     val candidatesOfRenderedReturnType: List<String>,
     val containerClassFqName: FqName?,

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

@@ -68,7 +68,9 @@ context (KtAnalysisSession)
 internal fun KtType.convertToClass(): KtClass? = expandedClassSymbol?.psi as? KtClass
 
 context (KtAnalysisSession)
-internal fun KtElement.getExpectedJvmType(): JvmType? = getExpectedType()?.convertToJvmType(this)
+internal fun KtElement.getExpectedJvmType(): JvmType? = getExpectedType()?.let { expectedType ->
+    expectedType.convertToJvmType(this)
+}
 
 context (KtAnalysisSession)
 private fun KtType.convertToJvmType(useSitePosition: PsiElement): JvmType? = asPsiType(useSitePosition, allowErrorTypes = false)
@@ -80,16 +82,16 @@ internal fun KtExpression.getClassOfExpressionType(): PsiElement? = when (val sy
     else -> getKtType()?.expandedClassSymbol
 }?.psi
 
-internal data class ParameterInfo(val nameCandidates: List<String>, val type: JvmType?)
+internal data class ParameterInfo(val nameCandidates: MutableList<String>, val type: JvmType?)
 
 context (KtAnalysisSession)
 internal fun KtValueArgument.getExpectedParameterInfo(parameterIndex: Int): ParameterInfo {
     val parameterNameAsString = getArgumentName()?.asName?.asString()
     val argumentExpression = getArgumentExpression()
     val expectedArgumentType = argumentExpression?.getKtType()
-    val parameterNames = parameterNameAsString?.let { sequenceOf(it) } ?: expectedArgumentType?.let { NAME_SUGGESTER.suggestTypeNames(it) }
+    val parameterName = parameterNameAsString?.let { sequenceOf(it) } ?: expectedArgumentType?.let { NAME_SUGGESTER.suggestTypeNames(it) }
     val parameterType = expectedArgumentType?.convertToJvmType(argumentExpression)
-    return ParameterInfo(parameterNames?.toList() ?: listOf("p$parameterIndex"), parameterType)
+    return ParameterInfo(parameterName?.toMutableList() ?: mutableListOf("p$parameterIndex"), parameterType)
 }
 
 context (KtAnalysisSession)
@@ -143,7 +145,7 @@ internal fun JvmType.toKtType(useSitePosition: PsiElement): KtType? = when (this
         try {
             asKtType(useSitePosition)
         } catch (e: Error) {
-            // Some requests from Java side do not have a type. For example, in `var foo = dep.<caret>foo();`, we cannot guess
+            // Some requests from Java side does not have a type. For example, in `var foo = dep.<caret>foo();`, we cannot guess
             // the type of `foo()`. In this case, the request passes "PsiType:null" whose name is "null" as a text. The analysis
             // API cannot get a KtType from this weird type. We return `Any?` for this case.
             builtinTypes.NULLABLE_ANY

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

@@ -15,7 +15,13 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtClassOrObjectSymbol
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.lexer.KtTokens
-import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.KtCallExpression
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtEnumEntry
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
 import org.jetbrains.kotlin.psi.psiUtil.getReceiverExpression
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
@@ -59,10 +65,11 @@ internal fun buildRequests(callExpression: KtCallExpression): Map<JvmClass, Crea
         // TODO: Check whether this class or file can be edited (Use `canRefactor()`).
         val defaultClassForReceiverOrFile = calleeExpression.getReceiverOrContainerClass()
         defaultClassForReceiverOrFile?.let {
+            val modifiers = mutableSetOf<JvmModifier>()
             val packageNameOfReceiver = calleeExpression.getReceiverOrContainerClassPackageName()
-            val modifiers = if (packageNameOfReceiver != null && packageNameOfReceiver == callExpression.containingKtFile.packageFqName)
-              listOf(JvmModifier.PUBLIC)
-            else listOf()
+            if (packageNameOfReceiver != null && packageNameOfReceiver == callExpression.containingKtFile.packageFqName) {
+                modifiers.add(JvmModifier.PUBLIC)
+            }
             requests[it] = CreateMethodFromKotlinUsageRequest(callExpression, modifiers, receiverExpression)
         }
     }
@@ -132,7 +139,7 @@ private fun LinkedHashMap<JvmClass, CreateMethodRequest>.registerCreateAbstractC
 ) {
     val jvmClassWrapper = JvmClassWrapperForKtClass(abstractContainerClass)
     this[jvmClassWrapper] = CreateMethodFromKotlinUsageRequest(
-        callExpression, setOf(), receiverExpression, isAbstractClassOrInterface = true
+        callExpression, mutableSetOf(), receiverExpression, isAbstractClassOrInterface = true
     )
 }
 
@@ -141,5 +148,5 @@ private fun LinkedHashMap<JvmClass, CreateMethodRequest>.registerCreateExtension
 ) {
     val containerClassForExtension = calleeExpression.getNonStrictParentOfType<KtClassOrObject>() ?: calleeExpression.containingKtFile
     val jvmClassWrapper = JvmClassWrapperForKtClass(containerClassForExtension)
-    this[jvmClassWrapper] = CreateMethodFromKotlinUsageRequest(callExpression, setOf(), receiverExpression, isExtension = true)
+    this[jvmClassWrapper] = CreateMethodFromKotlinUsageRequest(callExpression, mutableSetOf(), receiverExpression, isExtension = true)
 }