[FIR] Commonize code for creating common, JVM and JS session

Extract FirAbstractSessionFactory

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

@@ -0,0 +1,139 @@
+/*
+ * Copyright 2010-2022 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.config.LanguageVersionSettings
+import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.checkers.registerCommonCheckers
+import org.jetbrains.kotlin.fir.deserialization.ModuleDataProvider
+import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
+import org.jetbrains.kotlin.fir.extensions.FirSwitchableExtensionDeclarationsSymbolProvider
+import org.jetbrains.kotlin.fir.java.FirCliSession
+import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
+import org.jetbrains.kotlin.fir.resolve.providers.FirDependenciesSymbolProvider
+import org.jetbrains.kotlin.fir.resolve.providers.FirProvider
+import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
+import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCompositeSymbolProvider
+import org.jetbrains.kotlin.fir.resolve.providers.impl.FirDependenciesSymbolProviderImpl
+import org.jetbrains.kotlin.fir.resolve.providers.impl.FirLibrarySessionProvider
+import org.jetbrains.kotlin.fir.resolve.providers.impl.FirProviderImpl
+import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
+import org.jetbrains.kotlin.incremental.components.EnumWhenTracker
+import org.jetbrains.kotlin.incremental.components.LookupTracker
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.resolve.PlatformDependentAnalyzerServices
+
+@OptIn(PrivateSessionConstructor::class, SessionConfiguration::class)
+abstract class FirAbstractSessionFactory {
+    protected fun createLibrarySession(
+        mainModuleName: Name,
+        sessionProvider: FirProjectSessionProvider,
+        moduleDataProvider: ModuleDataProvider,
+        languageVersionSettings: LanguageVersionSettings,
+        registerExtraComponents: ((FirSession) -> Unit)?,
+        createKotlinScopeProvider: () -> FirKotlinScopeProvider,
+        createProviders: (FirSession, FirModuleData, FirKotlinScopeProvider) -> List<FirSymbolProvider>
+    ): FirSession {
+        return FirCliSession(sessionProvider, FirSession.Kind.Library).apply session@{
+            moduleDataProvider.allModuleData.forEach {
+                sessionProvider.registerSession(it, this)
+                it.bindSession(this)
+            }
+
+            registerCliCompilerOnlyComponents()
+            registerCommonComponents(languageVersionSettings)
+            registerExtraComponents?.invoke(this)
+
+            val kotlinScopeProvider = createKotlinScopeProvider.invoke()
+            register(FirKotlinScopeProvider::class, kotlinScopeProvider)
+
+            val builtinsModuleData = createModuleDataForBuiltins(
+                mainModuleName,
+                moduleDataProvider.platform,
+                moduleDataProvider.analyzerServices
+            ).also { it.bindSession(this@session) }
+
+            val providers = createProviders(this, builtinsModuleData, kotlinScopeProvider)
+
+            val symbolProvider = FirCompositeSymbolProvider(this, providers)
+            register(FirSymbolProvider::class, symbolProvider)
+            register(FirProvider::class, FirLibrarySessionProvider(symbolProvider))
+        }
+    }
+
+    private fun createModuleDataForBuiltins(
+        parentModuleName: Name,
+        platform: TargetPlatform,
+        analyzerServices: PlatformDependentAnalyzerServices
+    ): FirModuleData {
+        return DependencyListForCliModule.createDependencyModuleData(
+            Name.special("<builtins of ${parentModuleName.identifier}"),
+            platform,
+            analyzerServices,
+        )
+    }
+
+    protected fun createModuleBasedSession(
+        moduleData: FirModuleData,
+        sessionProvider: FirProjectSessionProvider,
+        extensionRegistrars: List<FirExtensionRegistrar>,
+        languageVersionSettings: LanguageVersionSettings,
+        lookupTracker: LookupTracker?,
+        enumWhenTracker: EnumWhenTracker?,
+        init: FirSessionConfigurator.() -> Unit,
+        registerExtraComponents: ((FirSession) -> Unit)?,
+        registerExtraCheckers: ((FirSessionConfigurator) -> Unit)?,
+        createKotlinScopeProvider: () -> FirKotlinScopeProvider,
+        createProviders: (
+            FirSession, FirKotlinScopeProvider, FirSymbolProvider,
+            FirSwitchableExtensionDeclarationsSymbolProvider?,
+            FirDependenciesSymbolProviderImpl
+        ) -> List<FirSymbolProvider>
+    ): FirSession {
+        return FirCliSession(sessionProvider, FirSession.Kind.Source).apply session@{
+            moduleData.bindSession(this@session)
+            sessionProvider.registerSession(moduleData, this@session)
+            registerModuleData(moduleData)
+            registerCliCompilerOnlyComponents()
+            registerCommonComponents(languageVersionSettings)
+            registerResolveComponents(lookupTracker, enumWhenTracker)
+            registerExtraComponents?.invoke(this)
+
+            val kotlinScopeProvider = createKotlinScopeProvider.invoke()
+            register(FirKotlinScopeProvider::class, kotlinScopeProvider)
+
+            val firProvider = FirProviderImpl(this, kotlinScopeProvider)
+            register(FirProvider::class, firProvider)
+
+            FirSessionFactory.FirSessionConfigurator(this).apply {
+                registerCommonCheckers()
+                registerExtraCheckers?.invoke(this)
+
+                for (extensionRegistrar in extensionRegistrars) {
+                    registerExtensions(extensionRegistrar.configure())
+                }
+                init()
+            }.configure()
+
+            val dependenciesSymbolProvider = FirDependenciesSymbolProviderImpl(this)
+            val generatedSymbolsProvider = FirSwitchableExtensionDeclarationsSymbolProvider.create(this)
+
+            val providers = createProviders(
+                this, kotlinScopeProvider, firProvider.symbolProvider, generatedSymbolsProvider, dependenciesSymbolProvider,
+            )
+
+            register(FirSymbolProvider::class, FirCompositeSymbolProvider(this, providers))
+
+            generatedSymbolsProvider?.let { register(FirSwitchableExtensionDeclarationsSymbolProvider::class, it) }
+
+            register(
+                FirDependenciesSymbolProvider::class,
+                dependenciesSymbolProvider
+            )
+        }
+    }
+}

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

@@ -14,21 +14,21 @@ import org.jetbrains.kotlin.fir.analysis.checkers.expression.ExpressionCheckers
 import org.jetbrains.kotlin.fir.analysis.checkers.type.TypeCheckers
 import org.jetbrains.kotlin.fir.analysis.checkersComponent
 import org.jetbrains.kotlin.fir.analysis.extensions.additionalCheckers
-import org.jetbrains.kotlin.fir.checkers.registerCommonCheckers
 import org.jetbrains.kotlin.fir.checkers.registerJvmCheckers
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
-import org.jetbrains.kotlin.fir.deserialization.ModuleDataProvider
 import org.jetbrains.kotlin.fir.deserialization.SingleModuleDataProvider
-import org.jetbrains.kotlin.fir.extensions.*
+import org.jetbrains.kotlin.fir.extensions.BunchOfRegisteredExtensions
-import org.jetbrains.kotlin.fir.java.FirCliSession
+import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
+import org.jetbrains.kotlin.fir.extensions.extensionService
+import org.jetbrains.kotlin.fir.extensions.registerExtensions
 import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
 import org.jetbrains.kotlin.fir.java.JavaSymbolProvider
 import org.jetbrains.kotlin.fir.java.deserialization.JvmClassFileBasedSymbolProvider
 import org.jetbrains.kotlin.fir.java.deserialization.OptionalAnnotationClassesProvider
-import org.jetbrains.kotlin.fir.resolve.providers.FirDependenciesSymbolProvider
-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.providers.impl.FirBuiltinSymbolProvider
+import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCloneableSymbolProvider
+import org.jetbrains.kotlin.fir.resolve.providers.impl.FirDependenciesSymbolProviderImpl
 import org.jetbrains.kotlin.fir.resolve.scopes.wrapScopeWithJvmMapped
 import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
 import org.jetbrains.kotlin.fir.session.environment.AbstractProjectEnvironment
@@ -43,7 +43,7 @@ import org.jetbrains.kotlin.resolve.PlatformDependentAnalyzerServices
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformAnalyzerServices
 
 @OptIn(PrivateSessionConstructor::class, SessionConfiguration::class)
-object FirSessionFactory {
+object FirSessionFactory : FirAbstractSessionFactory() {
     class FirSessionConfigurator(private val session: FirSession) {
         private val registeredExtensions: MutableList<BunchOfRegisteredExtensions> = mutableListOf(BunchOfRegisteredExtensions.empty())
 
@@ -98,13 +98,14 @@ object FirSessionFactory {
     ): FirSession {
         val dependencyList = DependencyListForCliModule.build(moduleName, platform, analyzerServices, dependenciesConfigurator)
         val sessionProvider = externalSessionProvider ?: FirProjectSessionProvider()
+        val packagePartProvider = projectEnvironment.getPackagePartProvider(librariesScope)
         createLibrarySession(
             moduleName,
             sessionProvider,
-            dependencyList.moduleDataProvider,
+            dependencyList,
-            librariesScope,
             projectEnvironment,
-            projectEnvironment.getPackagePartProvider(librariesScope),
+            librariesScope,
+            packagePartProvider,
             languageVersionSettings
         )
 
@@ -116,22 +117,58 @@ object FirSessionFactory {
             dependencyList.platform,
             dependencyList.analyzerServices
         )
-        return createJavaModuleBasedSession(
+        return createModuleBasedSession(
             mainModuleData,
             sessionProvider,
             javaSourcesScope,
             projectEnvironment,
             incrementalCompilationContext,
             extensionRegistrars,
-            languageVersionSettings = languageVersionSettings,
+            languageVersionSettings,
-            lookupTracker = lookupTracker,
+            lookupTracker,
-            enumWhenTracker = enumWhenTracker,
+            enumWhenTracker,
             needRegisterJavaElementFinder,
-            init = sessionConfigurator
+            sessionConfigurator
         )
     }
 
-    fun createJavaModuleBasedSession(
+    fun createLibrarySession(
+        mainModuleName: Name,
+        sessionProvider: FirProjectSessionProvider,
+        dependencyList: DependencyListForCliModule,
+        projectEnvironment: AbstractProjectEnvironment,
+        scope: AbstractProjectFileSearchScope,
+        packagePartProvider: PackagePartProvider,
+        languageVersionSettings: LanguageVersionSettings,
+    ): FirSession {
+        return createLibrarySession(
+            mainModuleName,
+            sessionProvider,
+            dependencyList.moduleDataProvider,
+            languageVersionSettings,
+            registerExtraComponents = { it.registerCommonJavaComponents(projectEnvironment.getJavaModuleResolver()) },
+            createKotlinScopeProvider = { FirKotlinScopeProvider(::wrapScopeWithJvmMapped) },
+            createProviders = { session, builtinsModuleData, kotlinScopeProvider ->
+                listOf(
+                    JvmClassFileBasedSymbolProvider(
+                        session,
+                        dependencyList.moduleDataProvider,
+                        kotlinScopeProvider,
+                        packagePartProvider,
+                        projectEnvironment.getKotlinClassFinder(scope),
+                        projectEnvironment.getFirJavaFacade(session, dependencyList.moduleDataProvider.allModuleData.last(), scope)
+                    ),
+                    FirBuiltinSymbolProvider(session, builtinsModuleData, kotlinScopeProvider),
+                    FirCloneableSymbolProvider(session, builtinsModuleData, kotlinScopeProvider),
+                    FirDependenciesSymbolProviderImpl(session),
+                    OptionalAnnotationClassesProvider(session, dependencyList.moduleDataProvider, kotlinScopeProvider, packagePartProvider)
+                )
+            }
+        )
+    }
+
+    @OptIn(SessionConfiguration::class)
+    fun createModuleBasedSession(
         moduleData: FirModuleData,
         sessionProvider: FirProjectSessionProvider,
         javaSourcesScope: AbstractProjectFileSearchScope,
@@ -144,148 +181,67 @@ object FirSessionFactory {
         needRegisterJavaElementFinder: Boolean,
         init: FirSessionConfigurator.() -> Unit = {}
     ): FirSession {
-        return FirCliSession(sessionProvider, FirSession.Kind.Source).apply session@{
+        return createModuleBasedSession(
-            moduleData.bindSession(this@session)
+            moduleData,
-            sessionProvider.registerSession(moduleData, this@session)
+            sessionProvider,
-            registerModuleData(moduleData)
+            extensionRegistrars,
-            registerCliCompilerOnlyComponents()
+            languageVersionSettings,
-            registerCommonComponents(languageVersionSettings)
+            lookupTracker,
-            registerCommonJavaComponents(projectEnvironment.getJavaModuleResolver())
+            enumWhenTracker,
-            registerResolveComponents(lookupTracker, enumWhenTracker)
+            init,
-            registerJavaSpecificResolveComponents()
+            registerExtraComponents = {
-
+                it.registerCommonJavaComponents(projectEnvironment.getJavaModuleResolver())
-            val kotlinScopeProvider = FirKotlinScopeProvider(::wrapScopeWithJvmMapped)
+                it.registerJavaSpecificResolveComponents()
-            register(FirKotlinScopeProvider::class, kotlinScopeProvider)
+            },
-
+            registerExtraCheckers = { it.registerJvmCheckers() },
-            val firProvider = FirProviderImpl(this, kotlinScopeProvider)
+            createKotlinScopeProvider = { FirKotlinScopeProvider(::wrapScopeWithJvmMapped) },
-            register(FirProvider::class, firProvider)
+            createProviders = { session, kotlinScopeProvider, symbolProvider, generatedSymbolsProvider, dependenciesSymbolProvider ->
-
+                var symbolProviderForBinariesFromIncrementalCompilation: JvmClassFileBasedSymbolProvider? = null
-            var symbolProviderForBinariesFromIncrementalCompilation: JvmClassFileBasedSymbolProvider? = null
+                var optionalAnnotationClassesProviderForBinariesFromIncrementalCompilation: OptionalAnnotationClassesProvider? = null
-            var optionalAnnotationClassesProviderForBinariesFromIncrementalCompilation: OptionalAnnotationClassesProvider? = null
+                incrementalCompilationContext?.let {
-            incrementalCompilationContext?.let {
+                    if (it.precompiledBinariesPackagePartProvider != null && it.precompiledBinariesFileScope != null) {
-                if (it.precompiledBinariesPackagePartProvider != null && it.precompiledBinariesFileScope != null) {
+                        val moduleDataProvider = SingleModuleDataProvider(moduleData)
-                    val moduleDataProvider = SingleModuleDataProvider(moduleData)
+                        symbolProviderForBinariesFromIncrementalCompilation =
-                    symbolProviderForBinariesFromIncrementalCompilation =
+                            JvmClassFileBasedSymbolProvider(
-                        JvmClassFileBasedSymbolProvider(
+                                session,
-                            this@session,
+                                moduleDataProvider,
-                            moduleDataProvider,
+                                kotlinScopeProvider,
-                            kotlinScopeProvider,
+                                it.precompiledBinariesPackagePartProvider,
-                            it.precompiledBinariesPackagePartProvider,
+                                projectEnvironment.getKotlinClassFinder(it.precompiledBinariesFileScope),
-                            projectEnvironment.getKotlinClassFinder(it.precompiledBinariesFileScope),
+                                projectEnvironment.getFirJavaFacade(session, moduleData, it.precompiledBinariesFileScope),
-                            projectEnvironment.getFirJavaFacade(this, moduleData, it.precompiledBinariesFileScope),
+                                defaultDeserializationOrigin = FirDeclarationOrigin.Precompiled
-                            defaultDeserializationOrigin = FirDeclarationOrigin.Precompiled
+                            )
-                        )
+                        optionalAnnotationClassesProviderForBinariesFromIncrementalCompilation =
-                    optionalAnnotationClassesProviderForBinariesFromIncrementalCompilation =
+                            OptionalAnnotationClassesProvider(
-                        OptionalAnnotationClassesProvider(
+                                session,
-                            this@session,
+                                moduleDataProvider,
-                            moduleDataProvider,
+                                kotlinScopeProvider,
-                            kotlinScopeProvider,
+                                it.precompiledBinariesPackagePartProvider,
-                            it.precompiledBinariesPackagePartProvider,
+                                defaultDeserializationOrigin = FirDeclarationOrigin.Precompiled
-                            defaultDeserializationOrigin = FirDeclarationOrigin.Precompiled
+                            )
-                        )
+                    }
                 }
-            }
 
-            FirSessionConfigurator(this).apply {
+                val javaSymbolProvider = JavaSymbolProvider(session, projectEnvironment.getFirJavaFacade(session, moduleData, javaSourcesScope))
-                registerCommonCheckers()
+                session.register(JavaSymbolProvider::class, javaSymbolProvider)
-                registerJvmCheckers()
-                for (extensionRegistrar in extensionRegistrars) {
-                    registerExtensions(extensionRegistrar.configure())
-                }
-                init()
-            }.configure()
 
-            val dependenciesSymbolProvider = FirDependenciesSymbolProviderImpl(this)
+                listOfNotNull(
-            val generatedSymbolsProvider = FirSwitchableExtensionDeclarationsSymbolProvider.create(this)
+                    symbolProvider,
-            val javaSymbolProvider = JavaSymbolProvider(this, projectEnvironment.getFirJavaFacade(this, moduleData, javaSourcesScope))
+                    *(incrementalCompilationContext?.previousFirSessionsSymbolProviders?.toTypedArray() ?: emptyArray()),
-            register(
+                    symbolProviderForBinariesFromIncrementalCompilation,
-                FirSymbolProvider::class,
+                    generatedSymbolsProvider,
-                FirCompositeSymbolProvider(
+                    javaSymbolProvider,
-                    this,
+                    dependenciesSymbolProvider,
-                    listOfNotNull(
+                    optionalAnnotationClassesProviderForBinariesFromIncrementalCompilation,
-                        firProvider.symbolProvider,
-                        *(incrementalCompilationContext?.previousFirSessionsSymbolProviders?.toTypedArray() ?: emptyArray()),
-                        symbolProviderForBinariesFromIncrementalCompilation,
-                        generatedSymbolsProvider,
-                        javaSymbolProvider,
-                        dependenciesSymbolProvider,
-                        optionalAnnotationClassesProviderForBinariesFromIncrementalCompilation,
-                    )
                 )
-            )
+            }
-            register(JavaSymbolProvider::class, javaSymbolProvider)
+        ).also {
-
-            generatedSymbolsProvider?.let { register(FirSwitchableExtensionDeclarationsSymbolProvider::class, it) }
-
-            register(
-                FirDependenciesSymbolProvider::class,
-                dependenciesSymbolProvider
-            )
             if (needRegisterJavaElementFinder) {
-                projectEnvironment.registerAsJavaElementFinder(this)
+                projectEnvironment.registerAsJavaElementFinder(it)
             }
         }
     }
 
-    fun createLibrarySession(
-        mainModuleName: Name,
-        sessionProvider: FirProjectSessionProvider,
-        moduleDataProvider: ModuleDataProvider,
-        scope: AbstractProjectFileSearchScope,
-        projectEnvironment: AbstractProjectEnvironment,
-        packagePartProvider: PackagePartProvider,
-        languageVersionSettings: LanguageVersionSettings = LanguageVersionSettingsImpl.DEFAULT,
-    ): FirSession {
-        return FirCliSession(sessionProvider, FirSession.Kind.Library).apply session@{
-            moduleDataProvider.allModuleData.forEach {
-                sessionProvider.registerSession(it, this)
-                it.bindSession(this)
-            }
-
-            registerCliCompilerOnlyComponents()
-            registerCommonComponents(languageVersionSettings)
-            registerCommonJavaComponents(projectEnvironment.getJavaModuleResolver())
-
-            val kotlinScopeProvider = FirKotlinScopeProvider(::wrapScopeWithJvmMapped)
-            register(FirKotlinScopeProvider::class, kotlinScopeProvider)
-
-            val classFileBasedSymbolProvider = JvmClassFileBasedSymbolProvider(
-                this,
-                moduleDataProvider,
-                kotlinScopeProvider,
-                packagePartProvider,
-                projectEnvironment.getKotlinClassFinder(scope),
-                projectEnvironment.getFirJavaFacade(this, moduleDataProvider.allModuleData.last(), scope)
-            )
-
-            val optionalAnnotationClassesProvider = OptionalAnnotationClassesProvider(
-                this,
-                moduleDataProvider,
-                kotlinScopeProvider,
-                packagePartProvider
-            )
-
-            val builtinsModuleData = createModuleDataForBuiltins(
-                mainModuleName,
-                moduleDataProvider.platform,
-                moduleDataProvider.analyzerServices
-            ).also { it.bindSession(this@session) }
-
-            val symbolProvider = FirCompositeSymbolProvider(
-                this,
-                listOf(
-                    classFileBasedSymbolProvider,
-                    FirBuiltinSymbolProvider(this, builtinsModuleData, kotlinScopeProvider),
-                    FirCloneableSymbolProvider(this, builtinsModuleData, kotlinScopeProvider),
-                    FirDependenciesSymbolProviderImpl(this),
-                    optionalAnnotationClassesProvider
-                )
-            )
-            register(FirSymbolProvider::class, symbolProvider)
-            register(FirProvider::class, FirLibrarySessionProvider(symbolProvider))
-        }
-    }
-
     @TestOnly
     fun createEmptySession(): FirSession {
         return object : FirSession(null, Kind.Source) {}.apply {
@@ -301,16 +257,4 @@ object FirSessionFactory {
             moduleData.bindSession(this)
         }
     }
-
-    fun createModuleDataForBuiltins(
-        parentModuleName: Name,
-        platform: TargetPlatform,
-        analyzerServices: PlatformDependentAnalyzerServices
-    ): FirModuleData {
-        return DependencyListForCliModule.createDependencyModuleData(
-            Name.special("<builtins of ${parentModuleName.identifier}"),
-            platform,
-            analyzerServices,
-        )
-    }
 }

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/FirFrontendFacade.kt

@@ -5,11 +5,9 @@
 
 package org.jetbrains.kotlin.test.frontend.fir
 
-import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.StandardFileSystems
 import com.intellij.openapi.vfs.VirtualFileManager
 import com.intellij.psi.PsiElementFinder
-import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.search.ProjectScope
 import org.jetbrains.kotlin.analyzer.common.CommonPlatformAnalyzerServices
 import org.jetbrains.kotlin.asJava.finder.JavaElementFinder
@@ -21,13 +19,10 @@ import org.jetbrains.kotlin.cli.jvm.config.jvmClasspathRoots
 import org.jetbrains.kotlin.cli.jvm.config.jvmModularRoots
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
-import org.jetbrains.kotlin.config.LanguageVersionSettings
-import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.FirAnalyzerFacade
 import org.jetbrains.kotlin.fir.checkers.registerExtendedCommonCheckers
 import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
-import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
 import org.jetbrains.kotlin.fir.session.FirSessionFactory
 import org.jetbrains.kotlin.ir.backend.js.jsResolveLibraries
 import org.jetbrains.kotlin.ir.backend.js.toResolverLogger
@@ -101,33 +96,82 @@ class FirFrontendFacade(
             additionalSessionConfiguration?.invoke(this)
         }
 
+        val isCommonOrJvm = module.targetPlatform.isJvm() || module.targetPlatform.isCommon()
+
+        val dependencyList: DependencyListForCliModule = buildDependencyList(module, moduleName, moduleInfoProvider, analyzerServices) {
+            if (isCommonOrJvm) {
+                configureJvmDependencies(configuration)
+            } else {
+                configureJsDependencies(module, testServices)
+            }
+        }
+
+        val projectEnvironment: VfsBasedProjectEnvironment?
+
+        if (isCommonOrJvm) {
+            val packagePartProviderFactory = compilerConfigurationProvider.getPackagePartProviderFactory(module)
+            projectEnvironment = VfsBasedProjectEnvironment(
+                project, VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.FILE_PROTOCOL),
+            ) { packagePartProviderFactory.invoke(it) }
+            val projectFileSearchScope = PsiBasedProjectFileSearchScope(ProjectScope.getLibrariesScope(project))
+            val packagePartProvider = projectEnvironment.getPackagePartProvider(projectFileSearchScope)
+
+            FirSessionFactory.createLibrarySession(
+                moduleName,
+                moduleInfoProvider.firSessionProvider,
+                dependencyList,
+                projectEnvironment,
+                projectFileSearchScope,
+                packagePartProvider,
+                languageVersionSettings,
+            )
+        } else {
+            projectEnvironment = null
+
+            FirJsSessionFactory.createLibrarySession(
+                moduleName,
+                moduleInfoProvider.firSessionProvider,
+                dependencyList,
+                module,
+                testServices,
+                configuration,
+                languageVersionSettings,
+            )
+        }
+
+        val mainModuleData = FirModuleDataImpl(
+            moduleName,
+            dependencyList.regularDependencies,
+            dependencyList.dependsOnDependencies,
+            dependencyList.friendsDependencies,
+            dependencyList.platform,
+            dependencyList.analyzerServices
+        )
+
         val session = when {
-            module.targetPlatform.isJvm() || module.targetPlatform.isCommon() -> {
+            isCommonOrJvm -> {
-                configureSessionsForJvmOrCommon(
+                FirSessionFactory.createModuleBasedSession(
-                    module,
+                    mainModuleData,
-                    moduleName,
+                    moduleInfoProvider.firSessionProvider,
-                    project,
+                    PsiBasedProjectFileSearchScope(TopDownAnalyzerFacadeForJVM.newModuleSearchScope(project, ktFiles)),
-                    ktFiles,
+                    projectEnvironment!!,
-                    compilerConfigurationProvider,
+                    incrementalCompilationContext = null,
-                    moduleInfoProvider,
-                    analyzerServices,
-                    configuration,
-                    sessionConfigurator,
                     extensionRegistrars,
                     languageVersionSettings,
+                    lookupTracker = null,
+                    enumWhenTracker = null,
+                    needRegisterJavaElementFinder = true,
+                    sessionConfigurator,
                 )
             }
             module.targetPlatform.isJs() -> {
-                configureSessionsForJs(
+                FirJsSessionFactory.createModuleBasedSession(
-                    module,
+                    mainModuleData,
-                    moduleName,
+                    moduleInfoProvider.firSessionProvider,
-                    moduleInfoProvider,
-                    analyzerServices,
-                    configuration,
-                    testServices,
-                    sessionConfigurator,
                     extensionRegistrars,
                     languageVersionSettings,
+                    null,
+                    sessionConfigurator,
                 )
             }
             else -> error("Unsupported")
@@ -213,166 +257,6 @@ private fun buildDependencyList(
     sourceDependsOnDependencies(moduleInfoProvider.getDependentDependsOnSourceModules(module))
 }
 
-private fun configureSessionsForJvmOrCommon(
-    module: TestModule,
-    moduleName: Name,
-    project: Project,
-    ktFiles: Collection<KtFile>,
-    compilerConfigurationProvider: CompilerConfigurationProvider,
-    moduleInfoProvider: FirModuleInfoProvider,
-    analyzerServices: PlatformDependentAnalyzerServices,
-    configuration: CompilerConfiguration,
-    sessionConfigurator: FirSessionFactory.FirSessionConfigurator.() -> Unit,
-    extensionRegistrars: List<FirExtensionRegistrar>,
-    languageVersionSettings: LanguageVersionSettings = LanguageVersionSettingsImpl.DEFAULT,
-): FirSession {
-    val librariesScope = ProjectScope.getLibrariesScope(project)
-    val sourcesScope = TopDownAnalyzerFacadeForJVM.newModuleSearchScope(project, ktFiles)
-
-    val dependencyList = buildDependencyList(module, moduleName, moduleInfoProvider, analyzerServices) {
-        configureJvmDependencies(configuration)
-    }
-
-    configureLibrarySessionForJvmOrCommon(
-        module,
-        moduleName,
-        moduleInfoProvider.firSessionProvider,
-        dependencyList,
-        librariesScope,
-        project,
-        compilerConfigurationProvider,
-        languageVersionSettings,
-    )
-
-    val mainModuleData = FirModuleDataImpl(
-        moduleName,
-        dependencyList.regularDependencies,
-        dependencyList.dependsOnDependencies,
-        dependencyList.friendsDependencies,
-        dependencyList.platform,
-        dependencyList.analyzerServices
-    )
-
-    return configureMainSessionForJvmOrCommon(
-        module,
-        project,
-        compilerConfigurationProvider,
-        sessionConfigurator,
-        extensionRegistrars,
-        sourcesScope,
-        mainModuleData,
-        moduleInfoProvider.firSessionProvider,
-        languageVersionSettings,
-    )
-}
-
-private fun configureLibrarySessionForJvmOrCommon(
-    module: TestModule,
-    moduleName: Name,
-    sessionProvider: FirProjectSessionProvider,
-    dependencyList: DependencyListForCliModule,
-    librariesScope: GlobalSearchScope,
-    project: Project,
-    compilerConfigurationProvider: CompilerConfigurationProvider,
-    languageVersionSettings: LanguageVersionSettings = LanguageVersionSettingsImpl.DEFAULT,
-): FirSession {
-    val packagePartProviderFactory = compilerConfigurationProvider.getPackagePartProviderFactory(module)
-
-    val projectEnvironment = VfsBasedProjectEnvironment(
-        project, VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.FILE_PROTOCOL),
-    ) { packagePartProviderFactory.invoke(it) }
-
-    val projectFileSearchScope = PsiBasedProjectFileSearchScope(librariesScope)
-
-    return FirSessionFactory.createLibrarySession(
-        moduleName,
-        sessionProvider,
-        dependencyList.moduleDataProvider,
-        projectFileSearchScope,
-        projectEnvironment,
-        projectEnvironment.getPackagePartProvider(projectFileSearchScope),
-        languageVersionSettings,
-    )
-}
-
-private fun configureMainSessionForJvmOrCommon(
-    module: TestModule,
-    project: Project,
-    compilerConfigurationProvider: CompilerConfigurationProvider,
-    sessionConfigurator: FirSessionFactory.FirSessionConfigurator.() -> Unit,
-    extensionRegistrars: List<FirExtensionRegistrar>,
-    sourcesScope: GlobalSearchScope,
-    mainModuleData: FirModuleData,
-    sessionProvider: FirProjectSessionProvider,
-    languageVersionSettings: LanguageVersionSettings = LanguageVersionSettingsImpl.DEFAULT,
-): FirSession {
-    val packagePartProviderFactory = compilerConfigurationProvider.getPackagePartProviderFactory(module)
-
-    val projectEnvironment = VfsBasedProjectEnvironment(
-        project, VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.FILE_PROTOCOL),
-    ) { packagePartProviderFactory.invoke(it) }
-
-    val projectFileSearchScope = PsiBasedProjectFileSearchScope(sourcesScope)
-
-    return FirSessionFactory.createJavaModuleBasedSession(
-        mainModuleData,
-        sessionProvider,
-        projectFileSearchScope,
-        projectEnvironment,
-        incrementalCompilationContext = null,
-        extensionRegistrars,
-        languageVersionSettings,
-        lookupTracker = null,
-        enumWhenTracker = null,
-        needRegisterJavaElementFinder = true,
-        sessionConfigurator,
-    )
-}
-
-private fun configureSessionsForJs(
-    module: TestModule,
-    moduleName: Name,
-    moduleInfoProvider: FirModuleInfoProvider,
-    analyzerServices: PlatformDependentAnalyzerServices,
-    configuration: CompilerConfiguration,
-    testServices: TestServices,
-    sessionConfigurator: FirSessionFactory.FirSessionConfigurator.() -> Unit,
-    extensionRegistrars: List<FirExtensionRegistrar>,
-    languageVersionSettings: LanguageVersionSettings = LanguageVersionSettingsImpl.DEFAULT,
-): FirSession {
-    val dependencyList = buildDependencyList(module, moduleName, moduleInfoProvider, analyzerServices) {
-        configureJsDependencies(module, testServices)
-    }
-
-    FirJsSessionFactory.createJsLibrarySession(
-        moduleName,
-        module,
-        testServices,
-        configuration,
-        moduleInfoProvider.firSessionProvider,
-        dependencyList.moduleDataProvider,
-        languageVersionSettings,
-    )
-
-    val mainModuleData = FirModuleDataImpl(
-        moduleName,
-        dependencyList.regularDependencies,
-        dependencyList.dependsOnDependencies,
-        dependencyList.friendsDependencies,
-        dependencyList.platform,
-        dependencyList.analyzerServices
-    )
-
-    return FirJsSessionFactory.createJsModuleBasedSession(
-        mainModuleData,
-        moduleInfoProvider.firSessionProvider,
-        extensionRegistrars,
-        languageVersionSettings,
-        null,
-        sessionConfigurator,
-    )
-}
-
 fun TargetPlatform.getAnalyzerServices(): PlatformDependentAnalyzerServices {
     return when {
         isJvm() -> JvmPlatformAnalyzerServices

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/FirJsSessionFactory.kt

@@ -10,72 +10,79 @@ import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.analysis.FirOverridesBackwardCompatibilityHelper
-import org.jetbrains.kotlin.fir.checkers.registerCommonCheckers
 import org.jetbrains.kotlin.fir.checkers.registerJsCheckers
-import org.jetbrains.kotlin.fir.deserialization.ModuleDataProvider
 import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
-import org.jetbrains.kotlin.fir.extensions.FirSwitchableExtensionDeclarationsSymbolProvider
-import org.jetbrains.kotlin.fir.java.FirCliSession
 import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
 import org.jetbrains.kotlin.fir.resolve.calls.ConeCallConflictResolverFactory
-import org.jetbrains.kotlin.fir.resolve.calls.FirSyntheticNamesProvider
+import org.jetbrains.kotlin.fir.resolve.providers.impl.FirBuiltinSymbolProvider
-import org.jetbrains.kotlin.fir.resolve.providers.FirDependenciesSymbolProvider
+import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCloneableSymbolProvider
-import org.jetbrains.kotlin.fir.resolve.providers.FirProvider
+import org.jetbrains.kotlin.fir.resolve.providers.impl.FirDependenciesSymbolProviderImpl
-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.FirKotlinScopeProvider
 import org.jetbrains.kotlin.fir.scopes.FirPlatformClassMapper
-import org.jetbrains.kotlin.fir.session.*
+import org.jetbrains.kotlin.fir.session.FirAbstractSessionFactory
+import org.jetbrains.kotlin.fir.session.FirSessionFactory
+import org.jetbrains.kotlin.fir.session.KlibBasedSymbolProvider
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.TestServices
 
-object FirJsSessionFactory {
+object FirJsSessionFactory : FirAbstractSessionFactory() {
-    @OptIn(PrivateSessionConstructor::class, SessionConfiguration::class)
+    fun createLibrarySession(
-    fun createJsLibrarySession(
         mainModuleName: Name,
+        sessionProvider: FirProjectSessionProvider,
+        dependencyListForCliModule: DependencyListForCliModule,
         module: TestModule,
         testServices: TestServices,
         configuration: CompilerConfiguration,
-        sessionProvider: FirProjectSessionProvider,
+        languageVersionSettings: LanguageVersionSettings,
-        moduleDataProvider: ModuleDataProvider,
-        languageVersionSettings: LanguageVersionSettings = LanguageVersionSettingsImpl.DEFAULT,
     ): FirSession {
-        return FirCliSession(sessionProvider, FirSession.Kind.Library).apply session@{
+        val moduleDataProvider = dependencyListForCliModule.moduleDataProvider
-            moduleDataProvider.allModuleData.forEach {
+        return createLibrarySession(
-                sessionProvider.registerSession(it, this)
+            mainModuleName,
-                it.bindSession(this)
+            sessionProvider,
+            moduleDataProvider,
+            languageVersionSettings,
+            null,
+            createKotlinScopeProvider = { FirKotlinScopeProvider { _, declaredMemberScope, _, _ -> declaredMemberScope } },
+            createProviders = { session, builtinsModuleData, kotlinScopeProvider ->
+                listOf(
+                    FirBuiltinSymbolProvider(session, builtinsModuleData, kotlinScopeProvider),
+                    FirCloneableSymbolProvider(session, builtinsModuleData, kotlinScopeProvider),
+                    FirDependenciesSymbolProviderImpl(session),
+                ) + resolveJsLibraries(module, testServices, configuration).map {
+                    KlibBasedSymbolProvider(session, moduleDataProvider, kotlinScopeProvider, it)
+                }
+            })
+    }
+
+    fun createModuleBasedSession(
+        moduleData: FirModuleData,
+        sessionProvider: FirProjectSessionProvider,
+        extensionRegistrars: List<FirExtensionRegistrar>,
+        languageVersionSettings: LanguageVersionSettings = LanguageVersionSettingsImpl.DEFAULT,
+        lookupTracker: LookupTracker?,
+        init: FirSessionConfigurator.() -> Unit
+    ): FirSession {
+        return createModuleBasedSession(
+            moduleData,
+            sessionProvider,
+            extensionRegistrars,
+            languageVersionSettings,
+            lookupTracker,
+            null,
+            init,
+            registerExtraComponents = { it.registerJsSpecificResolveComponents() },
+            registerExtraCheckers = { it.registerJsCheckers() },
+            createKotlinScopeProvider = { FirKotlinScopeProvider { _, declaredMemberScope, _, _ -> declaredMemberScope } },
+            createProviders = { _, _, symbolProvider, generatedSymbolsProvider, dependenciesSymbolProvider ->
+                listOfNotNull(
+                    symbolProvider,
+                    generatedSymbolsProvider,
+                    dependenciesSymbolProvider,
+                )
             }
-
+        )
-            registerCliCompilerOnlyComponents()
-            registerCommonComponents(languageVersionSettings)
-
-            val kotlinScopeProvider = FirKotlinScopeProvider(::wrapScopeWithJvmMapped)
-            register(FirKotlinScopeProvider::class, kotlinScopeProvider)
-
-            val builtinsModuleData = FirSessionFactory.createModuleDataForBuiltins(
-                mainModuleName,
-                moduleDataProvider.platform,
-                moduleDataProvider.analyzerServices
-            ).also { it.bindSession(this@session) }
-
-            val klibProviders = resolveJsLibraries(module, testServices, configuration).map {
-                KlibBasedSymbolProvider(this@session, moduleDataProvider, kotlinScopeProvider, it)
-            }
-
-            val otherProviders = listOf(
-                FirBuiltinSymbolProvider(this, builtinsModuleData, kotlinScopeProvider),
-                FirCloneableSymbolProvider(this, builtinsModuleData, kotlinScopeProvider),
-                FirDependenciesSymbolProviderImpl(this)
-            )
-
-            val symbolProvider = FirCompositeSymbolProvider(this, otherProviders + klibProviders)
-
-            register(FirSymbolProvider::class, symbolProvider)
-            register(FirProvider::class, FirLibrarySessionProvider(symbolProvider))
-        }
     }
 
     @OptIn(SessionConfiguration::class)
@@ -86,60 +93,4 @@ object FirJsSessionFactory {
         register(FirSyntheticNamesProvider::class, FirJsSyntheticNamesProvider)
         register(FirOverridesBackwardCompatibilityHelper::class, FirOverridesBackwardCompatibilityHelper.Default())
     }
-
-    @OptIn(PrivateSessionConstructor::class, SessionConfiguration::class)
-    fun createJsModuleBasedSession(
-        moduleData: FirModuleData,
-        sessionProvider: FirProjectSessionProvider,
-        extensionRegistrars: List<FirExtensionRegistrar>,
-        languageVersionSettings: LanguageVersionSettings = LanguageVersionSettingsImpl.DEFAULT,
-        lookupTracker: LookupTracker? = null,
-        init: FirSessionFactory.FirSessionConfigurator.() -> Unit = {}
-    ): FirSession {
-        return FirCliSession(sessionProvider, FirSession.Kind.Source).apply session@{
-            moduleData.bindSession(this@session)
-            sessionProvider.registerSession(moduleData, this@session)
-            registerModuleData(moduleData)
-            registerCliCompilerOnlyComponents()
-            registerCommonComponents(languageVersionSettings)
-            registerResolveComponents(lookupTracker)
-            registerJsSpecificResolveComponents()
-
-            val kotlinScopeProvider = FirKotlinScopeProvider { _, declaredMemberScope, _, _ -> declaredMemberScope }
-            register(FirKotlinScopeProvider::class, kotlinScopeProvider)
-
-            val firProvider = FirProviderImpl(this, kotlinScopeProvider)
-            register(FirProvider::class, firProvider)
-
-            FirSessionFactory.FirSessionConfigurator(this).apply {
-                registerCommonCheckers()
-                registerJsCheckers()
-                for (extensionRegistrar in extensionRegistrars) {
-                    registerExtensions(extensionRegistrar.configure())
-                }
-                init()
-            }.configure()
-
-            val dependenciesSymbolProvider = FirDependenciesSymbolProviderImpl(this)
-            val generatedSymbolsProvider = FirSwitchableExtensionDeclarationsSymbolProvider.create(this)
-            register(
-                FirSymbolProvider::class,
-                FirCompositeSymbolProvider(
-                    this,
-                    listOfNotNull(
-                        firProvider.symbolProvider,
-                        generatedSymbolsProvider,
-                        dependenciesSymbolProvider,
-                    )
-                )
-            )
-
-            generatedSymbolsProvider?.let { register(FirSwitchableExtensionDeclarationsSymbolProvider::class, it) }
-
-            register(
-                FirDependenciesSymbolProvider::class,
-                dependenciesSymbolProvider
-            )
-        }
-    }
 }