From 7d672cd474f94e1547bab99fdde88c1477bd827d Mon Sep 17 00:00:00 2001 From: Dmitrii Gridin Date: Sat, 17 Feb 2024 23:33:17 +0100 Subject: [PATCH] [LL FIR] drop ScopeSession parameter from LLFirModuleLazyDeclarationResolver This parameter was required for on-air analysis to avoid garbage in the original scope session. Now we can drop it, and it will be less error-prone --- .../api/fir/LLFirLazyDeclarationResolver.kt | 25 +++------ .../LLFirModuleLazyDeclarationResolver.kt | 55 +++++-------------- .../api/fir/transformers/LLFirLazyResolver.kt | 8 +-- .../transformers/LLFirLazyResolverRunner.kt | 9 ++- 4 files changed, 28 insertions(+), 69 deletions(-) diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/LLFirLazyDeclarationResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/LLFirLazyDeclarationResolver.kt index 21e328c0fc3..28ccb22e698 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/LLFirLazyDeclarationResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/LLFirLazyDeclarationResolver.kt @@ -1,11 +1,11 @@ /* - * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ package org.jetbrains.kotlin.analysis.low.level.api.fir -import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirResolvableModuleSession +import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.llFirResolvableSession import org.jetbrains.kotlin.fir.FirElementWithResolveState import org.jetbrains.kotlin.fir.ThreadSafeMutableState import org.jetbrains.kotlin.fir.declarations.FirClass @@ -19,35 +19,26 @@ internal class LLFirLazyDeclarationResolver : FirLazyDeclarationResolver() { override fun finishResolvingPhase(phase: FirResolvePhase) {} override fun lazyResolveToPhase(element: FirElementWithResolveState, toPhase: FirResolvePhase) { - val session = element.moduleData.session - if (session !is LLFirResolvableModuleSession) return - val moduleComponents = session.moduleComponents - moduleComponents.firModuleLazyDeclarationResolver.lazyResolve( + val session = element.llFirResolvableSession ?: return + session.moduleComponents.firModuleLazyDeclarationResolver.lazyResolve( target = element, - scopeSession = moduleComponents.scopeSessionProvider.getScopeSession(), toPhase = toPhase, ) } override fun lazyResolveToPhaseWithCallableMembers(clazz: FirClass, toPhase: FirResolvePhase) { val fir = clazz as? FirRegularClass ?: return - val session = fir.moduleData.session - if (session !is LLFirResolvableModuleSession) return - val moduleComponents = session.moduleComponents - moduleComponents.firModuleLazyDeclarationResolver.lazyResolveWithCallableMembers( + val session = fir.llFirResolvableSession ?: return + session.moduleComponents.firModuleLazyDeclarationResolver.lazyResolveWithCallableMembers( target = fir, - scopeSession = moduleComponents.scopeSessionProvider.getScopeSession(), toPhase = toPhase, ) } override fun lazyResolveToPhaseRecursively(element: FirElementWithResolveState, toPhase: FirResolvePhase) { - val session = element.moduleData.session - if (session !is LLFirResolvableModuleSession) return - val moduleComponents = session.moduleComponents - moduleComponents.firModuleLazyDeclarationResolver.lazyResolveRecursively( + val session = element.llFirResolvableSession ?: return + session.moduleComponents.firModuleLazyDeclarationResolver.lazyResolveRecursively( target = element, - scopeSession = moduleComponents.scopeSessionProvider.getScopeSession(), toPhase = toPhase, ) } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/LLFirModuleLazyDeclarationResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/LLFirModuleLazyDeclarationResolver.kt index cd880c9e409..dbb3e76809e 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/LLFirModuleLazyDeclarationResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/LLFirModuleLazyDeclarationResolver.kt @@ -14,7 +14,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkCanceled import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getContainingFile import org.jetbrains.kotlin.fir.FirElementWithResolveState import org.jetbrains.kotlin.fir.declarations.* -import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.transformers.FirImportResolveTransformer import org.jetbrains.kotlin.fir.utils.exceptions.withFirEntry import org.jetbrains.kotlin.fir.visitors.transformSingle @@ -28,13 +27,10 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod * * Resolution is performed under the lock specific to each declaration that is going to be resolved. */ - fun lazyResolve( - target: FirElementWithResolveState, - scopeSession: ScopeSession, - toPhase: FirResolvePhase, - ) { + fun lazyResolve(target: FirElementWithResolveState, toPhase: FirResolvePhase) { if (target.resolvePhase >= toPhase) return - lazyResolve(target, scopeSession, toPhase, LLFirResolveDesignationCollector::getDesignationToResolve) + + lazyResolve(target, toPhase, LLFirResolveDesignationCollector::getDesignationToResolve) } /** @@ -44,12 +40,8 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod * * Resolution is performed under the lock specific to each declaration that is going to be resolved. */ - fun lazyResolveWithCallableMembers( - target: FirRegularClass, - scopeSession: ScopeSession, - toPhase: FirResolvePhase, - ) { - lazyResolve(target, scopeSession, toPhase, LLFirResolveDesignationCollector::getDesignationToResolveWithCallableMembers) + fun lazyResolveWithCallableMembers(target: FirRegularClass, toPhase: FirResolvePhase) { + lazyResolve(target, toPhase, LLFirResolveDesignationCollector::getDesignationToResolveWithCallableMembers) } /** @@ -59,17 +51,12 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod * * Resolution is performed under the lock specific to each declaration that is going to be resolved. */ - fun lazyResolveRecursively( - target: FirElementWithResolveState, - scopeSession: ScopeSession, - toPhase: FirResolvePhase, - ) { - lazyResolve(target, scopeSession, toPhase, LLFirResolveDesignationCollector::getDesignationToResolveRecursively) + fun lazyResolveRecursively(target: FirElementWithResolveState, toPhase: FirResolvePhase) { + lazyResolve(target, toPhase, LLFirResolveDesignationCollector::getDesignationToResolveRecursively) } private inline fun lazyResolve( targetElement: T, - scopeSession: ScopeSession, toPhase: FirResolvePhase, resolveTarget: (T) -> LLFirResolveTarget?, ) { @@ -79,11 +66,7 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod if (toPhase == FirResolvePhase.IMPORTS) return val target = resolveTarget(targetElement) ?: return - lazyResolveTargets( - target, - scopeSession, - toPhase, - ) + lazyResolveTargets(target, toPhase) } catch (e: Exception) { handleExceptionFromResolve(e, targetElement, fromPhase, toPhase) } @@ -105,11 +88,7 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod target.firFile?.let(::resolveFileToImportsWithLock) if (toPhase == FirResolvePhase.IMPORTS) return - lazyResolveTargets( - target, - moduleComponents.scopeSessionProvider.getScopeSession(), - toPhase, - ) + lazyResolveTargets(target, toPhase) } catch (e: Exception) { handleExceptionFromResolve(e, target, toPhase) } @@ -127,28 +106,20 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod } } - private fun lazyResolveTargets( - target: LLFirResolveTarget, - scopeSession: ScopeSession, - toPhase: FirResolvePhase, - ) { + private fun lazyResolveTargets(target: LLFirResolveTarget, toPhase: FirResolvePhase) { var currentPhase = getMinResolvePhase(target).coerceAtLeast(FirResolvePhase.IMPORTS) if (currentPhase >= toPhase) return - val lockProvider = moduleComponents.globalResolveComponents.lockProvider - // to catch a contract violation for jumping phases - lockProvider.checkContractViolations(toPhase) + moduleComponents.globalResolveComponents.lockProvider.checkContractViolations(toPhase) while (currentPhase < toPhase) { currentPhase = currentPhase.next checkCanceled() LLFirLazyResolverRunner.runLazyResolverByPhase( - currentPhase, - target, - scopeSession, - lockProvider, + phase = currentPhase, + target = target, ) } } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyResolver.kt index 8efd5879439..8c6d522e703 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyResolver.kt @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.LLFirResolveTarget import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.LLFirPhaseUpdater +import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.llFirSession import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase import org.jetbrains.kotlin.fir.FirElementWithResolveState import org.jetbrains.kotlin.fir.declarations.* @@ -21,11 +22,8 @@ import org.jetbrains.kotlin.utils.exceptions.requireWithAttachment * @see LLFirTargetResolver */ internal abstract class LLFirLazyResolver(val resolverPhase: FirResolvePhase) { - fun resolve( - target: LLFirResolveTarget, - lockProvider: LLFirLockProvider, - scopeSession: ScopeSession, - ) { + fun resolve(target: LLFirResolveTarget, lockProvider: LLFirLockProvider) { + val scopeSession = target.target.llFirSession.getScopeSession() val resolver = createTargetResolver(target, lockProvider, scopeSession) requireWithAttachment( resolverPhase == resolver.resolverPhase, diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyResolverRunner.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyResolverRunner.kt index c83a670356c..9402ebe16fb 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyResolverRunner.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyResolverRunner.kt @@ -5,22 +5,21 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers +import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirGlobalResolveComponents import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.LLFirResolveTarget -import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.session import org.jetbrains.kotlin.fir.declarations.FirResolvePhase -import org.jetbrains.kotlin.fir.resolve.ScopeSession internal object LLFirLazyResolverRunner { fun runLazyResolverByPhase( phase: FirResolvePhase, target: LLFirResolveTarget, - scopeSession: ScopeSession, - lockProvider: LLFirLockProvider, ) { val lazyResolver = LLFirLazyPhaseResolverByPhase.getByPhase(phase) + val lockProvider = LLFirGlobalResolveComponents.getInstance(target.session).lockProvider lockProvider.withGlobalLock { lockProvider.withGlobalPhaseLock(phase) { - lazyResolver.resolve(target, lockProvider, scopeSession) + lazyResolver.resolve(target, lockProvider) } }