[FIR] Introduce FirResolveProcessors

2020-05-20 12:30:12 +03:00
parent 96802dde04
commit 8d686226c7
24 changed files with 260 additions and 125 deletions
@@ -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) {
-            transformer.transformFile(firFile, null)
-        }
+        totalTransformer.process(listOf(firFile))

        bh.consume(firFile.hashCode())
    }
@@ -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
                }
@@ -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
            }
@@ -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)
@@ -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)
-        transform<FirFile, Nothing?>(phaseTransformer, null)
+        val phaseProcessor = currentPhase.createTransformerBasedProcessorByPhase(session, scopeSession)
+        phaseProcessor.processFile(this)
    }
 }
@@ -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
@@ -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)
+    }
+}
@@ -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")
@@ -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)

@@ -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
@@ -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>
+}
@@ -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)
-            }
-        }
-    }
-}
@@ -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,
@@ -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.FirImplicitTypeBodyResolveTransformerAdapter
-import org.jetbrains.kotlin.fir.resolve.transformers.contracts.FirContractResolveTransformerAdapter
-import org.jetbrains.kotlin.fir.resolve.transformers.plugin.FirPluginAnnotationsResolveTransformer
-import org.jetbrains.kotlin.fir.visitors.FirTransformer
+import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirBodyResolveProcessor
+import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirImplicitTypeBodyResolveProcessor
+import org.jetbrains.kotlin.fir.resolve.transformers.contracts.FirContractResolveProcessor
+import org.jetbrains.kotlin.fir.resolve.transformers.plugin.FirPluginAnnotationsResolveProcessor

-// TODO: add FirSession parameter
-@OptIn(AdapterForResolvePhase::class)
-fun FirResolvePhase.createTransformerByPhase(session: FirSession, scopeSession: ScopeSession): FirTransformer<Nothing?> {
+fun FirResolvePhase.createProcessorByPhase(
+    session: FirSession,
+    scopeSession: ScopeSession,
+    compilerMode: CompilerMode = CompilerMode.CLI
+): FirResolveProcessor {
    return when (this) {
-        RAW_FIR -> throw AssertionError("Raw FIR building phase does not have a transformer")
-        ANNOTATIONS_FOR_PLUGINS -> FirPluginAnnotationsResolveTransformer(session, scopeSession)
+        RAW_FIR -> throw IllegalStateException("Raw FIR building phase does not have a transformer")
+        ANNOTATIONS_FOR_PLUGINS -> FirPluginAnnotationsResolveProcessor(session, scopeSession)
 //        FIRST_PLUGIN_GENERATION -> FirFirstGenerationTransformer()
-        IMPORTS -> FirImportResolveTransformer(session)
-        SUPER_TYPES -> FirSupertypeResolverTransformer(session, scopeSession)
-        SEALED_CLASS_INHERITORS -> FirSealedClassInheritorsTransformer()
-        TYPES -> FirTypeResolveTransformer(session, scopeSession)
-        STATUS -> FirStatusResolveTransformer(session)
-        CONTRACTS -> FirContractResolveTransformerAdapter(session, scopeSession)
-        IMPLICIT_TYPES_BODY_RESOLVE -> FirImplicitTypeBodyResolveTransformerAdapter(session, scopeSession)
-        BODY_RESOLVE -> FirBodyResolveTransformerAdapter(session, scopeSession)
+        IMPORTS -> FirImportResolveProcessor(session, scopeSession)
+        SUPER_TYPES -> FirSupertypeResolverProcessor(session, scopeSession)
+        SEALED_CLASS_INHERITORS -> FirSealedClassInheritorsProcessor(session, scopeSession)
+        TYPES -> FirTypeResolveProcessor(session, scopeSession)
+        STATUS -> FirStatusResolveProcessor(session, scopeSession)
+        CONTRACTS -> FirContractResolveProcessor(session, scopeSession)
+        IMPLICIT_TYPES_BODY_RESOLVE -> FirImplicitTypeBodyResolveProcessor(session, scopeSession)
+        BODY_RESOLVE -> FirBodyResolveProcessor(session, scopeSession)
    }
 }

-@RequiresOptIn(message = "Should be used just once from createTransformerByPhase")
-annotation class AdapterForResolvePhase
+fun FirResolvePhase.createTransformerBasedProcessorByPhase(session: FirSession, scopeSession: ScopeSession): FirTransformerBasedResolveProcessor {
+    return createProcessorByPhase(session, scopeSession, CompilerMode.IDE) as FirTransformerBasedResolveProcessor
+}
+
+enum class CompilerMode {
+    CLI, IDE
+}
@@ -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,
@@ -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.ReturnTypeCalculator
+import org.jetbrains.kotlin.fir.resolve.transformers.*
 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 {
@@ -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()
    }
@@ -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")
    }
@@ -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
            }
@@ -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
            )
        }
@@ -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) {
@@ -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
-            val before = vmStateSnapshot()
-            val time = measureNanoTime {
-                try {
-                    transformer.transformFile(firFile, null)
-                } catch (e: Throwable) {
-                    val ktFile = firFile.psi
-                    if (ktFile is KtFile) {
-                        println("Fail in file: ${ktFile.virtualFilePath}")
-                        fails += FailureInfo(transformer::class, e, ktFile.virtualFilePath)
-                    } else {
-                        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
+            processWithTimeMeasure(
+                transformer::class,
+                { transformer.transformFile(firFile, null) }
+            ) { e ->
+                val ktFile = firFile.psi
+                if (ktFile is KtFile) {
+                    println("Fail in file: ${ktFile.virtualFilePath}")
+                    FailureInfo(transformer::class, e, ktFile.virtualFilePath)
+                } else {
+                    println("Fail in file: ${firFile.packageFqName} / ${firFile.name}")
+                    FailureInfo(transformer::class, e, firFile.packageFqName.asString() + "/" + firFile.name)
                }
            }
-            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()
 }
@@ -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
@@ -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)
                }
            }
        }