[K/N][Tests] Move some codegen tests to new infra: annotations..coroutines

^KT-61259

native/native.tests/testData/codegen/coroutines/anonymousObject.kt

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.anonymousObject
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun suspendHere(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    x.resume(42)
+    COROUTINE_SUSPENDED
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+interface I {
+    suspend fun foo(lambda: suspend (String) -> Unit)
+    suspend fun bar(s: String)
+}
+
+fun create() = object: I {
+    var lambda: suspend (String) -> Unit = {}
+
+    override suspend fun foo(lambda: suspend (String) -> Unit) {
+        this.lambda = lambda
+    }
+
+    override suspend fun bar(s: String) {
+        lambda(s)
+    }
+}
+
+@Test fun runTest() {
+    builder {
+        val z = create()
+        z.foo { suspendHere(); println(it) }
+        z.bar("zzz")
+    }
+}

native/native.tests/testData/codegen/coroutines/anonymousObject.out

@@ -0,0 +1 @@
+zzz

native/native.tests/testData/codegen/coroutines/controlFlow_chain.kt

@@ -0,0 +1,43 @@
+/*
+ * 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 file.
+ */
+
+package codegen.coroutines.controlFlow_chain
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun suspendHere(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    x.resume(42)
+    COROUTINE_SUSPENDED
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+// See https://github.com/JetBrains/kotlin-native/issues/3476
+@Test fun runTest() {
+    var result = 0
+    builder {
+        foo().bar()
+        result = 1
+    }
+    assertEquals(1, result)
+}
+
+class Foo {
+    suspend fun bar() {
+        suspendHere()
+    }
+}
+
+suspend fun foo() = Foo()

native/native.tests/testData/codegen/coroutines/controlFlow_finally1.kt

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.controlFlow_finally1
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun s1(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s1")
+    x.resume(42)
+    COROUTINE_SUSPENDED
+}
+
+fun f1(): Int {
+    println("f1")
+    return 117
+}
+
+fun f2(): Int {
+    println("f2")
+    return 1
+}
+
+fun f3(x: Int, y: Int): Int {
+    println("f3")
+    return x + y
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+@Test fun runTest() {
+    var result = 0
+
+    builder {
+        result = try {
+            f1()
+        } catch (t: Throwable) {
+            f2()
+        } finally {
+            s1()
+        }
+    }
+
+    println(result)
+}

native/native.tests/testData/codegen/coroutines/controlFlow_finally1.out

@@ -0,0 +1,3 @@
+f1
+s1
+117

native/native.tests/testData/codegen/coroutines/controlFlow_finally2.kt

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.controlFlow_finally2
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun s1(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s1")
+    x.resume(42)
+    COROUTINE_SUSPENDED
+}
+
+fun f1(): Int {
+    println("f1")
+    return 117
+}
+
+fun f2(): Int {
+    println("f2")
+    return 1
+}
+
+fun f3(x: Int, y: Int): Int {
+    println("f3")
+    return x + y
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+@Test fun runTest() {
+    var result = 0
+
+    builder {
+        val x = try {
+            f1()
+        } catch (t: Throwable) {
+            f2()
+        } finally {
+            s1()
+        }
+        result = x
+    }
+
+    println(result)
+}

native/native.tests/testData/codegen/coroutines/controlFlow_finally2.out

@@ -0,0 +1,3 @@
+f1
+s1
+117

native/native.tests/testData/codegen/coroutines/controlFlow_finally3.kt

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.controlFlow_finally3
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun s1(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s1")
+    x.resume(42)
+    COROUTINE_SUSPENDED
+}
+
+fun f1(): Int {
+    println("f1")
+    return 117
+}
+
+fun f2(): Int {
+    println("f2")
+    return 1
+}
+
+fun f3(x: Int, y: Int): Int {
+    println("f3")
+    return x + y
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+@Test fun runTest() {
+    var result = 0
+
+    builder {
+        try {
+            result = f1()
+        } catch (t: Throwable) {
+            result = f2()
+        } finally {
+            s1()
+        }
+    }
+
+    println(result)
+}

native/native.tests/testData/codegen/coroutines/controlFlow_finally3.out

@@ -0,0 +1,3 @@
+f1
+s1
+117

native/native.tests/testData/codegen/coroutines/controlFlow_finally4.kt

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.controlFlow_finally4
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun s1(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s1")
+    x.resume(42)
+    COROUTINE_SUSPENDED
+}
+
+fun f1(): Int {
+    println("f1")
+    return 117
+}
+
+fun f2(): Int {
+    println("f2")
+    return 1
+}
+
+fun f3(x: Int, y: Int): Int {
+    println("f3")
+    return x + y
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+@Test fun runTest() {
+    var result = 0
+
+    builder {
+        try {
+            result = s1()
+        } catch (t: Throwable) {
+            result = f2()
+        } finally {
+            println("finally")
+        }
+    }
+
+    println(result)
+}

native/native.tests/testData/codegen/coroutines/controlFlow_finally4.out

@@ -0,0 +1,3 @@
+s1
+finally
+42

native/native.tests/testData/codegen/coroutines/controlFlow_finally5.kt

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.controlFlow_finally5
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun s1(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s1")
+    x.resumeWithException(Error())
+    COROUTINE_SUSPENDED
+}
+
+fun f1(): Int {
+    println("f1")
+    return 117
+}
+
+fun f2(): Int {
+    println("f2")
+    return 1
+}
+
+fun f3(x: Int, y: Int): Int {
+    println("f3")
+    return x + y
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+@Test fun runTest() {
+    var result = 0
+
+    builder {
+        try {
+            result = s1()
+        } catch (t: Throwable) {
+            result = f2()
+        } finally {
+            println("finally")
+        }
+    }
+
+    println(result)
+}

native/native.tests/testData/codegen/coroutines/controlFlow_finally5.out

@@ -0,0 +1,4 @@
+s1
+f2
+finally
+1

native/native.tests/testData/codegen/coroutines/controlFlow_finally6.kt

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.controlFlow_finally6
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun s1(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s1")
+    x.resumeWithException(Error("error"))
+    COROUTINE_SUSPENDED
+}
+
+fun f1(): Int {
+    println("f1")
+    return 117
+}
+
+fun f2(): Int {
+    println("f2")
+    return 1
+}
+
+fun f3(x: Int, y: Int): Int {
+    println("f3")
+    return x + y
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+@Test fun runTest() {
+    var result = 0
+
+    builder {
+        try {
+            try {
+                result = s1()
+            } catch (t: ClassCastException) {
+                result = f2()
+            } finally {
+                println("finally")
+            }
+        }
+        catch(t: Error) {
+            println(t.message)
+        }
+    }
+
+    println(result)
+}

native/native.tests/testData/codegen/coroutines/controlFlow_finally6.out

@@ -0,0 +1,4 @@
+s1
+finally
+error
+0

native/native.tests/testData/codegen/coroutines/controlFlow_finally7.kt

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.controlFlow_finally7
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun s1(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s1")
+    x.resumeWithException(Error())
+    COROUTINE_SUSPENDED
+}
+
+suspend fun s2(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s2")
+    x.resume(42)
+    COROUTINE_SUSPENDED
+}
+
+fun f1(): Int {
+    println("f1")
+    return 117
+}
+
+fun f2(): Int {
+    println("f2")
+    return 1
+}
+
+fun f3(x: Int, y: Int): Int {
+    println("f3")
+    return x + y
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+@Test fun runTest() {
+    var result = 0
+
+    builder {
+        try {
+            try {
+                result = s1()
+            } catch (t: Throwable) {
+                result = f2()
+            } finally {
+                println("finally1")
+                result = s2()
+            }
+        } finally {
+            println("finally2")
+        }
+    }
+
+    println(result)
+}

native/native.tests/testData/codegen/coroutines/controlFlow_finally7.out

@@ -0,0 +1,6 @@
+s1
+f2
+finally1
+s2
+finally2
+42

native/native.tests/testData/codegen/coroutines/controlFlow_if1.kt

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.controlFlow_if1
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun s1(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s1")
+    x.resume(42)
+    COROUTINE_SUSPENDED
+}
+
+fun f1(): Int {
+    println("f1")
+    return 117
+}
+
+fun f2(): Int {
+    println("f2")
+    return 1
+}
+
+fun f3(x: Int, y: Int): Int {
+    println("f3")
+    return x + y
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+@Test fun runTest() {
+    var result = 0
+
+    builder {
+        result = f3(if (f1() > 100) s1() else f2(), 42)
+    }
+
+    println(result)
+}

native/native.tests/testData/codegen/coroutines/controlFlow_if1.out

@@ -0,0 +1,4 @@
+f1
+s1
+f3
+84

native/native.tests/testData/codegen/coroutines/controlFlow_if2.kt

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.controlFlow_if2
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun s1(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s1")
+    x.resume(42)
+    COROUTINE_SUSPENDED
+}
+
+fun f1(): Int {
+    println("f1")
+    return 117
+}
+
+fun f2(): Int {
+    println("f2")
+    return 1
+}
+
+fun f3(x: Int, y: Int): Int {
+    println("f3")
+    return x + y
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+@Test fun runTest() {
+    var result = 0
+
+    builder {
+        if (f1() > 100)
+            result = s1() + f2()
+        else
+            result = 42
+    }
+
+    println(result)
+}

native/native.tests/testData/codegen/coroutines/controlFlow_if2.out

@@ -0,0 +1,4 @@
+f1
+s1
+f2
+43

native/native.tests/testData/codegen/coroutines/controlFlow_inline1.kt

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.controlFlow_inline1
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun s1(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s1")
+    x.resume(42)
+    COROUTINE_SUSPENDED
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+inline suspend fun inline_s2(): Int {
+    return 42
+}
+
+@Test fun runTest() {
+    var result = 0
+
+    builder {
+        result = inline_s2()
+    }
+
+    println(result)
+}

native/native.tests/testData/codegen/coroutines/controlFlow_inline1.out

@@ -0,0 +1 @@
+42

native/native.tests/testData/codegen/coroutines/controlFlow_inline2.kt

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.controlFlow_inline2
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun s1(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s1")
+    x.resume(42)
+    COROUTINE_SUSPENDED
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+inline suspend fun inline_s2(): Int {
+    var x = s1()
+    return x
+}
+
+@Test fun runTest() {
+    var result = 0
+
+    builder {
+        result = inline_s2()
+    }
+
+    println(result)
+}

native/native.tests/testData/codegen/coroutines/controlFlow_inline2.out

@@ -0,0 +1,2 @@
+s1
+42

native/native.tests/testData/codegen/coroutines/controlFlow_inline3.kt

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.controlFlow_inline3
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun s1(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s1")
+    x.resume(42)
+    COROUTINE_SUSPENDED
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+fun f1(): Int {
+    println("f1")
+    return 117
+}
+
+fun f2(): Int {
+    println("f2")
+    return 1
+}
+
+inline suspend fun inline_s2(): Int {
+    var x = 0
+    if (f1() > 0)
+        x = s1()
+    else x = f2()
+    return x
+}
+
+@Test fun runTest() {
+    var result = 0
+
+    builder {
+        result = inline_s2()
+    }
+
+    println(result)
+}

native/native.tests/testData/codegen/coroutines/controlFlow_inline3.out

@@ -0,0 +1,3 @@
+f1
+s1
+42

native/native.tests/testData/codegen/coroutines/controlFlow_tryCatch1.kt

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.controlFlow_tryCatch1
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun s1(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s1")
+    x.resume(42)
+    COROUTINE_SUSPENDED
+}
+
+fun f1(): Int {
+    println("f1")
+    return 117
+}
+
+fun f2(): Int {
+    println("f2")
+    return 1
+}
+
+fun f3(x: Int, y: Int): Int {
+    println("f3")
+    return x + y
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+@Test fun runTest() {
+    var result = 0
+
+    builder {
+        val x = try {
+            s1()
+        } catch (t: Throwable) {
+            f2()
+        }
+        result = x
+    }
+
+    println(result)
+}

native/native.tests/testData/codegen/coroutines/controlFlow_tryCatch1.out

@@ -0,0 +1,2 @@
+s1
+42

native/native.tests/testData/codegen/coroutines/controlFlow_tryCatch2.kt

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.controlFlow_tryCatch2
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun s1(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s1")
+    x.resume(42)
+    COROUTINE_SUSPENDED
+}
+
+fun f1(): Int {
+    println("f1")
+    return 117
+}
+
+fun f2(): Int {
+    println("f2")
+    return 1
+}
+
+fun f3(x: Int, y: Int): Int {
+    println("f3")
+    return x + y
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+@Test fun runTest() {
+    var result = 0
+
+    builder {
+        result = try {
+            s1()
+        } catch (t: Throwable) {
+            f2()
+        }
+    }
+
+    println(result)
+}

native/native.tests/testData/codegen/coroutines/controlFlow_tryCatch2.out

@@ -0,0 +1,2 @@
+s1
+42

native/native.tests/testData/codegen/coroutines/controlFlow_tryCatch3.kt

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.controlFlow_tryCatch3
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun s1(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s1")
+    x.resume(42)
+    COROUTINE_SUSPENDED
+}
+
+suspend fun s2(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s2")
+    x.resumeWithException(Error())
+    COROUTINE_SUSPENDED
+}
+
+fun f1(): Int {
+    println("f1")
+    return 117
+}
+
+fun f2(): Int {
+    println("f2")
+    return 1
+}
+
+fun f3(x: Int, y: Int): Int {
+    println("f3")
+    return x + y
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+@Test fun runTest() {
+    var result = 0
+
+    builder {
+        result = try {
+            s2()
+        } catch (t: Throwable) {
+            f2()
+        }
+    }
+
+    println(result)
+}

native/native.tests/testData/codegen/coroutines/controlFlow_tryCatch3.out

@@ -0,0 +1,3 @@
+s2
+f2
+1

native/native.tests/testData/codegen/coroutines/controlFlow_tryCatch4.kt

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.controlFlow_tryCatch4
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun s1(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s1")
+    x.resume(42)
+    COROUTINE_SUSPENDED
+}
+
+suspend fun s2(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s2")
+    x.resumeWithException(Error())
+    COROUTINE_SUSPENDED
+}
+
+fun f1(): Int {
+    println("f1")
+    return 117
+}
+
+fun f2(): Int {
+    println("f2")
+    return 1
+}
+
+fun f3(x: Int, y: Int): Int {
+    println("f3")
+    return x + y
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+@Test fun runTest() {
+    var result = 0
+
+    builder {
+        val x = try {
+            s2()
+        } catch (t: Throwable) {
+            f2()
+        }
+        result = x
+    }
+
+    println(result)
+}

native/native.tests/testData/codegen/coroutines/controlFlow_tryCatch4.out

@@ -0,0 +1,3 @@
+s2
+f2
+1

native/native.tests/testData/codegen/coroutines/controlFlow_tryCatch5.kt

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.controlFlow_tryCatch5
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun s1(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s1")
+    x.resume(42)
+    COROUTINE_SUSPENDED
+}
+
+suspend fun s2(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s2")
+    x.resumeWithException(Error("Error"))
+    COROUTINE_SUSPENDED
+}
+
+fun f1(): Int {
+    println("f1")
+    return 117
+}
+
+fun f2(): Int {
+    println("f2")
+    return 1
+}
+
+fun f3(x: Int, y: Int): Int {
+    println("f3")
+    return x + y
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+@Test fun runTest() {
+    var result = 0
+
+    builder {
+        result = try {
+            s2()
+        } catch (t: Throwable) {
+            val x = s1()
+            println(t.message)
+            x
+        }
+    }
+
+    println(result)
+}

native/native.tests/testData/codegen/coroutines/controlFlow_tryCatch5.out

@@ -0,0 +1,4 @@
+s2
+s1
+Error
+42

native/native.tests/testData/codegen/coroutines/controlFlow_while1.kt

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.controlFlow_while1
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun s1(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s1")
+    x.resume(42)
+    COROUTINE_SUSPENDED
+}
+
+suspend fun s2(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s2")
+    x.resumeWithException(Error("Error"))
+    COROUTINE_SUSPENDED
+}
+
+suspend fun s3(value: Int): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s3")
+    x.resume(value)
+    COROUTINE_SUSPENDED
+}
+
+fun f1(): Int {
+    println("f1")
+    return 117
+}
+
+fun f2(): Int {
+    println("f2")
+    return 1
+}
+
+fun f3(x: Int, y: Int): Int {
+    println("f3")
+    return x + y
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+@Test fun runTest() {
+    var result = 0
+
+    builder {
+        while (s3(result) < 3)
+            ++result
+    }
+
+    println(result)
+}

native/native.tests/testData/codegen/coroutines/controlFlow_while1.out

@@ -0,0 +1,5 @@
+s3
+s3
+s3
+s3
+3

native/native.tests/testData/codegen/coroutines/controlFlow_while2.kt

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.controlFlow_while2
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun s1(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s1")
+    x.resume(42)
+    COROUTINE_SUSPENDED
+}
+
+suspend fun s2(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s2")
+    x.resumeWithException(Error("Error"))
+    COROUTINE_SUSPENDED
+}
+
+suspend fun s3(value: Int): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s3")
+    x.resume(value)
+    COROUTINE_SUSPENDED
+}
+
+fun f1(): Int {
+    println("f1")
+    return 117
+}
+
+fun f2(): Int {
+    println("f2")
+    return 1
+}
+
+fun f3(x: Int, y: Int): Int {
+    println("f3")
+    return x + y
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+@Test fun runTest() {
+    var result = 0
+
+    builder {
+        while (result < 3)
+            result = s3(result) + 1
+    }
+
+    println(result)
+}

native/native.tests/testData/codegen/coroutines/controlFlow_while2.out

@@ -0,0 +1,4 @@
+s3
+s3
+s3
+3

native/native.tests/testData/codegen/coroutines/coroutineContext1.kt

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.coroutineContext1
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+@Test fun runTest() {
+    builder { println(coroutineContext) }
+}

native/native.tests/testData/codegen/coroutines/coroutineContext1.out

@@ -0,0 +1 @@
+EmptyCoroutineContext

native/native.tests/testData/codegen/coroutines/coroutineContext2.kt

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.coroutineContext2
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+suspend fun foo() = coroutineContext
+
+@Test fun runTest() {
+    builder { println(foo()) }
+}

native/native.tests/testData/codegen/coroutines/coroutineContext2.out

@@ -0,0 +1 @@
+EmptyCoroutineContext

native/native.tests/testData/codegen/coroutines/correctOrder1.kt

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.correctOrder1
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun s1(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s1")
+    x.resume(42)
+    COROUTINE_SUSPENDED
+}
+
+fun f1(): Int {
+    println("f1")
+    return 117
+}
+
+fun f2(): Int {
+    println("f2")
+    return 1
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+@Test fun runTest() {
+    var result = 0
+
+    builder {
+        result = f1() + s1() + f2()
+    }
+
+    println(result)
+}

native/native.tests/testData/codegen/coroutines/correctOrder1.out

@@ -0,0 +1,4 @@
+f1
+s1
+f2
+160

native/native.tests/testData/codegen/coroutines/degenerate1.kt

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.degenerate1
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun s1() {
+    println("s1")
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+@Test fun runTest() {
+    builder {
+        s1()
+    }
+}

native/native.tests/testData/codegen/coroutines/degenerate1.out

@@ -0,0 +1 @@
+s1

native/native.tests/testData/codegen/coroutines/degenerate2.kt

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.degenerate2
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun s1(): Unit = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s1")
+    x.resume(Unit)
+    COROUTINE_SUSPENDED
+}
+
+suspend fun s2() {
+    println("s2")
+    s1()
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+@Test fun runTest() {
+    builder {
+        s2()
+    }
+}

native/native.tests/testData/codegen/coroutines/degenerate2.out

@@ -0,0 +1,2 @@
+s2
+s1

native/native.tests/testData/codegen/coroutines/functionReference_eqeq_name.kt

@@ -0,0 +1,32 @@
+/*
+ * 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 file.
+ */
+
+package codegen.coroutines.functionReference_eqeq_name
+
+import kotlin.test.*
+
+suspend fun foo(x: Int) = x
+
+class Foo(val x: Int) {
+    suspend fun bar() = x
+}
+
+@Test fun runTest() {
+    val ref1 = ::foo
+    val rec = Foo(42)
+    val ref2 = rec::bar
+    val ref3 = ::foo
+    val ref4 = Foo(42)::bar
+    val ref5 = rec::bar
+    val ref6 = Foo::bar
+    assertEquals("foo", ref1.name)
+    assertEquals("bar", ref2.name)
+    assertEquals("bar", ref6.name)
+    assertFalse(ref1 == ref2)
+    assertTrue(ref1 == ref3)
+    assertFalse(ref2 == ref4)
+    assertTrue(ref2 == ref5)
+    assertFalse(ref6 == ref2)
+}

native/native.tests/testData/codegen/coroutines/functionReference_invokeAsFunction.kt

@@ -0,0 +1,28 @@
+/*
+ * 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 file.
+ */
+
+package codegen.coroutines.functionReference_invokeAsFunction
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+class Foo(val x: Int) {
+    suspend fun bar(y: Int) = foo(y) + x
+}
+
+suspend fun foo(x: Int) = x
+
+@Test fun runTest() {
+    val ref = Foo(42)::bar
+
+    println((ref as Function2<Int, Continuation<Int>, Any?>)(117, EmptyContinuation))
+}

native/native.tests/testData/codegen/coroutines/functionReference_invokeAsFunction.out

@@ -0,0 +1 @@
+159

native/native.tests/testData/codegen/coroutines/functionReference_lambdaAsSuspendLambda.kt

@@ -0,0 +1,19 @@
+/*
+ * 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 file.
+ */
+
+package codegen.coroutines.functionReference_lambdaAsSuspendLambda
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+fun foo(block: (Continuation<Unit>) -> Any?) {
+    block as (suspend () -> Unit)
+}
+
+@Test fun runTest() {
+    foo {}
+}

native/native.tests/testData/codegen/coroutines/functionReference_simple.kt

@@ -0,0 +1,39 @@
+/*
+ * 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 file.
+ */
+
+package codegen.coroutines.functionReference_simple
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun suspendHere(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    x.resume(42)
+    COROUTINE_SUSPENDED
+}
+
+suspend fun foo(x: suspend () -> Int) = x()
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+@Test fun runTest() {
+    var result = 0
+
+    val ref = ::suspendHere
+
+    builder {
+        result = foo(ref)
+    }
+
+    println(result)
+}

native/native.tests/testData/codegen/coroutines/functionReference_simple.out

@@ -0,0 +1 @@
+42

native/native.tests/testData/codegen/coroutines/inheritance.kt

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package codegen.coroutines.inheritance
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+class SuspendHere(): suspend () -> Int {
+    override suspend fun invoke() : Int = suspendCoroutineUninterceptedOrReturn { x ->
+        x.resume(42)
+        COROUTINE_SUSPENDED
+    }
+}
+
+// in old compiler versions all suspend functions were implementing this interface
+// now they are not, but let's test it works correctly
+class SuspendHereLegacy(): suspend () -> Int, SuspendFunction<Int> {
+    override suspend fun invoke() : Int = suspendCoroutineUninterceptedOrReturn { x ->
+        x.resume(43)
+        COROUTINE_SUSPENDED
+    }
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+@Test fun runTest() {
+    var result = 0
+
+    builder {
+        result = SuspendHere()()
+    }
+    println(result)
+    builder {
+        result = SuspendHereLegacy()()
+    }
+    println(result)
+}

native/native.tests/testData/codegen/coroutines/inheritance.out

@@ -0,0 +1,2 @@
+42
+43

native/native.tests/testData/codegen/coroutines/kt41394.kt

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.kt41394
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun suspendHere(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    x.resume(42)
+    COROUTINE_SUSPENDED
+}
+
+suspend fun foo(label: String): String {
+    val x = suspendHere()
+    return label + x.toString()
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+@Test fun runTest() {
+    var result = ""
+
+    builder {
+        result = foo("zzz")
+    }
+
+    assertEquals("zzz42", result)
+}

native/native.tests/testData/codegen/coroutines/returnsNothing1.kt

@@ -0,0 +1,40 @@
+/*
+ * 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 file.
+ */
+
+package codegen.coroutines.returnsNothing1
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun suspendForever(): Int = suspendCoroutineUninterceptedOrReturn {
+    COROUTINE_SUSPENDED
+}
+
+suspend fun foo(): Nothing {
+    suspendForever()
+    throw Error()
+}
+
+suspend fun bar() {
+    foo()
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+@Test fun runTest() {
+    builder {
+        bar()
+    }
+    println("OK")
+}

native/native.tests/testData/codegen/coroutines/returnsNothing1.out

@@ -0,0 +1 @@
+OK

native/native.tests/testData/codegen/coroutines/returnsUnit1.kt

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.returnsUnit1
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun s1(): Unit = suspendCoroutineUninterceptedOrReturn { x ->
+    println("s1")
+    x.resume(Unit)
+    COROUTINE_SUSPENDED
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+inline suspend fun inline_s2(x: Int): Unit {
+    println(x)
+    s1()
+}
+
+suspend fun s3(x: Int) {
+    inline_s2(x)
+}
+
+@Test fun runTest() {
+    var result = 0
+
+    builder {
+        s3(117)
+    }
+
+    println(result)
+}

native/native.tests/testData/codegen/coroutines/returnsUnit1.out

@@ -0,0 +1,3 @@
+117
+s1
+0

native/native.tests/testData/codegen/coroutines/simple.kt

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.simple
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+suspend fun suspendHere(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+    x.resume(42)
+    COROUTINE_SUSPENDED
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+@Test fun runTest() {
+    var result = 0
+
+    builder {
+        result = suspendHere()
+    }
+
+    println(result)
+}

native/native.tests/testData/codegen/coroutines/simple.out

@@ -0,0 +1 @@
+42

native/native.tests/testData/codegen/coroutines/suspendConversion.kt

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+fun main() {
+    var result = 0
+
+    val f: () -> Unit = { result = 42 }
+    builder(f)
+
+    assertEquals(42, result)
+}

native/native.tests/testData/codegen/coroutines/withReceiver.kt

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.coroutines.withReceiver
+
+import kotlin.test.*
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resumeWith(result: Result<Any?>) { result.getOrThrow() }
+}
+
+class Controller {
+    suspend fun suspendHere(): Int = suspendCoroutineUninterceptedOrReturn { x ->
+        x.resume(42)
+        COROUTINE_SUSPENDED
+    }
+}
+
+fun builder(c: suspend Controller.() -> Unit) {
+    c.startCoroutine(Controller(), EmptyContinuation)
+}
+
+@Test fun runTest() {
+    var result = 0
+
+    builder {
+        result = suspendHere()
+    }
+
+    println(result)
+}

native/native.tests/testData/codegen/coroutines/withReceiver.out

@@ -0,0 +1 @@
+42