diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.kt index bc64c14b0e2..eb027dfb59d 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.kt @@ -32,6 +32,7 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.classId import org.jetbrains.kotlin.resolve.descriptorUtil.isEffectivelyPrivateApi import org.jetbrains.kotlin.resolve.descriptorUtil.nonSourceAnnotations import org.jetbrains.kotlin.resolve.jvm.annotations.hasJvmDefaultAnnotation +import org.jetbrains.kotlin.resolve.jvm.requiresFunctionNameManglingForParameterTypes import org.jetbrains.kotlin.resolve.jvm.requiresFunctionNameManglingForReturnType import org.jetbrains.kotlin.serialization.DescriptorSerializer import org.jetbrains.kotlin.serialization.DescriptorSerializer.Companion.writeVersionRequirement @@ -202,7 +203,10 @@ class JvmSerializerExtension @JvmOverloads constructor( versionRequirementTable?.writeInlineParameterNullCheckRequirement(proto::addVersionRequirement) } - if (requiresFunctionNameManglingForReturnType(descriptor)) { + if (requiresFunctionNameManglingForReturnType(descriptor) && + !DescriptorUtils.hasJvmNameAnnotation(descriptor) && + !requiresFunctionNameManglingForParameterTypes(descriptor) + ) { versionRequirementTable?.writeFunctionNameManglingForReturnTypeRequirement(proto::addVersionRequirement) } } @@ -267,7 +271,7 @@ class JvmSerializerExtension @JvmOverloads constructor( versionRequirementTable?.writeInlineParameterNullCheckRequirement(proto::addVersionRequirement) } - if (requiresFunctionNameManglingForReturnType(descriptor)) { + if (!DescriptorUtils.hasJvmNameAnnotation(descriptor) && requiresFunctionNameManglingForReturnType(descriptor)) { versionRequirementTable?.writeFunctionNameManglingForReturnTypeRequirement(proto::addVersionRequirement) } } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/inlineClassManglingUtils.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/inlineClassManglingUtils.kt index de85ad43b88..edf1a14238d 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/inlineClassManglingUtils.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/inlineClassManglingUtils.kt @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.codegen.state import org.jetbrains.kotlin.codegen.coroutines.unwrapInitialDescriptorForSuspendFunction import org.jetbrains.kotlin.descriptors.* +import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.resolve.InlineClassDescriptorResolver import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe import org.jetbrains.kotlin.resolve.jvm.requiresFunctionNameManglingForParameterTypes @@ -24,10 +25,13 @@ fun getManglingSuffixBasedOnKotlinSignature( if (descriptor is ConstructorDescriptor) return null if (InlineClassDescriptorResolver.isSynthesizedBoxOrUnboxMethod(descriptor)) return null + // Don't mangle functions with '@JvmName' annotation. + // Some stdlib functions ('Result.success', 'Result.failure') are annotated with '@JvmName' as a workaround for forward compatibility. + if (DescriptorUtils.hasJvmNameAnnotation(descriptor)) return null + // If a function accepts inline class parameters, mangle its name. - val actualValueParameterTypes = listOfNotNull(descriptor.extensionReceiverParameter?.type) + descriptor.valueParameters.map { it.type } - if (requiresFunctionNameManglingForParameterTypes(actualValueParameterTypes)) { - return "-" + md5base64(collectSignatureForMangling(actualValueParameterTypes)) + if (requiresFunctionNameManglingForParameterTypes(descriptor)) { + return "-" + md5base64(collectSignatureForMangling(descriptor)) } // If a class member function returns inline class value, mangle its name. @@ -42,8 +46,10 @@ fun getManglingSuffixBasedOnKotlinSignature( return null } -private fun collectSignatureForMangling(types: List) = - types.joinToString { getSignatureElementForMangling(it) } +private fun collectSignatureForMangling(descriptor: CallableMemberDescriptor): String { + val types = listOfNotNull(descriptor.extensionReceiverParameter?.type) + descriptor.valueParameters.map { it.type } + return types.joinToString { getSignatureElementForMangling(it) } +} private fun getSignatureElementForMangling(type: KotlinType): String = buildString { val descriptor = type.constructor.declarationDescriptor ?: return "" diff --git a/compiler/fir/fir2ir/tests/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java b/compiler/fir/fir2ir/tests/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java index 120c65796db..019dc526324 100644 --- a/compiler/fir/fir2ir/tests/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java +++ b/compiler/fir/fir2ir/tests/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java @@ -13023,6 +13023,11 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT runTest("compiler/testData/codegen/box/inlineClasses/noReturnTypeMangling.kt"); } + @TestMetadata("noReturnTypeManglingJvmName.kt") + public void testNoReturnTypeManglingJvmName() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/noReturnTypeManglingJvmName.kt"); + } + @TestMetadata("nullableEqeqNonNull.kt") public void testNullableEqeqNonNull() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/nullableEqeqNonNull.kt"); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/declarationCheckers.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/declarationCheckers.kt index 4ee2beb2eed..d6817d7932c 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/declarationCheckers.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/declarationCheckers.kt @@ -150,7 +150,7 @@ class JvmNameAnnotationChecker : DeclarationChecker { if (DescriptorUtils.isOverride(descriptor) || descriptor.isOverridable) { diagnosticHolder.report(ErrorsJvm.INAPPLICABLE_JVM_NAME.on(annotationEntry)) } else if (descriptor.containingDeclaration.isInlineClassThatRequiresMangling() || - requiresFunctionNameManglingForParameterTypes(descriptor.valueParameters.map { it.type }) || + requiresFunctionNameManglingForParameterTypes(descriptor) || requiresFunctionNameManglingForReturnType(descriptor) ) { diagnosticHolder.report(ErrorsJvm.INAPPLICABLE_JVM_NAME.on(annotationEntry)) diff --git a/compiler/testData/codegen/box/inlineClasses/noReturnTypeManglingJvmName.kt b/compiler/testData/codegen/box/inlineClasses/noReturnTypeManglingJvmName.kt new file mode 100644 index 00000000000..dccdebca29f --- /dev/null +++ b/compiler/testData/codegen/box/inlineClasses/noReturnTypeManglingJvmName.kt @@ -0,0 +1,16 @@ +// !LANGUAGE: +InlineClasses -MangleClassMembersReturningInlineClasses +// WITH_RUNTIME +// TARGET_BACKEND: JVM + +inline class S(val x: String) + +class Test { + @Suppress("INAPPLICABLE_JVM_NAME") + @JvmName("getO") + fun getOK() = S("OK") +} + +fun box(): String { + val t = Test() + return t.getOK().x +} \ No newline at end of file diff --git a/compiler/testData/codegen/boxInline/inlineClasses/noReturnTypeManglingFunJvmName.kt b/compiler/testData/codegen/boxInline/inlineClasses/noReturnTypeManglingFunJvmName.kt new file mode 100644 index 00000000000..6d83786d9a2 --- /dev/null +++ b/compiler/testData/codegen/boxInline/inlineClasses/noReturnTypeManglingFunJvmName.kt @@ -0,0 +1,20 @@ +// !LANGUAGE: +InlineClasses -MangleClassMembersReturningInlineClasses +// WITH_RUNTIME +// TARGET_BACKEND: JVM + +// FILE: 1.kt + +package test + +inline class S(val string: String) + +@Suppress("INAPPLICABLE_JVM_NAME") +@JvmName("foo") +inline fun foo() = S("OK") + +// FILE: 2.kt + +import test.* + +fun box() : String = + foo().string diff --git a/compiler/testData/codegen/boxInline/inlineClasses/withReturnTypeManglingFunJvmName.kt b/compiler/testData/codegen/boxInline/inlineClasses/withReturnTypeManglingFunJvmName.kt new file mode 100644 index 00000000000..d4998521c95 --- /dev/null +++ b/compiler/testData/codegen/boxInline/inlineClasses/withReturnTypeManglingFunJvmName.kt @@ -0,0 +1,20 @@ +// !LANGUAGE: +InlineClasses +MangleClassMembersReturningInlineClasses +// WITH_RUNTIME +// TARGET_BACKEND: JVM + +// FILE: 1.kt + +package test + +inline class S(val string: String) + +@Suppress("INAPPLICABLE_JVM_NAME") +@JvmName("foo") +inline fun foo() = S("OK") + +// FILE: 2.kt + +import test.* + +fun box() : String = + foo().string diff --git a/compiler/testData/codegen/bytecodeText/inlineClasses/noManglingForFunctionsWithJvmName.kt b/compiler/testData/codegen/bytecodeText/inlineClasses/noManglingForFunctionsWithJvmName.kt new file mode 100644 index 00000000000..533b009b0e3 --- /dev/null +++ b/compiler/testData/codegen/bytecodeText/inlineClasses/noManglingForFunctionsWithJvmName.kt @@ -0,0 +1,21 @@ +// WITH_RUNTIME +inline class IC(val x: Int) + +class C { + @Suppress("INAPPLICABLE_JVM_NAME") + @JvmName("test") + fun test() = IC(42) + + @Suppress("INAPPLICABLE_JVM_NAME") + @JvmName("differentName") + fun test2() = IC(42) +} + +fun call1() = C().test() + +fun call2() = C().test2() + +// 1 public final test\(\)I +// 1 INVOKEVIRTUAL C.test \(\)I +// 1 public final differentName\(\)I +// 1 INVOKEVIRTUAL C.differentName \(\)I diff --git a/compiler/testData/versionRequirement/inlineClassReturnTypeMangled.kt b/compiler/testData/versionRequirement/inlineClassReturnTypeMangled.kt index 55642cbc600..1d52e0c3bde 100644 --- a/compiler/testData/versionRequirement/inlineClassReturnTypeMangled.kt +++ b/compiler/testData/versionRequirement/inlineClassReturnTypeMangled.kt @@ -5,6 +5,10 @@ inline class IC(val x: Int) class C { fun returnsInlineClassType(): IC = IC(42) val propertyOfInlineClassType: IC get() = IC(42) + + @Suppress("INAPPLICABLE_JVM_NAME") + @JvmName("returnsInlineClassTypeJvmName") + fun returnsInlineClassTypeJvmName(): IC = IC(42) } fun returnsInlineClassType(): IC = IC(42) diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java index a49c9d2efd9..002854c588c 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java @@ -14238,6 +14238,11 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { runTest("compiler/testData/codegen/box/inlineClasses/noReturnTypeMangling.kt"); } + @TestMetadata("noReturnTypeManglingJvmName.kt") + public void testNoReturnTypeManglingJvmName() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/noReturnTypeManglingJvmName.kt"); + } + @TestMetadata("nullableEqeqNonNull.kt") public void testNullableEqeqNonNull() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/nullableEqeqNonNull.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxInlineCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxInlineCodegenTestGenerated.java index 8bc373049b8..fe5371bb07c 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxInlineCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxInlineCodegenTestGenerated.java @@ -1896,6 +1896,11 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo runTest("compiler/testData/codegen/boxInline/inlineClasses/noReturnTypeManglingFun.kt"); } + @TestMetadata("noReturnTypeManglingFunJvmName.kt") + public void testNoReturnTypeManglingFunJvmName() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/noReturnTypeManglingFunJvmName.kt"); + } + @TestMetadata("noReturnTypeManglingVal.kt") public void testNoReturnTypeManglingVal() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/noReturnTypeManglingVal.kt"); @@ -1906,6 +1911,11 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo runTest("compiler/testData/codegen/boxInline/inlineClasses/withReturnTypeManglingFun.kt"); } + @TestMetadata("withReturnTypeManglingFunJvmName.kt") + public void testWithReturnTypeManglingFunJvmName() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/withReturnTypeManglingFunJvmName.kt"); + } + @TestMetadata("withReturnTypeManglingVal.kt") public void testWithReturnTypeManglingVal() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/withReturnTypeManglingVal.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/BytecodeTextTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/BytecodeTextTestGenerated.java index 78c0ac37993..b0ccbd6c106 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/BytecodeTextTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/BytecodeTextTestGenerated.java @@ -2951,6 +2951,11 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { runTest("compiler/testData/codegen/bytecodeText/inlineClasses/noBoxingUnboxingInAccessorsForDelegatedPropertyWithInlineClassDelegate.kt"); } + @TestMetadata("noManglingForFunctionsWithJvmName.kt") + public void testNoManglingForFunctionsWithJvmName() throws Exception { + runTest("compiler/testData/codegen/bytecodeText/inlineClasses/noManglingForFunctionsWithJvmName.kt"); + } + @TestMetadata("noReturnTypeMangling.kt") public void testNoReturnTypeMangling() throws Exception { runTest("compiler/testData/codegen/bytecodeText/inlineClasses/noReturnTypeMangling.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/CompileKotlinAgainstInlineKotlinTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/CompileKotlinAgainstInlineKotlinTestGenerated.java index a6e3c908cfd..ca5bec0ce09 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/CompileKotlinAgainstInlineKotlinTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/CompileKotlinAgainstInlineKotlinTestGenerated.java @@ -1896,6 +1896,11 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi runTest("compiler/testData/codegen/boxInline/inlineClasses/noReturnTypeManglingFun.kt"); } + @TestMetadata("noReturnTypeManglingFunJvmName.kt") + public void testNoReturnTypeManglingFunJvmName() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/noReturnTypeManglingFunJvmName.kt"); + } + @TestMetadata("noReturnTypeManglingVal.kt") public void testNoReturnTypeManglingVal() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/noReturnTypeManglingVal.kt"); @@ -1906,6 +1911,11 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi runTest("compiler/testData/codegen/boxInline/inlineClasses/withReturnTypeManglingFun.kt"); } + @TestMetadata("withReturnTypeManglingFunJvmName.kt") + public void testWithReturnTypeManglingFunJvmName() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/withReturnTypeManglingFunJvmName.kt"); + } + @TestMetadata("withReturnTypeManglingVal.kt") public void testWithReturnTypeManglingVal() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/withReturnTypeManglingVal.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java index 71d66886206..eec8e6adc73 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java @@ -14243,6 +14243,11 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes runTest("compiler/testData/codegen/box/inlineClasses/noReturnTypeMangling.kt"); } + @TestMetadata("noReturnTypeManglingJvmName.kt") + public void testNoReturnTypeManglingJvmName() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/noReturnTypeManglingJvmName.kt"); + } + @TestMetadata("nullableEqeqNonNull.kt") public void testNullableEqeqNonNull() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/nullableEqeqNonNull.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java index 3a1f7d58377..68071003cc2 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java @@ -13023,6 +13023,11 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes runTest("compiler/testData/codegen/box/inlineClasses/noReturnTypeMangling.kt"); } + @TestMetadata("noReturnTypeManglingJvmName.kt") + public void testNoReturnTypeManglingJvmName() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/noReturnTypeManglingJvmName.kt"); + } + @TestMetadata("nullableEqeqNonNull.kt") public void testNullableEqeqNonNull() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/nullableEqeqNonNull.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxInlineCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxInlineCodegenTestGenerated.java index 053bd47b714..40a0ece26f1 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxInlineCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxInlineCodegenTestGenerated.java @@ -1896,6 +1896,11 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli runTest("compiler/testData/codegen/boxInline/inlineClasses/noReturnTypeManglingFun.kt"); } + @TestMetadata("noReturnTypeManglingFunJvmName.kt") + public void testNoReturnTypeManglingFunJvmName() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/noReturnTypeManglingFunJvmName.kt"); + } + @TestMetadata("noReturnTypeManglingVal.kt") public void testNoReturnTypeManglingVal() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/noReturnTypeManglingVal.kt"); @@ -1906,6 +1911,11 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli runTest("compiler/testData/codegen/boxInline/inlineClasses/withReturnTypeManglingFun.kt"); } + @TestMetadata("withReturnTypeManglingFunJvmName.kt") + public void testWithReturnTypeManglingFunJvmName() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/withReturnTypeManglingFunJvmName.kt"); + } + @TestMetadata("withReturnTypeManglingVal.kt") public void testWithReturnTypeManglingVal() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/withReturnTypeManglingVal.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBytecodeTextTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBytecodeTextTestGenerated.java index 3939d6967f4..4173b4ec9a3 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBytecodeTextTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBytecodeTextTestGenerated.java @@ -3036,6 +3036,11 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { runTest("compiler/testData/codegen/bytecodeText/inlineClasses/noBoxingUnboxingInAccessorsForDelegatedPropertyWithInlineClassDelegate.kt"); } + @TestMetadata("noManglingForFunctionsWithJvmName.kt") + public void testNoManglingForFunctionsWithJvmName() throws Exception { + runTest("compiler/testData/codegen/bytecodeText/inlineClasses/noManglingForFunctionsWithJvmName.kt"); + } + @TestMetadata("noReturnTypeMangling.kt") public void testNoReturnTypeMangling() throws Exception { runTest("compiler/testData/codegen/bytecodeText/inlineClasses/noReturnTypeMangling.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrCompileKotlinAgainstInlineKotlinTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrCompileKotlinAgainstInlineKotlinTestGenerated.java index 97b3758c830..541c9f87e43 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrCompileKotlinAgainstInlineKotlinTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrCompileKotlinAgainstInlineKotlinTestGenerated.java @@ -1896,6 +1896,11 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC runTest("compiler/testData/codegen/boxInline/inlineClasses/noReturnTypeManglingFun.kt"); } + @TestMetadata("noReturnTypeManglingFunJvmName.kt") + public void testNoReturnTypeManglingFunJvmName() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/noReturnTypeManglingFunJvmName.kt"); + } + @TestMetadata("noReturnTypeManglingVal.kt") public void testNoReturnTypeManglingVal() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/noReturnTypeManglingVal.kt"); @@ -1906,6 +1911,11 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC runTest("compiler/testData/codegen/boxInline/inlineClasses/withReturnTypeManglingFun.kt"); } + @TestMetadata("withReturnTypeManglingFunJvmName.kt") + public void testWithReturnTypeManglingFunJvmName() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/withReturnTypeManglingFunJvmName.kt"); + } + @TestMetadata("withReturnTypeManglingVal.kt") public void testWithReturnTypeManglingVal() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/withReturnTypeManglingVal.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/serialization/JvmVersionRequirementTest.kt b/compiler/tests/org/jetbrains/kotlin/serialization/JvmVersionRequirementTest.kt index 11d4eed14f7..c3edf7c915a 100644 --- a/compiler/tests/org/jetbrains/kotlin/serialization/JvmVersionRequirementTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/serialization/JvmVersionRequirementTest.kt @@ -145,6 +145,7 @@ class JvmVersionRequirementTest : AbstractVersionRequirementTest() { doTest( VersionRequirement.Version(1, 3, 0), DeprecationLevel.ERROR, null, LANGUAGE_VERSION, null, fqNamesWithRequirements = listOf( + "test.C.returnsInlineClassTypeJvmName", "test.returnsInlineClassType", "test.propertyOfInlineClassType" ), diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/resolve/jvm/inlineClassManglingRules.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/resolve/jvm/inlineClassManglingRules.kt index 1088d8ac532..2993886c087 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/resolve/jvm/inlineClassManglingRules.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/resolve/jvm/inlineClassManglingRules.kt @@ -24,8 +24,10 @@ fun shouldHideConstructorDueToInlineClassTypeValueParameters(descriptor: Callabl return constructorDescriptor.valueParameters.any { it.type.requiresFunctionNameManglingInParameterTypes() } } -fun requiresFunctionNameManglingForParameterTypes(valueParameterTypes: List): Boolean { - return valueParameterTypes.any { it.requiresFunctionNameManglingInParameterTypes() } +fun requiresFunctionNameManglingForParameterTypes(descriptor: CallableMemberDescriptor): Boolean { + val extensionReceiverType = descriptor.extensionReceiverParameter?.type + return extensionReceiverType != null && extensionReceiverType.requiresFunctionNameManglingInParameterTypes() || + descriptor.valueParameters.any { it.type.requiresFunctionNameManglingInParameterTypes() } } // NB functions returning all inline classes (including our special 'kotlin.Result') should be mangled. diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.java index 5804fb3f14a..38e82368bc9 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.java +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.java @@ -569,6 +569,10 @@ public class DescriptorUtils { return annotated.getAnnotations().findAnnotation(JVM_NAME); } + public static boolean hasJvmNameAnnotation(@NotNull Annotated annotated) { + return findJvmNameAnnotation(annotated) != null; + } + @NotNull public static SourceFile getContainingSourceFile(@NotNull DeclarationDescriptor descriptor) { if (descriptor instanceof PropertySetterDescriptor) { diff --git a/js/js.translator/testData/lineNumbers/coroutine.kt b/js/js.translator/testData/lineNumbers/coroutine.kt index a73d4107732..41b8a593698 100644 --- a/js/js.translator/testData/lineNumbers/coroutine.kt +++ b/js/js.translator/testData/lineNumbers/coroutine.kt @@ -14,4 +14,4 @@ suspend fun bar(): Unit { println(a + b) } -// LINES: 38 4 4 4 7 5 5 44 44 5 89 44 5 5 6 4 4 4 9 15 9 9 9 * 9 15 10 10 11 11 11 11 11 * 11 12 12 13 13 13 13 13 13 13 14 14 * 9 15 9 9 9 9 \ No newline at end of file +// LINES: 38 4 4 4 7 5 5 44 44 5 92 44 5 5 6 4 4 4 9 15 9 9 9 * 9 15 10 10 11 11 11 11 11 * 11 12 12 13 13 13 13 13 13 13 14 14 * 9 15 9 9 9 9 \ No newline at end of file diff --git a/libraries/stdlib/src/kotlin/util/Result.kt b/libraries/stdlib/src/kotlin/util/Result.kt index 28beacd0763..a2e519aebd9 100644 --- a/libraries/stdlib/src/kotlin/util/Result.kt +++ b/libraries/stdlib/src/kotlin/util/Result.kt @@ -10,6 +10,7 @@ package kotlin import kotlin.contracts.* import kotlin.internal.InlineOnly import kotlin.jvm.JvmField +import kotlin.jvm.JvmName /** * A discriminated union that encapsulates a successful outcome with a value of type [T] @@ -84,14 +85,18 @@ public inline class Result @PublishedApi internal constructor( /** * Returns an instance that encapsulates the given [value] as successful value. */ + @Suppress("INAPPLICABLE_JVM_NAME") @InlineOnly + @JvmName("success") public inline fun success(value: T): Result = Result(value) /** * Returns an instance that encapsulates the given [Throwable] [exception] as failure. */ + @Suppress("INAPPLICABLE_JVM_NAME") @InlineOnly + @JvmName("failure") public inline fun failure(exception: Throwable): Result = Result(createFailure(exception)) }