FIR IDE: Get rid of FirTransformerProvider class

Instead, create `ScopeSession` by hand and pass it as a parameter when
it is crucial for the performance

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

@@ -35,7 +35,6 @@ internal class FirModuleResolveStateForCompletion(
     override val moduleInfo: IdeaModuleInfo get() = originalState.moduleInfo
 
     override val rootModuleSession get() = originalState.rootModuleSession
-    override val firTransformerProvider: FirTransformerProvider get() = originalState.firTransformerProvider
     private val fileStructureCache = originalState.fileStructureCache
 
     private val completionMapping = mutableMapOf<KtElement, FirElement>()

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

@@ -44,7 +44,6 @@ internal class FirModuleResolveStateImpl(
     val firLazyDeclarationResolver: FirLazyDeclarationResolver,
 ) : FirModuleResolveState() {
     override val rootModuleSession: FirIdeSourcesSession get() = sessionProvider.rootModuleSession
-    override val firTransformerProvider: FirTransformerProvider get() = firFileBuilder.firPhaseRunner.transformerProvider
     val fileStructureCache = FileStructureCache(firFileBuilder, firLazyDeclarationResolver)
     val elementBuilder = FirElementBuilder()
     private val diagnosticsCollector = DiagnosticsCollector(fileStructureCache, rootModuleSession.cache)

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

@@ -7,28 +7,30 @@ 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.lazy.resolve.FirLazyBodiesCalculator
 import org.jetbrains.kotlin.idea.fir.low.level.api.util.executeWithoutPCE
 import java.util.concurrent.locks.ReentrantLock
 import kotlin.concurrent.withLock
 
-internal class FirPhaseRunner(val transformerProvider: FirTransformerProvider) {
+internal class FirPhaseRunner {
     private val superTypesBodyResolveLock = ReentrantLock()
     private val statusResolveLock = ReentrantLock()
     private val implicitTypesResolveLock = ReentrantLock()
 
-    fun runPhase(firFile: FirFile, phase: FirResolvePhase) = when (phase) {
+    fun runPhase(firFile: FirFile, phase: FirResolvePhase, scopeSession: ScopeSession) = when (phase) {
         FirResolvePhase.SUPER_TYPES -> superTypesBodyResolveLock.withLock {
-            runPhaseWithoutLock(firFile, phase)
+            runPhaseWithoutLock(firFile, phase, scopeSession)
         }
         FirResolvePhase.STATUS -> statusResolveLock.withLock {
-            runPhaseWithoutLock(firFile, phase)
+            runPhaseWithoutLock(firFile, phase, scopeSession)
         }
         FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE -> implicitTypesResolveLock.withLock {
-            runPhaseWithoutLock(firFile, phase)
+            runPhaseWithoutLock(firFile, phase, scopeSession)
         }
         else -> {
-            runPhaseWithoutLock(firFile, phase)
+            runPhaseWithoutLock(firFile, phase, scopeSession)
         }
     }
 
@@ -54,8 +56,8 @@ internal class FirPhaseRunner(val transformerProvider: FirTransformerProvider) {
     }
 
 
-    private fun runPhaseWithoutLock(firFile: FirFile, phase: FirResolvePhase) {
+    private fun runPhaseWithoutLock(firFile: FirFile, phase: FirResolvePhase, scopeSession: ScopeSession) {
-        val phaseProcessor = transformerProvider.getTransformerForPhase(firFile.session, phase)
+        val phaseProcessor = phase.createTransformerBasedProcessorByPhase(firFile.session, scopeSession)
         executeWithoutPCE {
             FirLazyBodiesCalculator.calculateLazyBodiesIfPhaseRequires(firFile, phase)
             phaseProcessor.processFile(firFile)

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

@@ -1,36 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.idea.fir.low.level.api
-
-import com.google.common.collect.MapMaker
-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.FirSessionComponent
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.resolve.transformers.FirTransformerBasedResolveProcessor
-import org.jetbrains.kotlin.fir.resolve.transformers.createTransformerBasedProcessorByPhase
-import java.util.*
-
-class FirTransformerProvider {
-    private val scopeSession = MapMaker().weakKeys().makeMap<FirSession, ScopeSession>()
-    private val transformers = MapMaker().weakKeys().makeMap<FirSession, EnumMap<FirResolvePhase, FirTransformerBasedResolveProcessor>>()
-
-
-    fun getTransformerForPhase(session: FirSession, phase: FirResolvePhase): FirTransformerBasedResolveProcessor =
-        transformers.computeIfAbsent(session) {
-            val scopesSession = getScopeSession(session)
-            EnumMap<FirResolvePhase, FirTransformerBasedResolveProcessor>(FirResolvePhase::class.java).apply {
-                FirResolvePhase.values().forEach { resolvePhase ->
-                    if (resolvePhase != FirResolvePhase.RAW_FIR) {
-                        put(resolvePhase, resolvePhase.createTransformerBasedProcessorByPhase(session, scopesSession))
-                    }
-                }
-            }
-        }.getValue(phase)
-
-    fun getScopeSession(session: FirSession): ScopeSession =
-        scopeSession.getOrPut(session) { ScopeSession() }
-}

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

@@ -11,16 +11,12 @@ import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.providers.FirProvider
-import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
-import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.idea.caches.project.IdeaModuleInfo
 import org.jetbrains.kotlin.idea.caches.project.getModuleInfo
 import org.jetbrains.kotlin.idea.fir.low.level.api.FirIdeResolveStateService
-import org.jetbrains.kotlin.idea.fir.low.level.api.FirTransformerProvider
 import org.jetbrains.kotlin.idea.fir.low.level.api.annotations.InternalForInline
 import org.jetbrains.kotlin.idea.fir.low.level.api.annotations.PrivateForInline
 import org.jetbrains.kotlin.idea.fir.low.level.api.element.builder.FirTowerDataContextCollector
-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.sessions.FirIdeSourcesSession
 import org.jetbrains.kotlin.idea.util.getElementTextInContext
@@ -36,8 +32,6 @@ abstract class FirModuleResolveState {
 
     abstract val moduleInfo: IdeaModuleInfo
 
-    abstract val firTransformerProvider: FirTransformerProvider
-
     internal abstract fun getSessionFor(moduleInfo: IdeaModuleInfo): FirSession
 
     internal abstract fun getOrBuildFirFor(element: KtElement): FirElement

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

@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.fir.builder.RawFirBuilder
 import org.jetbrains.kotlin.fir.builder.RawFirBuilderMode
 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.scopes.FirScopeProvider
 import org.jetbrains.kotlin.idea.fir.low.level.api.FirPhaseRunner
 import org.jetbrains.kotlin.psi.KtFile
@@ -81,10 +82,11 @@ internal class FirFileBuilder(
             "Trying to resolve file ${firFile.name} from $fromPhase to $toPhase"
         }
         var currentPhase = fromPhase
+        val scopeSession = ScopeSession()
         while (currentPhase < toPhase) {
             if (checkPCE) checkCanceled()
             currentPhase = currentPhase.next
-            firPhaseRunner.runPhase(firFile, currentPhase)
+            firPhaseRunner.runPhase(firFile, currentPhase, scopeSession)
         }
     }
 

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

@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.ResolutionMode
+import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.FirProvider
 import org.jetbrains.kotlin.idea.fir.low.level.api.element.builder.FirTowerDataContextCollector
@@ -119,6 +120,8 @@ internal class FirLazyDeclarationResolver(
         }
 
         var currentPhase = nonLazyPhase
+        val scopeSession = ScopeSession()
+
         while (currentPhase < toPhase) {
             currentPhase = currentPhase.next
             if (currentPhase.pluginPhase) continue
@@ -129,6 +132,7 @@ internal class FirLazyDeclarationResolver(
                 moduleFileCache,
                 provider,
                 currentPhase,
+                scopeSession,
                 towerDataContextCollector
             )
         }
@@ -140,6 +144,7 @@ internal class FirLazyDeclarationResolver(
         moduleFileCache: ModuleFileCache,
         provider: FirProvider,
         phase: FirResolvePhase,
+        scopeSession: ScopeSession,
         towerDataContextCollector: FirTowerDataContextCollector?,
     ) {
         val nonLocalDeclarationToResolve = firDeclarationToResolve.getNonLocalDeclarationToResolve(provider, moduleFileCache)
@@ -160,7 +165,6 @@ internal class FirLazyDeclarationResolver(
         if (designation.all { it.resolvePhase >= phase }) {
             return
         }
-        val scopeSession = firFileBuilder.firPhaseRunner.transformerProvider.getScopeSession(containerFirFile.session)
         val transformer = when (phase) {
             FirResolvePhase.CONTRACTS -> FirDesignatedContractsResolveTransformerForIDE(
                 designation.iterator(),

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

@@ -29,7 +29,6 @@ import org.jetbrains.kotlin.fir.session.*
 import org.jetbrains.kotlin.idea.caches.project.*
 import org.jetbrains.kotlin.idea.caches.resolve.IDEPackagePartProvider
 import org.jetbrains.kotlin.idea.fir.low.level.api.FirPhaseRunner
-import org.jetbrains.kotlin.idea.fir.low.level.api.FirTransformerProvider
 import org.jetbrains.kotlin.idea.fir.low.level.api.IdeFirPhaseManager
 import org.jetbrains.kotlin.idea.fir.low.level.api.IdeSessionComponents
 import org.jetbrains.kotlin.idea.fir.low.level.api.file.builder.FirFileBuilder

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

@@ -12,7 +12,6 @@ import kotlinx.collections.immutable.toPersistentMap
 import org.jetbrains.kotlin.fir.BuiltinTypes
 import org.jetbrains.kotlin.idea.caches.project.ModuleSourceInfo
 import org.jetbrains.kotlin.idea.fir.low.level.api.FirPhaseRunner
-import org.jetbrains.kotlin.idea.fir.low.level.api.FirTransformerProvider
 import org.jetbrains.kotlin.idea.fir.low.level.api.trackers.KotlinFirOutOfBlockModificationTrackerFactory
 import org.jetbrains.kotlin.idea.fir.low.level.api.util.addValueFor
 import org.jetbrains.kotlin.idea.fir.low.level.api.util.executeWithoutPCE
@@ -23,8 +22,7 @@ internal class FirIdeSessionProviderStorage(private val project: Project) {
     private val sessionsCache = ConcurrentHashMap<ModuleSourceInfo, FromModuleViewSessionCache>()
 
     fun getSessionProvider(rootModule: ModuleSourceInfo): FirIdeSessionProvider {
-        val transformerProvider = FirTransformerProvider()
+        val firPhaseRunner = FirPhaseRunner()
-        val firPhaseRunner = FirPhaseRunner(transformerProvider)
 
         val builtinTypes = BuiltinTypes()
         val builtinsAndCloneableSession = FirIdeSessionFactory.createBuiltinsAndCloneableSession(project, builtinTypes)

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

@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.calls.FirSyntheticPropertiesScope
 import org.jetbrains.kotlin.fir.resolve.scope
 import org.jetbrains.kotlin.fir.scopes.*
@@ -79,13 +80,12 @@ internal class KtFirScopeProvider(
                 val firSession = fir.session
                 fir.unsubstitutedScope(
                     firSession,
-                    firResolveState.firTransformerProvider.getScopeSession(firSession),
+                    ScopeSession(),
                     withForcedTypeCalculator = false
                 )
             } ?: return@getOrPut KtFirEmptyMemberScope(classSymbol)
 
             firScopeStorage.register(firScope)
-
             KtFirMemberScope(classSymbol, firScope, token, builder)
         }
     }
@@ -129,7 +129,7 @@ internal class KtFirScopeProvider(
         val firSession = firResolveState.rootModuleSession
         val firTypeScope = type.coneType.scope(
             firSession,
-            firResolveState.firTransformerProvider.getScopeSession(firSession),
+            ScopeSession(),
             FakeOverrideTypeCalculator.Forced
         ) ?: return null
         return getCompositeScope(