Support non-tail suspend calls in JVM back-end

#KT-15597 In Progress

compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/dispatchResume.kt

@@ -0,0 +1,82 @@
+// WITH_RUNTIME
+// WITH_COROUTINES
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+class Controller {
+    var log = ""
+    var resumeIndex = 0
+
+    suspend fun <T> suspendWithValue(value: T): T = suspendCoroutineOrReturn { continuation ->
+        log += "suspend($value);"
+        continuation.resume(value)
+        SUSPENDED_MARKER
+    }
+
+    suspend fun suspendWithException(value: String): Unit = suspendCoroutineOrReturn { continuation ->
+        log += "error($value);"
+        continuation.resumeWithException(RuntimeException(value))
+        SUSPENDED_MARKER
+    }
+}
+
+fun test(c: suspend Controller.() -> Unit): String {
+    val controller = Controller()
+    c.startCoroutine(controller, EmptyContinuation, object: ContinuationDispatcher {
+        private fun dispatchResume(block: () -> Unit) {
+            val id = controller.resumeIndex++
+            controller.log += "before $id;"
+            block()
+            controller.log += "after $id;"
+        }
+
+        override fun <P> dispatchResume(data: P, continuation: Continuation<P>): Boolean {
+            dispatchResume {
+                continuation.resume(data)
+            }
+            return true
+        }
+
+        override fun dispatchResumeWithException(exception: Throwable, continuation: Continuation<*>): Boolean {
+            dispatchResume {
+                continuation.resumeWithException(exception)
+            }
+            return true
+        }
+    })
+    return controller.log
+}
+
+suspend fun Controller.foo() = suspendWithValue("") + suspendWithValue("O")
+
+suspend fun Controller.test1() {
+    val o = foo()
+    val k = suspendWithValue("K")
+    log += "$o$k;"
+}
+
+suspend fun Controller.test2() {
+    try {
+        foo()
+
+        suspendWithException("OK")
+        log += "ignore;"
+    }
+    catch (e: RuntimeException) {
+        log += "${e.message};"
+    }
+}
+
+fun box(): String {
+    var result = test {
+        test1()
+    }
+    if (result != "before 0;suspend();before 1;suspend(O);before 2;before 3;suspend(K);before 4;OK;before 5;after 5;after 4;after 3;after 2;after 1;after 0;") return "fail1: $result"
+
+    result = test {
+        test2()
+    }
+    if (result != "before 0;suspend();before 1;suspend(O);before 2;before 3;error(OK);before 4;OK;before 5;after 5;after 4;after 3;after 2;after 1;after 0;") return "fail2: $result"
+
+    return "OK"
+}

compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/handleException.kt

