Here goes stdlib separation.

$ gradlew backend.native:stdlib

builds you stdlib.kt.bc now.

The test runs are taught to supply
-library stdlib.kt.bc to kotlin compiler for proper imports resolution,
and then later stdlib.kt.bc is provided to clang for the final link step.

backend.native/cli.bc/src/org/jetbrains/kotlin/cli/bc/K2Native.kt

@@ -37,25 +37,19 @@ class NativeAnalyzer(
 class K2Native : CLICompiler<K2NativeCompilerArguments>() { 
 
     val defaultModuleName = "main";
-    
+
     override fun doExecute(arguments     : K2NativeCompilerArguments,
                            configuration : CompilerConfiguration,
                            rootDisposable: Disposable
                           ): ExitCode {
 
-        configuration.put(CommonConfigurationKeys.MODULE_NAME, defaultModuleName )
+        configuration.put(CommonConfigurationKeys.MODULE_NAME, defaultModuleName)
 
         configuration.addKotlinSourceRoots(arguments.freeArgs)
 
-
-        // TODO: remove, once linker is available.
-        if (arguments.headers != null) {
-            configuration.addKotlinSourceRoots(arguments.headers.asList())
-        }
-
-        // As of now we don't have any library mechnanism
-        var libraryFiles = listOf<String>()
-        configuration.put(KonanConfigurationKeys.LIBRARY_FILES, libraryFiles)
+        val libraries = arguments.libraries?.asList<String>() ?: listOf<String>()
+        configuration.put(KonanConfigurationKeys.LIBRARY_FILES, libraries)
+        libraries.forEach{println(it)}
 
         val environment = KotlinCoreEnvironment.createForProduction(rootDisposable,
             configuration, Arrays.asList<String>("extensions/common.xml"))

backend.native/cli.bc/src/org/jetbrains/kotlin/cli/bc/K2NativeCompilerArguments.java

@@ -14,9 +14,10 @@ public class K2NativeCompilerArguments extends CommonCompilerArguments {
     @ValueDescription("<path>")
     public String runtimeFile;
 
-    @Argument(value = "headers", description = "Header files used for compilation")
+    @Argument(value = "library", description = "Bitcode file with metadata attached")
     @ValueDescription("<path>")
-    public String[] headers;
+    public String[] libraries;
+
 
     public K2NativeCompilerArguments() {
     }
@@ -24,7 +25,7 @@ public class K2NativeCompilerArguments extends CommonCompilerArguments {
     public K2NativeCompilerArguments(K2NativeCompilerArguments arguments) {
         this.outputFile = arguments.outputFile;
         this.runtimeFile = arguments.runtimeFile;
-        this.headers = arguments.headers;
+        this.libraries = arguments.libraries;
     }
 
     public CommonCompilerArguments copy() {

backend.native/cli.bc/src/org/jetbrains/kotlin/cli/bc/KonanConfig.kt

@@ -23,14 +23,9 @@ import org.jetbrains.kotlin.backend.konan.llvm.KotlinKonanMetadataUtils
 class KonanConfig(val project: Project, val configuration: CompilerConfiguration) {
     private val storageManager = LockBasedStorageManager()
 
-    private val sourceFilesFromLibraries = listOf<KtFile>()
-    private var metadata = listOf<KotlinKonanMetadata>()
-    internal var moduleDescriptors: MutableList<JsModuleDescriptor<ModuleDescriptorImpl>>? = null
+    private val libraries = configuration.getList(KonanConfigurationKeys.LIBRARY_FILES)
 
-    init {
-        val libraries = configuration.getList(KonanConfigurationKeys.LIBRARY_FILES)
-        metadata = KotlinKonanMetadataUtils.loadLibMetadata(libraries)
-    }
+    private val metadata = KotlinKonanMetadataUtils.loadLibMetadata(libraries)
 
     val moduleId: String
         get() = configuration.getNotNull(CommonConfigurationKeys.MODULE_NAME)
@@ -38,26 +33,25 @@ class KonanConfig(val project: Project, val configuration: CompilerConfiguration
     val moduleKind: ModuleKind
         get() = configuration.get(KonanConfigurationKeys.MODULE_KIND)!!
 
-    fun getModuleDescriptors(): MutableList<JsModuleDescriptor<ModuleDescriptorImpl>> {
-        if (moduleDescriptors != null) return moduleDescriptors!!
+    // We reuse JsModuleDescriptor for serialization for now, as we haven't got one for Konan yet.
+    internal val moduleDescriptors: MutableList<JsModuleDescriptor<ModuleDescriptorImpl>> by lazy {
+
+        val jsDescriptors = mutableListOf<JsModuleDescriptor<ModuleDescriptorImpl>>()
+        val descriptors = mutableListOf<ModuleDescriptorImpl>()
 
-        moduleDescriptors = mutableListOf<JsModuleDescriptor<ModuleDescriptorImpl>>()
-        val kotlinModuleDescriptors = mutableListOf<ModuleDescriptorImpl>()
         for (metadataEntry in metadata) {
             val descriptor = createModuleDescriptor(metadataEntry)
-            moduleDescriptors!!.add(descriptor)
-            kotlinModuleDescriptors.add(descriptor.data)
+            jsDescriptors.add(descriptor)
+            descriptors.add(descriptor.data)
         }
 
-        for (module in moduleDescriptors!!) {
-            setDependencies(module.data, kotlinModuleDescriptors)
+        for (module in jsDescriptors) {
+            setDependencies(module.data, descriptors)
         }
 
-        return moduleDescriptors!!
+        jsDescriptors 
     }
 
-
-    // We reuse JsModuleDescriptor for serialization for now, as we haven't got one for Konan yet.
     private fun createModuleDescriptor(metadata: KotlinKonanMetadata): JsModuleDescriptor<ModuleDescriptorImpl> {
 
         val moduleDescriptor = ModuleDescriptorImpl(
@@ -77,14 +71,6 @@ class KonanConfig(val project: Project, val configuration: CompilerConfiguration
         private fun setDependencies(module: ModuleDescriptorImpl, modules: List<ModuleDescriptorImpl>) {
             module.setDependencies(modules.plus(KonanPlatform.builtIns.builtInsModule))
         }
-
-        fun withJsLibAdded(files: Collection<KtFile>, config: KonanConfig): Collection<KtFile> {
-            val allFiles = mutableListOf<KtFile>()
-            allFiles.addAll(files)
-            // We don't store source files in the bitcode for Konan, dont't we?
-            //allFiles.addAll(config.getSourceFilesFromLibraries());
-            return allFiles
-        }
     }
 
 }

backend.native/cli.bc/src/org/jetbrains/kotlin/cli/bc/TopDownAnalyzerFacadeForKonan.kt

@@ -38,7 +38,7 @@ object TopDownAnalyzerFacadeForKonan {
         // Make sure the compiler produced BuiltIns module comes in last
         context.setDependencies(
                 listOf(context.module) +
-                config.getModuleDescriptors().map { it.data } +
+                config.moduleDescriptors.map { it.data } +
                 listOf(compilerBuiltInsModule)
         )
         return analyzeFilesWithGivenTrace(files, BindingTraceContext(), context, config)
@@ -51,14 +51,12 @@ object TopDownAnalyzerFacadeForKonan {
             config: KonanConfig
     ): AnalysisResult {
 
-        val allFiles = KonanConfig.withJsLibAdded(files, config)
-
         // we print out each file we compile for now
-        allFiles.forEach{println(it)}
+        files.forEach{println(it)}
 
         val analyzerForKonan = createTopDownAnalyzerForKonan(
                 moduleContext, trace,
-                FileBasedDeclarationProviderFactory(moduleContext.storageManager, allFiles),
+                FileBasedDeclarationProviderFactory(moduleContext.storageManager, files),
                 config.configuration.get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl.DEFAULT)
         )
 
@@ -66,9 +64,9 @@ object TopDownAnalyzerFacadeForKonan {
         return AnalysisResult.success(trace.bindingContext, moduleContext.module)
     }
 
-    fun checkForErrors(allFiles: Collection<KtFile>, bindingContext: BindingContext) {
+    fun checkForErrors(files: Collection<KtFile>, bindingContext: BindingContext) {
         AnalyzingUtils.throwExceptionOnErrors(bindingContext)
-        for (file in allFiles) {
+        for (file in files) {
             AnalyzingUtils.checkForSyntacticErrors(file)
         }
     }