[IR] Fix compatibility mode

- pass corresponding flag to mangler
 - properly handle local declarations in field initializers
 - fix KT-48912

compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmKotlinMangler.kt

@@ -14,15 +14,15 @@ import org.jetbrains.kotlin.fir.signaturer.FirMangler
 @NoMutableState
 class FirJvmKotlinMangler(private val session: FirSession) : AbstractKotlinMangler<FirDeclaration>(), FirMangler {
 
-    override fun FirDeclaration.mangleString(): String = getMangleComputer(MangleMode.FULL).computeMangle(this)
+    override fun FirDeclaration.mangleString(compatibleMode: Boolean): String = getMangleComputer(MangleMode.FULL, compatibleMode).computeMangle(this)
 
-    override fun FirDeclaration.signatureString(): String = getMangleComputer(MangleMode.SIGNATURE).computeMangle(this)
+    override fun FirDeclaration.signatureString(compatibleMode: Boolean): String = getMangleComputer(MangleMode.SIGNATURE, compatibleMode).computeMangle(this)
 
-    override fun FirDeclaration.fqnString(): String = getMangleComputer(MangleMode.FQNAME).computeMangle(this)
+    override fun FirDeclaration.fqnString(compatibleMode: Boolean): String = getMangleComputer(MangleMode.FQNAME, compatibleMode).computeMangle(this)
 
     override fun FirDeclaration.isExported(compatibleMode: Boolean): Boolean = true
 
-    override fun getExportChecker(compatibleMode: Boolean): KotlinExportChecker<FirDeclaration>  {
+    override fun getExportChecker(compatibleMode: Boolean): KotlinExportChecker<FirDeclaration> {
         return object : KotlinExportChecker<FirDeclaration> {
             override fun check(declaration: FirDeclaration, type: SpecialDeclarationType): Boolean = true
 
@@ -30,7 +30,7 @@ class FirJvmKotlinMangler(private val session: FirSession) : AbstractKotlinMangl
         }
     }
 
-    override fun getMangleComputer(mode: MangleMode): KotlinMangleComputer<FirDeclaration> {
+    override fun getMangleComputer(mode: MangleMode, compatibleMode: Boolean): KotlinMangleComputer<FirDeclaration> {
         return FirJvmMangleComputer(StringBuilder(256), mode, session)
     }
 }

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/signaturer/FirBasedSignatureComposer.kt

@@ -40,17 +40,17 @@ class FirBasedSignatureComposer(private val mangler: FirMangler) : Fir2IrSignatu
         }
 
         override fun visitConstructor(constructor: FirConstructor, data: Any?) {
-            hashId = mangler.run { constructor.signatureMangle() }
+            hashId = mangler.run { constructor.signatureMangle(compatibleMode = false) }
             setExpected(constructor.isExpect)
         }
 
         override fun visitSimpleFunction(simpleFunction: FirSimpleFunction, data: Any?) {
-            hashId = mangler.run { simpleFunction.signatureMangle() }
+            hashId = mangler.run { simpleFunction.signatureMangle(compatibleMode = false) }
             setExpected(simpleFunction.isExpect)
         }
 
         override fun visitProperty(property: FirProperty, data: Any?) {
-            hashId = mangler.run { property.signatureMangle() }
+            hashId = mangler.run { property.signatureMangle(compatibleMode = false) }
             setExpected(property.isExpect)
         }
 

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/NameTables.kt

@@ -32,7 +32,7 @@ import kotlin.math.abs
 private fun <T> mapToKey(declaration: T): String {
     return with(JsManglerIr) {
         if (declaration is IrDeclaration) {
-            declaration.hashedMangle().toString()
+            declaration.hashedMangle(compatibleMode = false).toString()
         } else if (declaration is String) {
             declaration.hashMangle.toString()
         } else {

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/KotlinMangler.kt

@@ -15,13 +15,13 @@ interface KotlinMangler<D : Any> {
     val String.hashMangle: Long
 
     fun D.isExported(compatibleMode: Boolean): Boolean
-    fun D.mangleString(): String
+    fun D.mangleString(compatibleMode: Boolean): String
-    fun D.signatureString(): String
+    fun D.signatureString(compatibleMode: Boolean): String
-    fun D.fqnString(): String
+    fun D.fqnString(compatibleMode: Boolean): String
 
-    fun D.hashedMangle(): Long = mangleString().hashMangle
+    fun D.hashedMangle(compatibleMode: Boolean): Long = mangleString(compatibleMode).hashMangle
-    fun D.signatureMangle(): Long = signatureString().hashMangle
+    fun D.signatureMangle(compatibleMode: Boolean): Long = signatureString(compatibleMode).hashMangle
-    fun D.fqnMangle(): Long = fqnString().hashMangle
+    fun D.fqnMangle(compatibleMode: Boolean): Long = fqnString(compatibleMode).hashMangle
 
     fun D.isPlatformSpecificExport(): Boolean = false
 
@@ -31,9 +31,9 @@ interface KotlinMangler<D : Any> {
         override val manglerName: String
             get() = "Descriptor"
 
-        fun ClassDescriptor.mangleEnumEntryString(): String
+        fun ClassDescriptor.mangleEnumEntryString(compatibleMode: Boolean): String
 
-        fun PropertyDescriptor.mangleFieldString(): String
+        fun PropertyDescriptor.mangleFieldString(compatibleMode: Boolean): String
     }
 
     interface IrMangler : KotlinMangler<IrDeclaration> {

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

@@ -31,7 +31,7 @@ class FakeOverrideChecker(
         }
     }
 
-    private fun validateFakeOverrides(clazz: IrClass) {
+    private fun validateFakeOverrides(clazz: IrClass, compatibleMode: Boolean = false) {
         val classId = clazz.classId ?: return
         val classDescriptor = clazz.module.module.findClassAcrossModuleDependencies(classId) ?: return
         // All enum entry overrides look like fake overrides in descriptor enum entries
@@ -44,7 +44,7 @@ class FakeOverrideChecker(
             .filterNot { it.visibility == DescriptorVisibilities.PRIVATE || it.visibility == DescriptorVisibilities.INVISIBLE_FAKE }
 
         val descriptorSignatures = descriptorFakeOverrides
-            .map { with(descriptorMangler) { it.signatureString() } }
+            .map { with(descriptorMangler) { it.signatureString(compatibleMode) } }
             .sorted()
 
         val irFakeOverrides = clazz.declarations
@@ -56,7 +56,7 @@ class FakeOverrideChecker(
         }
 
         val irSignatures = irFakeOverrides
-            .map { with(irMangler) { it.signatureString() } }
+            .map { with(irMangler) { it.signatureString(compatibleMode) } }
             .sorted()
 
         // We can't have equality here because dependency libraries could have

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

@@ -165,7 +165,7 @@ class DescriptorByIdSignatureFinder(
                 // We don't compute id for typealiases and classes.
                 candidate is ClassDescriptor || candidate is TypeAliasDescriptor
             } else {
-                val candidateHash = with(mangler) { candidate.signatureMangle() }
+                val candidateHash = with(mangler) { candidate.signatureMangle(compatibleMode = false) }
                 candidateHash == id
             }
         }

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

@@ -12,5 +12,5 @@ abstract class AbstractKotlinMangler<D : Any> : KotlinMangler<D> {
     override val String.hashMangle get() = cityHash64()
 
     abstract fun getExportChecker(compatibleMode: Boolean): KotlinExportChecker<D>
-    abstract fun getMangleComputer(mode: MangleMode): KotlinMangleComputer<D>
+    abstract fun getMangleComputer(mode: MangleMode, compatibleMode: Boolean): KotlinMangleComputer<D>
 }

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

@@ -52,13 +52,13 @@ class ManglerChecker(vararg _manglers: KotlinMangler<IrDeclaration>) : IrElement
     private fun KotlinMangler<IrDeclaration>.isExportCheck(declaration: IrDeclaration) =
         !declaration.shouldBeSkipped() && declaration.isExported(false)
     private fun KotlinMangler<IrDeclaration>.stringMangle(declaration: IrDeclaration) =
-        declaration.mangleString()
+        declaration.mangleString(compatibleMode = false)
 
     private fun KotlinMangler<IrDeclaration>.signatureMangle(declaration: IrDeclaration) =
-        declaration.signatureString()
+        declaration.signatureString(compatibleMode = false)
 
     private fun KotlinMangler<IrDeclaration>.fqnMangle(declaration: IrDeclaration) =
-        declaration.fqnString()
+        declaration.fqnString(compatibleMode = false)
 
     private fun <T : Any, R> Iterable<T>.checkAllEqual(init: R, op: T.() -> R, onError: (T, R, T, R) -> Unit): R {
         var prev: T? = null

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/mangle/descriptor/DescriptorBasedKotlinManglerImpl.kt

@@ -16,18 +16,18 @@ import org.jetbrains.kotlin.ir.util.KotlinMangler
 import org.jetbrains.kotlin.types.KotlinType
 
 abstract class DescriptorBasedKotlinManglerImpl : AbstractKotlinMangler<DeclarationDescriptor>(), KotlinMangler.DescriptorMangler {
-    private fun withMode(mode: MangleMode, descriptor: DeclarationDescriptor): String =
+    private fun withMode(mode: MangleMode, compatibleMode: Boolean, descriptor: DeclarationDescriptor): String =
-        getMangleComputer(mode).computeMangle(descriptor)
+        getMangleComputer(mode, compatibleMode).computeMangle(descriptor)
 
-    override fun ClassDescriptor.mangleEnumEntryString(): String = withMode(MangleMode.FQNAME, this)
+    override fun ClassDescriptor.mangleEnumEntryString(compatibleMode: Boolean): String = withMode(MangleMode.FQNAME, compatibleMode, this)
 
-    override fun PropertyDescriptor.mangleFieldString(): String = mangleString()
+    override fun PropertyDescriptor.mangleFieldString(compatibleMode: Boolean): String = mangleString(compatibleMode)
 
-    override fun DeclarationDescriptor.mangleString(): String = withMode(MangleMode.FULL, this)
+    override fun DeclarationDescriptor.mangleString(compatibleMode: Boolean): String = withMode(MangleMode.FULL, compatibleMode, this)
 
-    override fun DeclarationDescriptor.signatureString(): String = withMode(MangleMode.SIGNATURE, this)
+    override fun DeclarationDescriptor.signatureString(compatibleMode: Boolean): String = withMode(MangleMode.SIGNATURE, compatibleMode, this)
 
-    override fun DeclarationDescriptor.fqnString(): String = withMode(MangleMode.FQNAME, this)
+    override fun DeclarationDescriptor.fqnString(compatibleMode: Boolean): String = withMode(MangleMode.FQNAME, compatibleMode, this)
 
     override fun DeclarationDescriptor.isExported(compatibleMode: Boolean): Boolean = getExportChecker(compatibleMode).check(this, SpecialDeclarationType.REGULAR)
 }
@@ -41,19 +41,19 @@ class Ir2DescriptorManglerAdapter(private val delegate: DescriptorBasedKotlinMan
         return delegate.run { descriptor.isExported(compatibleMode) }
     }
 
-    override fun IrDeclaration.mangleString(): String {
+    override fun IrDeclaration.mangleString(compatibleMode: Boolean): String {
         return when (this) {
-            is IrEnumEntry -> delegate.run { descriptor.mangleEnumEntryString() }
+            is IrEnumEntry -> delegate.run { descriptor.mangleEnumEntryString(compatibleMode) }
-            is IrField -> delegate.run { descriptor.mangleFieldString() }
+            is IrField -> delegate.run { descriptor.mangleFieldString(compatibleMode) }
-            else -> delegate.run { descriptor.mangleString() }
+            else -> delegate.run { descriptor.mangleString(compatibleMode) }
         }
     }
 
-    override fun IrDeclaration.signatureString(): String = delegate.run { descriptor.signatureString() }
+    override fun IrDeclaration.signatureString(compatibleMode: Boolean): String = delegate.run { descriptor.signatureString(compatibleMode) }
 
-    override fun IrDeclaration.fqnString(): String = delegate.run { descriptor.fqnString() }
+    override fun IrDeclaration.fqnString(compatibleMode: Boolean): String = delegate.run { descriptor.fqnString(compatibleMode) }
 
-    override fun getMangleComputer(mode: MangleMode): KotlinMangleComputer<IrDeclaration> =
+    override fun getMangleComputer(mode: MangleMode, compatibleMode: Boolean): KotlinMangleComputer<IrDeclaration> =
         error("Should not have been reached")
 
     override fun getExportChecker(compatibleMode: Boolean): KotlinExportChecker<IrDeclaration> {

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

@@ -13,11 +13,11 @@ import org.jetbrains.kotlin.ir.util.KotlinMangler
 
 abstract class IrBasedKotlinManglerImpl : AbstractKotlinMangler<IrDeclaration>(), KotlinMangler.IrMangler {
 
-    override fun IrDeclaration.mangleString(): String = getMangleComputer(MangleMode.FULL).computeMangle(this)
+    override fun IrDeclaration.mangleString(compatibleMode: Boolean): String = getMangleComputer(MangleMode.FULL, compatibleMode).computeMangle(this)
 
-    override fun IrDeclaration.signatureString(): String = getMangleComputer(MangleMode.SIGNATURE).computeMangle(this)
+    override fun IrDeclaration.signatureString(compatibleMode: Boolean): String = getMangleComputer(MangleMode.SIGNATURE, compatibleMode).computeMangle(this)
 
-    override fun IrDeclaration.fqnString(): String = getMangleComputer(MangleMode.FQNAME).computeMangle(this)
+    override fun IrDeclaration.fqnString(compatibleMode: Boolean): String = getMangleComputer(MangleMode.FQNAME, compatibleMode).computeMangle(this)
 
     override fun IrDeclaration.isExported(compatibleMode: Boolean): Boolean =
         getExportChecker(compatibleMode).check(this, SpecialDeclarationType.REGULAR)

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

@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.ir.visitors.acceptVoid
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.utils.addToStdlib.ifNotEmpty
 
-abstract class IrMangleComputer(protected val builder: StringBuilder, private val mode: MangleMode) :
+abstract class IrMangleComputer(protected val builder: StringBuilder, private val mode: MangleMode, protected val compatibleMode: Boolean) :
     IrElementVisitorVoid, KotlinMangleComputer<IrDeclaration> {
 
     private val typeParameterContainer = ArrayList<IrDeclaration>(4)
@@ -260,10 +260,11 @@ abstract class IrMangleComputer(protected val builder: StringBuilder, private va
 
     override fun visitField(declaration: IrField) {
         val prop = declaration.correspondingPropertySymbol
-        if (prop != null) {
+        if (compatibleMode || prop == null) { // act as used to be (KT-48912)
-            visitProperty(prop.owner)
+            // test compiler/testData/codegen/box/ir/serializationRegressions/anonFakeOverride.kt
-        } else {
             declaration.mangleSimpleDeclaration(declaration.name.asString())
+        } else {
+            visitProperty(prop.owner)
         }
     }
 

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

@@ -72,7 +72,7 @@ open class IdSignatureDescriptor(private val mangler: KotlinMangler.DescriptorMa
 
         override fun visitFunctionDescriptor(descriptor: FunctionDescriptor, data: Nothing?) {
             collectParents(descriptor)
-            hashId = mangler.run { descriptor.signatureMangle() }
+            hashId = mangler.run { descriptor.signatureMangle(compatibleMode = false) }
             isTopLevelPrivate = isTopLevelPrivate or descriptor.isTopLevelPrivate
             setDescription(descriptor)
             setExpected(descriptor.isExpect)
@@ -116,7 +116,7 @@ open class IdSignatureDescriptor(private val mangler: KotlinMangler.DescriptorMa
 
         override fun visitConstructorDescriptor(constructorDescriptor: ConstructorDescriptor, data: Nothing?) {
             collectParents(constructorDescriptor)
-            hashId = mangler.run { constructorDescriptor.signatureMangle() }
+            hashId = mangler.run { constructorDescriptor.signatureMangle(compatibleMode = false) }
             platformSpecificConstructor(constructorDescriptor)
         }
 
@@ -133,7 +133,7 @@ open class IdSignatureDescriptor(private val mangler: KotlinMangler.DescriptorMa
             isTopLevelPrivate = isTopLevelPrivate or actualDeclaration.isTopLevelPrivate
 
 
-            hashId = mangler.run { actualDeclaration.signatureMangle() }
+            hashId = mangler.run { actualDeclaration.signatureMangle(compatibleMode = false) }
             setExpected(actualDeclaration.isExpect)
             platformSpecificProperty(actualDeclaration)
             if (type == SpecialDeclarationType.BACKING_FIELD) {
@@ -150,7 +150,7 @@ open class IdSignatureDescriptor(private val mangler: KotlinMangler.DescriptorMa
 
         override fun visitPropertyGetterDescriptor(descriptor: PropertyGetterDescriptor, data: Nothing?) {
             descriptor.correspondingProperty.accept(this, null)
-            hashIdAcc = mangler.run { descriptor.signatureMangle() }
+            hashIdAcc = mangler.run { descriptor.signatureMangle(compatibleMode = false) }
             classFqnSegments.add(descriptor.name.asString())
             setExpected(descriptor.isExpect)
             platformSpecificGetter(descriptor)
@@ -158,7 +158,7 @@ open class IdSignatureDescriptor(private val mangler: KotlinMangler.DescriptorMa
 
         override fun visitPropertySetterDescriptor(descriptor: PropertySetterDescriptor, data: Nothing?) {
             descriptor.correspondingProperty.accept(this, null)
-            hashIdAcc = mangler.run { descriptor.signatureMangle() }
+            hashIdAcc = mangler.run { descriptor.signatureMangle(compatibleMode = false) }
             classFqnSegments.add(descriptor.name.asString())
             setExpected(descriptor.isExpect)
             platformSpecificSetter(descriptor)

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

@@ -60,7 +60,7 @@ class PublicIdSignatureComputer(val mangler: KotlinMangler.IrMangler) : IdSignat
         scopeCounter = 0
     }
 
-    private inner class PublicIdSigBuilder(private val containerSig: IdSignature? = null) : IdSignatureBuilder<IrDeclaration>(),
+    private inner class PublicIdSigBuilder : IdSignatureBuilder<IrDeclaration>(),
         IrElementVisitorVoid {
 
         override val currentFileSignature: IdSignature.FileSignature?
@@ -115,7 +115,8 @@ class PublicIdSignatureComputer(val mangler: KotlinMangler.IrMangler) : IdSignat
             setExpected(declaration.isExpect)
         }
 
-        private fun IrDeclarationWithName.hashId(): Long = mangler.run { signatureMangle() }
+        // Note: `false` because `compatibleMode` is not applied to public signatures
+        private fun IrDeclarationWithName.hashId(): Long = mangler.run { signatureMangle(compatibleMode = false) }
 
         override fun visitSimpleFunction(declaration: IrSimpleFunction) {
             val property = declaration.correspondingPropertySymbol
@@ -243,18 +244,18 @@ class IdSignatureSerializer(
                 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) }
+                    val p = declaration.correspondingPropertySymbol?.let { composeSignatureForDeclaration(it.owner, compatibleMode) }
                         ?: composeContainerIdSignature(declaration.parent, compatibleMode)
                     IdSignature.FileLocalSignature(p, ++localIndex)
                 }
                 is IrSimpleFunction -> {
                     val parent = declaration.parent
-                    val p = declaration.correspondingPropertySymbol?.let { composeSignatureForDeclaration(it.owner, true) }
+                    val p = declaration.correspondingPropertySymbol?.let { composeSignatureForDeclaration(it.owner, compatibleMode) }
                         ?: composeContainerIdSignature(parent, compatibleMode)
                     IdSignature.FileLocalSignature(
                         p,
                         if (declaration.isOverridableFunction()) {
-                            mangler.run { declaration.signatureMangle() }
+                            mangler.run { declaration.signatureMangle(compatibleMode) }
                         } else {
                             ++localIndex
                         },
@@ -266,7 +267,7 @@ class IdSignatureSerializer(
                     IdSignature.FileLocalSignature(
                         composeContainerIdSignature(parent, compatibleMode),
                         if (declaration.isOverridableProperty()) {
-                            mangler.run { declaration.signatureMangle() }
+                            mangler.run { declaration.signatureMangle(compatibleMode) }
                         } else {
                             ++localIndex
                         },

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

@@ -23,14 +23,14 @@ abstract class AbstractJsManglerIr : IrBasedKotlinManglerImpl() {
         override fun IrDeclaration.isPlatformSpecificExported() = false
     }
 
-    private class JsIrManglerComputer(builder: StringBuilder, mode: MangleMode) : IrMangleComputer(builder, mode) {
+    private class JsIrManglerComputer(builder: StringBuilder, mode: MangleMode, compatibleMode: Boolean) : IrMangleComputer(builder, mode, compatibleMode) {
-        override fun copy(newMode: MangleMode): IrMangleComputer = JsIrManglerComputer(builder, newMode)
+        override fun copy(newMode: MangleMode): IrMangleComputer = JsIrManglerComputer(builder, newMode, compatibleMode)
     }
 
     override fun getExportChecker(compatibleMode: Boolean): KotlinExportChecker<IrDeclaration> = JsIrExportChecker(compatibleMode)
 
-    override fun getMangleComputer(mode: MangleMode): KotlinMangleComputer<IrDeclaration> {
+    override fun getMangleComputer(mode: MangleMode, compatibleMode: Boolean): KotlinMangleComputer<IrDeclaration> {
-        return JsIrManglerComputer(StringBuilder(256), mode)
+        return JsIrManglerComputer(StringBuilder(256), mode, compatibleMode)
     }
 }
 
@@ -52,7 +52,7 @@ abstract class AbstractJsDescriptorMangler : DescriptorBasedKotlinManglerImpl()
 
     override fun getExportChecker(compatibleMode: Boolean): KotlinExportChecker<DeclarationDescriptor> = exportChecker
 
-    override fun getMangleComputer(mode: MangleMode): KotlinMangleComputer<DeclarationDescriptor> {
+    override fun getMangleComputer(mode: MangleMode, compatibleMode: Boolean): KotlinMangleComputer<DeclarationDescriptor> {
         return JsDescriptorManglerComputer(StringBuilder(256), mode)
     }
 }

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

@@ -37,9 +37,9 @@ object JvmIrMangler : IrBasedKotlinManglerImpl() {
         override fun IrDeclaration.isPlatformSpecificExported() = false
     }
 
-    private class JvmIrManglerComputer(builder: StringBuilder, mode: MangleMode) : IrMangleComputer(builder, mode) {
+    private class JvmIrManglerComputer(builder: StringBuilder, mode: MangleMode, compatibleMode: Boolean) : IrMangleComputer(builder, mode, compatibleMode) {
         override fun copy(newMode: MangleMode): IrMangleComputer =
-            JvmIrManglerComputer(builder, newMode)
+            JvmIrManglerComputer(builder, newMode, compatibleMode)
 
         override fun addReturnTypeSpecialCase(irFunction: IrFunction): Boolean =
             irFunction.isFromJava()
@@ -53,8 +53,8 @@ object JvmIrMangler : IrBasedKotlinManglerImpl() {
 
     override fun getExportChecker(compatibleMode: Boolean): KotlinExportChecker<IrDeclaration> = JvmIrExportChecker(compatibleMode)
 
-    override fun getMangleComputer(mode: MangleMode): KotlinMangleComputer<IrDeclaration> =
+    override fun getMangleComputer(mode: MangleMode, compatibleMode: Boolean): KotlinMangleComputer<IrDeclaration> =
-        JvmIrManglerComputer(StringBuilder(256), mode)
+        JvmIrManglerComputer(StringBuilder(256), mode, compatibleMode)
 }
 
 class JvmDescriptorMangler(private val mainDetector: MainFunctionDetector?) : DescriptorBasedKotlinManglerImpl() {
@@ -101,6 +101,6 @@ class JvmDescriptorMangler(private val mainDetector: MainFunctionDetector?) : De
 
     override fun getExportChecker(compatibleMode: Boolean): KotlinExportChecker<DeclarationDescriptor> = ExportChecker
 
-    override fun getMangleComputer(mode: MangleMode): KotlinMangleComputer<DeclarationDescriptor> =
+    override fun getMangleComputer(mode: MangleMode, compatibleMode: Boolean): KotlinMangleComputer<DeclarationDescriptor> =
         JvmDescriptorManglerComputer(StringBuilder(256), mainDetector, mode)
 }

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

@@ -36,7 +36,7 @@ object KonanBinaryInterface {
 
     private val exportChecker = mangler.getExportChecker(compatibleMode = true)
 
-    val IrFunction.functionName: String get() = mangler.run { signatureString() }
+    val IrFunction.functionName: String get() = mangler.run { signatureString(compatibleMode = true) }
 
     val IrFunction.symbolName: String get() = funSymbolNameImpl()
     val IrField.symbolName: String get() =
@@ -65,7 +65,7 @@ object KonanBinaryInterface {
             return name // no wrapping currently required
         }
 
-        return withPrefix(MangleConstant.FUN_PREFIX, mangler.run { mangleString() })
+        return withPrefix(MangleConstant.FUN_PREFIX, mangler.run { mangleString(compatibleMode = true) })
     }
 
     private fun IrField.fieldSymbolNameImpl(): String {

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

@@ -13,12 +13,11 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.types.getClass
 import org.jetbrains.kotlin.ir.util.hasAnnotation
-import org.jetbrains.kotlin.types.KotlinType
 
 abstract class AbstractKonanIrMangler(private val withReturnType: Boolean) : IrBasedKotlinManglerImpl() {
     override fun getExportChecker(compatibleMode: Boolean): IrExportCheckerVisitor = KonanIrExportChecker(compatibleMode)
 
-    override fun getMangleComputer(mode: MangleMode): IrMangleComputer = KonanIrManglerComputer(StringBuilder(256), mode, withReturnType)
+    override fun getMangleComputer(mode: MangleMode, compatibleMode: Boolean): IrMangleComputer = KonanIrManglerComputer(StringBuilder(256), mode, compatibleMode, withReturnType)
 
     override fun IrDeclaration.isPlatformSpecificExport(): Boolean {
         if (this is IrSimpleFunction) if (isFakeOverride) return false
@@ -51,8 +50,8 @@ abstract class AbstractKonanIrMangler(private val withReturnType: Boolean) : IrB
         override fun IrDeclaration.isPlatformSpecificExported(): Boolean = isPlatformSpecificExport()
     }
 
-    private class KonanIrManglerComputer(builder: StringBuilder, mode: MangleMode, private val withReturnType: Boolean) : IrMangleComputer(builder, mode) {
+    private class KonanIrManglerComputer(builder: StringBuilder, mode: MangleMode, compatibleMode: Boolean, private val withReturnType: Boolean) : IrMangleComputer(builder, mode, compatibleMode) {
-        override fun copy(newMode: MangleMode): IrMangleComputer = KonanIrManglerComputer(builder, newMode, withReturnType)
+        override fun copy(newMode: MangleMode): IrMangleComputer = KonanIrManglerComputer(builder, newMode, compatibleMode, withReturnType)
 
         override fun addReturnType(): Boolean = withReturnType
 
@@ -93,7 +92,7 @@ object KonanManglerIr : AbstractKonanIrMangler(false)
 abstract class AbstractKonanDescriptorMangler : DescriptorBasedKotlinManglerImpl() {
     override fun getExportChecker(compatibleMode: Boolean): KotlinExportChecker<DeclarationDescriptor> = KonanDescriptorExportChecker()
 
-    override fun getMangleComputer(mode: MangleMode): DescriptorMangleComputer = KonanDescriptorMangleComputer(StringBuilder(256), mode)
+    override fun getMangleComputer(mode: MangleMode, compatibleMode: Boolean): DescriptorMangleComputer = KonanDescriptorMangleComputer(StringBuilder(256), mode)
 
     private inner class KonanDescriptorExportChecker : DescriptorExportCheckerVisitor() {
         override fun DeclarationDescriptor.isPlatformSpecificExported(): Boolean = isPlatformSpecificExport()