[FIR] Introduce FirResolveProcessors

benchmarks/src/org/jetbrains/kotlin/benchmarks/AbstractSimpleFileBenchmark.kt

@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.fir.java.FirLibrarySession
 import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
 import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.impl.FirProviderImpl
-import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveTransformer
+import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveProcessor
 import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.TargetPlatform
@@ -164,12 +164,10 @@ abstract class AbstractSimpleFileBenchmark {
         val firProvider = session.firProvider as FirProviderImpl
         val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider, stubMode = false)
 
-        val totalTransformer = FirTotalResolveTransformer(session)
+        val totalTransformer = FirTotalResolveProcessor(session)
         val firFile = builder.buildFirFile(file).also(firProvider::recordFile)
 
-        for (transformer in totalTransformer.transformers) {
+        totalTransformer.process(listOf(firFile))
-            transformer.transformFile(firFile, null)
-        }
 
         bh.consume(firFile.hashCode())
     }

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.kt

@@ -64,7 +64,7 @@ import org.jetbrains.kotlin.fir.java.FirLibrarySession
 import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
 import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.impl.FirProviderImpl
-import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveTransformer
+import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveProcessor
 import org.jetbrains.kotlin.idea.MainFunctionDetector
 import org.jetbrains.kotlin.ir.backend.jvm.jvmResolveLibraries
 import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmManglerDesc
@@ -333,14 +333,14 @@ object KotlinToJVMBytecodeCompiler {
             }
             val firProvider = (session.firProvider as FirProviderImpl)
             val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider, stubMode = false)
