From 14082f6924f5e076423a2bc4c15ace8593873020 Mon Sep 17 00:00:00 2001 From: Dmitrii Gridin Date: Thu, 21 Dec 2023 00:07:07 +0100 Subject: [PATCH] [LL FIR] LLFirLazyResolver: drop redundant FirSession argument LLFirSession should be received from LLFirResolveTarget to avoid potential wrong sessions ScopeSession cannot be dropped yet as we should be able to use another session during on-air resolution to avoid garbage in the original one ^KT-63547 --- .../level/api/fir/api/targets/targetUtils.kt | 3 +++ .../LLFirAnnotationArgumentsLazyResolver.kt | 6 ++---- .../fir/transformers/LLFirBodyLazyResolver.kt | 6 ++---- .../LLFirCompilerAnnotationsLazyResolver.kt | 8 ++------ .../LLFirContractsLazyResolver.kt | 7 ++----- .../LLFirExpectActualMatcherLazyResolver.kt | 9 +++------ ...FirGeneratedCompanionObjectLazyResolver.kt | 7 ++----- .../LLFirImplicitTypesLazyResolver.kt | 7 ++----- .../api/fir/transformers/LLFirLazyResolver.kt | 6 +----- .../transformers/LLFirLazyResolverRunner.kt | 3 +-- .../LLFirReturnTypeCalculatorWithJump.kt | 1 - .../LLFirSealedClassInheritorsLazyResolver.kt | 2 -- .../transformers/LLFirStatusLazyResolver.kt | 9 +++------ .../LLFirSupertypeLazyResolver.kt | 20 +++++++++---------- .../fir/transformers/LLFirTargetResolver.kt | 3 +++ .../fir/transformers/LLFirTypeLazyResolver.kt | 10 ++++------ 16 files changed, 39 insertions(+), 68 deletions(-) diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/targets/targetUtils.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/targets/targetUtils.kt index 927c2fc3c9a..df9d1ce0db4 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/targets/targetUtils.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/targets/targetUtils.kt @@ -6,6 +6,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile +import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSession import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.llFirResolvableSession import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.llFirSession import org.jetbrains.kotlin.fir.FirElementWithResolveState @@ -32,3 +33,5 @@ internal fun LLFirResolveTarget.resolve(phase: FirResolvePhase) { val lazyDeclarationResolver = session.moduleComponents.firModuleLazyDeclarationResolver lazyDeclarationResolver.lazyResolveTarget(this, phase, towerDataContextCollector = null) } + +internal val LLFirResolveTarget.session: LLFirSession get() = target.llFirSession \ No newline at end of file diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAnnotationArgumentsLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAnnotationArgumentsLazyResolver.kt index 59bb8f3193d..f6aee1c1caf 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAnnotationArgumentsLazyResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirAnnotationArgumentsLazyResolver.kt @@ -35,11 +35,10 @@ internal object LLFirAnnotationArgumentsLazyResolver : LLFirLazyResolver(FirReso override fun resolve( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - session: FirSession, scopeSession: ScopeSession, towerDataContextCollector: FirResolveContextCollector?, ) { - val resolver = LLFirAnnotationArgumentsTargetResolver(target, lockProvider, session, scopeSession, towerDataContextCollector) + val resolver = LLFirAnnotationArgumentsTargetResolver(target, lockProvider, scopeSession, towerDataContextCollector) resolver.resolveDesignation() } @@ -83,7 +82,6 @@ internal object LLFirAnnotationArgumentsLazyResolver : LLFirLazyResolver(FirReso private class LLFirAnnotationArgumentsTargetResolver( resolveTarget: LLFirResolveTarget, lockProvider: LLFirLockProvider, - session: FirSession, scopeSession: ScopeSession, firResolveContextCollector: FirResolveContextCollector?, ) : LLFirAbstractBodyTargetResolver( @@ -105,7 +103,7 @@ private class LLFirAnnotationArgumentsTargetResolver( * @see org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirAbstractBodyResolveTransformerDispatcher.transformForeignAnnotationCall */ override val transformer = FirAnnotationArgumentsTransformer( - session, + resolveTargetSession, scopeSession, resolverPhase, returnTypeCalculator = createReturnTypeCalculator(firResolveContextCollector = firResolveContextCollector), diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirBodyLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirBodyLazyResolver.kt index beeede088bc..722dcdc1e16 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirBodyLazyResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirBodyLazyResolver.kt @@ -59,11 +59,10 @@ internal object LLFirBodyLazyResolver : LLFirLazyResolver(FirResolvePhase.BODY_R override fun resolve( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - session: FirSession, scopeSession: ScopeSession, towerDataContextCollector: FirResolveContextCollector?, ) { - val resolver = LLFirBodyTargetResolver(target, lockProvider, session, scopeSession, towerDataContextCollector) + val resolver = LLFirBodyTargetResolver(target, lockProvider, scopeSession, towerDataContextCollector) resolver.resolveDesignation() } @@ -84,7 +83,6 @@ internal object LLFirBodyLazyResolver : LLFirLazyResolver(FirResolvePhase.BODY_R private class LLFirBodyTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - session: FirSession, scopeSession: ScopeSession, firResolveContextCollector: FirResolveContextCollector?, ) : LLFirAbstractBodyTargetResolver( @@ -94,7 +92,7 @@ private class LLFirBodyTargetResolver( FirResolvePhase.BODY_RESOLVE, ) { override val transformer = object : FirBodyResolveTransformer( - session, + resolveTargetSession, phase = resolverPhase, implicitTypeOnly = false, scopeSession = scopeSession, diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirCompilerAnnotationsLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirCompilerAnnotationsLazyResolver.kt index f2539f5c5ba..72c39b51b9f 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirCompilerAnnotationsLazyResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirCompilerAnnotationsLazyResolver.kt @@ -19,7 +19,6 @@ import org.jetbrains.kotlin.analysis.utils.errors.requireIsInstance import org.jetbrains.kotlin.fir.FirAnnotationContainer import org.jetbrains.kotlin.fir.FirElementWithResolveState import org.jetbrains.kotlin.fir.FirFileAnnotationsContainer -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.caches.firCachesFactory import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.annotationPlatformSupport @@ -39,11 +38,10 @@ internal object LLFirCompilerAnnotationsLazyResolver : LLFirLazyResolver(FirReso override fun resolve( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - session: FirSession, scopeSession: ScopeSession, towerDataContextCollector: FirResolveContextCollector?, ) { - val resolver = LLFirCompilerRequiredAnnotationsTargetResolver(target, lockProvider, session, scopeSession) + val resolver = LLFirCompilerRequiredAnnotationsTargetResolver(target, lockProvider, scopeSession) resolver.resolveDesignation() } @@ -58,7 +56,6 @@ internal object LLFirCompilerAnnotationsLazyResolver : LLFirLazyResolver(FirReso private class LLFirCompilerRequiredAnnotationsTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - session: FirSession, scopeSession: ScopeSession, computationSession: LLFirCompilerRequiredAnnotationsComputationSession? = null, ) : LLFirTargetResolver(target, lockProvider, FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS, isJumpingPhase = false) { @@ -73,7 +70,6 @@ private class LLFirCompilerRequiredAnnotationsTargetResolver( val resolver = LLFirCompilerRequiredAnnotationsTargetResolver( designation, lockProvider, - targetSession, targetSession.getScopeSession(), this, ) @@ -85,7 +81,7 @@ private class LLFirCompilerRequiredAnnotationsTargetResolver( } private val transformer = FirCompilerRequiredAnnotationsResolveTransformer( - session, + resolveTargetSession, scopeSession, computationSession ?: LLFirCompilerRequiredAnnotationsComputationSession(), ) diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirContractsLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirContractsLazyResolver.kt index cb3bdcaa0f6..22bb7e9105e 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirContractsLazyResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirContractsLazyResolver.kt @@ -14,7 +14,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkContractDescrip import org.jetbrains.kotlin.analysis.low.level.api.fir.util.isCallableWithSpecialBody import org.jetbrains.kotlin.fir.FirElementWithResolveState import org.jetbrains.kotlin.fir.FirFileAnnotationsContainer -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.contracts.FirRawContractDescription import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.impl.FirPrimaryConstructor @@ -30,11 +29,10 @@ internal object LLFirContractsLazyResolver : LLFirLazyResolver(FirResolvePhase.C override fun resolve( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - session: FirSession, scopeSession: ScopeSession, towerDataContextCollector: FirResolveContextCollector?, ) { - val resolver = LLFirContractsTargetResolver(target, lockProvider, session, scopeSession, towerDataContextCollector) + val resolver = LLFirContractsTargetResolver(target, lockProvider, scopeSession, towerDataContextCollector) resolver.resolveDesignation() } @@ -47,7 +45,6 @@ internal object LLFirContractsLazyResolver : LLFirLazyResolver(FirResolvePhase.C private class LLFirContractsTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - session: FirSession, scopeSession: ScopeSession, firResolveContextCollector: FirResolveContextCollector?, ) : LLFirAbstractBodyTargetResolver( @@ -57,7 +54,7 @@ private class LLFirContractsTargetResolver( FirResolvePhase.CONTRACTS, ) { override val transformer = FirContractResolveTransformer( - session, + resolveTargetSession, scopeSession, firResolveContextCollector = firResolveContextCollector, ) diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirExpectActualMatcherLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirExpectActualMatcherLazyResolver.kt index d738eb108bc..14e6b84e0c1 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirExpectActualMatcherLazyResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirExpectActualMatcherLazyResolver.kt @@ -10,7 +10,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockPro import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkExpectForActualIsResolved import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.fir.FirElementWithResolveState -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.isCopyCreatedInScope @@ -24,11 +23,10 @@ internal object LLFirExpectActualMatcherLazyResolver : LLFirLazyResolver(FirReso override fun resolve( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - session: FirSession, scopeSession: ScopeSession, towerDataContextCollector: FirResolveContextCollector?, ) { - val resolver = LLFirExpectActualMatchingTargetResolver(target, lockProvider, session, scopeSession) + val resolver = LLFirExpectActualMatchingTargetResolver(target, lockProvider, scopeSession) resolver.resolveDesignation() } @@ -45,10 +43,9 @@ internal object LLFirExpectActualMatcherLazyResolver : LLFirLazyResolver(FirReso private class LLFirExpectActualMatchingTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - session: FirSession, scopeSession: ScopeSession, ) : LLFirTargetResolver(target, lockProvider, FirResolvePhase.EXPECT_ACTUAL_MATCHING) { - private val enabled = session.languageVersionSettings.supportsFeature(LanguageFeature.MultiPlatformProjects) + private val enabled = resolveTargetSession.languageVersionSettings.supportsFeature(LanguageFeature.MultiPlatformProjects) @Deprecated("Should never be called directly, only for override purposes, please use withRegularClass", level = DeprecationLevel.ERROR) override fun withRegularClassImpl(firClass: FirRegularClass, action: () -> Unit) { @@ -60,7 +57,7 @@ private class LLFirExpectActualMatchingTargetResolver( action() } - private val transformer = object : FirExpectActualMatcherTransformer(session, scopeSession) { + private val transformer = object : FirExpectActualMatcherTransformer(resolveTargetSession, scopeSession) { override fun transformRegularClass(regularClass: FirRegularClass, data: Nothing?): FirStatement { transformMemberDeclaration(regularClass) return regularClass diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirGeneratedCompanionObjectLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirGeneratedCompanionObjectLazyResolver.kt index 42d7aca2cb0..80bed7ad2fa 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirGeneratedCompanionObjectLazyResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirGeneratedCompanionObjectLazyResolver.kt @@ -8,7 +8,6 @@ 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.fir.FirElementWithResolveState -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.resolve.ScopeSession @@ -19,11 +18,10 @@ internal object LLFirGeneratedCompanionObjectLazyResolver : LLFirLazyResolver(Fi override fun resolve( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - session: FirSession, scopeSession: ScopeSession, towerDataContextCollector: FirResolveContextCollector?, ) { - val resolver = LLFirCompanionGenerationTargetResolver(target, lockProvider, session) + val resolver = LLFirCompanionGenerationTargetResolver(target, lockProvider) resolver.resolveDesignation() } } @@ -31,9 +29,8 @@ internal object LLFirGeneratedCompanionObjectLazyResolver : LLFirLazyResolver(Fi private class LLFirCompanionGenerationTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - session: FirSession, ) : LLFirTargetResolver(target, lockProvider, FirResolvePhase.COMPANION_GENERATION) { - private val transformer: FirCompanionGenerationTransformer = FirCompanionGenerationTransformer(session) + private val transformer: FirCompanionGenerationTransformer = FirCompanionGenerationTransformer(resolveTargetSession) override fun doLazyResolveUnderLock(target: FirElementWithResolveState) { if (target !is FirRegularClass) return 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 aa96c58c335..c66056149a2 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 @@ -14,7 +14,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.util.forEachDependentDecl import org.jetbrains.kotlin.analysis.low.level.api.fir.util.isScriptDependentDeclaration import org.jetbrains.kotlin.fir.FirElementWithResolveState import org.jetbrains.kotlin.fir.FirFileAnnotationsContainer -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.isCopyCreatedInScope @@ -35,11 +34,10 @@ internal object LLFirImplicitTypesLazyResolver : LLFirLazyResolver(FirResolvePha override fun resolve( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - session: FirSession, scopeSession: ScopeSession, towerDataContextCollector: FirResolveContextCollector?, ) { - val resolver = LLFirImplicitBodyTargetResolver(target, lockProvider, session, scopeSession, towerDataContextCollector) + val resolver = LLFirImplicitBodyTargetResolver(target, lockProvider, scopeSession, towerDataContextCollector) resolver.resolveDesignation() } @@ -112,7 +110,6 @@ internal class LLImplicitBodyResolveComputationSession : ImplicitBodyResolveComp internal class LLFirImplicitBodyTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - session: FirSession, scopeSession: ScopeSession, firResolveContextCollector: FirResolveContextCollector?, llImplicitBodyResolveComputationSessionParameter: LLImplicitBodyResolveComputationSession? = null, @@ -125,7 +122,7 @@ internal class LLFirImplicitBodyTargetResolver( isJumpingPhase = true, ) { override val transformer = object : FirImplicitAwareBodyResolveTransformer( - session, + resolveTargetSession, implicitBodyResolveComputationSession = llImplicitBodyResolveComputationSession, phase = resolverPhase, implicitTypeOnly = true, 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 f2a0dacf2d1..9511a3611e1 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 @@ -11,18 +11,14 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.LLFirPhaseUp import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase import org.jetbrains.kotlin.analysis.low.level.api.fir.util.forEachDependentDeclaration import org.jetbrains.kotlin.fir.FirElementWithResolveState -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirResolveContextCollector -internal abstract class LLFirLazyResolver( - val resolverPhase: FirResolvePhase, -) { +internal abstract class LLFirLazyResolver(val resolverPhase: FirResolvePhase) { abstract fun resolve( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - session: FirSession, scopeSession: ScopeSession, towerDataContextCollector: FirResolveContextCollector?, ) 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 08b59fd50ba..50bf6f838c3 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 @@ -20,10 +20,9 @@ internal object LLFirLazyResolverRunner { towerDataContextCollector: FirResolveContextCollector?, ) { val lazyResolver = LLFirLazyPhaseResolverByPhase.getByPhase(phase) - val session = target.target.moduleData.session lockProvider.withGlobalLock { lockProvider.withGlobalPhaseLock(phase) { - lazyResolver.resolve(target, lockProvider, session, scopeSession, towerDataContextCollector) + lazyResolver.resolve(target, lockProvider, scopeSession, towerDataContextCollector) } } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirReturnTypeCalculatorWithJump.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirReturnTypeCalculatorWithJump.kt index ee3dfc85ef1..0e4ceeab4d3 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirReturnTypeCalculatorWithJump.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirReturnTypeCalculatorWithJump.kt @@ -38,7 +38,6 @@ internal class LLFirReturnTypeCalculatorWithJump( val resolver = LLFirImplicitBodyTargetResolver( designation, lockProvider = lockProvider, - session = targetSession, scopeSession = targetSession.getScopeSession(), firResolveContextCollector = towerDataContextCollector, llImplicitBodyResolveComputationSessionParameter = implicitBodyResolveComputationSession as LLImplicitBodyResolveComputationSession, diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirSealedClassInheritorsLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirSealedClassInheritorsLazyResolver.kt index e1ece667e03..a68ac28b9ce 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirSealedClassInheritorsLazyResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirSealedClassInheritorsLazyResolver.kt @@ -8,7 +8,6 @@ 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.fir.FirElementWithResolveState -import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirResolveContextCollector @@ -17,7 +16,6 @@ internal object LLFirSealedClassInheritorsLazyResolver : LLFirLazyResolver(FirRe override fun resolve( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - session: FirSession, scopeSession: ScopeSession, towerDataContextCollector: FirResolveContextCollector?, ) { diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirStatusLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirStatusLazyResolver.kt index b767e33ba33..abde386217b 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirStatusLazyResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirStatusLazyResolver.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.api.targets.LLFirSingleResolveTarget import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.asResolveTarget +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.session import org.jetbrains.kotlin.analysis.low.level.api.fir.api.tryCollectDesignationWithFile import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.llFirSession @@ -34,14 +35,12 @@ internal object LLFirStatusLazyResolver : LLFirLazyResolver(FirResolvePhase.STAT override fun resolve( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - session: FirSession, scopeSession: ScopeSession, towerDataContextCollector: FirResolveContextCollector?, ) { val resolver = LLFirStatusTargetResolver( target = target, lockProvider = lockProvider, - session = session, scopeSession = scopeSession, resolveMode = target.resolveMode(), ) @@ -110,12 +109,11 @@ private class LLStatusComputationSession(val useSiteSession: FirSession) : Statu private class LLFirStatusTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - session: FirSession, scopeSession: ScopeSession, - private val statusComputationSession: LLStatusComputationSession = LLStatusComputationSession(session), + private val statusComputationSession: LLStatusComputationSession = LLStatusComputationSession(target.session), private val resolveMode: StatusResolveMode, ) : LLFirTargetResolver(target, lockProvider, FirResolvePhase.STATUS, isJumpingPhase = false) { - private val transformer = Transformer(session, scopeSession) + private val transformer = Transformer(resolveTargetSession, scopeSession) @Deprecated("Should never be called directly, only for override purposes, please use withRegularClass", level = DeprecationLevel.ERROR) override fun withRegularClassImpl(firClass: FirRegularClass, action: () -> Unit) { @@ -266,7 +264,6 @@ private class LLFirStatusTargetResolver( val resolver = LLFirStatusTargetResolver( target, lockProvider, - targetSession, targetSession.getScopeSession(), computationSession, resolveMode = resolveMode, diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirSupertypeLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirSupertypeLazyResolver.kt index 4c6bdafa00a..5f6761fdf19 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirSupertypeLazyResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirSupertypeLazyResolver.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.api.targets.LLFirSingleResolveTarget import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.asResolveTarget +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.session import org.jetbrains.kotlin.analysis.low.level.api.fir.api.tryCollectDesignationWithFile import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkTypeRefIsResolved @@ -32,11 +33,10 @@ internal object LLFirSupertypeLazyResolver : LLFirLazyResolver(FirResolvePhase.S override fun resolve( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - session: FirSession, scopeSession: ScopeSession, towerDataContextCollector: FirResolveContextCollector?, ) { - val resolver = LLFirSuperTypeTargetResolver(target, lockProvider, session, scopeSession) + val resolver = LLFirSuperTypeTargetResolver(target, lockProvider, scopeSession) resolver.resolveDesignation() } @@ -58,13 +58,12 @@ internal object LLFirSupertypeLazyResolver : LLFirLazyResolver(FirResolvePhase.S private class LLFirSuperTypeTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - private val session: FirSession, private val scopeSession: ScopeSession, - private val supertypeComputationSession: LLFirSupertypeComputationSession = LLFirSupertypeComputationSession(session), + private val supertypeComputationSession: LLFirSupertypeComputationSession = LLFirSupertypeComputationSession(target.session), private val visitedElements: MutableSet = hashSetOf(), ) : LLFirTargetResolver(target, lockProvider, FirResolvePhase.SUPER_TYPES, isJumpingPhase = false) { private val supertypeResolver = object : FirSupertypeResolverVisitor( - session = session, + session = resolveTargetSession, supertypeComputationSession = supertypeComputationSession, scopeSession = scopeSession, ) { @@ -110,7 +109,7 @@ private class LLFirSuperTypeTargetResolver( resolver = { supertypeResolver.resolveSpecificClassLikeSupertypes(target, it) }, superTypeUpdater = { target.replaceSuperTypeRefs(it) - session.platformSupertypeUpdater?.updateSupertypesIfNeeded(target, scopeSession) + resolveTargetSession.platformSupertypeUpdater?.updateSupertypesIfNeeded(target, scopeSession) }, ) is FirTypeAlias -> performResolve( @@ -176,7 +175,7 @@ private class LLFirSuperTypeTargetResolver( } private fun FirClassLikeDeclaration.asResolveTarget(): LLFirSingleResolveTarget? { - return takeIf { it.canHaveLoopInSupertypesHierarchy(session) } + return takeIf { it.canHaveLoopInSupertypesHierarchy(resolveTargetSession) } ?.tryCollectDesignationWithFile() ?.asResolveTarget() } @@ -185,7 +184,6 @@ private class LLFirSuperTypeTargetResolver( LLFirSuperTypeTargetResolver( target = target, lockProvider = lockProvider, - session = session, scopeSession = scopeSession, supertypeComputationSession = supertypeComputationSession, visitedElements = visitedElements, @@ -199,14 +197,14 @@ private class LLFirSuperTypeTargetResolver( * So we crawl the resolved supertypes of visited designations to find more designations to collect. */ private fun crawlSupertype(type: ConeKotlinType) { - val classLikeDeclaration = type.toSymbol(session)?.fir + val classLikeDeclaration = type.toSymbol(resolveTargetSession)?.fir if (classLikeDeclaration !is FirClassLikeDeclaration) return if (classLikeDeclaration in visitedElements) return if (classLikeDeclaration is FirJavaClass) { - if (!classLikeDeclaration.canHaveLoopInSupertypesHierarchy(session)) return + if (!classLikeDeclaration.canHaveLoopInSupertypesHierarchy(resolveTargetSession)) return visitedElements += classLikeDeclaration - val parentClass = classLikeDeclaration.outerClass(session) + val parentClass = classLikeDeclaration.outerClass(resolveTargetSession) if (parentClass != null) { crawlSupertype(parentClass.defaultType()) } 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 1d24dc966b2..cccd13bd13e 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 @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.* import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider +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.FirElement import org.jetbrains.kotlin.fir.FirElementWithResolveState @@ -37,6 +38,8 @@ internal abstract class LLFirTargetResolver( protected val resolverPhase: FirResolvePhase, private val isJumpingPhase: Boolean = false, ) : LLFirResolveTargetVisitor { + val resolveTargetSession: LLFirSession get() = resolveTarget.session + private val _nestedClassesStack = mutableListOf() val nestedClassesStack: List get() = _nestedClassesStack diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirTypeLazyResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirTypeLazyResolver.kt index 35da80ab230..6e63843002a 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirTypeLazyResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirTypeLazyResolver.kt @@ -6,6 +6,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.api.targets.session import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodiesCalculator import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkAnnotationTypeIsResolved @@ -18,8 +19,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.util.forEachDependentDecl import org.jetbrains.kotlin.fir.FirAnnotationContainer import org.jetbrains.kotlin.fir.FirElementWithResolveState import org.jetbrains.kotlin.fir.FirFileAnnotationsContainer -import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.util.PrivateForInline import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.transformers.FirTypeResolveTransformer @@ -29,17 +28,17 @@ import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.utils.exceptions.withFirEntry import org.jetbrains.kotlin.fir.visitors.transformSingle +import org.jetbrains.kotlin.util.PrivateForInline import org.jetbrains.kotlin.utils.exceptions.errorWithAttachment internal object LLFirTypeLazyResolver : LLFirLazyResolver(FirResolvePhase.TYPES) { override fun resolve( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - session: FirSession, scopeSession: ScopeSession, towerDataContextCollector: FirResolveContextCollector?, ) { - val resolver = LLFirTypeTargetResolver(target, lockProvider, session, scopeSession) + val resolver = LLFirTypeTargetResolver(target, lockProvider, scopeSession) resolver.resolveDesignation() } @@ -73,10 +72,9 @@ internal object LLFirTypeLazyResolver : LLFirLazyResolver(FirResolvePhase.TYPES) private class LLFirTypeTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - session: FirSession, scopeSession: ScopeSession, ) : LLFirTargetResolver(target, lockProvider, FirResolvePhase.TYPES) { - private val transformer = object : FirTypeResolveTransformer(session, scopeSession) { + private val transformer = object : FirTypeResolveTransformer(target.session, scopeSession) { override fun transformTypeRef(typeRef: FirTypeRef, data: Any?): FirResolvedTypeRef { FirLazyBodiesCalculator.calculateAnnotations(typeRef, session) return super.transformTypeRef(typeRef, data)