[AA] stub-based library symbol providers for non-JVM platforms

Use existing stub-based JVM library symbol provider for .knm and
.kotlin_metadata files. The only real difference is the scope filtering
by file types

KT-58769

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/configurators/AnalysisApiBaseTestServiceRegistrar.kt

@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.analysis.api.standalone.base.project.structure.Stand
 import org.jetbrains.kotlin.analysis.decompiled.light.classes.ClsJavaStubByVirtualFileCache
 import org.jetbrains.kotlin.analysis.decompiled.light.classes.DecompiledLightClassesFactory
 import org.jetbrains.kotlin.analysis.decompiler.psi.BuiltInDefinitionFile
+import org.jetbrains.kotlin.analysis.decompiler.psi.KotlinBuiltInFileType
 import org.jetbrains.kotlin.analysis.decompiler.psi.file.KtClsFile
 import org.jetbrains.kotlin.analysis.project.structure.KtModuleScopeProvider
 import org.jetbrains.kotlin.analysis.project.structure.KtModuleScopeProviderImpl
@@ -94,5 +95,7 @@ object AnalysisApiBaseTestServiceRegistrar: AnalysisApiTestServiceRegistrar()  {
     }
 
     override fun registerApplicationServices(application: MockApplication, testServices: TestServices) {
+        testServices.environmentManager.getApplicationEnvironment().registerFileType(KotlinBuiltInFileType, "kotlin_builtins")
+        testServices.environmentManager.getApplicationEnvironment().registerFileType(KotlinBuiltInFileType, "kotlin_metadata")
     }
 }

analysis/analysis-api-providers/src/org/jetbrains/kotlin/analysis/providers/impl/KotlinStaticDeclarationProvider.kt

@@ -23,6 +23,7 @@ import com.intellij.util.indexing.FileContentImpl
 import com.intellij.util.io.URLUtil
 import java.util.concurrent.ConcurrentHashMap
 import org.jetbrains.kotlin.analysis.decompiler.psi.KotlinBuiltInDecompiler
