[LL API] Encapsulate on-air class provider logic in LLFirProvider

The old 'FirProviderInterceptor' is too invasive, ad-hoc, and only a
few places in the compiler are aware of it.

This fixes the test 'FirOnAirResolveTestGenerated#testOnAirTypesResolve'
which started failing after the designation path collection refactoring.
The newly appeared class existence check started to fail:

```
val declaration = firProvider.getFirClassifierByFqName(classId)
check(declaration != null)
```

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/LLFirModuleLazyDeclarationResolver.kt

@@ -12,8 +12,8 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.tryCollectDesignation
 import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.llFirModuleData
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSessionInvalidator
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.llFirSession
-import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirFirProviderInterceptor
 import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformerExecutor
+import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.withSyntheticClasses
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkCanceled
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getContainingFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.withFirEntry
@@ -163,8 +163,7 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod
                 scopeSession = scopeSession,
                 phaseRunner = moduleComponents.globalResolveComponents.phaseRunner,
                 lockProvider = moduleComponents.globalResolveComponents.lockProvider,
-                towerDataContextCollector = null,
+                towerDataContextCollector = null
-                firProviderInterceptor = null,
             )
         }
     }
@@ -175,31 +174,30 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod
         towerDataContextCollector: FirTowerDataContextCollector?,
     ) {
         resolveFileToImportsWithoutLock(designation.firFile)
-        var currentPhase = maxOf(designation.target.resolvePhase, FirResolvePhase.IMPORTS)
 
-        val scopeSession = ScopeSession()
+        fun runTransformation() {
+            val scopeSession = ScopeSession()
+            var currentPhase = maxOf(designation.target.resolvePhase, FirResolvePhase.IMPORTS)
 
-        val firProviderInterceptor = if (onAirCreatedDeclaration) {
+            while (currentPhase < FirResolvePhase.BODY_RESOLVE) {
-            LLFirFirProviderInterceptor.createForFirElement(
+                currentPhase = currentPhase.next
-                session = designation.firFile.moduleData.session,
+                checkCanceled()
-                firFile = designation.firFile,
-                element = designation.target
-            )
-        } else null
 
-        while (currentPhase < FirResolvePhase.BODY_RESOLVE) {
+                LLFirLazyTransformerExecutor.execute(
-            currentPhase = currentPhase.next
+                    phase = currentPhase,
-            checkCanceled()
+                    designation = designation,
+                    scopeSession = scopeSession,
+                    phaseRunner = moduleComponents.globalResolveComponents.phaseRunner,
+                    lockProvider = moduleComponents.globalResolveComponents.lockProvider,
+                    towerDataContextCollector = towerDataContextCollector
+                )
+            }
+        }
 
-            LLFirLazyTransformerExecutor.execute(
+        if (onAirCreatedDeclaration) {
-                phase = currentPhase,
+            withSyntheticClasses(designation, ::runTransformation)
-                designation = designation,
+        } else {
-                scopeSession = scopeSession,
+            runTransformation()
-                phaseRunner = moduleComponents.globalResolveComponents.phaseRunner,
-                lockProvider = moduleComponents.globalResolveComponents.lockProvider,
-                towerDataContextCollector = towerDataContextCollector,
-                firProviderInterceptor = firProviderInterceptor,
-            )
         }
     }
 }

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/providers/LLFirLibrarySessionProvider.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.low.level.api.fir.providers
 
+import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.SyntheticFirClassProvider
 import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.resolve.providers.FirProvider
