FIR JS: prepare session factory for JS/KLib usage

compiler/fir/entrypoint/build.gradle.kts

@@ -14,6 +14,7 @@ dependencies {
     api(project(":compiler:fir:checkers:checkers.jvm"))
     api(project(":compiler:fir:checkers:checkers.js"))
     api(project(":compiler:fir:checkers:checkers.native"))
+    api(project(":js:js.frontend"))
 
     // TODO: do not use GeneratorExtensions in `FirAnalyzerFacade.convertToIr`, and make this an 'implementation' dependency.
     api(project(":compiler:ir.psi2ir"))
@@ -23,6 +24,7 @@ dependencies {
     implementation(project(":compiler:backend.jvm"))
     implementation(project(":compiler:ir.serialization.common"))
     implementation(project(":compiler:ir.serialization.jvm"))
+    implementation(project(":compiler:ir.serialization.js"))
     implementation(project(":compiler:ir.tree"))
 
     compileOnly(intellijCore())

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

@@ -50,7 +50,7 @@ abstract class FirAbstractSessionFactory {
             register(FirKotlinScopeProvider::class, kotlinScopeProvider)
 
             val builtinsModuleData = DependencyListForCliModule.createDependencyModuleData(
-                Name.special("<builtins of ${mainModuleName.identifier}"),
+                Name.special("<builtins of ${mainModuleName.asString()}"),
                 moduleDataProvider.platform,
                 moduleDataProvider.analyzerServices,
             )

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

@@ -0,0 +1,91 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.session
+
+import org.jetbrains.kotlin.config.*
+import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.analysis.FirOverridesBackwardCompatibilityHelper
+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.java.FirProjectSessionProvider
+import org.jetbrains.kotlin.fir.resolve.calls.ConeCallConflictResolverFactory
+import org.jetbrains.kotlin.fir.resolve.providers.impl.*
+import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
+import org.jetbrains.kotlin.fir.scopes.FirPlatformClassMapper
+import org.jetbrains.kotlin.incremental.components.LookupTracker
+import org.jetbrains.kotlin.library.resolver.KotlinResolvedLibrary
+import org.jetbrains.kotlin.name.Name
+
+object FirJsSessionFactory : FirAbstractSessionFactory() {
+
+    fun createJsModuleBasedSession(
+        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,
+                )
+            }
+        )
+    }
+
+    fun createJsLibrarySession(
+        mainModuleName: Name,
+        resolvedLibraries: List<KotlinResolvedLibrary>,
+        sessionProvider: FirProjectSessionProvider,
+        moduleDataProvider: ModuleDataProvider,
+        languageVersionSettings: LanguageVersionSettings = LanguageVersionSettingsImpl.DEFAULT,
+    ) = createLibrarySession(
+        mainModuleName,
+        sessionProvider,
+        moduleDataProvider,
+        languageVersionSettings,
+        registerExtraComponents = { it.registerJsSpecificResolveComponents() },
+        createKotlinScopeProvider = { FirKotlinScopeProvider { _, declaredMemberScope, _, _ -> declaredMemberScope } },
+        createProviders = { session, builtinsModuleData, kotlinScopeProvider ->
+            val klibProviders = resolvedLibraries.map {
+                KlibBasedSymbolProvider(session, moduleDataProvider, kotlinScopeProvider, it)
+            }
+
+            klibProviders +
+                listOf(
+                    FirCloneableSymbolProvider(session, builtinsModuleData, kotlinScopeProvider),
+                    // (Most) builtins should be taken from the dependencies in JS compilation, therefore builtins provider is the last one
+                    // TODO: consider using "poisoning" provider for builtins to ensure that proper ones are taken from dependencies
+                    // NOTE: it requires precise filtering for true nuiltins, like Function*
+                    FirBuiltinSymbolProvider(session, builtinsModuleData, kotlinScopeProvider),
+                )
+        }
+    )
+
+    @OptIn(SessionConfiguration::class)
+    fun FirSession.registerJsSpecificResolveComponents() {
+        register(FirVisibilityChecker::class, FirVisibilityChecker.Default)
+        register(ConeCallConflictResolverFactory::class, JsCallConflictResolverFactory)
+        register(FirPlatformClassMapper::class, FirPlatformClassMapper.Default)
+        register(FirOverridesBackwardCompatibilityHelper::class, FirOverridesBackwardCompatibilityHelper.Default())
+    }
+}
+

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

@@ -15,8 +15,7 @@ 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.impl.FirBuiltinSymbolProvider
-import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCloneableSymbolProvider
+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.session.environment.AbstractProjectEnvironment
@@ -116,7 +115,8 @@ object FirJvmSessionFactory : FirAbstractSessionFactory() {
                     }
                 }
 
-                val javaSymbolProvider = JavaSymbolProvider(session, projectEnvironment.getFirJavaFacade(session, moduleData, javaSourcesScope))
+                val javaSymbolProvider =
+                    JavaSymbolProvider(session, projectEnvironment.getFirJavaFacade(session, moduleData, javaSourcesScope))
                 session.register(JavaSymbolProvider::class, javaSymbolProvider)
 
                 listOfNotNull(
@@ -136,3 +136,4 @@ object FirJvmSessionFactory : FirAbstractSessionFactory() {
         }
     }
 }
+

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

@@ -20,6 +20,7 @@ import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
 import org.jetbrains.kotlin.fir.scopes.FirPlatformClassMapper
 import org.jetbrains.kotlin.fir.session.FirAbstractSessionFactory
 import org.jetbrains.kotlin.fir.session.FirSessionConfigurator
+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
@@ -35,24 +36,11 @@ object FirJsSessionFactory : FirAbstractSessionFactory() {
         testServices: TestServices,
         configuration: CompilerConfiguration,
         languageVersionSettings: LanguageVersionSettings,
-    ): FirSession {
-        val moduleDataProvider = dependencyListForCliModule.moduleDataProvider
-        return createLibrarySession(
-            mainModuleName,
-            sessionProvider,
-            moduleDataProvider,
-            languageVersionSettings,
-            null,
-            createKotlinScopeProvider = { FirKotlinScopeProvider { _, declaredMemberScope, _, _ -> declaredMemberScope } },
-            createProviders = { session, builtinsModuleData, kotlinScopeProvider ->
-                listOf(
-                    FirBuiltinSymbolProvider(session, builtinsModuleData, kotlinScopeProvider),
-                    FirCloneableSymbolProvider(session, builtinsModuleData, kotlinScopeProvider),
-                ) + resolveJsLibraries(module, testServices, configuration).map {
-                    KlibBasedSymbolProvider(session, moduleDataProvider, kotlinScopeProvider, it)
-                }
-            })
-    }
+    ): FirSession = FirSessionFactory.createJsLibrarySession(
+        mainModuleName,
+        getAllJsDependenciesPaths(module, testServices),
+        configuration, sessionProvider, dependencyListForCliModule.moduleDataProvider, languageVersionSettings
+    )
 
     fun createModuleBasedSession(
         moduleData: FirModuleData,