[LL FIR] create separate library session for each library

2022-07-18 20:20:02 +02:00
parent dbfeeae696
commit dc4527462f
18 changed files with 254 additions and 184 deletions
@@ -0,0 +1,68 @@
+/*
+ * 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.analysis.low.level.api.fir.project.structure
+
+import com.intellij.openapi.project.Project
+import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.LLFirBuiltinSymbolProvider
+import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.LLFirBuiltinsAndCloneableSessionProvider
+import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirBuiltinsAndCloneableSession
+import org.jetbrains.kotlin.fir.BuiltinTypes
+import org.jetbrains.kotlin.fir.PrivateSessionConstructor
+import org.jetbrains.kotlin.fir.SessionConfiguration
+import org.jetbrains.kotlin.fir.backend.jvm.FirJvmTypeMapper
+import org.jetbrains.kotlin.fir.resolve.providers.FirProvider
+import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
+import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCloneableSymbolProvider
+import org.jetbrains.kotlin.fir.resolve.scopes.wrapScopeWithJvmMapped
+import org.jetbrains.kotlin.fir.resolve.transformers.FirPhaseCheckingPhaseManager
+import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
+import org.jetbrains.kotlin.fir.session.registerCommonComponents
+import org.jetbrains.kotlin.fir.session.registerModuleData
+import org.jetbrains.kotlin.fir.symbols.FirPhaseManager
+import java.util.concurrent.ConcurrentHashMap
+import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
+import org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformAnalyzerServices
+
+@OptIn(PrivateSessionConstructor::class, SessionConfiguration::class)
+ class LLFirBuiltinsSessionFactory(
+    private val project: Project,
+) {
+    private val builtInTypes = BuiltinTypes() // TODO should be platform-specific
+    private val builtinsAndCloneableSession = ConcurrentHashMap<TargetPlatform, LLFirBuiltinsAndCloneableSession>()
+
+    fun getBuiltinsSession(platform: TargetPlatform): LLFirBuiltinsAndCloneableSession {
+        return builtinsAndCloneableSession.getOrPut(platform) { createBuiltinsAndCloneableSession(platform) }
+    }
+
+    private fun createBuiltinsAndCloneableSession(platform: TargetPlatform): LLFirBuiltinsAndCloneableSession {
+        return LLFirBuiltinsAndCloneableSession(project, builtInTypes).apply session@{
+            val moduleData = LLFirBuiltinsModuleData(platform, JvmPlatformAnalyzerServices/*TODO*/).apply {
+                bindSession(this@session)
+            }
+            registerIdeComponents(project)
+            register(FirPhaseManager::class, FirPhaseCheckingPhaseManager)
+            registerCommonComponents(LanguageVersionSettingsImpl.DEFAULT/*TODO*/)
+            registerModuleData(moduleData)
+
+            val kotlinScopeProvider = FirKotlinScopeProvider(::wrapScopeWithJvmMapped)
+            register(FirKotlinScopeProvider::class, kotlinScopeProvider)
+            val symbolProvider = createCompositeSymbolProvider(this) {
+                add(LLFirBuiltinSymbolProvider(this@session, moduleData, kotlinScopeProvider))
+                add(FirCloneableSymbolProvider(this@session, moduleData, kotlinScopeProvider))
+            }
+
+            register(FirSymbolProvider::class, symbolProvider)
+            register(FirProvider::class, LLFirBuiltinsAndCloneableSessionProvider(symbolProvider))
+            register(FirJvmTypeMapper::class, FirJvmTypeMapper(this))
+        }
+    }
+
+    companion object {
+        fun getInstance(project: Project): LLFirBuiltinsSessionFactory =
+            project.getService(LLFirBuiltinsSessionFactory::class.java)
+    }
+}
@@ -11,15 +11,8 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.services.createPackag
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirJavaFacadeForBinaries
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSession
 import org.jetbrains.kotlin.analysis.project.structure.KtBinaryModule