@@ -17,8 +18,10 @@ import org.jetbrains.kotlin.name.Name
 internal class LLFirLibrarySessionProvider(
     override val symbolProvider: FirSymbolProvider
 ) : FirProvider() {
-    override fun getFirClassifierByFqName(classId: ClassId): FirClassLikeDeclaration? =
+    override fun getFirClassifierByFqName(classId: ClassId): FirClassLikeDeclaration? {
-        symbolProvider.getClassLikeSymbolByClassId(classId)?.fir
+        return SyntheticFirClassProvider.getInstance(symbolProvider.session).getFirClassifierByFqName(classId)
+            ?: symbolProvider.getClassLikeSymbolByClassId(classId)?.fir
+    }
 
     override fun getFirClassifierContainerFile(fqName: ClassId): FirFile = shouldNotBeCalled()
 

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/providers/LLFirProvider.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.providers
 
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirModuleResolveComponents
+import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.SyntheticFirClassProvider
 import org.jetbrains.kotlin.analysis.providers.KotlinDeclarationProvider
 import org.jetbrains.kotlin.analysis.providers.KotlinPackageProvider
 import org.jetbrains.kotlin.fir.FirSession
@@ -44,8 +45,10 @@ internal class LLFirProvider(
 
     override val isPhasedFirAllowed: Boolean get() = true
 
-    override fun getFirClassifierByFqName(classId: ClassId): FirClassLikeDeclaration? =
+    override fun getFirClassifierByFqName(classId: ClassId): FirClassLikeDeclaration? {
-        providerHelper.getFirClassifierByFqName(classId)
+        return SyntheticFirClassProvider.getInstance(session).getFirClassifierByFqName(classId)
+            ?: providerHelper.getFirClassifierByFqName(classId)
+    }
 
     override fun getFirClassifierContainerFile(fqName: ClassId): FirFile {
         return getFirClassifierContainerFileIfAny(fqName)
@@ -53,8 +56,8 @@ internal class LLFirProvider(
     }
 
     override fun getFirClassifierContainerFileIfAny(fqName: ClassId): FirFile? {
-        val fir = getFirClassifierByFqName(fqName) ?: return null // Necessary to ensure cacheProvider contains this classifier
+        return SyntheticFirClassProvider.getInstance(session).getFirClassifierContainerFileIfAny(fqName)
-        return moduleComponents.cache.getContainerFirFile(fir)
+            ?: getFirClassifierByFqName(fqName)?.let { moduleComponents.cache.getContainerFirFile(it) }
     }
 
     override fun getFirClassifierContainerFile(symbol: FirClassLikeSymbol<*>): FirFile {
@@ -62,9 +65,10 @@ internal class LLFirProvider(
             ?: error("Couldn't find container for ${symbol.classId}")
     }
 
-    override fun getFirClassifierContainerFileIfAny(symbol: FirClassLikeSymbol<*>): FirFile? =
+    override fun getFirClassifierContainerFileIfAny(symbol: FirClassLikeSymbol<*>): FirFile? {
-        moduleComponents.cache.getContainerFirFile(symbol.fir)
+        return SyntheticFirClassProvider.getInstance(session).getFirClassifierContainerFileIfAny(symbol.classId)
-
+            ?: moduleComponents.cache.getContainerFirFile(symbol.fir)
+    }
 
     override fun getFirCallableContainerFile(symbol: FirCallableSymbol<*>): FirFile? {
         symbol.fir.originalForSubstitutionOverride?.symbol?.let { originalSymbol ->

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedBodyResolveTransformer.kt

@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.fir.FirSession
 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.FirProviderInterceptor
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformer
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirTowerDataContextCollector
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyResolveComputationSession
@@ -28,8 +27,7 @@ internal class LLFirDesignatedBodyResolveTransformer(
     private val designation: FirDesignationWithFile,
     session: FirSession,
     scopeSession: ScopeSession,
-    towerDataContextCollector: FirTowerDataContextCollector?,
+    towerDataContextCollector: FirTowerDataContextCollector?
-    firProviderInterceptor: FirProviderInterceptor?,
 ) : LLFirLazyTransformer, FirBodyResolveTransformer(
     session,
     phase = FirResolvePhase.BODY_RESOLVE,
@@ -40,8 +38,7 @@ internal class LLFirDesignatedBodyResolveTransformer(
         ImplicitBodyResolveComputationSession(),
         ::LLFirEnsureBasedTransformerForReturnTypeCalculator
     ),
-    firTowerDataContextCollector = towerDataContextCollector,
+    firTowerDataContextCollector = towerDataContextCollector
-    firProviderInterceptor = firProviderInterceptor,
 ) {
     private val ideDeclarationTransformer = LLFirDeclarationTransformer(designation)
 

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedSupertypeResolverTransformer.kt

@@ -35,8 +35,7 @@ internal class LLFirDesignatedSupertypeResolverTransformer(
     private val designation: FirDesignationWithFile,
     private val session: FirSession,
     private val scopeSession: ScopeSession,
-    private val lockProvider: LLFirLockProvider,
+    private val lockProvider: LLFirLockProvider
-    private val firProviderInterceptor: FirProviderInterceptor?,
 ) : LLFirLazyTransformer {
 
     private val supertypeComputationSession = SupertypeComputationSession()
@@ -47,8 +46,7 @@ internal class LLFirDesignatedSupertypeResolverTransformer(
             supertypeComputationSession = supertypeComputationSession,
             scopeSession = scopeSession,
             scopeForLocalClass = null,
-            localClassesNavigationInfo = null,
+            localClassesNavigationInfo = null
-            firProviderInterceptor = firProviderInterceptor,
         ) {
         val declarationTransformer = LLFirDeclarationTransformer(classDesignation)
 

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirFirProviderInterceptor.kt

@@ -1,49 +0,0 @@
-/*
- * Copyright 2010-2021 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.analysis.low.level.api.fir.transformers
-
-import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirFile
-import org.jetbrains.kotlin.fir.resolve.providers.firProvider
-import org.jetbrains.kotlin.fir.resolve.transformers.FirProviderInterceptor
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
-import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
-import org.jetbrains.kotlin.name.ClassId
-
-internal class LLFirFirProviderInterceptor private constructor(
-    private val firFile: FirFile,
-    private val session: FirSession,
-    private val symbolSet: Set<FirClassLikeSymbol<*>>,
-    private val classIdToElementMap: Map<ClassId, FirClassLikeDeclaration>
-) : FirProviderInterceptor {
-
-    override fun getFirClassifierContainerFileIfAny(symbol: FirClassLikeSymbol<*>): FirFile? =
-        if (symbolSet.contains(symbol)) firFile else session.firProvider.getFirClassifierContainerFileIfAny(symbol)
-
-    override fun getFirClassifierByFqName(classId: ClassId): FirClassLikeDeclaration? =
-        classIdToElementMap[classId] ?: session.firProvider.getFirClassifierByFqName(classId)
-
-    companion object {
-        fun createForFirElement(session: FirSession, firFile: FirFile, element: FirElement): FirProviderInterceptor {
-            val nodeInfoCollector = object : FirVisitorVoid() {
-                val symbolSet = mutableSetOf<FirClassLikeSymbol<*>>()
-                val classIdToElementMap = mutableMapOf<ClassId, FirClassLikeDeclaration>()
-                override fun visitElement(element: FirElement) {
-                    if (element is FirClassLikeDeclaration) {
-                        symbolSet.add(element.symbol)
-                        classIdToElementMap[element.symbol.classId] = element
-                    }
-                    element.acceptChildren(this)
-                }
-            }
-            nodeInfoCollector.visitElement(element)
-
-            return LLFirFirProviderInterceptor(firFile, session, nodeInfoCollector.symbolSet, nodeInfoCollector.classIdToElementMap)
-        }
-    }
-}

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyTransformerExecutor.kt

@@ -10,7 +10,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFil
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.resolve.transformers.FirProviderInterceptor
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirTowerDataContextCollector
 
 internal class LLFirLazyTransformerExecutor {
@@ -21,8 +20,7 @@ internal class LLFirLazyTransformerExecutor {
             scopeSession: ScopeSession,
             phaseRunner: LLFirPhaseRunner,
             lockProvider: LLFirLockProvider,
-            towerDataContextCollector: FirTowerDataContextCollector?,
+            towerDataContextCollector: FirTowerDataContextCollector?
-            firProviderInterceptor: FirProviderInterceptor?,
         ) {
 
             val lazyTransformer = LazyTransformerFactory.createLazyTransformer(
@@ -30,8 +28,7 @@ internal class LLFirLazyTransformerExecutor {
                 designation,
                 scopeSession,
                 lockProvider,
-                towerDataContextCollector,
+                towerDataContextCollector
-                firProviderInterceptor,
             )
             lazyTransformer.transformDeclaration(phaseRunner)
         }

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LazyTransformerFactory.kt

@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFil
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.resolve.transformers.FirProviderInterceptor
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirTowerDataContextCollector
 
 internal object LazyTransformerFactory {
@@ -18,8 +17,7 @@ internal object LazyTransformerFactory {
         designation: FirDesignationWithFile,
         scopeSession: ScopeSession,
         lockProvider: LLFirLockProvider,
-        towerDataContextCollector: FirTowerDataContextCollector?,
+        towerDataContextCollector: FirTowerDataContextCollector?
-        firProviderInterceptor: FirProviderInterceptor?,
     ): LLFirLazyTransformer = when (phase) {
         FirResolvePhase.COMPANION_GENERATION -> LLFirDesignatedGeneratedCompanionObjectResolveTransformer(
             designation = designation,
@@ -30,8 +28,7 @@ internal object LazyTransformerFactory {
             designation = designation,
             session = designation.firFile.moduleData.session,
             scopeSession = scopeSession,
-            lockProvider = lockProvider,
+            lockProvider = lockProvider
-            firProviderInterceptor = firProviderInterceptor,
         )
         FirResolvePhase.TYPES -> LLFirDesignatedTypeResolverTransformer(
             designation,
@@ -73,8 +70,7 @@ internal object LazyTransformerFactory {
             designation,
             designation.firFile.moduleData.session,
             scopeSession,
-            towerDataContextCollector,
+            towerDataContextCollector
-            firProviderInterceptor,
         )
         FirResolvePhase.EXPECT_ACTUAL_MATCHING -> LLFirDesignatedExpectActualMatcherTransformer(
             designation,

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/SyntheticFirClassProvider.kt

@@ -0,0 +1,105 @@
+/*
+ * Copyright 2010-2021 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.analysis.low.level.api.fir.transformers
+
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirFile
+import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
+import org.jetbrains.kotlin.name.ClassId
+import java.util.WeakHashMap
+
+internal interface SyntheticFirClassProvider {
+    fun getFirClassifierContainerFileIfAny(classId: ClassId): FirFile?
+    fun getFirClassifierByFqName(classId: ClassId): FirClassLikeDeclaration?
+
+    companion object {
+        fun getInstance(session: FirSession): SyntheticFirClassProvider {
+            return providersForThread.get()[session] ?: EmptySyntheticFirClassProvider
+        }
+    }
+}
+
+internal fun withSyntheticClasses(designation: FirDesignationWithFile, block: () -> Unit) {
+    val firSession = designation.firFile.moduleData.session
+
+    val compoundProvider = providersForThread.get()
+        .getOrPut(firSession) { CompoundSyntheticFirClassProvider() }
+
+    val provider = StaticSyntheticFirClassProvider.create(designation)
+
+    try {
+        compoundProvider.push(provider)
+        block()
+    } finally {
+        compoundProvider.pop(provider)
+    }
+}
+
+private class StaticSyntheticFirClassProvider private constructor(
+    private val firFile: FirFile,
+    private val classes: Map<ClassId, FirClassLikeDeclaration>
+) : SyntheticFirClassProvider {
+    override fun getFirClassifierContainerFileIfAny(classId: ClassId): FirFile? {
+        return if (classId in classes) firFile else null
+    }
+
+    override fun getFirClassifierByFqName(classId: ClassId): FirClassLikeDeclaration? {
+        return classes[classId]
+    }
+
+    companion object {
+        fun create(designation: FirDesignationWithFile): SyntheticFirClassProvider {
+            val firFile = designation.firFile
+            val firElement = designation.target
+
+            val nodeInfoCollector = object : FirVisitorVoid() {
+                val classes = mutableMapOf<ClassId, FirClassLikeDeclaration>()
+                override fun visitElement(element: FirElement) {
+                    if (element is FirClassLikeDeclaration) {
+                        classes[element.symbol.classId] = element
+                    }
+                    element.acceptChildren(this)
+                }
+            }
+
+            nodeInfoCollector.visitElement(firElement)
+            return StaticSyntheticFirClassProvider(firFile, nodeInfoCollector.classes)
+        }
+    }
+}
+
+private class CompoundSyntheticFirClassProvider : SyntheticFirClassProvider {
+    private val providers = ArrayDeque<SyntheticFirClassProvider>()
+
+    fun push(provider: SyntheticFirClassProvider) {
+        providers.addFirst(provider)
+    }
+
+    fun pop(provider: SyntheticFirClassProvider) {
+        assert(providers.removeFirst() === provider)
+    }
+
+    override fun getFirClassifierContainerFileIfAny(classId: ClassId): FirFile? {
+        return providers.asReversed()
+            .firstNotNullOfOrNull { it.getFirClassifierContainerFileIfAny(classId) }
+    }
+
+    override fun getFirClassifierByFqName(classId: ClassId): FirClassLikeDeclaration? {
+        return providers.asReversed()
+            .firstNotNullOfOrNull { it.getFirClassifierByFqName(classId) }
+    }
+}
+
+private object EmptySyntheticFirClassProvider : SyntheticFirClassProvider {
+    override fun getFirClassifierContainerFileIfAny(classId: ClassId) = null
+    override fun getFirClassifierByFqName(classId: ClassId) = null
+}
+
+private val providersForThread: ThreadLocal<WeakHashMap<FirSession, CompoundSyntheticFirClassProvider>> =
+    ThreadLocal.withInitial { WeakHashMap() }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt

@@ -50,14 +50,6 @@ class FirSupertypeResolverProcessor(session: FirSession, scopeSession: ScopeSess
     override val transformer = FirSupertypeResolverTransformer(session, scopeSession)
 }
 
-/**
- * Interceptor needed by IDE to resolve in-air created declarations.
- */
-interface FirProviderInterceptor {
-    fun getFirClassifierContainerFileIfAny(symbol: FirClassLikeSymbol<*>): FirFile?
-    fun getFirClassifierByFqName(classId: ClassId): FirClassLikeDeclaration?
-}
-
 open class FirSupertypeResolverTransformer(
     final override val session: FirSession,
     scopeSession: ScopeSession
@@ -84,7 +76,6 @@ fun <F : FirClassLikeDeclaration> F.runSupertypeResolvePhaseForLocalClass(
     scopeSession: ScopeSession,
     currentScopeList: List<FirScope>,
     localClassesNavigationInfo: LocalClassesNavigationInfo,
-    firProviderInterceptor: FirProviderInterceptor?,
     useSiteFile: FirFile,
     containingDeclarations: List<FirDeclaration>,
 ): F {
@@ -93,7 +84,6 @@ fun <F : FirClassLikeDeclaration> F.runSupertypeResolvePhaseForLocalClass(
         session, supertypeComputationSession, scopeSession,
         currentScopeList.toPersistentList(),
         localClassesNavigationInfo,
-        firProviderInterceptor,
         useSiteFile,
         containingDeclarations,
     )
@@ -220,7 +210,6 @@ open class FirSupertypeResolverVisitor(
     private val scopeSession: ScopeSession,
     private val scopeForLocalClass: PersistentList<FirScope>? = null,
     private val localClassesNavigationInfo: LocalClassesNavigationInfo? = null,
-    private val firProviderInterceptor: FirProviderInterceptor? = null,
     @property:PrivateForInline var useSiteFile: FirFile? = null,
     containingDeclarations: List<FirDeclaration> = emptyList(),
 ) : FirDefaultVisitor<Unit, Any?>() {
@@ -246,13 +235,13 @@ open class FirSupertypeResolverVisitor(
         }
     }
 
-    private fun getFirClassifierContainerFileIfAny(symbol: FirClassLikeSymbol<*>): FirFile? =
+    private fun getFirClassifierContainerFileIfAny(symbol: FirClassLikeSymbol<*>): FirFile? {
-        if (firProviderInterceptor != null) firProviderInterceptor.getFirClassifierContainerFileIfAny(symbol)
+        return symbol.moduleData.session.firProvider.getFirClassifierContainerFileIfAny(symbol.classId)
-        else symbol.moduleData.session.firProvider.getFirClassifierContainerFileIfAny(symbol.classId)
+    }
 
-    private fun getFirClassifierByFqName(moduleSession: FirSession, classId: ClassId): FirClassLikeDeclaration? =
+    private fun getFirClassifierByFqName(moduleSession: FirSession, classId: ClassId): FirClassLikeDeclaration? {
-        if (firProviderInterceptor != null) firProviderInterceptor.getFirClassifierByFqName(classId)
+        return moduleSession.firProvider.getFirClassifierByFqName(classId)
-        else moduleSession.firProvider.getFirClassifierByFqName(classId)
+    }
 
     override fun visitElement(element: FirElement, data: Any?) {}
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformerDispatcher.kt

@@ -10,19 +10,9 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.resolve.calls.ResolutionContext
-import org.jetbrains.kotlin.fir.resolve.calls.ResolutionStageRunner
 import org.jetbrains.kotlin.fir.resolve.dfa.DataFlowAnalyzerContext
-import org.jetbrains.kotlin.fir.resolve.dfa.FirDataFlowAnalyzer
-import org.jetbrains.kotlin.fir.resolve.inference.FirCallCompleter
-import org.jetbrains.kotlin.fir.resolve.inference.InferenceComponents
-import org.jetbrains.kotlin.fir.resolve.inference.inferenceComponents
-import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
-import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
 import org.jetbrains.kotlin.fir.resolve.transformers.*
-import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.scopes.impl.FirLocalScope
 import org.jetbrains.kotlin.fir.types.*
-import org.jetbrains.kotlin.fir.types.builder.buildImplicitTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
 abstract class FirAbstractBodyResolveTransformerDispatcher(
@@ -33,7 +23,6 @@ abstract class FirAbstractBodyResolveTransformerDispatcher(
     val returnTypeCalculator: ReturnTypeCalculator = ReturnTypeCalculatorForFullBodyResolve,
     outerBodyResolveContext: BodyResolveContext? = null,
     val firTowerDataContextCollector: FirTowerDataContextCollector? = null,
-    val firProviderInterceptor: FirProviderInterceptor? = null,
 ) : FirAbstractBodyResolveTransformer(phase) {
 
     final override val context: BodyResolveContext =

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt

@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.resolve.transformers.body.resolve
 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.FirProviderInterceptor
 import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator
 import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculatorForFullBodyResolve
 
@@ -19,8 +18,7 @@ open class FirBodyResolveTransformer(
     scopeSession: ScopeSession,
     returnTypeCalculator: ReturnTypeCalculator = ReturnTypeCalculatorForFullBodyResolve,
     outerBodyResolveContext: BodyResolveContext? = null,
-    firTowerDataContextCollector: FirTowerDataContextCollector? = null,
+    firTowerDataContextCollector: FirTowerDataContextCollector? = null
-    firProviderInterceptor: FirProviderInterceptor? = null,
 ) : FirAbstractBodyResolveTransformerDispatcher(
     session,
     phase,
@@ -28,8 +26,7 @@ open class FirBodyResolveTransformer(
     scopeSession,
     returnTypeCalculator,
     outerBodyResolveContext,
-    firTowerDataContextCollector,
+    firTowerDataContextCollector
-    firProviderInterceptor,
 ) {
     final override val expressionsTransformer = FirExpressionsResolveTransformer(this)
     final override val declarationsTransformer = FirDeclarationsResolveTransformer(this)

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt

@@ -493,13 +493,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirAbstractBodyResolve
     override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): FirStatement = whileAnalysing(session, regularClass) {
         return context.withContainingClass(regularClass) {
             if (regularClass.isLocal && regularClass !in context.targetedLocalClasses) {
-                return regularClass.runAllPhasesForLocalClass(
+                return regularClass.runAllPhasesForLocalClass(transformer, components, data, transformer.firTowerDataContextCollector)
-                    transformer,
-                    components,
-                    data,
-                    transformer.firTowerDataContextCollector,
-                    transformer.firProviderInterceptor
-                )
             }
 
             doTransformTypeParameters(regularClass)
@@ -519,13 +513,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirAbstractBodyResolve
 
     override fun transformTypeAlias(typeAlias: FirTypeAlias, data: ResolutionMode): FirTypeAlias = whileAnalysing(session, typeAlias) {
         if (typeAlias.isLocal && typeAlias !in context.targetedLocalClasses) {
-            return typeAlias.runAllPhasesForLocalClass(
+            return typeAlias.runAllPhasesForLocalClass(transformer, components, data, transformer.firTowerDataContextCollector)
-                transformer,
-                components,
-                data,
-                transformer.firTowerDataContextCollector,
-                transformer.firProviderInterceptor
-            )
         }
         doTransformTypeParameters(typeAlias)
         typeAlias.transformAnnotations(transformer, data)
@@ -554,13 +542,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirAbstractBodyResolve
         data: ResolutionMode
     ): FirStatement = whileAnalysing(session, anonymousObject) {
         if (anonymousObject !in context.targetedLocalClasses) {
-            return anonymousObject.runAllPhasesForLocalClass(
+            return anonymousObject.runAllPhasesForLocalClass(transformer, components, data, transformer.firTowerDataContextCollector)
-                transformer,
-                components,
-                data,
-                transformer.firTowerDataContextCollector,
-                transformer.firProviderInterceptor
-            )
         }
         // TODO: why would there be a graph already?
         val buildGraph = !implicitTypeOnly && anonymousObject.controlFlowGraphReference == null

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/LocalClassesResolution.kt

@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.fir.resolve.transformers.body.resolve
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.ResolutionMode
 import org.jetbrains.kotlin.fir.resolve.createCurrentScopeList
-import org.jetbrains.kotlin.fir.resolve.transformers.FirProviderInterceptor
 import org.jetbrains.kotlin.fir.resolve.transformers.plugin.runCompilerRequiredAnnotationsResolvePhaseForLocalClass
 import org.jetbrains.kotlin.fir.resolve.transformers.plugin.runCompanionGenerationPhaseForLocalClass
 import org.jetbrains.kotlin.fir.resolve.transformers.runStatusResolveForLocalClass
@@ -19,8 +18,7 @@ fun <F : FirClassLikeDeclaration> F.runAllPhasesForLocalClass(
     transformer: FirAbstractBodyResolveTransformer,
     components: FirAbstractBodyResolveTransformer.BodyResolveTransformerComponents,
     resolutionMode: ResolutionMode,
-    firTowerDataContextCollector: FirTowerDataContextCollector?,
+    firTowerDataContextCollector: FirTowerDataContextCollector?
-    firProviderInterceptor: FirProviderInterceptor?,
 ): F {
     if (status is FirResolvedDeclarationStatus) return this
     if (this is FirRegularClass) {
@@ -47,7 +45,6 @@ fun <F : FirClassLikeDeclaration> F.runAllPhasesForLocalClass(
         components.scopeSession,
         components.createCurrentScopeList(),
         localClassesNavigationInfo,
-        firProviderInterceptor,
         components.file,
         components.containingDeclarations,
     )