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

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
 ) {
@@ -68,4 +69,4 @@ class LightTree2Fir(
         return DeclarationsConverter(session, scopeProvider, stubMode, lightTree)
             .convertFile(lightTree.root, fileName)
     }
-}
+}

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
-        ).buildFunctionWithBody(functionToBuild)
+
+        @OptIn(PrivateSessionConstructor::class)
+        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)
@@ -35,4 +39,4 @@ abstract class AbstractPartialRawFirBuilderTestCase : AbstractRawFirBuilderTestC
     companion object {
         private const val prefix = "// FUNCTION: "
     }
-}
+}

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.FirRenderer
-import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.*
 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 =
-        RawFirBuilder(object : FirSession(null) {}, StubFirScopeProvider, stubMode).buildFirFile(this)
+    protected fun KtFile.toFirFile(stubMode: Boolean): FirFile {
+        @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)
@@ -64,4 +67,4 @@ class BuiltinTypes {
     val nullableNothingType: FirImplicitBuiltinTypeRef = FirImplicitNullableNothingTypeRef(null)
     val charType: FirImplicitBuiltinTypeRef = FirImplicitCharTypeRef(null)
     val stringType: FirImplicitBuiltinTypeRef = FirImplicitStringTypeRef(null)
-}
+}