-import org.jetbrains.kotlin.analysis.project.structure.KtModule
-import org.jetbrains.kotlin.analysis.project.structure.allDirectDependenciesOfType
-import org.jetbrains.kotlin.analysis.utils.errors.checkIsInstance
 import org.jetbrains.kotlin.fir.BuiltinTypes
-import org.jetbrains.kotlin.fir.FirModuleData
-import org.jetbrains.kotlin.fir.deserialization.EmptyModuleDataProvider
-import org.jetbrains.kotlin.fir.deserialization.LibraryPathFilter
-import org.jetbrains.kotlin.fir.deserialization.ModuleDataProvider
-import org.jetbrains.kotlin.fir.deserialization.MultipleModuleDataProvider
+import org.jetbrains.kotlin.fir.deserialization.SingleModuleDataProvider
 import org.jetbrains.kotlin.fir.java.deserialization.JvmClassFileBasedSymbolProvider
 import org.jetbrains.kotlin.fir.java.deserialization.OptionalAnnotationClassesProvider
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
@@ -28,56 +21,55 @@ import org.jetbrains.kotlin.load.java.createJavaClassFinder
 import org.jetbrains.kotlin.load.kotlin.VirtualFileFinderFactory

 internal object LLFirLibraryProviderFactory {
-    fun createProvidersByModuleLibraryDependencies(
+    fun createLibraryProvidersForSingleBinaryModule(
        session: LLFirSession,
-        module: KtModule,
+        moduleData: LLFirModuleData,
+        module: KtBinaryModule,
        kotlinScopeProvider: FirKotlinScopeProvider,
        project: Project,
        builtinTypes: BuiltinTypes,
-        createSearchScopeForModules: (List<KtBinaryModule>) -> GlobalSearchScope
-    ): List<FirSymbolProvider> = buildList {
-        module
-            .allDirectDependenciesOfType<KtBinaryModule>()
-            .groupBy { it.platform }
-            .forEach { (_, binaryDependencies) ->
-                val moduleDataProvider = createModuleDataProviderWithLibraryDependencies(module, binaryDependencies, session)
-                val scope = createSearchScopeForModules(binaryDependencies)
-                val packagePartProvider = project.createPackagePartProviderForLibrary(scope)
-                add(
-                    JvmClassFileBasedSymbolProvider(
-                        session,
-                        moduleDataProvider,
-                        kotlinScopeProvider,
-                        packagePartProvider,
-                        VirtualFileFinderFactory.getInstance(project).create(scope),
-                        LLFirJavaFacadeForBinaries(session, builtinTypes, project.createJavaClassFinder(scope), moduleDataProvider)
-                    )
+    ): List<FirSymbolProvider> {
+        val moduleDataProvider = SingleModuleDataProvider(moduleData)
+        val scope = module.contentScope
+        val packagePartProvider = project.createPackagePartProviderForLibrary(scope)
+        return buildList {
+            add(
+                JvmClassFileBasedSymbolProvider(
+                    session,
+                    moduleDataProvider,
+                    kotlinScopeProvider,
+                    packagePartProvider,
+                    VirtualFileFinderFactory.getInstance(project).create(scope),
+                    LLFirJavaFacadeForBinaries(session, builtinTypes, project.createJavaClassFinder(scope), moduleDataProvider)
                )
-                add(OptionalAnnotationClassesProvider(session, moduleDataProvider, kotlinScopeProvider, packagePartProvider))
-            }
-    }
-
-    private fun createModuleDataProviderWithLibraryDependencies(
-        sourceModule: KtModule,
-        binaryDependencies: List<KtBinaryModule>,
-        session: LLFirSession
-    ): ModuleDataProvider {
-        val moduleDatas = binaryDependencies.map { LLFirKtModuleBasedModuleData(it) }
-
-        if (moduleDatas.isEmpty()) {
-            return EmptyModuleDataProvider(sourceModule.platform, sourceModule.analyzerServices)
+            )
+            add(OptionalAnnotationClassesProvider(session, moduleDataProvider, kotlinScopeProvider, packagePartProvider))
        }
-
-        moduleDatas.forEach { it.bindSession(session) }
-
-        val moduleDataWithFilters: Map<FirModuleData, LibraryPathFilter.LibraryList> =
-            moduleDatas.associateWith { moduleData ->
-                checkIsInstance<LLFirKtModuleBasedModuleData>(moduleData)
-                val ktBinaryModule = moduleData.ktModule as KtBinaryModule
-                val moduleBinaryRoots = ktBinaryModule.getBinaryRoots().mapTo(mutableSetOf()) { it.toAbsolutePath() }
-                LibraryPathFilter.LibraryList(moduleBinaryRoots)
-            }
-
-        return MultipleModuleDataProvider(moduleDataWithFilters)
    }
+
+    fun createLibraryProvidersForAllProjectLibraries(
+        session: LLFirSession,
+        moduleData: LLFirModuleData,
+        kotlinScopeProvider: FirKotlinScopeProvider,
+        project: Project,
+        builtinTypes: BuiltinTypes,
+        scope: GlobalSearchScope,
+    ): List<FirSymbolProvider> {
+        val moduleDataProvider = SingleModuleDataProvider(moduleData)
+        val packagePartProvider = project.createPackagePartProviderForLibrary(scope)
+        return buildList {
+            add(
+                JvmClassFileBasedSymbolProvider(
+                    session,
+                    moduleDataProvider,
+                    kotlinScopeProvider,
+                    packagePartProvider,
+                    VirtualFileFinderFactory.getInstance(project).create(scope),
+                    LLFirJavaFacadeForBinaries(session, builtinTypes, project.createJavaClassFinder(scope), moduleDataProvider)
+                )
+            )
+            add(OptionalAnnotationClassesProvider(session, moduleDataProvider, kotlinScopeProvider, packagePartProvider))
+        }
+    }
+
 }
@@ -6,23 +6,20 @@
 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.providers.LLFirBuiltinSymbolProvider
-import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.LLFirBuiltinsAndCloneableSessionProvider
-import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.LLFirLibrariesSessionProvider
-import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirBuiltinsAndCloneableSession
-import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirLibrariesSession
+import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.LLFirLibrarySessionProvider
+import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirLibraryLikeSession
+import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirLibrarySession
+import org.jetbrains.kotlin.analysis.project.structure.KtBinaryModule
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
-import org.jetbrains.kotlin.analysis.project.structure.KtSourceModule
-import org.jetbrains.kotlin.config.LanguageVersionSettings
-import org.jetbrains.kotlin.fir.BuiltinTypes
+import org.jetbrains.kotlin.analysis.project.structure.allDirectDependenciesOfType
+import org.jetbrains.kotlin.analysis.providers.createLibrariesModificationTracker
+import org.jetbrains.kotlin.analysis.utils.caches.softCachedValue
+import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.fir.PrivateSessionConstructor
 import org.jetbrains.kotlin.fir.SessionConfiguration
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmTypeMapper
 import org.jetbrains.kotlin.fir.resolve.providers.FirProvider
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
-import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCloneableSymbolProvider
-import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCompositeSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
 import org.jetbrains.kotlin.fir.resolve.scopes.wrapScopeWithJvmMapped
 import org.jetbrains.kotlin.fir.resolve.transformers.FirPhaseCheckingPhaseManager
@@ -34,78 +31,66 @@ import org.jetbrains.kotlin.fir.session.registerModuleData
 import org.jetbrains.kotlin.fir.symbols.FirPhaseManager
 import org.jetbrains.kotlin.resolve.jvm.modules.JavaModuleResolver
 import java.util.concurrent.ConcurrentHashMap
+import org.jetbrains.kotlin.analysis.utils.caches.getValue

@OptIn(PrivateSessionConstructor::class, SessionConfiguration::class)
 internal class LLFirLibrarySessionFactory(
    private val project: Project,
-    private val useSiteModule: KtModule,
-    private val useSiteLanguageVersionSettings: LanguageVersionSettings,
 ) {
-    val builtInTypes = BuiltinTypes()
-    val builtinsAndCloneableSession = createBuiltinsAndCloneableSession()
-
-    private val librarySessionByModule = ConcurrentHashMap<KtModule, LLFirLibrariesSession>()
-
-    fun getLibrarySessionForSourceModule(ktModule: KtSourceModule): LLFirLibrariesSession {
-        return librarySessionByModule.getOrPut(ktModule) { createModuleLibrariesSession(ktModule) }
+    private val librarySessionByModule by softCachedValue(project, project.createLibrariesModificationTracker()) {
+        ConcurrentHashMap<KtBinaryModule, LLFirLibrarySession>()
    }

+    fun getLibrarySessionsForModule(module: KtModule): List<LLFirLibraryLikeSession> = buildList {
+        LLFirBuiltinsSessionFactory.getInstance(project).getBuiltinsSession(module.platform).let(::add)
+        return module.allDirectDependenciesOfType<KtBinaryModule>().mapTo(this) { getLibrarySession(it) }
+    }
+
+    private fun getLibrarySession(ktBinaryModule: KtBinaryModule): LLFirLibrarySession {
+        return librarySessionByModule.getOrPut(ktBinaryModule) { createModuleLibrariesSession(ktBinaryModule) }
+    }
+
+
    private fun createModuleLibrariesSession(
-        sourceModule: KtSourceModule,
-    ): LLFirLibrariesSession {
-        return LLFirLibrariesSession(project, builtInTypes).apply session@{
-            registerModuleData(LLFirKtModuleBasedModuleData(sourceModule).apply { bindSession(this@session) })
+        ktLibraryModule: KtBinaryModule,
+    ): LLFirLibrarySession {
+        val platform = ktLibraryModule.platform
+        val builtinsSession = LLFirBuiltinsSessionFactory.getInstance(project).getBuiltinsSession(platform)
+        return LLFirLibrarySession(project, builtinsSession.builtinTypes).apply session@{
+            val moduleData = LLFirKtModuleBasedModuleData(ktLibraryModule).apply { bindSession(this@session) }
+            registerModuleData(moduleData)
            registerIdeComponents(project)
            register(FirPhaseManager::class, FirPhaseCheckingPhaseManager)
-            registerCommonComponents(sourceModule.languageVersionSettings)
+            registerCommonComponents(LanguageVersionSettingsImpl.DEFAULT/*TODO*/)
            registerCommonJavaComponents(JavaModuleResolver.getInstance(project))
            registerJavaSpecificResolveComponents()

            val kotlinScopeProvider = FirKotlinScopeProvider(::wrapScopeWithJvmMapped)
            register(FirKotlinScopeProvider::class, kotlinScopeProvider)

-            val providers = LLFirLibraryProviderFactory.createProvidersByModuleLibraryDependencies(
+            val providers = LLFirLibraryProviderFactory.createLibraryProvidersForSingleBinaryModule(
                this,
-                sourceModule,
+                moduleData,
+                ktLibraryModule,
                kotlinScopeProvider,
                project,
                builtinTypes
-            ) { binaryDependencies ->
-                GlobalSearchScope.union(binaryDependencies.map { it.contentScope })
-            }
+            )

            val symbolProvider = createCompositeSymbolProvider(this) {
                addAll(providers)
-                add(builtinsAndCloneableSession.symbolProvider)
+                add(builtinsSession.symbolProvider)
            }

-            register(FirProvider::class, LLFirLibrariesSessionProvider(symbolProvider))
+            register(FirProvider::class, LLFirLibrarySessionProvider(symbolProvider))
            register(FirSymbolProvider::class, symbolProvider)
            register(FirJvmTypeMapper::class, FirJvmTypeMapper(this))
        }
    }

-
-    private fun createBuiltinsAndCloneableSession(): LLFirBuiltinsAndCloneableSession {
-        return LLFirBuiltinsAndCloneableSession(project, builtInTypes).apply session@{
-            val moduleData = LLFirBuiltinsModuleData(useSiteModule).apply {
-                bindSession(this@session)
-            }
-            registerIdeComponents(project)
-            register(FirPhaseManager::class, FirPhaseCheckingPhaseManager)
-            registerCommonComponents(useSiteLanguageVersionSettings)
-            registerModuleData(moduleData)
-
-            val kotlinScopeProvider = FirKotlinScopeProvider(::wrapScopeWithJvmMapped)
-            register(FirKotlinScopeProvider::class, kotlinScopeProvider)
-            val symbolProvider = createCompositeSymbolProvider(this) {
-                add(LLFirBuiltinSymbolProvider(this@session, moduleData, kotlinScopeProvider))
-                add(FirCloneableSymbolProvider(this@session, moduleData, kotlinScopeProvider))
-            }
-
-            register(FirSymbolProvider::class, symbolProvider)
-            register(FirProvider::class, LLFirBuiltinsAndCloneableSessionProvider(symbolProvider))
-            register(FirJvmTypeMapper::class, FirJvmTypeMapper(this))
-        }
+    companion object {
+        fun getInstance(project: Project): LLFirLibrarySessionFactory =
+            project.getService(LLFirLibrarySessionFactory::class.java)
    }
+
 }
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name

-internal class LLFirLibrariesSessionProvider(
+internal class LLFirLibrarySessionProvider(
    override val symbolProvider: FirSymbolProvider
 ) : FirProvider() {
    override fun getFirClassifierByFqName(classId: ClassId): FirClassLikeDeclaration? =
@@ -28,6 +28,6 @@ internal class LLFirLibrariesSessionProvider(

    override fun getClassNamesInPackage(fqName: FqName): Set<Name> = shouldNotBeCalled()

-    private fun shouldNotBeCalled(): Nothing = error("Should not be called for LLFirLibrariesSessionProvider")
+    private fun shouldNotBeCalled(): Nothing = error("Should not be called for LLFirLibrarySessionProvider")
 }

@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.PrivateSessionConstructor
 * [org.jetbrains.kotlin.fir.FirSession] responsible for all libraries analysing module transitively depends on
 */
@OptIn(PrivateSessionConstructor::class)
-internal class LLFirLibrariesSession @PrivateSessionConstructor constructor(
+internal class LLFirLibrarySession @PrivateSessionConstructor constructor(
    project: Project,
    builtinTypes: BuiltinTypes,
 ) : LLFirLibraryLikeSession(project, builtinTypes)
@@ -12,7 +12,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirGlobalResolveCompone
 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.*
-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
 import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.*
@@ -55,6 +54,7 @@ internal object LLFirSessionFactory {
        configureSession: (LLFirSession.() -> Unit)? = null
    ): LLFirSourcesSession {
        sessionsCache[module]?.let { return it as LLFirSourcesSession }
+        val platform = module.platform
        val languageVersionSettings = object : LanguageVersionSettings by module.languageVersionSettings {
            override fun getFeatureSupport(feature: LanguageFeature): LanguageFeature.State =
                if (feature == LanguageFeature.EnableDfaWarningsInK2) LanguageFeature.State.ENABLED
@@ -72,7 +72,12 @@ internal object LLFirSessionFactory {

        val contentScope = module.contentScope
        val dependentModules = module.directRegularDependenciesOfType<KtSourceModule>()
-        val session = LLFirSourcesSession(module, project, components, librariesSessionFactory.builtInTypes)
+        val session = LLFirSourcesSession(
+            module,
+            project,
+            components,
+            LLFirBuiltinsSessionFactory.getInstance(project).getBuiltinsSession(platform).builtinTypes
+        )
        sessionsCache[module] = session
        components.session = session

@@ -105,7 +110,7 @@ internal object LLFirSessionFactory {
            }

            val dependencyProvider = LLFirDependentModuleProviders(this) {
-                add(librariesSessionFactory.getLibrarySessionForSourceModule(module).symbolProvider)
+                librariesSessionFactory.getLibrarySessionsForModule(module).mapTo(this) { it.symbolProvider }
                dependentModules
                    .mapTo(this) { dependentSourceModule ->
                        val dependentSourceSession = createSourcesSession(
@@ -148,10 +153,9 @@ internal object LLFirSessionFactory {
    fun createLibraryOrLibrarySourceResolvableSession(
        project: Project,
        module: KtModule,
-        builtinsAndCloneableSession: LLFirBuiltinsAndCloneableSession,
        globalComponents: LLFirGlobalResolveComponents,
        sessionInvalidator: LLFirSessionInvalidator,
-        builtinTypes: BuiltinTypes,
+        builtinSession: LLFirBuiltinsAndCloneableSession,
        sessionsCache: MutableMap<KtModule, LLFirResolvableModuleSession>,
        languageVersionSettings: LanguageVersionSettings = LanguageVersionSettingsImpl.DEFAULT,
        configureSession: (LLFirSession.() -> Unit)? = null
@@ -170,7 +174,7 @@ internal object LLFirSessionFactory {
        val components = LLFirModuleResolveComponents(module, globalComponents, scopeProvider)

        val contentScope = module.contentScope
-        val session = LLFirLibraryOrLibrarySourceResolvableModuleSession(module, project, components, builtinTypes)
+        val session = LLFirLibraryOrLibrarySourceResolvableModuleSession(module, project, components, builtinSession.builtinTypes)
        sessionsCache[module] = session
        components.session = session

@@ -205,11 +209,11 @@ internal object LLFirSessionFactory {
                // <all libraries scope> - <current library scope>
                val librariesSearchScope =
                    ProjectScope.getLibrariesScope(project).intersectWith(GlobalSearchScope.notScope(libraryModule.contentScope))
-                add(builtinsAndCloneableSession.symbolProvider)
+                add(builtinSession.symbolProvider)
                addAll(
-                    LLFirLibraryProviderFactory.createProvidersByModuleLibraryDependencies(
-                        session, module, scopeProvider, project, builtinTypes
-                    ) { librariesSearchScope }
+                    LLFirLibraryProviderFactory.createLibraryProvidersForAllProjectLibraries(
+                        session, moduleData, scopeProvider, project, builtinTypes, librariesSearchScope
+                    )
                )
            }

@@ -16,20 +16,15 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.firKtMo
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.addValueFor
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.executeWithoutPCE
 import org.jetbrains.kotlin.analysis.project.structure.*
-import org.jetbrains.kotlin.analysis.providers.createLibrariesModificationTracker
 import org.jetbrains.kotlin.analysis.providers.createModuleWithoutDependenciesOutOfBlockModificationTracker
-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.LanguageVersionSettingsImpl
 import java.util.concurrent.ConcurrentHashMap
+import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.LLFirBuiltinsSessionFactory

 class LLFirSessionProviderStorage(val project: Project) {
    private val sessionsCache = ConcurrentHashMap<KtModule, FromModuleViewSessionCache>()

-    private val librariesFactoryByUseSiteModule by softCachedValue(project, project.createLibrariesModificationTracker()) {
-        ConcurrentHashMap<KtModule, LLFirLibrarySessionFactory>()
-    }
+    private val librariesSessionFactory = LLFirLibrarySessionFactory.getInstance(project)
+    private val builtInsSessionFactopry = LLFirBuiltinsSessionFactory.getInstance(project)

    fun getSessionProvider(
        useSiteKtModule: KtModule,
@@ -37,15 +32,6 @@ class LLFirSessionProviderStorage(val project: Project) {
    ): LLFirSessionProvider {
        val globalComponents = LLFirGlobalResolveComponents(useSiteKtModule, project)

-        val librariesSessionFactory = librariesFactoryByUseSiteModule.getOrPut(useSiteKtModule) {
-            val languageVersionSettings = when (useSiteKtModule) {
-                is KtSourceModule -> useSiteKtModule.languageVersionSettings
-                is KtLibraryModule, is KtLibrarySourceModule -> LanguageVersionSettingsImpl.DEFAULT
-                else -> unexpectedElementError("module", useSiteKtModule)
-            }
-            LLFirLibrarySessionFactory(project, useSiteKtModule, languageVersionSettings)
-        }
-
        val cache = sessionsCache.getOrPut(useSiteKtModule) { FromModuleViewSessionCache() }
        val (sessions, session) = cache.withMappings(project) { mappings ->
            val sessions = mutableMapOf<KtModule, LLFirResolvableModuleSession>().apply { putAll(mappings) }
@@ -58,7 +44,7 @@ class LLFirSessionProviderStorage(val project: Project) {
                            globalComponents,
                            cache.sessionInvalidator,
                            sessions,
-                            librariesSessionFactory = librariesSessionFactory,
+                            librariesSessionFactory,
                            configureSession = configureSession,
                        )
                    }
@@ -66,10 +52,9 @@ class LLFirSessionProviderStorage(val project: Project) {
                        LLFirSessionFactory.createLibraryOrLibrarySourceResolvableSession(
                            project,
                            useSiteKtModule,
-                            librariesSessionFactory.builtinsAndCloneableSession,
                            globalComponents,
                            cache.sessionInvalidator,
-                            librariesSessionFactory.builtInTypes,
+                            builtInsSessionFactopry.getBuiltinsSession(useSiteKtModule.platform),
                            sessions,
                            configureSession = configureSession,
                        )
@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.analysis.api.fir.references.ReadWriteAccessCheckerFi
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirResolveSessionService
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.services.FirSealedClassInheritorsProcessorFactory
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.services.PackagePartProviderFactory
+import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.*
 import org.jetbrains.kotlin.analysis.low.level.api.fir.services.KtCompilerPluginsProviderForTests
 import org.jetbrains.kotlin.analysis.low.level.api.fir.services.LLFirSealedClassInheritorsProcessorFactoryForTests
 import org.jetbrains.kotlin.analysis.low.level.api.fir.services.PackagePartProviderTestImpl
@@ -46,6 +47,8 @@ object AnalysisApiFirTestServiceRegistrar : AnalysisApiTestServiceRegistrar() {
            registerService(KtAnalysisSessionProvider::class.java, KtFirAnalysisSessionProvider(this))
            registerService(FirSealedClassInheritorsProcessorFactory::class.java, LLFirSealedClassInheritorsProcessorFactoryForTests())
            registerService(LLFirResolveSessionService::class.java)
+            registerService(LLFirLibrarySessionFactory::class.java)
+            registerService(LLFirBuiltinsSessionFactory::class.java)
            registerService(PackagePartProviderFactory::class.java, PackagePartProviderTestImpl(testServices))

            registerService(SymbolLightClassFacadeCache::class.java)
@@ -58,18 +58,18 @@ object FirLowLevelCompilerBasedTestConfigurator : AnalysisApiTestConfigurator()
        return KtModuleProjectStructure(
            mainModules = mainModules,
            binaryModules = mainModules.asSequence().flatMap { it.ktModule.allDirectDependenciesOfType<KtLibraryModule>() }.asIterable(),
-            stdlibFor = { module ->
-                createFakeStdlibModule(module, project)
+            stdlibFor = { platform ->
+                createFakeStdlibModule(platform, project)
            }
        )
    }

    private fun createFakeStdlibModule(
-        module: KtModule,
+        platform: TargetPlatform,
        project: Project
    ): KtLibraryModule = KtLibraryModuleImpl(
        libraryName = "fake-std-lib",
-        platform = module.platform,
+        platform = platform,
        contentScope = ProjectScope.getLibrariesScope(project),
        project = project,
        binaryRoots = emptyList(),