[klib] Implement diagnostics for clashing KLIB signatures

Now, we detect clashing signatures during serialization to KLIB and
report a compiler error if two or more declarations have the same
`IdSignature`

For example, for the following code:
```kotlin
@Deprecated("", level = DeprecationLevel.HIDDEN)
fun foo(): String = ""

fun foo(): Int = 0
```

the compiler will produce this diagnostic:
```
e: main.kt:1:1 Platform declaration clash: The following declarations
       have the same KLIB signature (/foo|foo(){}[0]):
    fun foo(): String defined in root package
    fun foo(): Int defined in root package
e: main.kt:4:1 Platform declaration clash: The following declarations
       have the same KLIB signature (/foo|foo(){}[0]):
    fun foo(): String defined in root package
    fun foo(): Int defined in root package
```

Note that we report this diagnostic during serialization and not earlier
(e.g., in fir2ir) for more robustness, so ensure that we check
exactly the signatures that will be written to a KLIB.
If we later introduce some annotation for customizing a declaration's
signature (e.g., for preserving binary compatibility), this
diagnostic will continue to work as expected.

^KT-63670 Fixed

compiler/frontend.common-psi/src/org/jetbrains/kotlin/diagnostics/rendering/CommonRenderers.kt

@@ -9,6 +9,7 @@ import com.intellij.openapi.util.text.StringUtil
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.types.Variance
+import org.jetbrains.kotlin.utils.addToStdlib.joinToWithBuffer
 import java.io.PrintWriter
 import java.io.StringWriter
 
@@ -63,4 +64,27 @@ object CommonRenderers {
             }
         }
     }
+
+    @JvmStatic
+    fun <Declaration, Data> renderConflictingSignatureData(
+        signatureKind: String,
+        sortUsing: Comparator<Declaration>,
+        declarationRenderer: DiagnosticParameterRenderer<Declaration>,
+        renderSignature: StringBuilder.(Data) -> Unit,
+        declarations: (Data) -> Collection<Declaration>,
+    ) = Renderer<Data> { data ->
+        val sortedDeclarations = declarations(data).sortedWith(sortUsing)
+        val renderingContext = RenderingContext.Impl(sortedDeclarations)
+        buildString {
+            append("The following declarations have the same ")
+            append(signatureKind)
+            append(" signature (")
+            renderSignature(data)
+            appendLine("):")
+            sortedDeclarations.joinToWithBuffer(this, separator = "\n") { descriptor ->
+                append("    ")
+                append(declarationRenderer.render(descriptor, renderingContext))
+            }
+        }
+    }
 }

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/JvmBackendErrors.kt

@@ -11,12 +11,14 @@ import org.jetbrains.kotlin.diagnostics.SourceElementPositioningStrategies.DECLA
 import org.jetbrains.kotlin.diagnostics.error0
 import org.jetbrains.kotlin.diagnostics.error1
 import org.jetbrains.kotlin.diagnostics.error2
-import org.jetbrains.kotlin.diagnostics.rendering.*
+import org.jetbrains.kotlin.diagnostics.rendering.BaseDiagnosticRendererFactory
+import org.jetbrains.kotlin.diagnostics.rendering.CommonRenderers
 import org.jetbrains.kotlin.diagnostics.rendering.CommonRenderers.NAME
 import org.jetbrains.kotlin.diagnostics.rendering.CommonRenderers.STRING