-            val resolveTransformer = FirTotalResolveTransformer(session)
+            val resolveTransformer = FirTotalResolveProcessor(session)
             val firFiles = ktFiles.map {
                 val firFile = builder.buildFirFile(it)
                 firProvider.recordFile(firFile)
                 firFile
             }.also {
                 try {
-                    resolveTransformer.processFiles(it)
+                    resolveTransformer.process(it)
                 } catch (e: Exception) {
                     throw e
                 }

compiler/fir/fir2ir/tests/org/jetbrains/kotlin/fir/AbstractFir2IrTextTest.kt

@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.backend.Fir2IrConverter
 import org.jetbrains.kotlin.fir.builder.RawFirBuilder
 import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.impl.FirProviderImpl
-import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveTransformer
+import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveProcessor
 import org.jetbrains.kotlin.ir.AbstractIrTextTestCase
 import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmManglerDesc
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
@@ -68,14 +68,14 @@ abstract class AbstractFir2IrTextTest : AbstractIrTextTestCase() {
         val firProvider = (session.firProvider as FirProviderImpl)
         val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider, stubMode = false)
 
-        val resolveTransformer = FirTotalResolveTransformer(session)
+        val resolveTransformer = FirTotalResolveProcessor(session)
         val firFiles = psiFiles.map {
             val firFile = builder.buildFirFile(it)
             firProvider.recordFile(firFile)
             firFile
         }.also {
             try {
-                resolveTransformer.processFiles(it)
+                resolveTransformer.process(it)
             } catch (e: Exception) {
                 throw e
             }

compiler/fir/modularized-tests/tests/org/jetbrains/kotlin/fir/FirResolveModularizedTotalKotlinTest.kt

@@ -21,7 +21,8 @@ import org.jetbrains.kotlin.fir.dump.MultiModuleHtmlFirDump
 import org.jetbrains.kotlin.fir.lightTree.LightTree2Fir
 import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.impl.FirProviderImpl
-import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveTransformer
+import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveProcessor
+import org.jetbrains.kotlin.fir.resolve.transformers.createAllResolveProcessors
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import java.io.File
 import java.io.FileOutputStream
@@ -55,7 +56,7 @@ class FirResolveModularizedTotalKotlinTest : AbstractModularizedTest() {
             .uniteWith(TopDownAnalyzerFacadeForJVM.AllJavaSourcesInProjectScope(project))
         val librariesScope = ProjectScope.getLibrariesScope(project)
         val session = createSession(environment, scope, librariesScope, moduleData.qualifiedName)
-        val totalTransformer = FirTotalResolveTransformer(session)
+        val processors = createAllResolveProcessors(session)
 
         val firProvider = session.firProvider as FirProviderImpl
         val firFiles = if (useLightTree) {
@@ -68,7 +69,7 @@ class FirResolveModularizedTotalKotlinTest : AbstractModularizedTest() {
 
         //println("Raw FIR up, files: ${firFiles.size}")
 
-        bench.processFiles(firFiles, totalTransformer.transformers)
+        bench.processFiles(firFiles, processors)
 
         val disambiguatedName = moduleData.disambiguatedName()
         dumpFir(disambiguatedName, moduleData, firFiles)

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

@@ -59,7 +59,7 @@ fun FirFile.runResolve(toPhase: FirResolvePhase, fromPhase: FirResolvePhase = Fi
     var currentPhase = fromPhase
     while (currentPhase < toPhase) {
         currentPhase = currentPhase.next
-        val phaseTransformer = currentPhase.createTransformerByPhase(session, scopeSession)
+        val phaseProcessor = currentPhase.createTransformerBasedProcessorByPhase(session, scopeSession)
-        transform<FirFile, Nothing?>(phaseTransformer, null)
+        phaseProcessor.processFile(this)
     }
 }

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

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.fir.declarations.FirImport
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.builder.buildResolvedImport
 import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
+import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
@@ -19,6 +20,10 @@ import org.jetbrains.kotlin.fir.visitors.compose
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 
+class FirImportResolveProcessor(session: FirSession, scopeSession: ScopeSession) : FirTransformerBasedResolveProcessor(session, scopeSession) {
+    override val transformer = FirImportResolveTransformer(session)
+}
+
 open class FirImportResolveTransformer protected constructor(
     final override val session: FirSession,
     phase: FirResolvePhase

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

@@ -0,0 +1,31 @@
+/*
+ * 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.fir.resolve.transformers
+
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirFile
+import org.jetbrains.kotlin.fir.resolve.ScopeSession
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+
+@RequiresOptIn(message = "Should be used just only in resolve processor")
+annotation class AdapterForResolveProcessor
+
+sealed class FirResolveProcessor(val session: FirSession, val scopeSession: ScopeSession)
+
+abstract class FirGlobalResolveProcessor(session: FirSession, scopeSession: ScopeSession) : FirResolveProcessor(session, scopeSession) {
+    abstract fun process()
+}
+
+abstract class FirTransformerBasedResolveProcessor(
+    session: FirSession,
+    scopeSession: ScopeSession
+) : FirResolveProcessor(session, scopeSession) {
+    abstract val transformer: FirTransformer<Nothing?>
+
+    fun processFile(file: FirFile) {
+        file.transform<FirFile, Nothing?>(transformer, null)
+    }
+}

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

@@ -7,10 +7,13 @@ package org.jetbrains.kotlin.fir.resolve.transformers
 
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.FirStatement
 import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
+import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
+import org.jetbrains.kotlin.fir.resolve.transformers.plugin.FirPluginAnnotationsResolveTransformer
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
@@ -24,6 +27,10 @@ import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.compose
 import org.jetbrains.kotlin.name.ClassId
 
+class FirSealedClassInheritorsProcessor(session: FirSession, scopeSession: ScopeSession) : FirTransformerBasedResolveProcessor(session, scopeSession) {
+    override val transformer = FirSealedClassInheritorsTransformer()
+}
+
 class FirSealedClassInheritorsTransformer : FirTransformer<Nothing?>() {
     override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
         throw IllegalStateException("Should not be there")

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

@@ -14,11 +14,16 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.expressions.FirStatement
-import org.jetbrains.kotlin.fir.extensions.statusTransformerExtensions
+import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
 import org.jetbrains.kotlin.fir.visitors.compose
 import org.jetbrains.kotlin.fir.visitors.transformSingle
 
+@OptIn(AdapterForResolveProcessor::class)
+class FirStatusResolveProcessor(session: FirSession, scopeSession: ScopeSession) : FirTransformerBasedResolveProcessor(session, scopeSession) {
+    override val transformer = FirStatusResolveTransformer(session)
+}
+
 fun <F : FirClass<F>> F.runStatusResolveForLocalClass(session: FirSession): F {
     val transformer = FirStatusResolveTransformer(session)
 

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

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.FirStatement
 import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.LocalClassesNavigationInfo
+import org.jetbrains.kotlin.fir.resolve.transformers.plugin.FirPluginAnnotationsResolveTransformer
 import org.jetbrains.kotlin.fir.scopes.FirIterableScope
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.createImportingScopes
@@ -24,6 +25,10 @@ import org.jetbrains.kotlin.fir.visitors.*
 import org.jetbrains.kotlin.utils.addIfNotNull
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
+class FirSupertypeResolverProcessor(session: FirSession, scopeSession: ScopeSession) : FirTransformerBasedResolveProcessor(session, scopeSession) {
+    override val transformer = FirSupertypeResolverTransformer(session, scopeSession)
+}
+
 class FirSupertypeResolverTransformer(
     override val session: FirSession,
     scopeSession: ScopeSession

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

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2010-2018 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.fir.resolve.transformers
+
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirFile
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.resolve.ScopeSession
+
+class FirTotalResolveProcessor(session: FirSession) {
+    val scopeSession: ScopeSession = ScopeSession()
+
+    private val processors: List<FirResolveProcessor> = createAllResolveProcessors(session, scopeSession)
+
+    fun process(files: List<FirFile>) {
+        for (processor in processors) {
+            when (processor) {
+                is FirTransformerBasedResolveProcessor -> {
+                    for (file in files) {
+                        processor.processFile(file)
+                    }
+                }
+                is FirGlobalResolveProcessor -> {
+                    processor.process()
+                }
+            }
+        }
+    }
+}
+
+fun createAllResolveProcessors(
+    session: FirSession,
+    scopeSession: ScopeSession? = null,
+    mode: CompilerMode = CompilerMode.CLI
+): List<FirResolveProcessor> {
+    @Suppress("NAME_SHADOWING")
+    val scopeSession = scopeSession ?: ScopeSession()
+    return FirResolvePhase.values()
+        .drop(1) // to remove RAW_FIR phase
+        .map { it.createProcessorByPhase(session, scopeSession, mode) }
+}
+
+fun createAllTransformerBasedResolveProcessors(
+    session: FirSession,
+    scopeSession: ScopeSession? = null,
+): List<FirTransformerBasedResolveProcessor> {
+    @Suppress("UNCHECKED_CAST")
+    return createAllResolveProcessors(session, scopeSession, CompilerMode.IDE) as List<FirTransformerBasedResolveProcessor>
+}

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

@@ -1,29 +0,0 @@
-/*
- * Copyright 2010-2018 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.fir.resolve.transformers
-
-import org.jetbrains.kotlin.fir.FirSession
-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.visitors.FirTransformer
-
-class FirTotalResolveTransformer(session: FirSession) {
-    val scopeSession = ScopeSession()
-
-    val transformers: List<FirTransformer<Nothing?>> =
-        FirResolvePhase.values()
-            .drop(1) // to remove RAW_FIR phase
-            .map { it.createTransformerByPhase(session, scopeSession) }
-
-    fun processFiles(files: List<FirFile>) {
-        for (transformer in transformers) {
-            for (firFile in files) {
-                firFile.transform<FirFile, Nothing?>(transformer, null)
-            }
-        }
-    }
-}

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

@@ -18,6 +18,10 @@ import org.jetbrains.kotlin.fir.types.impl.FirImplicitBuiltinTypeRef
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
 import org.jetbrains.kotlin.fir.visitors.compose
 
+class FirTypeResolveProcessor(session: FirSession, scopeSession: ScopeSession) : FirTransformerBasedResolveProcessor(session, scopeSession) {
+    override val transformer = FirTypeResolveTransformer(session, scopeSession)
+}
+
 fun <F : FirClass<F>> F.runTypeResolvePhaseForLocalClass(
     session: FirSession,
     scopeSession: ScopeSession,

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

@@ -9,29 +9,35 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase.*
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveTransformerAdapter
+import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveProcessor
-import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirImplicitTypeBodyResolveTransformerAdapter
+import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirImplicitTypeBodyResolveProcessor
-import org.jetbrains.kotlin.fir.resolve.transformers.contracts.FirContractResolveTransformerAdapter
+import org.jetbrains.kotlin.fir.resolve.transformers.contracts.FirContractResolveProcessor
-import org.jetbrains.kotlin.fir.resolve.transformers.plugin.FirPluginAnnotationsResolveTransformer
+import org.jetbrains.kotlin.fir.resolve.transformers.plugin.FirPluginAnnotationsResolveProcessor
-import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
-// TODO: add FirSession parameter
+fun FirResolvePhase.createProcessorByPhase(
-@OptIn(AdapterForResolvePhase::class)
+    session: FirSession,
-fun FirResolvePhase.createTransformerByPhase(session: FirSession, scopeSession: ScopeSession): FirTransformer<Nothing?> {
+    scopeSession: ScopeSession,
+    compilerMode: CompilerMode = CompilerMode.CLI
+): FirResolveProcessor {
     return when (this) {
-        RAW_FIR -> throw AssertionError("Raw FIR building phase does not have a transformer")
+        RAW_FIR -> throw IllegalStateException("Raw FIR building phase does not have a transformer")
-        ANNOTATIONS_FOR_PLUGINS -> FirPluginAnnotationsResolveTransformer(session, scopeSession)
+        ANNOTATIONS_FOR_PLUGINS -> FirPluginAnnotationsResolveProcessor(session, scopeSession)
 //        FIRST_PLUGIN_GENERATION -> FirFirstGenerationTransformer()
-        IMPORTS -> FirImportResolveTransformer(session)
+        IMPORTS -> FirImportResolveProcessor(session, scopeSession)
-        SUPER_TYPES -> FirSupertypeResolverTransformer(session, scopeSession)
+        SUPER_TYPES -> FirSupertypeResolverProcessor(session, scopeSession)
-        SEALED_CLASS_INHERITORS -> FirSealedClassInheritorsTransformer()
+        SEALED_CLASS_INHERITORS -> FirSealedClassInheritorsProcessor(session, scopeSession)
-        TYPES -> FirTypeResolveTransformer(session, scopeSession)
+        TYPES -> FirTypeResolveProcessor(session, scopeSession)
-        STATUS -> FirStatusResolveTransformer(session)
+        STATUS -> FirStatusResolveProcessor(session, scopeSession)
-        CONTRACTS -> FirContractResolveTransformerAdapter(session, scopeSession)
+        CONTRACTS -> FirContractResolveProcessor(session, scopeSession)
-        IMPLICIT_TYPES_BODY_RESOLVE -> FirImplicitTypeBodyResolveTransformerAdapter(session, scopeSession)
+        IMPLICIT_TYPES_BODY_RESOLVE -> FirImplicitTypeBodyResolveProcessor(session, scopeSession)
-        BODY_RESOLVE -> FirBodyResolveTransformerAdapter(session, scopeSession)
+        BODY_RESOLVE -> FirBodyResolveProcessor(session, scopeSession)
     }
 }
 
-@RequiresOptIn(message = "Should be used just once from createTransformerByPhase")
+fun FirResolvePhase.createTransformerBasedProcessorByPhase(session: FirSession, scopeSession: ScopeSession): FirTransformerBasedResolveProcessor {
-annotation class AdapterForResolvePhase
+    return createProcessorByPhase(session, scopeSession, CompilerMode.IDE) as FirTransformerBasedResolveProcessor
+}
+
+enum class CompilerMode {
+    CLI, IDE
+}

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

@@ -11,12 +11,18 @@ import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.resolve.ResolutionMode
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.resolve.transformers.AdapterForResolvePhase
+import org.jetbrains.kotlin.fir.resolve.transformers.AdapterForResolveProcessor
+import org.jetbrains.kotlin.fir.resolve.transformers.FirTransformerBasedResolveProcessor
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.compose
 
-@AdapterForResolvePhase
+@OptIn(AdapterForResolveProcessor::class)
+class FirBodyResolveProcessor(session: FirSession, scopeSession: ScopeSession) : FirTransformerBasedResolveProcessor(session, scopeSession) {
+    override val transformer = FirBodyResolveTransformerAdapter(session, scopeSession)
+}
+
+@AdapterForResolveProcessor
 class FirBodyResolveTransformerAdapter(session: FirSession, scopeSession: ScopeSession) : FirTransformer<Nothing?>() {
     private val transformer = FirBodyResolveTransformer(
         session,

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

@@ -17,8 +17,7 @@ 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.firProvider
-import org.jetbrains.kotlin.fir.resolve.transformers.AdapterForResolvePhase
+import org.jetbrains.kotlin.fir.resolve.transformers.*
-import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator
 import org.jetbrains.kotlin.fir.resolve.transformers.TransformImplicitType
 import org.jetbrains.kotlin.fir.resolve.transformers.contracts.runContractResolveForLocalClass
 import org.jetbrains.kotlin.fir.symbols.impl.FirAccessorSymbol
@@ -30,7 +29,12 @@ import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.compose
 
-@AdapterForResolvePhase
+@OptIn(AdapterForResolveProcessor::class)
+class FirImplicitTypeBodyResolveProcessor(session: FirSession, scopeSession: ScopeSession) : FirTransformerBasedResolveProcessor(session, scopeSession) {
+    override val transformer = FirImplicitTypeBodyResolveTransformerAdapter(session, scopeSession)
+}
+
+@AdapterForResolveProcessor
 class FirImplicitTypeBodyResolveTransformerAdapter(session: FirSession, scopeSession: ScopeSession) : FirTransformer<Nothing?>() {
     private val implicitBodyResolveComputationSession = ImplicitBodyResolveComputationSession()
     private val returnTypeCalculator = ReturnTypeCalculatorWithJump(session, scopeSession, implicitBodyResolveComputationSession).also {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirContractResolveTransformerAdapter.kt

@@ -10,10 +10,10 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirFile
-import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
 import org.jetbrains.kotlin.fir.resolve.ResolutionMode
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.resolve.transformers.AdapterForResolvePhase
+import org.jetbrains.kotlin.fir.resolve.transformers.AdapterForResolveProcessor
+import org.jetbrains.kotlin.fir.resolve.transformers.FirTransformerBasedResolveProcessor
 import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculatorForFullBodyResolve
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirAbstractBodyResolveTransformer
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
@@ -21,10 +21,14 @@ import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.compose
 import org.jetbrains.kotlin.fir.visitors.transformSingle
 
-@AdapterForResolvePhase
+@OptIn(AdapterForResolveProcessor::class)
+class FirContractResolveProcessor(session: FirSession, scopeSession: ScopeSession) : FirTransformerBasedResolveProcessor(session, scopeSession) {
+    override val transformer = FirContractResolveTransformerAdapter(session, scopeSession)
+}
+
+@AdapterForResolveProcessor
 class FirContractResolveTransformerAdapter(session: FirSession, scopeSession: ScopeSession) : FirTransformer<Nothing?>() {
     private val transformer = FirContractResolveTransformer(session, scopeSession)
-
     override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
         return element.compose()
     }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirPluginAnnotationsResolveTransformer.kt

@@ -17,14 +17,19 @@ import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirStatement
 import org.jetbrains.kotlin.fir.extensions.*
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.resolve.transformers.FirAbstractPhaseTransformer
 import org.jetbrains.kotlin.fir.resolve.fqName
+import org.jetbrains.kotlin.fir.resolve.transformers.FirAbstractPhaseTransformer
 import org.jetbrains.kotlin.fir.resolve.transformers.FirImportResolveTransformer
 import org.jetbrains.kotlin.fir.resolve.transformers.FirSpecificTypeResolverTransformer
+import org.jetbrains.kotlin.fir.resolve.transformers.FirTransformerBasedResolveProcessor
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
 import org.jetbrains.kotlin.fir.visitors.compose
 import org.jetbrains.kotlin.name.FqName
 
+class FirPluginAnnotationsResolveProcessor(session: FirSession, scopeSession: ScopeSession) : FirTransformerBasedResolveProcessor(session, scopeSession) {
+    override val transformer = FirPluginAnnotationsResolveTransformer(session, scopeSession)
+}
+
 class FirPluginAnnotationsResolveTransformer(
     override val session: FirSession,
     scopeSession: ScopeSession
@@ -33,7 +38,6 @@ class FirPluginAnnotationsResolveTransformer(
     private val importTransformer = FirPartialImportResolveTransformer(session)
 
     val extensionService = session.extensionService
-
     override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
         throw IllegalStateException("Should not be here")
     }

compiler/tests-common/tests/org/jetbrains/kotlin/codegen/GenerationUtils.kt

@@ -48,10 +48,9 @@ import org.jetbrains.kotlin.fir.builder.RawFirBuilder
 import org.jetbrains.kotlin.fir.createSession
 import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.impl.FirProviderImpl
-import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveTransformer
+import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveProcessor
 import org.jetbrains.kotlin.ir.backend.jvm.jvmResolveLibraries
 import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmManglerDesc
-import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.AnalyzingUtils
@@ -128,14 +127,14 @@ object GenerationUtils {
 
         val firProvider = (session.firProvider as FirProviderImpl)
         val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider, stubMode = false)
-        val resolveTransformer = FirTotalResolveTransformer(session)
+        val resolveTransformer = FirTotalResolveProcessor(session)
         val firFiles = files.map {
             val firFile = builder.buildFirFile(it)
             firProvider.recordFile(firFile)
             firFile
         }.also {
             try {
-                resolveTransformer.processFiles(it)
+                resolveTransformer.process(it)
             } catch (e: Exception) {
                 throw e
             }

compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirDiagnosticTest.kt

@@ -28,7 +28,8 @@ import org.jetbrains.kotlin.fir.resolve.dfa.cfg.CFGNode
 import org.jetbrains.kotlin.fir.resolve.dfa.cfg.ControlFlowGraph
 import org.jetbrains.kotlin.fir.resolve.dfa.cfg.EdgeKind
 import org.jetbrains.kotlin.fir.resolve.dfa.cfg.FirControlFlowGraphRenderVisitor
-import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveTransformer
+import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveProcessor
+import org.jetbrains.kotlin.fir.resolve.transformers.createAllResolveProcessors
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
@@ -76,7 +77,7 @@ abstract class AbstractFirDiagnosticsTest : AbstractFirBaseDiagnosticsTest() {
         for ((session, firFiles) in firFilesPerSession) {
             doFirResolveTestBench(
                 firFiles,
-                FirTotalResolveTransformer(session).transformers,
+                createAllResolveProcessors(session),
                 gc = false
             )
         }

compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirOldFrontendDiagnosticsTest.kt

@@ -6,7 +6,8 @@
 package org.jetbrains.kotlin.fir
 
 import org.jetbrains.kotlin.fir.declarations.FirFile
-import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveTransformer
+import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveProcessor
+import org.jetbrains.kotlin.fir.resolve.transformers.createAllResolveProcessors
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import java.io.File
 
@@ -32,7 +33,7 @@ abstract class AbstractFirOldFrontendDiagnosticsTest : AbstractFirDiagnosticsTes
     override fun runAnalysis(testDataFile: File, testFiles: List<TestFile>, firFilesPerSession: Map<FirSession, List<FirFile>>) {
         val failure: FirRuntimeException? = try {
             for ((session, firFiles) in firFilesPerSession) {
-                doFirResolveTestBench(firFiles, FirTotalResolveTransformer(session).transformers, gc = false)
+                doFirResolveTestBench(firFiles, createAllResolveProcessors(session), gc = false)
             }
             null
         } catch (e: FirRuntimeException) {

compiler/tests-common/tests/org/jetbrains/kotlin/fir/FirResolveBench.kt

@@ -18,9 +18,11 @@ import org.jetbrains.kotlin.fir.lightTree.LightTree2Fir
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.impl.FirProviderImpl
+import org.jetbrains.kotlin.fir.resolve.transformers.FirResolveProcessor
+import org.jetbrains.kotlin.fir.resolve.transformers.FirTransformerBasedResolveProcessor
+import org.jetbrains.kotlin.fir.resolve.transformers.FirGlobalResolveProcessor
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitorVoid
-import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 import org.jetbrains.kotlin.utils.addToStdlib.sumByLong
@@ -154,47 +156,75 @@ class FirResolveBench(val withProgress: Boolean) {
         }
     }
 
-    private fun runStage(transformer: FirTransformer<Nothing?>, firFileSequence: Sequence<FirFile>) {
+    private fun runStage(processor: FirResolveProcessor, firFileSequence: Sequence<FirFile>) {
+        when (processor) {
+            is FirTransformerBasedResolveProcessor -> runStage(processor, firFileSequence)
+            is FirGlobalResolveProcessor -> runStage(processor)
+        }
+    }
+
+    private fun runStage(processor: FirTransformerBasedResolveProcessor, firFileSequence: Sequence<FirFile>) {
+        val transformer = processor.transformer
         for (firFile in firFileSequence) {
-            var fail = false
+            processWithTimeMeasure(
-            val before = vmStateSnapshot()
+                transformer::class,
-            val time = measureNanoTime {
+                { transformer.transformFile(firFile, null) }
-                try {
+            ) { e ->
-                    transformer.transformFile(firFile, null)
+                val ktFile = firFile.psi
-                } catch (e: Throwable) {
+                if (ktFile is KtFile) {
-                    val ktFile = firFile.psi
+                    println("Fail in file: ${ktFile.virtualFilePath}")
-                    if (ktFile is KtFile) {
+                    FailureInfo(transformer::class, e, ktFile.virtualFilePath)
-                        println("Fail in file: ${ktFile.virtualFilePath}")
+                } else {
-                        fails += FailureInfo(transformer::class, e, ktFile.virtualFilePath)
+                    println("Fail in file: ${firFile.packageFqName} / ${firFile.name}")
-                    } else {
+                    FailureInfo(transformer::class, e, firFile.packageFqName.asString() + "/" + firFile.name)
-                        println("Fail in file: ${firFile.packageFqName} / ${firFile.name}")
-                        fails += FailureInfo(transformer::class, e, firFile.packageFqName.asString() + "/" + firFile.name)
-                    }
-                    fail = true
-                    //println(ktFile.text)
-                    //throw e
                 }
             }
-            if (!fail) {
+        }
-                val after = vmStateSnapshot()
+    }
-                val diff = after - before
-                recordTime(transformer::class, diff, time)
 
+    private fun runStage(processor: FirGlobalResolveProcessor) {
+        processWithTimeMeasure(
+            processor::class,
+            { processor.process() }
+        ) { e ->
+            val message = "Fail on stage ${processor::class}"
+            println(message)
+            FailureInfo(processor::class, e, message)
+        }
+    }
+
+    private inline fun processWithTimeMeasure(
+        kClass: KClass<*>,
+        block: () -> Unit,
+        catchBlock: (Throwable) -> FailureInfo
+    ) {
+        var fail = false
+        val before = vmStateSnapshot()
+        val time = measureNanoTime {
+            try {
+                block()
+            } catch (e: Throwable) {
+                fails += catchBlock(e)
+                fail = true
             }
-            //totalLength += StringBuilder().apply { FirRenderer(this).visitFile(firFile) }.length
+        }
+        if (!fail) {
+            val after = vmStateSnapshot()
+            val diff = after - before
+            recordTime(kClass, diff, time)
         }
     }
 
     fun processFiles(
         firFiles: List<FirFile>,
-        transformers: List<FirTransformer<Nothing?>>
+        processors: List<FirResolveProcessor>
     ) {
         fileCount += firFiles.size
         try {
-            for ((stage, transformer) in transformers.withIndex()) {
+            for ((stage, processor) in processors.withIndex()) {
                 //println("Starting stage #$stage. $transformer")
                 val firFileSequence = if (withProgress) firFiles.progress("   ~ ") else firFiles.asSequence()
-                runStage(transformer, firFileSequence)
+                runStage(processor, firFileSequence)
                 checkFirProvidersConsistency(firFiles)
             }
 
@@ -205,7 +235,6 @@ class FirResolveBench(val withProgress: Boolean) {
             }
         } finally {
 
-
             val fileDocumentManager = FileDocumentManager.getInstance()
 
             firFiles.forEach {
@@ -327,7 +356,7 @@ class FirResolveBench(val withProgress: Boolean) {
 
 fun doFirResolveTestBench(
     firFiles: List<FirFile>,
-    transformers: List<FirTransformer<Nothing?>>,
+    processors: List<FirResolveProcessor>,
     gc: Boolean = true,
     withProgress: Boolean = false,
     silent: Boolean = true
@@ -338,7 +367,7 @@ fun doFirResolveTestBench(
     }
 
     val bench = FirResolveBench(withProgress)
-    bench.processFiles(firFiles, transformers)
+    bench.processFiles(firFiles, processors)
     if (!silent) bench.getTotalStatistics().report(System.out, "")
     bench.throwFailure()
 }

compiler/visualizer/tests/org/jetbrains/kotlin/visualizer/fir/AbstractFirVisualizer.kt

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.createSession
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.impl.FirProviderImpl
-import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveTransformer
+import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveProcessor
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.visualizer.AbstractVisualizer
 import org.junit.Assert
@@ -37,14 +37,14 @@ abstract class AbstractFirVisualizer : AbstractVisualizer() {
         val firProvider = (session.firProvider as FirProviderImpl)
         val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider, stubMode = false)
 
-        val transformer = FirTotalResolveTransformer(session)
+        val transformer = FirTotalResolveProcessor(session)
         val firFiles = ktFiles.map {
             val firFile = builder.buildFirFile(it)
             firProvider.recordFile(firFile)
             firFile
         }.also {
             try {
-                transformer.processFiles(it)
+                transformer.process(it)
             } catch (e: Exception) {
                 it.forEach { println(it.render()) }
                 throw e

idea/idea-fir/tests/org/jetbrains/kotlin/idea/fir/AbstractFirMultiModuleResolveTest.kt

@@ -16,9 +16,7 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.dependenciesWithoutSelf
-import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
 import org.jetbrains.kotlin.fir.extensions.extensionService
-import org.jetbrains.kotlin.fir.extensions.oldExtensionsService
 import org.jetbrains.kotlin.fir.extensions.registerExtensions
 import org.jetbrains.kotlin.fir.java.FirJavaModuleBasedSession
 import org.jetbrains.kotlin.fir.java.FirLibrarySession
@@ -34,7 +32,10 @@ import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.impl.FirCompositeSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.impl.FirProviderImpl
-import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveTransformer
+import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveProcessor
+import org.jetbrains.kotlin.fir.resolve.transformers.FirTransformerBasedResolveProcessor
+import org.jetbrains.kotlin.fir.resolve.transformers.FirGlobalResolveProcessor
+import org.jetbrains.kotlin.fir.resolve.transformers.createAllTransformerBasedResolveProcessors
 import org.jetbrains.kotlin.fir.scopes.impl.FirCompositeScope
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.caches.project.IdeaModuleInfo
@@ -84,7 +85,7 @@ abstract class AbstractFirMultiModuleResolveTest : AbstractMultiModuleTest() {
 
     private fun doFirResolveTest(dirPath: String) {
         val firFilesPerSession = mutableMapOf<FirJavaModuleBasedSession, List<FirFile>>()
-        val totalTransformerPerSession = mutableMapOf<FirJavaModuleBasedSession, FirTotalResolveTransformer>()
+        val processorsPerSession = mutableMapOf<FirJavaModuleBasedSession, List<FirTransformerBasedResolveProcessor>>()
         val sessions = mutableListOf<FirJavaModuleBasedSession>()
         val provider = FirProjectSessionProvider(project)
         for (module in project.allModules().drop(1)) {
@@ -116,7 +117,7 @@ abstract class AbstractFirMultiModuleResolveTest : AbstractMultiModuleTest() {
                 firFiles += firFile
             }
             firFilesPerSession[session] = firFiles
-            totalTransformerPerSession[session] = FirTotalResolveTransformer(session)
+            processorsPerSession[session] = createAllTransformerBasedResolveProcessors(session)
         }
         println("Raw fir up, files: ${firFilesPerSession.values.flatten().size}")
 
@@ -136,9 +137,10 @@ abstract class AbstractFirMultiModuleResolveTest : AbstractMultiModuleTest() {
         for (phaseIndex in 1 until FirResolvePhase.values().size) {
             for (session in sessions) {
                 val firFiles = firFilesPerSession[session]!!
-                val transformer = totalTransformerPerSession[session]!!
+                val processors = processorsPerSession[session]!!
                 for (file in firFiles) {
-                    transformer.transformers[phaseIndex - 1].visitFile(file, null)
+                    val processor = processors[phaseIndex - 1]
+                    processor.processFile(file)
                 }
             }
         }