From ba759fb61b008f482d6d7f93035d2ad13ec9b87f Mon Sep 17 00:00:00 2001 From: Roman Artemev Date: Tue, 5 Oct 2021 10:37:11 +0300 Subject: [PATCH] [IR] Fix compatibility mode - pass corresponding flag to mangler - properly handle local declarations in field initializers - fix KT-48912 --- .../fir/backend/jvm/FirJvmKotlinMangler.kt | 10 +++---- .../signaturer/FirBasedSignatureComposer.kt | 6 ++-- .../kotlin/ir/backend/js/utils/NameTables.kt | 2 +- .../jetbrains/kotlin/ir/util/KotlinMangler.kt | 16 +++++------ .../common/overrides/FakeOverrideChecker.kt | 6 ++-- .../DescriptorByIdSignatureFinder.kt | 2 +- .../mangle/AbstractKotlinMangler.kt | 2 +- .../serialization/mangle/ManglerChecker.kt | 6 ++-- .../DescriptorBasedKotlinManglerImpl.kt | 28 +++++++++---------- .../mangle/ir/IrBasedKotlinManglerImpl.kt | 6 ++-- .../mangle/ir/IrMangleComputer.kt | 9 +++--- .../signature/IdSignatureDescriptor.kt | 10 +++---- .../signature/IdSignatureSerializer.kt | 13 +++++---- .../js/lower/serialization/ir/JsMangler.kt | 10 +++---- .../backend/jvm/serialization/JvmMangler.kt | 10 +++---- .../backend/konan/llvm/BinaryInterface.kt | 4 +-- .../konan/serialization/KonanMangler.kt | 9 +++--- 17 files changed, 75 insertions(+), 74 deletions(-) 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 41a13752d7b..19fc1f91d2b 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 @@ import org.jetbrains.kotlin.fir.signaturer.FirMangler @NoMutableState class FirJvmKotlinMangler(private val session: FirSession) : AbstractKotlinMangler(), 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 { + override fun getExportChecker(compatibleMode: Boolean): KotlinExportChecker { return object : KotlinExportChecker { 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 { + override fun getMangleComputer(mode: MangleMode, compatibleMode: Boolean): KotlinMangleComputer { 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 2f0e26afb5a..a2f1acc79a0 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 @@ 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) } 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 8ce12abf203..48c3dfdf6bb 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 @@ import kotlin.math.abs private fun 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 245f9d7caec..ebb847e9637 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 @@ interface KotlinMangler { 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 @@ interface KotlinMangler { 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 { 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 51fe1825882..f19fc26ed40 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 @@ 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 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 91ef3394c66..48715e77167 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 @@ 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 } } 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 ddaffc89962..daed805fad9 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 @@ abstract class AbstractKotlinMangler : KotlinMangler { override val String.hashMangle get() = cityHash64() abstract fun getExportChecker(compatibleMode: Boolean): KotlinExportChecker - abstract fun getMangleComputer(mode: MangleMode): KotlinMangleComputer + abstract fun getMangleComputer(mode: MangleMode, compatibleMode: Boolean): KotlinMangleComputer } \ 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 33342eaf3a1..f130715d1a3 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 @@ class ManglerChecker(vararg _manglers: KotlinMangler) : IrElement private fun KotlinMangler.isExportCheck(declaration: IrDeclaration) = !declaration.shouldBeSkipped() && declaration.isExported(false) private fun KotlinMangler.stringMangle(declaration: IrDeclaration) = - declaration.mangleString() + declaration.mangleString(compatibleMode = false) private fun KotlinMangler.signatureMangle(declaration: IrDeclaration) = - declaration.signatureString() + declaration.signatureString(compatibleMode = false) private fun KotlinMangler.fqnMangle(declaration: IrDeclaration) = - declaration.fqnString() + declaration.fqnString(compatibleMode = false) private fun Iterable.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 5a4dbfba20d..a7b08904515 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.ir.util.KotlinMangler import org.jetbrains.kotlin.types.KotlinType abstract class DescriptorBasedKotlinManglerImpl : AbstractKotlinMangler(), 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 @@ 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 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 = + override fun getMangleComputer(mode: MangleMode, compatibleMode: Boolean): KotlinMangleComputer = error("Should not have been reached") override fun getExportChecker(compatibleMode: Boolean): KotlinExportChecker { 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 973eebd2c93..80bb5a25b9b 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 @@ import org.jetbrains.kotlin.ir.util.KotlinMangler abstract class IrBasedKotlinManglerImpl : AbstractKotlinMangler(), 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 7f93617b9d2..5292e8fd619 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.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 { private val typeParameterContainer = ArrayList(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) { - visitProperty(prop.owner) - } else { + if (compatibleMode || prop == null) { // act as used to be (KT-48912) + // test compiler/testData/codegen/box/ir/serializationRegressions/anonFakeOverride.kt 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 a818bafeffa..cb9a5f2ff23 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 @@ 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) 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 a5fd29ec72f..ce7c0fdf11d 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 @@ class PublicIdSignatureComputer(val mangler: KotlinMangler.IrMangler) : IdSignat scopeCounter = 0 } - private inner class PublicIdSigBuilder(private val containerSig: IdSignature? = null) : IdSignatureBuilder(), + private inner class PublicIdSigBuilder : IdSignatureBuilder(), 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 }, 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 0d3065b2e85..f4b2ba93488 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 @@ abstract class AbstractJsManglerIr : IrBasedKotlinManglerImpl() { 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 = JsIrExportChecker(compatibleMode) - override fun getMangleComputer(mode: MangleMode): KotlinMangleComputer { - return JsIrManglerComputer(StringBuilder(256), mode) + override fun getMangleComputer(mode: MangleMode, compatibleMode: Boolean): KotlinMangleComputer { + return JsIrManglerComputer(StringBuilder(256), mode, compatibleMode) } } @@ -52,7 +52,7 @@ abstract class AbstractJsDescriptorMangler : DescriptorBasedKotlinManglerImpl() override fun getExportChecker(compatibleMode: Boolean): KotlinExportChecker = exportChecker - override fun getMangleComputer(mode: MangleMode): KotlinMangleComputer { + override fun getMangleComputer(mode: MangleMode, compatibleMode: Boolean): KotlinMangleComputer { 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 90d409bf5e1..4ece809c0aa 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 @@ 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 = JvmIrExportChecker(compatibleMode) - override fun getMangleComputer(mode: MangleMode): KotlinMangleComputer = - JvmIrManglerComputer(StringBuilder(256), mode) + override fun getMangleComputer(mode: MangleMode, compatibleMode: Boolean): KotlinMangleComputer = + 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 = ExportChecker - override fun getMangleComputer(mode: MangleMode): KotlinMangleComputer = + override fun getMangleComputer(mode: MangleMode, compatibleMode: Boolean): KotlinMangleComputer = 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 c0ab278b06e..f312d340cd8 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 @@ 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 { 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 0fb5d0fe486..b791394fadd 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.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) { - 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 @@ object KonanManglerIr : AbstractKonanIrMangler(false) abstract class AbstractKonanDescriptorMangler : DescriptorBasedKotlinManglerImpl() { override fun getExportChecker(compatibleMode: Boolean): KotlinExportChecker = 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()