[fir low level, refactoring] refactor LLFirSessionFactory

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/project/structure/sessionFactoryHelpers.kt

@@ -6,18 +6,34 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure
 
 import com.intellij.openapi.project.Project
+import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analysis.low.level.api.fir.IdeSessionComponents
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.services.createSealedInheritorsProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.fir.caches.FirThreadSafeCachesFactory
+import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.LLFirIdePredicateBasedProvider
+import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.LLFirIdeRegisteredPluginAnnotations
+import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirLibraryOrLibrarySourceResolvableModuleSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSession
+import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSourcesSession
+import org.jetbrains.kotlin.analysis.project.structure.KtSourceModule
+import org.jetbrains.kotlin.analysis.project.structure.moduleScopeProvider
+import org.jetbrains.kotlin.analysis.providers.createAnnotationResolver
+import org.jetbrains.kotlin.analysis.providers.createDeclarationProvider
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.SessionConfiguration
 import org.jetbrains.kotlin.fir.caches.FirCachesFactory
 import org.jetbrains.kotlin.fir.declarations.SealedClassInheritorsProvider
+import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar
+import org.jetbrains.kotlin.fir.extensions.FirPredicateBasedProvider
+import org.jetbrains.kotlin.fir.extensions.FirRegisteredPluginAnnotations
+import org.jetbrains.kotlin.fir.java.FirJavaFacadeForSource
+import org.jetbrains.kotlin.fir.java.JavaSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCompositeSymbolProvider
+import org.jetbrains.kotlin.fir.session.FirSessionFactory
+import org.jetbrains.kotlin.load.java.createJavaClassFinder
 