+import org.jetbrains.kotlin.analysis.decompiler.psi.KotlinBuiltInFileType
 import org.jetbrains.kotlin.analysis.decompiler.stub.file.ClsKotlinBinaryClassCache
 import org.jetbrains.kotlin.analysis.decompiler.stub.file.KotlinClsStubBuilder
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
@@ -315,10 +316,20 @@ public class KotlinStaticDeclarationProviderFactory(
                     override fun visitFile(file: VirtualFile): Boolean {
                         if (!file.isDirectory) {
                             val fileContent = FileContentImpl.createByFile(file)
-                            if (binaryClassCache.isKotlinJvmCompiledFile(file, fileContent.content) &&
+                            when {
-                                file.fileType == JavaClassFileType.INSTANCE
+                                binaryClassCache.isKotlinJvmCompiledFile(file, fileContent.content) &&
-                            ) {
+                                        file.fileType == JavaClassFileType.INSTANCE -> {
-                                (KotlinClsStubBuilder().buildFileStub(fileContent) as? KotlinFileStubImpl)?.let { stubs.put(file, it) }
+                                    (KotlinClsStubBuilder().buildFileStub(fileContent) as? KotlinFileStubImpl)?.let { stubs.put(file, it) }
+                                }
+                                file.fileType == KotlinBuiltInFileType
+                                        && file.extension != BuiltInSerializerProtocol.BUILTINS_FILE_EXTENSION -> {
+                                    (builtInDecompiler.stubBuilder.buildFileStub(fileContent) as? KotlinFileStubImpl)?.let {
+                                        stubs.put(
+                                            file,
+                                            it
+                                        )
+                                    }
+                                }
                             }
                         }
                         return true

analysis/analysis-api-standalone/analysis-api-fir-standalone-base/src/org/jetbrains/kotlin/analysis/api/standalone/base/project/structure/FirStandaloneServiceRegistrar.kt

@@ -55,7 +55,7 @@ object FirStandaloneServiceRegistrar : AnalysisApiStandaloneServiceRegistrar {
             registerService(LLFirBuiltinsSessionFactory::class.java)
             registerService(JvmFirDeserializedSymbolProviderFactory::class.java, JvmStubBasedDeserializedSymbolProviderFactory::class.java)
             registerService(KotlinReferenceProviderContributor::class.java, KotlinFirReferenceContributor::class.java)
-            registerService(ReadWriteAccessChecker::class.java, ReadWriteAccessCheckerFirImpl::class.java   )
+            registerService(ReadWriteAccessChecker::class.java, ReadWriteAccessCheckerFirImpl::class.java)
         }
     }
 

analysis/low-level-api-fir/build.gradle.kts

@@ -21,6 +21,7 @@ dependencies {
     api(project(":analysis:analysis-api-impl-barebone"))
     api(project(":js:js.config"))
     api(project(":compiler:cli-common"))
+    implementation(project(":analysis:decompiled:decompiler-to-psi"))
     testImplementation(project(":analysis:analysis-api-fir"))
     implementation(project(":compiler:frontend.common"))
     implementation(project(":compiler:fir:entrypoint"))

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

@@ -15,7 +15,7 @@ import com.intellij.psi.util.CachedValuesManager
 import org.jetbrains.annotations.TestOnly
 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.analysis.low.level.api.fir.stubBased.deserialization.JvmStubBasedFirDeserializedSymbolProvider
+import org.jetbrains.kotlin.analysis.low.level.api.fir.stubBased.deserialization.StubBasedFirDeserializedSymbolProvider
 import org.jetbrains.kotlin.analysis.project.structure.KtBuiltinsModule
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.analyzer.common.CommonPlatformAnalyzerServices
@@ -100,7 +100,7 @@ class LLFirBuiltinsSessionFactory(private val project: Project) {
             val symbolProvider = createCompositeSymbolProvider(this) {
                 val moduleDataProvider = SingleModuleDataProvider(moduleData)
                 add(
-                    object : JvmStubBasedFirDeserializedSymbolProvider(
+                    object : StubBasedFirDeserializedSymbolProvider(
                         session,
                         moduleDataProvider,
                         kotlinScopeProvider,

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

@@ -1,82 +0,0 @@
-/*
- * 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 com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.LLFirDependenciesSymbolProvider
-import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.LLFirModuleWithDependenciesSymbolProvider
-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.providers.createPackagePartProvider
-import org.jetbrains.kotlin.fir.BuiltinTypes
-import org.jetbrains.kotlin.fir.deserialization.SingleModuleDataProvider
-import org.jetbrains.kotlin.fir.java.deserialization.OptionalAnnotationClassesProvider
-import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
-import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
-import org.jetbrains.kotlin.load.java.createJavaClassFinder
-import org.jetbrains.kotlin.utils.addIfNotNull
-
-internal object LLFirLibraryProviderFactory {
-    fun createLibraryProvidersForScope(
-        session: LLFirSession,
-        moduleData: LLFirModuleData,
-        kotlinScopeProvider: FirKotlinScopeProvider,
-        project: Project,
-        builtinTypes: BuiltinTypes,
-        scope: GlobalSearchScope,
-        builtinSymbolProvider: FirSymbolProvider,
-    ): LLFirModuleWithDependenciesSymbolProvider {
-        return LLFirModuleWithDependenciesSymbolProvider(
-            session,
-            providers = createProjectLibraryProvidersForScope(
-                session,
-                moduleData,
-                kotlinScopeProvider,
-                project,
-                builtinTypes,
-                scope
-            ),
-            LLFirDependenciesSymbolProvider(session, listOf(builtinSymbolProvider)),
-        )
-    }
-
-    fun createProjectLibraryProvidersForScope(
-        session: LLFirSession,
-        moduleData: LLFirModuleData,
-        kotlinScopeProvider: FirKotlinScopeProvider,
-        project: Project,
-        builtinTypes: BuiltinTypes,
-        scope: GlobalSearchScope,
-    ): List<FirSymbolProvider> {
-        val moduleDataProvider = SingleModuleDataProvider(moduleData)
-        val packagePartProvider = project.createPackagePartProvider(scope)
-        return buildList {
-            val firJavaFacade = LLFirJavaFacadeForBinaries(session, builtinTypes, project.createJavaClassFinder(scope), moduleDataProvider)
-            val service = project.getService(JvmFirDeserializedSymbolProviderFactory::class.java)
-            addAll(
-                service.createJvmFirDeserializedSymbolProviders(
-                    project,
-                    session,
-                    moduleData,
-                    kotlinScopeProvider,
-                    moduleDataProvider,
-                    firJavaFacade,
-                    packagePartProvider,
-                    scope
-                )
-            )
-            addIfNotNull(
-                OptionalAnnotationClassesProvider.createIfNeeded(
-                    session,
-                    moduleDataProvider,
-                    kotlinScopeProvider,
-                    packagePartProvider
-                )
-            )
-        }
-    }
-}

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

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.low.level.api.fir.providers
 
-import org.jetbrains.kotlin.analysis.low.level.api.fir.stubBased.deserialization.JvmStubBasedFirDeserializedSymbolProvider
+import org.jetbrains.kotlin.analysis.low.level.api.fir.stubBased.deserialization.StubBasedFirDeserializedSymbolProvider
 import org.jetbrains.kotlin.analysis.utils.collections.buildSmartList
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.resolve.providers.FirNullSymbolNamesProvider
@@ -45,7 +45,7 @@ internal class LLFirModuleWithDependenciesSymbolProvider(
         classId: ClassId,
         classLikeDeclaration: KtClassLikeDeclaration,
     ): FirClassLikeSymbol<*>? = providers.firstNotNullOfOrNull { provider ->
-        if (provider !is JvmStubBasedFirDeserializedSymbolProvider) return@firstNotNullOfOrNull null
+        if (provider !is StubBasedFirDeserializedSymbolProvider) return@firstNotNullOfOrNull null
         provider.getClassLikeSymbolByClassId(classId, classLikeDeclaration)
     }
 
@@ -63,7 +63,7 @@ internal class LLFirModuleWithDependenciesSymbolProvider(
         callableDeclaration: KtCallableDeclaration,
     ) {
         providers.forEach { provider ->
-            if (provider !is JvmStubBasedFirDeserializedSymbolProvider) return@forEach
+            if (provider !is StubBasedFirDeserializedSymbolProvider) return@forEach
             destination.addIfNotNull(provider.getTopLevelCallableSymbol(packageFqName, shortName, callableDeclaration))
         }
     }

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

@@ -25,6 +25,7 @@ import org.jetbrains.kotlin.analysis.utils.trackers.CompositeModificationTracker
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
+import org.jetbrains.kotlin.fir.BuiltinTypes
 import org.jetbrains.kotlin.fir.PrivateSessionConstructor
 import org.jetbrains.kotlin.fir.SessionConfiguration
 import org.jetbrains.kotlin.fir.analysis.checkersComponent
@@ -59,6 +60,38 @@ internal abstract class LLFirAbstractSessionFactory(protected val project: Proje
     abstract fun createLibrarySession(module: KtModule): LLFirLibraryOrLibrarySourceResolvableModuleSession
     abstract fun createBinaryLibrarySession(module: KtBinaryModule): LLFirLibrarySession
 
+    private fun createLibraryProvidersForScope(
+        session: LLFirSession,
+        moduleData: LLFirModuleData,
+        kotlinScopeProvider: FirKotlinScopeProvider,
+        project: Project,
+        builtinTypes: BuiltinTypes,
+        scope: GlobalSearchScope,
+        builtinSymbolProvider: FirSymbolProvider,
+    ): LLFirModuleWithDependenciesSymbolProvider {
+        return LLFirModuleWithDependenciesSymbolProvider(
+            session,
+            providers = createProjectLibraryProvidersForScope(
+                session,
+                moduleData,
+                kotlinScopeProvider,
+                project,
+                builtinTypes,
+                scope
+            ),
+            LLFirDependenciesSymbolProvider(session, listOf(builtinSymbolProvider)),
+        )
+    }
+
+    abstract fun createProjectLibraryProvidersForScope(
+        session: LLFirSession,
+        moduleData: LLFirModuleData,
+        kotlinScopeProvider: FirKotlinScopeProvider,
+        project: Project,
+        builtinTypes: BuiltinTypes,
+        scope: GlobalSearchScope,
+    ): List<FirSymbolProvider>
+
     fun createScriptSession(module: KtScriptModule): LLFirScriptSession {
         val platform = module.platform
         val builtinsSession = LLFirBuiltinsSessionFactory.getInstance(project).getBuiltinsSession(platform)
@@ -348,7 +381,7 @@ internal abstract class LLFirAbstractSessionFactory(protected val project: Proje
                     val librariesSearchScope = ProjectScope.getLibrariesScope(project)
                         .intersectWith(GlobalSearchScope.notScope(libraryModule.contentScope))
 
-                    val restLibrariesProvider = LLFirLibraryProviderFactory.createProjectLibraryProvidersForScope(
+                    val restLibrariesProvider = createProjectLibraryProvidersForScope(
                         session, moduleData, scopeProvider,
                         project, builtinTypes, librariesSearchScope
                     )
@@ -398,7 +431,7 @@ internal abstract class LLFirAbstractSessionFactory(protected val project: Proje
             val kotlinScopeProvider = FirKotlinScopeProvider(::wrapScopeWithJvmMapped)
             register(FirKotlinScopeProvider::class, kotlinScopeProvider)
 
-            val symbolProvider = LLFirLibraryProviderFactory.createLibraryProvidersForScope(
+            val symbolProvider = createLibraryProvidersForScope(
                 this,
                 moduleData,
                 kotlinScopeProvider,

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

@@ -6,18 +6,28 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.sessions
 
 import com.intellij.openapi.project.Project
+import com.intellij.psi.search.GlobalSearchScope
+import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.LLFirModuleData
 import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.LLFirModuleWithDependenciesSymbolProvider
+import org.jetbrains.kotlin.analysis.low.level.api.fir.stubBased.deserialization.createStubBasedFirSymbolProviderForCommonMetadataFiles
+import org.jetbrains.kotlin.analysis.low.level.api.fir.stubBased.deserialization.createStubBasedFirSymbolProviderForKotlinNativeMetadataFiles
 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.analysis.providers.createPackagePartProvider
+import org.jetbrains.kotlin.fir.BuiltinTypes
 import org.jetbrains.kotlin.fir.FirVisibilityChecker
 import org.jetbrains.kotlin.fir.SessionConfiguration
 import org.jetbrains.kotlin.fir.analysis.FirOverridesBackwardCompatibilityHelper
 import org.jetbrains.kotlin.fir.analysis.jvm.FirJvmOverridesBackwardCompatibilityHelper
+import org.jetbrains.kotlin.fir.deserialization.SingleModuleDataProvider
+import org.jetbrains.kotlin.fir.java.deserialization.OptionalAnnotationClassesProvider
 import org.jetbrains.kotlin.fir.resolve.calls.ConeCallConflictResolverFactory
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
+import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
 import org.jetbrains.kotlin.fir.scopes.FirPlatformClassMapper
 import org.jetbrains.kotlin.fir.session.DefaultCallConflictResolverFactory
+import org.jetbrains.kotlin.utils.addIfNotNull
 
 @OptIn(SessionConfiguration::class)
 internal class LLFirCommonSessionFactory(project: Project) : LLFirAbstractSessionFactory(project) {
@@ -61,6 +71,31 @@ internal class LLFirCommonSessionFactory(project: Project) : LLFirAbstractSessio
         }
     }
 
+    override fun createProjectLibraryProvidersForScope(
+        session: LLFirSession,
+        moduleData: LLFirModuleData,
+        kotlinScopeProvider: FirKotlinScopeProvider,
+        project: Project,
+        builtinTypes: BuiltinTypes,
+        scope: GlobalSearchScope,
+    ): List<FirSymbolProvider> {
+        val moduleDataProvider = SingleModuleDataProvider(moduleData)
+        val packagePartProvider = project.createPackagePartProvider(scope)
+        return buildList {
+            add(createStubBasedFirSymbolProviderForCommonMetadataFiles(project, scope, session, moduleDataProvider, kotlinScopeProvider))
+            add(createStubBasedFirSymbolProviderForKotlinNativeMetadataFiles(project, scope, session, moduleDataProvider, kotlinScopeProvider))
+
+            addIfNotNull(
+                OptionalAnnotationClassesProvider.createIfNeeded(
+                    session,
+                    moduleDataProvider,
+                    kotlinScopeProvider,
+                    packagePartProvider
+                )
+            )
+        }
+    }
+
     private fun LLFirSession.registerModuleIndependentCommonComponents() {
         register(FirVisibilityChecker::class, FirVisibilityChecker.Default)
         register(ConeCallConflictResolverFactory::class, DefaultCallConflictResolverFactory)

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

@@ -6,10 +6,13 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.sessions
 
 import com.intellij.openapi.project.Project
+import com.intellij.psi.search.GlobalSearchScope
+import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.LLFirModuleData
 import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.LLFirModuleWithDependenciesSymbolProvider
 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.fir.BuiltinTypes
 import org.jetbrains.kotlin.fir.FirVisibilityChecker
 import org.jetbrains.kotlin.fir.SessionConfiguration
 import org.jetbrains.kotlin.fir.analysis.FirOverridesBackwardCompatibilityHelper
@@ -18,6 +21,7 @@ import org.jetbrains.kotlin.fir.analysis.js.checkers.FirJsPlatformDiagnosticSupp
 import org.jetbrains.kotlin.fir.analysis.jvm.FirJvmOverridesBackwardCompatibilityHelper
 import org.jetbrains.kotlin.fir.resolve.calls.ConeCallConflictResolverFactory
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
+import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
 import org.jetbrains.kotlin.fir.scopes.FirPlatformClassMapper
 import org.jetbrains.kotlin.fir.session.JsCallConflictResolverFactory
 
@@ -65,6 +69,17 @@ internal class LLFirJsSessionFactory(project: Project) : LLFirAbstractSessionFac
         }
     }
 
+    override fun createProjectLibraryProvidersForScope(
+        session: LLFirSession,
+        moduleData: LLFirModuleData,
+        kotlinScopeProvider: FirKotlinScopeProvider,
+        project: Project,
+        builtinTypes: BuiltinTypes,
+        scope: GlobalSearchScope,
+    ): List<FirSymbolProvider> {
+        return emptyList() // TODO(kirpichenkov)
+    }
+
     private fun LLFirSession.registerModuleIndependentJsComponents() {
         register(FirVisibilityChecker::class, FirVisibilityChecker.Default)
         register(ConeCallConflictResolverFactory::class, JsCallConflictResolverFactory)

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

@@ -6,17 +6,24 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.sessions
 
 import com.intellij.openapi.project.Project
+import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.*
 import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.*
 import org.jetbrains.kotlin.analysis.project.structure.*
+import org.jetbrains.kotlin.analysis.providers.createPackagePartProvider
+import org.jetbrains.kotlin.fir.BuiltinTypes
 import org.jetbrains.kotlin.fir.SessionConfiguration
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmTypeMapper
+import org.jetbrains.kotlin.fir.deserialization.SingleModuleDataProvider
 import org.jetbrains.kotlin.fir.java.JavaSymbolProvider
+import org.jetbrains.kotlin.fir.java.deserialization.OptionalAnnotationClassesProvider
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
 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.load.java.createJavaClassFinder
 import org.jetbrains.kotlin.resolve.jvm.modules.JavaModuleResolver
+import org.jetbrains.kotlin.utils.addIfNotNull
 
 @OptIn(SessionConfiguration::class)
 internal class LLFirJvmSessionFactory(project: Project) : LLFirAbstractSessionFactory(project) {
@@ -74,4 +81,40 @@ internal class LLFirJvmSessionFactory(project: Project) : LLFirAbstractSessionFa
             register(FirJvmTypeMapper::class, FirJvmTypeMapper(this))
         }
     }
+
+    override fun createProjectLibraryProvidersForScope(
+        session: LLFirSession,
+        moduleData: LLFirModuleData,
+        kotlinScopeProvider: FirKotlinScopeProvider,
+        project: Project,
+        builtinTypes: BuiltinTypes,
+        scope: GlobalSearchScope,
+    ): List<FirSymbolProvider> {
+        val moduleDataProvider = SingleModuleDataProvider(moduleData)
+        val packagePartProvider = project.createPackagePartProvider(scope)
+        return buildList {
+            val firJavaFacade = LLFirJavaFacadeForBinaries(session, builtinTypes, project.createJavaClassFinder(scope), moduleDataProvider)
+            val deserializedSymbolProviderFactory = project.getService(JvmFirDeserializedSymbolProviderFactory::class.java)
+            addAll(
+                deserializedSymbolProviderFactory.createJvmFirDeserializedSymbolProviders(
+                    project,
+                    session,
+                    moduleData,
+                    kotlinScopeProvider,
+                    moduleDataProvider,
+                    firJavaFacade,
+                    packagePartProvider,
+                    scope
+                )
+            )
+            addIfNotNull(
+                OptionalAnnotationClassesProvider.createIfNeeded(
+                    session,
+                    moduleDataProvider,
+                    kotlinScopeProvider,
+                    packagePartProvider
+                )
+            )
+        }
+    }
 }

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

@@ -6,18 +6,27 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.sessions
 
 import com.intellij.openapi.project.Project
+import com.intellij.psi.search.GlobalSearchScope
+import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.LLFirModuleData
 import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.LLFirModuleWithDependenciesSymbolProvider
+import org.jetbrains.kotlin.analysis.low.level.api.fir.stubBased.deserialization.createStubBasedFirSymbolProviderForKotlinNativeMetadataFiles
 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.analysis.providers.createPackagePartProvider
+import org.jetbrains.kotlin.fir.BuiltinTypes
 import org.jetbrains.kotlin.fir.FirVisibilityChecker
 import org.jetbrains.kotlin.fir.SessionConfiguration
 import org.jetbrains.kotlin.fir.analysis.FirDefaultOverridesBackwardCompatibilityHelper
 import org.jetbrains.kotlin.fir.analysis.FirOverridesBackwardCompatibilityHelper
+import org.jetbrains.kotlin.fir.deserialization.SingleModuleDataProvider
+import org.jetbrains.kotlin.fir.java.deserialization.OptionalAnnotationClassesProvider
 import org.jetbrains.kotlin.fir.resolve.calls.ConeCallConflictResolverFactory
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
+import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
 import org.jetbrains.kotlin.fir.scopes.FirPlatformClassMapper
 import org.jetbrains.kotlin.fir.session.DefaultCallConflictResolverFactory
+import org.jetbrains.kotlin.utils.addIfNotNull
 
 @OptIn(SessionConfiguration::class)
 internal class LLFirNativeSessionFactory(project: Project) : LLFirAbstractSessionFactory(project) {
@@ -62,6 +71,33 @@ internal class LLFirNativeSessionFactory(project: Project) : LLFirAbstractSessio
         }
     }
 
+    override fun createProjectLibraryProvidersForScope(
+        session: LLFirSession,
+        moduleData: LLFirModuleData,
+        kotlinScopeProvider: FirKotlinScopeProvider,
+        project: Project,
+        builtinTypes: BuiltinTypes,
+        scope: GlobalSearchScope,
+    ): List<FirSymbolProvider> {
+        val moduleDataProvider = SingleModuleDataProvider(moduleData)
+        val packagePartProvider = project.createPackagePartProvider(scope)
+        return buildList {
+            add(
+                createStubBasedFirSymbolProviderForKotlinNativeMetadataFiles(
+                    project, scope, session, moduleDataProvider, kotlinScopeProvider
+                )
+            )
+            addIfNotNull(
+                OptionalAnnotationClassesProvider.createIfNeeded(
+                    session,
+                    moduleDataProvider,
+                    kotlinScopeProvider,
+                    packagePartProvider
+                )
+            )
+        }
+    }
+
     private fun LLFirSession.registerModuleIndependentNativeComponents() {
         register(FirVisibilityChecker::class, FirVisibilityChecker.Default)
         register(ConeCallConflictResolverFactory::class, DefaultCallConflictResolverFactory)

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

@@ -91,8 +91,7 @@ class LLFirSessionCache(private val project: Project) {
             targetPlatform.all { it is JvmPlatform } -> LLFirJvmSessionFactory(project)
             targetPlatform.all { it is JsPlatform } -> LLFirJsSessionFactory(project)
             targetPlatform.all { it is NativePlatform } -> LLFirNativeSessionFactory(project)
-            // TODO(kirpichenkov): falling back to JVM. Common session factory hasn't been implemented correctly yet and breaks tests
+            else -> LLFirCommonSessionFactory(project)
-            else -> LLFirJvmSessionFactory(project)
         }
     }
 }

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/stubBased/deserialization/JvmStubBasedDeserializedSymbolProviderFactory.kt

@@ -7,15 +7,13 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.stubBased.deserializatio
 
 import com.intellij.ide.highlighter.JavaClassFileType
 import com.intellij.openapi.project.Project
-import com.intellij.openapi.vfs.VirtualFile
-import com.intellij.psi.search.DelegatingGlobalSearchScope
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirInternals
 import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.JvmFirDeserializedSymbolProviderFactory
 import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.LLFirModuleData
 import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.LLFirJavaSymbolProvider
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
+import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin.Library
 import org.jetbrains.kotlin.fir.deserialization.SingleModuleDataProvider
 import org.jetbrains.kotlin.fir.java.FirJavaFacade
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
@@ -37,26 +35,10 @@ class JvmStubBasedDeserializedSymbolProviderFactory : JvmFirDeserializedSymbolPr
         return buildList {
             //stub based provider here works over kotlin-only indices and thus provides only kotlin declarations
             //in order to find java declarations, one need to explicitly setup java symbol provider.
-            //for ProtoBuf based provider (used in compiler), there is no need in separated java provider, 
+            //for ProtoBuf based provider (used in compiler), there is no need in separated java provider,
             //because all declarations are retrieved at once and are not distinguished
-            add(
+            add(createStubBasedFirSymbolProviderForClassFiles(project, scope, session, moduleDataProvider, kotlinScopeProvider))
-                JvmStubBasedFirDeserializedSymbolProvider(
-                    session,
-                    moduleDataProvider,
-                    kotlinScopeProvider,
-                    project,
-                    object : DelegatingGlobalSearchScope(project, scope) {
-                        override fun contains(file: VirtualFile): Boolean {
-                            if (file.extension != JavaClassFileType.INSTANCE.defaultExtension) {
-                                return false
-                            }
-                            return super.contains(file)
-                        }
-                    },
-                    FirDeclarationOrigin.Library
-                )
-            )
             add(LLFirJavaSymbolProvider(session, moduleData, project, scope))
         }
     }
-}
+}

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/stubBased/deserialization/StubBasedFirDeserializedSymbolProvider.kt

@@ -35,7 +35,7 @@ import java.util.ArrayList
 typealias DeserializedTypeAliasPostProcessor = (FirTypeAliasSymbol) -> Unit
 
 /**
- * [JvmStubBasedFirDeserializedSymbolProvider] works over existing stubs,
+ * [StubBasedFirDeserializedSymbolProvider] works over existing stubs,
  * retrieving them by classId/callableId from [KotlinDeclarationProvider].
  *
  * It works in IDE only, in standalone mode works [JvmClassFileBasedSymbolProvider].
@@ -46,7 +46,7 @@ typealias DeserializedTypeAliasPostProcessor = (FirTypeAliasSymbol) -> Unit
  *
  * Same as [JvmClassFileBasedSymbolProvider], resulting fir elements are already resolved.
  */
-internal open class JvmStubBasedFirDeserializedSymbolProvider(
+internal open class StubBasedFirDeserializedSymbolProvider(
     session: FirSession,
     moduleDataProvider: SingleModuleDataProvider,
     private val kotlinScopeProvider: FirKotlinScopeProvider,

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/stubBased/deserialization/StubBasedFirSymbolProviderFactories.kt

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2010-2023 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.stubBased.deserialization
+
+import com.intellij.ide.highlighter.JavaClassFileType
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.psi.search.DelegatingGlobalSearchScope
+import com.intellij.psi.search.GlobalSearchScope
+import org.jetbrains.kotlin.analysis.decompiler.psi.KotlinBuiltInFileType
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
+import org.jetbrains.kotlin.fir.deserialization.SingleModuleDataProvider
+import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
+import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
+import org.jetbrains.kotlin.library.KLIB_METADATA_FILE_EXTENSION
+
+internal fun createStubBasedFirSymbolProviderForClassFiles(
+    project: Project,
+    baseScope: GlobalSearchScope,
+    session: FirSession,
+    moduleDataProvider: SingleModuleDataProvider,
+    kotlinScopeProvider: FirKotlinScopeProvider,
+): FirSymbolProvider = createStubBasedFirSymbolProviderForScopeLimitedByFiles(
+    project, baseScope, session, moduleDataProvider, kotlinScopeProvider,
+    fileFilter = { file -> file.extension == JavaClassFileType.INSTANCE.defaultExtension },
+)
+
+internal fun createStubBasedFirSymbolProviderForCommonMetadataFiles(
+    project: Project,
+    baseScope: GlobalSearchScope,
+    session: FirSession,
+    moduleDataProvider: SingleModuleDataProvider,
+    kotlinScopeProvider: FirKotlinScopeProvider,
+): FirSymbolProvider = createStubBasedFirSymbolProviderForScopeLimitedByFiles(
+    project, baseScope, session, moduleDataProvider, kotlinScopeProvider,
+    fileFilter = { file -> file.fileType == KotlinBuiltInFileType },
+)
+
+internal fun createStubBasedFirSymbolProviderForKotlinNativeMetadataFiles(
+    project: Project,
+    baseScope: GlobalSearchScope,
+    session: FirSession,
+    moduleDataProvider: SingleModuleDataProvider,
+    kotlinScopeProvider: FirKotlinScopeProvider,
+): FirSymbolProvider = createStubBasedFirSymbolProviderForScopeLimitedByFiles(
+    project, baseScope, session, moduleDataProvider, kotlinScopeProvider,
+    fileFilter = { file -> file.extension == KLIB_METADATA_FILE_EXTENSION },
+)
+
+internal fun createStubBasedFirSymbolProviderForScopeLimitedByFiles(
+    project: Project,
+    baseScope: GlobalSearchScope,
+    session: FirSession,
+    moduleDataProvider: SingleModuleDataProvider,
+    kotlinScopeProvider: FirKotlinScopeProvider,
+    fileFilter: (VirtualFile) -> Boolean,
+): StubBasedFirDeserializedSymbolProvider {
+    return createFirSymbolProviderForScopeLimitedByFiles(
+        project, baseScope, fileFilter,
+        symbolProviderFactory = { reducedScope: GlobalSearchScope ->
+            StubBasedFirDeserializedSymbolProvider(
+                session, moduleDataProvider, kotlinScopeProvider, project, reducedScope, FirDeclarationOrigin.Library,
+            )
+        }
+    )
+}
+
+private fun <T : FirSymbolProvider> createFirSymbolProviderForScopeLimitedByFiles(
+    project: Project,
+    baseScope: GlobalSearchScope,
+    fileFilter: (VirtualFile) -> Boolean,
+    symbolProviderFactory: (reducedScope: GlobalSearchScope) -> T,
+): T {
+    val scopeWithFileFiltering = object : DelegatingGlobalSearchScope(project, baseScope) {
+        override fun contains(file: VirtualFile): Boolean {
+            if (!fileFilter(file)) {
+                return false
+            }
+            return super.contains(file)
+        }
+    }
+
+    return symbolProviderFactory(scopeWithFileFiltering)
+}

compiler/testData/diagnostics/testsWithStdLib/annotations/Volatile.kt

@@ -1,6 +1,4 @@
 // FIR_IDENTICAL
-// IGNORE_REVERSED_RESOLVE
-// IGNORE_DIAGNOSTIC_API
 // !DIAGNOSTICS: -UNUSED_ANONYMOUS_PARAMETER
 // !LANGUAGE: +MultiPlatformProjects