From ca9372cfa0371121bed6aa05d9e698ce4145503b Mon Sep 17 00:00:00 2001 From: "Denis.Zharkov" Date: Wed, 20 Dec 2023 11:02:37 +0100 Subject: [PATCH] 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 --- .../kotlin/fir/resolve/ResolutionMode.kt | 11 ++++- .../fir/resolve/inference/FirCallCompleter.kt | 2 + .../FirExpressionsResolveTransformer.kt | 43 ++++++------------- 3 files changed, 23 insertions(+), 33 deletions(-) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolutionMode.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolutionMode.kt index ecdb7c11f80..8af883c6578 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolutionMode.kt +++ b/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 ContextDependent : ResolutionMode(forceFullCompletion = false) { +sealed class ResolutionMode( + 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) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt index 4a7a58f1455..7b2489d04ee 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/FirCallCompleter.kt +++ b/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 { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt index 30763201224..9ad08bb2c43 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt +++ b/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 { - assignOperatorCall.transformSingle(this, ResolutionMode.ContextDependent) - } + val resolvedAssignCall = assignOperatorCall.resolveCandidateForAssignmentOperatorCall() val assignCallReference = resolvedAssignCall.calleeReference as? FirNamedReferenceWithCandidate val assignIsSuccessful = assignCallReference?.isError == false // x = x + y val simpleOperatorCall = generator.createSimpleOperatorCall(KtFakeSourceElementKind.DesugaredCompoundAssignment) - val resolvedOperatorCall = resolveCandidateForAssignmentOperatorCall { - simpleOperatorCall.transformSingle(this, ResolutionMode.ContextDependent) - } + val resolvedOperatorCall = simpleOperatorCall.resolveCandidateForAssignmentOperatorCall() 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 inline fun resolveCandidateForAssignmentOperatorCall(block: () -> T): T { - assert(!resolvingAugmentedAssignment) - resolvingAugmentedAssignment = true - return try { - context.withInferenceSession(InferenceSessionForAssignmentOperatorCall) { - block() - } - } finally { - resolvingAugmentedAssignment = false - } - } - - private object InferenceSessionForAssignmentOperatorCall : FirStubInferenceSession() { - override fun shouldRunCompletion(call: T): Boolean where T : FirStatement, T : FirResolvable = false + private fun FirFunctionCall.resolveCandidateForAssignmentOperatorCall(): FirFunctionCall { + return transformFunctionCallInternal( + this, + ResolutionMode.ContextDependent.AugmentedAssignmentCallOption, + provideDelegate = false + ) as FirFunctionCall } 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 { - assignOperatorCall.transformSingle(this, ResolutionMode.ContextDependent) - } + val resolvedAssignCall = assignOperatorCall.resolveCandidateForAssignmentOperatorCall() 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 { - operatorCall.transformSingle(this, ResolutionMode.ContextDependent) - } + val resolvedOperatorCall = operatorCall.resolveCandidateForAssignmentOperatorCall() 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 { - setCall.transformSingle(this, ResolutionMode.ContextDependent) - } + val resolvedSetCall = setCall.resolveCandidateForAssignmentOperatorCall() return AugmentedArraySetAsGetSetCallDesugaringInfo( augmentedArraySetCall,