Support crossinline suspend lambda as parameter of inline function

Use fake continuation instead of ALOAD 0 while inlining
Do not generate state machine for inner lambdas and inner objects,
which capture crossinline suspend lambda.

 #KT-19159: Fixed

compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/crossinlineSuspendValueParameter.kt

@@ -0,0 +1,2 @@
+// SKIP_TXT
+inline fun foo(crossinline <!WRONG_MODIFIER_TARGET!>suspend<!> <!UNUSED_PARAMETER!>c<!>: () -> Unit) {}

compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineOrdinaryOfCrossinlineOrdinary.kt

@@ -0,0 +1,37 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+// SKIP_TXT
+import kotlin.coroutines.experimental.*
+import kotlin.coroutines.experimental.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resume(<!PARAMETER_NAME_CHANGED_ON_OVERRIDE!>data<!>: Any?) {}
+    override fun resumeWithException(exception: Throwable) { throw exception }
+}
+
+// Function is NOT suspend
+// parameter is crossinline
+// parameter is NOT suspend
+// Block is allowed to be called inside the body of owner inline function
+// Block is allowed to be called from nested classes/lambdas (as common crossinlines)
+// It is NOT possible to call startCoroutine on the parameter
+// suspend calls NOT possible inside lambda matching to the parameter
+
+inline fun test(crossinline c: () -> Unit) {
+    c()
+    val o = object: Runnable {
+        override fun run() {
+            c()
+        }
+    }
+    val l = { c() }
+    c.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>startCoroutine<!>(EmptyContinuation)
+}
+
+suspend fun calculate() = "OK"
+
+fun box() {
+    test {
+        <!ILLEGAL_SUSPEND_FUNCTION_CALL!>calculate<!>()
+    }
+}

compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineOrdinaryOfCrossinlineSuspend.kt

@@ -0,0 +1,41 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER -NOTHING_TO_INLINE
+// SKIP_TXT
+import kotlin.coroutines.experimental.*
+import kotlin.coroutines.experimental.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resume(<!PARAMETER_NAME_CHANGED_ON_OVERRIDE!>data<!>: Any?) {}
+    override fun resumeWithException(exception: Throwable) { throw exception }
+}
+
+interface SuspendRunnable {
+    suspend fun run()
+}
+
+// Function is NOT suspend
+// parameter is crossinline
+// parameter is suspend
+// Block is NOT allowed to be called inside the body of owner inline function
+// Block is allowed to be called from nested classes/lambdas (as common crossinlines)
+// It is NOT possible to call startCoroutine on the parameter
+// suspend calls possible inside lambda matching to the parameter
+
+inline fun test(crossinline c: suspend () -> Unit)  {
+    <!ILLEGAL_SUSPEND_FUNCTION_CALL!>c<!>()
+    val o = object : SuspendRunnable {
+        override suspend fun run() {
+            c()
+        }
+    }
+    val l: suspend () -> Unit = { c() }
+    <!USAGE_IS_NOT_INLINABLE!>c<!>.startCoroutine(EmptyContinuation)
+}
+
+suspend fun calculate() = "OK"
+
+fun box() {
+    test {
+        calculate()
+    }
+}

compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineOrdinaryOfNoinlineOrdinary.kt

@@ -0,0 +1,36 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -NOTHING_TO_INLINE
+// SKIP_TXT
+import kotlin.coroutines.experimental.*
+import kotlin.coroutines.experimental.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resume(<!PARAMETER_NAME_CHANGED_ON_OVERRIDE!>data<!>: Any?) {}
+    override fun resumeWithException(exception: Throwable) { throw exception }
+}
+
+// Function is NOT suspend
+// parameter is noinline
+// parameter is NOT suspend
+// Block is allowed to be called inside the body of owner inline function
+// Block is allowed to be called from nested classes/lambdas (as common crossinlines)
+// It is NOT possible to call startCoroutine on the parameter
+// suspend calls NOT possible inside lambda matching to the parameter
+inline fun test(noinline c: () -> Unit) {
+    c()
+    val o = object: Runnable {
+        override fun run() {
+            c()
+        }
+    }
+    val l = { c() }
+    c.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>startCoroutine<!>(EmptyContinuation)
+}
+
+suspend fun calculate() = "OK"
+
+fun box() {
+    test {
+        <!ILLEGAL_SUSPEND_FUNCTION_CALL!>calculate<!>()
+    }
+}

compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineOrdinaryOfNoinlineSuspend.kt

@@ -0,0 +1,41 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER -NOTHING_TO_INLINE
+// SKIP_TXT
+import kotlin.coroutines.experimental.*
+import kotlin.coroutines.experimental.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resume(<!PARAMETER_NAME_CHANGED_ON_OVERRIDE!>data<!>: Any?) {}
+    override fun resumeWithException(exception: Throwable) { throw exception }
+}
+
+interface SuspendRunnable {
+    suspend fun run()
+}
+
+// Function is NOT suspend
+// parameter is noinline
+// parameter is suspend
+// Block is NOT allowed to be called inside the body of owner inline function
+// Block is allowed to be called from nested classes/lambdas (as common crossinlines)
+// It is possible to call startCoroutine on the parameter
+// suspend calls possible inside lambda matching to the parameter
+
+inline fun test(noinline c: suspend () -> Unit)  {
+    <!ILLEGAL_SUSPEND_FUNCTION_CALL!>c<!>()
+    val o = object : SuspendRunnable {
+        override suspend fun run() {
+            c()
+        }
+    }
+    val l: suspend () -> Unit = { c() }
+    c.startCoroutine(EmptyContinuation)
+}
+
+suspend fun calculate() = "OK"
+
+fun box() {
+    test {
+        calculate()
+    }
+}

compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineOrdinaryOfOrdinary.kt

@@ -0,0 +1,43 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+// SKIP_TXT
+import kotlin.coroutines.experimental.*
+import kotlin.coroutines.experimental.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resume(<!PARAMETER_NAME_CHANGED_ON_OVERRIDE!>data<!>: Any?) {}
+    override fun resumeWithException(exception: Throwable) { throw exception }
+}
+
+// Function is NOT suspend
+// parameter is inline
+// parameter is NOT suspend
+// Block is allowed to be called inside the body of owner inline function
+// Block is NOT allowed to be called from nested classes/lambdas (as common crossinlines)
+// It is NOT possible to call startCoroutine on the parameter
+// suspend calls possible inside lambda matching to the parameter
+
+inline fun test(c: () -> Unit) {
+    c()
+    val o = object : Runnable {
+        override fun run() {
+            <!NON_LOCAL_RETURN_NOT_ALLOWED!>c<!>()
+        }
+    }
+    val l = { <!NON_LOCAL_RETURN_NOT_ALLOWED!>c<!>() }
+    c.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>startCoroutine<!>(EmptyContinuation)
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+suspend fun calculate() = "OK"
+
+fun box() {
+    builder {
+        test {
+            calculate()
+        }
+    }
+}

compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineOrdinaryOfSuspend.kt

@@ -0,0 +1,43 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -NOTHING_TO_INLINE -UNUSED_PARAMETER
+// SKIP_TXT
+import kotlin.coroutines.experimental.*
+import kotlin.coroutines.experimental.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resume(<!PARAMETER_NAME_CHANGED_ON_OVERRIDE!>data<!>: Any?) {}
+    override fun resumeWithException(exception: Throwable) { throw exception }
+}
+
+interface SuspendRunnable {
+    suspend fun run()
+}
+
+// Function is NOT suspend
+// parameter is inline
+// parameter is suspend
+// Block is NOT allowed to be called inside the body of owner inline function
+// Block is NOT allowed to be called from nested classes/lambdas (as common crossinlines)
+// It is NOT possible to call startCoroutine on the parameter
+// suspend calls possible inside lambda matching to the parameter
+
+inline fun test(<!INLINE_SUSPEND_FUNCTION_TYPE_UNSUPPORTED!>c: suspend () -> Unit<!>) {
+    <!ILLEGAL_SUSPEND_FUNCTION_CALL!>c<!>()
+    val o = object: SuspendRunnable {
+        override suspend fun run() {
+            <!NON_LOCAL_RETURN_NOT_ALLOWED!>c<!>()
+        }
+    }
+    val l: suspend () -> Unit = { <!NON_LOCAL_RETURN_NOT_ALLOWED!>c<!>() }
+    <!USAGE_IS_NOT_INLINABLE!>c<!>.startCoroutine(EmptyContinuation)
+}
+
+fun builder(c: suspend () -> Unit) {}
+
+suspend fun calculate() = "OK"
+
+fun box() {
+    test {
+        calculate()
+    }
+}

compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineSuspendOfCrossinlineOrdinary.kt

@@ -0,0 +1,42 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+// SKIP_TXT
+import kotlin.coroutines.experimental.*
+import kotlin.coroutines.experimental.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resume(<!PARAMETER_NAME_CHANGED_ON_OVERRIDE!>data<!>: Any?) {}
+    override fun resumeWithException(exception: Throwable) { throw exception }
+}
+
+// Function is suspend
+// parameter is crossinline
+// parameter is NOT suspend
+// Block is allowed to be called inside the body of owner inline function
+// Block is allowed to be called from nested classes/lambdas (as common crossinlines)
+// It is NOT possible to call startCoroutine on the parameter
+// suspend calls NOT possible inside lambda matching to the parameter
+suspend inline fun test(crossinline c: () -> Unit) {
+    c()
+    val o = object : Runnable {
+        override fun run() {
+            c()
+        }
+    }
+    val l = { c() }
+    c.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>startCoroutine<!>(EmptyContinuation)
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+suspend fun calculate() = "OK"
+
+fun box() {
+    builder {
+        test {
+            <!NON_LOCAL_SUSPENSION_POINT!>calculate<!>()
+        }
+    }
+}

compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineSuspendOfCrossinlineSuspend.kt

@@ -0,0 +1,44 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER -NOTHING_TO_INLINE
+// SKIP_TXT
+import kotlin.coroutines.experimental.*
+import kotlin.coroutines.experimental.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resume(<!PARAMETER_NAME_CHANGED_ON_OVERRIDE!>data<!>: Any?) {}
+    override fun resumeWithException(exception: Throwable) { throw exception }
+}
+
+interface SuspendRunnable {
+    suspend fun run()
+}
+
+// Function is suspend
+// parameter is crossinline
+// parameter is suspend
+// Block is allowed to be called inside the body of owner inline function
+// Block is allowed to be called from nested classes/lambdas (as common crossinlines)
+// It is NOT possible to call startCoroutine on the parameter
+// suspend calls possible inside lambda matching to the parameter
+suspend inline fun test(crossinline c: suspend () -> Unit) {
+    c()
+    val o = object : SuspendRunnable {
+        override suspend fun run() {
+            c()
+        }
+    }
+    val l: suspend () -> Unit = { c() }
+    <!USAGE_IS_NOT_INLINABLE!>c<!>.startCoroutine(EmptyContinuation)
+}
+
+fun builder(c: suspend () -> Unit) {}
+
+suspend fun calculate() = "OK"
+
+fun box() {
+    builder {
+        test {
+            calculate()
+        }
+    }
+}

compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineSuspendOfNoinlineOrdinary.kt

@@ -0,0 +1,42 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -NOTHING_TO_INLINE
+// SKIP_TXT
+import kotlin.coroutines.experimental.*
+import kotlin.coroutines.experimental.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resume(<!PARAMETER_NAME_CHANGED_ON_OVERRIDE!>data<!>: Any?) {}
+    override fun resumeWithException(exception: Throwable) { throw exception }
+}
+
+// Function is suspend
+// parameter is noinline
+// parameter is NOT suspend
+// Block is allowed to be called inside the body of owner inline function
+// Block is allowed to be called from nested classes/lambdas (as common crossinlines)
+// It is NOT possible to call startCoroutine on the parameter
+// suspend calls NOT possible inside lambda matching to the parameter
+suspend inline fun test(noinline c: () -> Unit) {
+    c()
+    val o = object : Runnable {
+        override fun run() {
+            c()
+        }
+    }
+    val l = { c() }
+    c.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>startCoroutine<!>(EmptyContinuation)
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+suspend fun calculate() = "OK"
+
+fun box() {
+    builder {
+        test {
+            <!NON_LOCAL_SUSPENSION_POINT!>calculate<!>()
+        }
+    }
+}

compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineSuspendOfNoinlineSuspend.kt

@@ -0,0 +1,44 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -NOTHING_TO_INLINE -UNUSED_PARAMETER
+// SKIP_TXT
+import kotlin.coroutines.experimental.*
+import kotlin.coroutines.experimental.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resume(<!PARAMETER_NAME_CHANGED_ON_OVERRIDE!>data<!>: Any?) {}
+    override fun resumeWithException(exception: Throwable) { throw exception }
+}
+
+interface SuspendRunnable {
+    suspend fun run()
+}
+
+// Function is suspend
+// parameter is noinline
+// parameter is suspend
+// Block is allowed to be called inside the body of owner inline function
+// Block is allowed to be called from nested classes/lambdas (as common crossinlines)
+// It is possible to call startCoroutine on the parameter
+// suspend calls possible inside lambda matching to the parameter
+suspend inline fun test(noinline c: suspend () -> Unit) {
+    c()
+    val o = object : SuspendRunnable {
+        override suspend fun run() {
+            c()
+        }
+    }
+    val l: suspend () -> Unit = { c() }
+    c.startCoroutine(EmptyContinuation)
+}
+
+fun builder(c: suspend () -> Unit) {}
+
+suspend fun calculate() = "OK"
+
+fun box() {
+    builder {
+        test {
+            calculate()
+        }
+    }
+}

compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineSuspendOfOrdinary.kt

@@ -0,0 +1,40 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
+// SKIP_TXT
+import kotlin.coroutines.experimental.*
+import kotlin.coroutines.experimental.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resume(<!PARAMETER_NAME_CHANGED_ON_OVERRIDE!>data<!>: Any?) {}
+    override fun resumeWithException(exception: Throwable) { throw exception }
+}
+
+// Function is suspend
+// parameter is inline
+// parameter is NOT suspend
+// Block is allowed to be called inside the body of owner inline function
+// Block is NOT allowed to be called from nested classes/lambdas (as common crossinlines)
+// It is NOT possible to call startCoroutine on the parameter
+// suspend calls possible inside lambda matching to the parameter
+suspend inline fun test(c: () -> Unit) {
+    c()
+    val o = object: Runnable {
+        override fun run() {
+            <!NON_LOCAL_RETURN_NOT_ALLOWED!>c<!>()
+        }
+    }
+    val l = { <!NON_LOCAL_RETURN_NOT_ALLOWED!>c<!>() }
+    c.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>startCoroutine<!>(EmptyContinuation)
+}
+
+suspend fun calculate() = "OK"
+
+fun builder(c: suspend () -> Unit) {}
+
+fun box() {
+    builder {
+        test {
+            calculate()
+        }
+    }
+}

compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineSuspendOfSuspend.kt

