[FIR] Introduce module :fir:entrypoint and FirSessionFactory for creating sessions

compiler/cli/build.gradle.kts

@@ -24,6 +24,7 @@ dependencies {
     compile(project(":compiler:fir:resolve"))
     compile(project(":compiler:fir:jvm"))
     compile(project(":compiler:fir:java"))
+    implementation(project(":compiler:fir:entrypoint"))
     compile(project(":compiler:fir:fir2ir"))
     compile(project(":compiler:fir:fir2ir:jvm-backend"))
     compile(project(":compiler:fir:checkers"))

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

@@ -58,7 +58,6 @@ import org.jetbrains.kotlin.fir.FirPsiSourceElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.analysis.collectors.FirDiagnosticsCollector
 import org.jetbrains.kotlin.fir.analysis.diagnostics.*
-import org.jetbrains.kotlin.fir.analysis.registerExtendedCheckersComponent
 import org.jetbrains.kotlin.fir.backend.Fir2IrConverter
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmBackendClassResolver
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmClassCodegen
@@ -68,12 +67,12 @@ import org.jetbrains.kotlin.fir.builder.RawFirBuilder
 import org.jetbrains.kotlin.fir.extensions.BunchOfRegisteredExtensions
 import org.jetbrains.kotlin.fir.extensions.extensionService
 import org.jetbrains.kotlin.fir.extensions.registerExtensions
-import org.jetbrains.kotlin.fir.java.FirJavaModuleBasedSession
-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.providers.impl.FirProviderImpl
 import org.jetbrains.kotlin.fir.resolve.transformers.FirTotalResolveProcessor
+import org.jetbrains.kotlin.fir.session.FirSessionFactory
+import org.jetbrains.kotlin.fir.session.registerExtendedCheckersComponent
 import org.jetbrains.kotlin.idea.MainFunctionDetector
 import org.jetbrains.kotlin.ir.backend.jvm.jvmResolveLibraries
 import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmManglerDesc
@@ -354,11 +353,11 @@ object KotlinToJVMBytecodeCompiler {
             }
 
             val moduleInfo = FirJvmModuleInfo(module.getModuleName())
-            val session: FirSession = FirJavaModuleBasedSession.create(moduleInfo, provider, scope).also {
+            val session: FirSession = FirSessionFactory.createJavaModuleBasedSession(moduleInfo, provider, scope).also {
                 val dependenciesInfo = FirJvmModuleInfo(Name.special("<dependencies>"))
                 moduleInfo.dependencies.add(dependenciesInfo)
                 val librariesScope = ProjectScope.getLibrariesScope(project)
-                FirLibrarySession.create(
+                FirSessionFactory.createLibrarySession(
                     dependenciesInfo, provider, librariesScope,
                     project, environment.createPackagePartProvider(librariesScope)
                 )

compiler/fir/analysis-tests/build.gradle.kts

@@ -18,6 +18,7 @@ dependencies {
     testCompileOnly(project(":kotlin-test:kotlin-test-junit"))
     testApi(projectTests(":compiler:tests-common"))
     testApi(project(":compiler:fir:checkers"))
+    testApi(project(":compiler:fir:entrypoint"))
     testApi(project(":compiler:frontend"))
 
     testCompileOnly(project(":kotlin-reflect-api"))

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

@@ -45,19 +45,6 @@ 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())
-}
-
-fun FirSession.registerExtendedCheckersComponent() {
-    this.checkersComponent.register(ExtendedExpressionCheckers)
-    this.checkersComponent.register(ExtendedDeclarationCheckers)
-}
-
 private class ComposedDeclarationCheckers : DeclarationCheckers() {
     override val fileCheckers: List<FirFileChecker>
         get() = _fileCheckers

compiler/fir/entrypoint/build.gradle.kts

@@ -0,0 +1,21 @@
+plugins {
+    kotlin("jvm")
+    id("jps-compatible")
+}
+
+dependencies {
+    api(project(":core:descriptors.jvm"))
+    api(project(":compiler:frontend.java"))
+    api(project(":compiler:fir:java"))
+
+    implementation(project(":compiler:fir:resolve"))
+    implementation(project(":compiler:fir:checkers"))
+
+    compileOnly(project(":kotlin-reflect-api"))
+    compileOnly(intellijCoreDep()) { includeJars("intellij-core", "guava", rootProject = rootProject) }
+}
+
+sourceSets {
+    "main" { projectDefault() }
+    "test" { none() }
+}

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/ComponentsContainers.kt

@@ -0,0 +1,71 @@
+/*
+ * 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.session
+
+import org.jetbrains.kotlin.fir.FirModuleBasedSession
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.analysis.CheckersComponent
+import org.jetbrains.kotlin.fir.analysis.checkers.declaration.ExtendedDeclarationCheckers
+import org.jetbrains.kotlin.fir.analysis.checkers.expression.ExtendedExpressionCheckers
+import org.jetbrains.kotlin.fir.analysis.checkersComponent
+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.java.registerJavaVisibilityChecker
+import org.jetbrains.kotlin.fir.registerJvmEffectiveVisibilityResolver
+import org.jetbrains.kotlin.fir.resolve.FirQualifierResolver
+import org.jetbrains.kotlin.fir.resolve.FirTypeResolver
+import org.jetbrains.kotlin.fir.resolve.calls.jvm.registerJvmCallConflictResolverFactory
+import org.jetbrains.kotlin.fir.resolve.providers.impl.FirQualifierResolverImpl
+import org.jetbrains.kotlin.fir.resolve.providers.impl.FirTypeResolverImpl
+import org.jetbrains.kotlin.fir.resolve.registerJavaClassMapper
+import org.jetbrains.kotlin.fir.resolve.registerJavaSyntheticNamesProvider
+import org.jetbrains.kotlin.fir.resolve.transformers.plugin.GeneratedClassIndex
+import org.jetbrains.kotlin.fir.scopes.impl.FirDeclaredMemberScopeProvider
+import org.jetbrains.kotlin.fir.types.FirCorrespondingSupertypesCache
+
+// -------------------------- Required components --------------------------
+
+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))
+    register(GeneratedClassIndex::class, GeneratedClassIndex.create())
+}
+
+// -------------------------- Resolve components --------------------------
+
+// TODO: rename to `registerCommonResolveComponents
+fun FirModuleBasedSession.registerResolveComponents() {
+    register(FirQualifierResolver::class, FirQualifierResolverImpl(this))
+    register(FirTypeResolver::class, FirTypeResolverImpl(this))
+}
+
+fun FirModuleBasedSession.registerJavaSpecificComponents() {
+    registerJavaVisibilityChecker()
+    registerJvmCallConflictResolverFactory()
+    registerJvmEffectiveVisibilityResolver()
+    registerJavaClassMapper()
+    registerJavaSyntheticNamesProvider()
+}
+
+// -------------------------- Checker components --------------------------
+
+/*
+ * TODO: in future rename to `registerCheckersComponent` and configure
+ *    exact checkers according to platforms of current session
+ */
+fun FirModuleBasedSession.registerCheckersComponent() {
+    register(CheckersComponent::class, CheckersComponent.componentWithDefaultCheckers())
+}
+
+fun FirModuleBasedSession.registerExtendedCheckersComponent() {
+    this.checkersComponent.register(ExtendedExpressionCheckers)
+    this.checkersComponent.register(ExtendedDeclarationCheckers)
+}

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirSessionFactory.kt

@@ -0,0 +1,104 @@
+/*
+ * 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.session
+
+import com.intellij.openapi.extensions.Extensions
+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.PrivateSessionConstructor
+import org.jetbrains.kotlin.fir.java.*
+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.providers.impl.*
+import org.jetbrains.kotlin.fir.resolve.scopes.wrapScopeWithJvmMapped
+import org.jetbrains.kotlin.fir.scopes.KotlinScopeProvider
+import org.jetbrains.kotlin.load.java.JavaClassFinderImpl
+import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
+import org.jetbrains.kotlin.load.kotlin.VirtualFileFinderFactory
+
+@OptIn(PrivateSessionConstructor::class)
+object FirSessionFactory {
+    fun createJavaModuleBasedSession(
+        moduleInfo: ModuleInfo,
+        sessionProvider: FirProjectSessionProvider,
+        scope: GlobalSearchScope,
+        dependenciesProvider: FirSymbolProvider? = null
+    ): FirJavaModuleBasedSession {
+        return FirJavaModuleBasedSession(moduleInfo, sessionProvider).apply {
+            registerCommonComponents()
+            registerResolveComponents()
+            registerCheckersComponent()
+            registerJavaSpecificComponents()
+
+            val kotlinScopeProvider = KotlinScopeProvider(::wrapScopeWithJvmMapped)
+
+            val firProvider = FirProviderImpl(this, kotlinScopeProvider)
+            register(FirProvider::class, firProvider)
+
+            register(
+                FirSymbolProvider::class,
+                FirCompositeSymbolProvider(
+                    this,
+                    listOf(
+                        firProvider.symbolProvider,
+                        JavaSymbolProvider(this, sessionProvider.project, scope),
+                        dependenciesProvider ?: FirDependenciesSymbolProviderImpl(this)
+                    )
+                ) as FirSymbolProvider
+            )
+
+            Extensions.getArea(sessionProvider.project)
+                .getExtensionPoint(PsiElementFinder.EP_NAME)
+                .registerExtension(FirJavaElementFinder(this, sessionProvider.project))
+        }
+    }
+
+    fun createLibrarySession(
+        moduleInfo: ModuleInfo,
+        sessionProvider: FirProjectSessionProvider,
+        scope: GlobalSearchScope,
+        project: Project,
+        packagePartProvider: PackagePartProvider
+    ): FirLibrarySession {
+        val javaClassFinder = JavaClassFinderImpl().apply {
+            this.setProjectInstance(project)
+            this.setScope(scope)
+        }
+
+        val kotlinClassFinder = VirtualFileFinderFactory.getInstance(project).create(scope)
+        return FirLibrarySession(moduleInfo, sessionProvider).apply {
+            registerCommonComponents()
+
+            val javaSymbolProvider = JavaSymbolProvider(this, sessionProvider.project, scope)
+
+            val kotlinScopeProvider = KotlinScopeProvider(::wrapScopeWithJvmMapped)
+
+            register(
+                FirSymbolProvider::class,
+                FirCompositeSymbolProvider(
+                    this,
+                    listOf(
+                        KotlinDeserializedJvmSymbolsProvider(
+                            this, sessionProvider.project,
+                            packagePartProvider,
+                            javaSymbolProvider,
+                            kotlinClassFinder,
+                            javaClassFinder,
+                            kotlinScopeProvider
+                        ),
+                        FirBuiltinSymbolProvider(this, kotlinScopeProvider),
+                        FirCloneableSymbolProvider(this, kotlinScopeProvider),
+                        javaSymbolProvider,
+                        FirDependenciesSymbolProviderImpl(this)
+                    )
+                )
+            )
+        }
+    }
+}

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

@@ -5,119 +5,25 @@
 
 package org.jetbrains.kotlin.fir.java
 
-import com.intellij.openapi.extensions.Extensions
 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.*
-import org.jetbrains.kotlin.fir.analysis.registerCheckersComponent
-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.providers.impl.*
-import org.jetbrains.kotlin.fir.resolve.scopes.wrapScopeWithJvmMapped
-import org.jetbrains.kotlin.fir.scopes.KotlinScopeProvider
-import org.jetbrains.kotlin.load.java.JavaClassFinderImpl
-import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
-import org.jetbrains.kotlin.load.kotlin.VirtualFileFinderFactory
 
-class FirJavaModuleBasedSession private constructor(
+@OptIn(PrivateSessionConstructor::class)
+class FirJavaModuleBasedSession @PrivateSessionConstructor constructor(
     moduleInfo: ModuleInfo,
     sessionProvider: FirProjectSessionProvider,
 ) : 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()
-                registerJavaSpecificComponents()
-
-                val kotlinScopeProvider = KotlinScopeProvider(::wrapScopeWithJvmMapped)
-
-                val firProvider = FirProviderImpl(this, kotlinScopeProvider)
-                register(FirProvider::class, firProvider)
-
-                register(
-                    FirSymbolProvider::class,
-                    FirCompositeSymbolProvider(
-                        this,
-                        listOf(
-                            firProvider.symbolProvider,
-                            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.registerSession(moduleInfo, this)
     }
 }
 
-class FirLibrarySession private constructor(
+@OptIn(PrivateSessionConstructor::class)
+class FirLibrarySession @PrivateSessionConstructor constructor(
     override val moduleInfo: ModuleInfo,
     sessionProvider: FirProjectSessionProvider,
 ) : FirSession(sessionProvider) {
-    companion object {
-        fun create(
-            moduleInfo: ModuleInfo,
-            sessionProvider: FirProjectSessionProvider,
-            scope: GlobalSearchScope,
-            project: Project,
-            packagePartProvider: PackagePartProvider
-        ): FirLibrarySession {
-            val javaClassFinder = JavaClassFinderImpl().apply {
-                this.setProjectInstance(project)
-                this.setScope(scope)
-            }
-
-            val kotlinClassFinder = VirtualFileFinderFactory.getInstance(project).create(scope)
-            return FirLibrarySession(moduleInfo, sessionProvider).apply {
-                registerCommonComponents()
-
-                val javaSymbolProvider = JavaSymbolProvider(this, sessionProvider.project, scope)
-
-                val kotlinScopeProvider = KotlinScopeProvider(::wrapScopeWithJvmMapped)
-
-                register(
-                    FirSymbolProvider::class,
-                    FirCompositeSymbolProvider(
-                        this,
-                        listOf(
-                            KotlinDeserializedJvmSymbolsProvider(
-                                this, sessionProvider.project,
-                                packagePartProvider,
-                                javaSymbolProvider,
-                                kotlinClassFinder,
-                                javaClassFinder,
-                                kotlinScopeProvider
-                            ),
-                            FirBuiltinSymbolProvider(this, kotlinScopeProvider),
-                            FirCloneableSymbolProvider(this, kotlinScopeProvider),
-                            javaSymbolProvider,
-                            FirDependenciesSymbolProviderImpl(this)
-                        )
-                    )
-                )
-            }
-        }
-    }
-
     init {
         sessionProvider.registerSession(moduleInfo, this)
     }

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

@@ -1,20 +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.java
-
-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.registerJvmEffectiveVisibilityResolver
-import org.jetbrains.kotlin.fir.resolve.calls.jvm.registerJvmCallConflictResolverFactory
-import org.jetbrains.kotlin.fir.resolve.registerJavaClassMapper
-import org.jetbrains.kotlin.fir.resolve.registerJavaSyntheticNamesProvider
-
-fun FirSession.registerJavaSpecificComponents() {
-    registerJavaVisibilityChecker()
-    registerJvmCallConflictResolverFactory()
-    registerJvmEffectiveVisibilityResolver()
-    registerJavaClassMapper()
-    registerJavaSyntheticNamesProvider()
-}

compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/LightTree2Fir.kt

@@ -11,6 +11,7 @@ import com.intellij.openapi.util.io.FileUtil
 import com.intellij.openapi.vfs.CharsetToolkit
 import com.intellij.util.diff.FlyweightCapableTreeStructure
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.PrivateSessionConstructor
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.lightTree.converter.DeclarationsConverter
 import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
@@ -21,7 +22,7 @@ import java.io.File
 import java.nio.file.Path
 
 class LightTree2Fir(
-    val session: FirSession = object : FirSession(null) {},
+    val session: FirSession = @OptIn(PrivateSessionConstructor::class) object : FirSession(null) {},
     private val scopeProvider: FirScopeProvider,
     private val stubMode: Boolean = false
 ) {

compiler/fir/raw-fir/light-tree2fir/tests/org/jetbrains/kotlin/fir/lightTree/SimpleTestCase.kt

@@ -13,6 +13,7 @@ import com.intellij.testFramework.LightVirtualFile
 import com.intellij.testFramework.TestDataPath
 import org.jetbrains.kotlin.fir.FirRenderer
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.PrivateSessionConstructor
 import org.jetbrains.kotlin.fir.builder.AbstractRawFirBuilderTestCase
 import org.jetbrains.kotlin.fir.builder.StubFirScopeProvider
 import org.jetbrains.kotlin.fir.lightTree.converter.DeclarationsConverter
@@ -63,7 +64,7 @@ class SimpleTestCase : AbstractRawFirBuilderTestCase() {
         println(DebugUtil.nodeTreeToString(builder.treeBuilt, false))
 
         val firFromLightTreeFile = DeclarationsConverter(
-            object : FirSession(null) {},
+            @OptIn(PrivateSessionConstructor::class) object : FirSession(null) {},
             StubFirScopeProvider,
             true,
             builder.lightTree

compiler/fir/raw-fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/AbstractPartialRawFirBuilderTestCase.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.builder
 
 import org.jetbrains.kotlin.fir.FirRenderer
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.PrivateSessionConstructor
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.psi.KtNamedFunction
 import org.jetbrains.kotlin.psi.psiUtil.findDescendantOfType
@@ -14,7 +15,6 @@ import org.jetbrains.kotlin.test.KotlinTestUtils
 import java.io.File
 
 abstract class AbstractPartialRawFirBuilderTestCase : AbstractRawFirBuilderTestCase() {
-
     override fun doRawFirTest(filePath: String) {
         val nameToFind = File(filePath).useLines {
             it.first().run {
@@ -24,9 +24,13 @@ abstract class AbstractPartialRawFirBuilderTestCase : AbstractRawFirBuilderTestC
         }
         val file = createKtFile(filePath)
         val functionToBuild = file.findDescendantOfType<KtNamedFunction> { it.name == nameToFind }!!
-        val firFunction = RawFirBuilder(
+
-            object : FirSession(null) {}, StubFirScopeProvider, false
+        @OptIn(PrivateSessionConstructor::class)
-        ).buildFunctionWithBody(functionToBuild)
+        val session = object : FirSession(null) {}
+
+        val firFunction = RawFirBuilder(session, StubFirScopeProvider, false)
+            .buildFunctionWithBody(functionToBuild)
+
         val firDump = firFunction.render(FirRenderer.RenderMode.WithFqNames)
         val expectedPath = filePath.replace(".kt", ".txt")
         KotlinTestUtils.assertEqualsToFile(File(expectedPath), firDump)

compiler/fir/raw-fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/AbstractRawFirBuilderTestCase.kt

@@ -14,9 +14,7 @@ import com.intellij.psi.PsiFile
 import com.intellij.psi.tree.IElementType
 import com.intellij.util.PathUtil
 import org.jetbrains.kotlin.KtNodeTypes
-import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.*
-import org.jetbrains.kotlin.fir.FirRenderer
-import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.contracts.impl.FirEmptyContractDescription
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
@@ -26,7 +24,6 @@ import org.jetbrains.kotlin.fir.expressions.FirEmptyArgumentList
 import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.expressions.impl.FirStubStatement
 import org.jetbrains.kotlin.fir.references.impl.FirStubReference
-import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.isExtensionFunctionAnnotationCall
@@ -76,8 +73,11 @@ abstract class AbstractRawFirBuilderTestCase : KtParsingTestCase(
         }
     }
 
-    protected fun KtFile.toFirFile(stubMode: Boolean): FirFile =
+    protected fun KtFile.toFirFile(stubMode: Boolean): FirFile {
-        RawFirBuilder(object : FirSession(null) {}, StubFirScopeProvider, stubMode).buildFirFile(this)
+        @OptIn(PrivateSessionConstructor::class)
+        val session = object : FirSession(null) {}
+        return RawFirBuilder(session, StubFirScopeProvider, stubMode).buildFirFile(this)
+    }
 
     private fun FirElement.traverseChildren(result: MutableSet<FirElement> = hashSetOf()): MutableSet<FirElement> {
         if (!result.add(this)) {

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

@@ -6,17 +6,9 @@
 package org.jetbrains.kotlin.fir
 
 import org.jetbrains.kotlin.analyzer.ModuleInfo
-import org.jetbrains.kotlin.fir.resolve.FirQualifierResolver
-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
 
-abstract class FirModuleBasedSession(
+@OptIn(PrivateSessionConstructor::class)
+abstract class FirModuleBasedSession @PrivateSessionConstructor constructor(
     override val moduleInfo: ModuleInfo,
     sessionProvider: FirSessionProvider?
 ) : FirSession(sessionProvider)
-
-fun FirSession.registerResolveComponents() {
-    register(FirQualifierResolver::class, FirQualifierResolverImpl(this))
-    register(FirTypeResolver::class, FirTypeResolverImpl(this))
-}

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirSessionCommonComponents.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.resolve.transformers.plugin.GeneratedClassIndex
-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))
-    register(GeneratedClassIndex::class, GeneratedClassIndex.create())
-}

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

@@ -15,9 +15,12 @@ import org.jetbrains.kotlin.fir.utils.TypeRegistry
 import org.jetbrains.kotlin.utils.Jsr305State
 import kotlin.reflect.KClass
 
+@RequiresOptIn
+annotation class PrivateSessionConstructor
+
 interface FirSessionComponent
 
-abstract class FirSession(val sessionProvider: FirSessionProvider?) : ComponentArrayOwner<FirSessionComponent, FirSessionComponent>() {
+abstract class FirSession @PrivateSessionConstructor constructor(val sessionProvider: FirSessionProvider?) : ComponentArrayOwner<FirSessionComponent, FirSessionComponent>() {
     companion object : TypeRegistry<FirSessionComponent, FirSessionComponent>() {
         inline fun <reified T : FirSessionComponent> sessionComponentAccessor(): ArrayMapAccessor<FirSessionComponent, FirSessionComponent, T> {
             return generateAccessor(T::class)

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

@@ -30,12 +30,11 @@ import org.jetbrains.kotlin.fir.extensions.BunchOfRegisteredExtensions
 import org.jetbrains.kotlin.fir.extensions.FirExtensionService
 import org.jetbrains.kotlin.fir.extensions.extensionService
 import org.jetbrains.kotlin.fir.extensions.registerExtensions
-import org.jetbrains.kotlin.fir.java.FirJavaModuleBasedSession
-import org.jetbrains.kotlin.fir.java.FirLibrarySession
 import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
 import org.jetbrains.kotlin.fir.lightTree.LightTree2Fir
 import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirProviderImpl
+import org.jetbrains.kotlin.fir.session.FirSessionFactory
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.TargetPlatform
@@ -76,7 +75,8 @@ abstract class AbstractFirBaseDiagnosticsTest : BaseDiagnosticsTest() {
 
         //For BuiltIns, registered in sessionProvider automatically
         val allProjectScope = GlobalSearchScope.allScope(project)
-        FirLibrarySession.create(
+
+        FirSessionFactory.createLibrarySession(
             builtInsModuleInfo, sessionProvider, allProjectScope, project,
             environment.createPackagePartProvider(allProjectScope)
         ).also {
@@ -88,7 +88,7 @@ abstract class AbstractFirBaseDiagnosticsTest : BaseDiagnosticsTest() {
             val scope = TopDownAnalyzerFacadeForJVM.newModuleSearchScope(
                 project,
                 moduleFiles.mapNotNull { it.ktFile })
-            FirJavaModuleBasedSession.create(info, sessionProvider, scope).also {
+            FirSessionFactory.createJavaModuleBasedSession(info, sessionProvider, scope).also {
                 registerFirExtensions(it.extensionService)
                 configureSession(it)
             }

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

@@ -11,9 +11,8 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.fir.extensions.BunchOfRegisteredExtensions
 import org.jetbrains.kotlin.fir.extensions.extensionService
 import org.jetbrains.kotlin.fir.extensions.registerExtensions
-import org.jetbrains.kotlin.fir.java.FirJavaModuleBasedSession
-import org.jetbrains.kotlin.fir.java.FirLibrarySession
 import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
+import org.jetbrains.kotlin.fir.session.FirSessionFactory
 import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
 import org.jetbrains.kotlin.name.Name
 
@@ -22,7 +21,7 @@ fun createSession(
     sourceScope: GlobalSearchScope,
     librariesScope: GlobalSearchScope = GlobalSearchScope.notScope(sourceScope),
     moduleName: String = "TestModule"
-) = createSession(environment.project, sourceScope, librariesScope, moduleName, environment::createPackagePartProvider)
+): FirSession = createSession(environment.project, sourceScope, librariesScope, moduleName, environment::createPackagePartProvider)
 
 fun createSession(
     project: Project,
@@ -33,7 +32,7 @@ fun createSession(
 ): FirSession {
     val moduleInfo = FirTestModuleInfo(name = Name.identifier(moduleName))
     val provider = FirProjectSessionProvider(project)
-    return FirJavaModuleBasedSession.create(moduleInfo, provider, sourceScope).also {
+    return FirSessionFactory.createJavaModuleBasedSession(moduleInfo, provider, sourceScope).also {
         createSessionForDependencies(project, provider, moduleInfo, librariesScope, packagePartProvider)
         it.extensionService.registerExtensions(BunchOfRegisteredExtensions.empty())
     }
@@ -48,7 +47,7 @@ private fun createSessionForDependencies(
 ) {
     val dependenciesInfo = FirTestModuleInfo(name = Name.identifier(moduleInfo.name.identifier + ".dependencies"))
     moduleInfo.dependencies.add(dependenciesInfo)
-    FirLibrarySession.create(
+    FirSessionFactory.createLibrarySession(
         dependenciesInfo, provider, librariesScope, project, packagePartProvider(librariesScope)
     )
 }

idea/idea-frontend-fir/idea-fir-low-level-api/build.gradle.kts

@@ -15,6 +15,7 @@ dependencies {
     compile(project(":compiler:fir:checkers"))
     compile(project(":compiler:fir:java"))
     compile(project(":compiler:fir:jvm"))
+    implementation(project(":compiler:fir:entrypoint"))
     compile(intellijDep())
     compile(intellijCoreDep())
 

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

@@ -7,16 +7,17 @@ package org.jetbrains.kotlin.idea.fir.low.level.api.sessions
 
 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
+import org.jetbrains.kotlin.fir.PrivateSessionConstructor
 import org.jetbrains.kotlin.analyzer.ModuleInfo
 import org.jetbrains.kotlin.fir.java.JavaSymbolProvider
 import org.jetbrains.kotlin.fir.java.deserialization.KotlinDeserializedJvmSymbolsProvider
-import org.jetbrains.kotlin.fir.registerCommonComponents
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirBuiltinSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCloneableSymbolProvider
 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.session.registerCommonComponents
 import org.jetbrains.kotlin.idea.caches.project.ModuleSourceInfo
 import org.jetbrains.kotlin.idea.caches.resolve.IDEPackagePartProvider
 import org.jetbrains.kotlin.idea.fir.low.level.api.IdeSessionComponents
@@ -26,11 +27,12 @@ import org.jetbrains.kotlin.load.kotlin.VirtualFileFinderFactory
 /**
  * [org.jetbrains.kotlin.fir.FirSession] responsible for all libraries analysing module transitively depends on
  */
+@OptIn(PrivateSessionConstructor::class)
 internal class FirIdeLibrariesSession private constructor(
-    override val moduleInfo: ModuleInfo,
+    moduleInfo: ModuleInfo,
     sessionProvider: FirIdeSessionProvider,
     override val scope: GlobalSearchScope
-) : FirIdeSession(sessionProvider) {
+) : FirIdeSession(moduleInfo, sessionProvider) {
     companion object {
         fun create(
             moduleInfo: ModuleSourceInfo,

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

@@ -6,8 +6,14 @@
 package org.jetbrains.kotlin.idea.fir.low.level.api.sessions
 
 import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.analyzer.ModuleInfo
+import org.jetbrains.kotlin.fir.FirModuleBasedSession
+import org.jetbrains.kotlin.fir.PrivateSessionConstructor
 
-internal abstract class FirIdeSession(sessionProvider: FirIdeSessionProvider) : FirSession(sessionProvider) {
+@OptIn(PrivateSessionConstructor::class)
+internal abstract class FirIdeSession(
+    moduleInfo: ModuleInfo,
+    sessionProvider: FirIdeSessionProvider
+) : FirModuleBasedSession(moduleInfo, sessionProvider) {
     abstract val scope: GlobalSearchScope
 }

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

@@ -10,12 +10,10 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analyzer.ModuleInfo
 import org.jetbrains.kotlin.fir.*
-import org.jetbrains.kotlin.fir.analysis.registerCheckersComponent
 import org.jetbrains.kotlin.fir.extensions.BunchOfRegisteredExtensions
 import org.jetbrains.kotlin.fir.extensions.extensionService
 import org.jetbrains.kotlin.fir.extensions.registerExtensions
 import org.jetbrains.kotlin.fir.java.JavaSymbolProvider
-import org.jetbrains.kotlin.fir.java.registerJavaSpecificComponents
 import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.FirProvider
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
@@ -23,6 +21,10 @@ import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCompositeSymbolProvide
 import org.jetbrains.kotlin.fir.resolve.scopes.wrapScopeWithJvmMapped
 import org.jetbrains.kotlin.fir.resolve.transformers.PhasedFirFileResolver
 import org.jetbrains.kotlin.fir.scopes.KotlinScopeProvider
+import org.jetbrains.kotlin.fir.session.registerCheckersComponent
+import org.jetbrains.kotlin.fir.session.registerCommonComponents
+import org.jetbrains.kotlin.fir.session.registerJavaSpecificComponents
+import org.jetbrains.kotlin.fir.session.registerResolveComponents
 import org.jetbrains.kotlin.idea.caches.project.ModuleSourceInfo
 import org.jetbrains.kotlin.idea.fir.low.level.api.lazy.resolve.FirLazyDeclarationResolver
 import org.jetbrains.kotlin.idea.fir.low.level.api.FirPhaseRunner
@@ -36,12 +38,13 @@ import org.jetbrains.kotlin.idea.fir.low.level.api.util.collectTransitiveDepende
 /**
  * [org.jetbrains.kotlin.fir.FirSession] responsible for all Kotlin & Java source modules analysing module transitively depends on
  */
+@OptIn(PrivateSessionConstructor::class)
 internal class FirIdeSourcesSession private constructor(
-    override val moduleInfo: ModuleInfo?,
+    moduleInfo: ModuleInfo,
     sessionProvider: FirIdeSessionProvider,
     override val scope: GlobalSearchScope,
     val firFileBuilder: FirFileBuilder,
-) : FirIdeSession(sessionProvider) {
+) : FirIdeSession(moduleInfo, sessionProvider) {
     val cache get() = firIdeProvider.cache
 
     companion object {

idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/AbstractFirMultiModuleResolveTest.kt

@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirProviderImpl
 import org.jetbrains.kotlin.fir.resolve.transformers.FirTransformerBasedResolveProcessor
 import org.jetbrains.kotlin.fir.resolve.transformers.createAllTransformerBasedResolveProcessors
+import org.jetbrains.kotlin.fir.session.FirSessionFactory
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.caches.project.IdeaModuleInfo
 import org.jetbrains.kotlin.idea.caches.project.isLibraryClasses
@@ -59,14 +60,14 @@ abstract class AbstractFirMultiModuleResolveTest : AbstractMultiModuleTest() {
 
     private fun createSession(module: Module, provider: FirProjectSessionProvider): FirJavaModuleBasedSession {
         val moduleInfo = module.productionSourceInfo()!!
-        return FirJavaModuleBasedSession.create(moduleInfo, provider, moduleInfo.contentScope()).also {
+        return FirSessionFactory.createJavaModuleBasedSession(moduleInfo, provider, moduleInfo.contentScope()).also {
             it.extensionService.registerExtensions(BunchOfRegisteredExtensions.empty())
         }
     }
 
     private fun createLibrarySession(moduleInfo: IdeaModuleInfo, provider: FirProjectSessionProvider): FirLibrarySession {
         val contentScope = moduleInfo.contentScope()
-        return FirLibrarySession.create(moduleInfo, provider, contentScope, project, IDEPackagePartProvider(contentScope))
+        return FirSessionFactory.createLibrarySession(moduleInfo, provider, contentScope, project, IDEPackagePartProvider(contentScope))
     }
 
     private fun doFirResolveTest(dirPath: String) {

prepare/idea-plugin/build.gradle.kts

@@ -43,6 +43,7 @@ val projectsToShadow by extra(listOf(
         ":compiler:psi",
         ":compiler:fir:cones",
         ":compiler:fir:checkers",
+        ":compiler:fir:entrypoint",
         ":compiler:fir:resolve",
         ":compiler:fir:fir-serialization",
         ":compiler:fir:fir-deserialization",

settings.gradle

@@ -312,6 +312,7 @@ include ":compiler:fir:cones",
         ":compiler:fir:dump",
         ":compiler:fir:jvm",
         ":compiler:fir:checkers",
+        ":compiler:fir:entrypoint",
         ":compiler:fir:analysis-tests"
 
 include ":idea:idea-frontend-fir:idea-fir-low-level-api"