[JS IC] Drop special IdSignatureSerializer for IC

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

@@ -39,8 +39,8 @@ class FakeOverrideGlobalDeclarationTable(
 
 open class FakeOverrideDeclarationTable(
     mangler: KotlinMangler.IrMangler,
-    signatureSerializerFactory: (PublicIdSignatureComputer, DeclarationTable) -> IdSignatureSerializer,
-    globalTable: FakeOverrideGlobalDeclarationTable = FakeOverrideGlobalDeclarationTable(mangler)
+    globalTable: FakeOverrideGlobalDeclarationTable = FakeOverrideGlobalDeclarationTable(mangler),
+    signatureSerializerFactory: (PublicIdSignatureComputer, DeclarationTable) -> IdSignatureSerializer
 ) : DeclarationTable(globalTable) {
     override val globalDeclarationTable: FakeOverrideGlobalDeclarationTable = globalTable
     override val signaturer: IdSignatureSerializer = signatureSerializerFactory(globalTable.publicIdSignatureComputer, this)
@@ -69,8 +69,9 @@ class FakeOverrideBuilder(
     mangler: KotlinMangler.IrMangler,
     typeSystem: IrTypeSystemContext,
     val platformSpecificClassFilter: FakeOverrideClassFilter = DefaultFakeOverrideClassFilter,
-    val signatureSerializerFactory: (PublicIdSignatureComputer, DeclarationTable) -> IdSignatureSerializer = ::IdSignatureSerializer,
-    private val fakeOverrideDeclarationTable: DeclarationTable = FakeOverrideDeclarationTable(mangler, signatureSerializerFactory),
+    private val fakeOverrideDeclarationTable: DeclarationTable = FakeOverrideDeclarationTable(mangler) { builder, table ->
+        IdSignatureSerializer(builder, table)
+    }
 ) : FakeOverrideBuilderStrategy() {
     private val haveFakeOverrides = mutableSetOf<IrClass>()
 

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

@@ -200,11 +200,14 @@ class PublicIdSignatureComputer(val mangler: KotlinMangler.IrMangler) : IdSignat
     }
 }
 
-open class IdSignatureSerializer(
+class IdSignatureSerializer(
     private val publicSignatureBuilder: PublicIdSignatureComputer,
     private val table: DeclarationTable,
+    startIndex: Int
 ) : IdSignatureComputer {
 
+    constructor(publicSignatureBuilder: PublicIdSignatureComputer, table: DeclarationTable) : this(publicSignatureBuilder, table, 0)
+
     private val mangler: KotlinMangler.IrMangler = publicSignatureBuilder.mangler
 
     override fun computeSignature(declaration: IrDeclaration): IdSignature {
@@ -217,8 +220,8 @@ open class IdSignatureSerializer(
         } else composeFileLocalIdSignature(declaration, compatibleMode)
     }
 
-    protected var localIndex: Long = 0
-    protected var scopeIndex: Int = 0
+    private var localIndex: Long = startIndex.toLong()
+    private var scopeIndex: Int = startIndex
 
     override fun inFile(file: IrFileSymbol?, block: () -> Unit) {
         publicSignatureBuilder.inFile(file, block)
@@ -236,19 +239,19 @@ open class IdSignatureSerializer(
 
         return table.privateDeclarationSignature(declaration, compatibleMode) {
             when (declaration) {
-                is IrValueDeclaration -> declaration.createScopeLocalSignature(scopeIndex++, declaration.name.asString())
-                is IrAnonymousInitializer -> declaration.createScopeLocalSignature(scopeIndex++, "ANON INIT")
-                is IrLocalDelegatedProperty -> declaration.createScopeLocalSignature(scopeIndex++, declaration.name.asString())
+                is IrValueDeclaration -> IdSignature.ScopeLocalDeclaration(scopeIndex++, declaration.name.asString())
+                is IrAnonymousInitializer -> IdSignature.ScopeLocalDeclaration(scopeIndex++, "ANON INIT")
+                is IrLocalDelegatedProperty -> IdSignature.ScopeLocalDeclaration(scopeIndex++, declaration.name.asString())
                 is IrField -> {
                     val p = declaration.correspondingPropertySymbol?.let { composeSignatureForDeclaration(it.owner, true) }
                         ?: composeContainerIdSignature(declaration.parent, compatibleMode)
-                    declaration.createFileLocalSignature(p, ++localIndex)
+                    IdSignature.FileLocalSignature(p, ++localIndex)
                 }
                 is IrSimpleFunction -> {
                     val parent = declaration.parent
                     val p = declaration.correspondingPropertySymbol?.let { composeSignatureForDeclaration(it.owner, true) }
                         ?: composeContainerIdSignature(parent, compatibleMode)
-                    declaration.createFileLocalSignature(
+                    IdSignature.FileLocalSignature(
                         p,
                         if (declaration.isOverridableFunction()) {
                             mangler.run { declaration.signatureMangle() }
@@ -260,9 +263,8 @@ open class IdSignatureSerializer(
                 }
                 is IrProperty -> {
                     val parent = declaration.parent
-                    declaration.createFileLocalSignature(
+                    IdSignature.FileLocalSignature(
                         composeContainerIdSignature(parent, compatibleMode),
-
                         if (declaration.isOverridableProperty()) {
                             mangler.run { declaration.signatureMangle() }
                         } else {
@@ -272,7 +274,7 @@ open class IdSignatureSerializer(
                     )
                 }
                 else -> {
-                    declaration.createFileLocalSignature(
+                    IdSignature.FileLocalSignature(
                         composeContainerIdSignature(declaration.parent, compatibleMode),
                         ++localIndex,
                         declaration.render()
@@ -281,12 +283,4 @@ open class IdSignatureSerializer(
             }
         }
     }
-
-    protected open fun IrDeclaration.createFileLocalSignature(parentSignature: IdSignature, localIndex: Long, description: String? = null): IdSignature {
-        return IdSignature.FileLocalSignature(parentSignature, localIndex, description)
-    }
-
-    protected open fun IrDeclaration.createScopeLocalSignature(scopeIndex: Int, description: String): IdSignature {
-        return IdSignature.ScopeLocalDeclaration(scopeIndex, description)
-    }
 }

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

@@ -8,7 +8,6 @@ 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.signature.IdSignatureSerializer
-import org.jetbrains.kotlin.backend.common.serialization.signature.PublicIdSignatureComputer
 import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.backend.js.JsMapping
 import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsGlobalDeclarationTable
@@ -79,7 +78,7 @@ class IcSerializer(
 
             val symbolToSignature = fileDeserializer.symbolDeserializer.deserializedSymbols.entries.associate { (idSig, symbol) -> symbol to idSig }.toMutableMap()
 
-            val icDeclarationTable = IcDeclarationTable(globalDeclarationTable, irFactory, 1000000, 1000000, symbolToSignature)
+            val icDeclarationTable = IcDeclarationTable(globalDeclarationTable, irFactory, 1000000, symbolToSignature)
             val fileSerializer = JsIrFileSerializer(
                 linker.messageLogger,
                 icDeclarationTable,
@@ -138,12 +137,12 @@ class IcSerializer(
     class IcDeclarationTable(
         globalDeclarationTable: JsGlobalDeclarationTable,
         val irFactory: PersistentIrFactory,
-        newLocalIndex: Long,
-        newScopeIndex: Int,
+        startIndex: Int,
         val existingMappings: MutableMap<IrSymbol, IdSignature>
     ) : DeclarationTable(globalDeclarationTable) {
 
-        override val signaturer: IdSignatureSerializer = IdSignatureSerializerWithForIC(globalDeclarationTable.publicIdSignatureComputer, this, newLocalIndex, newScopeIndex)
+        override val signaturer: IdSignatureSerializer =
+            IdSignatureSerializer(globalDeclarationTable.publicIdSignatureComputer, this, startIndex)
 
         override fun signatureByDeclaration(declaration: IrDeclaration, compatibleMode: Boolean): IdSignature {
             return existingMappings.getOrPut(declaration.symbol) {
@@ -153,18 +152,6 @@ class IcSerializer(
     }
 }
 
-class IdSignatureSerializerWithForIC(
-    publicSignatureBuilder: PublicIdSignatureComputer,
-    table: DeclarationTable,
-    localIndexOffset: Long = 0,
-    scopeIndexOffset: Int = 0,
-) : IdSignatureSerializer(publicSignatureBuilder, table) {
-    init {
-        localIndex = localIndexOffset
-        scopeIndex = scopeIndexOffset
-    }
-}
-
 fun storeOrder(file: IrFile, fileDeclarations: Iterable<IrDeclaration>, idSigToLong: (IrSymbol) -> Long): SerializedOrder {
     val topLevelSignatures = mutableListOf<Long>()
     val containerSignatures = mutableListOf<Long>()

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

@@ -7,12 +7,10 @@ package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir
 
 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.builders.TranslationPluginContext
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
@@ -35,14 +33,7 @@ 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))
 
     override fun isBuiltInModule(moduleDescriptor: ModuleDescriptor): Boolean =
         moduleDescriptor === moduleDescriptor.builtIns.builtInsModule

compiler/ir/serialization.jvm/src/org/jetbrains/kotlin/backend/jvm/serialization/deserializeLazyDeclarations.kt

@@ -250,7 +250,7 @@ private fun buildFakeOverridesForLocalClasses(
 
 class PrePopulatedDeclarationTable(
     sig2symbol: Map<IdSignature, IrSymbol>
-) : FakeOverrideDeclarationTable(JvmIrMangler, ::IdSignatureSerializer) {
+) : FakeOverrideDeclarationTable(JvmIrMangler, signatureSerializerFactory = ::IdSignatureSerializer) {
     private val symbol2Sig = sig2symbol.entries.associate { (x, y) -> y to x }
 
     override fun tryComputeBackendSpecificSignature(declaration: IrDeclaration): IdSignature? {