diff --git a/compiler/testData/codegen/box/inlineClasses/kt26103_contravariantUnderlyingType.kt b/compiler/testData/codegen/box/inlineClasses/kt26103_contravariantUnderlyingType.kt new file mode 100644 index 00000000000..ad92ebf2f63 --- /dev/null +++ b/compiler/testData/codegen/box/inlineClasses/kt26103_contravariantUnderlyingType.kt @@ -0,0 +1,58 @@ +// !LANGUAGE: +InlineClasses +// WITH_RUNTIME +// IGNORE_BACKEND: JVM_IR, JS_IR + +inline class GCmp(val xc: Comparable) +inline class GSCmp(val sc: Comparable) +inline class SCmp(val sc: Comparable) +inline class ICmp(val intc: Comparable) +inline class GICmp(val intc: Comparable) + +inline class II(val i: Int) : Comparable { + override fun compareTo(other: II): Int { + return i.compareTo(other.i) + } +} + +inline class IICmp(val iic: Comparable) +inline class GIICmp(val iic: Comparable) + +fun testGCmp(x: GCmp) { + if (x.xc.compareTo("OK") != 0) throw AssertionError() +} + +fun testGSCmp(x: GSCmp) { + if (x.sc.compareTo("OK") != 0) throw AssertionError() +} + +fun testSCmp(x: SCmp) { + if (x.sc.compareTo("OK") != 0) throw AssertionError() +} + +fun testICmp(x: ICmp) { + if (x.intc.compareTo(42) != 0) throw AssertionError() +} + +fun testGICmp(x: GICmp) { + if (x.intc.compareTo(42) != 0) throw AssertionError() +} + +fun testIICmp(x: IICmp) { + if (x.iic.compareTo(II(42)) != 0) throw AssertionError() +} + +fun testGIICmp(x: GIICmp) { + if (x.iic.compareTo(II(42)) != 0) throw AssertionError() +} + +fun box(): String { + testGCmp(GCmp("OK")) + testGSCmp(GSCmp("OK")) + testSCmp(SCmp("OK")) + testICmp(ICmp(42)) + testGICmp(GICmp(42)) + testIICmp(IICmp(II(42))) + testGIICmp(GIICmp(II(42))) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/inlineClasses/kt26103_covariantUnderlyingType.kt b/compiler/testData/codegen/box/inlineClasses/kt26103_covariantUnderlyingType.kt new file mode 100644 index 00000000000..d9528471540 --- /dev/null +++ b/compiler/testData/codegen/box/inlineClasses/kt26103_covariantUnderlyingType.kt @@ -0,0 +1,53 @@ +// !LANGUAGE: +InlineClasses +// WITH_RUNTIME +// IGNORE_BACKEND: JVM_IR, JS_IR + +inline class GList(val xs: List) +inline class GSList(val ss: List) +inline class SList(val ss: List) +inline class IList(val ints: List) +inline class GIList(val ints: List) + +inline class II(val i: Int) +inline class IIList(val iis: List) +inline class GIIList(val iis: List) + +fun testGList(gl: GList) { + if (gl.xs[0] != "OK") throw AssertionError() +} + +fun testGSList(sl: GSList) { + if (sl.ss[0] != "OK") throw AssertionError() +} + +fun testSList(sl: SList) { + if (sl.ss[0] != "OK") throw AssertionError() +} + +fun testIList(il: IList) { + if (il.ints[0] != 42) throw AssertionError() +} + +fun testGIList(gil: GIList) { + if (gil.ints[0] != 42) throw AssertionError() +} + +fun testIIList(iil: IIList) { + if (iil.iis[0].i != 42) throw AssertionError() +} + +fun testGIIList(giil: GIIList) { + if (giil.iis[0].i != 42) throw AssertionError() +} + +fun box(): String { + testGList(GList(listOf("OK"))) + testGSList(GSList(listOf("OK"))) + testSList(SList(listOf("OK"))) + testIList(IList(listOf(42))) + testGIList(GIList(listOf(42))) + testIIList(IIList(listOf(II(42)))) + testGIIList(GIIList(listOf(II(42)))) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/writeSignature/inlineClasses/inlineClassWithComplexSubstitutedType.kt b/compiler/testData/writeSignature/inlineClasses/inlineClassWithComplexSubstitutedType.kt index a3cdcdeb0e6..e1c78e03220 100644 --- a/compiler/testData/writeSignature/inlineClasses/inlineClassWithComplexSubstitutedType.kt +++ b/compiler/testData/writeSignature/inlineClasses/inlineClassWithComplexSubstitutedType.kt @@ -1,24 +1,41 @@ // !LANGUAGE: +InlineClasses -class Inv - -inline class AsList(val list: List) inline class UInt(val value: Int) +inline class AsList(val list: List) +inline class AsCmp(val cmp: Comparable) + object Test { - fun withInlineClassArgument(a: AsList) {} + fun withInlineClassArgumentOut(a: AsList) {} + fun withInlineClassArgumentIn(a: AsCmp) {} + fun withListOfInlineClassArgument(a: AsList>) {} - fun withInnerGenericInlineClass(a: AsList>>) {} + fun withComparableOfInlineClassArgument(a: AsCmp>) {} + + fun withInnerGenericInlineClassOut(a: AsList>>) {} + fun withInnerGenericInlineClassIn(a: AsCmp>>) {} } -// method: Test::withInlineClassArgument +// method: Test::withInlineClassArgumentOut // jvm signature: (Ljava/util/List;)V // generic signature: (Ljava/util/List;)V +// method: Test::withInlineClassArgumentIn +// jvm signature: (Ljava/lang/Comparable;)V +// generic signature: (Ljava/lang/Comparable<-LUInt;>;)V + // method: Test::withListOfInlineClassArgument // jvm signature: (Ljava/util/List;)V // generic signature: (Ljava/util/List<+Ljava/util/List;>;)V -// method: Test::withInnerGenericInlineClass +// method: Test::withComparableOfInlineClassArgument +// jvm signature: (Ljava/lang/Comparable;)V +// generic signature: (Ljava/lang/Comparable<-Ljava/lang/Comparable<-LUInt;>;>;)V + +// method: Test::withInnerGenericInlineClassOut // jvm signature: (Ljava/util/List;)V -// generic signature: (Ljava/util/List;>;>;)V +// generic signature: (Ljava/util/List;>;>;)V + +// method: Test::withInnerGenericInlineClassIn +// jvm signature: (Ljava/lang/Comparable;)V +// generic signature: (Ljava/lang/Comparable<-LAsCmp;>;>;)V \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java index bd63770b1e8..13e82d95464 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java @@ -11553,6 +11553,16 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { runTest("compiler/testData/codegen/box/inlineClasses/kt26103.kt"); } + @TestMetadata("kt26103_contravariantUnderlyingType.kt") + public void testKt26103_contravariantUnderlyingType() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt26103_contravariantUnderlyingType.kt"); + } + + @TestMetadata("kt26103_covariantUnderlyingType.kt") + public void testKt26103_covariantUnderlyingType() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt26103_covariantUnderlyingType.kt"); + } + @TestMetadata("kt26103_original.kt") public void testKt26103_original() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt26103_original.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java index abec48634f4..39ea4de3fab 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java @@ -11553,6 +11553,16 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes runTest("compiler/testData/codegen/box/inlineClasses/kt26103.kt"); } + @TestMetadata("kt26103_contravariantUnderlyingType.kt") + public void testKt26103_contravariantUnderlyingType() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt26103_contravariantUnderlyingType.kt"); + } + + @TestMetadata("kt26103_covariantUnderlyingType.kt") + public void testKt26103_covariantUnderlyingType() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt26103_covariantUnderlyingType.kt"); + } + @TestMetadata("kt26103_original.kt") public void testKt26103_original() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt26103_original.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java index 733e8c865f8..e8bfb63a172 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java @@ -11553,6 +11553,16 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes runTest("compiler/testData/codegen/box/inlineClasses/kt26103.kt"); } + @TestMetadata("kt26103_contravariantUnderlyingType.kt") + public void testKt26103_contravariantUnderlyingType() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt26103_contravariantUnderlyingType.kt"); + } + + @TestMetadata("kt26103_covariantUnderlyingType.kt") + public void testKt26103_covariantUnderlyingType() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt26103_covariantUnderlyingType.kt"); + } + @TestMetadata("kt26103_original.kt") public void testKt26103_original() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt26103_original.kt"); diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/kotlin/TypeMappingMode.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/kotlin/TypeMappingMode.kt index bc070378d3a..01509afdc68 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/kotlin/TypeMappingMode.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/kotlin/TypeMappingMode.kt @@ -107,7 +107,9 @@ class TypeMappingMode private constructor( if (type.isInlineClassType() && shouldUseUnderlyingType(type)) { val underlyingType = computeUnderlyingType(type) if (underlyingType != null) { - return getOptimalModeForSignaturePart(underlyingType, isForAnnotationParameter, canBeUsedInSupertypePosition) + return getOptimalModeForSignaturePart( + underlyingType, isForAnnotationParameter, canBeUsedInSupertypePosition + ).dontWrapInlineClassesMode() } } @@ -161,4 +163,10 @@ class TypeMappingMode private constructor( needPrimitiveBoxing, true, isForAnnotationParameter, skipDeclarationSiteWildcards, skipDeclarationSiteWildcardsIfPossible, genericArgumentMode, kotlinCollectionsToJavaCollections, genericContravariantArgumentMode, genericInvariantArgumentMode ) + + fun dontWrapInlineClassesMode(): TypeMappingMode = + TypeMappingMode( + needPrimitiveBoxing, false, isForAnnotationParameter, skipDeclarationSiteWildcards, skipDeclarationSiteWildcardsIfPossible, + genericArgumentMode, kotlinCollectionsToJavaCollections, genericContravariantArgumentMode, genericInvariantArgumentMode + ) } diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/IrJsCodegenBoxTestGenerated.java b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/IrJsCodegenBoxTestGenerated.java index b8c601f20e0..a43a4360c59 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/IrJsCodegenBoxTestGenerated.java +++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/IrJsCodegenBoxTestGenerated.java @@ -10123,6 +10123,16 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { runTest("compiler/testData/codegen/box/inlineClasses/kt26103.kt"); } + @TestMetadata("kt26103_contravariantUnderlyingType.kt") + public void testKt26103_contravariantUnderlyingType() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt26103_contravariantUnderlyingType.kt"); + } + + @TestMetadata("kt26103_covariantUnderlyingType.kt") + public void testKt26103_covariantUnderlyingType() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt26103_covariantUnderlyingType.kt"); + } + @TestMetadata("kt26103_original.kt") public void testKt26103_original() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt26103_original.kt"); diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java index 0617a3bc43f..35369955a72 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java +++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java @@ -11178,6 +11178,16 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { runTest("compiler/testData/codegen/box/inlineClasses/kt26103.kt"); } + @TestMetadata("kt26103_contravariantUnderlyingType.kt") + public void testKt26103_contravariantUnderlyingType() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt26103_contravariantUnderlyingType.kt"); + } + + @TestMetadata("kt26103_covariantUnderlyingType.kt") + public void testKt26103_covariantUnderlyingType() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt26103_covariantUnderlyingType.kt"); + } + @TestMetadata("kt26103_original.kt") public void testKt26103_original() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt26103_original.kt");