@@ -0,0 +1,45 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER -NOTHING_TO_INLINE
+// SKIP_TXT
+import kotlin.coroutines.experimental.*
+import kotlin.coroutines.experimental.intrinsics.*
+
+open class EmptyContinuation(override val context: CoroutineContext = EmptyCoroutineContext) : Continuation<Any?> {
+    companion object : EmptyContinuation()
+    override fun resume(<!PARAMETER_NAME_CHANGED_ON_OVERRIDE!>data<!>: Any?) {}
+    override fun resumeWithException(exception: Throwable) { throw exception }
+}
+
+interface SuspendRunnable {
+    suspend fun run()
+}
+
+// Function is suspend
+// parameter is inline
+// parameter is suspend
+// Block is allowed to be called inside the body of owner inline function
+// Block is NOT allowed to be called from nested classes/lambdas (as common crossinlines)
+// It is NOT possible to call startCoroutine on the parameter
+// suspend calls possible inside lambda matching to the parameter
+suspend inline fun test(<!REDUNDANT_INLINE_SUSPEND_FUNCTION_TYPE!>c: suspend () -> Unit<!>) {
+    c()
+    val o = object: SuspendRunnable {
+        override suspend fun run() {
+            <!NON_LOCAL_RETURN_NOT_ALLOWED!>c<!>()
+        }
+    }
+    val l: suspend () -> Unit = { <!NON_LOCAL_RETURN_NOT_ALLOWED!>c<!>() }
+    <!USAGE_IS_NOT_INLINABLE!>c<!>.startCoroutine(EmptyContinuation)
+}
+
+fun builder(c: suspend () -> Unit) {
+}
+
+suspend fun calculate() = "OK"
+
+fun box() {
+    builder {
+        test {
+            calculate()
+        }
+    }
+}

compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/inline.kt

@@ -1,18 +1,18 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 // SKIP_TXT
-<!NOTHING_TO_INLINE!>inline<!> fun foo1(<!INLINE_SUSPEND_FUNCTION_TYPE_UNSUPPORTED!>x: suspend () -> Unit<!>) {}
-<!NOTHING_TO_INLINE!>inline<!> fun foo2(<!INLINE_SUSPEND_FUNCTION_TYPE_UNSUPPORTED!>crossinline x: suspend () -> Unit<!>) {}
+inline fun foo1(<!INLINE_SUSPEND_FUNCTION_TYPE_UNSUPPORTED!>x: suspend () -> Unit<!>) {}
+inline fun foo2(crossinline x: suspend () -> Unit) {}
 <!NOTHING_TO_INLINE!>inline<!> fun foo3(noinline x: suspend () -> Unit) {}
 <!NOTHING_TO_INLINE!>inline<!> fun foo4(<!INCOMPATIBLE_MODIFIERS!>noinline<!> <!INCOMPATIBLE_MODIFIERS!>crossinline<!> x: suspend () -> Unit) {}
 
-suspend inline fun bar1(<!INLINE_SUSPEND_FUNCTION_TYPE_UNSUPPORTED!>x: suspend () -> Unit<!>) {}
-suspend inline fun bar2(<!INLINE_SUSPEND_FUNCTION_TYPE_UNSUPPORTED!>crossinline x: suspend () -> Unit<!>) {}
+suspend inline fun bar1(<!REDUNDANT_INLINE_SUSPEND_FUNCTION_TYPE!>x: suspend () -> Unit<!>) {}
+suspend inline fun bar2(crossinline x: suspend () -> Unit) {}
 suspend inline fun bar3(noinline x: suspend () -> Unit) {}
 suspend inline fun bar4(<!INCOMPATIBLE_MODIFIERS!>noinline<!> <!INCOMPATIBLE_MODIFIERS!>crossinline<!> x: suspend () -> Unit) {}
 
 suspend fun baz() {
     foo1 {
-        <!RETURN_NOT_ALLOWED!>return@baz<!>
+        return@baz
     }
 
     foo2 {
@@ -28,7 +28,7 @@ suspend fun baz() {
     }
 
     bar1 {
-        <!RETURN_NOT_ALLOWED!>return@baz<!>
+        return@baz
     }
 
     bar2 {