From 0c21d6329066faf58c87280624e154f1aa106692 Mon Sep 17 00:00:00 2001 From: Dmitry Petrov Date: Tue, 7 Apr 2020 17:01:19 +0300 Subject: [PATCH] Box inline class return value in covariant override of suspend fun --- .../kotlin/codegen/state/KotlinTypeMapper.kt | 45 ++++-- .../ir/FirBlackBoxCodegenTestGenerated.java | 115 ++++++++++++++ .../covariantOverrideSuspendFun.kt | 45 ++++++ ...errideSuspendFunWithNullableInlineClass.kt | 47 ++++++ ...deSuspendFunWithNullableInlineClass_Any.kt | 46 ++++++ ...deSuspendFunWithNullableInlineClass_Int.kt | 49 ++++++ ...dFunWithNullableInlineClass_NullableAny.kt | 45 ++++++ ...ithNullableInlineClass_NullableAny_null.kt | 56 +++++++ ...dFunWithNullableInlineClass_NullableInt.kt | 49 ++++++ ...ithNullableInlineClass_NullableInt_null.kt | 49 ++++++ .../covariantOverrideSuspendFun_Any.kt | 46 ++++++ .../covariantOverrideSuspendFun_Int.kt | 50 +++++++ .../genericOverrideSuspendFun.kt | 29 ++++ .../genericOverrideSuspendFun_Any.kt | 29 ++++ ...ndFun_Any_NullableInlineClassUpperBound.kt | 29 ++++ .../genericOverrideSuspendFun_Int.kt | 32 ++++ .../genericOverrideSuspendFun_NullableAny.kt | 29 ++++ ...ericOverrideSuspendFun_NullableAny_null.kt | 32 ++++ .../genericOverrideSuspendFun_NullableInt.kt | 32 ++++ ...ericOverrideSuspendFun_NullableInt_null.kt | 32 ++++ .../inlineClasses/overrideSuspendFun.kt | 110 ++++++++++++++ .../inlineClasses/overrideSuspendFun_Any.kt | 104 +++++++++++++ .../overrideSuspendFun_Any_itf.kt | 38 +++++ .../overrideSuspendFun_Any_this.kt | 37 +++++ .../inlineClasses/overrideSuspendFun_Int.kt | 113 ++++++++++++++ .../codegen/BlackBoxCodegenTestGenerated.java | 140 ++++++++++++++++++ .../LightAnalysisModeTestGenerated.java | 140 ++++++++++++++++++ .../ir/IrBlackBoxCodegenTestGenerated.java | 115 ++++++++++++++ .../IrJsCodegenBoxTestGenerated.java | 115 ++++++++++++++ .../semantics/JsCodegenBoxTestGenerated.java | 115 ++++++++++++++ 30 files changed, 1900 insertions(+), 13 deletions(-) create mode 100644 compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun.kt create mode 100644 compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass.kt create mode 100644 compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_Any.kt create mode 100644 compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_Int.kt create mode 100644 compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny.kt create mode 100644 compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null.kt create mode 100644 compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt.kt create mode 100644 compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null.kt create mode 100644 compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun_Any.kt create mode 100644 compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun_Int.kt create mode 100644 compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun.kt create mode 100644 compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Any.kt create mode 100644 compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Any_NullableInlineClassUpperBound.kt create mode 100644 compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Int.kt create mode 100644 compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableAny.kt create mode 100644 compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableAny_null.kt create mode 100644 compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableInt.kt create mode 100644 compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableInt_null.kt create mode 100644 compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun.kt create mode 100644 compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any.kt create mode 100644 compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any_itf.kt create mode 100644 compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any_this.kt create mode 100644 compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Int.kt diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt index a4ae550fa5a..62f1f478df1 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt @@ -88,7 +88,7 @@ class KotlinTypeMapper @JvmOverloads constructor( private val isIrBackend: Boolean = false, private val typePreprocessor: ((KotlinType) -> KotlinType?)? = null, private val namePreprocessor: ((ClassDescriptor) -> String?)? = null -): KotlinTypeMapperBase() { +) : KotlinTypeMapperBase() { private val isReleaseCoroutines = languageVersionSettings.supportsFeature(LanguageFeature.ReleaseCoroutines) private val typeMappingConfiguration = object : TypeMappingConfiguration { @@ -269,10 +269,6 @@ class KotlinTypeMapper @JvmOverloads constructor( } } - private fun mapInlineClassType(kotlinType: KotlinType): Type { - return mapInlineClassType(kotlinType, TypeMappingMode.DEFAULT, typeMappingConfiguration) - } - private fun writeGenericType( type: KotlinType, asmType: Type, @@ -367,14 +363,37 @@ class KotlinTypeMapper @JvmOverloads constructor( ?: functionDescriptor.returnType!! private fun getActualReturnTypeForSuspendFunctionWithInlineClassReturnTypeHack(functionDescriptor: FunctionDescriptor): KotlinType? { - val originalSuspendFunctionForJvmView = functionDescriptor.unwrapInitialDescriptorForSuspendFunction() - if (originalSuspendFunctionForJvmView === functionDescriptor) return null - val originalReturnType = originalSuspendFunctionForJvmView.returnType!! + // For each suspend function, we have a corresponding JVM view function that has an extra continuation parameter, + // and, more importantly, returns 'kotlin.Any' (so that it can return as a reference value or a special COROUTINE_SUSPENDED object). + // This also causes boxing of primitives and inline class values. + // If we have a function returning an inline class value that is mapped to a reference type, we want to avoid boxing. + // However, we have to do that consistently both on declaration site and on call site in case of covariant overrides. + + if (!functionDescriptor.isSuspend) return null + + val originalSuspendFunction = functionDescriptor.unwrapInitialDescriptorForSuspendFunction() + val originalReturnType = originalSuspendFunction.returnType!! if (!originalReturnType.isInlineClassType()) return null - val jvmReturnType = mapType(originalReturnType) - return if (AsmUtil.isPrimitive(jvmReturnType)) null else originalReturnType + + if (!originalReturnType.isInlineClassTypeSafeToKeepUnboxedOnSuspendFunReturn()) { + return originalSuspendFunction.module.builtIns.nullableAnyType + } + + // NB JVM view of a Kotlin function overrides JVM views of corresponding overridden functions + val originalOverridden = getAllOverriddenDeclarations(functionDescriptor).map { + it.unwrapInitialDescriptorForSuspendFunction().original + } + if (originalOverridden.any { !it.returnType!!.isInlineClassTypeSafeToKeepUnboxedOnSuspendFunReturn() }) { + return originalSuspendFunction.module.builtIns.nullableAnyType + } + + return originalReturnType } + private fun KotlinType.isInlineClassTypeSafeToKeepUnboxedOnSuspendFunReturn(): Boolean = + isInlineClassType() && !AsmUtil.isPrimitive(mapType(this)) && (!isMarkedNullable || !isNullableUnderlyingType()) + + @JvmOverloads fun mapToCallableMethod( descriptor: FunctionDescriptor, @@ -806,13 +825,13 @@ class KotlinTypeMapper @JvmOverloads constructor( } } else { val directMember = DescriptorUtils.getDirectMember(f) - val thisIfNeeded: KotlinType? = when { - kind == OwnerKind.DEFAULT_IMPLS -> { + val thisIfNeeded: KotlinType? = when (kind) { + OwnerKind.DEFAULT_IMPLS -> { val receiverTypeAndTypeParameters = patchTypeParametersForDefaultImplMethod(directMember) writeFormalTypeParameters(receiverTypeAndTypeParameters.typeParameters + directMember.typeParameters, sw) receiverTypeAndTypeParameters.receiverType } - kind == OwnerKind.ERASED_INLINE_CLASS -> { + OwnerKind.ERASED_INLINE_CLASS -> { writeFormalTypeParameters(directMember.typeParameters, sw) (directMember.containingDeclaration as ClassDescriptor).defaultType } 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 c24242ed0ab..a137920e87c 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 @@ -7161,10 +7161,125 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/bridgeGenerationNonInline.kt", "kotlin.coroutines"); } + @TestMetadata("covariantOverrideSuspendFun.kt") + public void testCovariantOverrideSuspendFun() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_Any.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_Any.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_Int.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_Int.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableAny.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableAny() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableInt.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableInt() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null.kt"); + } + + @TestMetadata("covariantOverrideSuspendFun_Any.kt") + public void testCovariantOverrideSuspendFun_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun_Any.kt"); + } + + @TestMetadata("covariantOverrideSuspendFun_Int.kt") + public void testCovariantOverrideSuspendFun_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun_Int.kt"); + } + + @TestMetadata("genericOverrideSuspendFun.kt") + public void testGenericOverrideSuspendFun() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_Any.kt") + public void testGenericOverrideSuspendFun_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Any.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_Any_NullableInlineClassUpperBound.kt") + public void testGenericOverrideSuspendFun_Any_NullableInlineClassUpperBound() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Any_NullableInlineClassUpperBound.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_Int.kt") + public void testGenericOverrideSuspendFun_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Int.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_NullableAny.kt") + public void testGenericOverrideSuspendFun_NullableAny() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableAny.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_NullableAny_null.kt") + public void testGenericOverrideSuspendFun_NullableAny_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableAny_null.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_NullableInt.kt") + public void testGenericOverrideSuspendFun_NullableInt() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableInt.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_NullableInt_null.kt") + public void testGenericOverrideSuspendFun_NullableInt_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableInt_null.kt"); + } + @TestMetadata("interfaceDelegateWithInlineClass.kt") public void testInterfaceDelegateWithInlineClass_1_3() throws Exception { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines"); } + + @TestMetadata("overrideSuspendFun.kt") + public void testOverrideSuspendFun_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun.kt", "kotlin.coroutines"); + } + + @TestMetadata("overrideSuspendFun_Any.kt") + public void testOverrideSuspendFun_Any_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any.kt", "kotlin.coroutines"); + } + + @TestMetadata("overrideSuspendFun_Any_itf.kt") + public void testOverrideSuspendFun_Any_itf_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any_itf.kt", "kotlin.coroutines"); + } + + @TestMetadata("overrideSuspendFun_Any_this.kt") + public void testOverrideSuspendFun_Any_this_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any_this.kt", "kotlin.coroutines"); + } + + @TestMetadata("overrideSuspendFun_Int.kt") + public void testOverrideSuspendFun_Int_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Int.kt", "kotlin.coroutines"); + } } @TestMetadata("compiler/testData/codegen/box/coroutines/intLikeVarSpilling") diff --git a/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun.kt new file mode 100644 index 00000000000..09f505676ea --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun.kt @@ -0,0 +1,45 @@ +// IGNORE_BACKEND_FIR: JVM_IR +// WITH_RUNTIME +// WITH_COROUTINES + +import helpers.* +import kotlin.coroutines.* + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +@Suppress("UNSUPPORTED_FEATURE") +inline class IC(val s: String) + +interface IBar { + suspend fun bar(): Any +} + +class Test() : IBar { + + override suspend fun bar(): IC = IC("OK") + + suspend fun test1(): String { + val b: IBar = this + return (b.bar() as IC).s + } + + suspend fun test2(): String = bar().s +} + +fun box(): String { + var result = "FAIL 1" + builder { + result = Test().test1() + } + if (result != "OK") return "FAIL 1 $result" + + result = "FAIL2 " + builder { + result = Test().test2() + } + if (result != "OK") return "FAIL 2 $result" + + return result +} diff --git a/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass.kt new file mode 100644 index 00000000000..1a91f17a8eb --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass.kt @@ -0,0 +1,47 @@ +// IGNORE_BACKEND_FIR: JVM_IR +// WITH_RUNTIME +// WITH_COROUTINES + +import helpers.* +import kotlin.coroutines.* + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +@Suppress("UNSUPPORTED_FEATURE") +inline class IC(val s: String) + +interface IBar { + suspend fun bar(): IC? +} + +class Test() : IBar { + + override suspend fun bar(): IC = IC("OK") + + suspend fun test1(): String { + val b: IBar = this + return b.bar()!!.s + } + + suspend fun test2(): String { + return bar().s + } +} + +fun box(): String { + var result = "FAIL" + builder { + result = Test().test1() + } + if (result != "OK") return "FAIL 1 $result" + + result = "FAIL2" + builder { + result = Test().test2() + } + if (result != "OK") return "FAIL 2 $result" + + return result +} diff --git a/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_Any.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_Any.kt new file mode 100644 index 00000000000..da75013bf2d --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_Any.kt @@ -0,0 +1,46 @@ +// IGNORE_BACKEND_FIR: JVM_IR +// WITH_RUNTIME +// WITH_COROUTINES + +import helpers.* +import kotlin.coroutines.* + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +@Suppress("UNSUPPORTED_FEATURE") +inline class IC(val s: Any) + +interface IBar { + suspend fun bar(): IC? +} + +class Test() : IBar { + override suspend fun bar(): IC = IC("OK") + + suspend fun test1(): String { + val b: IBar = this + return b.bar()!!.s as String + } + + suspend fun test2(): String { + return bar()!!.s as String + } +} + +fun box(): String { + var result = "FAIL" + builder { + result = Test().test1() + } + if (result != "OK") return "FAIL 1 $result" + + result = "FAIL2" + builder { + result = Test().test2() + } + if (result != "OK") return "FAIL 2 $result" + + return result +} diff --git a/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_Int.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_Int.kt new file mode 100644 index 00000000000..b6370f78695 --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_Int.kt @@ -0,0 +1,49 @@ +// IGNORE_BACKEND_FIR: JVM_IR +// WITH_RUNTIME +// WITH_COROUTINES + +import helpers.* +import kotlin.coroutines.* + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +@Suppress("UNSUPPORTED_FEATURE") +inline class IC(val s: Int) + +interface IBar { + suspend fun bar(): IC? +} + +fun Int.toResultString() = + if (this == 42) "OK" else "!!! $this" + +class Test() : IBar { + override suspend fun bar(): IC = IC(42) + + suspend fun test1(): String { + val b: IBar = this + return b.bar()!!.s.toResultString() + } + + suspend fun test2(): String { + return bar()!!.s.toResultString() + } +} + +fun box(): String { + var result = "FAIL" + builder { + result = Test().test1() + } + if (result != "OK") return "FAIL 1 $result" + + result = "FAIL2" + builder { + result = Test().test2() + } + if (result != "OK") return "FAIL 2 $result" + + return result +} diff --git a/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny.kt new file mode 100644 index 00000000000..57294e80bee --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny.kt @@ -0,0 +1,45 @@ +// IGNORE_BACKEND_FIR: JVM_IR +// WITH_RUNTIME +// WITH_COROUTINES + +import helpers.* +import kotlin.coroutines.* + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +@Suppress("UNSUPPORTED_FEATURE") +inline class IC(val s: Any?) + +interface IBar { + suspend fun bar(): IC? +} + +class Test() : IBar { + override suspend fun bar(): IC = IC("OK") + + suspend fun test1(): String { + val b: IBar = this + return b.bar()!!.s as String + } + + suspend fun test2(): String = bar().s as String +} + + +fun box(): String { + var result = "FAIL" + builder { + result = Test().test1() + } + if (result != "OK") return "FAIL 1 $result" + + result = "FAIL2" + builder { + result = Test().test2() + } + if (result != "OK") return "FAIL 2 $result" + + return result +} diff --git a/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null.kt new file mode 100644 index 00000000000..b63d9f51033 --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null.kt @@ -0,0 +1,56 @@ +// IGNORE_BACKEND_FIR: JVM_IR +// WITH_RUNTIME +// WITH_COROUTINES + +import helpers.* +import kotlin.coroutines.* + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +@Suppress("UNSUPPORTED_FEATURE") +inline class IC(val s: Any?) + +interface IBar { + suspend fun bar(): IC? +} + +class Test1() : IBar { + override suspend fun bar(): IC { + return IC(null) + } + + suspend fun test(): Any? { + val b: IBar = this + return b.bar()!!.s + } +} + +class Test2() : IBar { + override suspend fun bar(): IC { + return IC(null) + } + + suspend fun test(): IC { + val b: IBar = this + return b.bar()!! + } +} + + +fun box(): String { + var result: Any? = "FAIL 1" + builder { + result = Test1().test() + } + if (result != null) return "FAIL 1 $result" + + result = "FAIL 2" + builder { + result = Test2().test() + } + if (result != IC(null)) return "FAIL 2 $result" + + return "OK" +} diff --git a/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt.kt new file mode 100644 index 00000000000..0816fc5ce47 --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt.kt @@ -0,0 +1,49 @@ +// IGNORE_BACKEND_FIR: JVM_IR +// WITH_RUNTIME +// WITH_COROUTINES + +import helpers.* +import kotlin.coroutines.* + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +@Suppress("UNSUPPORTED_FEATURE") +inline class IC(val s: Int?) + +interface IBar { + suspend fun bar(): IC? +} + +fun Int?.toResultString() = + if (this == 42) "OK" else "!!! $this" + +class Test() : IBar { + override suspend fun bar(): IC = IC(42) + + suspend fun test1(): String { + val b: IBar = this + return b.bar()!!.s.toResultString() + } + + suspend fun test2(): String { + return bar()!!.s.toResultString() + } +} + +fun box(): String { + var result = "FAIL" + builder { + result = Test().test1() + } + if (result != "OK") return "FAIL 1 $result" + + result = "FAIL2" + builder { + result = Test().test2() + } + if (result != "OK") return "FAIL 2 $result" + + return result +} diff --git a/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null.kt new file mode 100644 index 00000000000..62f7e628222 --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null.kt @@ -0,0 +1,49 @@ +// IGNORE_BACKEND_FIR: JVM_IR +// WITH_RUNTIME +// WITH_COROUTINES + +import helpers.* +import kotlin.coroutines.* + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +@Suppress("UNSUPPORTED_FEATURE") +inline class IC(val s: Int?) + +interface IBar { + suspend fun bar(): IC? +} + +fun Int?.toResultString() = + if (this == null) "OK" else "!!! $this" + +class Test() : IBar { + override suspend fun bar(): IC = IC(null) + + suspend fun test1(): String { + val b: IBar = this + return b.bar()!!.s.toResultString() + } + + suspend fun test2(): String { + return bar()!!.s.toResultString() + } +} + +fun box(): String { + var result = "FAIL" + builder { + result = Test().test1() + } + if (result != "OK") return "FAIL 1 $result" + + result = "FAIL2" + builder { + result = Test().test2() + } + if (result != "OK") return "FAIL 2 $result" + + return result +} diff --git a/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun_Any.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun_Any.kt new file mode 100644 index 00000000000..689c28ddcee --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun_Any.kt @@ -0,0 +1,46 @@ +// IGNORE_BACKEND_FIR: JVM_IR +// WITH_RUNTIME +// WITH_COROUTINES + +import helpers.* +import kotlin.coroutines.* + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +@Suppress("UNSUPPORTED_FEATURE") +inline class IC(val s: Any) + +interface IBar { + suspend fun bar(): Any +} + +class Test() : IBar { + + override suspend fun bar(): IC = IC("OK") + + suspend fun test1(): String { + val b: IBar = this + return (b.bar() as IC).s as String + } + + suspend fun test2(): String = bar().s as String +} + + +fun box(): String { + var result = "FAIL 1" + builder { + result = Test().test1() + } + if (result != "OK") return "FAIL 1 $result" + + result = "FAIL2 " + builder { + result = Test().test2() + } + if (result != "OK") return "FAIL 2 $result" + + return result +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun_Int.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun_Int.kt new file mode 100644 index 00000000000..0b2ccb80633 --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun_Int.kt @@ -0,0 +1,50 @@ +// IGNORE_BACKEND_FIR: JVM_IR +// WITH_RUNTIME +// WITH_COROUTINES + +import helpers.* +import kotlin.coroutines.* + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +@Suppress("UNSUPPORTED_FEATURE") +inline class IC(val s: Int) + +interface IBar { + suspend fun bar(): Any +} + +class Test() : IBar { + override suspend fun bar(): IC = IC(42) + + suspend fun test1(): Int { + val b: IBar = this + return (b.bar() as IC).s + } + + suspend fun test2(): Int { + val b: IBar = this + return (b.bar() as IC).s + } +} + +fun Int.toBoxResult() = + if (this == 42) "OK" else toString() + +fun box(): String { + var result: String = "FAIL" + builder { + result = Test().test1().toBoxResult() + } + if (result != "OK") return "FAIL 1 $result" + + result = "FAIL2" + builder { + result = Test().test2().toBoxResult() + } + if (result != "OK") return "FAIL 2 $result" + + return result as String +} diff --git a/compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun.kt new file mode 100644 index 00000000000..fe3d2f8d46d --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun.kt @@ -0,0 +1,29 @@ +// IGNORE_BACKEND_FIR: JVM_IR +// WITH_RUNTIME +// WITH_COROUTINES + +import helpers.* +import kotlin.coroutines.* + +inline class IC(val s: String) + +interface Base { + suspend fun generic(): T +} + +class Derived : Base { + override suspend fun generic(): IC = suspendCoroutine { it.resume(IC("OK")) } +} + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +fun box(): String { + var res: String? = null + builder { + val base: Base<*> = Derived() + res = (base.generic() as IC).s + } + return res!! +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Any.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Any.kt new file mode 100644 index 00000000000..72a47139e82 --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Any.kt @@ -0,0 +1,29 @@ +// IGNORE_BACKEND_FIR: JVM_IR +// WITH_RUNTIME +// WITH_COROUTINES + +import helpers.* +import kotlin.coroutines.* + +inline class IC(val s: Any) + +interface Base { + suspend fun generic(): T +} + +class Derived : Base { + override suspend fun generic(): IC = suspendCoroutine { it.resume(IC("OK")) } +} + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +fun box(): String { + var res: String? = null + builder { + val base: Base<*> = Derived() + res = (base.generic() as IC).s as String + } + return res!! +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Any_NullableInlineClassUpperBound.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Any_NullableInlineClassUpperBound.kt new file mode 100644 index 00000000000..1bca2c23700 --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Any_NullableInlineClassUpperBound.kt @@ -0,0 +1,29 @@ +// IGNORE_BACKEND_FIR: JVM_IR +// WITH_RUNTIME +// WITH_COROUTINES + +import helpers.* +import kotlin.coroutines.* + +inline class IC(val s: Any) + +interface Base { + suspend fun generic(): T +} + +class Derived : Base { + override suspend fun generic(): IC = suspendCoroutine { it.resume(IC("OK")) } +} + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +fun box(): String { + var res: String? = null + builder { + val base: Base<*> = Derived() + res = base.generic()!!.s as String + } + return res!! +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Int.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Int.kt new file mode 100644 index 00000000000..38e53d17893 --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Int.kt @@ -0,0 +1,32 @@ +// IGNORE_BACKEND_FIR: JVM_IR +// WITH_RUNTIME +// WITH_COROUTINES + +import helpers.* +import kotlin.coroutines.* + +inline class IC(val s: Int) + +fun Int.toResultString() = + if (this == 42) "OK" else "!! $this" + +interface Base { + suspend fun generic(): T +} + +class Derived : Base { + override suspend fun generic(): IC = suspendCoroutine { it.resume(IC(42)) } +} + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +fun box(): String { + var res: String? = null + builder { + val base: Base<*> = Derived() + res = (base.generic() as IC).s.toResultString() + } + return res!! +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableAny.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableAny.kt new file mode 100644 index 00000000000..5854c0a6abc --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableAny.kt @@ -0,0 +1,29 @@ +// IGNORE_BACKEND_FIR: JVM_IR +// WITH_RUNTIME +// WITH_COROUTINES + +import helpers.* +import kotlin.coroutines.* + +inline class IC(val s: Any?) + +interface Base { + suspend fun generic(): T +} + +class Derived : Base { + override suspend fun generic(): IC = suspendCoroutine { it.resume(IC("OK")) } +} + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +fun box(): String { + var res: String? = null + builder { + val base: Base<*> = Derived() + res = (base.generic() as IC).s as String + } + return res!! +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableAny_null.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableAny_null.kt new file mode 100644 index 00000000000..a15597cc059 --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableAny_null.kt @@ -0,0 +1,32 @@ +// IGNORE_BACKEND_FIR: JVM_IR +// WITH_RUNTIME +// WITH_COROUTINES + +import helpers.* +import kotlin.coroutines.* + +inline class IC(val s: Any?) + +interface Base { + suspend fun generic(): T +} + +class Derived : Base { + override suspend fun generic(): IC = suspendCoroutine { it.resume(IC(null)) } +} + +fun Any?.toResultString(): String = + if (this == null) "OK" else "!! $this" + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +fun box(): String { + var res: String? = null + builder { + val base: Base<*> = Derived() + res = (base.generic() as IC).s.toResultString() + } + return res!! +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableInt.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableInt.kt new file mode 100644 index 00000000000..e3bafa820f5 --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableInt.kt @@ -0,0 +1,32 @@ +// IGNORE_BACKEND_FIR: JVM_IR +// WITH_RUNTIME +// WITH_COROUTINES + +import helpers.* +import kotlin.coroutines.* + +inline class IC(val s: Int?) + +fun Int?.toResultString() = + if (this == 42) "OK" else "!! $this" + +interface Base { + suspend fun generic(): T +} + +class Derived : Base { + override suspend fun generic(): IC = suspendCoroutine { it.resume(IC(42)) } +} + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +fun box(): String { + var res: String? = null + builder { + val base: Base<*> = Derived() + res = (base.generic() as IC).s.toResultString() + } + return res!! +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableInt_null.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableInt_null.kt new file mode 100644 index 00000000000..84af6282835 --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableInt_null.kt @@ -0,0 +1,32 @@ +// IGNORE_BACKEND_FIR: JVM_IR +// WITH_RUNTIME +// WITH_COROUTINES + +import helpers.* +import kotlin.coroutines.* + +inline class IC(val s: Int?) + +fun Int?.toResultString() = + if (this == null) "OK" else "!! $this" + +interface Base { + suspend fun generic(): T +} + +class Derived : Base { + override suspend fun generic(): IC = suspendCoroutine { it.resume(IC(null)) } +} + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +fun box(): String { + var res: String? = null + builder { + val base: Base<*> = Derived() + res = (base.generic() as IC).s.toResultString() + } + return res!! +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun.kt new file mode 100644 index 00000000000..2f5aef2a88d --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun.kt @@ -0,0 +1,110 @@ +// IGNORE_BACKEND_FIR: JVM_IR +// WITH_RUNTIME +// WITH_COROUTINES +// COMMON_COROUTINES_TEST + +import helpers.* +import COROUTINES_PACKAGE.* +import COROUTINES_PACKAGE.intrinsics.* + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +@Suppress("UNSUPPORTED_FEATURE") +inline class IC(val s: String) + +interface IBar { + suspend fun bar(): IC +} + +class Test1() : IBar { + + suspend fun foo(value: T): T { + return suspendCoroutineUninterceptedOrReturn { + it.resume(value) + COROUTINE_SUSPENDED + } + } + + suspend fun qux(ss: IC): IC = IC(ss.s) + + suspend fun quz(t: T): T = t + + override suspend fun bar(): IC { + return foo(qux(quz(IC("OK")))) + } + + suspend fun test(): String { + val b: IBar = this + return b.bar().s + } +} + + +class Test2 : IBar { + + suspend fun foo(value: IC): IC { + return suspendCoroutineUninterceptedOrReturn { + it.resume(value) + COROUTINE_SUSPENDED + } + } + + suspend fun qux(s: String): IC = IC(s) + + suspend fun quz(): String = "OK" + + override suspend fun bar(): IC { + return foo(qux(quz())) + } + + suspend fun test(): String { + val b: IBar = this + return b.bar().s + } +} + +class Test3 : IBar { + suspend fun foo(value: T): T { + return suspendCoroutineUninterceptedOrReturn { + it.resume(value) + COROUTINE_SUSPENDED + } + } + + override suspend fun bar(): IC { + return foo(IC("OK")) + } + + suspend fun test(): String { + val b: IBar = this + return b.bar().s + } +} + +fun box(): String { + + var result = "FAIL" + builder { + result = Test1().test() + } + + if (result != "OK") return "FAIL 1 $result" + + result = "FAIL2" + + builder { + result = Test2().test() + } + + if (result != "OK") return "FAIL 2 $result" + + result = "FAIL 3" + + builder { + result = Test3().test() + } + + return result +} diff --git a/compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any.kt new file mode 100644 index 00000000000..fb058fc6f58 --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any.kt @@ -0,0 +1,104 @@ +// IGNORE_BACKEND_FIR: JVM_IR +// WITH_RUNTIME +// WITH_COROUTINES +// COMMON_COROUTINES_TEST + +import helpers.* +import COROUTINES_PACKAGE.* +import COROUTINES_PACKAGE.intrinsics.* + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +@Suppress("UNSUPPORTED_FEATURE") +inline class IC(val s: Any) + +interface IBar { + suspend fun bar(): IC +} + +class Test1() : IBar { + + suspend fun foo(value: T): T { + return suspendCoroutineUninterceptedOrReturn { + it.resume(value) + COROUTINE_SUSPENDED + } + } + + suspend fun qux(ss: IC): IC = IC(ss.s) + + suspend fun quz(t: T): T = t + + override suspend fun bar(): IC { + return foo(qux(quz(IC("OK")))) + } + + suspend fun test(): Any { + val b: IBar = this + return b.bar().s + } +} + + +class Test2 : IBar { + + suspend fun foo(value: IC): IC { + return suspendCoroutineUninterceptedOrReturn { + it.resume(value) + COROUTINE_SUSPENDED + } + } + + suspend fun qux(s: String): IC = IC(s) + + suspend fun quz(): String = "OK" + + override suspend fun bar(): IC { + return foo(qux(quz())) + } + + suspend fun test(): Any { + val b: IBar = this + return b.bar().s + } +} + +class Test3 : IBar { + suspend fun foo(value: T): T { + return suspendCoroutineUninterceptedOrReturn { + it.resume(value) + COROUTINE_SUSPENDED + } + } + + override suspend fun bar(): IC { + return foo(IC("OK")) + } + + suspend fun test(): Any { + val b: IBar = this + return b.bar().s + } +} + +fun box(): String { + var result: Any = "FAIL1" + builder { + result = Test1().test() + } + if (result != "OK") return "FAIL 1 $result" + + result = "FAIL2" + builder { + result = Test2().test() + } + if (result != "OK") return "FAIL 2 $result" + + result = "FAIL 3" + builder { + result = Test3().test() + } + return result as String +} diff --git a/compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any_itf.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any_itf.kt new file mode 100644 index 00000000000..61eeb819bd9 --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any_itf.kt @@ -0,0 +1,38 @@ +// IGNORE_BACKEND_FIR: JVM_IR +// WITH_RUNTIME +// WITH_COROUTINES +// COMMON_COROUTINES_TEST + +import helpers.* +import COROUTINES_PACKAGE.* +import COROUTINES_PACKAGE.intrinsics.* + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +@Suppress("UNSUPPORTED_FEATURE") +inline class IC(val s: Any) + +interface IBar { + suspend fun bar(): IC +} + +class Test0() : IBar { + override suspend fun bar(): IC = IC("OK") + + suspend fun test(): Any { + val b: IBar = this + return b.bar().s + } +} + +fun box(): String { + var result: Any = "FAIL" + builder { + result = Test0().test() + } + if (result != "OK") return "FAIL 0 $result" + + return result as String +} diff --git a/compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any_this.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any_this.kt new file mode 100644 index 00000000000..5de4a3d24c5 --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any_this.kt @@ -0,0 +1,37 @@ +// IGNORE_BACKEND_FIR: JVM_IR +// WITH_RUNTIME +// WITH_COROUTINES +// COMMON_COROUTINES_TEST + +import helpers.* +import COROUTINES_PACKAGE.* +import COROUTINES_PACKAGE.intrinsics.* + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +@Suppress("UNSUPPORTED_FEATURE") +inline class IC(val s: Any) + +interface IBar { + suspend fun bar(): IC +} + +class Test0() : IBar { + override suspend fun bar(): IC = IC("OK") + + suspend fun test(): Any { + return bar().s + } +} + +fun box(): String { + var result: Any = "FAIL" + builder { + result = Test0().test() + } + if (result != "OK") return "FAIL 0 $result" + + return result as String +} diff --git a/compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Int.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Int.kt new file mode 100644 index 00000000000..0997525c7f0 --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Int.kt @@ -0,0 +1,113 @@ +// IGNORE_BACKEND_FIR: JVM_IR +// WITH_RUNTIME +// WITH_COROUTINES +// COMMON_COROUTINES_TEST + +import helpers.* +import COROUTINES_PACKAGE.* +import COROUTINES_PACKAGE.intrinsics.* + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +@Suppress("UNSUPPORTED_FEATURE") +inline class IC(val s: Int) + +interface IBar { + suspend fun bar(): IC +} + +class Test1() : IBar { + + suspend fun foo(value: T): T { + return suspendCoroutineUninterceptedOrReturn { + it.resume(value) + COROUTINE_SUSPENDED + } + } + + suspend fun qux(ss: IC): IC = IC(ss.s) + + suspend fun quz(t: T): T = t + + override suspend fun bar(): IC { + return foo(qux(quz(IC(42)))) + } + + suspend fun test(): Int { + val b: IBar = this + return b.bar().s + } +} + + +class Test2 : IBar { + + suspend fun foo(value: IC): IC { + return suspendCoroutineUninterceptedOrReturn { + it.resume(value) + COROUTINE_SUSPENDED + } + } + + suspend fun qux(s: Int): IC = IC(s) + + suspend fun quz(): Int = 42 + + override suspend fun bar(): IC { + return foo(qux(quz())) + } + + suspend fun test(): Int { + val b: IBar = this + return b.bar().s + } +} + +class Test3 : IBar { + suspend fun foo(value: T): T { + return suspendCoroutineUninterceptedOrReturn { + it.resume(value) + COROUTINE_SUSPENDED + } + } + + override suspend fun bar(): IC { + return foo(IC(42)) + } + + suspend fun test(): Int { + val b: IBar = this + return b.bar().s + } +} + +fun Int.toBoxResult() = + if (this == 42) "OK" else toString() + +fun box(): String { + + var result: String = "FAIL" + builder { + result = Test1().test().toBoxResult() + } + + if (result != "OK") return "FAIL 1 $result" + + result = "FAIL2" + + builder { + result = Test2().test().toBoxResult() + } + + if (result != "OK") return "FAIL 2 $result" + + result = "FAIL 3" + + builder { + result = Test3().test().toBoxResult() + } + + return result as String +} diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java index 4729fadaa98..11f82f9029a 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java @@ -7921,6 +7921,96 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/bridgeGenerationNonInline.kt", "kotlin.coroutines"); } + @TestMetadata("covariantOverrideSuspendFun.kt") + public void testCovariantOverrideSuspendFun() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_Any.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_Any.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_Int.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_Int.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableAny.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableAny() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableInt.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableInt() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null.kt"); + } + + @TestMetadata("covariantOverrideSuspendFun_Any.kt") + public void testCovariantOverrideSuspendFun_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun_Any.kt"); + } + + @TestMetadata("covariantOverrideSuspendFun_Int.kt") + public void testCovariantOverrideSuspendFun_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun_Int.kt"); + } + + @TestMetadata("genericOverrideSuspendFun.kt") + public void testGenericOverrideSuspendFun() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_Any.kt") + public void testGenericOverrideSuspendFun_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Any.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_Any_NullableInlineClassUpperBound.kt") + public void testGenericOverrideSuspendFun_Any_NullableInlineClassUpperBound() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Any_NullableInlineClassUpperBound.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_Int.kt") + public void testGenericOverrideSuspendFun_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Int.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_NullableAny.kt") + public void testGenericOverrideSuspendFun_NullableAny() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableAny.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_NullableAny_null.kt") + public void testGenericOverrideSuspendFun_NullableAny_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableAny_null.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_NullableInt.kt") + public void testGenericOverrideSuspendFun_NullableInt() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableInt.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_NullableInt_null.kt") + public void testGenericOverrideSuspendFun_NullableInt_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableInt_null.kt"); + } + @TestMetadata("interfaceDelegateWithInlineClass.kt") public void testInterfaceDelegateWithInlineClass_1_2() throws Exception { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines.experimental"); @@ -7930,6 +8020,56 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { public void testInterfaceDelegateWithInlineClass_1_3() throws Exception { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines"); } + + @TestMetadata("overrideSuspendFun.kt") + public void testOverrideSuspendFun_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("overrideSuspendFun.kt") + public void testOverrideSuspendFun_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun.kt", "kotlin.coroutines"); + } + + @TestMetadata("overrideSuspendFun_Any.kt") + public void testOverrideSuspendFun_Any_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("overrideSuspendFun_Any.kt") + public void testOverrideSuspendFun_Any_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any.kt", "kotlin.coroutines"); + } + + @TestMetadata("overrideSuspendFun_Any_itf.kt") + public void testOverrideSuspendFun_Any_itf_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any_itf.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("overrideSuspendFun_Any_itf.kt") + public void testOverrideSuspendFun_Any_itf_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any_itf.kt", "kotlin.coroutines"); + } + + @TestMetadata("overrideSuspendFun_Any_this.kt") + public void testOverrideSuspendFun_Any_this_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any_this.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("overrideSuspendFun_Any_this.kt") + public void testOverrideSuspendFun_Any_this_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any_this.kt", "kotlin.coroutines"); + } + + @TestMetadata("overrideSuspendFun_Int.kt") + public void testOverrideSuspendFun_Int_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Int.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("overrideSuspendFun_Int.kt") + public void testOverrideSuspendFun_Int_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Int.kt", "kotlin.coroutines"); + } } @TestMetadata("compiler/testData/codegen/box/coroutines/intLikeVarSpilling") diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java index bbd32332d9f..04bc4906c4e 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java @@ -7921,6 +7921,96 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/bridgeGenerationNonInline.kt", "kotlin.coroutines"); } + @TestMetadata("covariantOverrideSuspendFun.kt") + public void testCovariantOverrideSuspendFun() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_Any.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_Any.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_Int.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_Int.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableAny.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableAny() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableInt.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableInt() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null.kt"); + } + + @TestMetadata("covariantOverrideSuspendFun_Any.kt") + public void testCovariantOverrideSuspendFun_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun_Any.kt"); + } + + @TestMetadata("covariantOverrideSuspendFun_Int.kt") + public void testCovariantOverrideSuspendFun_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun_Int.kt"); + } + + @TestMetadata("genericOverrideSuspendFun.kt") + public void testGenericOverrideSuspendFun() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_Any.kt") + public void testGenericOverrideSuspendFun_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Any.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_Any_NullableInlineClassUpperBound.kt") + public void testGenericOverrideSuspendFun_Any_NullableInlineClassUpperBound() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Any_NullableInlineClassUpperBound.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_Int.kt") + public void testGenericOverrideSuspendFun_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Int.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_NullableAny.kt") + public void testGenericOverrideSuspendFun_NullableAny() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableAny.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_NullableAny_null.kt") + public void testGenericOverrideSuspendFun_NullableAny_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableAny_null.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_NullableInt.kt") + public void testGenericOverrideSuspendFun_NullableInt() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableInt.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_NullableInt_null.kt") + public void testGenericOverrideSuspendFun_NullableInt_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableInt_null.kt"); + } + @TestMetadata("interfaceDelegateWithInlineClass.kt") public void testInterfaceDelegateWithInlineClass_1_2() throws Exception { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines.experimental"); @@ -7930,6 +8020,56 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes public void testInterfaceDelegateWithInlineClass_1_3() throws Exception { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines"); } + + @TestMetadata("overrideSuspendFun.kt") + public void testOverrideSuspendFun_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("overrideSuspendFun.kt") + public void testOverrideSuspendFun_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun.kt", "kotlin.coroutines"); + } + + @TestMetadata("overrideSuspendFun_Any.kt") + public void testOverrideSuspendFun_Any_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("overrideSuspendFun_Any.kt") + public void testOverrideSuspendFun_Any_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any.kt", "kotlin.coroutines"); + } + + @TestMetadata("overrideSuspendFun_Any_itf.kt") + public void testOverrideSuspendFun_Any_itf_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any_itf.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("overrideSuspendFun_Any_itf.kt") + public void testOverrideSuspendFun_Any_itf_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any_itf.kt", "kotlin.coroutines"); + } + + @TestMetadata("overrideSuspendFun_Any_this.kt") + public void testOverrideSuspendFun_Any_this_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any_this.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("overrideSuspendFun_Any_this.kt") + public void testOverrideSuspendFun_Any_this_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any_this.kt", "kotlin.coroutines"); + } + + @TestMetadata("overrideSuspendFun_Int.kt") + public void testOverrideSuspendFun_Int_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Int.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("overrideSuspendFun_Int.kt") + public void testOverrideSuspendFun_Int_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Int.kt", "kotlin.coroutines"); + } } @TestMetadata("compiler/testData/codegen/box/coroutines/intLikeVarSpilling") diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java index 35ffb1c54ef..d3906f4b2b3 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java @@ -7161,10 +7161,125 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/bridgeGenerationNonInline.kt", "kotlin.coroutines"); } + @TestMetadata("covariantOverrideSuspendFun.kt") + public void testCovariantOverrideSuspendFun() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_Any.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_Any.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_Int.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_Int.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableAny.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableAny() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableInt.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableInt() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null.kt"); + } + + @TestMetadata("covariantOverrideSuspendFun_Any.kt") + public void testCovariantOverrideSuspendFun_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun_Any.kt"); + } + + @TestMetadata("covariantOverrideSuspendFun_Int.kt") + public void testCovariantOverrideSuspendFun_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun_Int.kt"); + } + + @TestMetadata("genericOverrideSuspendFun.kt") + public void testGenericOverrideSuspendFun() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_Any.kt") + public void testGenericOverrideSuspendFun_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Any.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_Any_NullableInlineClassUpperBound.kt") + public void testGenericOverrideSuspendFun_Any_NullableInlineClassUpperBound() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Any_NullableInlineClassUpperBound.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_Int.kt") + public void testGenericOverrideSuspendFun_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Int.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_NullableAny.kt") + public void testGenericOverrideSuspendFun_NullableAny() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableAny.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_NullableAny_null.kt") + public void testGenericOverrideSuspendFun_NullableAny_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableAny_null.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_NullableInt.kt") + public void testGenericOverrideSuspendFun_NullableInt() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableInt.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_NullableInt_null.kt") + public void testGenericOverrideSuspendFun_NullableInt_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableInt_null.kt"); + } + @TestMetadata("interfaceDelegateWithInlineClass.kt") public void testInterfaceDelegateWithInlineClass_1_3() throws Exception { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines"); } + + @TestMetadata("overrideSuspendFun.kt") + public void testOverrideSuspendFun_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun.kt", "kotlin.coroutines"); + } + + @TestMetadata("overrideSuspendFun_Any.kt") + public void testOverrideSuspendFun_Any_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any.kt", "kotlin.coroutines"); + } + + @TestMetadata("overrideSuspendFun_Any_itf.kt") + public void testOverrideSuspendFun_Any_itf_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any_itf.kt", "kotlin.coroutines"); + } + + @TestMetadata("overrideSuspendFun_Any_this.kt") + public void testOverrideSuspendFun_Any_this_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any_this.kt", "kotlin.coroutines"); + } + + @TestMetadata("overrideSuspendFun_Int.kt") + public void testOverrideSuspendFun_Int_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Int.kt", "kotlin.coroutines"); + } } @TestMetadata("compiler/testData/codegen/box/coroutines/intLikeVarSpilling") diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java b/js/js.tests/test/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java index 159a4eb157e..38b56a5307f 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java +++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java @@ -6091,10 +6091,125 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/bridgeGenerationNonInline.kt", "kotlin.coroutines"); } + @TestMetadata("covariantOverrideSuspendFun.kt") + public void testCovariantOverrideSuspendFun() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_Any.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_Any.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_Int.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_Int.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableAny.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableAny() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableInt.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableInt() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null.kt"); + } + + @TestMetadata("covariantOverrideSuspendFun_Any.kt") + public void testCovariantOverrideSuspendFun_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun_Any.kt"); + } + + @TestMetadata("covariantOverrideSuspendFun_Int.kt") + public void testCovariantOverrideSuspendFun_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun_Int.kt"); + } + + @TestMetadata("genericOverrideSuspendFun.kt") + public void testGenericOverrideSuspendFun() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_Any.kt") + public void testGenericOverrideSuspendFun_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Any.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_Any_NullableInlineClassUpperBound.kt") + public void testGenericOverrideSuspendFun_Any_NullableInlineClassUpperBound() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Any_NullableInlineClassUpperBound.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_Int.kt") + public void testGenericOverrideSuspendFun_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Int.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_NullableAny.kt") + public void testGenericOverrideSuspendFun_NullableAny() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableAny.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_NullableAny_null.kt") + public void testGenericOverrideSuspendFun_NullableAny_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableAny_null.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_NullableInt.kt") + public void testGenericOverrideSuspendFun_NullableInt() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableInt.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_NullableInt_null.kt") + public void testGenericOverrideSuspendFun_NullableInt_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableInt_null.kt"); + } + @TestMetadata("interfaceDelegateWithInlineClass.kt") public void testInterfaceDelegateWithInlineClass_1_3() throws Exception { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines"); } + + @TestMetadata("overrideSuspendFun.kt") + public void testOverrideSuspendFun_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun.kt", "kotlin.coroutines"); + } + + @TestMetadata("overrideSuspendFun_Any.kt") + public void testOverrideSuspendFun_Any_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any.kt", "kotlin.coroutines"); + } + + @TestMetadata("overrideSuspendFun_Any_itf.kt") + public void testOverrideSuspendFun_Any_itf_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any_itf.kt", "kotlin.coroutines"); + } + + @TestMetadata("overrideSuspendFun_Any_this.kt") + public void testOverrideSuspendFun_Any_this_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any_this.kt", "kotlin.coroutines"); + } + + @TestMetadata("overrideSuspendFun_Int.kt") + public void testOverrideSuspendFun_Int_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Int.kt", "kotlin.coroutines"); + } } @TestMetadata("compiler/testData/codegen/box/coroutines/intLikeVarSpilling") 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 eb7b4564f6b..9bc0b52400b 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 @@ -6091,10 +6091,125 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/bridgeGenerationNonInline.kt", "kotlin.coroutines"); } + @TestMetadata("covariantOverrideSuspendFun.kt") + public void testCovariantOverrideSuspendFun() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_Any.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_Any.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_Int.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_Int.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableAny.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableAny() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableInt.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableInt() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt.kt"); + } + + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null.kt"); + } + + @TestMetadata("covariantOverrideSuspendFun_Any.kt") + public void testCovariantOverrideSuspendFun_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun_Any.kt"); + } + + @TestMetadata("covariantOverrideSuspendFun_Int.kt") + public void testCovariantOverrideSuspendFun_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/covariantOverrideSuspendFun_Int.kt"); + } + + @TestMetadata("genericOverrideSuspendFun.kt") + public void testGenericOverrideSuspendFun() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_Any.kt") + public void testGenericOverrideSuspendFun_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Any.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_Any_NullableInlineClassUpperBound.kt") + public void testGenericOverrideSuspendFun_Any_NullableInlineClassUpperBound() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Any_NullableInlineClassUpperBound.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_Int.kt") + public void testGenericOverrideSuspendFun_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_Int.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_NullableAny.kt") + public void testGenericOverrideSuspendFun_NullableAny() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableAny.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_NullableAny_null.kt") + public void testGenericOverrideSuspendFun_NullableAny_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableAny_null.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_NullableInt.kt") + public void testGenericOverrideSuspendFun_NullableInt() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableInt.kt"); + } + + @TestMetadata("genericOverrideSuspendFun_NullableInt_null.kt") + public void testGenericOverrideSuspendFun_NullableInt_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericOverrideSuspendFun_NullableInt_null.kt"); + } + @TestMetadata("interfaceDelegateWithInlineClass.kt") public void testInterfaceDelegateWithInlineClass_1_3() throws Exception { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines"); } + + @TestMetadata("overrideSuspendFun.kt") + public void testOverrideSuspendFun_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun.kt", "kotlin.coroutines"); + } + + @TestMetadata("overrideSuspendFun_Any.kt") + public void testOverrideSuspendFun_Any_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any.kt", "kotlin.coroutines"); + } + + @TestMetadata("overrideSuspendFun_Any_itf.kt") + public void testOverrideSuspendFun_Any_itf_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any_itf.kt", "kotlin.coroutines"); + } + + @TestMetadata("overrideSuspendFun_Any_this.kt") + public void testOverrideSuspendFun_Any_this_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Any_this.kt", "kotlin.coroutines"); + } + + @TestMetadata("overrideSuspendFun_Int.kt") + public void testOverrideSuspendFun_Int_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/overrideSuspendFun_Int.kt", "kotlin.coroutines"); + } } @TestMetadata("compiler/testData/codegen/box/coroutines/intLikeVarSpilling")