[KLIB] Cutting down usages of moduleDescriptor in linker

Replace map key `ModuleDescriptor` with `String` which is module name

compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/JvmIrCodegenFactory.kt

@@ -139,7 +139,7 @@ open class JvmIrCodegenFactory(
                 // We have to ensure that deserializer for built-ins module is created
                 irLinker.deserializeIrModuleHeader(it.builtIns.builtInsModule, null)
             }
-            irLinker.deserializeIrModuleHeader(it, kotlinLibrary)
+            irLinker.deserializeIrModuleHeader(it, kotlinLibrary, _moduleName = it.name.asString())
         }
         val irProviders = listOf(irLinker)
 

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/KotlinIrLinker.kt

@@ -14,7 +14,8 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.ir.builders.TranslationPluginContext
 import org.jetbrains.kotlin.ir.declarations.IrDeclaration
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
-import org.jetbrains.kotlin.ir.descriptors.*
+import org.jetbrains.kotlin.ir.descriptors.IrAbstractFunctionFactory
+import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.linkage.IrDeserializer
 import org.jetbrains.kotlin.ir.linkage.KotlinIrLinkerInternalException
 import org.jetbrains.kotlin.ir.symbols.*
@@ -23,6 +24,7 @@ import org.jetbrains.kotlin.ir.util.IrMessageLogger
 import org.jetbrains.kotlin.ir.util.SymbolTable
 import org.jetbrains.kotlin.ir.util.file
 import org.jetbrains.kotlin.library.KotlinLibrary
+import org.jetbrains.kotlin.library.uniqueName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
 
