From 00e952ab1597639fef6ed0855a3067c06a90cdad Mon Sep 17 00:00:00 2001 From: Ilmir Usmanov Date: Thu, 4 Apr 2019 20:33:13 +0300 Subject: [PATCH] Introduce CHECK_TAIL_CALL_OPTIMIZATION directive This directive generates TailCallOptimizationChecker in package helpers. The check for tail call optimization is based on coroutine stack traces bug (feature?): when tail call optimization hits, the continuation object is not generated. Thus, there is no debug metadata for this suspend function. Consequently, the coroutines stack trace does not contain stack trace element for that function. This check is performed by TailCallOptimizationChecker. Since this is runtime check, unlike bytecode tests, it does not require test data adjustments on each codegen or inliner change. Since the check is based on debug metadata, which is JVM specific, there is not support for other backends yet. --- .../{tailCallOptimizations => }/epam.kt | 1 - .../coroutines/tailCallOptimizations/also.kt | 12 +- .../coroutines/tailCallOptimizations/also.txt | 34 ---- .../tailCallOptimizations/also_1_2.txt | 33 ---- .../coroutines/tailCallOptimizations/epam.txt | 83 -------- .../tailCallOptimizations/epam_1_2.txt | 74 ------- .../inlineWithStateMachine.kt | 14 +- .../inlineWithStateMachine.txt | 50 ----- .../inlineWithStateMachine_1_2.txt | 50 ----- .../tailCallOptimizations/simple.kt | 12 +- .../tailCallOptimizations/simple.txt | 21 -- .../tailCallOptimizations/simple_1_2.txt | 19 -- .../tailCallIfReturnUnit.kt | 33 ++++ .../tailCallIntrinsics.kt | 40 ++++ .../tailSuspendUnitFun.kt | 129 ++++++++++++ .../tailCallOptimizations/tryCatchTailCall.kt | 33 ++++ .../tailCallOptimizations/unreachable.kt | 183 ++++++++++++++++-- .../tailCallOptimizations/whenUnit.kt | 21 +- .../tailCallOptimizations/whenUnit.txt | 44 ----- .../tailCallOptimizations/whenUnit_1_2.txt | 42 ---- .../bytecodeListing/releaseCoroutines.txt | 32 --- .../tailcall/tailCallIfReturnUnit.kt | 17 -- .../tailcall/tailCallIfReturnUnit.txt | 6 - .../tailcall/tailCallIfReturnUnit_1_3.txt | 6 - .../tailcall/tailCallIntrinsics.kt | 19 -- .../tailcall/tailCallIntrinsics.txt | 20 -- .../tailcall/tailSuspendUnitFun.kt | 64 ------ .../tailcall/tailSuspendUnitFun.txt | 115 ----------- .../tailcall/tailSuspendUnitFun_1_3.txt | 112 ----------- .../tailcall/tryCatchTailCall.kt | 13 -- .../tailcall/tryCatchTailCall.txt | 17 -- .../tailcall/tryCatchTailCall_1_3.txt | 16 -- .../bytecodeListing/tailcall/unreachable.kt | 121 ------------ .../bytecodeListing/tailcall/unreachable.txt | 115 ----------- .../tailcall/unreachable_1_3.txt | 112 ----------- .../bytecodeListing/tailcall/whenUnit.kt | 12 -- .../bytecodeListing/tailcall/whenUnit.txt | 26 --- .../codegen/AbstractBlackBoxCodegenTest.java | 2 +- .../codegen/AbstractBytecodeListingTest.kt | 2 +- .../kotlin/codegen/CodegenTestCase.java | 2 +- .../org/jetbrains/kotlin/coroutineTestUtil.kt | 41 +++- .../kotlin/test/KotlinTestUtils.java | 15 +- .../kotlin/test/KotlinTestUtils.java.as32 | 13 +- .../codegen/BlackBoxCodegenTestGenerated.java | 81 ++++---- .../codegen/BytecodeListingTestGenerated.java | 72 ------- .../LightAnalysisModeTestGenerated.java | 81 ++++---- .../ir/IrBlackBoxCodegenTestGenerated.java | 81 ++++---- .../IrJsCodegenBoxTestGenerated.java | 35 +--- .../semantics/JsCodegenBoxTestGenerated.java | 70 +------ 49 files changed, 633 insertions(+), 1613 deletions(-) rename compiler/testData/codegen/box/coroutines/{tailCallOptimizations => }/epam.kt (96%) delete mode 100644 compiler/testData/codegen/box/coroutines/tailCallOptimizations/also.txt delete mode 100644 compiler/testData/codegen/box/coroutines/tailCallOptimizations/also_1_2.txt delete mode 100644 compiler/testData/codegen/box/coroutines/tailCallOptimizations/epam.txt delete mode 100644 compiler/testData/codegen/box/coroutines/tailCallOptimizations/epam_1_2.txt delete mode 100644 compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithStateMachine.txt delete mode 100644 compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithStateMachine_1_2.txt delete mode 100644 compiler/testData/codegen/box/coroutines/tailCallOptimizations/simple.txt delete mode 100644 compiler/testData/codegen/box/coroutines/tailCallOptimizations/simple_1_2.txt create mode 100644 compiler/testData/codegen/box/coroutines/tailCallOptimizations/tailCallIfReturnUnit.kt create mode 100644 compiler/testData/codegen/box/coroutines/tailCallOptimizations/tailCallIntrinsics.kt create mode 100644 compiler/testData/codegen/box/coroutines/tailCallOptimizations/tailSuspendUnitFun.kt create mode 100644 compiler/testData/codegen/box/coroutines/tailCallOptimizations/tryCatchTailCall.kt delete mode 100644 compiler/testData/codegen/box/coroutines/tailCallOptimizations/whenUnit.txt delete mode 100644 compiler/testData/codegen/box/coroutines/tailCallOptimizations/whenUnit_1_2.txt delete mode 100644 compiler/testData/codegen/bytecodeListing/releaseCoroutines.txt delete mode 100644 compiler/testData/codegen/bytecodeListing/tailcall/tailCallIfReturnUnit.kt delete mode 100644 compiler/testData/codegen/bytecodeListing/tailcall/tailCallIfReturnUnit.txt delete mode 100644 compiler/testData/codegen/bytecodeListing/tailcall/tailCallIfReturnUnit_1_3.txt delete mode 100644 compiler/testData/codegen/bytecodeListing/tailcall/tailCallIntrinsics.kt delete mode 100644 compiler/testData/codegen/bytecodeListing/tailcall/tailCallIntrinsics.txt delete mode 100644 compiler/testData/codegen/bytecodeListing/tailcall/tailSuspendUnitFun.kt delete mode 100644 compiler/testData/codegen/bytecodeListing/tailcall/tailSuspendUnitFun.txt delete mode 100644 compiler/testData/codegen/bytecodeListing/tailcall/tailSuspendUnitFun_1_3.txt delete mode 100644 compiler/testData/codegen/bytecodeListing/tailcall/tryCatchTailCall.kt delete mode 100644 compiler/testData/codegen/bytecodeListing/tailcall/tryCatchTailCall.txt delete mode 100644 compiler/testData/codegen/bytecodeListing/tailcall/tryCatchTailCall_1_3.txt delete mode 100644 compiler/testData/codegen/bytecodeListing/tailcall/unreachable.kt delete mode 100644 compiler/testData/codegen/bytecodeListing/tailcall/unreachable.txt delete mode 100644 compiler/testData/codegen/bytecodeListing/tailcall/unreachable_1_3.txt delete mode 100644 compiler/testData/codegen/bytecodeListing/tailcall/whenUnit.kt delete mode 100644 compiler/testData/codegen/bytecodeListing/tailcall/whenUnit.txt diff --git a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/epam.kt b/compiler/testData/codegen/box/coroutines/epam.kt similarity index 96% rename from compiler/testData/codegen/box/coroutines/tailCallOptimizations/epam.kt rename to compiler/testData/codegen/box/coroutines/epam.kt index 63b36e9d3f0..f9ada0e88c7 100644 --- a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/epam.kt +++ b/compiler/testData/codegen/box/coroutines/epam.kt @@ -3,7 +3,6 @@ // COMMON_COROUTINES_TEST // WITH_RUNTIME // WITH_COROUTINES -// CHECK_BYTECODE_LISTING import helpers.* import COROUTINES_PACKAGE.* diff --git a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/also.kt b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/also.kt index 3e2aa82dec7..ad7018cd04a 100644 --- a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/also.kt +++ b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/also.kt @@ -1,13 +1,14 @@ // IGNORE_BACKEND: JVM_IR -// COMMON_COROUTINES_TEST +// TARGET_BACKEND: JVM +// FULL_JDK // WITH_RUNTIME // WITH_COROUTINES -// CHECK_BYTECODE_LISTING - +// CHECK_TAIL_CALL_OPTIMIZATION import helpers.* -import COROUTINES_PACKAGE.* +import kotlin.coroutines.* +import kotlin.coroutines.intrinsics.* -suspend fun dummy(): Unit = Unit +suspend fun dummy() = TailCallOptimizationChecker.saveStackTrace() suspend fun test(): Int = 1.also { dummy() } @@ -21,5 +22,6 @@ fun box(): String { builder { res = test() } + TailCallOptimizationChecker.checkStateMachineIn("test") return if (res == 1) "OK" else "FAIL" } diff --git a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/also.txt b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/also.txt deleted file mode 100644 index dce4b87f3bc..00000000000 --- a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/also.txt +++ /dev/null @@ -1,34 +0,0 @@ -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class AlsoKt$box$1 { - synthetic final field $res: kotlin.jvm.internal.Ref$IntRef - field L$0: java.lang.Object - field label: int - inner class AlsoKt$box$1 - method (p0: kotlin.jvm.internal.Ref$IntRef, p1: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -@kotlin.coroutines.jvm.internal.DebugMetadata -final class AlsoKt$test$1 { - field I$0: int - field L$0: java.lang.Object - field label: int - synthetic field result: java.lang.Object - inner class AlsoKt$test$1 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -public final class AlsoKt { - inner class AlsoKt$box$1 - inner class AlsoKt$test$1 - public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String - public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void - public final static @org.jetbrains.annotations.Nullable method dummy(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method test(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object -} diff --git a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/also_1_2.txt b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/also_1_2.txt deleted file mode 100644 index bc7bb4fe8e3..00000000000 --- a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/also_1_2.txt +++ /dev/null @@ -1,33 +0,0 @@ -@kotlin.Metadata -final class AlsoKt$box$1 { - synthetic final field $res: kotlin.jvm.internal.Ref$IntRef - field L$0: java.lang.Object - inner class AlsoKt$box$1 - method (p0: kotlin.jvm.internal.Ref$IntRef, p1: kotlin.coroutines.experimental.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): kotlin.coroutines.experimental.Continuation - public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object - public final method invoke(p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -final class AlsoKt$test$1 { - field I$0: int - field L$0: java.lang.Object - synthetic field data: java.lang.Object - synthetic field exception: java.lang.Throwable - inner class AlsoKt$test$1 - method (p0: kotlin.coroutines.experimental.Continuation): void - public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object - synthetic final method getLabel(): int - synthetic final method setLabel(p0: int): void -} - -@kotlin.Metadata -public final class AlsoKt { - inner class AlsoKt$box$1 - inner class AlsoKt$test$1 - public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String - public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void - public final static @org.jetbrains.annotations.Nullable method dummy(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method test(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): java.lang.Object -} diff --git a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/epam.txt b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/epam.txt deleted file mode 100644 index 5d02678e008..00000000000 --- a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/epam.txt +++ /dev/null @@ -1,83 +0,0 @@ -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -public final class EpamKt$box$1$invokeSuspend$$inlined$zip$1 { - synthetic final field $source1: MyDeferred - synthetic final field $source2: MyDeferred - field L$0: java.lang.Object - field label: int - inner class EpamKt$box$1$invokeSuspend$$inlined$zip$1 - public method (p0: MyDeferred, p1: MyDeferred, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class EpamKt$box$1 { - synthetic final field $first: MyDeferred - synthetic final field $result: kotlin.jvm.internal.Ref$IntRef - synthetic final field $second: MyDeferred - field L$0: java.lang.Object - field label: int - inner class EpamKt$box$1 - method (p0: kotlin.jvm.internal.Ref$IntRef, p1: MyDeferred, p2: MyDeferred, p3: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class EpamKt$box$first$1 { - field label: int - inner class EpamKt$box$first$1 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class EpamKt$box$second$1 { - field label: int - inner class EpamKt$box$second$1 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -public final class EpamKt$zip$1 { - synthetic final field $source1: MyDeferred - synthetic final field $source2: MyDeferred - synthetic final field $zipper: kotlin.jvm.functions.Function2 - field label: int - inner class EpamKt$zip$1 - public method (p0: kotlin.jvm.functions.Function2, p1: MyDeferred, p2: MyDeferred, p3: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -public final class EpamKt { - inner class EpamKt$box$1 - inner class EpamKt$box$first$1 - inner class EpamKt$box$second$1 - inner class EpamKt$zip$1 - public final static @org.jetbrains.annotations.NotNull method async(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): MyDeferred - public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String - public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void - public final static @org.jetbrains.annotations.NotNull method zip(@org.jetbrains.annotations.NotNull p0: MyDeferred, @org.jetbrains.annotations.NotNull p1: MyDeferred, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2): MyDeferred -} - -@kotlin.Metadata -public final class MyDeferred { - private final @org.jetbrains.annotations.NotNull field t: kotlin.jvm.functions.Function1 - public method (@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void - public final @org.jetbrains.annotations.Nullable method await(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public final @org.jetbrains.annotations.NotNull method getT(): kotlin.jvm.functions.Function1 -} diff --git a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/epam_1_2.txt b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/epam_1_2.txt deleted file mode 100644 index b577a90d507..00000000000 --- a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/epam_1_2.txt +++ /dev/null @@ -1,74 +0,0 @@ -@kotlin.Metadata -public final class EpamKt$box$1$doResume$$inlined$zip$1 { - synthetic final field $source1: MyDeferred - synthetic final field $source2: MyDeferred - field L$0: java.lang.Object - inner class EpamKt$box$1$doResume$$inlined$zip$1 - public method (p0: MyDeferred, p1: MyDeferred, p2: kotlin.coroutines.experimental.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): kotlin.coroutines.experimental.Continuation - public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object - public final method invoke(p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -final class EpamKt$box$1 { - synthetic final field $first: MyDeferred - synthetic final field $result: kotlin.jvm.internal.Ref$IntRef - synthetic final field $second: MyDeferred - field L$0: java.lang.Object - inner class EpamKt$box$1 - method (p0: kotlin.jvm.internal.Ref$IntRef, p1: MyDeferred, p2: MyDeferred, p3: kotlin.coroutines.experimental.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): kotlin.coroutines.experimental.Continuation - public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object - public final method invoke(p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -final class EpamKt$box$first$1 { - inner class EpamKt$box$first$1 - method (p0: kotlin.coroutines.experimental.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): kotlin.coroutines.experimental.Continuation - public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object - public final method invoke(p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -final class EpamKt$box$second$1 { - inner class EpamKt$box$second$1 - method (p0: kotlin.coroutines.experimental.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): kotlin.coroutines.experimental.Continuation - public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object - public final method invoke(p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -public final class EpamKt$zip$1 { - synthetic final field $source1: MyDeferred - synthetic final field $source2: MyDeferred - synthetic final field $zipper: kotlin.jvm.functions.Function2 - inner class EpamKt$zip$1 - public method (p0: kotlin.jvm.functions.Function2, p1: MyDeferred, p2: MyDeferred, p3: kotlin.coroutines.experimental.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): kotlin.coroutines.experimental.Continuation - public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object - public final method invoke(p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -public final class EpamKt { - inner class EpamKt$box$1 - inner class EpamKt$box$first$1 - inner class EpamKt$box$second$1 - inner class EpamKt$zip$1 - public final static @org.jetbrains.annotations.NotNull method async(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): MyDeferred - public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String - public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void - public final static @org.jetbrains.annotations.NotNull method zip(@org.jetbrains.annotations.NotNull p0: MyDeferred, @org.jetbrains.annotations.NotNull p1: MyDeferred, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2): MyDeferred -} - -@kotlin.Metadata -public final class MyDeferred { - private final @org.jetbrains.annotations.NotNull field t: kotlin.jvm.functions.Function1 - public method (@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void - public final @org.jetbrains.annotations.Nullable method await(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): java.lang.Object - public final @org.jetbrains.annotations.NotNull method getT(): kotlin.jvm.functions.Function1 -} diff --git a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithStateMachine.kt b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithStateMachine.kt index f3b6f416aa9..969947d3409 100644 --- a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithStateMachine.kt +++ b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithStateMachine.kt @@ -1,15 +1,15 @@ // IGNORE_BACKEND: JVM_IR +// TARGET_BACKEND: JVM +// FULL_JDK // WITH_RUNTIME // WITH_COROUTINES -// COMMON_COROUTINES_TEST +// CHECK_TAIL_CALL_OPTIMIZATION import helpers.* -// CHECK_BYTECODE_LISTING -// CHECK_NEW_COUNT: function=suspendHere count=1 -// CHECK_NEW_COUNT: function=mainSuspend count=1 -import COROUTINES_PACKAGE.* -import COROUTINES_PACKAGE.intrinsics.* +import kotlin.coroutines.* +import kotlin.coroutines.intrinsics.* inline suspend fun suspendThere(v: String): String = suspendCoroutineUninterceptedOrReturn { x -> + TailCallOptimizationChecker.saveStackTrace(x) x.resume(v) COROUTINE_SUSPENDED } @@ -30,5 +30,7 @@ fun box(): String { result = mainSuspend() } + TailCallOptimizationChecker.checkStateMachineIn("mainSuspend") + return result } diff --git a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithStateMachine.txt b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithStateMachine.txt deleted file mode 100644 index 9761a230cec..00000000000 --- a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithStateMachine.txt +++ /dev/null @@ -1,50 +0,0 @@ -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class InlineWithStateMachineKt$box$1 { - synthetic final field $result: kotlin.jvm.internal.Ref$ObjectRef - field L$0: java.lang.Object - field label: int - inner class InlineWithStateMachineKt$box$1 - method (p0: kotlin.jvm.internal.Ref$ObjectRef, p1: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -@kotlin.coroutines.jvm.internal.DebugMetadata -final class InlineWithStateMachineKt$mainSuspend$1 { - field L$0: java.lang.Object - field L$1: java.lang.Object - field label: int - synthetic field result: java.lang.Object - inner class InlineWithStateMachineKt$mainSuspend$1 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -@kotlin.coroutines.jvm.internal.DebugMetadata -public final class InlineWithStateMachineKt$suspendHere$1 { - field L$0: java.lang.Object - field L$1: java.lang.Object - field label: int - synthetic field result: java.lang.Object - inner class InlineWithStateMachineKt$suspendHere$1 - public method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -public final class InlineWithStateMachineKt { - inner class InlineWithStateMachineKt$box$1 - inner class InlineWithStateMachineKt$mainSuspend$1 - inner class InlineWithStateMachineKt$suspendHere$1 - public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String - public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void - public final static @org.jetbrains.annotations.Nullable method mainSuspend(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - private final static @org.jetbrains.annotations.Nullable method suspendHere$$forInline(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method suspendHere(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - private final static @org.jetbrains.annotations.Nullable method suspendThere$$forInline(@org.jetbrains.annotations.NotNull p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method suspendThere(@org.jetbrains.annotations.NotNull p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object -} diff --git a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithStateMachine_1_2.txt b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithStateMachine_1_2.txt deleted file mode 100644 index c9c8735cc09..00000000000 --- a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithStateMachine_1_2.txt +++ /dev/null @@ -1,50 +0,0 @@ -@kotlin.Metadata -final class InlineWithStateMachineKt$box$1 { - synthetic final field $result: kotlin.jvm.internal.Ref$ObjectRef - field L$0: java.lang.Object - inner class InlineWithStateMachineKt$box$1 - method (p0: kotlin.jvm.internal.Ref$ObjectRef, p1: kotlin.coroutines.experimental.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): kotlin.coroutines.experimental.Continuation - public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object - public final method invoke(p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -final class InlineWithStateMachineKt$mainSuspend$1 { - field L$0: java.lang.Object - field L$1: java.lang.Object - synthetic field data: java.lang.Object - synthetic field exception: java.lang.Throwable - inner class InlineWithStateMachineKt$mainSuspend$1 - method (p0: kotlin.coroutines.experimental.Continuation): void - public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object - synthetic final method getLabel(): int - synthetic final method setLabel(p0: int): void -} - -@kotlin.Metadata -public final class InlineWithStateMachineKt$suspendHere$1 { - field L$0: java.lang.Object - field L$1: java.lang.Object - synthetic field data: java.lang.Object - synthetic field exception: java.lang.Throwable - inner class InlineWithStateMachineKt$suspendHere$1 - public method (p0: kotlin.coroutines.experimental.Continuation): void - public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object - synthetic final method getLabel(): int - synthetic final method setLabel(p0: int): void -} - -@kotlin.Metadata -public final class InlineWithStateMachineKt { - inner class InlineWithStateMachineKt$box$1 - inner class InlineWithStateMachineKt$mainSuspend$1 - inner class InlineWithStateMachineKt$suspendHere$1 - public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String - public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void - public final static @org.jetbrains.annotations.Nullable method mainSuspend(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): java.lang.Object - private final static @org.jetbrains.annotations.Nullable method suspendHere$$forInline(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method suspendHere(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): java.lang.Object - private final static @org.jetbrains.annotations.Nullable method suspendThere$$forInline(@org.jetbrains.annotations.NotNull p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method suspendThere(@org.jetbrains.annotations.NotNull p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object -} diff --git a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/simple.kt b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/simple.kt index 8955a3b15e9..a4c4cd4ab89 100644 --- a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/simple.kt +++ b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/simple.kt @@ -1,14 +1,15 @@ // IGNORE_BACKEND: JVM_IR +// TARGET_BACKEND: JVM +// FULL_JDK // WITH_RUNTIME // WITH_COROUTINES -// CHECK_BYTECODE_LISTING -// CHECK_NEW_COUNT: function=suspendHere count=0 -// COMMON_COROUTINES_TEST +// CHECK_TAIL_CALL_OPTIMIZATION import helpers.* -import COROUTINES_PACKAGE.* -import COROUTINES_PACKAGE.intrinsics.* +import kotlin.coroutines.* +import kotlin.coroutines.intrinsics.* suspend fun suspendThere(v: String): String = suspendCoroutineUninterceptedOrReturn { x -> + TailCallOptimizationChecker.saveStackTrace(x) x.resume(v) COROUTINE_SUSPENDED } @@ -25,6 +26,7 @@ fun box(): String { builder { result = suspendHere() } + TailCallOptimizationChecker.checkNoStateMachineIn("suspendHere") return result } diff --git a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/simple.txt b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/simple.txt deleted file mode 100644 index a55bc191a68..00000000000 --- a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/simple.txt +++ /dev/null @@ -1,21 +0,0 @@ -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class SimpleKt$box$1 { - synthetic final field $result: kotlin.jvm.internal.Ref$ObjectRef - field L$0: java.lang.Object - field label: int - inner class SimpleKt$box$1 - method (p0: kotlin.jvm.internal.Ref$ObjectRef, p1: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -public final class SimpleKt { - inner class SimpleKt$box$1 - public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String - public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void - public final static @org.jetbrains.annotations.Nullable method suspendHere(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method suspendThere(@org.jetbrains.annotations.NotNull p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object -} diff --git a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/simple_1_2.txt b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/simple_1_2.txt deleted file mode 100644 index 58051fe2123..00000000000 --- a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/simple_1_2.txt +++ /dev/null @@ -1,19 +0,0 @@ -@kotlin.Metadata -final class SimpleKt$box$1 { - synthetic final field $result: kotlin.jvm.internal.Ref$ObjectRef - field L$0: java.lang.Object - inner class SimpleKt$box$1 - method (p0: kotlin.jvm.internal.Ref$ObjectRef, p1: kotlin.coroutines.experimental.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): kotlin.coroutines.experimental.Continuation - public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object - public final method invoke(p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -public final class SimpleKt { - inner class SimpleKt$box$1 - public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String - public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void - public final static @org.jetbrains.annotations.Nullable method suspendHere(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method suspendThere(@org.jetbrains.annotations.NotNull p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object -} diff --git a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/tailCallIfReturnUnit.kt b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/tailCallIfReturnUnit.kt new file mode 100644 index 00000000000..a5defd7bf04 --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/tailCallIfReturnUnit.kt @@ -0,0 +1,33 @@ +// IGNORE_BACKEND: JVM_IR +// TARGET_BACKEND: JVM +// FULL_JDK +// WITH_RUNTIME +// WITH_COROUTINES +// CHECK_TAIL_CALL_OPTIMIZATION +import helpers.* +import kotlin.coroutines.* +import kotlin.coroutines.intrinsics.* + +fun check() = true + +suspend fun f_1(): Unit { + return f_2() +} + +private inline suspend fun f_2(): Unit { + if (check()) return + return suspendCoroutineUninterceptedOrReturn { + TailCallOptimizationChecker.saveStackTrace(it) + COROUTINE_SUSPENDED + } +} + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +fun box(): String { + builder { f_1() } + TailCallOptimizationChecker.checkNoStateMachineIn("f_1") + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/tailCallIntrinsics.kt b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/tailCallIntrinsics.kt new file mode 100644 index 00000000000..c23d7a3107d --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/tailCallIntrinsics.kt @@ -0,0 +1,40 @@ +// IGNORE_BACKEND: JVM_IR +// TARGET_BACKEND: JVM +// FULL_JDK +// WITH_RUNTIME +// WITH_COROUTINES +// CHECK_TAIL_CALL_OPTIMIZATION +import helpers.* +import kotlin.coroutines.* +import kotlin.coroutines.intrinsics.* + +var p: Int = 5846814 +private suspend fun withoutInline() { + val c = { c: Continuation -> + TailCallOptimizationChecker.saveStackTrace(c) + if (p > 52158) Unit else COROUTINE_SUSPENDED + } + + return suspendCoroutineUninterceptedOrReturn(c) +} + +private suspend fun withInline() { + return suspendCoroutineUninterceptedOrReturn { c -> + TailCallOptimizationChecker.saveStackTrace(c) + if (p > 52158) Unit else COROUTINE_SUSPENDED + } +} + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +fun box(): String { + builder { + withoutInline() + TailCallOptimizationChecker.checkNoStateMachineIn("withoutInline") + withInline() + TailCallOptimizationChecker.checkNoStateMachineIn("withInline") + } + return "OK" +} diff --git a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/tailSuspendUnitFun.kt b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/tailSuspendUnitFun.kt new file mode 100644 index 00000000000..d47c6071e0f --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/tailSuspendUnitFun.kt @@ -0,0 +1,129 @@ +// IGNORE_BACKEND: JVM_IR +// TARGET_BACKEND: JVM +// FULL_JDK +// WITH_RUNTIME +// WITH_COROUTINES +// CHECK_TAIL_CALL_OPTIMIZATION +import helpers.* +import kotlin.coroutines.* +import kotlin.coroutines.intrinsics.* + +suspend fun empty() = TailCallOptimizationChecker.saveStackTrace() +suspend fun withoutReturn() { empty() } +suspend fun withReturn() { return empty() } +suspend fun notTailCall() { empty(); empty() } +suspend fun lambdaAsParameter(c: suspend ()->Unit) { c() } +suspend fun lambdaAsParameterNotTailCall(c: suspend ()->Unit) { c(); c() } +suspend fun lambdaAsParameterReturn(c: suspend ()->Unit) { return c() } +suspend fun returnsInt() = 42.also { TailCallOptimizationChecker.saveStackTrace() } +// This should not be tail-call, since the caller should push Unit.INSTANCE on stack +suspend fun callsIntNotTailCall() { returnsInt() } +suspend fun multipleExitPoints(b: Boolean) { if (b) empty() else withoutReturn() } +suspend fun multipleExitPointsNotTailCall(b: Boolean) { if (b) empty() else returnsInt() } + +fun ordinary() = 1 +inline fun ordinaryInline() { ordinary() } +suspend fun multipleExitPointsWithOrdinaryInline(b: Boolean) { if (b) empty() else ordinaryInline() } + +suspend fun multipleExitPointsWhen(i: Int) { + when(i) { + 1 -> empty() + 2 -> withReturn() + 3 -> withoutReturn() + else -> lambdaAsParameter {} + } +} + +suspend fun generic() = (Unit as T).also { TailCallOptimizationChecker.saveStackTrace() } +suspend fun useGenericReturningUnit() { + generic() +} + +class Generic { + suspend fun foo() = generic() +} +suspend fun useGenericClass(g: Generic) { + g.foo() +} + +suspend fun genericInferType(c: () -> T) = c().also { TailCallOptimizationChecker.saveStackTrace() } +suspend fun useGenericInferType() { + genericInferType {} +} + +suspend fun nullableUnit(): Unit? = null.also { TailCallOptimizationChecker.saveStackTrace() } +suspend fun useNullableUnit() { + nullableUnit() +} + +suspend fun useRunRunRunRunRun() { + run { + run { + run { + run { + run { + empty() + } + } + } + } + } +} + + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +fun box(): String { + builder { + withoutReturn() + TailCallOptimizationChecker.checkNoStateMachineIn("withoutReturn") + + withReturn() + TailCallOptimizationChecker.checkNoStateMachineIn("withReturn") + + notTailCall() + TailCallOptimizationChecker.checkStateMachineIn("notTailCall") + + lambdaAsParameter { TailCallOptimizationChecker.saveStackTrace() } + TailCallOptimizationChecker.checkNoStateMachineIn("lambdaAsParameter") + + lambdaAsParameterNotTailCall { TailCallOptimizationChecker.saveStackTrace() } + TailCallOptimizationChecker.checkStateMachineIn("lambdaAsParameterNotTailCall") + + lambdaAsParameterReturn { TailCallOptimizationChecker.saveStackTrace() } + TailCallOptimizationChecker.checkNoStateMachineIn("lambdaAsParameterReturn") + + callsIntNotTailCall() + TailCallOptimizationChecker.checkStateMachineIn("callsIntNotTailCall") + + multipleExitPoints(false) + TailCallOptimizationChecker.checkNoStateMachineIn("multipleExitPoints") + + multipleExitPointsNotTailCall(false) + TailCallOptimizationChecker.checkStateMachineIn("multipleExitPointsNotTailCall") + + multipleExitPointsWithOrdinaryInline(true) + TailCallOptimizationChecker.checkNoStateMachineIn("multipleExitPointsWithOrdinaryInline") + + multipleExitPointsWhen(1) + TailCallOptimizationChecker.checkNoStateMachineIn("multipleExitPointsWhen") + + useGenericReturningUnit() + TailCallOptimizationChecker.checkNoStateMachineIn("useGenericReturningUnit") + + useGenericClass(Generic()) + TailCallOptimizationChecker.checkNoStateMachineIn("useGenericClass") + + useGenericInferType() + TailCallOptimizationChecker.checkNoStateMachineIn("useGenericInferType") + + useNullableUnit() + TailCallOptimizationChecker.checkStateMachineIn("useNullableUnit") + + useRunRunRunRunRun() + TailCallOptimizationChecker.checkNoStateMachineIn("useRunRunRunRunRun") + } + return "OK" +} diff --git a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/tryCatchTailCall.kt b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/tryCatchTailCall.kt new file mode 100644 index 00000000000..3b98f16441e --- /dev/null +++ b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/tryCatchTailCall.kt @@ -0,0 +1,33 @@ +// IGNORE_BACKEND: JVM_IR +// TARGET_BACKEND: JVM +// FULL_JDK +// WITH_RUNTIME +// WITH_COROUTINES +// CHECK_TAIL_CALL_OPTIMIZATION +import helpers.* +import kotlin.coroutines.* +import kotlin.coroutines.intrinsics.* + +suspend fun catchException(): String { + try { + return suspendWithException() + } + catch(e: Exception) { + return e.message!! + } +} + +suspend fun suspendWithException(): String = "OK".also { TailCallOptimizationChecker.saveStackTrace() } + +fun builder(c: suspend () -> Unit) { + c.startCoroutine(EmptyContinuation) +} + +fun box(): String { + var res = "FAIL" + builder { + res = catchException() + } + TailCallOptimizationChecker.checkStateMachineIn("catchException") + return res +} diff --git a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/unreachable.kt b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/unreachable.kt index 137ccec3893..0bf8a06952e 100644 --- a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/unreachable.kt +++ b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/unreachable.kt @@ -1,26 +1,187 @@ // IGNORE_BACKEND: JVM_IR +// TARGET_BACKEND: JVM +// FULL_JDK // WITH_RUNTIME // WITH_COROUTINES -// COMMON_COROUTINES_TEST +// CHECK_TAIL_CALL_OPTIMIZATION import helpers.* -import COROUTINES_PACKAGE.* -import COROUTINES_PACKAGE.intrinsics.* +import kotlin.coroutines.* +import kotlin.coroutines.intrinsics.* -suspend fun twoReturns(c: suspend () -> Unit) { - return c() - throw RuntimeException("FAIL 1") +suspend fun empty() = TailCallOptimizationChecker.saveStackTrace() +suspend fun withoutReturn() { + empty() } +suspend fun withReturn() { + return empty() + return empty() +} + +suspend fun notTailCall() { + empty() + return empty() + empty() +} + +suspend fun lambdaAsParameter(c: suspend () -> Unit) { + c() +} + +suspend fun lambdaAsParameterNotTailCall(c: suspend () -> Unit) { + c() + return c() + c() +} + +suspend fun lambdaAsParameterReturn(c: suspend () -> Unit) { + return c() + c() +} + +suspend fun returnsInt() = 42.also { TailCallOptimizationChecker.saveStackTrace() } +// This should not be tail-call, since the caller should push Unit.INSTANCE on stack +suspend fun callsIntNotTailCall() { + returnsInt() + return + empty() +} + +suspend fun multipleExitPoints(b: Boolean) { + if (b) empty() else withoutReturn() + return + empty() +} + +suspend fun multipleExitPointsNotTailCall(b: Boolean) { + if (b) empty() else returnsInt() + return + empty() +} + +fun ordinary() = 1 +inline fun ordinaryInline() { + ordinary() +} + +suspend fun multipleExitPointsWithOrdinaryInline(b: Boolean) { + if (b) empty() else ordinaryInline() + return + empty() +} + +suspend fun multipleExitPointsWhen(i: Int) { + when (i) { + 1 -> empty() + 2 -> withReturn() + 3 -> withoutReturn() + else -> lambdaAsParameter {} + } + return + empty() +} + +suspend fun generic() = (Unit as T).also { TailCallOptimizationChecker.saveStackTrace() } +suspend fun useGenericReturningUnit() { + generic() + return + empty() +} + +class Generic { + suspend fun foo() = generic() +} + +suspend fun useGenericClass(g: Generic) { + g.foo() + return + empty() +} + +suspend fun genericInferType(c: () -> T) = c().also { TailCallOptimizationChecker.saveStackTrace() } +suspend fun useGenericInferType() { + genericInferType {} + return + empty() +} + +suspend fun nullableUnit(): Unit? = null.also { TailCallOptimizationChecker.saveStackTrace() } +suspend fun useNullableUnit() { + nullableUnit() + return + empty() +} + +suspend fun useRunRunRunRunRun() { + run { + run { + run { + run { + run { + empty() + } + } + } + } + } + return + empty() +} + + fun builder(c: suspend () -> Unit) { c.startCoroutine(EmptyContinuation) } fun box(): String { - var res = "FAIL" builder { - twoReturns { - res = "OK" - } + withoutReturn() + TailCallOptimizationChecker.checkNoStateMachineIn("withoutReturn") + + withReturn() + TailCallOptimizationChecker.checkNoStateMachineIn("withReturn") + + notTailCall() + TailCallOptimizationChecker.checkStateMachineIn("notTailCall") + + lambdaAsParameter { TailCallOptimizationChecker.saveStackTrace() } + TailCallOptimizationChecker.checkNoStateMachineIn("lambdaAsParameter") + + lambdaAsParameterNotTailCall { TailCallOptimizationChecker.saveStackTrace() } + TailCallOptimizationChecker.checkStateMachineIn("lambdaAsParameterNotTailCall") + + lambdaAsParameterReturn { TailCallOptimizationChecker.saveStackTrace() } + TailCallOptimizationChecker.checkNoStateMachineIn("lambdaAsParameterReturn") + + callsIntNotTailCall() + TailCallOptimizationChecker.checkStateMachineIn("callsIntNotTailCall") + + multipleExitPoints(false) + TailCallOptimizationChecker.checkNoStateMachineIn("multipleExitPoints") + + multipleExitPointsNotTailCall(false) + TailCallOptimizationChecker.checkStateMachineIn("multipleExitPointsNotTailCall") + + multipleExitPointsWithOrdinaryInline(true) + TailCallOptimizationChecker.checkNoStateMachineIn("multipleExitPointsWithOrdinaryInline") + + multipleExitPointsWhen(1) + TailCallOptimizationChecker.checkNoStateMachineIn("multipleExitPointsWhen") + + useGenericReturningUnit() + TailCallOptimizationChecker.checkNoStateMachineIn("useGenericReturningUnit") + + useGenericClass(Generic()) + TailCallOptimizationChecker.checkNoStateMachineIn("useGenericClass") + + useGenericInferType() + TailCallOptimizationChecker.checkNoStateMachineIn("useGenericInferType") + + useNullableUnit() + TailCallOptimizationChecker.checkStateMachineIn("useNullableUnit") + + useRunRunRunRunRun() + TailCallOptimizationChecker.checkNoStateMachineIn("useRunRunRunRunRun") } - return res + return "OK" } diff --git a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/whenUnit.kt b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/whenUnit.kt index 8a5675b0ccd..4a596d6542a 100644 --- a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/whenUnit.kt +++ b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/whenUnit.kt @@ -1,10 +1,12 @@ // IGNORE_BACKEND: JVM_IR +// TARGET_BACKEND: JVM +// FULL_JDK // WITH_RUNTIME // WITH_COROUTINES -// COMMON_COROUTINES_TEST -// CHECK_BYTECODE_LISTING +// CHECK_TAIL_CALL_OPTIMIZATION import helpers.* -import COROUTINES_PACKAGE.* +import kotlin.coroutines.* +import kotlin.coroutines.intrinsics.* sealed class X { class A : X() @@ -13,8 +15,15 @@ sealed class X { var log = "" -suspend fun process(a: X.A) { log = "${log}from A;" } -suspend fun process(b: X.B) { log = "${log}from B;" } +suspend fun process(a: X.A) { + log = "${log}from A;" + TailCallOptimizationChecker.saveStackTrace() +} + +suspend fun process(b: X.B) { + log = "${log}from B;" + TailCallOptimizationChecker.saveStackTrace() +} suspend fun process(x: X) = when (x) { is X.A -> process(x) @@ -28,7 +37,9 @@ fun builder(c: suspend () -> Unit) { fun box(): String { builder { process(X.A()) + TailCallOptimizationChecker.checkNoStateMachineIn("process") process(X.B()) + TailCallOptimizationChecker.checkNoStateMachineIn("process") } if (log != "from A;from B;") return log return "OK" diff --git a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/whenUnit.txt b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/whenUnit.txt deleted file mode 100644 index 803a4587e0f..00000000000 --- a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/whenUnit.txt +++ /dev/null @@ -1,44 +0,0 @@ -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class WhenUnitKt$box$1 { - field label: int - inner class WhenUnitKt$box$1 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -public final class WhenUnitKt { - private static @org.jetbrains.annotations.NotNull field log: java.lang.String - inner class WhenUnitKt$box$1 - static method (): void - public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String - public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void - public final static @org.jetbrains.annotations.NotNull method getLog(): java.lang.String - public final static @org.jetbrains.annotations.Nullable method process(@org.jetbrains.annotations.NotNull p0: X$A, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method process(@org.jetbrains.annotations.NotNull p0: X$B, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method process(@org.jetbrains.annotations.NotNull p0: X, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object - public final static method setLog(@org.jetbrains.annotations.NotNull p0: java.lang.String): void -} - -@kotlin.Metadata -public final class X$A { - inner class X$A - public method (): void -} - -@kotlin.Metadata -public final class X$B { - inner class X$B - public method (): void -} - -@kotlin.Metadata -public abstract class X { - inner class X$A - inner class X$B - private method (): void - public synthetic method (p0: kotlin.jvm.internal.DefaultConstructorMarker): void -} diff --git a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/whenUnit_1_2.txt b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/whenUnit_1_2.txt deleted file mode 100644 index 28fcecdb56e..00000000000 --- a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/whenUnit_1_2.txt +++ /dev/null @@ -1,42 +0,0 @@ -@kotlin.Metadata -final class WhenUnitKt$box$1 { - inner class WhenUnitKt$box$1 - method (p0: kotlin.coroutines.experimental.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): kotlin.coroutines.experimental.Continuation - public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object - public final method invoke(p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -public final class WhenUnitKt { - private static @org.jetbrains.annotations.NotNull field log: java.lang.String - inner class WhenUnitKt$box$1 - static method (): void - public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String - public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void - public final static @org.jetbrains.annotations.NotNull method getLog(): java.lang.String - public final static @org.jetbrains.annotations.Nullable method process(@org.jetbrains.annotations.NotNull p0: X$A, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method process(@org.jetbrains.annotations.NotNull p0: X$B, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method process(@org.jetbrains.annotations.NotNull p0: X, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object - public final static method setLog(@org.jetbrains.annotations.NotNull p0: java.lang.String): void -} - -@kotlin.Metadata -public final class X$A { - inner class X$A - public method (): void -} - -@kotlin.Metadata -public final class X$B { - inner class X$B - public method (): void -} - -@kotlin.Metadata -public abstract class X { - inner class X$A - inner class X$B - private method (): void - public synthetic method (p0: kotlin.jvm.internal.DefaultConstructorMarker): void -} diff --git a/compiler/testData/codegen/bytecodeListing/releaseCoroutines.txt b/compiler/testData/codegen/bytecodeListing/releaseCoroutines.txt deleted file mode 100644 index c51a6b487e4..00000000000 --- a/compiler/testData/codegen/bytecodeListing/releaseCoroutines.txt +++ /dev/null @@ -1,32 +0,0 @@ -@kotlin.Metadata -final class ReleaseCoroutinesKt$l$1 { - field label: int - inner class ReleaseCoroutinesKt$l$1 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -final class ReleaseCoroutinesKt$withStateMachine$1 { - synthetic field data: java.lang.Object - field label: int - inner class ReleaseCoroutinesKt$withStateMachine$1 - method (p0: kotlin.coroutines.Continuation): void - synthetic final method getLabel(): int - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object - synthetic final method setLabel(p0: int): void -} - -@kotlin.Metadata -public final class ReleaseCoroutinesKt { - private final static @org.jetbrains.annotations.NotNull field l: kotlin.jvm.functions.Function1 - inner class ReleaseCoroutinesKt$l$1 - inner class ReleaseCoroutinesKt$withStateMachine$1 - static method (): void - public final static @org.jetbrains.annotations.NotNull method getL(): kotlin.jvm.functions.Function1 - public final static @org.jetbrains.annotations.Nullable method named(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method withStateMachine(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object -} diff --git a/compiler/testData/codegen/bytecodeListing/tailcall/tailCallIfReturnUnit.kt b/compiler/testData/codegen/bytecodeListing/tailcall/tailCallIfReturnUnit.kt deleted file mode 100644 index 21f777c0cae..00000000000 --- a/compiler/testData/codegen/bytecodeListing/tailcall/tailCallIfReturnUnit.kt +++ /dev/null @@ -1,17 +0,0 @@ -// WITH_RUNTIME -// COMMON_COROUTINES_TEST - -import COROUTINES_PACKAGE.intrinsics.* - -fun check() = true - -suspend fun f(i: Int): Unit { - return f_2() -} - -private inline suspend fun f_2(): Unit { - if (check()) return - return suspendCoroutineUninterceptedOrReturn { - COROUTINE_SUSPENDED - } -} diff --git a/compiler/testData/codegen/bytecodeListing/tailcall/tailCallIfReturnUnit.txt b/compiler/testData/codegen/bytecodeListing/tailcall/tailCallIfReturnUnit.txt deleted file mode 100644 index 38dde421230..00000000000 --- a/compiler/testData/codegen/bytecodeListing/tailcall/tailCallIfReturnUnit.txt +++ /dev/null @@ -1,6 +0,0 @@ -@kotlin.Metadata -public final class TailCallIfReturnUnitKt { - public final static method check(): boolean - public final static @org.jetbrains.annotations.Nullable method f(p0: int, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object - private synthetic final static method f_2(p0: kotlin.coroutines.experimental.Continuation): java.lang.Object -} diff --git a/compiler/testData/codegen/bytecodeListing/tailcall/tailCallIfReturnUnit_1_3.txt b/compiler/testData/codegen/bytecodeListing/tailcall/tailCallIfReturnUnit_1_3.txt deleted file mode 100644 index 7fb7923b1ca..00000000000 --- a/compiler/testData/codegen/bytecodeListing/tailcall/tailCallIfReturnUnit_1_3.txt +++ /dev/null @@ -1,6 +0,0 @@ -@kotlin.Metadata -public final class TailCallIfReturnUnitKt { - public final static method check(): boolean - public final static @org.jetbrains.annotations.Nullable method f(p0: int, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object - private synthetic final static method f_2(p0: kotlin.coroutines.Continuation): java.lang.Object -} diff --git a/compiler/testData/codegen/bytecodeListing/tailcall/tailCallIntrinsics.kt b/compiler/testData/codegen/bytecodeListing/tailcall/tailCallIntrinsics.kt deleted file mode 100644 index 896084090e8..00000000000 --- a/compiler/testData/codegen/bytecodeListing/tailcall/tailCallIntrinsics.kt +++ /dev/null @@ -1,19 +0,0 @@ -// WITH_RUNTIME -// COMMON_COROUTINES_TEST -import COROUTINES_PACKAGE.* -import COROUTINES_PACKAGE.intrinsics.* - -var p: Int = 5846814 -private suspend fun withoutInline() { - val c = { c: Continuation -> - if (p > 52158) Unit else COROUTINE_SUSPENDED - } - - return suspendCoroutineUninterceptedOrReturn(c) -} - -private suspend fun withInline() { - return suspendCoroutineUninterceptedOrReturn { c -> - if (p > 52158) Unit else COROUTINE_SUSPENDED - } -} diff --git a/compiler/testData/codegen/bytecodeListing/tailcall/tailCallIntrinsics.txt b/compiler/testData/codegen/bytecodeListing/tailcall/tailCallIntrinsics.txt deleted file mode 100644 index 2e3f0ce0941..00000000000 --- a/compiler/testData/codegen/bytecodeListing/tailcall/tailCallIntrinsics.txt +++ /dev/null @@ -1,20 +0,0 @@ -@kotlin.Metadata -final class TailCallIntrinsicsKt$withoutInline$c$1 { - public final static field INSTANCE: TailCallIntrinsicsKt$withoutInline$c$1 - inner class TailCallIntrinsicsKt$withoutInline$c$1 - static method (): void - method (): void - public final @org.jetbrains.annotations.NotNull method invoke(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object - public synthetic method invoke(p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -public final class TailCallIntrinsicsKt { - private static field p: int - inner class TailCallIntrinsicsKt$withoutInline$c$1 - static method (): void - public final static method getP(): int - public final static method setP(p0: int): void - synthetic final static @org.jetbrains.annotations.Nullable method withInline(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object - synthetic final static @org.jetbrains.annotations.Nullable method withoutInline(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object -} diff --git a/compiler/testData/codegen/bytecodeListing/tailcall/tailSuspendUnitFun.kt b/compiler/testData/codegen/bytecodeListing/tailcall/tailSuspendUnitFun.kt deleted file mode 100644 index 1b64812a82d..00000000000 --- a/compiler/testData/codegen/bytecodeListing/tailcall/tailSuspendUnitFun.kt +++ /dev/null @@ -1,64 +0,0 @@ -// COMMON_COROUTINES_TEST -// WITH_RUNTIME - -suspend fun empty() {} -suspend fun withoutReturn() { empty() } -suspend fun withReturn() { return empty() } -suspend fun notTailCall() { empty(); empty() } -suspend fun lambdaAsParameter(c: suspend ()->Unit) { c() } -suspend fun lambdaAsParameterNotTailCall(c: suspend ()->Unit) { c(); c() } -suspend fun lambdaAsParameterReturn(c: suspend ()->Unit) { return c() } -suspend fun returnsInt() = 42 -// This should not be tail-call, since the caller should push Unit.INSTANCE on stack -suspend fun callsIntNotTailCall() { returnsInt() } -suspend fun multipleExitPoints(b: Boolean) { if (b) empty() else withoutReturn() } -suspend fun multipleExitPointsNotTailCall(b: Boolean) { if (b) empty() else returnsInt() } - -fun ordinary() = 1 -inline fun ordinaryInline() { ordinary() } -suspend fun multipleExitPointsWithOrdinaryInline(b: Boolean) { if (b) empty() else ordinaryInline() } - -suspend fun multipleExitPointsWhen(i: Int) { - when(i) { - 1 -> empty() - 2 -> withReturn() - 3 -> withoutReturn() - else -> lambdaAsParameter {} - } -} - -suspend fun generic(): T = TODO() -suspend fun useGenericReturningUnit() { - generic() -} - -class Generic { - suspend fun foo(): T = TODO() -} -suspend fun useGenericClass(g: Generic) { - g.foo() -} - -suspend fun genericInferType(c: () -> T): T = TODO() -suspend fun useGenericIngerType() { - genericInferType {} -} - -suspend fun nullableUnit(): Unit? = null -suspend fun useNullableUnit() { - nullableUnit() -} - -suspend fun useRunRunRunRunRun() { - run { - run { - run { - run { - run { - empty() - } - } - } - } - } -} diff --git a/compiler/testData/codegen/bytecodeListing/tailcall/tailSuspendUnitFun.txt b/compiler/testData/codegen/bytecodeListing/tailcall/tailSuspendUnitFun.txt deleted file mode 100644 index 5ee56cf220f..00000000000 --- a/compiler/testData/codegen/bytecodeListing/tailcall/tailSuspendUnitFun.txt +++ /dev/null @@ -1,115 +0,0 @@ -@kotlin.Metadata -public final class Generic { - public method (): void - public final @org.jetbrains.annotations.Nullable method foo(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object -} - -@kotlin.Metadata -final class TailSuspendUnitFunKt$callsIntNotTailCall$1 { - synthetic field data: java.lang.Object - synthetic field exception: java.lang.Throwable - inner class TailSuspendUnitFunKt$callsIntNotTailCall$1 - method (p0: COROUTINES_PACKAGE.Continuation): void - public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object - synthetic final method getLabel(): int - synthetic final method setLabel(p0: int): void -} - -@kotlin.Metadata -final class TailSuspendUnitFunKt$lambdaAsParameterNotTailCall$1 { - field L$0: java.lang.Object - synthetic field data: java.lang.Object - synthetic field exception: java.lang.Throwable - inner class TailSuspendUnitFunKt$lambdaAsParameterNotTailCall$1 - method (p0: COROUTINES_PACKAGE.Continuation): void - public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object - synthetic final method getLabel(): int - synthetic final method setLabel(p0: int): void -} - -@kotlin.Metadata -final class TailSuspendUnitFunKt$multipleExitPointsNotTailCall$1 { - field Z$0: boolean - synthetic field data: java.lang.Object - synthetic field exception: java.lang.Throwable - inner class TailSuspendUnitFunKt$multipleExitPointsNotTailCall$1 - method (p0: COROUTINES_PACKAGE.Continuation): void - public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object - synthetic final method getLabel(): int - synthetic final method setLabel(p0: int): void -} - -@kotlin.Metadata -final class TailSuspendUnitFunKt$multipleExitPointsWhen$2 { - inner class TailSuspendUnitFunKt$multipleExitPointsWhen$2 - method (p0: COROUTINES_PACKAGE.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): COROUTINES_PACKAGE.Continuation - public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object - public final method invoke(p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -final class TailSuspendUnitFunKt$notTailCall$1 { - synthetic field data: java.lang.Object - synthetic field exception: java.lang.Throwable - inner class TailSuspendUnitFunKt$notTailCall$1 - method (p0: COROUTINES_PACKAGE.Continuation): void - public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object - synthetic final method getLabel(): int - synthetic final method setLabel(p0: int): void -} - -@kotlin.Metadata -final class TailSuspendUnitFunKt$useGenericIngerType$2 { - public final static field INSTANCE: TailSuspendUnitFunKt$useGenericIngerType$2 - inner class TailSuspendUnitFunKt$useGenericIngerType$2 - static method (): void - method (): void - public synthetic method invoke(): java.lang.Object - public final method invoke(): void -} - -@kotlin.Metadata -final class TailSuspendUnitFunKt$useNullableUnit$1 { - synthetic field data: java.lang.Object - synthetic field exception: java.lang.Throwable - inner class TailSuspendUnitFunKt$useNullableUnit$1 - method (p0: COROUTINES_PACKAGE.Continuation): void - public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object - synthetic final method getLabel(): int - synthetic final method setLabel(p0: int): void -} - -@kotlin.Metadata -public final class TailSuspendUnitFunKt { - inner class TailSuspendUnitFunKt$callsIntNotTailCall$1 - inner class TailSuspendUnitFunKt$lambdaAsParameterNotTailCall$1 - inner class TailSuspendUnitFunKt$multipleExitPointsNotTailCall$1 - inner class TailSuspendUnitFunKt$multipleExitPointsWhen$2 - inner class TailSuspendUnitFunKt$notTailCall$1 - inner class TailSuspendUnitFunKt$useGenericIngerType$2 - inner class TailSuspendUnitFunKt$useNullableUnit$1 - public final static @org.jetbrains.annotations.Nullable method callsIntNotTailCall(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method empty(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method generic(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method genericInferType(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function0, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method lambdaAsParameter(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method lambdaAsParameterNotTailCall(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method lambdaAsParameterReturn(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method multipleExitPoints(p0: boolean, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method multipleExitPointsNotTailCall(p0: boolean, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method multipleExitPointsWhen(p0: int, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method multipleExitPointsWithOrdinaryInline(p0: boolean, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method notTailCall(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method nullableUnit(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static method ordinary(): int - public final static method ordinaryInline(): void - public final static @org.jetbrains.annotations.Nullable method returnsInt(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method useGenericClass(@org.jetbrains.annotations.NotNull p0: Generic, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method useGenericIngerType(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method useGenericReturningUnit(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method useNullableUnit(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method useRunRunRunRunRun(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method withReturn(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method withoutReturn(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object -} diff --git a/compiler/testData/codegen/bytecodeListing/tailcall/tailSuspendUnitFun_1_3.txt b/compiler/testData/codegen/bytecodeListing/tailcall/tailSuspendUnitFun_1_3.txt deleted file mode 100644 index d06941fcfdb..00000000000 --- a/compiler/testData/codegen/bytecodeListing/tailcall/tailSuspendUnitFun_1_3.txt +++ /dev/null @@ -1,112 +0,0 @@ -@kotlin.Metadata -public final class Generic { - public method (): void - public final @org.jetbrains.annotations.Nullable method foo(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.Metadata -@kotlin.coroutines.jvm.internal.DebugMetadata -final class TailSuspendUnitFunKt$callsIntNotTailCall$1 { - field label: int - synthetic field result: java.lang.Object - inner class TailSuspendUnitFunKt$callsIntNotTailCall$1 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -@kotlin.coroutines.jvm.internal.DebugMetadata -final class TailSuspendUnitFunKt$lambdaAsParameterNotTailCall$1 { - field L$0: java.lang.Object - field label: int - synthetic field result: java.lang.Object - inner class TailSuspendUnitFunKt$lambdaAsParameterNotTailCall$1 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -@kotlin.coroutines.jvm.internal.DebugMetadata -final class TailSuspendUnitFunKt$multipleExitPointsNotTailCall$1 { - field Z$0: boolean - field label: int - synthetic field result: java.lang.Object - inner class TailSuspendUnitFunKt$multipleExitPointsNotTailCall$1 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TailSuspendUnitFunKt$multipleExitPointsWhen$2 { - field label: int - inner class TailSuspendUnitFunKt$multipleExitPointsWhen$2 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -@kotlin.coroutines.jvm.internal.DebugMetadata -final class TailSuspendUnitFunKt$notTailCall$1 { - field label: int - synthetic field result: java.lang.Object - inner class TailSuspendUnitFunKt$notTailCall$1 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -final class TailSuspendUnitFunKt$useGenericIngerType$2 { - public final static field INSTANCE: TailSuspendUnitFunKt$useGenericIngerType$2 - inner class TailSuspendUnitFunKt$useGenericIngerType$2 - static method (): void - method (): void - public synthetic method invoke(): java.lang.Object - public final method invoke(): void -} - -@kotlin.Metadata -@kotlin.coroutines.jvm.internal.DebugMetadata -final class TailSuspendUnitFunKt$useNullableUnit$1 { - field label: int - synthetic field result: java.lang.Object - inner class TailSuspendUnitFunKt$useNullableUnit$1 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -public final class TailSuspendUnitFunKt { - inner class TailSuspendUnitFunKt$callsIntNotTailCall$1 - inner class TailSuspendUnitFunKt$lambdaAsParameterNotTailCall$1 - inner class TailSuspendUnitFunKt$multipleExitPointsNotTailCall$1 - inner class TailSuspendUnitFunKt$multipleExitPointsWhen$2 - inner class TailSuspendUnitFunKt$notTailCall$1 - inner class TailSuspendUnitFunKt$useGenericIngerType$2 - inner class TailSuspendUnitFunKt$useNullableUnit$1 - public final static @org.jetbrains.annotations.Nullable method callsIntNotTailCall(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method empty(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method generic(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method genericInferType(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function0, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method lambdaAsParameter(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method lambdaAsParameterNotTailCall(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method lambdaAsParameterReturn(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method multipleExitPoints(p0: boolean, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method multipleExitPointsNotTailCall(p0: boolean, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method multipleExitPointsWhen(p0: int, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method multipleExitPointsWithOrdinaryInline(p0: boolean, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method notTailCall(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method nullableUnit(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public final static method ordinary(): int - public final static method ordinaryInline(): void - public final static @org.jetbrains.annotations.Nullable method returnsInt(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method useGenericClass(@org.jetbrains.annotations.NotNull p0: Generic, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method useGenericIngerType(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method useGenericReturningUnit(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method useNullableUnit(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method useRunRunRunRunRun(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method withReturn(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method withoutReturn(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object -} diff --git a/compiler/testData/codegen/bytecodeListing/tailcall/tryCatchTailCall.kt b/compiler/testData/codegen/bytecodeListing/tailcall/tryCatchTailCall.kt deleted file mode 100644 index efd115b4a48..00000000000 --- a/compiler/testData/codegen/bytecodeListing/tailcall/tryCatchTailCall.kt +++ /dev/null @@ -1,13 +0,0 @@ -// COMMON_COROUTINES_TEST -// WITH_RUNTIME - -suspend fun catchException(): String { - try { - return suspendWithException() - } - catch(e: Exception) { - return e.message!! - } -} - -suspend fun suspendWithException(): String = TODO() diff --git a/compiler/testData/codegen/bytecodeListing/tailcall/tryCatchTailCall.txt b/compiler/testData/codegen/bytecodeListing/tailcall/tryCatchTailCall.txt deleted file mode 100644 index 624495c572d..00000000000 --- a/compiler/testData/codegen/bytecodeListing/tailcall/tryCatchTailCall.txt +++ /dev/null @@ -1,17 +0,0 @@ -@kotlin.Metadata -final class TryCatchTailCallKt$catchException$1 { - synthetic field data: java.lang.Object - synthetic field exception: java.lang.Throwable - inner class TryCatchTailCallKt$catchException$1 - method (p0: COROUTINES_PACKAGE.Continuation): void - public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object - synthetic final method getLabel(): int - synthetic final method setLabel(p0: int): void -} - -@kotlin.Metadata -public final class TryCatchTailCallKt { - inner class TryCatchTailCallKt$catchException$1 - public final static @org.jetbrains.annotations.Nullable method catchException(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method suspendWithException(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object -} diff --git a/compiler/testData/codegen/bytecodeListing/tailcall/tryCatchTailCall_1_3.txt b/compiler/testData/codegen/bytecodeListing/tailcall/tryCatchTailCall_1_3.txt deleted file mode 100644 index ebbee7374b9..00000000000 --- a/compiler/testData/codegen/bytecodeListing/tailcall/tryCatchTailCall_1_3.txt +++ /dev/null @@ -1,16 +0,0 @@ -@kotlin.Metadata -@kotlin.coroutines.jvm.internal.DebugMetadata -final class TryCatchTailCallKt$catchException$1 { - field label: int - synthetic field result: java.lang.Object - inner class TryCatchTailCallKt$catchException$1 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -public final class TryCatchTailCallKt { - inner class TryCatchTailCallKt$catchException$1 - public final static @org.jetbrains.annotations.Nullable method catchException(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method suspendWithException(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object -} diff --git a/compiler/testData/codegen/bytecodeListing/tailcall/unreachable.kt b/compiler/testData/codegen/bytecodeListing/tailcall/unreachable.kt deleted file mode 100644 index ead19c61e64..00000000000 --- a/compiler/testData/codegen/bytecodeListing/tailcall/unreachable.kt +++ /dev/null @@ -1,121 +0,0 @@ -// COMMON_COROUTINES_TEST -// WITH_RUNTIME - -suspend fun empty() {} -suspend fun withoutReturn() { - empty() -} - -suspend fun twoReturns() { - return empty() - return empty() -} - -suspend fun notTailCall() { - empty() - return empty() - empty() -} - -suspend fun lambdaAsParameter(c: suspend () -> Unit) { - c() -} - -suspend fun lambdaAsParameterNotTailCall(c: suspend () -> Unit) { - c() - return c() - c() -} - -suspend fun lambdaAsParameterReturn(c: suspend () -> Unit) { - return c() - c() -} - -suspend fun returnsInt() = 42 -suspend fun callsIntNotTailCall() { - returnsInt() - return - empty() -} - -suspend fun multipleExitPoints(b: Boolean) { - if (b) empty() else withoutReturn() - return - empty() -} - -suspend fun multipleExitPointsNotTailCall(b: Boolean) { - if (b) empty() else returnsInt() - return - empty() -} - -fun ordinary() = 1 -inline fun ordinaryInline() { - ordinary() -} - -suspend fun multipleExitPointsWithOrdinaryInline(b: Boolean) { - if (b) empty() else ordinaryInline() - return - empty() -} - -suspend fun multipleExitPointsWhen(i: Int) { - when (i) { - 1 -> empty() - 2 -> twoReturns() - 3 -> withoutReturn() - else -> lambdaAsParameter {} - } - return - empty() -} - -suspend fun generic(): T = TODO() -suspend fun useGenericReturningUnit() { - generic() - return - empty() -} - -class Generic { - suspend fun foo(): T = TODO() -} - -suspend fun useGenericClass(g: Generic) { - g.foo() - return - empty() -} - -suspend fun genericInferType(c: () -> T): T = TODO() -suspend fun useGenericInferType() { - genericInferType {} - return - empty() -} - -suspend fun nullableUnit(): Unit? = null -suspend fun useNullableUnit() { - nullableUnit() - return - empty() -} - -suspend fun useRunRunRunRunRun() { - run { - run { - run { - run { - run { - empty() - } - } - } - } - } - return - empty() -} diff --git a/compiler/testData/codegen/bytecodeListing/tailcall/unreachable.txt b/compiler/testData/codegen/bytecodeListing/tailcall/unreachable.txt deleted file mode 100644 index f97eafa87bf..00000000000 --- a/compiler/testData/codegen/bytecodeListing/tailcall/unreachable.txt +++ /dev/null @@ -1,115 +0,0 @@ -@kotlin.Metadata -public final class Generic { - public method (): void - public final @org.jetbrains.annotations.Nullable method foo(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object -} - -@kotlin.Metadata -final class UnreachableKt$callsIntNotTailCall$1 { - synthetic field data: java.lang.Object - synthetic field exception: java.lang.Throwable - inner class UnreachableKt$callsIntNotTailCall$1 - method (p0: COROUTINES_PACKAGE.Continuation): void - public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object - synthetic final method getLabel(): int - synthetic final method setLabel(p0: int): void -} - -@kotlin.Metadata -final class UnreachableKt$lambdaAsParameterNotTailCall$1 { - field L$0: java.lang.Object - synthetic field data: java.lang.Object - synthetic field exception: java.lang.Throwable - inner class UnreachableKt$lambdaAsParameterNotTailCall$1 - method (p0: COROUTINES_PACKAGE.Continuation): void - public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object - synthetic final method getLabel(): int - synthetic final method setLabel(p0: int): void -} - -@kotlin.Metadata -final class UnreachableKt$multipleExitPointsNotTailCall$1 { - field Z$0: boolean - synthetic field data: java.lang.Object - synthetic field exception: java.lang.Throwable - inner class UnreachableKt$multipleExitPointsNotTailCall$1 - method (p0: COROUTINES_PACKAGE.Continuation): void - public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object - synthetic final method getLabel(): int - synthetic final method setLabel(p0: int): void -} - -@kotlin.Metadata -final class UnreachableKt$multipleExitPointsWhen$2 { - inner class UnreachableKt$multipleExitPointsWhen$2 - method (p0: COROUTINES_PACKAGE.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): COROUTINES_PACKAGE.Continuation - public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object - public final method invoke(p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -final class UnreachableKt$notTailCall$1 { - synthetic field data: java.lang.Object - synthetic field exception: java.lang.Throwable - inner class UnreachableKt$notTailCall$1 - method (p0: COROUTINES_PACKAGE.Continuation): void - public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object - synthetic final method getLabel(): int - synthetic final method setLabel(p0: int): void -} - -@kotlin.Metadata -final class UnreachableKt$useGenericInferType$2 { - public final static field INSTANCE: UnreachableKt$useGenericInferType$2 - inner class UnreachableKt$useGenericInferType$2 - static method (): void - method (): void - public synthetic method invoke(): java.lang.Object - public final method invoke(): void -} - -@kotlin.Metadata -final class UnreachableKt$useNullableUnit$1 { - synthetic field data: java.lang.Object - synthetic field exception: java.lang.Throwable - inner class UnreachableKt$useNullableUnit$1 - method (p0: COROUTINES_PACKAGE.Continuation): void - public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object - synthetic final method getLabel(): int - synthetic final method setLabel(p0: int): void -} - -@kotlin.Metadata -public final class UnreachableKt { - inner class UnreachableKt$callsIntNotTailCall$1 - inner class UnreachableKt$lambdaAsParameterNotTailCall$1 - inner class UnreachableKt$multipleExitPointsNotTailCall$1 - inner class UnreachableKt$multipleExitPointsWhen$2 - inner class UnreachableKt$notTailCall$1 - inner class UnreachableKt$useGenericInferType$2 - inner class UnreachableKt$useNullableUnit$1 - public final static @org.jetbrains.annotations.Nullable method callsIntNotTailCall(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method empty(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method generic(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method genericInferType(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function0, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method lambdaAsParameter(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method lambdaAsParameterNotTailCall(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method lambdaAsParameterReturn(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method multipleExitPoints(p0: boolean, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method multipleExitPointsNotTailCall(p0: boolean, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method multipleExitPointsWhen(p0: int, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method multipleExitPointsWithOrdinaryInline(p0: boolean, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method notTailCall(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method nullableUnit(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static method ordinary(): int - public final static method ordinaryInline(): void - public final static @org.jetbrains.annotations.Nullable method returnsInt(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method twoReturns(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method useGenericClass(@org.jetbrains.annotations.NotNull p0: Generic, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method useGenericInferType(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method useGenericReturningUnit(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method useNullableUnit(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method useRunRunRunRunRun(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method withoutReturn(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object -} diff --git a/compiler/testData/codegen/bytecodeListing/tailcall/unreachable_1_3.txt b/compiler/testData/codegen/bytecodeListing/tailcall/unreachable_1_3.txt deleted file mode 100644 index 1f793c60cd1..00000000000 --- a/compiler/testData/codegen/bytecodeListing/tailcall/unreachable_1_3.txt +++ /dev/null @@ -1,112 +0,0 @@ -@kotlin.Metadata -public final class Generic { - public method (): void - public final @org.jetbrains.annotations.Nullable method foo(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.Metadata -@kotlin.coroutines.jvm.internal.DebugMetadata -final class UnreachableKt$callsIntNotTailCall$1 { - field label: int - synthetic field result: java.lang.Object - inner class UnreachableKt$callsIntNotTailCall$1 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -@kotlin.coroutines.jvm.internal.DebugMetadata -final class UnreachableKt$lambdaAsParameterNotTailCall$1 { - field L$0: java.lang.Object - field label: int - synthetic field result: java.lang.Object - inner class UnreachableKt$lambdaAsParameterNotTailCall$1 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -@kotlin.coroutines.jvm.internal.DebugMetadata -final class UnreachableKt$multipleExitPointsNotTailCall$1 { - field Z$0: boolean - field label: int - synthetic field result: java.lang.Object - inner class UnreachableKt$multipleExitPointsNotTailCall$1 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class UnreachableKt$multipleExitPointsWhen$2 { - field label: int - inner class UnreachableKt$multipleExitPointsWhen$2 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -@kotlin.coroutines.jvm.internal.DebugMetadata -final class UnreachableKt$notTailCall$1 { - field label: int - synthetic field result: java.lang.Object - inner class UnreachableKt$notTailCall$1 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -final class UnreachableKt$useGenericInferType$2 { - public final static field INSTANCE: UnreachableKt$useGenericInferType$2 - inner class UnreachableKt$useGenericInferType$2 - static method (): void - method (): void - public synthetic method invoke(): java.lang.Object - public final method invoke(): void -} - -@kotlin.Metadata -@kotlin.coroutines.jvm.internal.DebugMetadata -final class UnreachableKt$useNullableUnit$1 { - field label: int - synthetic field result: java.lang.Object - inner class UnreachableKt$useNullableUnit$1 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -public final class UnreachableKt { - inner class UnreachableKt$callsIntNotTailCall$1 - inner class UnreachableKt$lambdaAsParameterNotTailCall$1 - inner class UnreachableKt$multipleExitPointsNotTailCall$1 - inner class UnreachableKt$multipleExitPointsWhen$2 - inner class UnreachableKt$notTailCall$1 - inner class UnreachableKt$useGenericInferType$2 - inner class UnreachableKt$useNullableUnit$1 - public final static @org.jetbrains.annotations.Nullable method callsIntNotTailCall(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method empty(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method generic(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method genericInferType(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function0, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method lambdaAsParameter(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method lambdaAsParameterNotTailCall(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method lambdaAsParameterReturn(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method multipleExitPoints(p0: boolean, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method multipleExitPointsNotTailCall(p0: boolean, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method multipleExitPointsWhen(p0: int, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method multipleExitPointsWithOrdinaryInline(p0: boolean, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method notTailCall(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method nullableUnit(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public final static method ordinary(): int - public final static method ordinaryInline(): void - public final static @org.jetbrains.annotations.Nullable method returnsInt(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method twoReturns(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method useGenericClass(@org.jetbrains.annotations.NotNull p0: Generic, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method useGenericInferType(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method useGenericReturningUnit(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method useNullableUnit(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method useRunRunRunRunRun(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method withoutReturn(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object -} diff --git a/compiler/testData/codegen/bytecodeListing/tailcall/whenUnit.kt b/compiler/testData/codegen/bytecodeListing/tailcall/whenUnit.kt deleted file mode 100644 index 4005be1787e..00000000000 --- a/compiler/testData/codegen/bytecodeListing/tailcall/whenUnit.kt +++ /dev/null @@ -1,12 +0,0 @@ -sealed class X { - class A : X() - class B : X() -} - -suspend fun process(a: X.A) {} -suspend fun process(b: X.B) {} - -suspend fun process(x: X) = when (x) { - is X.A -> process(x) - is X.B -> process(x) -} diff --git a/compiler/testData/codegen/bytecodeListing/tailcall/whenUnit.txt b/compiler/testData/codegen/bytecodeListing/tailcall/whenUnit.txt deleted file mode 100644 index cf7d3e73c39..00000000000 --- a/compiler/testData/codegen/bytecodeListing/tailcall/whenUnit.txt +++ /dev/null @@ -1,26 +0,0 @@ -@kotlin.Metadata -public final class WhenUnitKt { - public final static @org.jetbrains.annotations.Nullable method process(@org.jetbrains.annotations.NotNull p0: X$A, @org.jetbrains.annotations.Nullable p1: java.lang.Object): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method process(@org.jetbrains.annotations.NotNull p0: X$B, @org.jetbrains.annotations.Nullable p1: java.lang.Object): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method process(@org.jetbrains.annotations.NotNull p0: X, @org.jetbrains.annotations.Nullable p1: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -public final class X$A { - inner class X$A - public method (): void -} - -@kotlin.Metadata -public final class X$B { - inner class X$B - public method (): void -} - -@kotlin.Metadata -public abstract class X { - inner class X$A - inner class X$B - private method (): void - public synthetic method (p0: kotlin.jvm.internal.DefaultConstructorMarker): void -} diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBlackBoxCodegenTest.java b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBlackBoxCodegenTest.java index 3d24ef46672..dde3a4c2b55 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBlackBoxCodegenTest.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBlackBoxCodegenTest.java @@ -1,5 +1,5 @@ /* - * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license * that can be found in the license/LICENSE.txt file. */ diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBytecodeListingTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBytecodeListingTest.kt index b4ccfb74cc7..922a24dd6bc 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBytecodeListingTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBytecodeListingTest.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license * that can be found in the license/LICENSE.txt file. */ diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/CodegenTestCase.java b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/CodegenTestCase.java index ce77594f4de..1d731fa7d1e 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/CodegenTestCase.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/CodegenTestCase.java @@ -1,5 +1,5 @@ /* - * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license * that can be found in the license/LICENSE.txt file. */ diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/coroutineTestUtil.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/coroutineTestUtil.kt index b6e79950dba..a545a8179b4 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/coroutineTestUtil.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/coroutineTestUtil.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license * that can be found in the license/LICENSE.txt file. */ @@ -7,7 +7,7 @@ package org.jetbrains.kotlin import org.jetbrains.kotlin.resolve.DescriptorUtils -fun createTextForHelpers(isReleaseCoroutines: Boolean, checkStateMachine: Boolean): String { +fun createTextForHelpers(isReleaseCoroutines: Boolean, checkStateMachine: Boolean, checkTailCallOptimization: Boolean): String { val coroutinesPackage = if (isReleaseCoroutines) DescriptorUtils.COROUTINES_PACKAGE_FQ_NAME_RELEASE.asString() @@ -123,9 +123,45 @@ fun createTextForHelpers(isReleaseCoroutines: Boolean, checkStateMachine: Boolea } """.trimIndent() + // TODO: Find a way to check for tail-call optimization on JS and Native + val checkTailCallOptimizationString = + """ + class TailCallOptimizationCheckerClass { + private val stackTrace = arrayListOf() + + suspend fun saveStackTrace() = suspendCoroutineUninterceptedOrReturn { + saveStackTrace(it) + } + + fun saveStackTrace(c: Continuation<*>) { + if (c !is CoroutineStackFrame) error("Continuation " + c + " is not subtype of CoroutineStackFrame") + stackTrace.clear() + var csf: CoroutineStackFrame? = c + while (csf != null) { + stackTrace.add(csf.getStackTraceElement()) + csf = csf.callerFrame + } + } + + fun checkNoStateMachineIn(method: String) { + stackTrace.find { it?.methodName == method }?.let { error("tail-call optimization miss: method at " + it + " has state-machine " + + stackTrace.joinToString(separator = "\n")) } + } + + fun checkStateMachineIn(method: String) { + stackTrace.find { it?.methodName == method } ?: error("tail-call optimization hit: method " + method + " has not state-machine " + + stackTrace.joinToString(separator = "\n")) + } + } + + val TailCallOptimizationChecker = TailCallOptimizationCheckerClass() + """.trimIndent() + return """ |package helpers |import $coroutinesPackage.* + |import $coroutinesPackage.intrinsics.* + |${if (checkTailCallOptimization) "import $coroutinesPackage.jvm.internal.*" else ""} | |fun handleResultContinuation(x: (T) -> Unit): Continuation = object: Continuation { | override val context = EmptyCoroutineContext @@ -149,5 +185,6 @@ fun createTextForHelpers(isReleaseCoroutines: Boolean, checkStateMachine: Boolea |} | |${if (checkStateMachine) checkStateMachineString else ""} + |${if (checkTailCallOptimization) checkTailCallOptimizationString else ""} """.trimMargin() } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java b/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java index c28b0166342..3cd789e1156 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java @@ -1,5 +1,5 @@ /* - * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license * that can be found in the license/LICENSE.txt file. */ @@ -807,12 +807,15 @@ public class KotlinTestUtils { !isDirectiveDefined(expectedText, "!LANGUAGE: -ReleaseCoroutines"); boolean checkStateMachine = isDirectiveDefined(expectedText, "CHECK_STATE_MACHINE"); + boolean checkTailCallOptimization = isDirectiveDefined(expectedText, "CHECK_TAIL_CALL_OPTIMIZATION"); - testFiles.add(factory.createFile(supportModule, - "CoroutineUtil.kt", - CoroutineTestUtilKt.createTextForHelpers(isReleaseCoroutines, checkStateMachine), - directives - )); + testFiles.add( + factory.createFile( + supportModule, + "CoroutineUtil.kt", + CoroutineTestUtilKt.createTextForHelpers(isReleaseCoroutines, checkStateMachine, checkTailCallOptimization), + directives + )); } return testFiles; diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java.as32 b/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java.as32 index c53a2fc69b1..9e77f27a75f 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java.as32 +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java.as32 @@ -792,12 +792,15 @@ public class KotlinTestUtils { !isDirectiveDefined(expectedText, "!LANGUAGE: -ReleaseCoroutines"); boolean checkStateMachine = isDirectiveDefined(expectedText, "CHECK_STATE_MACHINE"); + boolean checkTailCallOptimization = isDirectiveDefined(expectedText, "CHECK_TAIL_CALL_OPTIMIZATION"); - testFiles.add(factory.createFile(supportModule, - "CoroutineUtil.kt", - CoroutineTestUtilKt.createTextForHelpers(isReleaseCoroutines, checkStateMachine), - directives - )); + testFiles.add( + factory.createFile( + supportModule, + "CoroutineUtil.kt", + CoroutineTestUtilKt.createTextForHelpers(isReleaseCoroutines, checkStateMachine, checkTailCallOptimization), + directives + )); } return testFiles; diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java index 994624f2ac4..c02cb653b99 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java @@ -5774,6 +5774,16 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/emptyClosure.kt", "kotlin.coroutines"); } + @TestMetadata("epam.kt") + public void testEpam_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/epam.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("epam.kt") + public void testEpam_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/epam.kt", "kotlin.coroutines"); + } + @TestMetadata("falseUnitCoercion.kt") public void testFalseUnitCoercion_1_2() throws Exception { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/falseUnitCoercion.kt", "kotlin.coroutines.experimental"); @@ -8063,13 +8073,8 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } @TestMetadata("also.kt") - public void testAlso_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/also.kt", "kotlin.coroutines.experimental"); - } - - @TestMetadata("also.kt") - public void testAlso_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/also.kt", "kotlin.coroutines"); + public void testAlso() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/also.kt"); } @TestMetadata("crossinline.kt") @@ -8082,24 +8087,9 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/crossinline.kt", "kotlin.coroutines"); } - @TestMetadata("epam.kt") - public void testEpam_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/epam.kt", "kotlin.coroutines.experimental"); - } - - @TestMetadata("epam.kt") - public void testEpam_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/epam.kt", "kotlin.coroutines"); - } - @TestMetadata("inlineWithStateMachine.kt") - public void testInlineWithStateMachine_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithStateMachine.kt", "kotlin.coroutines.experimental"); - } - - @TestMetadata("inlineWithStateMachine.kt") - public void testInlineWithStateMachine_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithStateMachine.kt", "kotlin.coroutines"); + public void testInlineWithStateMachine() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithStateMachine.kt"); } @TestMetadata("inlineWithoutStateMachine.kt") @@ -8123,13 +8113,28 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } @TestMetadata("simple.kt") - public void testSimple_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/simple.kt", "kotlin.coroutines.experimental"); + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/simple.kt"); } - @TestMetadata("simple.kt") - public void testSimple_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/simple.kt", "kotlin.coroutines"); + @TestMetadata("tailCallIfReturnUnit.kt") + public void testTailCallIfReturnUnit() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/tailCallIfReturnUnit.kt"); + } + + @TestMetadata("tailCallIntrinsics.kt") + public void testTailCallIntrinsics() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/tailCallIntrinsics.kt"); + } + + @TestMetadata("tailSuspendUnitFun.kt") + public void testTailSuspendUnitFun() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/tailSuspendUnitFun.kt"); + } + + @TestMetadata("tryCatchTailCall.kt") + public void testTryCatchTailCall() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/tryCatchTailCall.kt"); } @TestMetadata("tryCatch.kt") @@ -8143,23 +8148,13 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } @TestMetadata("unreachable.kt") - public void testUnreachable_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unreachable.kt", "kotlin.coroutines.experimental"); - } - - @TestMetadata("unreachable.kt") - public void testUnreachable_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unreachable.kt", "kotlin.coroutines"); + public void testUnreachable() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unreachable.kt"); } @TestMetadata("whenUnit.kt") - public void testWhenUnit_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/whenUnit.kt", "kotlin.coroutines.experimental"); - } - - @TestMetadata("whenUnit.kt") - public void testWhenUnit_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/whenUnit.kt", "kotlin.coroutines"); + public void testWhenUnit() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/whenUnit.kt"); } } diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/BytecodeListingTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/BytecodeListingTestGenerated.java index 28c1cea829c..a6d8b41a05b 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/BytecodeListingTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/BytecodeListingTestGenerated.java @@ -481,76 +481,4 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { } } } - - @TestMetadata("compiler/testData/codegen/bytecodeListing/tailcall") - @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Tailcall extends AbstractBytecodeListingTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); - } - - private void runTestWithPackageReplacement(String testDataFilePath, String packageName) throws Exception { - KotlinTestUtils.runTest(filePath -> doTestWithCoroutinesPackageReplacement(filePath, packageName), TargetBackend.ANY, testDataFilePath); - } - - public void testAllFilesPresentInTailcall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/tailcall"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); - } - - @TestMetadata("tailCallIfReturnUnit.kt") - public void testTailCallIfReturnUnit_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/bytecodeListing/tailcall/tailCallIfReturnUnit.kt", "kotlin.coroutines.experimental"); - } - - @TestMetadata("tailCallIfReturnUnit.kt") - public void testTailCallIfReturnUnit_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/bytecodeListing/tailcall/tailCallIfReturnUnit.kt", "kotlin.coroutines"); - } - - @TestMetadata("tailCallIntrinsics.kt") - public void testTailCallIntrinsics_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/bytecodeListing/tailcall/tailCallIntrinsics.kt", "kotlin.coroutines.experimental"); - } - - @TestMetadata("tailCallIntrinsics.kt") - public void testTailCallIntrinsics_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/bytecodeListing/tailcall/tailCallIntrinsics.kt", "kotlin.coroutines"); - } - - @TestMetadata("tailSuspendUnitFun.kt") - public void testTailSuspendUnitFun_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/bytecodeListing/tailcall/tailSuspendUnitFun.kt", "kotlin.coroutines.experimental"); - } - - @TestMetadata("tailSuspendUnitFun.kt") - public void testTailSuspendUnitFun_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/bytecodeListing/tailcall/tailSuspendUnitFun.kt", "kotlin.coroutines"); - } - - @TestMetadata("tryCatchTailCall.kt") - public void testTryCatchTailCall_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/bytecodeListing/tailcall/tryCatchTailCall.kt", "kotlin.coroutines.experimental"); - } - - @TestMetadata("tryCatchTailCall.kt") - public void testTryCatchTailCall_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/bytecodeListing/tailcall/tryCatchTailCall.kt", "kotlin.coroutines"); - } - - @TestMetadata("unreachable.kt") - public void testUnreachable_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/bytecodeListing/tailcall/unreachable.kt", "kotlin.coroutines.experimental"); - } - - @TestMetadata("unreachable.kt") - public void testUnreachable_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/bytecodeListing/tailcall/unreachable.kt", "kotlin.coroutines"); - } - - @TestMetadata("whenUnit.kt") - public void testWhenUnit() throws Exception { - runTest("compiler/testData/codegen/bytecodeListing/tailcall/whenUnit.kt"); - } - } } diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java index 0de4d5016a2..fe77d9feb44 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java @@ -5774,6 +5774,16 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/emptyClosure.kt", "kotlin.coroutines"); } + @TestMetadata("epam.kt") + public void testEpam_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/epam.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("epam.kt") + public void testEpam_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/epam.kt", "kotlin.coroutines"); + } + @TestMetadata("falseUnitCoercion.kt") public void testFalseUnitCoercion_1_2() throws Exception { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/falseUnitCoercion.kt", "kotlin.coroutines.experimental"); @@ -8063,13 +8073,8 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } @TestMetadata("also.kt") - public void testAlso_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/also.kt", "kotlin.coroutines.experimental"); - } - - @TestMetadata("also.kt") - public void testAlso_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/also.kt", "kotlin.coroutines"); + public void testAlso() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/also.kt"); } @TestMetadata("crossinline.kt") @@ -8082,24 +8087,9 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/crossinline.kt", "kotlin.coroutines"); } - @TestMetadata("epam.kt") - public void testEpam_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/epam.kt", "kotlin.coroutines.experimental"); - } - - @TestMetadata("epam.kt") - public void testEpam_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/epam.kt", "kotlin.coroutines"); - } - @TestMetadata("inlineWithStateMachine.kt") - public void testInlineWithStateMachine_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithStateMachine.kt", "kotlin.coroutines.experimental"); - } - - @TestMetadata("inlineWithStateMachine.kt") - public void testInlineWithStateMachine_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithStateMachine.kt", "kotlin.coroutines"); + public void testInlineWithStateMachine() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithStateMachine.kt"); } @TestMetadata("inlineWithoutStateMachine.kt") @@ -8123,13 +8113,28 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } @TestMetadata("simple.kt") - public void testSimple_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/simple.kt", "kotlin.coroutines.experimental"); + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/simple.kt"); } - @TestMetadata("simple.kt") - public void testSimple_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/simple.kt", "kotlin.coroutines"); + @TestMetadata("tailCallIfReturnUnit.kt") + public void testTailCallIfReturnUnit() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/tailCallIfReturnUnit.kt"); + } + + @TestMetadata("tailCallIntrinsics.kt") + public void testTailCallIntrinsics() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/tailCallIntrinsics.kt"); + } + + @TestMetadata("tailSuspendUnitFun.kt") + public void testTailSuspendUnitFun() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/tailSuspendUnitFun.kt"); + } + + @TestMetadata("tryCatchTailCall.kt") + public void testTryCatchTailCall() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/tryCatchTailCall.kt"); } @TestMetadata("tryCatch.kt") @@ -8143,23 +8148,13 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } @TestMetadata("unreachable.kt") - public void testUnreachable_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unreachable.kt", "kotlin.coroutines.experimental"); - } - - @TestMetadata("unreachable.kt") - public void testUnreachable_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unreachable.kt", "kotlin.coroutines"); + public void testUnreachable() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unreachable.kt"); } @TestMetadata("whenUnit.kt") - public void testWhenUnit_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/whenUnit.kt", "kotlin.coroutines.experimental"); - } - - @TestMetadata("whenUnit.kt") - public void testWhenUnit_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/whenUnit.kt", "kotlin.coroutines"); + public void testWhenUnit() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/whenUnit.kt"); } } diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java index 1b74d60caa5..f8d4890c05e 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java @@ -5774,6 +5774,16 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/emptyClosure.kt", "kotlin.coroutines"); } + @TestMetadata("epam.kt") + public void testEpam_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/epam.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("epam.kt") + public void testEpam_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/epam.kt", "kotlin.coroutines"); + } + @TestMetadata("falseUnitCoercion.kt") public void testFalseUnitCoercion_1_2() throws Exception { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/falseUnitCoercion.kt", "kotlin.coroutines.experimental"); @@ -8063,13 +8073,8 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } @TestMetadata("also.kt") - public void testAlso_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/also.kt", "kotlin.coroutines.experimental"); - } - - @TestMetadata("also.kt") - public void testAlso_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/also.kt", "kotlin.coroutines"); + public void testAlso() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/also.kt"); } @TestMetadata("crossinline.kt") @@ -8082,24 +8087,9 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/crossinline.kt", "kotlin.coroutines"); } - @TestMetadata("epam.kt") - public void testEpam_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/epam.kt", "kotlin.coroutines.experimental"); - } - - @TestMetadata("epam.kt") - public void testEpam_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/epam.kt", "kotlin.coroutines"); - } - @TestMetadata("inlineWithStateMachine.kt") - public void testInlineWithStateMachine_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithStateMachine.kt", "kotlin.coroutines.experimental"); - } - - @TestMetadata("inlineWithStateMachine.kt") - public void testInlineWithStateMachine_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithStateMachine.kt", "kotlin.coroutines"); + public void testInlineWithStateMachine() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithStateMachine.kt"); } @TestMetadata("inlineWithoutStateMachine.kt") @@ -8123,13 +8113,28 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } @TestMetadata("simple.kt") - public void testSimple_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/simple.kt", "kotlin.coroutines.experimental"); + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/simple.kt"); } - @TestMetadata("simple.kt") - public void testSimple_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/simple.kt", "kotlin.coroutines"); + @TestMetadata("tailCallIfReturnUnit.kt") + public void testTailCallIfReturnUnit() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/tailCallIfReturnUnit.kt"); + } + + @TestMetadata("tailCallIntrinsics.kt") + public void testTailCallIntrinsics() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/tailCallIntrinsics.kt"); + } + + @TestMetadata("tailSuspendUnitFun.kt") + public void testTailSuspendUnitFun() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/tailSuspendUnitFun.kt"); + } + + @TestMetadata("tryCatchTailCall.kt") + public void testTryCatchTailCall() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/tryCatchTailCall.kt"); } @TestMetadata("tryCatch.kt") @@ -8143,23 +8148,13 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } @TestMetadata("unreachable.kt") - public void testUnreachable_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unreachable.kt", "kotlin.coroutines.experimental"); - } - - @TestMetadata("unreachable.kt") - public void testUnreachable_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unreachable.kt", "kotlin.coroutines"); + public void testUnreachable() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unreachable.kt"); } @TestMetadata("whenUnit.kt") - public void testWhenUnit_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/whenUnit.kt", "kotlin.coroutines.experimental"); - } - - @TestMetadata("whenUnit.kt") - public void testWhenUnit_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/whenUnit.kt", "kotlin.coroutines"); + public void testWhenUnit() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/whenUnit.kt"); } } 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 a6e71cd1c15..8b010279af2 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 @@ -4804,6 +4804,11 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/emptyClosure.kt", "kotlin.coroutines"); } + @TestMetadata("epam.kt") + public void testEpam_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/epam.kt", "kotlin.coroutines"); + } + @TestMetadata("falseUnitCoercion.kt") public void testFalseUnitCoercion_1_3() throws Exception { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/falseUnitCoercion.kt", "kotlin.coroutines"); @@ -6092,26 +6097,11 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JS_IR, true); } - @TestMetadata("also.kt") - public void testAlso_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/also.kt", "kotlin.coroutines"); - } - @TestMetadata("crossinline.kt") public void testCrossinline_1_3() throws Exception { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/crossinline.kt", "kotlin.coroutines"); } - @TestMetadata("epam.kt") - public void testEpam_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/epam.kt", "kotlin.coroutines"); - } - - @TestMetadata("inlineWithStateMachine.kt") - public void testInlineWithStateMachine_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithStateMachine.kt", "kotlin.coroutines"); - } - @TestMetadata("inlineWithoutStateMachine.kt") public void testInlineWithoutStateMachine_1_3() throws Exception { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithoutStateMachine.kt", "kotlin.coroutines"); @@ -6122,25 +6112,10 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/innerObjectRetransformation.kt", "kotlin.coroutines"); } - @TestMetadata("simple.kt") - public void testSimple_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/simple.kt", "kotlin.coroutines"); - } - @TestMetadata("tryCatch.kt") public void testTryCatch_1_3() throws Exception { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/tryCatch.kt", "kotlin.coroutines"); } - - @TestMetadata("unreachable.kt") - public void testUnreachable_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unreachable.kt", "kotlin.coroutines"); - } - - @TestMetadata("whenUnit.kt") - public void testWhenUnit_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/whenUnit.kt", "kotlin.coroutines"); - } } @TestMetadata("compiler/testData/codegen/box/coroutines/tailOperations") 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 245fab06d09..26c0b33aa9c 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 @@ -4914,6 +4914,16 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/emptyClosure.kt", "kotlin.coroutines"); } + @TestMetadata("epam.kt") + public void testEpam_1_2() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/epam.kt", "kotlin.coroutines.experimental"); + } + + @TestMetadata("epam.kt") + public void testEpam_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/epam.kt", "kotlin.coroutines"); + } + @TestMetadata("falseUnitCoercion.kt") public void testFalseUnitCoercion_1_2() throws Exception { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/falseUnitCoercion.kt", "kotlin.coroutines.experimental"); @@ -7087,16 +7097,6 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JS, true); } - @TestMetadata("also.kt") - public void testAlso_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/also.kt", "kotlin.coroutines.experimental"); - } - - @TestMetadata("also.kt") - public void testAlso_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/also.kt", "kotlin.coroutines"); - } - @TestMetadata("crossinline.kt") public void testCrossinline_1_2() throws Exception { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/crossinline.kt", "kotlin.coroutines.experimental"); @@ -7107,26 +7107,6 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/crossinline.kt", "kotlin.coroutines"); } - @TestMetadata("epam.kt") - public void testEpam_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/epam.kt", "kotlin.coroutines.experimental"); - } - - @TestMetadata("epam.kt") - public void testEpam_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/epam.kt", "kotlin.coroutines"); - } - - @TestMetadata("inlineWithStateMachine.kt") - public void testInlineWithStateMachine_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithStateMachine.kt", "kotlin.coroutines.experimental"); - } - - @TestMetadata("inlineWithStateMachine.kt") - public void testInlineWithStateMachine_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithStateMachine.kt", "kotlin.coroutines"); - } - @TestMetadata("inlineWithoutStateMachine.kt") public void testInlineWithoutStateMachine_1_2() throws Exception { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithoutStateMachine.kt", "kotlin.coroutines.experimental"); @@ -7147,16 +7127,6 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/innerObjectRetransformation.kt", "kotlin.coroutines"); } - @TestMetadata("simple.kt") - public void testSimple_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/simple.kt", "kotlin.coroutines.experimental"); - } - - @TestMetadata("simple.kt") - public void testSimple_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/simple.kt", "kotlin.coroutines"); - } - @TestMetadata("tryCatch.kt") public void testTryCatch_1_2() throws Exception { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/tryCatch.kt", "kotlin.coroutines.experimental"); @@ -7166,26 +7136,6 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { public void testTryCatch_1_3() throws Exception { runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/tryCatch.kt", "kotlin.coroutines"); } - - @TestMetadata("unreachable.kt") - public void testUnreachable_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unreachable.kt", "kotlin.coroutines.experimental"); - } - - @TestMetadata("unreachable.kt") - public void testUnreachable_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unreachable.kt", "kotlin.coroutines"); - } - - @TestMetadata("whenUnit.kt") - public void testWhenUnit_1_2() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/whenUnit.kt", "kotlin.coroutines.experimental"); - } - - @TestMetadata("whenUnit.kt") - public void testWhenUnit_1_3() throws Exception { - runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/tailCallOptimizations/whenUnit.kt", "kotlin.coroutines"); - } } @TestMetadata("compiler/testData/codegen/box/coroutines/tailOperations")