From a0120d28ccf5d7335426625b66b30d6df0f66f3f Mon Sep 17 00:00:00 2001 From: Dmitrii Gridin Date: Wed, 13 Mar 2024 17:52:23 +0100 Subject: [PATCH] [FIR] FirResolvePhase: introduce `isItAllowedToCallLazyResolveToTheSamePhase` To have explicitly declared contracts --- .../LLFirAbstractBodyTargetResolver.kt | 3 +-- .../LLFirImplicitTypesLazyResolver.kt | 1 - .../fir/transformers/LLFirTargetResolver.kt | 3 ++- .../fir/declarations/FirResolvePhase.kt | 24 +++++++++++++++---- 4 files changed, 23 insertions(+), 8 deletions(-) diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAbstractBodyTargetResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAbstractBodyTargetResolver.kt index 8712af684a4..3c24a48d3fc 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAbstractBodyTargetResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAbstractBodyTargetResolver.kt @@ -19,8 +19,7 @@ internal sealed class LLFirAbstractBodyTargetResolver( resolveTarget: LLFirResolveTarget, resolvePhase: FirResolvePhase, protected val llImplicitBodyResolveComputationSession: LLImplicitBodyResolveComputationSession = LLImplicitBodyResolveComputationSession(), - requiresJumpingLock: Boolean = false, -) : LLFirTargetResolver(resolveTarget, resolvePhase, requiresJumpingLock) { +) : LLFirTargetResolver(resolveTarget, resolvePhase) { protected fun createReturnTypeCalculator(): LLFirReturnTypeCalculatorWithJump = LLFirReturnTypeCalculatorWithJump( resolveTargetScopeSession, llImplicitBodyResolveComputationSession, diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirImplicitTypesLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirImplicitTypesLazyResolver.kt index d3eff23f4dc..2c4bcdd5007 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirImplicitTypesLazyResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirImplicitTypesLazyResolver.kt @@ -143,7 +143,6 @@ internal class LLFirImplicitBodyTargetResolver( target, FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, llImplicitBodyResolveComputationSession = llImplicitBodyResolveComputationSessionParameter ?: LLImplicitBodyResolveComputationSession(), - requiresJumpingLock = true, ) { override val transformer = object : FirImplicitAwareBodyResolveTransformer( resolveTargetSession, diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirTargetResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirTargetResolver.kt index 91a5e842388..a3a888f6e4d 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirTargetResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirTargetResolver.kt @@ -27,6 +27,7 @@ import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.declarations.FirScript import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction import org.jetbrains.kotlin.fir.declarations.destructuringDeclarationContainerVariable +import org.jetbrains.kotlin.fir.declarations.isItAllowedToCallLazyResolveToTheSamePhase import org.jetbrains.kotlin.fir.declarations.utils.componentFunctionSymbol import org.jetbrains.kotlin.fir.declarations.utils.correspondingValueParameterFromPrimaryConstructor import org.jetbrains.kotlin.fir.declarations.utils.fromPrimaryConstructor @@ -77,11 +78,11 @@ import org.jetbrains.kotlin.utils.exceptions.requireWithAttachment internal sealed class LLFirTargetResolver( protected val resolveTarget: LLFirResolveTarget, val resolverPhase: FirResolvePhase, - private val requiresJumpingLock: Boolean = false, ) : LLFirResolveTargetVisitor { val resolveTargetSession: LLFirSession get() = resolveTarget.session val resolveTargetScopeSession: ScopeSession get() = resolveTargetSession.getScopeSession() private val lockProvider: LLFirLockProvider get() = LLFirGlobalResolveComponents.getInstance(resolveTargetSession).lockProvider + private val requiresJumpingLock: Boolean get() = resolverPhase.isItAllowedToCallLazyResolveToTheSamePhase private val _containingDeclarations = mutableListOf() diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirResolvePhase.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirResolvePhase.kt index 020191d4559..893feea1f91 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirResolvePhase.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirResolvePhase.kt @@ -238,18 +238,34 @@ val FirResolvePhase.isBodyResolve: Boolean * @see FirResolvePhase * @see org.jetbrains.kotlin.fir.symbols.FirLazyDeclarationResolver * @see org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase + * @see isItAllowedToCallLazyResolveToTheSamePhase */ fun FirResolvePhase.isItAllowedToCallLazyResolveTo(requestedPhase: FirResolvePhase): Boolean = when { // It is fine to call lazy resolution for all phases less than our this > requestedPhase -> true // It is legal only in specific cases - this == requestedPhase -> when (requestedPhase) { + this == requestedPhase -> isItAllowedToCallLazyResolveToTheSamePhase + + else -> false +} + +/** + * Note: not all ***jumping phases*** can be [isItAllowedToCallLazyResolveToTheSamePhase], + * but all [isItAllowedToCallLazyResolveToTheSamePhase] phases are ***jumping phases*** + * due to the implementation details. + * + * @return **true** if it is allowed to call [lazyResolveToPhase][org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase] + * into the same phase + * + * @see org.jetbrains.kotlin.fir.symbols.FirLazyDeclarationResolver + * @see org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase + */ +val FirResolvePhase.isItAllowedToCallLazyResolveToTheSamePhase: Boolean + get() = when (this) { // The resolver can jump into Java initializer during this phase, // which can jump into the Kotlin world again, and we cannot provide the initial context FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE -> true + else -> false } - - else -> false -} \ No newline at end of file