FIR IDE: do not recreate transformer phases & ScopeSession

idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/FirPhaseRunner.kt

@@ -7,8 +7,6 @@ package org.jetbrains.kotlin.idea.fir.low.level.api
 
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.resolve.transformers.createTransformerBasedProcessorByPhase
 import org.jetbrains.kotlin.idea.fir.low.level.api.util.executeWithoutPCE
 import java.util.concurrent.locks.ReentrantLock
 import kotlin.concurrent.withLock
@@ -17,20 +15,20 @@ internal class FirPhaseRunner {
     private val superTypesBodyResolveLock = ReentrantLock()
     private val implicitTypesResolveLock = ReentrantLock()
 
-    fun runPhase(firFile: FirFile, phase: FirResolvePhase, scopeSession: ScopeSession) = when (phase) {
+    fun runPhase(firFile: FirFile, phase: FirResolvePhase) = when (phase) {
         FirResolvePhase.SUPER_TYPES -> superTypesBodyResolveLock.withLock {
-            runPhaseWithoutLock(firFile, phase, scopeSession)
+            runPhaseWithoutLock(firFile, phase)
         }
         FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE -> implicitTypesResolveLock.withLock {
-            runPhaseWithoutLock(firFile, phase, scopeSession)
+            runPhaseWithoutLock(firFile, phase)
         }
         else -> {
-            runPhaseWithoutLock(firFile, phase, scopeSession)
+            runPhaseWithoutLock(firFile, phase)
         }
     }
 
-    private fun runPhaseWithoutLock(firFile: FirFile, phase: FirResolvePhase, scopeSession: ScopeSession) {
-        val phaseProcessor = phase.createTransformerBasedProcessorByPhase(firFile.session, scopeSession)
+    private fun runPhaseWithoutLock(firFile: FirFile, phase: FirResolvePhase) {
+        val phaseProcessor = firFile.session.firTransformerProvider.getTransformerForPhase(phase)
         executeWithoutPCE { phaseProcessor.processFile(firFile) }
     }
 }

idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/file/builder/FirFileBuilder.kt

@@ -72,12 +72,11 @@ internal class FirFileBuilder(
         assert(fromPhase <= toPhase) {
             "Trying to resolve file ${firFile.name} from $fromPhase to $toPhase"
         }
-        val scopeSession = ScopeSession()
         var currentPhase = fromPhase
         while (currentPhase < toPhase) {
             if (checkPCE) checkCanceled()
             currentPhase = currentPhase.next
-            firPhaseRunner.runPhase(firFile, currentPhase, scopeSession)
+            firPhaseRunner.runPhase(firFile, currentPhase)
         }
     }
 

idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/lazy/resolve/FirLazyDeclarationResolver.kt

@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.idea.fir.low.level.api.element.builder.FirDesignated
 import org.jetbrains.kotlin.idea.fir.low.level.api.element.builder.getNonLocalContainingOrThisDeclaration
 import org.jetbrains.kotlin.idea.fir.low.level.api.file.builder.FirFileBuilder
 import org.jetbrains.kotlin.idea.fir.low.level.api.file.builder.ModuleFileCache
+import org.jetbrains.kotlin.idea.fir.low.level.api.firTransformerProvider
 import org.jetbrains.kotlin.idea.fir.low.level.api.providers.firIdeProvider
 import org.jetbrains.kotlin.idea.fir.low.level.api.util.checkCanceled
 import org.jetbrains.kotlin.idea.fir.low.level.api.util.executeWithoutPCE
@@ -127,7 +128,7 @@ internal class FirLazyDeclarationResolver(
         if (designation.all { it.resolvePhase >= toPhase }) {
             return
         }
-        val scopeSession = ScopeSession()
+        val scopeSession = containerFirFile.session.firTransformerProvider.getScopeSession()
         val transformer = FirDesignatedBodyResolveTransformerForIDE(
             designation.iterator(), containerFirFile.session,
             scopeSession,

idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/sessions/FirIdeSessionFactory.kt

@@ -110,6 +110,7 @@ internal object FirIdeSessionFactory {
 
         registerCommonComponents()
         registerResolveComponents()
+        registerIdeComponents()
 
         val provider = FirIdeProvider(
             project,
@@ -165,6 +166,7 @@ internal object FirIdeSessionFactory {
         return FirIdeLibrariesSession(moduleInfo, sessionProvider, searchScope).apply {
             registerCommonComponents()
             registerJavaSpecificComponents()
+            registerIdeComponents()
 
             val javaSymbolProvider = JavaSymbolProvider(this, sessionProvider.project, searchScope)
 
@@ -192,4 +194,9 @@ internal object FirIdeSessionFactory {
             )
         }
     }
+
+    private fun FirIdeSession.registerIdeComponents() {
+        register(IdeSessionComponents::class, IdeSessionComponents.create(this))
+        register(FirTransformerProvider::class, FirTransformerProvider(this))
+    }
 }

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirScopeProvider.kt

@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
 import org.jetbrains.kotlin.idea.fir.getOrBuildFirOfType
 import org.jetbrains.kotlin.idea.fir.low.level.api.FirModuleResolveState
 import org.jetbrains.kotlin.idea.fir.low.level.api.LowLevelFirApiFacade
+import org.jetbrains.kotlin.idea.fir.low.level.api.firTransformerProvider
 import org.jetbrains.kotlin.idea.frontend.api.KtAnalysisSession
 import org.jetbrains.kotlin.idea.frontend.api.ValidityToken
 import org.jetbrains.kotlin.idea.frontend.api.ValidityTokenOwner
@@ -59,7 +60,7 @@ internal class KtFirScopeProvider(
             check(classSymbol is KtFirClassOrObjectSymbol)
             val firScope =
                 classSymbol.firRef.withFir(FirResolvePhase.SUPER_TYPES) { fir ->
-                    fir.unsubstitutedScope(fir.session, ScopeSession())
+                    fir.unsubstitutedScope(fir.session, fir.session.firTransformerProvider.getScopeSession())
                 }.also(firScopeStorage::register)
             KtFirMemberScope(classSymbol, firScope, token, builder)
         }
@@ -91,8 +92,8 @@ internal class KtFirScopeProvider(
 
     override fun getTypeScope(type: KtType): KtScope? {
         check(type is KtFirType) { "KtFirScopeProvider can only work with KtFirType, but ${type::class} was provided" }
-
-        val firTypeScope = type.coneType.scope(firResolveState.currentModuleSourcesSession, ScopeSession()) ?: return null
+        val firSession = firResolveState.currentModuleSourcesSession
+        val firTypeScope = type.coneType.scope(firSession, firSession.firTransformerProvider.getScopeSession()) ?: return null
         return convertToKtScope(firTypeScope)
     }