From efeffb45b70ceeec012761dc93408afc5e2ecb09 Mon Sep 17 00:00:00 2001 From: Dmitrii Gridin Date: Sat, 17 Feb 2024 23:43:11 +0100 Subject: [PATCH] [LL FIR] LLFirLazyResolver: drop ScopeSession parameter It can be inferred from `LLFirResolveTarget` inside `LLFirTargetResolver` --- .../transformers/LLFirAbstractBodyTargetResolver.kt | 4 +--- .../LLFirAnnotationArgumentsLazyResolver.kt | 8 ++------ .../api/fir/transformers/LLFirBodyLazyResolver.kt | 7 ++----- .../LLFirCompilerAnnotationsLazyResolver.kt | 8 ++------ .../api/fir/transformers/LLFirContractsLazyResolver.kt | 8 ++------ .../LLFirExpectActualMatcherLazyResolver.kt | 7 ++----- .../LLFirGeneratedCompanionObjectLazyResolver.kt | 2 -- .../fir/transformers/LLFirImplicitTypesLazyResolver.kt | 8 ++------ .../level/api/fir/transformers/LLFirLazyResolver.kt | 6 +----- .../transformers/LLFirReturnTypeCalculatorWithJump.kt | 3 --- .../LLFirSealedClassInheritorsLazyResolver.kt | 2 -- .../api/fir/transformers/LLFirStatusLazyResolver.kt | 8 +------- .../api/fir/transformers/LLFirSupertypeLazyResolver.kt | 10 +++------- .../level/api/fir/transformers/LLFirTargetResolver.kt | 2 ++ .../api/fir/transformers/LLFirTypeLazyResolver.kt | 8 ++------ 15 files changed, 22 insertions(+), 69 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 41110bb6342..b8662110475 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 @@ -13,20 +13,18 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodie import org.jetbrains.kotlin.fir.FirElementWithResolveState import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.resolve.ResolutionMode -import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirAbstractBodyResolveTransformerDispatcher import org.jetbrains.kotlin.fir.visitors.transformSingle internal abstract class LLFirAbstractBodyTargetResolver( resolveTarget: LLFirResolveTarget, lockProvider: LLFirLockProvider, - private val scopeSession: ScopeSession, resolvePhase: FirResolvePhase, protected val llImplicitBodyResolveComputationSession: LLImplicitBodyResolveComputationSession = LLImplicitBodyResolveComputationSession(), isJumpingPhase: Boolean = false, ) : LLFirTargetResolver(resolveTarget, lockProvider, resolvePhase, isJumpingPhase) { protected fun createReturnTypeCalculator(): LLFirReturnTypeCalculatorWithJump = LLFirReturnTypeCalculatorWithJump( - scopeSession, + resolveTargetScopeSession, llImplicitBodyResolveComputationSession, lockProvider, ) 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 b6a0e0cbf85..5be91d4663e 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 @@ -20,7 +20,6 @@ import org.jetbrains.kotlin.fir.expressions.impl.FirResolvedArgumentList import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.references.isError import org.jetbrains.kotlin.fir.resolve.ResolutionMode -import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.transformers.plugin.FirAnnotationArgumentsTransformer import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol @@ -33,8 +32,7 @@ internal object LLFirAnnotationArgumentsLazyResolver : LLFirLazyResolver(FirReso override fun createTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - scopeSession: ScopeSession, - ): LLFirTargetResolver = LLFirAnnotationArgumentsTargetResolver(target, lockProvider, scopeSession) + ): LLFirTargetResolver = LLFirAnnotationArgumentsTargetResolver(target, lockProvider) override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) { if (target !is FirAnnotationContainer) return @@ -76,11 +74,9 @@ internal object LLFirAnnotationArgumentsLazyResolver : LLFirLazyResolver(FirReso private class LLFirAnnotationArgumentsTargetResolver( resolveTarget: LLFirResolveTarget, lockProvider: LLFirLockProvider, - scopeSession: ScopeSession, ) : LLFirAbstractBodyTargetResolver( resolveTarget, lockProvider, - scopeSession, FirResolvePhase.ANNOTATION_ARGUMENTS, ) { /** @@ -97,7 +93,7 @@ private class LLFirAnnotationArgumentsTargetResolver( */ override val transformer = FirAnnotationArgumentsTransformer( resolveTargetSession, - scopeSession, + resolveTargetScopeSession, resolverPhase, returnTypeCalculator = createReturnTypeCalculator(), ) 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 c7343712dc7..d201fbf0769 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 @@ -54,8 +54,7 @@ internal object LLFirBodyLazyResolver : LLFirLazyResolver(FirResolvePhase.BODY_R override fun createTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - scopeSession: ScopeSession, - ): LLFirTargetResolver = LLFirBodyTargetResolver(target, lockProvider, scopeSession) + ): LLFirTargetResolver = LLFirBodyTargetResolver(target, lockProvider) override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) { when (target) { @@ -73,18 +72,16 @@ internal object LLFirBodyLazyResolver : LLFirLazyResolver(FirResolvePhase.BODY_R private class LLFirBodyTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - scopeSession: ScopeSession, ) : LLFirAbstractBodyTargetResolver( target, lockProvider, - scopeSession, FirResolvePhase.BODY_RESOLVE, ) { override val transformer = object : FirBodyResolveTransformer( resolveTargetSession, phase = resolverPhase, implicitTypeOnly = false, - scopeSession = scopeSession, + scopeSession = resolveTargetScopeSession, returnTypeCalculator = createReturnTypeCalculator(), ) { override val preserveCFGForClasses: Boolean get() = false 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 c138029ae83..2cc841c67ec 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 @@ -35,8 +35,7 @@ internal object LLFirCompilerAnnotationsLazyResolver : LLFirLazyResolver(FirReso override fun createTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - scopeSession: ScopeSession, - ): LLFirTargetResolver = LLFirCompilerRequiredAnnotationsTargetResolver(target, lockProvider, scopeSession) + ): LLFirTargetResolver = LLFirCompilerRequiredAnnotationsTargetResolver(target, lockProvider) override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) { when (target) { @@ -49,7 +48,6 @@ internal object LLFirCompilerAnnotationsLazyResolver : LLFirLazyResolver(FirReso private class LLFirCompilerRequiredAnnotationsTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - scopeSession: ScopeSession, computationSession: LLFirCompilerRequiredAnnotationsComputationSession? = null, ) : LLFirTargetResolver(target, lockProvider, FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS, isJumpingPhase = false) { inner class LLFirCompilerRequiredAnnotationsComputationSession : CompilerRequiredAnnotationsComputationSession() { @@ -59,11 +57,9 @@ private class LLFirCompilerRequiredAnnotationsTargetResolver( symbol.lazyResolveToPhase(resolverPhase.previous) val designation = regularClass.collectDesignation().asResolveTarget() - val targetSession = designation.target.llFirSession val resolver = LLFirCompilerRequiredAnnotationsTargetResolver( designation, lockProvider, - targetSession.getScopeSession(), this, ) @@ -75,7 +71,7 @@ private class LLFirCompilerRequiredAnnotationsTargetResolver( private val transformer = FirCompilerRequiredAnnotationsResolveTransformer( resolveTargetSession, - scopeSession, + resolveTargetScopeSession, 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 ca03c7e9d25..0a3f51c63db 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 @@ -18,7 +18,6 @@ import org.jetbrains.kotlin.fir.contracts.FirRawContractDescription import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.impl.FirPrimaryConstructor import org.jetbrains.kotlin.fir.isCopyCreatedInScope -import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.transformers.contracts.FirContractResolveTransformer import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef @@ -26,8 +25,7 @@ internal object LLFirContractsLazyResolver : LLFirLazyResolver(FirResolvePhase.C override fun createTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - scopeSession: ScopeSession, - ): LLFirTargetResolver = LLFirContractsTargetResolver(target, lockProvider, scopeSession) + ): LLFirTargetResolver = LLFirContractsTargetResolver(target, lockProvider) override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) { if (target !is FirContractDescriptionOwner) return @@ -38,14 +36,12 @@ internal object LLFirContractsLazyResolver : LLFirLazyResolver(FirResolvePhase.C private class LLFirContractsTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - scopeSession: ScopeSession, ) : LLFirAbstractBodyTargetResolver( target, lockProvider, - scopeSession, FirResolvePhase.CONTRACTS, ) { - override val transformer = FirContractResolveTransformer(resolveTargetSession, scopeSession) + override val transformer = FirContractResolveTransformer(resolveTargetSession, resolveTargetScopeSession) override fun doLazyResolveUnderLock(target: FirElementWithResolveState) { // There is no sense to resolve such declarations as they do not have contracts 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 ac17a3cb965..a0479c8c757 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 @@ -14,7 +14,6 @@ import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.isCopyCreatedInScope import org.jetbrains.kotlin.fir.languageVersionSettings -import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.transformers.mpp.FirExpectActualMatcherTransformer import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase @@ -22,8 +21,7 @@ internal object LLFirExpectActualMatcherLazyResolver : LLFirLazyResolver(FirReso override fun createTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - scopeSession: ScopeSession, - ): LLFirTargetResolver = LLFirExpectActualMatchingTargetResolver(target, lockProvider, scopeSession) + ): LLFirTargetResolver = LLFirExpectActualMatchingTargetResolver(target, lockProvider) override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) { if (target.moduleData.session.languageVersionSettings.supportsFeature(LanguageFeature.MultiPlatformProjects) && @@ -38,7 +36,6 @@ internal object LLFirExpectActualMatcherLazyResolver : LLFirLazyResolver(FirReso private class LLFirExpectActualMatchingTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - scopeSession: ScopeSession, ) : LLFirTargetResolver(target, lockProvider, FirResolvePhase.EXPECT_ACTUAL_MATCHING) { private val enabled = resolveTargetSession.languageVersionSettings.supportsFeature(LanguageFeature.MultiPlatformProjects) @@ -52,7 +49,7 @@ private class LLFirExpectActualMatchingTargetResolver( action() } - private val transformer = object : FirExpectActualMatcherTransformer(resolveTargetSession, scopeSession) { + private val transformer = object : FirExpectActualMatcherTransformer(resolveTargetSession, resolveTargetScopeSession) { 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 aa23cb18943..ce9fafde45f 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 @@ -10,14 +10,12 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockPro import org.jetbrains.kotlin.fir.FirElementWithResolveState import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.FirResolvePhase -import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.transformers.plugin.FirCompanionGenerationTransformer internal object LLFirGeneratedCompanionObjectLazyResolver : LLFirLazyResolver(FirResolvePhase.COMPANION_GENERATION) { override fun createTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - scopeSession: ScopeSession, ): LLFirTargetResolver = LLFirCompanionGenerationTargetResolver(target, lockProvider) override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) {} 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 2add2907973..8bcae9b9bf9 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 @@ -15,7 +15,6 @@ import org.jetbrains.kotlin.fir.FirFileAnnotationsContainer import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.isCopyCreatedInScope -import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirImplicitAwareBodyResolveTransformer import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyResolveComputationSession import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol @@ -31,8 +30,7 @@ internal object LLFirImplicitTypesLazyResolver : LLFirLazyResolver(FirResolvePha override fun createTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - scopeSession: ScopeSession, - ): LLFirTargetResolver = LLFirImplicitBodyTargetResolver(target, lockProvider, scopeSession) + ): LLFirTargetResolver = LLFirImplicitBodyTargetResolver(target, lockProvider) override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) { if (target !is FirCallableDeclaration) return @@ -126,12 +124,10 @@ internal class LLImplicitBodyResolveComputationSession : ImplicitBodyResolveComp internal class LLFirImplicitBodyTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - scopeSession: ScopeSession, llImplicitBodyResolveComputationSessionParameter: LLImplicitBodyResolveComputationSession? = null, ) : LLFirAbstractBodyTargetResolver( target, lockProvider, - scopeSession, FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, llImplicitBodyResolveComputationSession = llImplicitBodyResolveComputationSessionParameter ?: LLImplicitBodyResolveComputationSession(), isJumpingPhase = true, @@ -141,7 +137,7 @@ internal class LLFirImplicitBodyTargetResolver( implicitBodyResolveComputationSession = llImplicitBodyResolveComputationSession, phase = resolverPhase, implicitTypeOnly = true, - scopeSession = scopeSession, + scopeSession = resolveTargetScopeSession, returnTypeCalculator = createReturnTypeCalculator(), ) { override val preserveCFGForClasses: Boolean get() = false 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 8c6d522e703..c83b03a0bcf 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,11 +8,9 @@ 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.* -import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.utils.exceptions.requireWithAttachment /** @@ -23,8 +21,7 @@ import org.jetbrains.kotlin.utils.exceptions.requireWithAttachment */ internal abstract class LLFirLazyResolver(val resolverPhase: FirResolvePhase) { fun resolve(target: LLFirResolveTarget, lockProvider: LLFirLockProvider) { - val scopeSession = target.target.llFirSession.getScopeSession() - val resolver = createTargetResolver(target, lockProvider, scopeSession) + val resolver = createTargetResolver(target, lockProvider) requireWithAttachment( resolverPhase == resolver.resolverPhase, { @@ -41,7 +38,6 @@ internal abstract class LLFirLazyResolver(val resolverPhase: FirResolvePhase) { protected abstract fun createTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - scopeSession: ScopeSession, ): LLFirTargetResolver fun checkIsResolved(target: FirElementWithResolveState) { 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 c87c7b8c9b7..8483c3a70b8 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 @@ -8,7 +8,6 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder import org.jetbrains.kotlin.analysis.low.level.api.fir.api.collectDesignation import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.asResolveTarget 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.transformers.LLFirImplicitBodyTargetResolver import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirImplicitTypesLazyResolver import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLImplicitBodyResolveComputationSession @@ -32,12 +31,10 @@ internal class LLFirReturnTypeCalculatorWithJump( declaration.lazyResolveToPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE.previous) val designation = declaration.collectDesignation().asResolveTarget() - val targetSession = designation.target.llFirSession val computationSession = implicitBodyResolveComputationSession as LLImplicitBodyResolveComputationSession val resolver = LLFirImplicitBodyTargetResolver( designation, lockProvider = lockProvider, - scopeSession = targetSession.getScopeSession(), llImplicitBodyResolveComputationSessionParameter = computationSession, ) 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 bd1a5d11b69..f81a607b341 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 @@ -9,13 +9,11 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.LLFirResolveT import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider import org.jetbrains.kotlin.fir.FirElementWithResolveState import org.jetbrains.kotlin.fir.declarations.FirResolvePhase -import org.jetbrains.kotlin.fir.resolve.ScopeSession internal object LLFirSealedClassInheritorsLazyResolver : LLFirLazyResolver(FirResolvePhase.SEALED_CLASS_INHERITORS) { override fun createTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - scopeSession: ScopeSession, ): LLFirTargetResolver = LLFirSealedClassInheritorsDesignatedResolver(target, lockProvider) override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) {} 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 7b37e6dedb8..5a580825407 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 @@ -11,7 +11,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.asResolveTarg import org.jetbrains.kotlin.analysis.low.level.api.fir.api.targets.session import org.jetbrains.kotlin.analysis.low.level.api.fir.api.tryCollectDesignation 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.checkDeclarationStatusIsResolved import org.jetbrains.kotlin.fir.FirElementWithResolveState import org.jetbrains.kotlin.fir.FirSession @@ -33,11 +32,9 @@ internal object LLFirStatusLazyResolver : LLFirLazyResolver(FirResolvePhase.STAT override fun createTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - scopeSession: ScopeSession, ): LLFirTargetResolver = LLFirStatusTargetResolver( target = target, lockProvider = lockProvider, - scopeSession = scopeSession, resolveMode = target.resolveMode(), ) @@ -102,11 +99,10 @@ private class LLStatusComputationSession(val useSiteSession: FirSession) : Statu private class LLFirStatusTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - scopeSession: ScopeSession, private val statusComputationSession: LLStatusComputationSession = LLStatusComputationSession(target.session), private val resolveMode: StatusResolveMode, ) : LLFirTargetResolver(target, lockProvider, FirResolvePhase.STATUS, isJumpingPhase = false) { - private val transformer = Transformer(resolveTargetSession, scopeSession) + private val transformer = Transformer(resolveTargetSession, resolveTargetScopeSession) @Deprecated("Should never be called directly, only for override purposes, please use withRegularClass", level = DeprecationLevel.ERROR) override fun withContainingRegularClass(firClass: FirRegularClass, action: () -> Unit) { @@ -252,11 +248,9 @@ private class LLFirStatusTargetResolver( } val target = regularClass.tryCollectDesignation()?.asResolveTarget() ?: return false - val targetSession = target.target.llFirSession val resolver = LLFirStatusTargetResolver( target, lockProvider, - 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 b517cbf05e9..c640756ccff 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 @@ -21,7 +21,6 @@ import org.jetbrains.kotlin.fir.declarations.utils.isActual import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass -import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.defaultType import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider import org.jetbrains.kotlin.fir.resolve.transformers.FirSupertypeResolverVisitor @@ -36,8 +35,7 @@ internal object LLFirSupertypeLazyResolver : LLFirLazyResolver(FirResolvePhase.S override fun createTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - scopeSession: ScopeSession, - ): LLFirTargetResolver = LLFirSuperTypeTargetResolver(target, lockProvider, scopeSession) + ): LLFirTargetResolver = LLFirSuperTypeTargetResolver(target, lockProvider) override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) { when (target) { @@ -57,14 +55,13 @@ internal object LLFirSupertypeLazyResolver : LLFirLazyResolver(FirResolvePhase.S private class LLFirSuperTypeTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - private val scopeSession: ScopeSession, 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 = resolveTargetSession, supertypeComputationSession = supertypeComputationSession, - scopeSession = scopeSession, + scopeSession = resolveTargetScopeSession, ) { /** * We can do nothing here because at a call moment we've already resolved [outerClass] @@ -108,7 +105,7 @@ private class LLFirSuperTypeTargetResolver( resolver = { supertypeResolver.resolveSpecificClassLikeSupertypes(target, it) }, superTypeUpdater = { target.replaceSuperTypeRefs(it) - resolveTargetSession.platformSupertypeUpdater?.updateSupertypesIfNeeded(target, scopeSession) + resolveTargetSession.platformSupertypeUpdater?.updateSupertypesIfNeeded(target, resolveTargetScopeSession) }, ) is FirTypeAlias -> performResolve( @@ -185,7 +182,6 @@ private class LLFirSuperTypeTargetResolver( LLFirSuperTypeTargetResolver( target = target, lockProvider = lockProvider, - scopeSession = target.session.getScopeSession(), supertypeComputationSession = supertypeComputationSession, visitedElements = visitedElements, ).resolveDesignation() 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 9bb4e290c47..24741207eba 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 @@ -29,6 +29,7 @@ import org.jetbrains.kotlin.fir.declarations.utils.componentFunctionSymbol import org.jetbrains.kotlin.fir.declarations.utils.correspondingValueParameterFromPrimaryConstructor import org.jetbrains.kotlin.fir.declarations.utils.fromPrimaryConstructor import org.jetbrains.kotlin.fir.originalIfFakeOverrideOrDelegated +import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase import org.jetbrains.kotlin.fir.utils.exceptions.withFirEntry import org.jetbrains.kotlin.resolve.DataClassResolver @@ -43,6 +44,7 @@ internal abstract class LLFirTargetResolver( private val isJumpingPhase: Boolean = false, ) : LLFirResolveTargetVisitor { val resolveTargetSession: LLFirSession get() = resolveTarget.session + val resolveTargetScopeSession: ScopeSession get() = resolveTargetSession.getScopeSession() private val _containingDeclarations = mutableListOf() 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 cc112f8128f..962ad4d4e52 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,7 +6,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.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 @@ -19,7 +18,6 @@ import org.jetbrains.kotlin.fir.FirAnnotationContainer import org.jetbrains.kotlin.fir.FirElementWithResolveState import org.jetbrains.kotlin.fir.FirFileAnnotationsContainer import org.jetbrains.kotlin.fir.declarations.* -import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.transformers.FirTypeResolveTransformer import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef @@ -33,8 +31,7 @@ internal object LLFirTypeLazyResolver : LLFirLazyResolver(FirResolvePhase.TYPES) override fun createTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - scopeSession: ScopeSession, - ): LLFirTargetResolver = LLFirTypeTargetResolver(target, lockProvider, scopeSession) + ): LLFirTargetResolver = LLFirTypeTargetResolver(target, lockProvider) override fun phaseSpecificCheckIsResolved(target: FirElementWithResolveState) { if (target is FirAnnotationContainer) { @@ -66,9 +63,8 @@ internal object LLFirTypeLazyResolver : LLFirLazyResolver(FirResolvePhase.TYPES) private class LLFirTypeTargetResolver( target: LLFirResolveTarget, lockProvider: LLFirLockProvider, - scopeSession: ScopeSession, ) : LLFirTargetResolver(target, lockProvider, FirResolvePhase.TYPES) { - private val transformer = object : FirTypeResolveTransformer(target.session, scopeSession) { + private val transformer = object : FirTypeResolveTransformer(resolveTargetSession, resolveTargetScopeSession) { override fun transformTypeRef(typeRef: FirTypeRef, data: Any?): FirResolvedTypeRef { FirLazyBodiesCalculator.calculateAnnotations(typeRef, session) return super.transformTypeRef(typeRef, data)