K2: Get rid of using inference session for augmented assignments

Instead, use specific resolution mode handled by call completer.
Mostly, it's done for simplification of PCLA implementation because
otherwise we would need to track how PCLA inference session and the
one for augmented should be combined.

But just independently of this, not using inference session here,
it looks just simpler.

^KT-59791 In Progress

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolutionMode.kt

@@ -11,13 +11,20 @@ import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 
-sealed class ResolutionMode(val forceFullCompletion: Boolean) {
+sealed class ResolutionMode(
-    sealed class ContextDependent : ResolutionMode(forceFullCompletion = false) {
+    val forceFullCompletion: Boolean,
+    // Only true AugmentedAssignmentCallOption, don't run an even slightest form of completion
+    val skipEvenPartialCompletion: Boolean = false,
+) {
+    sealed class ContextDependent(
+        skipCompletion: Boolean = false,
+    ) : ResolutionMode(forceFullCompletion = false, skipCompletion) {
         companion object Default : ContextDependent() {
             override fun toString(): String = "ContextDependent"
         }
 
         data object Delegate : ContextDependent()
+        data object AugmentedAssignmentCallOption : ContextDependent(skipCompletion = true)
     }
 
     data object ContextIndependent : ResolutionMode(forceFullCompletion = true)

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt

@@ -75,6 +75,8 @@ class FirCallCompleter(
             resolutionMode,
         )
 
+        if (resolutionMode.skipEvenPartialCompletion) return call
+
         val completionMode = candidate.computeCompletionMode(
             session.inferenceComponents, resolutionMode, initialType
         ).let {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt

@@ -418,6 +418,7 @@ open class FirExpressionsResolveTransformer(transformer: FirAbstractBodyResolveT
             functionCall.transformAnnotations(transformer, data)
             functionCall.replaceLambdaArgumentInvocationKinds(session)
             functionCall.transformTypeArguments(transformer, ResolutionMode.ContextIndependent)
+            val resolvingAugmentedAssignment = data == ResolutionMode.ContextDependent.AugmentedAssignmentCallOption
             val withTransformedArguments = if (!resolvingAugmentedAssignment) {
                 dataFlowAnalyzer.enterCallArguments(functionCall, functionCall.arguments)
                 // In provideDelegate mode the explicitReceiver is already resolved
@@ -599,17 +600,13 @@ open class FirExpressionsResolveTransformer(transformer: FirAbstractBodyResolveT
 
         // x.plusAssign(y)
         val assignOperatorCall = generator.createAssignOperatorCall(KtFakeSourceElementKind.DesugaredCompoundAssignment)
-        val resolvedAssignCall = resolveCandidateForAssignmentOperatorCall {
+        val resolvedAssignCall = assignOperatorCall.resolveCandidateForAssignmentOperatorCall()
-            assignOperatorCall.transformSingle(this, ResolutionMode.ContextDependent)
-        }
         val assignCallReference = resolvedAssignCall.calleeReference as? FirNamedReferenceWithCandidate
         val assignIsSuccessful = assignCallReference?.isError == false
 
         // x = x + y
         val simpleOperatorCall = generator.createSimpleOperatorCall(KtFakeSourceElementKind.DesugaredCompoundAssignment)
-        val resolvedOperatorCall = resolveCandidateForAssignmentOperatorCall {
+        val resolvedOperatorCall = simpleOperatorCall.resolveCandidateForAssignmentOperatorCall()
-            simpleOperatorCall.transformSingle(this, ResolutionMode.ContextDependent)
-        }
         val operatorCallReference = resolvedOperatorCall.calleeReference as? FirNamedReferenceWithCandidate
         val operatorIsSuccessful = operatorCallReference?.isError == false
 
@@ -822,22 +819,12 @@ open class FirExpressionsResolveTransformer(transformer: FirAbstractBodyResolveT
         return equalityOperatorCall
     }
 
-    private var resolvingAugmentedAssignment: Boolean = false
+    private fun FirFunctionCall.resolveCandidateForAssignmentOperatorCall(): FirFunctionCall {
-
+        return transformFunctionCallInternal(
-    private inline fun <T> resolveCandidateForAssignmentOperatorCall(block: () -> T): T {
+            this,
-        assert(!resolvingAugmentedAssignment)
+            ResolutionMode.ContextDependent.AugmentedAssignmentCallOption,
-        resolvingAugmentedAssignment = true
+            provideDelegate = false
-        return try {
+        ) as FirFunctionCall
-            context.withInferenceSession(InferenceSessionForAssignmentOperatorCall) {
-                block()
-            }
-        } finally {
-            resolvingAugmentedAssignment = false
-        }
-    }
-
-    private object InferenceSessionForAssignmentOperatorCall : FirStubInferenceSession() {
-        override fun <T> shouldRunCompletion(call: T): Boolean where T : FirStatement, T : FirResolvable = false
     }
 
     private fun FirTypeRef.withTypeArgumentsForBareType(argument: FirExpression, operation: FirOperation): FirTypeRef {
@@ -1424,9 +1411,7 @@ open class FirExpressionsResolveTransformer(transformer: FirAbstractBodyResolveT
 
         // a.get(b).plusAssign(c)
         val assignOperatorCall = generator.createAssignOperatorCall(operation.toArrayAugmentedAssignSourceKind())
-        val resolvedAssignCall = resolveCandidateForAssignmentOperatorCall {
+        val resolvedAssignCall = assignOperatorCall.resolveCandidateForAssignmentOperatorCall()
-            assignOperatorCall.transformSingle(this, ResolutionMode.ContextDependent)
-        }
         val assignCallReference = resolvedAssignCall.calleeReference as? FirNamedReferenceWithCandidate
         val assignIsSuccessful = assignCallReference?.isError == false
 
@@ -1628,9 +1613,7 @@ open class FirExpressionsResolveTransformer(transformer: FirAbstractBodyResolveT
         )
 
         val operatorCall = generator.createSimpleOperatorCall(augmentedArraySetCall.operation.toArrayAugmentedAssignSourceKind())
-        val resolvedOperatorCall = resolveCandidateForAssignmentOperatorCall {
+        val resolvedOperatorCall = operatorCall.resolveCandidateForAssignmentOperatorCall()
-            operatorCall.transformSingle(this, ResolutionMode.ContextDependent)
-        }
 
         val setCall = GeneratorOfPlusAssignCalls.createFunctionCall(
             OperatorNameConventions.SET,
@@ -1641,9 +1624,7 @@ open class FirExpressionsResolveTransformer(transformer: FirAbstractBodyResolveT
             *indicesQualifiedAccess.toTypedArray(), // indices
             resolvedOperatorCall // a.get(b).plus(c)
         )
-        val resolvedSetCall = resolveCandidateForAssignmentOperatorCall {
+        val resolvedSetCall = setCall.resolveCandidateForAssignmentOperatorCall()
-            setCall.transformSingle(this, ResolutionMode.ContextDependent)
-        }
 
         return AugmentedArraySetAsGetSetCallDesugaringInfo(
             augmentedArraySetCall,