[IR] Fix compatibility mode

 - pass corresponding flag to mangler
 - properly handle local declarations in field initializers
 - fix KT-48912
diff --git a/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmKotlinMangler.kt b/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmKotlinMangler.kt
index 41a1375..19fc1f9 100644
--- a/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmKotlinMangler.kt
+++ b/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirJvmKotlinMangler.kt
@@ -14,15 +14,15 @@
 @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 @@
         }
     }
 
-    override fun getMangleComputer(mode: MangleMode): KotlinMangleComputer<FirDeclaration> {
+    override fun getMangleComputer(mode: MangleMode, compatibleMode: Boolean): KotlinMangleComputer<FirDeclaration> {
         return FirJvmMangleComputer(StringBuilder(256), mode, session)
     }
 }
diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/signaturer/FirBasedSignatureComposer.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/signaturer/FirBasedSignatureComposer.kt
index 2f0e26a..a2f1acc 100644
--- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/signaturer/FirBasedSignatureComposer.kt
+++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/signaturer/FirBasedSignatureComposer.kt
@@ -40,17 +40,17 @@
         }
 
         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)
         }
 
diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/NameTables.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/NameTables.kt
index 8ce12ab..48c3dfd 100644
--- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/NameTables.kt
+++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/NameTables.kt
@@ -32,7 +32,7 @@
 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 {
diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/KotlinMangler.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/KotlinMangler.kt
index 245f9d7..ebb847e 100644
--- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/KotlinMangler.kt
+++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/KotlinMangler.kt
@@ -15,13 +15,13 @@
     val String.hashMangle: Long
 
     fun D.isExported(compatibleMode: Boolean): Boolean
-    fun D.mangleString(): String
-    fun D.signatureString(): String
-    fun D.fqnString(): String
+    fun D.mangleString(compatibleMode: Boolean): String
+    fun D.signatureString(compatibleMode: Boolean): String
+    fun D.fqnString(compatibleMode: Boolean): String
 
-    fun D.hashedMangle(): Long = mangleString().hashMangle
-    fun D.signatureMangle(): Long = signatureString().hashMangle
-    fun D.fqnMangle(): Long = fqnString().hashMangle
+    fun D.hashedMangle(compatibleMode: Boolean): Long = mangleString(compatibleMode).hashMangle
+    fun D.signatureMangle(compatibleMode: Boolean): Long = signatureString(compatibleMode).hashMangle
+    fun D.fqnMangle(compatibleMode: Boolean): Long = fqnString(compatibleMode).hashMangle
 
     fun D.isPlatformSpecificExport(): Boolean = false
 
@@ -31,9 +31,9 @@
         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> {
diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/overrides/FakeOverrideChecker.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/overrides/FakeOverrideChecker.kt
index 51fe182..f19fc26 100644
--- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/overrides/FakeOverrideChecker.kt
+++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/overrides/FakeOverrideChecker.kt
@@ -31,7 +31,7 @@
         }
     }
 
-    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 @@
             .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 @@
         }
 
         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
diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/DescriptorByIdSignatureFinder.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/DescriptorByIdSignatureFinder.kt
index 91ef339..48715e7 100644
--- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/DescriptorByIdSignatureFinder.kt
+++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/DescriptorByIdSignatureFinder.kt
@@ -165,7 +165,7 @@
                 // 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
             }
         }
diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/mangle/AbstractKotlinMangler.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/mangle/AbstractKotlinMangler.kt
index ddaffc8..daed805 100644
--- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/mangle/AbstractKotlinMangler.kt
+++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/mangle/AbstractKotlinMangler.kt
@@ -12,5 +12,5 @@
     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>
 }
\ No newline at end of file
diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/mangle/ManglerChecker.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/mangle/ManglerChecker.kt
index 33342ea..f130715 100644
--- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/mangle/ManglerChecker.kt
+++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/mangle/ManglerChecker.kt
@@ -52,13 +52,13 @@
     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
diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/mangle/descriptor/DescriptorBasedKotlinManglerImpl.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/mangle/descriptor/DescriptorBasedKotlinManglerImpl.kt
index 5a4dbfb..a7b0890 100644
--- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/mangle/descriptor/DescriptorBasedKotlinManglerImpl.kt
+++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/mangle/descriptor/DescriptorBasedKotlinManglerImpl.kt
@@ -16,18 +16,18 @@
 import org.jetbrains.kotlin.types.KotlinType
 
 abstract class DescriptorBasedKotlinManglerImpl : AbstractKotlinMangler<DeclarationDescriptor>(), KotlinMangler.DescriptorMangler {
-    private fun withMode(mode: MangleMode, descriptor: DeclarationDescriptor): String =
-        getMangleComputer(mode).computeMangle(descriptor)
+    private fun withMode(mode: MangleMode, compatibleMode: Boolean, descriptor: DeclarationDescriptor): String =
+        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 @@
         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 IrField -> delegate.run { descriptor.mangleFieldString() }
-            else -> delegate.run { descriptor.mangleString() }
+            is IrEnumEntry -> delegate.run { descriptor.mangleEnumEntryString(compatibleMode) }
+            is IrField -> delegate.run { descriptor.mangleFieldString(compatibleMode) }
+            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> {
diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/mangle/ir/IrBasedKotlinManglerImpl.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/mangle/ir/IrBasedKotlinManglerImpl.kt
index 973eebd..80bb5a2 100644
--- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/mangle/ir/IrBasedKotlinManglerImpl.kt
+++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/mangle/ir/IrBasedKotlinManglerImpl.kt
@@ -13,11 +13,11 @@
 
 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)
diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/mangle/ir/IrMangleComputer.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/mangle/ir/IrMangleComputer.kt
index 7f93617..4b13b75 100644
--- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/mangle/ir/IrMangleComputer.kt
+++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/mangle/ir/IrMangleComputer.kt
@@ -20,7 +20,7 @@
 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,10 @@
 
     override fun visitField(declaration: IrField) {
         val prop = declaration.correspondingPropertySymbol
-        if (prop != null) {
-            visitProperty(prop.owner)
-        } else {
+        if (compatibleMode || prop == null) { // act as used to be (KT-48912)
             declaration.mangleSimpleDeclaration(declaration.name.asString())
+        } else {
+            visitProperty(prop.owner)
         }
     }
 
diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/signature/IdSignatureDescriptor.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/signature/IdSignatureDescriptor.kt
index a818baf..cb9a5f2 100644
--- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/signature/IdSignatureDescriptor.kt
+++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/signature/IdSignatureDescriptor.kt
@@ -72,7 +72,7 @@
 
         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 @@
 
         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 @@
             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 @@
 
         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 @@
 
         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)
diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/signature/IdSignatureSerializer.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/signature/IdSignatureSerializer.kt
index a5fd29e..26ae3b0 100644
--- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/signature/IdSignatureSerializer.kt
+++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/signature/IdSignatureSerializer.kt
@@ -60,7 +60,7 @@
         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 @@
             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
@@ -254,7 +255,7 @@
                     IdSignature.FileLocalSignature(
                         p,
                         if (declaration.isOverridableFunction()) {
-                            mangler.run { declaration.signatureMangle() }
+                            mangler.run { declaration.signatureMangle(compatibleMode) }
                         } else {
                             ++localIndex
                         },
@@ -266,7 +267,7 @@
                     IdSignature.FileLocalSignature(
                         composeContainerIdSignature(parent, compatibleMode),
                         if (declaration.isOverridableProperty()) {
-                            mangler.run { declaration.signatureMangle() }
+                            mangler.run { declaration.signatureMangle(compatibleMode) }
                         } else {
                             ++localIndex
                         },
diff --git a/compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsMangler.kt b/compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsMangler.kt
index 0d3065b..f4b2ba9 100644
--- a/compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsMangler.kt
+++ b/compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsMangler.kt
@@ -23,14 +23,14 @@
         override fun IrDeclaration.isPlatformSpecificExported() = false
     }
 
-    private class JsIrManglerComputer(builder: StringBuilder, mode: MangleMode) : IrMangleComputer(builder, mode) {
-        override fun copy(newMode: MangleMode): IrMangleComputer = JsIrManglerComputer(builder, newMode)
+    private class JsIrManglerComputer(builder: StringBuilder, mode: MangleMode, compatibleMode: Boolean) : IrMangleComputer(builder, mode, compatibleMode) {
+        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> {
-        return JsIrManglerComputer(StringBuilder(256), mode)
+    override fun getMangleComputer(mode: MangleMode, compatibleMode: Boolean): KotlinMangleComputer<IrDeclaration> {
+        return JsIrManglerComputer(StringBuilder(256), mode, compatibleMode)
     }
 }
 
@@ -52,7 +52,7 @@
 
     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)
     }
 }
diff --git a/compiler/ir/serialization.jvm/src/org/jetbrains/kotlin/ir/backend/jvm/serialization/JvmMangler.kt b/compiler/ir/serialization.jvm/src/org/jetbrains/kotlin/ir/backend/jvm/serialization/JvmMangler.kt
index 90d409b..4ece809 100644
--- a/compiler/ir/serialization.jvm/src/org/jetbrains/kotlin/ir/backend/jvm/serialization/JvmMangler.kt
+++ b/compiler/ir/serialization.jvm/src/org/jetbrains/kotlin/ir/backend/jvm/serialization/JvmMangler.kt
@@ -37,9 +37,9 @@
         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 @@
 
     override fun getExportChecker(compatibleMode: Boolean): KotlinExportChecker<IrDeclaration> = JvmIrExportChecker(compatibleMode)
 
-    override fun getMangleComputer(mode: MangleMode): KotlinMangleComputer<IrDeclaration> =
-        JvmIrManglerComputer(StringBuilder(256), mode)
+    override fun getMangleComputer(mode: MangleMode, compatibleMode: Boolean): KotlinMangleComputer<IrDeclaration> =
+        JvmIrManglerComputer(StringBuilder(256), mode, compatibleMode)
 }
 
 class JvmDescriptorMangler(private val mainDetector: MainFunctionDetector?) : DescriptorBasedKotlinManglerImpl() {
@@ -101,6 +101,6 @@
 
     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)
 }
diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/BinaryInterface.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/BinaryInterface.kt
index c0ab278..f312d34 100644
--- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/BinaryInterface.kt
+++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/BinaryInterface.kt
@@ -36,7 +36,7 @@
 
     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 @@
             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 {
diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/serialization/KonanMangler.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/serialization/KonanMangler.kt
index 0fb5d0f..b791394 100644
--- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/serialization/KonanMangler.kt
+++ b/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.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 @@
         override fun IrDeclaration.isPlatformSpecificExported(): Boolean = isPlatformSpecificExport()
     }
 
-    private class KonanIrManglerComputer(builder: StringBuilder, mode: MangleMode, private val withReturnType: Boolean) : IrMangleComputer(builder, mode) {
-        override fun copy(newMode: MangleMode): IrMangleComputer = KonanIrManglerComputer(builder, newMode, withReturnType)
+    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, compatibleMode, withReturnType)
 
         override fun addReturnType(): Boolean = withReturnType
 
@@ -93,7 +92,7 @@
 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()