[JS IC] Lot of fixes after rebase

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

@@ -75,10 +75,11 @@ class IcFileDeserializer(
         linker.fakeOverrideBuilder.platformSpecificClassFilter,
         linker.fakeOverrideBuilder,
         allowRedeclaration = true,
+        compatibilityMode = CompatibilityMode.CURRENT
     )
 
     private fun deserializeOriginalPublicSymbol(idSig: IdSignature, symbolKind: BinarySymbolData.SymbolKind): IrSymbol {
-        assert(idSig.isPublic)
+        assert(idSig.isPubliclyVisible)
 
         val topLevelSig = idSig.topLevelSignature()
 
@@ -172,6 +173,7 @@ class IcFileDeserializer(
         additionalStatementOriginIndex = additionalStatementOriginIndex,
         allowErrorStatementOrigins = true,
         allowRedeclaration = true,
+        compatibilityMode = CompatibilityMode.CURRENT
     )
 
     private val protoFile: ProtoIrFile by lazy { ProtoIrFile.parseFrom(icFileData.file.fileData.codedInputStream, ExtensionRegistryLite.newInstance()) }
@@ -220,6 +222,7 @@ class IcFileDeserializer(
 
     private fun deserializePublicSymbol(idSig: IdSignature, kind: BinarySymbolData.SymbolKind) : IrSymbol {
         // TODO: reference lowered declarations cross-module
+        if (kind == BinarySymbolData.SymbolKind.FILE_SYMBOL) return (idSig as IdSignature.FileSignature).fileSymbol
         val topLevelSig = idSig.topLevelSignature()
         val actualModuleDeserializer =
             moduleDeserializer.findModuleDeserializerForTopLevelId(topLevelSig) ?:
@@ -314,4 +317,6 @@ private class FileReaderFromSerializedIrFile(val irFile: SerializedIrFile) : IrL
     override fun string(index: Int): ByteArray = stringReader.tableItemBytes(index)
 
     override fun body(index: Int): ByteArray = bodyReader.tableItemBytes(index)
+
+    override fun debugInfo(index: Int): ByteArray? = null
 }

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

@@ -13,16 +13,15 @@ import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsIrLinker
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrModuleFragmentImpl
 import org.jetbrains.kotlin.ir.declarations.persistent.PersistentIrFactory
-import org.jetbrains.kotlin.ir.symbols.IrFileSymbol
 import org.jetbrains.kotlin.ir.symbols.IrPropertySymbol
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
 import org.jetbrains.kotlin.ir.util.IdSignature
 import org.jetbrains.kotlin.ir.util.isEffectivelyExternal
 import org.jetbrains.kotlin.library.IrLibrary
+import org.jetbrains.kotlin.library.KotlinAbiVersion
 import org.jetbrains.kotlin.library.impl.IrLongArrayMemoryReader
 import org.jetbrains.kotlin.protobuf.ExtensionRegistryLite
-
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrFile as ProtoFile
 
 class IcModuleDeserializer(
@@ -35,7 +34,7 @@ class IcModuleDeserializer(
     override val strategy: DeserializationStrategy,
     private val containsErrorCode: Boolean = false,
     private val useGlobalSignatures: Boolean = false,
-) : IrModuleDeserializer(moduleDescriptor) {
+) : IrModuleDeserializer(moduleDescriptor, KotlinAbiVersion.CURRENT) {
 
     private val fileToDeserializerMap = mutableMapOf<IrFile, IrFileDeserializer>()
 
@@ -95,7 +94,7 @@ class IcModuleDeserializer(
     override fun contains(idSig: IdSignature): Boolean = idSig in moduleReversedFileIndex || idSig in icModuleReversedFileIndex
 
     override fun deserializeIrSymbol(idSig: IdSignature, symbolKind: BinarySymbolData.SymbolKind): IrSymbol {
-        assert(idSig.isPublic)
+        assert(idSig.isPubliclyVisible)
 
         if (idSig in icModuleReversedFileIndex) {
             val icDeserializer = icModuleReversedFileIndex[idSig]!!

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

@@ -5,10 +5,11 @@
 
 package org.jetbrains.kotlin.ir.backend.js.ic
 
+import org.jetbrains.kotlin.backend.common.serialization.CompatibilityMode
 import org.jetbrains.kotlin.backend.common.serialization.DeclarationTable
-import org.jetbrains.kotlin.backend.common.serialization.IdSignatureClashTracker
 import org.jetbrains.kotlin.backend.common.serialization.signature.IdSignatureSerializer
 import org.jetbrains.kotlin.backend.common.serialization.signature.PublicIdSignatureComputer
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.backend.js.JsMapping
 import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsGlobalDeclarationTable
@@ -18,11 +19,13 @@ import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.persistent.PersistentIrBodyBase
 import org.jetbrains.kotlin.ir.declarations.persistent.PersistentIrDeclarationBase
 import org.jetbrains.kotlin.ir.declarations.persistent.PersistentIrFactory
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
 import org.jetbrains.kotlin.ir.serialization.serializeCarriers
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
-import org.jetbrains.kotlin.ir.util.*
+import org.jetbrains.kotlin.ir.util.IdSignature
+import org.jetbrains.kotlin.ir.util.file
+import org.jetbrains.kotlin.ir.util.fileOrNull
+import org.jetbrains.kotlin.ir.util.isFakeOverride
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid
 import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid
 import org.jetbrains.kotlin.ir.visitors.acceptVoid
@@ -88,45 +91,48 @@ class IcSerializer(
                 skipExpects = true,
                 icMode = true,
                 allowNullTypes = true,
-                allowErrorStatementOrigins = true
+                allowErrorStatementOrigins = true,
+                compatibilityMode = CompatibilityMode.CURRENT
             )
 
-            bodies.forEach { body ->
-                if (body is IrExpressionBody) {
-                    fileSerializer.serializeIrExpressionBody(body.expression)
-                } else {
-                    fileSerializer.serializeIrStatementBody(body)
+            icDeclarationTable.inFile(file) {
+                bodies.forEach { body ->
+                    if (body is IrExpressionBody) {
+                        fileSerializer.serializeIrExpressionBody(body.expression)
+                    } else {
+                        fileSerializer.serializeIrStatementBody(body)
+                    }
                 }
+
+                // Only save newly created declarations
+                val newDeclarations = fileDeclarations.filter { d ->
+                    d is PersistentIrDeclarationBase<*> && (d.createdOn > 0 || /*d.isFakeOverride ||*/ (d is IrValueParameter || d is IrTypeParameter) && (d.parent as IrDeclaration).isFakeOverride)
+                }
+
+                val serializedCarriers = fileSerializer.serializeCarriers(
+                    fileDeclarations,
+                    bodies,
+                ) { declaration ->
+                    icDeclarationTable.signatureByDeclaration(declaration, compatibleMode = false)
+                }
+
+                val serializedMappings = mappings.state.serializeMappings(fileDeclarations) { symbol ->
+                    fileSerializer.serializeIrSymbol(symbol)
+                }
+
+                val order = storeOrder(file) { symbol ->
+                    fileSerializer.serializeIrSymbol(symbol)
+                }
+
+                val serializedIrFile = fileSerializer.serializeDeclarationsForIC(file, newDeclarations)
+
+                icData += SerializedIcDataForFile(
+                    serializedIrFile,
+                    serializedCarriers,
+                    serializedMappings,
+                    order,
+                )
             }
-
-            // Only save newly created declarations
-            val newDeclarations = fileDeclarations.filter { d ->
-                d is PersistentIrDeclarationBase<*> && (d.createdOn > 0 || /*d.isFakeOverride ||*/ (d is IrValueParameter || d is IrTypeParameter) && (d.parent as IrDeclaration).isFakeOverride)
-            }
-
-            val serializedCarriers = fileSerializer.serializeCarriers(
-                fileDeclarations,
-                bodies,
-            ) { declaration ->
-                icDeclarationTable.signatureByDeclaration(declaration)
-            }
-
-            val serializedMappings = mappings.state.serializeMappings(fileDeclarations) { symbol ->
-                fileSerializer.serializeIrSymbol(symbol)
-            }
-
-            val order = storeOrder(file) { symbol ->
-                fileSerializer.serializeIrSymbol(symbol)
-            }
-
-            val serializedIrFile = fileSerializer.serializeDeclarationsForIC(file, newDeclarations)
-
-            icData += SerializedIcDataForFile(
-                serializedIrFile,
-                serializedCarriers,
-                serializedMappings,
-                order,
-            )
         }
 
         return SerializedIcData(icData)
@@ -143,9 +149,9 @@ class IcSerializer(
 
         override val signaturer: IdSignatureSerializer = IdSignatureSerializerWithForIC(globalDeclarationTable.publicIdSignatureComputer, this, newLocalIndex, newScopeIndex)
 
-        override fun signatureByDeclaration(declaration: IrDeclaration): IdSignature {
+        override fun signatureByDeclaration(declaration: IrDeclaration, compatibleMode: Boolean): IdSignature {
             return existingMappings.getOrPut(declaration.symbol) {
-                irFactory.declarationSignature(declaration) ?: super.signatureByDeclaration(declaration)
+                irFactory.declarationSignature(declaration) ?: super.signatureByDeclaration(declaration, compatibleMode)
             }
         }
     }
@@ -165,7 +171,7 @@ class IdSignatureSerializerWithForIC(
         scopeIndex = scopeIndexOffset
     }
 
-    override fun IrDeclaration.createFileLocalSignature(parentSignature: IdSignature, localIndex: Long): IdSignature {
+    override fun IrDeclaration.createFileLocalSignature(parentSignature: IdSignature, localIndex: Long, description: String?): IdSignature {
         if (this is IrTypeParameter) {
             return IdSignature.GlobalFileLocalSignature(parentSignature, 1000_000_000_000L + index, fileOrNull?.path ?: "")
         }

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

@@ -13,7 +13,6 @@ import org.jetbrains.kotlin.library.impl.IrArrayMemoryReader
 import org.jetbrains.kotlin.library.impl.IrMemoryArrayWriter
 import org.jetbrains.kotlin.library.impl.toArray
 import java.io.File
-import java.nio.charset.Charset
 
 class SerializedIcData(
     val files: Collection<SerializedIcDataForFile>,
@@ -85,7 +84,8 @@ fun File.readIcData(): SerializedIcData {
             signatures = File(fileDir, "file.signatures").readBytes(),
             strings = File(fileDir, "file.strings").readBytes(),
             bodies = File(fileDir, "file.bodies").readBytes(),
-            declarations = File(fileDir, "file.declarations").readBytes()
+            declarations = File(fileDir, "file.declarations").readBytes(),
+            debugInfo = null
         )
 
         val carriers = SerializedCarriers(

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

@@ -171,7 +171,7 @@ fun generateKLib(
     val depsDescriptors =
         ModulesStructure(project, MainModule.SourceFiles(files), analyzer, configuration, dependencies, friendDependencies, EmptyLoweringsCacheProvider)
     val allDependencies = depsDescriptors.allDependencies
-    val (psi2IrContext, hasErrors) = runAnalysisAndPreparePsi2Ir(depsDescriptors, SymbolTable(IdSignatureDescriptor(JsManglerDesc), irFactory, errorPolicy)
+    val (psi2IrContext, hasErrors) = runAnalysisAndPreparePsi2Ir(depsDescriptors, errorPolicy, SymbolTable(IdSignatureDescriptor(JsManglerDesc), irFactory))
     val irBuiltIns = psi2IrContext.irBuiltIns
 
     val expectDescriptorToSymbol = mutableMapOf<DeclarationDescriptor, IrSymbol>()
@@ -255,6 +255,7 @@ object EmptyLoweringsCacheProvider : LoweringsCacheProvider {
     override fun cacheByPath(path: String): SerializedIcData? = null
 }
 
+@OptIn(ObsoleteDescriptorBasedAPI::class)
 fun loadIr(
     project: Project,
     mainModule: MainModule,
@@ -278,13 +279,11 @@ fun loadIr(
         is MainModule.SourceFiles -> {
             val (psi2IrContext, _) = runAnalysisAndPreparePsi2Ir(depsDescriptors, errorPolicy, symbolTable)
             val irBuiltIns = psi2IrContext.irBuiltIns
-            val symbolTable = psi2IrContext.symbolTable
             val feContext = psi2IrContext.run {
                 JsIrLinker.JsFePluginContext(moduleDescriptor, symbolTable, typeTranslator, irBuiltIns)
             }
             val moduleFragmentToUniqueName = mutableMapOf<IrModuleFragment, String>()
             val irLinker =
-                JsIrLinker(psi2IrContext.moduleDescriptor, messageLogger, irBuiltIns, symbolTable, feContext, null)
                 JsIrLinker(
                     psi2IrContext.moduleDescriptor,
                     messageLogger,
@@ -322,19 +321,18 @@ fun loadIr(
             }
 
             if (verifySignatures) {
-                (irBuiltIns as IrBuiltInsOverDescriptors).knownBuiltins.forEach { it.acceptVoid(mangleChecker) }
+                irBuiltIns.knownBuiltins.forEach { it.acceptVoid(mangleChecker) }
             }
 
             return IrModuleInfo(moduleFragment, deserializedModuleFragments, irBuiltIns, symbolTable, irLinker, moduleFragmentToUniqueName,
                                 depsDescriptors.modulesWithCaches(deserializedModuleFragments))
         }
         is MainModule.Klib -> {
-            val mainModuleLib = depsDescriptors.allDependencies.find { it.library.libraryFile.canonicalPath == mainModule.libPath }?.library
-                ?: error("No module with ${mainModule.libPath} found")
+            val mainPath = File(mainModule.libPath).canonicalPath
+            val mainModuleLib =
+                depsDescriptors.allDependencies.find { it.library.libraryFile.canonicalPath == mainPath }?.library
+                    ?: error("No module with ${mainModule.libPath} found")
             val moduleDescriptor = depsDescriptors.getModuleDescriptor(mainModuleLib)
-            val mangler = JsManglerDesc
-            val signaturer = IdSignatureDescriptor(mangler)
-            val symbolTable = SymbolTable(signaturer, irFactory)
             val typeTranslator =
                 TypeTranslatorImpl(symbolTable, depsDescriptors.compilerConfiguration.languageVersionSettings, moduleDescriptor)
             val irBuiltIns = IrBuiltInsOverDescriptors(moduleDescriptor.builtIns, typeTranslator, symbolTable)
@@ -346,7 +344,8 @@ fun loadIr(
                     val path = lib.libraryFile.absolutePath
                     val icData = loweringsCacheProvider.cacheByPath(path)
                     if (icData != null) {
-                        result[depsDescriptors.getModuleDescriptor(lib)] = icData
+                        val desc = depsDescriptors.getModuleDescriptor(lib)
+                        result[desc] = icData
                     }
                 }
 
@@ -367,7 +366,11 @@ fun loadIr(
 
             val moduleFragmentToUniqueName = mutableMapOf<IrModuleFragment, String>()
 
-            val deserializedModuleFragments = sortDependencies(allDependencies, depsDescriptors.descriptors).map { klib ->
+            val reachableDependencies = depsDescriptors.allResolvedDependencies.filterRoots {
+                it.library.libraryFile.canonicalPath == mainPath
+            }
+
+            val deserializedModuleFragments = sortDependencies(reachableDependencies.getFullResolvedList(), depsDescriptors.descriptors).map { klib ->
                 val strategy =
                     if (klib == mainModuleLib)
                         DeserializationStrategy.ALL
@@ -478,11 +481,13 @@ private class ModulesStructure(
     friendDependenciesPaths: Collection<String>,
     private val loweringsCacheProvider: LoweringsCacheProvider
 ) {
-    val allDependencies = jsResolveLibraries(
+    val allResolvedDependencies = jsResolveLibraries(
         dependencies,
         compilerConfiguration[JSConfigurationKeys.REPOSITORIES] ?: emptyList(),
         compilerConfiguration[IrMessageLogger.IR_MESSAGE_LOGGER].toResolverLogger()
-    ).getFullResolvedList()
+    )
+
+    val allDependencies = allResolvedDependencies.getFullResolvedList()
 
     val friendDependencies = allDependencies.run {
         val friendAbsolutePaths = friendDependenciesPaths.map { File(it).canonicalPath }

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

@@ -9,19 +9,17 @@ import org.jetbrains.kotlin.backend.common.serialization.IrModuleDeserializer
 import org.jetbrains.kotlin.backend.common.serialization.IrModuleDeserializerWithBuiltIns
 import org.jetbrains.kotlin.backend.common.serialization.encodings.BinarySymbolData
 import org.jetbrains.kotlin.backend.common.serialization.knownBuiltins
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
 import org.jetbrains.kotlin.ir.declarations.IrSymbolOwner
 import org.jetbrains.kotlin.ir.declarations.IrTypeParametersContainer
-import org.jetbrains.kotlin.ir.descriptors.IrAbstractFunctionFactory
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
 import org.jetbrains.kotlin.ir.util.IdSignature
 
 class IrIcModuleDeserializerWithBuiltIns(
     builtIns: IrBuiltIns,
-    functionFactory: IrAbstractFunctionFactory,
     delegate: IrModuleDeserializer,
-) : IrModuleDeserializerWithBuiltIns(builtIns, functionFactory, delegate) {
+) : IrModuleDeserializerWithBuiltIns(builtIns, delegate) {
 
     override fun additionalBuiltIns(builtIns: IrBuiltIns): Map<IdSignature, IrSymbol> {
         val result = mutableMapOf<IdSignature, IrSymbol>()

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

@@ -9,16 +9,14 @@ import org.jetbrains.kotlin.backend.common.overrides.FakeOverrideBuilder
 import org.jetbrains.kotlin.backend.common.serialization.*
 import org.jetbrains.kotlin.backend.common.serialization.signature.IdSignatureSerializer
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.backend.js.JsMapping
 import org.jetbrains.kotlin.ir.backend.js.ic.IcModuleDeserializer
 import org.jetbrains.kotlin.ir.backend.js.ic.IdSignatureSerializerWithForIC
 import org.jetbrains.kotlin.ir.backend.js.ic.SerializedIcData
-import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.builders.TranslationPluginContext
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 import org.jetbrains.kotlin.ir.declarations.persistent.PersistentIrFactory
-import org.jetbrains.kotlin.ir.descriptors.IrAbstractFunctionFactory
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.types.IrTypeSystemContextImpl
 import org.jetbrains.kotlin.ir.util.IrMessageLogger
 import org.jetbrains.kotlin.ir.util.ReferenceSymbolTable
@@ -37,10 +35,14 @@ class JsIrLinker(
     private val useGlobalSignatures: Boolean = false,
 ) : KotlinIrLinker(currentModule, messageLogger, builtIns, symbolTable, emptyList()) {
 
-    override val fakeOverrideBuilder = FakeOverrideBuilder(this, symbolTable, JsManglerIr, IrTypeSystemContextImpl(builtIns),
-                                                           signatureSerializerFactory = { publicSignatureBuilder, table ->
-        if (useGlobalSignatures) IdSignatureSerializerWithForIC(publicSignatureBuilder, table) else IdSignatureSerializer(publicSignatureBuilder, table)
-    })
+    override val fakeOverrideBuilder = FakeOverrideBuilder(
+        this, symbolTable, JsManglerIr, IrTypeSystemContextImpl(builtIns), signatureSerializerFactory = { publicSignatureBuilder, table ->
+            if (useGlobalSignatures) IdSignatureSerializerWithForIC(publicSignatureBuilder, table) else IdSignatureSerializer(
+                publicSignatureBuilder,
+                table
+            )
+        }
+    )
 
     override fun isBuiltInModule(moduleDescriptor: ModuleDescriptor): Boolean =
         moduleDescriptor === moduleDescriptor.builtIns.builtInsModule
@@ -48,7 +50,7 @@ class JsIrLinker(
     private val IrLibrary.libContainsErrorCode: Boolean
         get() = this is KotlinLibrary && this.containsErrorCode
 
-    override fun createModuleDeserializer(moduleDescriptor: ModuleDescriptor, klib: IrLibrary?, strategy: DeserializationStrategy): IrModuleDeserializer {
+    override fun createModuleDeserializer(moduleDescriptor: ModuleDescriptor, klib: KotlinLibrary?, strategy: DeserializationStrategy): IrModuleDeserializer {
         require(klib != null) { "Expecting kotlin library" }
         loweredIcData[moduleDescriptor]?.let { loweredIcData ->
             return IcModuleDeserializer(
@@ -63,14 +65,12 @@ class JsIrLinker(
                 useGlobalSignatures = useGlobalSignatures
             )
         }
-        return klib?.let { lib ->
-            JsModuleDeserializer(moduleDescriptor, lib, strategy, lib.versions.abiVersion ?: KotlinAbiVersion.CURRENT, lib.libContainsErrorCode)
-        } ?: error("Expecting kotlin library")
+        return JsModuleDeserializer(moduleDescriptor, klib, strategy, klib.versions.abiVersion ?: KotlinAbiVersion.CURRENT, klib.libContainsErrorCode)
     }
 
     val mapping: JsMapping by lazy { JsMapping(symbolTable.irFactory) }
 
-    private inner class JsModuleDeserializer(moduleDescriptor: ModuleDescriptor, klib: IrLibrary, strategy: DeserializationStrategy, allowErrorCode: Boolean) :
+    private inner class JsModuleDeserializer(moduleDescriptor: ModuleDescriptor, klib: IrLibrary, strategy: DeserializationStrategy, libraryAbiVersion: KotlinAbiVersion, allowErrorCode: Boolean) :
         BasicIrModuleDeserializer(this, moduleDescriptor, klib, strategy, libraryAbiVersion, allowErrorCode, useGlobalSignatures)
 
     override fun maybeWrapWithBuiltInAndInit(
@@ -79,9 +79,9 @@ class JsIrLinker(
     ): IrModuleDeserializer {
         return if (isBuiltInModule(moduleDescriptor)) {
             if (useGlobalSignatures) {
-                IrIcModuleDeserializerWithBuiltIns(builtIns, functionalInterfaceFactory, moduleDeserializer)
+                IrIcModuleDeserializerWithBuiltIns(builtIns, moduleDeserializer)
             } else {
-                IrModuleDeserializerWithBuiltIns(builtIns, functionalInterfaceFactory, moduleDeserializer)
+                IrModuleDeserializerWithBuiltIns(builtIns, moduleDeserializer)
             }
         } else moduleDeserializer
     }
@@ -103,7 +103,7 @@ class JsIrLinker(
 
 
     fun moduleDeserializer(moduleDescriptor: ModuleDescriptor): IrModuleDeserializer {
-        return deserializersForModules[moduleDescriptor] ?: error("Deserializer for $moduleDescriptor not found")
+        return deserializersForModules[moduleDescriptor.name.asString()] ?: error("Deserializer for $moduleDescriptor not found")
     }
 
     fun loadIcIr(preprocess: (IrModuleFragment) -> Unit) {