Move everything under kotlin-native folder

I was forced to manually do update the following files, because otherwise
they would be ignored according .gitignore settings. Probably they
should be deleted from repo.

Interop/.idea/compiler.xml
Interop/.idea/gradle.xml
Interop/.idea/libraries/Gradle__org_jetbrains_kotlin_kotlin_runtime_1_0_3.xml
Interop/.idea/libraries/Gradle__org_jetbrains_kotlin_kotlin_stdlib_1_0_3.xml
Interop/.idea/modules.xml
Interop/.idea/modules/Indexer/Indexer.iml
Interop/.idea/modules/Runtime/Runtime.iml
Interop/.idea/modules/StubGenerator/StubGenerator.iml
backend.native/backend.native.iml
backend.native/bc.frontend/bc.frontend.iml
backend.native/cli.bc/cli.bc.iml
backend.native/cli.bc/src/org/jetbrains/kotlin/cli/bc/K2Native.kt
backend.native/cli.bc/src/org/jetbrains/kotlin/cli/bc/K2NativeCompilerArguments.kt
backend.native/tests/link/lib/foo.kt
backend.native/tests/link/lib/foo2.kt
backend.native/tests/teamcity-test.property

kotlin-native/backend.native/tests/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")
+    }
+}

kotlin-native/backend.native/tests/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()

kotlin-native/backend.native/tests/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)
+}

kotlin-native/backend.native/tests/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)
+}

kotlin-native/backend.native/tests/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)
+}

kotlin-native/backend.native/tests/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)
+}

kotlin-native/backend.native/tests/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)
+}

kotlin-native/backend.native/tests/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)
+}

kotlin-native/backend.native/tests/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)
+}

kotlin-native/backend.native/tests/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)
+}

kotlin-native/backend.native/tests/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)
+}

kotlin-native/backend.native/tests/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)
+}

kotlin-native/backend.native/tests/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)
+}

kotlin-native/backend.native/tests/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)
+}

kotlin-native/backend.native/tests/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)
+}

kotlin-native/backend.native/tests/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)
+}

kotlin-native/backend.native/tests/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)
+}

kotlin-native/backend.native/tests/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)
+}

kotlin-native/backend.native/tests/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)
+}

kotlin-native/backend.native/tests/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)
+}

kotlin-native/backend.native/tests/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)
+}

kotlin-native/backend.native/tests/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) }
+}

kotlin-native/backend.native/tests/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()) }
+}

kotlin-native/backend.native/tests/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)
+}

kotlin-native/backend.native/tests/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()
+    }
+}

kotlin-native/backend.native/tests/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()
+    }
+}

kotlin-native/backend.native/tests/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)
+}

kotlin-native/backend.native/tests/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))
+}

kotlin-native/backend.native/tests/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 {}
+}

kotlin-native/backend.native/tests/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)
+}

kotlin-native/backend.native/tests/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)
+}

kotlin-native/backend.native/tests/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")
+}

kotlin-native/backend.native/tests/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)
+}

kotlin-native/backend.native/tests/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)
+}

kotlin-native/backend.native/tests/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)
+}

kotlin-native/backend.native/tests/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)
+}