[FIR] Move registration components out of initializers of FirSession

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

@@ -105,7 +105,7 @@ abstract class AbstractSimpleFileBenchmark {
     fun setUp() {
         if (isIR && !useNewInference) error("Invalid configuration")
         env = KotlinCoreEnvironment.createForTests(
-                myDisposable, 
+                myDisposable,
                 newConfiguration(useNewInference),
                 EnvironmentConfigFiles.JVM_CONFIG_FILES
         )
@@ -183,7 +183,7 @@ fun createSession(
     val moduleInfo = FirTestModuleInfo()
     val project = environment.project
     val provider = FirProjectSessionProvider(project)
-    return FirJavaModuleBasedSession(moduleInfo, provider, sourceScope).also {
+    return FirJavaModuleBasedSession.create(moduleInfo, provider, sourceScope).also {
         createSessionForDependencies(provider, moduleInfo, librariesScope, environment)
     }
 }

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

@@ -323,7 +323,7 @@ object KotlinToJVMBytecodeCompiler {
             }
 
             val moduleInfo = FirJvmModuleInfo(module.getModuleName())
-            val session: FirSession = FirJavaModuleBasedSession(moduleInfo, provider, scope).also {
+            val session: FirSession = FirJavaModuleBasedSession.create(moduleInfo, provider, scope).also {
                 val dependenciesInfo = FirJvmModuleInfo(Name.special("<dependencies>"))
                 moduleInfo.dependencies.add(dependenciesInfo)
                 val librariesScope = ProjectScope.getLibrariesScope(project)

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/CheckersComponent.kt

@@ -43,6 +43,14 @@ class CheckersComponent : FirSessionComponent {
 
 val FirSession.checkersComponent: CheckersComponent by FirSession.sessionComponentAccessor()
 
+/*
+ * TODO: in future rename to `registerCheckersComponent` and configure
+ *    exact checkers according to platforms of current session
+ */
+fun FirSession.registerCheckersComponent() {
+    register(CheckersComponent::class, CheckersComponent.componentWithDefaultCheckers())
+}
+
 private class ComposedDeclarationCheckers : DeclarationCheckers() {
     override val declarationCheckers: List<FirBasicDeclarationChecker>
         get() = _declarationCheckers

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/FirJavaModuleBasedSession.kt

@@ -10,111 +10,69 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElementFinder
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analyzer.ModuleInfo
-import org.jetbrains.kotlin.fir.FirModuleBasedSession
+import org.jetbrains.kotlin.fir.*
-import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.analysis.registerCheckersComponent
-import org.jetbrains.kotlin.fir.FirSessionBase
-import org.jetbrains.kotlin.fir.FirSessionProvider
-import org.jetbrains.kotlin.fir.analysis.CheckersComponent
-import org.jetbrains.kotlin.fir.extensions.FirExtensionService
-import org.jetbrains.kotlin.fir.extensions.FirRegisteredPluginAnnotations
-import org.jetbrains.kotlin.fir.extensions.FirPredicateBasedProvider
 import org.jetbrains.kotlin.fir.java.deserialization.KotlinDeserializedJvmSymbolsProvider
 import org.jetbrains.kotlin.fir.resolve.providers.FirProvider
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
-import org.jetbrains.kotlin.fir.resolve.calls.ConeCallConflictResolverFactory
+import org.jetbrains.kotlin.fir.resolve.calls.jvm.registerJvmCallConflictResolverFactory
-import org.jetbrains.kotlin.fir.resolve.calls.jvm.JvmCallConflictResolverFactory
 import org.jetbrains.kotlin.fir.resolve.providers.impl.*
 import org.jetbrains.kotlin.fir.resolve.scopes.wrapScopeWithJvmMapped
 import org.jetbrains.kotlin.fir.scopes.KotlinScopeProvider
-import org.jetbrains.kotlin.fir.scopes.impl.FirDeclaredMemberScopeProvider
-import org.jetbrains.kotlin.fir.types.FirCorrespondingSupertypesCache
-import org.jetbrains.kotlin.load.java.JavaClassFinder
 import org.jetbrains.kotlin.load.java.JavaClassFinderImpl
-import org.jetbrains.kotlin.load.kotlin.KotlinClassFinder
 import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
 import org.jetbrains.kotlin.load.kotlin.VirtualFileFinderFactory
 
-class FirJavaModuleBasedSession(
+class FirJavaModuleBasedSession private constructor(
     moduleInfo: ModuleInfo,
     sessionProvider: FirProjectSessionProvider,
-    scope: GlobalSearchScope,
-    dependenciesProvider: FirSymbolProvider? = null
 ) : FirModuleBasedSession(moduleInfo, sessionProvider) {
+    companion object {
+        fun create(
+            moduleInfo: ModuleInfo,
+            sessionProvider: FirProjectSessionProvider,
+            scope: GlobalSearchScope,
+            dependenciesProvider: FirSymbolProvider? = null
+        ): FirJavaModuleBasedSession {
+            return FirJavaModuleBasedSession(moduleInfo, sessionProvider).apply {
+                registerCommonComponents()
+                registerResolveComponents()
+                registerCheckersComponent()
+                registerJvmCallConflictResolverFactory()
+
+                val kotlinScopeProvider = KotlinScopeProvider(::wrapScopeWithJvmMapped)
+
+                val firProvider = FirProviderImpl(this, kotlinScopeProvider)
+                register(FirProvider::class, firProvider)
+
+                register(
+                    FirSymbolProvider::class,
+                    FirCompositeSymbolProvider(
+                        listOf(
+                            firProvider,
+                            JavaSymbolProvider(this, sessionProvider.project, scope),
+                            dependenciesProvider ?: FirDependenciesSymbolProviderImpl(this)
+                        )
+                    ) as FirSymbolProvider
+                )
+
+                Extensions.getArea(sessionProvider.project)
+                    .getExtensionPoint(PsiElementFinder.EP_NAME)
+                    .registerExtension(FirJavaElementFinder(this, sessionProvider.project))
+            }
+        }
+    }
 
 
     init {
         sessionProvider.sessionCache[moduleInfo] = this
-
-        val kotlinScopeProvider = KotlinScopeProvider(::wrapScopeWithJvmMapped)
-
-        val firProvider = FirProviderImpl(this, kotlinScopeProvider)
-        registerComponent(FirProvider::class, firProvider)
-
-        registerComponent(
-            FirSymbolProvider::class,
-            FirCompositeSymbolProvider(
-                listOf(
-                    firProvider,
-                    JavaSymbolProvider(this, sessionProvider.project, scope),
-                    dependenciesProvider ?: FirDependenciesSymbolProviderImpl(this)
-                )
-            ) as FirSymbolProvider
-        )
-
-        registerComponent(
-            ConeCallConflictResolverFactory::class,
-            JvmCallConflictResolverFactory
-        )
-
-        registerComponent(
-            CheckersComponent::class,
-            CheckersComponent.componentWithDefaultCheckers()
-        )
-
-        Extensions.getArea(sessionProvider.project)
-            .getExtensionPoint(PsiElementFinder.EP_NAME)
-            .registerExtension(FirJavaElementFinder(this, sessionProvider.project))
     }
 }
 
 class FirLibrarySession private constructor(
     moduleInfo: ModuleInfo,
     sessionProvider: FirProjectSessionProvider,
-    scope: GlobalSearchScope,
+) : FirSession(sessionProvider) {
-    packagePartProvider: PackagePartProvider,
-    kotlinClassFinder: KotlinClassFinder,
-    javaClassFinder: JavaClassFinder
-) : FirSessionBase(sessionProvider) {
-
-
-    init {
-        val javaSymbolProvider = JavaSymbolProvider(this, sessionProvider.project, scope)
-
-        val kotlinScopeProvider = KotlinScopeProvider(::wrapScopeWithJvmMapped)
-
-        registerComponent(
-            FirSymbolProvider::class,
-            FirCompositeSymbolProvider(
-                listOf(
-                    KotlinDeserializedJvmSymbolsProvider(
-                        this, sessionProvider.project,
-                        packagePartProvider,
-                        javaSymbolProvider,
-                        kotlinClassFinder,
-                        javaClassFinder,
-                        kotlinScopeProvider
-                    ),
-                    FirBuiltinSymbolProvider(this, kotlinScopeProvider),
-                    FirClonableSymbolProvider(this, kotlinScopeProvider),
-                    javaSymbolProvider,
-                    FirDependenciesSymbolProviderImpl(this)
-                )
-            )
-        )
-
-        sessionProvider.sessionCache[moduleInfo] = this
-    }
-
     companion object {
         fun create(
             moduleInfo: ModuleInfo,
@@ -128,14 +86,40 @@ class FirLibrarySession private constructor(
                 this.setScope(scope)
             }
 
-            return FirLibrarySession(
+            val kotlinClassFinder = VirtualFileFinderFactory.getInstance(project).create(scope)
-                moduleInfo, sessionProvider, scope,
+            return FirLibrarySession(moduleInfo, sessionProvider).apply {
-                packagePartProvider,
+                registerCommonComponents()
-                VirtualFileFinderFactory.getInstance(project).create(scope),
+
-                javaClassFinder
+                val javaSymbolProvider = JavaSymbolProvider(this, sessionProvider.project, scope)
-            )
+
+                val kotlinScopeProvider = KotlinScopeProvider(::wrapScopeWithJvmMapped)
+
+                register(
+                    FirSymbolProvider::class,
+                    FirCompositeSymbolProvider(
+                        listOf(
+                            KotlinDeserializedJvmSymbolsProvider(
+                                this, sessionProvider.project,
+                                packagePartProvider,
+                                javaSymbolProvider,
+                                kotlinClassFinder,
+                                javaClassFinder,
+                                kotlinScopeProvider
+                            ),
+                            FirBuiltinSymbolProvider(this, kotlinScopeProvider),
+                            FirClonableSymbolProvider(this, kotlinScopeProvider),
+                            javaSymbolProvider,
+                            FirDependenciesSymbolProviderImpl(this)
+                        )
+                    )
+                )
+            }
         }
     }
+
+    init {
+        sessionProvider.sessionCache[moduleInfo] = this
+    }
 }
 
 class FirProjectSessionProvider(override val project: Project) : FirSessionProvider {

compiler/fir/jvm/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/JvmCallConflictResolverFactory.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.fir.resolve.calls.jvm
 
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.resolve.calls.ConeCallConflictResolverFactory
 import org.jetbrains.kotlin.fir.resolve.calls.ConeCompositeConflictResolver
 import org.jetbrains.kotlin.fir.resolve.calls.ConeOverloadConflictResolver
@@ -23,5 +24,8 @@ object JvmCallConflictResolverFactory : ConeCallConflictResolverFactory() {
             ConeEquivalentCallConflictResolver(specificityComparator, components)
         )
     }
+}
 
+fun FirSession.registerJvmCallConflictResolverFactory() {
+    register(ConeCallConflictResolverFactory::class, JvmCallConflictResolverFactory)
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirModuleBasedSession.kt

@@ -6,20 +6,17 @@
 package org.jetbrains.kotlin.fir
 
 import org.jetbrains.kotlin.analyzer.ModuleInfo
-import org.jetbrains.kotlin.fir.extensions.FirExtensionService
-import org.jetbrains.kotlin.fir.extensions.FirRegisteredPluginAnnotations
 import org.jetbrains.kotlin.fir.resolve.FirQualifierResolver
-import org.jetbrains.kotlin.fir.extensions.FirPredicateBasedProvider
 import org.jetbrains.kotlin.fir.resolve.FirTypeResolver
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirQualifierResolverImpl
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirTypeResolverImpl
-import org.jetbrains.kotlin.fir.scopes.impl.FirDeclaredMemberScopeProvider
 
-abstract class FirModuleBasedSession(override val moduleInfo: ModuleInfo, sessionProvider: FirSessionProvider?) :
+abstract class FirModuleBasedSession(
-    FirSessionBase(sessionProvider) {
+    override val moduleInfo: ModuleInfo,
-    init {
+    sessionProvider: FirSessionProvider?
-        registerComponent(FirQualifierResolver::class, FirQualifierResolverImpl(this))
+) : FirSession(sessionProvider)
-        registerComponent(FirTypeResolver::class, FirTypeResolverImpl(this))
-    }
-}
 
+fun FirModuleBasedSession.registerResolveComponents() {
+    register(FirQualifierResolver::class, FirQualifierResolverImpl(this))
+    register(FirTypeResolver::class, FirTypeResolverImpl(this))
+}

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirSessionBase.kt

@@ -1,23 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.fir
-
-import org.jetbrains.kotlin.fir.extensions.FirExtensionService
-import org.jetbrains.kotlin.fir.extensions.FirPredicateBasedProvider
-import org.jetbrains.kotlin.fir.extensions.FirRegisteredPluginAnnotations
-import org.jetbrains.kotlin.fir.scopes.impl.FirDeclaredMemberScopeProvider
-import org.jetbrains.kotlin.fir.types.FirCorrespondingSupertypesCache
-
-abstract class FirSessionBase(sessionProvider: FirSessionProvider?) : FirSession(sessionProvider) {
-    init {
-        registerComponent(FirDeclaredMemberScopeProvider::class, FirDeclaredMemberScopeProvider())
-        registerComponent(FirCorrespondingSupertypesCache::class, FirCorrespondingSupertypesCache(this))
-
-        registerComponent(FirExtensionService::class, FirExtensionService(this))
-        registerComponent(FirRegisteredPluginAnnotations::class, FirRegisteredPluginAnnotations.create(this))
-        registerComponent(FirPredicateBasedProvider::class, FirPredicateBasedProvider.create(this))
-    }
-}

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirSessionCommonComponents.kt

@@ -0,0 +1,21 @@
+/*
+ * 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
+
+import org.jetbrains.kotlin.fir.extensions.FirExtensionService
+import org.jetbrains.kotlin.fir.extensions.FirPredicateBasedProvider
+import org.jetbrains.kotlin.fir.extensions.FirRegisteredPluginAnnotations
+import org.jetbrains.kotlin.fir.scopes.impl.FirDeclaredMemberScopeProvider
+import org.jetbrains.kotlin.fir.types.FirCorrespondingSupertypesCache
+
+fun FirSession.registerCommonComponents() {
+    register(FirDeclaredMemberScopeProvider::class, FirDeclaredMemberScopeProvider())
+    register(FirCorrespondingSupertypesCache::class, FirCorrespondingSupertypesCache(this))
+
+    register(FirExtensionService::class, FirExtensionService(this))
+    register(FirRegisteredPluginAnnotations::class, FirRegisteredPluginAnnotations.create(this))
+    register(FirPredicateBasedProvider::class, FirPredicateBasedProvider.create(this))
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirSession.kt

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.fir.utils.ArrayMapAccessor
 import org.jetbrains.kotlin.fir.utils.ComponentArrayOwner
 import org.jetbrains.kotlin.fir.utils.TypeRegistry
 import org.jetbrains.kotlin.utils.Jsr305State
+import kotlin.reflect.KClass
 
 interface FirSessionComponent
 
@@ -29,6 +30,10 @@ abstract class FirSession(val sessionProvider: FirSessionProvider?) : ComponentA
     val builtinTypes: BuiltinTypes = BuiltinTypes()
 
     final override val typeRegistry: TypeRegistry<FirSessionComponent, FirSessionComponent> = Companion
+
+    fun register(tClass: KClass<out FirSessionComponent>, value: FirSessionComponent) {
+        registerComponent(tClass, value)
+    }
 }
 
 interface FirSessionProvider {

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

@@ -88,7 +88,7 @@ abstract class AbstractFirBaseDiagnosticsTest : BaseDiagnosticsTest() {
             val scope = TopDownAnalyzerFacadeForJVM.newModuleSearchScope(
                 project,
                 moduleFiles.mapNotNull { it.ktFile })
-            FirJavaModuleBasedSession(info, sessionProvider, scope).also {
+            FirJavaModuleBasedSession.create(info, sessionProvider, scope).also {
                 registerFirExtensions(it.extensionService)
             }
         }

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

@@ -33,7 +33,7 @@ fun createSession(
 ): FirSession {
     val moduleInfo = FirTestModuleInfo(name = Name.identifier(moduleName))
     val provider = FirProjectSessionProvider(project)
-    return FirJavaModuleBasedSession(moduleInfo, provider, sourceScope).also {
+    return FirJavaModuleBasedSession.create(moduleInfo, provider, sourceScope).also {
         createSessionForDependencies(project, provider, moduleInfo, librariesScope, packagePartProvider)
         it.extensionService.registerExtensions(BunchOfRegisteredExtensions.empty())
     }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirIdeJavaModuleBasedSession.kt

@@ -9,53 +9,53 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analyzer.ModuleInfo
 import org.jetbrains.kotlin.fir.FirModuleBasedSession
-import org.jetbrains.kotlin.fir.analysis.CheckersComponent
+import org.jetbrains.kotlin.fir.analysis.registerCheckersComponent
 import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
 import org.jetbrains.kotlin.fir.java.JavaSymbolProvider
+import org.jetbrains.kotlin.fir.registerCommonComponents
+import org.jetbrains.kotlin.fir.registerResolveComponents
+import org.jetbrains.kotlin.fir.resolve.calls.jvm.registerJvmCallConflictResolverFactory
+import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.providers.FirProvider
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
-import org.jetbrains.kotlin.fir.resolve.calls.ConeCallConflictResolverFactory
-import org.jetbrains.kotlin.fir.resolve.calls.jvm.JvmCallConflictResolverFactory
-import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCompositeSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.scopes.wrapScopeWithJvmMapped
 import org.jetbrains.kotlin.fir.scopes.KotlinScopeProvider
-import org.jetbrains.kotlin.fir.types.FirCorrespondingSupertypesCache
 
 
 class FirIdeJavaModuleBasedSession(
-    project: Project,
     moduleInfo: ModuleInfo,
-    sessionProvider: FirProjectSessionProvider,
+    sessionProvider: FirProjectSessionProvider
-    scope: GlobalSearchScope
 ) : FirModuleBasedSession(moduleInfo, sessionProvider) {
+    companion object {
+        fun create(
+            project: Project,
+            moduleInfo: ModuleInfo,
+            sessionProvider: FirProjectSessionProvider,
+            scope: GlobalSearchScope
+        ): FirIdeJavaModuleBasedSession {
+            return FirIdeJavaModuleBasedSession(moduleInfo, sessionProvider).apply {
+                registerCommonComponents()
+                registerResolveComponents()
+                registerCheckersComponent()
+                registerJvmCallConflictResolverFactory()
 
+                val firIdeProvider = FirIdeProvider(project, scope, this, KotlinScopeProvider(::wrapScopeWithJvmMapped))
 
-    init {
+                register(FirProvider::class, firIdeProvider)
-        val firIdeProvider = FirIdeProvider(project, scope, this, KotlinScopeProvider(::wrapScopeWithJvmMapped))
+                register(FirIdeProvider::class, firIdeProvider)
 
-        registerComponent(FirProvider::class, firIdeProvider)
+                register(
-        registerComponent(FirIdeProvider::class, firIdeProvider)
+                    FirSymbolProvider::class,
-
+                    FirCompositeSymbolProvider(
-        registerComponent(
+                        listOf(
-            FirSymbolProvider::class,
+                            firProvider,
-            FirCompositeSymbolProvider(
+                            JavaSymbolProvider(this, sessionProvider.project, scope),
-                listOf(
+                            FirIdeModuleDependenciesSymbolProvider(this)
-                    firProvider,
+                        )
-                    JavaSymbolProvider(this, sessionProvider.project, scope),
+                    ) as FirSymbolProvider
-                    FirIdeModuleDependenciesSymbolProvider(this)
                 )
-            ) as FirSymbolProvider
+            }
-        )
+        }
-
-        registerComponent(
-            ConeCallConflictResolverFactory::class,
-            JvmCallConflictResolverFactory
-        )
-
-        registerComponent(
-            CheckersComponent::class,
-            CheckersComponent.componentWithDefaultCheckers()
-        )
     }
 }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirModuleResolveState.kt

@@ -34,7 +34,7 @@ interface FirModuleResolveState {
     fun getSession(project: Project, moduleInfo: ModuleSourceInfo): FirSession {
         sessionProvider.getSession(moduleInfo)?.let { return it }
         return synchronized(moduleInfo.module) {
-            val session = sessionProvider.getSession(moduleInfo) ?: FirIdeJavaModuleBasedSession(
+            val session = sessionProvider.getSession(moduleInfo) ?: FirIdeJavaModuleBasedSession.create(
                 project, moduleInfo, sessionProvider, moduleInfo.contentScope()
             ).also { moduleBasedSession ->
                 sessionProvider.sessionCache[moduleInfo] = moduleBasedSession

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

@@ -72,7 +72,7 @@ abstract class AbstractFirMultiModuleResolveTest : AbstractMultiModuleTest() {
 
     private fun createSession(module: Module, provider: FirProjectSessionProvider): FirJavaModuleBasedSession {
         val moduleInfo = module.productionSourceInfo()!!
-        return FirJavaModuleBasedSession(moduleInfo, provider, moduleInfo.contentScope()).also {
+        return FirJavaModuleBasedSession.create(moduleInfo, provider, moduleInfo.contentScope()).also {
             it.extensionService.registerExtensions(BunchOfRegisteredExtensions.empty())
         }
     }