diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/Callable.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/Callable.kt index 432897c575c..32700490400 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/Callable.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/Callable.kt @@ -37,7 +37,7 @@ interface Callable { fun invokeMethodWithArguments(resolvedCall: ResolvedCall<*>, receiver: StackValue, codegen: ExpressionCodegen): StackValue { // it's important to use unsubstituted return type here to unbox value if it comes from type variable - return StackValue.functionCall(returnType, resolvedCall.resultingDescriptor.original.returnType) { + return StackValue.functionCall(returnType, returnKotlinType ?: resolvedCall.resultingDescriptor.original.returnType) { codegen.invokeMethodWithArguments(this, resolvedCall, receiver) } } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java index 6765456d265..0307d4a8e7c 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java @@ -1648,7 +1648,7 @@ public class ExpressionCodegen extends KtVisitor impleme } else { returnType = this.returnType; - returnKotlinType = this.context.getFunctionDescriptor().getReturnType(); + returnKotlinType = typeMapper.getReturnValueType(this.context.getFunctionDescriptor()); } StackValue valueToReturn = returnedExpression != null ? gen(returnedExpression) : StackValue.none(); @@ -1701,7 +1701,10 @@ public class ExpressionCodegen extends KtVisitor impleme BindingContextUtils.getContainingFunctionSkipFunctionLiterals(descriptor, true).getFirst(); //FIRST_FUN_LABEL to prevent clashing with existing labels return new NonLocalReturnInfo( - new JvmKotlinType(typeMapper.mapReturnType(containingFunction), containingFunction.getReturnType()), + new JvmKotlinType( + typeMapper.mapReturnType(containingFunction), + typeMapper.getReturnValueType(containingFunction) + ), FIRST_FUN_LABEL ); } else { @@ -1739,7 +1742,9 @@ public class ExpressionCodegen extends KtVisitor impleme : returnType; KotlinType kotlinTypeForExpression = - isBlockedNamedFunction || isVoidCoroutineLambda ? null : context.getFunctionDescriptor().getReturnType(); + isBlockedNamedFunction || isVoidCoroutineLambda + ? null + : typeMapper.getReturnValueType(context.getFunctionDescriptor()); gen(expr, typeForExpression, kotlinTypeForExpression); 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 8b449c7bbc8..e84b322098f 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt @@ -362,6 +362,19 @@ class KotlinTypeMapper @JvmOverloads constructor( } } + fun getReturnValueType(functionDescriptor: FunctionDescriptor): KotlinType = + getActualReturnTypeForSuspendFunctionWithInlineClassReturnTypeHack(functionDescriptor) + ?: functionDescriptor.returnType!! + + private fun getActualReturnTypeForSuspendFunctionWithInlineClassReturnTypeHack(functionDescriptor: FunctionDescriptor): KotlinType? { + val originalSuspendFunctionForJvmView = functionDescriptor.unwrapInitialDescriptorForSuspendFunction() + if (originalSuspendFunctionForJvmView === functionDescriptor) return null + val originalReturnType = originalSuspendFunctionForJvmView.returnType!! + if (!originalReturnType.isInlineClassType()) return null + val jvmReturnType = mapType(originalReturnType) + return if (AsmUtil.isPrimitive(jvmReturnType)) null else originalReturnType + } + @JvmOverloads fun mapToCallableMethod( descriptor: FunctionDescriptor, @@ -431,7 +444,7 @@ class KotlinTypeMapper @JvmOverloads constructor( invokeOpcode = INVOKESTATIC val originalDescriptor = descriptor.original signature = mapSignatureSkipGeneric(originalDescriptor, OwnerKind.DEFAULT_IMPLS) - returnKotlinType = originalDescriptor.returnType + returnKotlinType = getReturnValueType(originalDescriptor) if (descriptor is AccessorForCallableDescriptor<*> && descriptor.calleeDescriptor.hasJvmDefaultAnnotation()) { owner = mapClass(functionParent) isInterfaceMember = true @@ -482,7 +495,7 @@ class KotlinTypeMapper @JvmOverloads constructor( skipGenericSignature = true, hasSpecialBridge = false ) - returnKotlinType = functionToCall.returnType + returnKotlinType = getReturnValueType(functionToCall) val receiver = if (currentIsInterface && !originalIsInterface || functionParent is FunctionClassDescriptor) declarationOwner @@ -495,7 +508,7 @@ class KotlinTypeMapper @JvmOverloads constructor( } else { val originalDescriptor = functionDescriptor.original signature = mapSignatureSkipGeneric(originalDescriptor) - returnKotlinType = originalDescriptor.returnType + returnKotlinType = getReturnValueType(originalDescriptor) owner = mapOwner(functionDescriptor) ownerForDefaultImpl = owner baseMethodDescriptor = functionDescriptor 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 06f0377e533..b1ed6288ce8 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 @@ -7023,6 +7023,46 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine.kt", "kotlin.coroutines"); } + @TestMetadata("boxUnboxInsideCoroutine_Any.kt") + public void testBoxUnboxInsideCoroutine_Any_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Any.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_InlineAny.kt") + public void testBoxUnboxInsideCoroutine_InlineAny_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_InlineAny.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_InlineInt.kt") + public void testBoxUnboxInsideCoroutine_InlineInt_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_InlineInt.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_Int.kt") + public void testBoxUnboxInsideCoroutine_Int_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Int.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_Long.kt") + public void testBoxUnboxInsideCoroutine_Long_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Long.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_NAny.kt") + public void testBoxUnboxInsideCoroutine_NAny_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_NAny.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_nonLocalReturn.kt") + public void testBoxUnboxInsideCoroutine_nonLocalReturn_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_nonLocalReturn.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_suspendFunType.kt") + public void testBoxUnboxInsideCoroutine_suspendFunType_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_suspendFunType.kt", "kotlin.coroutines"); + } + @TestMetadata("bridgeGenerationCrossinline.kt") public void testBridgeGenerationCrossinline_1_3() throws Exception { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/bridgeGenerationCrossinline.kt", "kotlin.coroutines"); diff --git a/compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Any.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Any.kt new file mode 100644 index 00000000000..fdc244e4839 --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Any.kt @@ -0,0 +1,97 @@ +// 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) + +class Test1() { + + 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 + + suspend fun bar(): IC { + return foo(qux(quz(IC("OK")))) + } + + suspend fun test(): Any = bar().s +} + + +class Test2 { + + 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" + + suspend fun bar(): IC { + return foo(qux(quz())) + } + + suspend fun test() = bar().s +} + +class Test3 { + suspend fun foo(value: T): T { + return suspendCoroutineUninterceptedOrReturn { + it.resume(value) + COROUTINE_SUSPENDED + } + } + + suspend fun bar(): IC { + return foo(IC("OK")) + } + + suspend fun test() = bar().s +} + +fun box(): String { + + var result: Any = "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 as String +} diff --git a/compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_InlineAny.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_InlineAny.kt new file mode 100644 index 00000000000..a50e9afaef7 --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_InlineAny.kt @@ -0,0 +1,100 @@ +// 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 I0(val x: Any) + +@Suppress("UNSUPPORTED_FEATURE") +inline class IC(val s: I0) + +class Test1() { + + 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 + + suspend fun bar(): IC { + return foo(qux(quz(IC(I0("OK"))))) + } + + suspend fun test() = bar().s.x +} + + +class Test2 { + + suspend fun foo(value: IC): IC { + return suspendCoroutineUninterceptedOrReturn { + it.resume(value) + COROUTINE_SUSPENDED + } + } + + suspend fun qux(s: String): IC = IC(I0(s)) + + suspend fun quz(): String = "OK" + + suspend fun bar(): IC { + return foo(qux(quz())) + } + + suspend fun test() = bar().s.x +} + +class Test3 { + suspend fun foo(value: T): T { + return suspendCoroutineUninterceptedOrReturn { + it.resume(value) + COROUTINE_SUSPENDED + } + } + + suspend fun bar(): IC { + return foo(IC(I0("OK"))) + } + + suspend fun test() = bar().s.x +} + +fun box(): String { + + var result: Any = "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 as String +} diff --git a/compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_InlineInt.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_InlineInt.kt new file mode 100644 index 00000000000..905cc81ea4b --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_InlineInt.kt @@ -0,0 +1,103 @@ +// 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 I0(val x: Int) + +@Suppress("UNSUPPORTED_FEATURE") +inline class IC(val s: I0) + +class Test1() { + + 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 + + suspend fun bar(): IC { + return foo(qux(quz(IC(I0(42))))) + } + + suspend fun test() = bar().s.x +} + + +class Test2 { + + suspend fun foo(value: IC): IC { + return suspendCoroutineUninterceptedOrReturn { + it.resume(value) + COROUTINE_SUSPENDED + } + } + + suspend fun qux(s: Int): IC = IC(I0(s)) + + suspend fun quz() = 42 + + suspend fun bar(): IC { + return foo(qux(quz())) + } + + suspend fun test() = bar().s.x +} + +class Test3 { + suspend fun foo(value: T): T { + return suspendCoroutineUninterceptedOrReturn { + it.resume(value) + COROUTINE_SUSPENDED + } + } + + suspend fun bar(): IC { + return foo(IC(I0(42))) + } + + suspend fun test() = bar().s.x +} + +fun Int.toBoxResult() = + if (this == 42) "OK" else toString() + +fun box(): String { + + var result: Any = "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/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Int.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Int.kt new file mode 100644 index 00000000000..272e804d065 --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Int.kt @@ -0,0 +1,100 @@ +// 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) + +class Test1() { + + 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 + + suspend fun bar(): IC { + return foo(qux(quz(IC(42)))) + } + + suspend fun test() = bar().s +} + + +class Test2 { + + 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 + + suspend fun bar(): IC { + return foo(qux(quz())) + } + + suspend fun test() = bar().s +} + +class Test3 { + suspend fun foo(value: T): T { + return suspendCoroutineUninterceptedOrReturn { + it.resume(value) + COROUTINE_SUSPENDED + } + } + + suspend fun bar(): IC { + return foo(IC(42)) + } + + suspend fun test() = 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/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Long.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Long.kt new file mode 100644 index 00000000000..902c48797fb --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Long.kt @@ -0,0 +1,100 @@ +// 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: Long) + +class Test1() { + + 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 + + suspend fun bar(): IC { + return foo(qux(quz(IC(42L)))) + } + + suspend fun test() = bar().s +} + + +class Test2 { + + suspend fun foo(value: IC): IC { + return suspendCoroutineUninterceptedOrReturn { + it.resume(value) + COROUTINE_SUSPENDED + } + } + + suspend fun qux(s: Long): IC = IC(s) + + suspend fun quz() = 42L + + suspend fun bar(): IC { + return foo(qux(quz())) + } + + suspend fun test() = bar().s +} + +class Test3 { + suspend fun foo(value: T): T { + return suspendCoroutineUninterceptedOrReturn { + it.resume(value) + COROUTINE_SUSPENDED + } + } + + suspend fun bar(): IC { + return foo(IC(42L)) + } + + suspend fun test() = bar().s +} + +fun Long.toBoxResult() = + if (this == 42L) "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/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_NAny.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_NAny.kt new file mode 100644 index 00000000000..1237e71645a --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_NAny.kt @@ -0,0 +1,97 @@ +// 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?) + +class Test1() { + + 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 + + suspend fun bar(): IC { + return foo(qux(quz(IC("OK")))) + } + + suspend fun test() = bar().s +} + + +class Test2 { + + 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" + + suspend fun bar(): IC { + return foo(qux(quz())) + } + + suspend fun test() = bar().s +} + +class Test3 { + suspend fun foo(value: T): T { + return suspendCoroutineUninterceptedOrReturn { + it.resume(value) + COROUTINE_SUSPENDED + } + } + + suspend fun bar(): IC { + return foo(IC("OK")) + } + + suspend fun test() = bar().s +} + +fun box(): String { + + var result: Any? = "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 as String +} diff --git a/compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_nonLocalReturn.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_nonLocalReturn.kt new file mode 100644 index 00000000000..99680908ffb --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_nonLocalReturn.kt @@ -0,0 +1,103 @@ +// 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) + +class Test1() { + + 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 + + suspend fun bar(): IC { + run { + return foo(qux(quz(IC("OK")))) + } + } + + suspend fun test() = bar().s +} + + +class Test2 { + + 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" + + suspend fun bar(): IC { + run { + return foo(qux(quz())) + } + } + + suspend fun test() = bar().s +} + +class Test3 { + suspend fun foo(value: T): T { + return suspendCoroutineUninterceptedOrReturn { + it.resume(value) + COROUTINE_SUSPENDED + } + } + + suspend fun bar(): IC { + run { + return foo(IC("OK")) + } + } + + suspend fun test() = 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/boxUnboxInsideCoroutine_suspendFunType.kt b/compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_suspendFunType.kt new file mode 100644 index 00000000000..9917616fbb2 --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_suspendFunType.kt @@ -0,0 +1,49 @@ +// 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) + +fun suspendFunId(block: suspend () -> IC) = block + +class Test1() { + + 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 + + suspend fun bar(): IC { + return suspendFunId { foo(qux(quz(IC("OK")))) }() + } + + suspend fun test() = bar().s +} + +fun box(): String { + + var result = "FAIL" + builder { + result = Test1().test() + } + + if (result != "OK") return "FAIL 1 $result" + + return result +} diff --git a/compiler/testData/codegen/bytecodeText/coroutines/inlineClasses/inlineClassBoxingInSuspendFunReturn_Primitive.kt b/compiler/testData/codegen/bytecodeText/coroutines/inlineClasses/inlineClassBoxingInSuspendFunReturn_Primitive.kt new file mode 100644 index 00000000000..759f4e7c392 --- /dev/null +++ b/compiler/testData/codegen/bytecodeText/coroutines/inlineClasses/inlineClassBoxingInSuspendFunReturn_Primitive.kt @@ -0,0 +1,20 @@ +// IGNORE_BACKEND: JVM_IR + +inline class ICInt(val x: Int) // unbox-impl in generated 'equals' + +suspend fun suspendICInt(): ICInt = ICInt(1) // box-impl +suspend fun suspendAny(): Any = ICInt(1) // box-impl +suspend fun suspendGeneric(x: T): T = x + +fun useICInt(x: ICInt) {} +fun useAny(x: Any) {} + +suspend fun test() { + useICInt(suspendICInt()) // unbox-impl + useICInt(suspendGeneric(ICInt(1))) // box-impl, unbox-impl + useAny(suspendAny()) + useAny(suspendICInt()) +} + +// 3 INVOKESTATIC ICInt\.box-impl +// 3 INVOKEVIRTUAL ICInt\.unbox-impl \ No newline at end of file diff --git a/compiler/testData/codegen/bytecodeText/coroutines/inlineClasses/noInlineClassBoxingInSuspendFunReturn_Any.kt b/compiler/testData/codegen/bytecodeText/coroutines/inlineClasses/noInlineClassBoxingInSuspendFunReturn_Any.kt new file mode 100644 index 00000000000..8652e00d255 --- /dev/null +++ b/compiler/testData/codegen/bytecodeText/coroutines/inlineClasses/noInlineClassBoxingInSuspendFunReturn_Any.kt @@ -0,0 +1,26 @@ +// IGNORE_BACKEND: JVM_IR + +inline class ICAny(val x: Any) + +suspend fun suspendICAny(): ICAny = ICAny("") +suspend fun suspendAny(): Any = ICAny("") +suspend fun suspendGeneric(x: T): T = x + +fun useICAny(x: ICAny) {} +fun useAny(x: Any) {} + +suspend fun test() { + useICAny(suspendICAny()) + useICAny(suspendGeneric(ICAny(""))) + useAny(suspendAny()) + useAny(suspendICAny()) +} + +// -- 1 in 'suspendAny(): Any = ICAny("")' +// -- 1 in 'useAny(suspendICAny())' +// -- 1 in 'suspendGeneric(ICAny(""))' +// 3 INVOKESTATIC ICAny\.box-impl + +// -- 1 in 'useICAny(suspendGeneric(ICAny(""))) +// -- 1 in 'equals-impl' for ICAny +// 2 INVOKEVIRTUAL ICAny\.unbox-impl \ No newline at end of file diff --git a/compiler/testData/codegen/bytecodeText/coroutines/inlineClasses/noInlineClassBoxingInSuspendFunReturn_InlineAny.kt b/compiler/testData/codegen/bytecodeText/coroutines/inlineClasses/noInlineClassBoxingInSuspendFunReturn_InlineAny.kt new file mode 100644 index 00000000000..5ae6d49bf84 --- /dev/null +++ b/compiler/testData/codegen/bytecodeText/coroutines/inlineClasses/noInlineClassBoxingInSuspendFunReturn_InlineAny.kt @@ -0,0 +1,24 @@ +// IGNORE_BACKEND: JVM_IR + +inline class IC0(val x: Any) // IC0.unbox-impl in generated 'equals' +inline class IC1(val x: IC0) // IC1.unbox-impl in generated 'equals' + +suspend fun suspendIC(): IC1 = IC1(IC0("")) +suspend fun suspendAny(): Any = IC1(IC0("")) // IC1.box-impl +suspend fun suspendGeneric(x: T): T = x + +fun useIC(x: IC1) {} +fun useAny(x: Any) {} + +suspend fun test() { + useIC(suspendIC()) + useIC(suspendGeneric(IC1(IC0("")))) // IC1.box-impl, IC1.unbox-impl + useAny(suspendAny()) + useAny(suspendIC()) // IC1.box-impl +} + +// 0 INVOKESTATIC IC0\.box-impl +// 3 INVOKESTATIC IC1\.box-impl + +// 1 INVOKEVIRTUAL IC0\.unbox-impl +// 2 INVOKEVIRTUAL IC1\.unbox-impl diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java index f363c4b8ba4..dd8ccb15191 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java @@ -7733,6 +7733,86 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine.kt", "kotlin.coroutines"); } + @TestMetadata("boxUnboxInsideCoroutine_Any.kt") + public void testBoxUnboxInsideCoroutine_Any_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Any.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("boxUnboxInsideCoroutine_Any.kt") + public void testBoxUnboxInsideCoroutine_Any_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Any.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_InlineAny.kt") + public void testBoxUnboxInsideCoroutine_InlineAny_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_InlineAny.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("boxUnboxInsideCoroutine_InlineAny.kt") + public void testBoxUnboxInsideCoroutine_InlineAny_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_InlineAny.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_InlineInt.kt") + public void testBoxUnboxInsideCoroutine_InlineInt_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_InlineInt.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("boxUnboxInsideCoroutine_InlineInt.kt") + public void testBoxUnboxInsideCoroutine_InlineInt_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_InlineInt.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_Int.kt") + public void testBoxUnboxInsideCoroutine_Int_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Int.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("boxUnboxInsideCoroutine_Int.kt") + public void testBoxUnboxInsideCoroutine_Int_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Int.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_Long.kt") + public void testBoxUnboxInsideCoroutine_Long_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Long.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("boxUnboxInsideCoroutine_Long.kt") + public void testBoxUnboxInsideCoroutine_Long_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Long.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_NAny.kt") + public void testBoxUnboxInsideCoroutine_NAny_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_NAny.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("boxUnboxInsideCoroutine_NAny.kt") + public void testBoxUnboxInsideCoroutine_NAny_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_NAny.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_nonLocalReturn.kt") + public void testBoxUnboxInsideCoroutine_nonLocalReturn_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_nonLocalReturn.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("boxUnboxInsideCoroutine_nonLocalReturn.kt") + public void testBoxUnboxInsideCoroutine_nonLocalReturn_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_nonLocalReturn.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_suspendFunType.kt") + public void testBoxUnboxInsideCoroutine_suspendFunType_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_suspendFunType.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("boxUnboxInsideCoroutine_suspendFunType.kt") + public void testBoxUnboxInsideCoroutine_suspendFunType_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_suspendFunType.kt", "kotlin.coroutines"); + } + @TestMetadata("bridgeGenerationCrossinline.kt") public void testBridgeGenerationCrossinline_1_2() throws Exception { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/bridgeGenerationCrossinline.kt", "kotlin.coroutines.experimental"); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/BytecodeTextTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/BytecodeTextTestGenerated.java index cb221da1e6a..b21066f70c3 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/BytecodeTextTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/BytecodeTextTestGenerated.java @@ -1472,6 +1472,34 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } } + @TestMetadata("compiler/testData/codegen/bytecodeText/coroutines/inlineClasses") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InlineClasses extends AbstractBytecodeTextTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath); + } + + public void testAllFilesPresentInInlineClasses() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + } + + @TestMetadata("inlineClassBoxingInSuspendFunReturn_Primitive.kt") + public void testInlineClassBoxingInSuspendFunReturn_Primitive() throws Exception { + runTest("compiler/testData/codegen/bytecodeText/coroutines/inlineClasses/inlineClassBoxingInSuspendFunReturn_Primitive.kt"); + } + + @TestMetadata("noInlineClassBoxingInSuspendFunReturn_Any.kt") + public void testNoInlineClassBoxingInSuspendFunReturn_Any() throws Exception { + runTest("compiler/testData/codegen/bytecodeText/coroutines/inlineClasses/noInlineClassBoxingInSuspendFunReturn_Any.kt"); + } + + @TestMetadata("noInlineClassBoxingInSuspendFunReturn_InlineAny.kt") + public void testNoInlineClassBoxingInSuspendFunReturn_InlineAny() throws Exception { + runTest("compiler/testData/codegen/bytecodeText/coroutines/inlineClasses/noInlineClassBoxingInSuspendFunReturn_InlineAny.kt"); + } + } + @TestMetadata("compiler/testData/codegen/bytecodeText/coroutines/intLikeVarSpilling") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java index 19a1d637078..271ca580b32 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java @@ -7733,6 +7733,86 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine.kt", "kotlin.coroutines"); } + @TestMetadata("boxUnboxInsideCoroutine_Any.kt") + public void testBoxUnboxInsideCoroutine_Any_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Any.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("boxUnboxInsideCoroutine_Any.kt") + public void testBoxUnboxInsideCoroutine_Any_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Any.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_InlineAny.kt") + public void testBoxUnboxInsideCoroutine_InlineAny_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_InlineAny.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("boxUnboxInsideCoroutine_InlineAny.kt") + public void testBoxUnboxInsideCoroutine_InlineAny_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_InlineAny.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_InlineInt.kt") + public void testBoxUnboxInsideCoroutine_InlineInt_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_InlineInt.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("boxUnboxInsideCoroutine_InlineInt.kt") + public void testBoxUnboxInsideCoroutine_InlineInt_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_InlineInt.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_Int.kt") + public void testBoxUnboxInsideCoroutine_Int_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Int.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("boxUnboxInsideCoroutine_Int.kt") + public void testBoxUnboxInsideCoroutine_Int_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Int.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_Long.kt") + public void testBoxUnboxInsideCoroutine_Long_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Long.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("boxUnboxInsideCoroutine_Long.kt") + public void testBoxUnboxInsideCoroutine_Long_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Long.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_NAny.kt") + public void testBoxUnboxInsideCoroutine_NAny_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_NAny.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("boxUnboxInsideCoroutine_NAny.kt") + public void testBoxUnboxInsideCoroutine_NAny_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_NAny.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_nonLocalReturn.kt") + public void testBoxUnboxInsideCoroutine_nonLocalReturn_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_nonLocalReturn.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("boxUnboxInsideCoroutine_nonLocalReturn.kt") + public void testBoxUnboxInsideCoroutine_nonLocalReturn_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_nonLocalReturn.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_suspendFunType.kt") + public void testBoxUnboxInsideCoroutine_suspendFunType_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_suspendFunType.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("boxUnboxInsideCoroutine_suspendFunType.kt") + public void testBoxUnboxInsideCoroutine_suspendFunType_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_suspendFunType.kt", "kotlin.coroutines"); + } + @TestMetadata("bridgeGenerationCrossinline.kt") public void testBridgeGenerationCrossinline_1_2() throws Exception { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/bridgeGenerationCrossinline.kt", "kotlin.coroutines.experimental"); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java index 197696ee233..cfabe030e18 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java @@ -7023,6 +7023,46 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine.kt", "kotlin.coroutines"); } + @TestMetadata("boxUnboxInsideCoroutine_Any.kt") + public void testBoxUnboxInsideCoroutine_Any_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Any.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_InlineAny.kt") + public void testBoxUnboxInsideCoroutine_InlineAny_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_InlineAny.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_InlineInt.kt") + public void testBoxUnboxInsideCoroutine_InlineInt_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_InlineInt.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_Int.kt") + public void testBoxUnboxInsideCoroutine_Int_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Int.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_Long.kt") + public void testBoxUnboxInsideCoroutine_Long_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Long.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_NAny.kt") + public void testBoxUnboxInsideCoroutine_NAny_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_NAny.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_nonLocalReturn.kt") + public void testBoxUnboxInsideCoroutine_nonLocalReturn_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_nonLocalReturn.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_suspendFunType.kt") + public void testBoxUnboxInsideCoroutine_suspendFunType_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_suspendFunType.kt", "kotlin.coroutines"); + } + @TestMetadata("bridgeGenerationCrossinline.kt") public void testBridgeGenerationCrossinline_1_3() throws Exception { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/bridgeGenerationCrossinline.kt", "kotlin.coroutines"); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBytecodeTextTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBytecodeTextTestGenerated.java index 9f939ea2892..6bbebbedb52 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBytecodeTextTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBytecodeTextTestGenerated.java @@ -1477,6 +1477,34 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } } + @TestMetadata("compiler/testData/codegen/bytecodeText/coroutines/inlineClasses") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InlineClasses extends AbstractIrBytecodeTextTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInInlineClasses() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @TestMetadata("inlineClassBoxingInSuspendFunReturn_Primitive.kt") + public void testInlineClassBoxingInSuspendFunReturn_Primitive() throws Exception { + runTest("compiler/testData/codegen/bytecodeText/coroutines/inlineClasses/inlineClassBoxingInSuspendFunReturn_Primitive.kt"); + } + + @TestMetadata("noInlineClassBoxingInSuspendFunReturn_Any.kt") + public void testNoInlineClassBoxingInSuspendFunReturn_Any() throws Exception { + runTest("compiler/testData/codegen/bytecodeText/coroutines/inlineClasses/noInlineClassBoxingInSuspendFunReturn_Any.kt"); + } + + @TestMetadata("noInlineClassBoxingInSuspendFunReturn_InlineAny.kt") + public void testNoInlineClassBoxingInSuspendFunReturn_InlineAny() throws Exception { + runTest("compiler/testData/codegen/bytecodeText/coroutines/inlineClasses/noInlineClassBoxingInSuspendFunReturn_InlineAny.kt"); + } + } + @TestMetadata("compiler/testData/codegen/bytecodeText/coroutines/intLikeVarSpilling") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) 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 79ea0981276..593de932148 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 @@ -5953,6 +5953,46 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine.kt", "kotlin.coroutines"); } + @TestMetadata("boxUnboxInsideCoroutine_Any.kt") + public void testBoxUnboxInsideCoroutine_Any_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Any.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_InlineAny.kt") + public void testBoxUnboxInsideCoroutine_InlineAny_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_InlineAny.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_InlineInt.kt") + public void testBoxUnboxInsideCoroutine_InlineInt_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_InlineInt.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_Int.kt") + public void testBoxUnboxInsideCoroutine_Int_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Int.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_Long.kt") + public void testBoxUnboxInsideCoroutine_Long_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Long.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_NAny.kt") + public void testBoxUnboxInsideCoroutine_NAny_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_NAny.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_nonLocalReturn.kt") + public void testBoxUnboxInsideCoroutine_nonLocalReturn_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_nonLocalReturn.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_suspendFunType.kt") + public void testBoxUnboxInsideCoroutine_suspendFunType_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_suspendFunType.kt", "kotlin.coroutines"); + } + @TestMetadata("bridgeGenerationCrossinline.kt") public void testBridgeGenerationCrossinline_1_3() throws Exception { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/bridgeGenerationCrossinline.kt", "kotlin.coroutines"); 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 428dd97862e..9abe23d264b 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 @@ -5953,6 +5953,46 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine.kt", "kotlin.coroutines"); } + @TestMetadata("boxUnboxInsideCoroutine_Any.kt") + public void testBoxUnboxInsideCoroutine_Any_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Any.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_InlineAny.kt") + public void testBoxUnboxInsideCoroutine_InlineAny_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_InlineAny.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_InlineInt.kt") + public void testBoxUnboxInsideCoroutine_InlineInt_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_InlineInt.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_Int.kt") + public void testBoxUnboxInsideCoroutine_Int_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Int.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_Long.kt") + public void testBoxUnboxInsideCoroutine_Long_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_Long.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_NAny.kt") + public void testBoxUnboxInsideCoroutine_NAny_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_NAny.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_nonLocalReturn.kt") + public void testBoxUnboxInsideCoroutine_nonLocalReturn_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_nonLocalReturn.kt", "kotlin.coroutines"); + } + + @TestMetadata("boxUnboxInsideCoroutine_suspendFunType.kt") + public void testBoxUnboxInsideCoroutine_suspendFunType_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/boxUnboxInsideCoroutine_suspendFunType.kt", "kotlin.coroutines"); + } + @TestMetadata("bridgeGenerationCrossinline.kt") public void testBridgeGenerationCrossinline_1_3() throws Exception { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/bridgeGenerationCrossinline.kt", "kotlin.coroutines");