[JS IR BE] Load builtins from code to runtime

Bypass builtins deserialization mechanism in legacy JS backend and load
bultins direcly as kotlin code.

This way we won't have separated IR declarations for Enum, Char, Long

Some "native" builtins are implemented in libraries/stdlib/js/irRuntime/builtins/
Other builtins are moved by MoveExternalDeclarationsToSeparatePlace and
used only in compile-time

js/js.frontend/src/org/jetbrains/kotlin/frontend/js/di/injection.kt

@@ -44,7 +44,7 @@ fun createTopDownAnalyzerForJs(
         languageVersionSettings: LanguageVersionSettings,
         lookupTracker: LookupTracker,
         expectActualTracker: ExpectActualTracker,
-        fallbackPackage: PackageFragmentProvider?
+        additionalPackages: List<PackageFragmentProvider>
 ): LazyTopDownAnalyzer {
     val storageComponentContainer = createContainer("TopDownAnalyzerForJs", JsPlatform) {
         configureModule(moduleContext, JsPlatform, TargetPlatformVersion.NoVersion, bindingTrace)
@@ -62,7 +62,7 @@ fun createTopDownAnalyzerForJs(
     }.apply {
         val packagePartProviders = mutableListOf(get<KotlinCodeAnalyzer>().packageFragmentProvider)
         val moduleDescriptor = get<ModuleDescriptorImpl>()
-        fallbackPackage?.let { packagePartProviders += it }
+        packagePartProviders += additionalPackages
         moduleDescriptor.initialize(CompositePackageFragmentProvider(packagePartProviders))
     }
     return storageComponentContainer.get<LazyTopDownAnalyzer>()

js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.kt

@@ -6,12 +6,15 @@
 package org.jetbrains.kotlin.js.analyze
 
 import com.intellij.openapi.project.Project
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.builtins.functions.functionInterfacePackageFragmentProvider
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.context.ContextForNewModule
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.context.ProjectContext
+import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.frontend.js.di.createTopDownAnalyzerForJs
 import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
@@ -45,31 +48,55 @@ object TopDownAnalyzerFacadeForJS {
         project: Project,
         configuration: CompilerConfiguration,
         moduleDescriptors: List<ModuleDescriptorImpl>,
-        friendModuleDescriptors: List<ModuleDescriptorImpl>
+        friendModuleDescriptors: List<ModuleDescriptorImpl>,
+        thisIsBuiltInsModule: Boolean = false,
+        customBuiltInsModule: ModuleDescriptorImpl? = null
     ): JsAnalysisResult {
+        require(!thisIsBuiltInsModule || customBuiltInsModule == null) {
+            "Can't simultaneously use custom built-ins module and set current module as built-ins"
+        }
+        val projectContext = ProjectContext(project)
+        val builtIns = if (thisIsBuiltInsModule || customBuiltInsModule != null) {
+            object : KotlinBuiltIns(projectContext.storageManager) {}
+        } else {
+            JsPlatform.builtIns
+        }
 
         val moduleName = configuration[CommonConfigurationKeys.MODULE_NAME]!!
-        val context = ContextForNewModule(ProjectContext(project), Name.special("<$moduleName>"), JsPlatform.builtIns, null)
-
-        context.module.setDependencies(
-            listOf(context.module) +
-                    moduleDescriptors +
-                    listOf(JsPlatform.builtIns.builtInsModule),
-            friendModuleDescriptors.toSet()
+        val context = ContextForNewModule(
+            projectContext,
+            Name.special("<$moduleName>"),
+            builtIns,
+            multiTargetPlatform = null
         )
 
+        val additionalPackages = mutableListOf<PackageFragmentProvider>()
+
+        if (customBuiltInsModule != null) {
+            builtIns.builtInsModule = customBuiltInsModule
+        }
+
+        if (thisIsBuiltInsModule) {
+            builtIns.builtInsModule = context.module
+            additionalPackages += functionInterfacePackageFragmentProvider(context.storageManager, context.module)
+        }
+
+        val dependencies = mutableSetOf(context.module) + moduleDescriptors + builtIns.builtInsModule
+        context.module.setDependencies(dependencies.toList(), friendModuleDescriptors.toSet())
+
         val moduleKind = configuration.get(JSConfigurationKeys.MODULE_KIND, ModuleKind.PLAIN)
 
         val trace = BindingTraceContext()
         trace.record(MODULE_KIND, context.module, moduleKind)
-        return analyzeFilesWithGivenTrace(files, trace, context, configuration)
+        return analyzeFilesWithGivenTrace(files, trace, context, configuration, additionalPackages)
     }
 
     fun analyzeFilesWithGivenTrace(
         files: Collection<KtFile>,
         trace: BindingTrace,
         moduleContext: ModuleContext,
-        configuration: CompilerConfiguration
+        configuration: CompilerConfiguration,
+        additionalPackages: List<PackageFragmentProvider> = emptyList()
     ): JsAnalysisResult {
         val lookupTracker = configuration.get(CommonConfigurationKeys.LOOKUP_TRACKER) ?: LookupTracker.DO_NOTHING
         val expectActualTracker = configuration.get(CommonConfigurationKeys.EXPECT_ACTUAL_TRACKER) ?: ExpectActualTracker.DoNothing
@@ -91,7 +118,7 @@ object TopDownAnalyzerFacadeForJS {
                 languageVersionSettings,
                 lookupTracker,
                 expectActualTracker,
-                packageFragment
+                additionalPackages + listOfNotNull(packageFragment)
         )
         analyzerForJs.analyzeDeclarations(TopDownAnalysisMode.TopLevelDeclarations, files)
         return JsAnalysisResult.success(trace, moduleContext.module)