@@ -0,0 +1,112 @@
+// WITH_RUNTIME
+// WITH_COROUTINES
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+class Controller {
+    var exception: Throwable? = null
+    val postponedActions = ArrayList<() -> Unit>()
+
+    suspend fun suspendWithValue(v: String): String = suspendCoroutineOrReturn { x ->
+        postponedActions.add {
+            x.resume(v)
+        }
+
+        SUSPENDED_MARKER
+    }
+
+    suspend fun suspendWithException(e: Exception): String = suspendCoroutineOrReturn { x ->
+        postponedActions.add {
+            x.resumeWithException(e)
+        }
+
+        SUSPENDED_MARKER
+    }
+
+    fun run(c: suspend Controller.() -> Unit) {
+        c.startCoroutine(this, handleExceptionContinuation {
+            exception = it
+        })
+        while (postponedActions.isNotEmpty()) {
+            postponedActions[0]()
+            postponedActions.removeAt(0)
+        }
+    }
+}
+
+fun builder(c: suspend Controller.() -> Unit) {
+    val controller = Controller()
+    controller.run(c)
+
+    if (controller.exception?.message != "OK") {
+        throw RuntimeException("Unexpected result: ${controller.exception?.message}")
+    }
+}
+
+fun commonThrow(t: Throwable) {
+    throw t
+}
+
+suspend fun justContinue(): Unit = suspendCoroutineOrReturn { x ->
+    x.resume(Unit)
+
+    SUSPENDED_MARKER
+}
+
+suspend fun Controller.test1() {
+    justContinue()
+    throw RuntimeException("OK")
+}
+
+suspend fun Controller.test2() {
+    justContinue()
+    commonThrow(RuntimeException("OK"))
+}
+
+suspend fun Controller.test3() {
+    justContinue()
+    suspendWithException(RuntimeException("OK"))
+}
+
+suspend fun Controller.test4() {
+    justContinue()
+    try {
+        suspendWithException(RuntimeException("fail 1"))
+    } catch (e: RuntimeException) {
+        suspendWithException(RuntimeException("OK"))
+    }
+}
+
+suspend fun Controller.test5() {
+    justContinue()
+    try {
+        suspendWithException(Exception("OK"))
+    } catch (e: RuntimeException) {
+        suspendWithException(RuntimeException("fail 3"))
+        throw RuntimeException("fail 4")
+    }
+}
+
+fun box(): String {
+    builder {
+        test1()
+    }
+
+    builder {
+        test2()
+    }
+
+    builder {
+        test3()
+    }
+
+    builder {
+        test4()
+    }
+
+    builder {
+        test5()
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/inline.kt

@@ -0,0 +1,32 @@
+// WITH_RUNTIME
+// WITH_COROUTINES
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+suspend fun suspendThere(v: String): String = suspendCoroutineOrReturn { x ->
+    x.resume(v)
+    SUSPENDED_MARKER
+}
+
+suspend inline fun suspendHere(crossinline block: () -> String): String {
+    return suspendThere(block()) + suspendThere(block())
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+fun box(): String {
+    var result = ""
+
+    builder {
+        var q = "O"
+        result = suspendHere {
+            val r = q
+            q = "K"
+            r
+        }
+    }
+
+    return result
+}

compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/member.kt

@@ -0,0 +1,27 @@
+// WITH_RUNTIME
+// WITH_COROUTINES
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+class A(val v: String) {
+    suspend fun suspendThere(v: String): String = suspendCoroutineOrReturn { x ->
+        x.resume(v)
+        SUSPENDED_MARKER
+    }
+
+    suspend fun suspendHere(): String = suspendThere("O") + suspendThere(v)
+}
+
+fun builder(c: suspend A.() -> Unit) {
+    c.startCoroutine(A("K"), EmptyContinuation)
+}
+
+fun box(): String {
+    var result = ""
+
+    builder {
+        result = suspendHere()
+    }
+
+    return result
+}

compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/returnNoSuspend.kt

@@ -0,0 +1,28 @@
+// WITH_RUNTIME
+// WITH_COROUTINES
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+suspend fun suspendThere(v: String): String = suspendCoroutineOrReturn { x ->
+    x.resume(v)
+    SUSPENDED_MARKER
+}
+
+suspend fun suspendHere(suspend: Boolean): String {
+    if (!suspend) return "O"
+
+    return suspendThere("") + suspendThere("K")
+}
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+fun box(): String {
+    var result = ""
+
+    builder {
+        result = suspendHere(false) + suspendHere(true)
+    }
+
+    return result
+}

compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/simple.kt

@@ -0,0 +1,25 @@
+// WITH_RUNTIME
+// WITH_COROUTINES
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+suspend fun suspendThere(v: String): String = suspendCoroutineOrReturn { x ->
+    x.resume(v)
+    SUSPENDED_MARKER
+}
+
+suspend fun suspendHere(): String = suspendThere("O") + suspendThere("K")
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+fun box(): String {
+    var result = ""
+
+    builder {
+        result = suspendHere()
+    }
+
+    return result
+}

compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/withVariables.kt

@@ -0,0 +1,31 @@
+// WITH_RUNTIME
+// WITH_COROUTINES
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+suspend fun suspendThere(v: String): String = suspendCoroutineOrReturn { x ->
+    x.resume(v)
+    SUSPENDED_MARKER
+}
+
+suspend fun suspendHere(): String {
+    val k = "K"
+    val x = suspendThere("O")
+    val y = x + suspendThere(k)
+
+    return y
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+fun box(): String {
+    var result = ""
+
+    builder {
+        result = suspendHere()
+    }
+
+    return result
+}

compiler/testData/codegen/bytecodeListing/coroutineFields.kt

@@ -5,6 +5,21 @@ class Controller {
     suspend fun suspendHere() = suspendCoroutineOrReturn<String> { x ->
         x.resume("OK")
     }
+
+    suspend fun tailCall(): String {
+        return suspendHere()
+    }
+
+    suspend fun nonTailCall(): String {
+        suspendHere()
+
+        return "OK"
+    }
+
+    suspend fun multipleSuspensions(): String {
+        suspendHere()
+        return suspendHere()
+    }
 }
 
 fun builder(c: suspend Controller.() -> Unit) {

compiler/testData/codegen/bytecodeListing/coroutineFields.txt

@@ -1,7 +1,26 @@
+final class Controller$multipleSuspensions$1 {
+    synthetic final field this$0: Controller
+    inner class Controller$multipleSuspensions$1
+    method <init>(p0: Controller, p1: kotlin.coroutines.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
+}
+
+final class Controller$nonTailCall$1 {
+    synthetic final field this$0: Controller
+    inner class Controller$nonTailCall$1
+    method <init>(p0: Controller, p1: kotlin.coroutines.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
+}
+
 @kotlin.Metadata
 public final class Controller {
+    inner class Controller$multipleSuspensions$1
+    inner class Controller$nonTailCall$1
     public method <init>(): void
+    public final @org.jetbrains.annotations.Nullable method multipleSuspensions(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method nonTailCall(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object
     public final @org.jetbrains.annotations.Nullable method suspendHere(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method tailCall(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -15,7 +34,7 @@ final class CoroutineFieldsKt$box$1 {
     method <init>(p0: kotlin.jvm.internal.Ref$ObjectRef, p1: kotlin.coroutines.Continuation): void
     public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: Controller, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation
     public synthetic method create(p0: java.lang.Object, p1: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation
-    protected 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 @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 @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: Controller, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
     public synthetic method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
 }

compiler/testData/codegen/light-analysis/coroutines/suspendFunctionAsCoroutine/dispatchResume.txt

@@ -0,0 +1,35 @@
+@kotlin.Metadata
+public final class Controller {
+    private @org.jetbrains.annotations.NotNull field log: java.lang.String
+    private field resumeIndex: int
+    public method <init>(): void
+    public final @org.jetbrains.annotations.NotNull method getLog(): java.lang.String
+    public final method getResumeIndex(): int
+    public final method setLog(@org.jetbrains.annotations.NotNull p0: java.lang.String): void
+    public final method setResumeIndex(p0: int): void
+    public final @org.jetbrains.annotations.Nullable method suspendWithException(@org.jetbrains.annotations.NotNull p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method suspendWithValue(p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
+}
+
+@kotlin.Metadata
+public final class CoroutineUtilKt {
+    public final static @org.jetbrains.annotations.NotNull method handleExceptionContinuation(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): kotlin.coroutines.Continuation
+    public final static @org.jetbrains.annotations.NotNull method handleResultContinuation(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): kotlin.coroutines.Continuation
+}
+
+@kotlin.Metadata
+public final class DispatchResumeKt {
+    public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
+    public final static @org.jetbrains.annotations.Nullable method foo(@org.jetbrains.annotations.NotNull p0: Controller, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.NotNull method test(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function2): java.lang.String
+    public final static @org.jetbrains.annotations.Nullable method test1(@org.jetbrains.annotations.NotNull p0: Controller, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.Nullable method test2(@org.jetbrains.annotations.NotNull p0: Controller, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
+}
+
+@kotlin.Metadata
+public final class EmptyContinuation {
+    public final static field INSTANCE: EmptyContinuation
+    private method <init>(): void
+    public method resume(@org.jetbrains.annotations.Nullable p0: java.lang.Object): void
+    public method resumeWithException(@org.jetbrains.annotations.NotNull p0: java.lang.Throwable): void
+}

compiler/testData/codegen/light-analysis/coroutines/suspendFunctionAsCoroutine/handleException.txt

@@ -0,0 +1,39 @@
+@kotlin.Metadata
+public final class Controller {
+    private @org.jetbrains.annotations.Nullable field exception: java.lang.Throwable
+    private final @org.jetbrains.annotations.NotNull field postponedActions: java.util.ArrayList
+    public method <init>(): void
+    public final @org.jetbrains.annotations.Nullable method getException(): java.lang.Throwable
+    public final @org.jetbrains.annotations.NotNull method getPostponedActions(): java.util.ArrayList
+    public final method run(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function2): void
+    public final method setException(@org.jetbrains.annotations.Nullable p0: java.lang.Throwable): void
+    public final @org.jetbrains.annotations.Nullable method suspendWithException(@org.jetbrains.annotations.NotNull p0: java.lang.Exception, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method suspendWithValue(@org.jetbrains.annotations.NotNull p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
+}
+
+@kotlin.Metadata
+public final class CoroutineUtilKt {
+    public final static @org.jetbrains.annotations.NotNull method handleExceptionContinuation(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): kotlin.coroutines.Continuation
+    public final static @org.jetbrains.annotations.NotNull method handleResultContinuation(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): kotlin.coroutines.Continuation
+}
+
+@kotlin.Metadata
+public final class EmptyContinuation {
+    public final static field INSTANCE: EmptyContinuation
+    private method <init>(): void
+    public method resume(@org.jetbrains.annotations.Nullable p0: java.lang.Object): void
+    public method resumeWithException(@org.jetbrains.annotations.NotNull p0: java.lang.Throwable): void
+}
+
+@kotlin.Metadata
+public final class HandleExceptionKt {
+    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.Function2): void
+    public final static method commonThrow(@org.jetbrains.annotations.NotNull p0: java.lang.Throwable): void
+    public final static @org.jetbrains.annotations.Nullable method justContinue(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.Nullable method test1(@org.jetbrains.annotations.NotNull p0: Controller, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.Nullable method test2(@org.jetbrains.annotations.NotNull p0: Controller, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.Nullable method test3(@org.jetbrains.annotations.NotNull p0: Controller, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.Nullable method test4(@org.jetbrains.annotations.NotNull p0: Controller, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.Nullable method test5(@org.jetbrains.annotations.NotNull p0: Controller, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
+}

compiler/testData/codegen/light-analysis/coroutines/suspendFunctionAsCoroutine/inline.txt

@@ -0,0 +1,21 @@
+@kotlin.Metadata
+public final class CoroutineUtilKt {
+    public final static @org.jetbrains.annotations.NotNull method handleExceptionContinuation(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): kotlin.coroutines.Continuation
+    public final static @org.jetbrains.annotations.NotNull method handleResultContinuation(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): kotlin.coroutines.Continuation
+}
+
+@kotlin.Metadata
+public final class EmptyContinuation {
+    public final static field INSTANCE: EmptyContinuation
+    private method <init>(): void
+    public method resume(@org.jetbrains.annotations.Nullable p0: java.lang.Object): void
+    public method resumeWithException(@org.jetbrains.annotations.NotNull p0: java.lang.Throwable): void
+}
+
+@kotlin.Metadata
+public final class InlineKt {
+    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.jvm.functions.Function0, @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
+}

compiler/testData/codegen/light-analysis/coroutines/suspendFunctionAsCoroutine/member.txt

@@ -0,0 +1,28 @@
+@kotlin.Metadata
+public final class A {
+    private final @org.jetbrains.annotations.NotNull field v: java.lang.String
+    public method <init>(@org.jetbrains.annotations.NotNull p0: java.lang.String): void
+    public final @org.jetbrains.annotations.NotNull method getV(): java.lang.String
+    public final @org.jetbrains.annotations.Nullable method suspendHere(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object
+    public final @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
+}
+
+@kotlin.Metadata
+public final class CoroutineUtilKt {
+    public final static @org.jetbrains.annotations.NotNull method handleExceptionContinuation(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): kotlin.coroutines.Continuation
+    public final static @org.jetbrains.annotations.NotNull method handleResultContinuation(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): kotlin.coroutines.Continuation
+}
+
+@kotlin.Metadata
+public final class EmptyContinuation {
+    public final static field INSTANCE: EmptyContinuation
+    private method <init>(): void
+    public method resume(@org.jetbrains.annotations.Nullable p0: java.lang.Object): void
+    public method resumeWithException(@org.jetbrains.annotations.NotNull p0: java.lang.Throwable): void
+}
+
+@kotlin.Metadata
+public final class MemberKt {
+    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.Function2): void
+}

compiler/testData/codegen/light-analysis/coroutines/suspendFunctionAsCoroutine/returnNoSuspend.txt

@@ -0,0 +1,21 @@
+@kotlin.Metadata
+public final class CoroutineUtilKt {
+    public final static @org.jetbrains.annotations.NotNull method handleExceptionContinuation(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): kotlin.coroutines.Continuation
+    public final static @org.jetbrains.annotations.NotNull method handleResultContinuation(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): kotlin.coroutines.Continuation
+}
+
+@kotlin.Metadata
+public final class EmptyContinuation {
+    public final static field INSTANCE: EmptyContinuation
+    private method <init>(): void
+    public method resume(@org.jetbrains.annotations.Nullable p0: java.lang.Object): void
+    public method resumeWithException(@org.jetbrains.annotations.NotNull p0: java.lang.Throwable): void
+}
+
+@kotlin.Metadata
+public final class ReturnNoSuspendKt {
+    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(p0: boolean, @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
+}

compiler/testData/codegen/light-analysis/coroutines/suspendFunctionAsCoroutine/simple.txt

@@ -0,0 +1,21 @@
+@kotlin.Metadata
+public final class CoroutineUtilKt {
+    public final static @org.jetbrains.annotations.NotNull method handleExceptionContinuation(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): kotlin.coroutines.Continuation
+    public final static @org.jetbrains.annotations.NotNull method handleResultContinuation(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): kotlin.coroutines.Continuation
+}
+
+@kotlin.Metadata
+public final class EmptyContinuation {
+    public final static field INSTANCE: EmptyContinuation
+    private method <init>(): void
+    public method resume(@org.jetbrains.annotations.Nullable p0: java.lang.Object): void
+    public method resumeWithException(@org.jetbrains.annotations.NotNull p0: java.lang.Throwable): void
+}
+
+@kotlin.Metadata
+public final class SimpleKt {
+    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
+}

compiler/testData/codegen/light-analysis/coroutines/suspendFunctionAsCoroutine/withVariables.txt

@@ -0,0 +1,21 @@
+@kotlin.Metadata
+public final class CoroutineUtilKt {
+    public final static @org.jetbrains.annotations.NotNull method handleExceptionContinuation(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): kotlin.coroutines.Continuation
+    public final static @org.jetbrains.annotations.NotNull method handleResultContinuation(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): kotlin.coroutines.Continuation
+}
+
+@kotlin.Metadata
+public final class EmptyContinuation {
+    public final static field INSTANCE: EmptyContinuation
+    private method <init>(): void
+    public method resume(@org.jetbrains.annotations.Nullable p0: java.lang.Object): void
+    public method resumeWithException(@org.jetbrains.annotations.NotNull p0: java.lang.Throwable): void
+}
+
+@kotlin.Metadata
+public final class WithVariablesKt {
+    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
+}