Add link from module descriptor to library reader

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/TopDownAnalyzerFacadeForKonan.kt

@@ -17,10 +17,12 @@
 package org.jetbrains.kotlin.backend.konan
 
 import org.jetbrains.kotlin.analyzer.AnalysisResult
+import org.jetbrains.kotlin.backend.konan.descriptors.createKonanModuleDescriptor
+import org.jetbrains.kotlin.backend.konan.descriptors.CurrentKonanModule
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
-import org.jetbrains.kotlin.context.ContextForNewModule
 import org.jetbrains.kotlin.context.ModuleContext
+import org.jetbrains.kotlin.context.MutableModuleContextImpl
 import org.jetbrains.kotlin.context.ProjectContext
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtFile
@@ -32,15 +34,13 @@ object TopDownAnalyzerFacadeForKonan {
         val moduleName = Name.special("<${config.moduleId}>") 
 
         val projectContext = ProjectContext(config.project)
-        val builtIns = KonanBuiltIns(projectContext.storageManager)
-        val context = ContextForNewModule(projectContext, moduleName, builtIns, null)
 
-        val module = context.module
-        builtIns.builtInsModule = module
+        val module = createKonanModuleDescriptor(moduleName, projectContext.storageManager, origin = CurrentKonanModule)
+        val context = MutableModuleContextImpl(module, projectContext)
 
         if (!module.isStdlib()) {
             context.setDependencies(listOf(module) + config.moduleDescriptors +
-                    config.getOrCreateForwardDeclarationsModule(builtIns, projectContext.storageManager))
+                    config.getOrCreateForwardDeclarationsModule(module.builtIns, projectContext.storageManager))
         } else {
             assert (config.moduleDescriptors.isEmpty())
             context.setDependencies(module)

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/descriptors/InteropDescriptors.kt

@@ -146,10 +146,11 @@ private class ForwardDeclarationsPackageFragmentDescriptor(
  * Note: this module should be unique per compilation and should always be the last dependency of any module.
  */
 fun createForwardDeclarationsModule(builtIns: KotlinBuiltIns, storageManager: StorageManager): ModuleDescriptorImpl {
-    val module = ModuleDescriptorImpl(
+    val module = createKonanModuleDescriptor(
             Name.special("<forward declarations>"),
             storageManager,
-            builtIns
+            builtIns,
+            origin = SyntheticModules
     )
 
     fun createPackage(fqName: FqName, supertypeName: String, classKind: ClassKind = ClassKind.CLASS) =

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/descriptors/KonanModuleDescriptors.kt

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2010-2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.backend.konan.descriptors
+
+import org.jetbrains.kotlin.backend.konan.Context
+import org.jetbrains.kotlin.backend.konan.KonanBuiltIns
+import org.jetbrains.kotlin.backend.konan.library.KonanLibraryReader
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.descriptorUtil.module
+import org.jetbrains.kotlin.storage.StorageManager
+
+sealed class KonanModuleOrigin {
+    companion object {
+        val CAPABILITY = ModuleDescriptor.Capability<KonanModuleOrigin>("KonanModuleOrigin")
+    }
+}
+
+// Note: merging these two concepts (LlvmSymbolOrigin and KonanModuleOrigin) for simplicity:
+sealed class LlvmSymbolOrigin : KonanModuleOrigin()
+
+data class DeserializedKonanModule(val reader: KonanLibraryReader) : LlvmSymbolOrigin()
+object CurrentKonanModule : LlvmSymbolOrigin()
+
+object SyntheticModules : KonanModuleOrigin()
+
+val ModuleDescriptor.origin get() = this.getCapability(KonanModuleOrigin.CAPABILITY)!!
+
+internal val Context.stdlibModule get() = this.builtIns.any.module
+
+internal fun createKonanModuleDescriptor(
+        name: Name,
+        storageManager: StorageManager,
+        origin: KonanModuleOrigin
+): ModuleDescriptorImpl {
+    val builtIns = KonanBuiltIns(storageManager)
+
+    val moduleDescriptor = createKonanModuleDescriptor(name, storageManager, builtIns, origin)
+
+    builtIns.builtInsModule = moduleDescriptor
+    // It is mostly correct because any module should depend on stdlib.
+
+    return moduleDescriptor
+}
+
+internal fun createKonanModuleDescriptor(
+        name: Name,
+        storageManager: StorageManager,
+        builtIns: KotlinBuiltIns,
+        origin: KonanModuleOrigin
+) = ModuleDescriptorImpl(
+        name, storageManager, builtIns,
+        capabilities = mapOf(KonanModuleOrigin.CAPABILITY to origin)
+)

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/serialization/KonanSerializationUtil.kt

@@ -17,6 +17,8 @@
 package org.jetbrains.kotlin.backend.konan.serialization
 
 import org.jetbrains.kotlin.backend.konan.*
+import org.jetbrains.kotlin.backend.konan.descriptors.DeserializedKonanModule
+import org.jetbrains.kotlin.backend.konan.descriptors.createKonanModuleDescriptor
 import org.jetbrains.kotlin.backend.konan.library.KonanLibraryReader
 import org.jetbrains.kotlin.backend.konan.library.LinkData
 import org.jetbrains.kotlin.backend.konan.llvm.base64Decode
@@ -131,10 +133,10 @@ internal fun deserializeModule(languageVersionSettings: LanguageVersionSettings,
     val moduleName = libraryProto.moduleName
 
     val storageManager = LockBasedStorageManager()
-    val builtIns = KonanBuiltIns(storageManager)
-    val moduleDescriptor = ModuleDescriptorImpl(
-            Name.special(moduleName), storageManager, builtIns)
-    builtIns.builtInsModule = moduleDescriptor
+    val moduleDescriptor = createKonanModuleDescriptor(
+            Name.special(moduleName), storageManager,
+            origin = DeserializedKonanModule(reader)
+    )
     val deserializationConfiguration = CompilerDeserializationConfiguration(languageVersionSettings)
 
     val provider = createKonanPackageFragmentProvider(