[LL FIR] LLFirLazyResolver: drop ScopeSession parameter

It can be inferred from `LLFirResolveTarget` inside `LLFirTargetResolver`
2024-02-17 23:43:11 +01:00
parent 7d672cd474
commit efeffb45b7
15 changed files with 22 additions and 69 deletions
@@ -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,
    )
@@ -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(),
    )
@@ -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
@@ -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(),
    )

@@ -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
@@ -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
@@ -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) {}
@@ -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
@@ -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) {
@@ -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,
        )

@@ -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) {}
@@ -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,
            )
@@ -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<FirElementWithResolveState> = 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()
@@ -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<FirDeclaration>()

@@ -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)