@@ -42,8 +44,7 @@ abstract class KotlinIrLinker(
 
     internal val modulesWithReachableTopLevels = mutableSetOf<IrModuleDeserializer>()
 
-    // TODO: replace with Map<Name, IrModuleDeserializer>
+    protected val deserializersForModules = mutableMapOf<String, IrModuleDeserializer>()
-    protected val deserializersForModules = mutableMapOf<ModuleDescriptor, IrModuleDeserializer>()
 
     abstract val fakeOverrideBuilder: FakeOverrideBuilder
 
@@ -68,7 +69,7 @@ abstract class KotlinIrLinker(
     }
 
     public open fun resolveModuleDeserializer(module: ModuleDescriptor, signature: IdSignature?): IrModuleDeserializer {
-        return deserializersForModules[module] ?: run {
+        return deserializersForModules[module.name.asString()] ?: run {
             val message = buildString {
                 append("Could not load module ")
                 append(module)
@@ -196,7 +197,7 @@ abstract class KotlinIrLinker(
                 resolveModuleDeserializer(it, null)
             }
             val currentModuleDeserializer = createCurrentModuleDeserializer(moduleFragment, currentModuleDependencies)
-            deserializersForModules[moduleFragment.descriptor] =
+            deserializersForModules[moduleFragment.name.asString()] =
                 maybeWrapWithBuiltInAndInit(moduleFragment.descriptor, currentModuleDeserializer)
         }
         deserializersForModules.values.forEach { it.init() }
@@ -253,7 +254,8 @@ abstract class KotlinIrLinker(
 
     override fun resolveBySignatureInModule(signature: IdSignature, kind: IrDeserializer.TopLevelSymbolKind, moduleName: Name): IrSymbol {
         val moduleDeserializer =
-            deserializersForModules.entries.find { it.key.name == moduleName }?.value ?: error("No module for name '$moduleName' found")
+            deserializersForModules.entries.find { it.key == moduleName.asString() }?.value
+                ?: error("No module for name '$moduleName' found")
         assert(signature == signature.topLevelSignature()) { "Signature '$signature' has to be top level" }
         if (signature !in moduleDeserializer) error("No signature $signature in module $moduleName")
         return moduleDeserializer.deserializeIrSymbol(signature, topLevelKindToSymbolKind(kind)).also {
@@ -290,9 +292,15 @@ abstract class KotlinIrLinker(
     fun deserializeIrModuleHeader(
         moduleDescriptor: ModuleDescriptor,
         kotlinLibrary: KotlinLibrary?,
-        deserializationStrategy: DeserializationStrategy = DeserializationStrategy.ONLY_REFERENCED
+        deserializationStrategy: DeserializationStrategy = DeserializationStrategy.ONLY_REFERENCED,
+        _moduleName: String? = null
     ): IrModuleFragment {
-        val deserializerForModule = deserializersForModules.getOrPut(moduleDescriptor) {
+        assert(kotlinLibrary != null || _moduleName != null) { "Either library or explicit name have to be provided $moduleDescriptor" }
+        val moduleName = kotlinLibrary?.uniqueName?.let { "<$it>" } ?: _moduleName!!
+        assert(moduleDescriptor.name.asString() == moduleName) {
+            "${moduleDescriptor.name.asString()} != $moduleName"
+        }
+        val deserializerForModule = deserializersForModules.getOrPut(moduleName) {
             maybeWrapWithBuiltInAndInit(moduleDescriptor, createModuleDeserializer(moduleDescriptor, kotlinLibrary, deserializationStrategy))
         }
         // The IrModule and its IrFiles have been created during module initialization.
@@ -306,7 +314,7 @@ abstract class KotlinIrLinker(
         if (isBuiltInModule(moduleDescriptor)) IrModuleDeserializerWithBuiltIns(builtIns, functionalInterfaceFactory, moduleDeserializer)
         else moduleDeserializer
 
-    fun deserializeIrModuleHeader(moduleDescriptor: ModuleDescriptor, kotlinLibrary: KotlinLibrary?): IrModuleFragment {
+    fun deserializeIrModuleHeader(moduleDescriptor: ModuleDescriptor, kotlinLibrary: KotlinLibrary?, moduleName: String): IrModuleFragment {
         // TODO: consider skip deserializing explicitly exported declarations for libraries.
         // Now it's not valid because of all dependencies that must be computed.
         val deserializationStrategy =
@@ -315,16 +323,16 @@ abstract class KotlinIrLinker(
             } else {
                 DeserializationStrategy.EXPLICITLY_EXPORTED
             }
-        return deserializeIrModuleHeader(moduleDescriptor, kotlinLibrary, deserializationStrategy)
+        return deserializeIrModuleHeader(moduleDescriptor, kotlinLibrary, deserializationStrategy, moduleName)
     }
 
-    fun deserializeFullModule(moduleDescriptor: ModuleDescriptor, kotlinLibrary: KotlinLibrary?): IrModuleFragment =
+    fun deserializeFullModule(moduleDescriptor: ModuleDescriptor, kotlinLibrary: KotlinLibrary): IrModuleFragment =
         deserializeIrModuleHeader(moduleDescriptor, kotlinLibrary, DeserializationStrategy.ALL)
 
     fun deserializeOnlyHeaderModule(moduleDescriptor: ModuleDescriptor, kotlinLibrary: KotlinLibrary?): IrModuleFragment =
         deserializeIrModuleHeader(moduleDescriptor, kotlinLibrary, DeserializationStrategy.ONLY_DECLARATION_HEADERS)
 
-    fun deserializeHeadersWithInlineBodies(moduleDescriptor: ModuleDescriptor, kotlinLibrary: KotlinLibrary?): IrModuleFragment =
+    fun deserializeHeadersWithInlineBodies(moduleDescriptor: ModuleDescriptor, kotlinLibrary: KotlinLibrary): IrModuleFragment =
         deserializeIrModuleHeader(moduleDescriptor, kotlinLibrary, DeserializationStrategy.WITH_INLINE_BODIES)
 }
 

compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/klib.kt

@@ -275,7 +275,11 @@ fun loadIr(
             val irLinker =
                 JsIrLinker(psi2IrContext.moduleDescriptor, messageLogger, irBuiltIns, symbolTable, functionFactory, feContext, null)
             val deserializedModuleFragments = sortDependencies(allDependencies, depsDescriptors.descriptors).map { klib ->
-                irLinker.deserializeIrModuleHeader(depsDescriptors.getModuleDescriptor(klib), klib).also { moduleFragment ->
+                irLinker.deserializeIrModuleHeader(
+                    depsDescriptors.getModuleDescriptor(klib),
+                    klib,
+                    deserializationStrategy = DeserializationStrategy.EXPLICITLY_EXPORTED
+                ).also { moduleFragment ->
                     klib.manifestProperties.getProperty(KLIB_PROPERTY_JS_OUTPUT_NAME)?.let {
                         moduleFragmentToUniqueName[moduleFragment] = it
                     }

compiler/tests-common/tests/org/jetbrains/kotlin/ir/AbstractKlibTextTestCase.kt

@@ -64,6 +64,7 @@ abstract class AbstractKlibTextTestCase : CodegenTestCase() {
 
     companion object {
         val SKIP_KLIB_TEST = Regex("""// SKIP_KLIB_TEST""")
+        const val MODULE_NAME = "testModule"
     }
 
     override fun doMultiFileTest(wholeFile: File, files: List<TestFile>) {
@@ -83,7 +84,7 @@ abstract class AbstractKlibTextTestCase : CodegenTestCase() {
             listOfNotNull(writeJavaFiles(files)),
             files
         )
-        configuration.put(CommonConfigurationKeys.MODULE_NAME, "testModule")
+        configuration.put(CommonConfigurationKeys.MODULE_NAME, MODULE_NAME)
         myEnvironment = KotlinCoreEnvironment.createForTests(testRootDisposable, configuration, EnvironmentConfigFiles.JS_CONFIG_FILES)
     }
 
@@ -194,7 +195,7 @@ abstract class AbstractKlibTextTestCase : CodegenTestCase() {
             metadata = serializedMetadata,
             dataFlowGraph = null,
             manifestProperties = properties,
-            moduleName = irModuleFragment.name.asString(),
+            moduleName = MODULE_NAME,
             nopack = true,
             perFile = false,
             output = klibDir.canonicalPath,

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

@@ -125,7 +125,7 @@ internal fun Context.psiToIr(
                         isProducingLibrary -> linker.deserializeOnlyHeaderModule(dependency, kotlinLibrary)
                         kotlinLibrary != null && config.cachedLibraries.isLibraryCached(kotlinLibrary) ->
                             linker.deserializeHeadersWithInlineBodies(dependency, kotlinLibrary)
-                        else -> linker.deserializeIrModuleHeader(dependency, kotlinLibrary)
+                        else -> linker.deserializeIrModuleHeader(dependency, kotlinLibrary, dependency.name.asString())
                     }
                 }
                 if (dependencies.size == dependenciesCount) break

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

@@ -20,11 +20,9 @@ import org.jetbrains.kotlin.backend.common.overrides.FakeOverrideBuilder
 import org.jetbrains.kotlin.backend.common.overrides.FakeOverrideClassFilter
 import org.jetbrains.kotlin.backend.common.serialization.*
 import org.jetbrains.kotlin.backend.common.serialization.encodings.BinarySymbolData
-import org.jetbrains.kotlin.backend.common.serialization.signature.IdSignatureSerializer
 import org.jetbrains.kotlin.backend.konan.CachedLibraries
 import org.jetbrains.kotlin.backend.konan.descriptors.isInteropLibrary
 import org.jetbrains.kotlin.backend.konan.ir.interop.IrProviderForCEnumAndCStructStubs
-import org.jetbrains.kotlin.backend.konan.ir.konanLibrary
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.konan.DeserializedKlibModuleOrigin
 import org.jetbrains.kotlin.descriptors.konan.isNativeStdlib
@@ -208,7 +206,7 @@ internal class KonanIrLinker(
             val descriptor = resolveDescriptor(idSig)
             val actualModule = descriptor.module
             if (actualModule !== moduleDescriptor) {
-                val moduleDeserializer = deserializersForModules[actualModule] ?: error("No module deserializer for $actualModule")
+                val moduleDeserializer = deserializersForModules[actualModule.name.asString()] ?: error("No module deserializer for $actualModule")
                 moduleDeserializer.addModuleReachableTopLevel(idSig)
                 return symbolTable.referenceClassFromLinker(idSig)
             }
@@ -220,18 +218,17 @@ internal class KonanIrLinker(
         override val moduleDependencies: Collection<IrModuleDeserializer> = emptyList()
     }
 
+    private val String.isForwardDeclarationModuleName: Boolean get() = this == "<forward declarations>"
+
     val modules: Map<String, IrModuleFragment>
         get() = mutableMapOf<String, IrModuleFragment>().apply {
             deserializersForModules
-                    .filter { !it.key.isForwardDeclarationModule && it.value.moduleDescriptor !== currentModule }
+                    .filter { !it.key.isForwardDeclarationModuleName && it.value.moduleDescriptor !== currentModule }
-                    .forEach { this.put(it.key.konanLibrary!!.libraryName, it.value.moduleFragment) }
+                    .forEach {
+                        val klib = it.value.klib as? KotlinLibrary ?: error("Expected to be KotlinLibrary (${it.key})")
+                        this[klib.libraryName] = it.value.moduleFragment
+                    }
         }
-    class KonanPluginContext(
-            override val moduleDescriptor: ModuleDescriptor,
-            override val symbolTable: ReferenceSymbolTable,
-            override val typeTranslator: TypeTranslator,
-            override val irBuiltIns: IrBuiltIns
-    ):TranslationPluginContext
 }
 
 class KonanIrModuleFragmentImpl(