+import org.jetbrains.kotlin.diagnostics.rendering.Renderers
+import org.jetbrains.kotlin.diagnostics.rendering.RootDiagnosticRendererFactory
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.MemberComparator
-import org.jetbrains.kotlin.utils.join
 
 object JvmBackendErrors {
     val CONFLICTING_JVM_DECLARATIONS by error1<PsiElement, ConflictingJvmDeclarationsData>(DECLARATION_SIGNATURE_OR_DEFAULT)
@@ -48,17 +50,16 @@ object JvmBackendErrors {
 object KtDefaultJvmErrorMessages : BaseDiagnosticRendererFactory() {
 
     @JvmField
-    val CONFLICTING_JVM_DECLARATIONS_DATA = Renderer<ConflictingJvmDeclarationsData> {
-        val renderedDescriptors = it.signatureDescriptors.sortedWith(MemberComparator.INSTANCE)
-        val renderingContext = RenderingContext.Impl(renderedDescriptors)
-        """
-                The following declarations have the same JVM signature (${it.signature.name}${it.signature.desc}):
-                
-                """.trimIndent() +
-                join(renderedDescriptors.map { descriptor ->
-                    "    " + Renderers.WITHOUT_MODIFIERS.render(descriptor, renderingContext)
-                }, "\n")
-    }
+    val CONFLICTING_JVM_DECLARATIONS_DATA = CommonRenderers.renderConflictingSignatureData(
+        signatureKind = "JVM",
+        sortUsing = MemberComparator.INSTANCE,
+        declarationRenderer = Renderers.WITHOUT_MODIFIERS,
+        renderSignature = {
+            append(it.signature.name)
+            append(it.signature.desc)
+        },
+        declarations = ConflictingJvmDeclarationsData::signatureDescriptors,
+    )
 
     override val MAP = KtDiagnosticFactoryToRendererMap("KT").also { map ->
         map.put(JvmBackendErrors.CONFLICTING_JVM_DECLARATIONS, "Platform declaration clash: {0}", CONFLICTING_JVM_DECLARATIONS_DATA)

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/Renderers.kt

@@ -31,13 +31,14 @@ import org.jetbrains.kotlin.diagnostics.rendering.TabledDescriptorRenderer.newTe
 import org.jetbrains.kotlin.name.FqNameUnsafe
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.isCommon
-import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.renderer.AnnotationArgumentsRenderingPolicy
+import org.jetbrains.kotlin.psi.KtClass
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.renderer.DescriptorRenderer.Companion.DEBUG_TEXT
-import org.jetbrains.kotlin.renderer.DescriptorRendererModifier
 import org.jetbrains.kotlin.renderer.PropertyAccessorRenderingPolicy
-import org.jetbrains.kotlin.resolve.*
+import org.jetbrains.kotlin.resolve.DescriptorUtils
+import org.jetbrains.kotlin.resolve.MemberComparator
 import org.jetbrains.kotlin.resolve.calls.inference.*
 import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.Bound
 import org.jetbrains.kotlin.resolve.calls.inference.TypeBounds.BoundKind.LOWER_BOUND
@@ -52,6 +53,7 @@ import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.utils.IDEAPlatforms
 import org.jetbrains.kotlin.utils.IDEAPluginsCompatibilityAPI
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
+import org.jetbrains.kotlin.utils.addToStdlib.joinToWithBuffer
 
 object Renderers {
 
@@ -706,9 +708,7 @@ object Renderers {
     @JvmField
     val COMPACT_WITHOUT_SUPERTYPES = DescriptorRenderer.COMPACT_WITHOUT_SUPERTYPES.asRenderer()
     @JvmField
-    val WITHOUT_MODIFIERS = DescriptorRenderer.withOptions {
-        modifiers = emptySet()
-    }.asRenderer()
+    val WITHOUT_MODIFIERS = DescriptorRenderer.WITHOUT_MODIFIERS.asRenderer()
     @JvmField
     val SHORT_NAMES_IN_TYPES = DescriptorRenderer.SHORT_NAMES_IN_TYPES.asRenderer()
     @JvmField

compiler/ir/serialization.common/build.gradle.kts

@@ -10,6 +10,7 @@ dependencies {
     api(project(":kotlin-util-klib-metadata"))
     api(project(":compiler:util"))
     implementation(project(":compiler:psi"))
+    implementation(project(":compiler:frontend.common-psi"))
     compileOnly(commonDependency("org.jetbrains.kotlin:kotlin-reflect")) { isTransitive = false }
     compileOnly(commonDependency("org.jetbrains.intellij.deps.fastutil:intellij-deps-fastutil"))
 

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

@@ -0,0 +1,11 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.backend.common.diagnostics
+
+import org.jetbrains.kotlin.ir.declarations.IrDeclaration
+import org.jetbrains.kotlin.ir.util.IdSignature
+
+internal data class ConflictingKlibSignaturesData(val signature: IdSignature, val declarations: Collection<IrDeclaration>)

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

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.backend.common.diagnostics
+
+import org.jetbrains.kotlin.ir.IrDiagnosticReporter
+import org.jetbrains.kotlin.ir.declarations.IrDeclaration
+import org.jetbrains.kotlin.ir.linkage.SignatureClashDetector
+import org.jetbrains.kotlin.ir.util.IdSignature
+import org.jetbrains.kotlin.ir.util.file
+import org.jetbrains.kotlin.ir.util.parentClassOrNull
+
+class IdSignatureClashDetector : SignatureClashDetector<IdSignature, IrDeclaration>() {
+    override fun reportSignatureConflict(
+        signature: IdSignature,
+        declarations: Collection<IrDeclaration>,
+        diagnosticReporter: IrDiagnosticReporter
+    ) {
+        reportSignatureClashTo(
+            diagnosticReporter,
+            SerializationErrors.CONFLICTING_KLIB_SIGNATURES_ERROR,
+            declarations,
+            ConflictingKlibSignaturesData(signature, declarations),
+            reportOnIfSynthetic = { it.parentClassOrNull ?: it.file },
+        )
+    }
+}

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

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.backend.common.diagnostics
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.backend.common.diagnostics.SerializationDiagnosticRenderers.CONFLICTING_KLIB_SIGNATURES_DATA
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.diagnostics.KtDiagnosticFactoryToRendererMap
+import org.jetbrains.kotlin.diagnostics.error1
+import org.jetbrains.kotlin.diagnostics.rendering.BaseDiagnosticRendererFactory
+import org.jetbrains.kotlin.diagnostics.rendering.CommonRenderers
+import org.jetbrains.kotlin.diagnostics.rendering.Renderer
+import org.jetbrains.kotlin.diagnostics.rendering.RootDiagnosticRendererFactory
+import org.jetbrains.kotlin.ir.declarations.IrDeclaration
+import org.jetbrains.kotlin.ir.descriptors.toIrBasedDescriptor
+import org.jetbrains.kotlin.ir.util.render
+import org.jetbrains.kotlin.renderer.DescriptorRenderer
+import org.jetbrains.kotlin.resolve.MemberComparator
+
+internal object SerializationErrors {
+    val CONFLICTING_KLIB_SIGNATURES_ERROR by error1<PsiElement, ConflictingKlibSignaturesData>()
+
+    init {
+        RootDiagnosticRendererFactory.registerFactory(KtDefaultSerializationErrorMessages)
+    }
+}
+
+internal object KtDefaultSerializationErrorMessages : BaseDiagnosticRendererFactory() {
+    override val MAP = KtDiagnosticFactoryToRendererMap("KT").also { map ->
+        map.put(
+            SerializationErrors.CONFLICTING_KLIB_SIGNATURES_ERROR,
+            "Platform declaration clash: {0}",
+            CONFLICTING_KLIB_SIGNATURES_DATA,
+        )
+    }
+}
+
+internal object SerializationDiagnosticRenderers {
+    val CONFLICTING_KLIB_SIGNATURES_DATA =
+        CommonRenderers.renderConflictingSignatureData<DeclarationDescriptor, ConflictingKlibSignaturesData>(
+            signatureKind = "KLIB",
+            sortUsing = MemberComparator.INSTANCE,
+            declarationRenderer = Renderer {
+                DescriptorRenderer.WITHOUT_MODIFIERS.render(it)
+            },
+            renderSignature = { append(it.signature.render()) },
+            declarations = { it.declarations.map(IrDeclaration::toIrBasedDescriptor) },
+        )
+}

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

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.backend.common.serialization
 
+import org.jetbrains.kotlin.backend.common.diagnostics.IdSignatureClashDetector
 import org.jetbrains.kotlin.backend.common.serialization.signature.IdSignatureFactory
 import org.jetbrains.kotlin.backend.common.serialization.signature.PublicIdSignatureComputer
 import org.jetbrains.kotlin.ir.IrBuiltIns
@@ -15,37 +16,24 @@ import org.jetbrains.kotlin.ir.util.IdSignature
 import org.jetbrains.kotlin.ir.util.KotlinMangler
 import org.jetbrains.kotlin.ir.util.render
 
-
-interface IdSignatureClashTracker {
-    fun commit(declaration: IrDeclaration, signature: IdSignature)
-
-    companion object {
-        val DEFAULT_TRACKER = object : IdSignatureClashTracker {
-            override fun commit(declaration: IrDeclaration, signature: IdSignature) {}
-        }
-    }
-}
-
-abstract class GlobalDeclarationTable(
-    private val mangler: KotlinMangler.IrMangler,
-    private val clashTracker: IdSignatureClashTracker
-) {
+abstract class GlobalDeclarationTable(private val mangler: KotlinMangler.IrMangler) {
     val publicIdSignatureComputer = PublicIdSignatureComputer(mangler)
+    internal val clashDetector = IdSignatureClashDetector()
 
     protected val table = hashMapOf<IrDeclaration, IdSignature>()
 
-    constructor(mangler: KotlinMangler.IrMangler) : this(mangler, IdSignatureClashTracker.DEFAULT_TRACKER)
-
     protected fun loadKnownBuiltins(builtIns: IrBuiltIns) {
         builtIns.knownBuiltins.forEach {
             val symbol = (it as IrSymbolOwner).symbol
-            table[it] = symbol.signature!!.also { id -> clashTracker.commit(it, id) }
+            table[it] = symbol.signature!!.also { id -> clashDetector.trackDeclaration(it, id) }
         }
     }
 
     open fun computeSignatureByDeclaration(declaration: IrDeclaration, compatibleMode: Boolean): IdSignature {
         return table.getOrPut(declaration) {
-            publicIdSignatureComputer.composePublicIdSignature(declaration, compatibleMode).also { clashTracker.commit(declaration, it) }
+            publicIdSignatureComputer.composePublicIdSignature(declaration, compatibleMode).also {
+                clashDetector.trackDeclaration(declaration, it)
+            }
         }
     }
 

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

@@ -6,14 +6,23 @@
 package org.jetbrains.kotlin.backend.common.serialization
 
 import org.jetbrains.kotlin.builtins.FunctionInterfacePackageFragment
+import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
+import org.jetbrains.kotlin.ir.IrDiagnosticReporter
 import org.jetbrains.kotlin.ir.declarations.IrFile
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 import org.jetbrains.kotlin.ir.util.IrMessageLogger
 import org.jetbrains.kotlin.library.SerializedIrFile
 import org.jetbrains.kotlin.library.SerializedIrModule
 
-abstract class IrModuleSerializer<F : IrFileSerializer>(protected val messageLogger: IrMessageLogger, protected val compatibilityMode: CompatibilityMode, protected val normalizeAbsolutePaths: Boolean, protected val sourceBaseDirs: Collection<String>) {
-    abstract fun createSerializerForFile(file: IrFile): F
+abstract class IrModuleSerializer<Serializer : IrFileSerializer>(
+    protected val diagnosticReporter: IrDiagnosticReporter,
+    protected val messageLogger: IrMessageLogger,
+    protected val compatibilityMode: CompatibilityMode,
+    protected val normalizeAbsolutePaths: Boolean,
+    protected val sourceBaseDirs: Collection<String>,
+    private val shouldCheckSignaturesOnUniqueness: Boolean,
+) {
+    abstract fun createSerializerForFile(file: IrFile): Serializer
 
     /**
      * Allows to skip [file] during serialization.
@@ -23,6 +32,8 @@ abstract class IrModuleSerializer<F : IrFileSerializer>(protected val messageLog
     protected open fun backendSpecificFileFilter(file: IrFile): Boolean =
         true
 
+    protected abstract val globalDeclarationTable: GlobalDeclarationTable
+
     private fun serializeIrFile(file: IrFile): SerializedIrFile {
         val fileSerializer = createSerializerForFile(file)
         return fileSerializer.serializeIrFile(file)
@@ -33,6 +44,9 @@ abstract class IrModuleSerializer<F : IrFileSerializer>(protected val messageLog
             .filter { it.packageFragmentDescriptor !is FunctionInterfacePackageFragment }
             .filter(this::backendSpecificFileFilter)
             .map(this::serializeIrFile)
+        if (shouldCheckSignaturesOnUniqueness) {
+            globalDeclarationTable.clashDetector.reportErrorsTo(diagnosticReporter)
+        }
         return SerializedIrModule(serializedFiles)
     }
 }

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

@@ -631,7 +631,7 @@ fun serializeModuleIntoKlib(
     val compatibilityMode = CompatibilityMode(abiVersion)
     val sourceBaseDirs = configuration[CommonConfigurationKeys.KLIB_RELATIVE_PATH_BASES] ?: emptyList()
     val absolutePathNormalization = configuration[CommonConfigurationKeys.KLIB_NORMALIZE_ABSOLUTE_PATH] ?: false
-    val signatureClashChecks = configuration[CommonConfigurationKeys.PRODUCE_KLIB_SIGNATURES_CLASH_CHECKS] ?: false
+    val signatureClashChecks = configuration[CommonConfigurationKeys.PRODUCE_KLIB_SIGNATURES_CLASH_CHECKS] ?: true
 
     val moduleExportedNames = moduleFragment.collectExportedNames()
 
@@ -643,6 +643,7 @@ fun serializeModuleIntoKlib(
 
     val serializedIr =
         JsIrModuleSerializer(
+            irDiagnosticReporter,
             messageLogger,
             moduleFragment.irBuiltins,
             compatibilityMode,
@@ -650,8 +651,7 @@ fun serializeModuleIntoKlib(
             sourceBaseDirs = sourceBaseDirs,
             configuration.languageVersionSettings,
             signatureClashChecks,
-            jsIrFileMetadataFactory = { JsIrFileMetadata(moduleExportedNames[it]?.values?.toSmartList() ?: emptyList()) }
-        ).serializedIrModule(moduleFragment)
+        ) { JsIrFileMetadata(moduleExportedNames[it]?.values?.toSmartList() ?: emptyList()) }.serializedIrModule(moduleFragment)
 
     val moduleDescriptor = moduleFragment.descriptor
 

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

@@ -6,36 +6,9 @@
 package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir
 
 import org.jetbrains.kotlin.backend.common.serialization.GlobalDeclarationTable
-import org.jetbrains.kotlin.backend.common.serialization.IdSignatureClashTracker
 import org.jetbrains.kotlin.ir.IrBuiltIns
-import org.jetbrains.kotlin.ir.declarations.IrDeclaration
-import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
-import org.jetbrains.kotlin.ir.declarations.IrTypeParameter
-import org.jetbrains.kotlin.ir.util.IdSignature
-import org.jetbrains.kotlin.ir.util.render
 
-class JsUniqIdClashTracker() : IdSignatureClashTracker {
-    private val committedIdSignatures = mutableMapOf<IdSignature, IrDeclaration>()
-
-    override fun commit(declaration: IrDeclaration, signature: IdSignature) {
-        if (!signature.isPubliclyVisible) return // don't track local ids
-
-        if (signature in committedIdSignatures) {
-            val clashedDeclaration = committedIdSignatures[signature]!!
-            val parent = declaration.parent
-            val clashedParent = clashedDeclaration.parent
-            if (declaration !is IrTypeParameter || parent !is IrSimpleFunction || clashedParent !is IrSimpleFunction || parent.correspondingPropertySymbol !== clashedParent.correspondingPropertySymbol) {
-                // TODO: handle clashes properly
-                error("IdSignature clash: $signature; Existed declaration ${clashedDeclaration.render()} clashed with new ${declaration.render()}")
-            }
-        }
-
-        committedIdSignatures[signature] = declaration
-    }
-}
-
-class JsGlobalDeclarationTable(builtIns: IrBuiltIns, tracker: IdSignatureClashTracker = JsUniqIdClashTracker()) :
-    GlobalDeclarationTable(JsManglerIr, tracker) {
+class JsGlobalDeclarationTable(builtIns: IrBuiltIns) : GlobalDeclarationTable(JsManglerIr) {
     init {
         loadKnownBuiltins(builtIns)
     }

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

@@ -7,14 +7,16 @@ package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir
 
 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.IrModuleSerializer
 import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.ir.IrBuiltIns
+import org.jetbrains.kotlin.ir.IrDiagnosticReporter
 import org.jetbrains.kotlin.ir.declarations.IrFile
 import org.jetbrains.kotlin.ir.util.IrMessageLogger
 
 class JsIrModuleSerializer(
+    diagnosticReporter: IrDiagnosticReporter,
     messageLogger: IrMessageLogger,
     irBuiltIns: IrBuiltIns,
     compatibilityMode: CompatibilityMode,
@@ -22,13 +24,17 @@ class JsIrModuleSerializer(
     sourceBaseDirs: Collection<String>,
     private val languageVersionSettings: LanguageVersionSettings,
     shouldCheckSignaturesOnUniqueness: Boolean = true,
-    private val jsIrFileMetadataFactory: JsIrFileMetadataFactory = JsIrFileEmptyMetadataFactory
-) : IrModuleSerializer<JsIrFileSerializer>(messageLogger, compatibilityMode, normalizeAbsolutePaths, sourceBaseDirs) {
+    private val jsIrFileMetadataFactory: JsIrFileMetadataFactory = JsIrFileEmptyMetadataFactory,
+) : IrModuleSerializer<JsIrFileSerializer>(
+    diagnosticReporter,
+    messageLogger,
+    compatibilityMode,
+    normalizeAbsolutePaths,
+    sourceBaseDirs,
+    shouldCheckSignaturesOnUniqueness,
+) {
 
-    private val globalDeclarationTable = JsGlobalDeclarationTable(
-        irBuiltIns,
-        if (shouldCheckSignaturesOnUniqueness) JsUniqIdClashTracker() else IdSignatureClashTracker.DEFAULT_TRACKER
-    )
+    override val globalDeclarationTable = JsGlobalDeclarationTable(irBuiltIns)
 
     override fun createSerializerForFile(file: IrFile): JsIrFileSerializer =
         JsIrFileSerializer(

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

@@ -8,12 +8,15 @@ package org.jetbrains.kotlin.backend.konan.serialization
 import org.jetbrains.kotlin.backend.common.serialization.CompatibilityMode
 import org.jetbrains.kotlin.backend.common.serialization.IrModuleSerializer
 import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.ir.IrBuiltIns
+import org.jetbrains.kotlin.ir.IrDiagnosticReporter
 import org.jetbrains.kotlin.ir.declarations.IrFile
 import org.jetbrains.kotlin.ir.util.IrMessageLogger
 import org.jetbrains.kotlin.name.NativeStandardInteropNames
 
 class KonanIrModuleSerializer(
+        diagnosticReporter: IrDiagnosticReporter,
         messageLogger: IrMessageLogger,
         irBuiltIns: IrBuiltIns,
         compatibilityMode: CompatibilityMode,
@@ -22,9 +25,17 @@ class KonanIrModuleSerializer(
         private val languageVersionSettings: LanguageVersionSettings,
         private val bodiesOnlyForInlines: Boolean = false,
         private val skipPrivateApi: Boolean = false,
-) : IrModuleSerializer<KonanIrFileSerializer>(messageLogger, compatibilityMode, normalizeAbsolutePaths, sourceBaseDirs) {
+        shouldCheckSignaturesOnUniqueness: Boolean = true,
+) : IrModuleSerializer<KonanIrFileSerializer>(
+        diagnosticReporter,
+        messageLogger,
+        compatibilityMode,
+        normalizeAbsolutePaths,
+        sourceBaseDirs,
+        shouldCheckSignaturesOnUniqueness,
+) {
 
-    private val globalDeclarationTable = KonanGlobalDeclarationTable(irBuiltIns)
+    override val globalDeclarationTable = KonanGlobalDeclarationTable(irBuiltIns)
 
     // We skip files with IR for C structs and enums because they should be
     // generated anew.

compiler/testData/diagnostics/klibSerializationTests/signatureClash.diag.txt

@@ -0,0 +1,14 @@
+/foo.kt:7:1: error: Platform declaration clash: The following declarations have the same KLIB signature (com.example.klib.serialization.diagnostics/foo|foo(){}[0]):
+    fun foo(): kotlin.Long defined in com.example.klib.serialization.diagnostics
+    fun foo(): kotlin.String defined in com.example.klib.serialization.diagnostics
+    fun foo(): kotlin.Int defined in com.example.klib.serialization.diagnostics
+
+/main.kt:13:1: error: Platform declaration clash: The following declarations have the same KLIB signature (com.example.klib.serialization.diagnostics/foo|foo(){}[0]):
+    fun foo(): kotlin.Long defined in com.example.klib.serialization.diagnostics
+    fun foo(): kotlin.String defined in com.example.klib.serialization.diagnostics
+    fun foo(): kotlin.Int defined in com.example.klib.serialization.diagnostics
+
+/main.kt:16:1: error: Platform declaration clash: The following declarations have the same KLIB signature (com.example.klib.serialization.diagnostics/foo|foo(){}[0]):
+    fun foo(): kotlin.Long defined in com.example.klib.serialization.diagnostics
+    fun foo(): kotlin.String defined in com.example.klib.serialization.diagnostics
+    fun foo(): kotlin.Int defined in com.example.klib.serialization.diagnostics

compiler/testData/diagnostics/klibSerializationTests/signatureClash.kt

@@ -0,0 +1,20 @@
+// FIR_IDENTICAL
+// RENDER_ALL_DIAGNOSTICS_FULL_TEXT
+
+// FILE: foo.kt
+package com.example.klib.serialization.diagnostics
+
+<!CONFLICTING_KLIB_SIGNATURES_ERROR!>@Deprecated("", level = DeprecationLevel.HIDDEN)
+fun foo(): Long = 0L<!>
+
+// FILE: main.kt
+package com.example.klib.serialization.diagnostics
+
+<!CONFLICTING_KLIB_SIGNATURES_ERROR!>@Deprecated("", level = DeprecationLevel.HIDDEN)
+fun foo(): String = ""<!>
+
+<!CONFLICTING_KLIB_SIGNATURES_ERROR!>fun foo(): Int = 0<!>
+
+fun main() {
+    foo()
+}

compiler/tests-common/tests/org/jetbrains/kotlin/klib/AbstractKlibIrTextTestCase.kt

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.klib
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
 import junit.framework.TestCase
+import org.jetbrains.kotlin.KtDiagnosticReporterWithImplicitIrBasedContext
 import org.jetbrains.kotlin.backend.common.CommonKLibResolver
 import org.jetbrains.kotlin.ir.util.isExpect
 import org.jetbrains.kotlin.backend.common.linkage.issues.checkNoUnboundSymbols
@@ -24,6 +25,8 @@ import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
+import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.ir.AbstractIrGeneratorTestCase
 import org.jetbrains.kotlin.ir.IrElement
@@ -139,16 +142,25 @@ abstract class AbstractKlibIrTextTestCase : CodegenTestCase() {
         return serializePackageFragment(moduleDescriptor, memberScope, ktFile.packageFqName)
     }
 
-    protected fun serializeModule(irModuleFragment: IrModuleFragment, bindingContext: BindingContext, stdlib: KotlinLibrary, containsErrorCode: Boolean): String {
+    private fun serializeModule(
+        irModuleFragment: IrModuleFragment,
+        bindingContext: BindingContext,
+        stdlib: KotlinLibrary,
+        containsErrorCode: Boolean,
+    ): String {
         val ktFiles = myFiles.psiFiles
         val serializedIr = JsIrModuleSerializer(
-                IrMessageLogger.None,
-                irModuleFragment.irBuiltins,
-                CompatibilityMode.CURRENT,
-                false,
-                emptyList(),
+            KtDiagnosticReporterWithImplicitIrBasedContext(
+                DiagnosticReporterFactory.createPendingReporter(),
                 myEnvironment.configuration.languageVersionSettings,
-            ).serializedIrModule(irModuleFragment)
+            ),
+            IrMessageLogger.None,
+            irModuleFragment.irBuiltins,
+            CompatibilityMode.CURRENT,
+            false,
+            emptyList(),
+            myEnvironment.configuration.languageVersionSettings,
+        ).serializedIrModule(irModuleFragment)
 
         val moduleDescriptor = irModuleFragment.descriptor
         val metadataSerializer = klibMetadataIncrementalSerializer(myEnvironment.configuration, myEnvironment.project, containsErrorCode)