-@OptIn(SessionConfiguration::class)
+@SessionConfiguration
 internal fun LLFirSession.registerIdeComponents(project: Project) {
     register(IdeSessionComponents::class, IdeSessionComponents.create(this))
     register(FirCachesFactory::class, FirThreadSafeCachesFactory)
@@ -26,6 +42,45 @@ internal fun LLFirSession.registerIdeComponents(project: Project) {
 
 internal inline fun createCompositeSymbolProvider(
     session: FirSession,
-    builderAction: MutableList<FirSymbolProvider>.() -> Unit
+    createSubProviders: MutableList<FirSymbolProvider>.() -> Unit
 ): FirCompositeSymbolProvider =
-    FirCompositeSymbolProvider(session, buildList(builderAction))
+    FirCompositeSymbolProvider(session, buildList(createSubProviders))
+
+@SessionConfiguration
+internal fun FirSession.registerCompilerPluginExtensions(project: Project) {
+    FirSessionFactory.FirSessionConfigurator(this).apply {
+        for (extensionRegistrar in FirExtensionRegistrar.getInstances(project)) {
+            registerExtensions(extensionRegistrar.configure())
+        }
+    }.configure()
+}
+
+@SessionConfiguration
+internal fun LLFirSourcesSession.registerCompilerPluginServices(
+    contentScope: GlobalSearchScope,
+    project: Project,
+    module: KtSourceModule
+) {
+    val projectWithDependenciesScope = contentScope.uniteWith(project.moduleScopeProvider.getModuleLibrariesScope(module))
+    val annotationsResolver = project.createAnnotationResolver(projectWithDependenciesScope)
+
+    // We need FirRegisteredPluginAnnotations and FirPredicateBasedProvider during extensions' registration process
+    register(FirRegisteredPluginAnnotations::class, LLFirIdeRegisteredPluginAnnotations(this, annotationsResolver))
+    register(
+        FirPredicateBasedProvider::class,
+        LLFirIdePredicateBasedProvider(this, annotationsResolver, project.createDeclarationProvider(projectWithDependenciesScope))
+    )
+
+}
+
+internal fun createJavaSymbolProvider(
+    firSession: LLFirSession,
+    moduleData: LLFirKtModuleBasedModuleData,
+    project: Project,
+    contentScope: GlobalSearchScope
+): JavaSymbolProvider {
+    return JavaSymbolProvider(
+        firSession,
+        FirJavaFacadeForSource(firSession, moduleData, project.createJavaClassFinder(contentScope))
+    )
+}

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/providers/LLFirModuleWithDependenciesSymbolProvider.kt

@@ -19,8 +19,8 @@ import org.jetbrains.kotlin.name.Name
 
 internal class LLFirModuleWithDependenciesSymbolProvider(
     session: FirSession,
+    val dependencyProvider: LLFirDependentModuleProviders,
     private val providers: List<FirSymbolProvider>,
-    val dependencyProvider: DependentModuleProviders
 ) : FirSymbolProvider(session) {
 
     override fun getClassLikeSymbolByClassId(classId: ClassId): FirClassLikeSymbol<*>? =
@@ -77,7 +77,14 @@ internal class LLFirModuleWithDependenciesSymbolProvider(
         providers.firstNotNullOfOrNull { it.getPackage(fqName) }
 }
 
-internal class DependentModuleProviders(session: FirSession, private val providers: List<FirSymbolProvider>) : FirDependenciesSymbolProvider(session) {
+internal class LLFirDependentModuleProviders(
+    session: FirSession,
+    private val providers: List<FirSymbolProvider>
+) : FirDependenciesSymbolProvider(session) {
+
+    constructor(session: FirSession, createSubProviders: MutableList<FirSymbolProvider>.() -> Unit)
+            : this(session, buildList { createSubProviders() })
+
     override fun getClassLikeSymbolByClassId(classId: ClassId): FirClassLikeSymbol<*>? =
         providers.firstNotNullOfOrNull { provider ->
             when (provider) {

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/sessions/LLFirSessionFactory.kt

@@ -11,7 +11,7 @@ import com.intellij.psi.search.ProjectScope
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirGlobalResolveComponents
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirModuleResolveComponents
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseManager
-import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.LLFirKtModuleBasedModuleData
+import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.*
 import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.LLFirLibraryProviderFactory
 import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.LLFirLibrarySessionFactory
 import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.registerIdeComponents
@@ -26,10 +26,7 @@ import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmTypeMapper
-import org.jetbrains.kotlin.fir.checkers.registerExtendedCommonCheckers
 import org.jetbrains.kotlin.fir.extensions.*
-import org.jetbrains.kotlin.fir.java.FirJavaFacadeForSource
-import org.jetbrains.kotlin.fir.java.JavaSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.FirDependenciesSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.FirProvider
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
@@ -38,12 +35,10 @@ import org.jetbrains.kotlin.fir.resolve.scopes.wrapScopeWithJvmMapped
 import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
 import org.jetbrains.kotlin.fir.session.*
 import org.jetbrains.kotlin.fir.symbols.FirPhaseManager
-import org.jetbrains.kotlin.load.java.createJavaClassFinder
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.resolve.jvm.modules.JavaModuleResolver
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformAnalyzerServices
-import java.nio.file.Path
 
 @OptIn(PrivateSessionConstructor::class, SessionConfiguration::class)
 internal object LLFirSessionFactory {
@@ -53,7 +48,6 @@ internal object LLFirSessionFactory {
         globalResolveComponents: LLFirGlobalResolveComponents,
         sessionInvalidator: LLFirSessionInvalidator,
         sessionsCache: MutableMap<KtModule, LLFirResolvableModuleSession>,
-        isRootModule: Boolean,
         librariesSessionFactory: LLFirLibrarySessionFactory,
         configureSession: (LLFirSession.() -> Unit)? = null
     ): LLFirSourcesSession {
@@ -100,73 +94,40 @@ internal object LLFirSessionFactory {
             register(FirProvider::class, provider)
             register(FirPhaseManager::class, LLFirPhaseManager(sessionInvalidator))
 
-            @OptIn(ExperimentalStdlibApi::class)
+            registerCompilerPluginServices(contentScope, project, module)
-            val dependentProviders = buildList {
+            registerCompilerPluginExtensions(project)
-                add(
-                    librariesSessionFactory.getLibrarySessionForSourceModule(module).symbolProvider
-                )
-                dependentModules
-                    .mapTo(this) {
-                        createSourcesSession(
-                            project,
-                            it,
-                            globalResolveComponents,
-                            sessionInvalidator,
-                            sessionsCache,
-                            isRootModule = false,
-                            librariesSessionFactory = librariesSessionFactory,
-                            configureSession = configureSession,
-                        ).symbolProvider
-                    }
-            }
 
-            val projectWithDependenciesScope = contentScope.uniteWith(project.moduleScopeProvider.getModuleLibrariesScope(module))
+            val switchableExtensionDeclarationsSymbolProvider = FirSwitchableExtensionDeclarationsSymbolProvider.create(session)?.also {
-            val annotationsResolver = project.createAnnotationResolver(projectWithDependenciesScope)
-
-            // We need FirRegisteredPluginAnnotations and FirPredicateBasedProvider during extensions' registration process
-            register(FirRegisteredPluginAnnotations::class, LLFirIdeRegisteredPluginAnnotations(this@session, annotationsResolver))
-            register(
-                FirPredicateBasedProvider::class,
-                LLFirIdePredicateBasedProvider(
-                    this@session,
-                    annotationsResolver,
-                    project.createDeclarationProvider(projectWithDependenciesScope)
-                )
-            )
-
-            FirSessionFactory.FirSessionConfigurator(this).apply {
-                if (isRootModule) {
-                    registerExtendedCommonCheckers()
-                }
-                for (extensionRegistrar in FirExtensionRegistrar.getInstances(project)) {
-                    registerExtensions(extensionRegistrar.configure())
-                }
-            }.configure()
-
-            val switchableExtensionDeclarationsSymbolProvider =
-                FirSwitchableExtensionDeclarationsSymbolProvider.create(session)
-
-            switchableExtensionDeclarationsSymbolProvider?.let {
                 register(FirSwitchableExtensionDeclarationsSymbolProvider::class, it)
             }
 
-            val dependencyProvider = DependentModuleProviders(this, dependentProviders)
+            val dependencyProvider = LLFirDependentModuleProviders(this) {
+                add(librariesSessionFactory.getLibrarySessionForSourceModule(module).symbolProvider)
+                dependentModules
+                    .mapTo(this) { dependentSourceModule ->
+                        val dependentSourceSession = createSourcesSession(
+                            project,
+                            dependentSourceModule,
+                            globalResolveComponents,
+                            sessionInvalidator,
+                            sessionsCache,
+                            librariesSessionFactory = librariesSessionFactory,
+                            configureSession = configureSession,
+                        )
+                        dependentSourceSession.symbolProvider
+                    }
+            }
 
             register(
                 FirSymbolProvider::class,
                 LLFirModuleWithDependenciesSymbolProvider(
                     this,
+                    dependencyProvider,
                     providers = listOfNotNull(
                         provider.symbolProvider,
                         switchableExtensionDeclarationsSymbolProvider,
-                        JavaSymbolProvider(
+                        createJavaSymbolProvider(this, moduleData, project, contentScope)
-                            this,
-                            FirJavaFacadeForSource(
-                                this, moduleData, project.createJavaClassFinder(contentScope)
-                            )
-                        ),
                     ),
-                    dependencyProvider
                 )
             )
 
@@ -228,48 +189,35 @@ internal object LLFirSessionFactory {
             register(FirProvider::class, provider)
 
             register(FirPhaseManager::class, LLFirPhaseManager(sessionInvalidator))
-            val dependentProviders = buildList {
-                val librariesSearchScope = ProjectScope.getLibrariesScope(project)
-                    .intersectWith(GlobalSearchScope.notScope(libraryModule.contentScope)) // <all libraries scope> - <current library scope>
-                add(builtinsAndCloneableSession.symbolProvider)
-                addAll(
-                    LLFirLibraryProviderFactory.createProvidersByModuleLibraryDependencies(
-                        session,
-                        module,
-                        scopeProvider,
-                        project,
-                        builtinTypes
-                    ) { librariesSearchScope }
-                )
-            }
 
             // We need FirRegisteredPluginAnnotations during extensions' registration process
             val annotationsResolver = project.createAnnotationResolver(contentScope)
             register(FirRegisteredPluginAnnotations::class, LLFirIdeRegisteredPluginAnnotations(this@session, annotationsResolver))
             register(FirPredicateBasedProvider::class, FirEmptyPredicateBasedProvider())
 
-            FirSessionFactory.FirSessionConfigurator(this).apply {
+            registerCompilerPluginExtensions(project)
-                for (extensionRegistrar in FirExtensionRegistrar.getInstances(project)) {
-                    registerExtensions(extensionRegistrar.configure())
-                }
-            }.configure()
 
-            val dependencyProvider = DependentModuleProviders(this, dependentProviders)
+            val dependencyProvider = LLFirDependentModuleProviders(this) {
+                // <all libraries scope> - <current library scope>
+                val librariesSearchScope =
+                    ProjectScope.getLibrariesScope(project).intersectWith(GlobalSearchScope.notScope(libraryModule.contentScope))
+                add(builtinsAndCloneableSession.symbolProvider)
+                addAll(
+                    LLFirLibraryProviderFactory.createProvidersByModuleLibraryDependencies(
+                        session, module, scopeProvider, project, builtinTypes
+                    ) { librariesSearchScope }
+                )
+            }
 
             register(
                 FirSymbolProvider::class,
                 LLFirModuleWithDependenciesSymbolProvider(
                     this,
+                    dependencyProvider,
                     providers = listOf(
                         provider.symbolProvider,
-                        JavaSymbolProvider(
+                        createJavaSymbolProvider(this, moduleData, project, contentScope),
-                            this,
-                            FirJavaFacadeForSource(
-                                this, moduleData, project.createJavaClassFinder(contentScope)
-                            )
-                        ),
                     ),
-                    dependencyProvider
                 )
             )
 
@@ -282,13 +230,6 @@ internal object LLFirSessionFactory {
     }
 }
 
-private fun List<KtModule>.extractLibraryPaths(): List<Path> =
-    asSequence()
-        .filterIsInstance<KtBinaryModule>()
-        .flatMap { it.getBinaryRoots() }
-        .map { it.toAbsolutePath() }
-        .toList()
-
 @Deprecated(
     "This is a dirty hack used only for one usage (building fir for psi from stubs) and it should be removed after fix of that usage",
     level = DeprecationLevel.ERROR

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/sessions/LLFirSessionProviderStorage.kt

@@ -21,9 +21,7 @@ import org.jetbrains.kotlin.analysis.providers.createModuleWithoutDependenciesOu
 import org.jetbrains.kotlin.analysis.utils.caches.getValue
 import org.jetbrains.kotlin.analysis.utils.caches.softCachedValue
 import org.jetbrains.kotlin.analysis.utils.errors.unexpectedElementError
-import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
-import org.jetbrains.kotlin.fir.BuiltinTypes
 import java.util.concurrent.ConcurrentHashMap
 
 class LLFirSessionProviderStorage(val project: Project) {
@@ -60,7 +58,6 @@ class LLFirSessionProviderStorage(val project: Project) {
                             globalComponents,
                             cache.sessionInvalidator,
                             sessions,
-                            isRootModule = true,
                             librariesSessionFactory = librariesSessionFactory,
                             configureSession = configureSession,
                         )