JVM: Suspend conversion for function references

compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/adaptedWithCoercionToUnit.kt

@@ -0,0 +1,28 @@
+// !LANGUAGE: +SuspendConversion
+// WITH_RUNTIME
+// WITH_COROUTINES
+// IGNORE_BACKEND_FIR: JVM_IR
+
+import helpers.*
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+fun runSuspend(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+var test = "failed"
+
+fun foo(s: String): String {
+    test = s + "K"
+    return test
+}
+
+suspend fun invokeSuspend(fn: suspend (String) -> Unit, arg: String) = fn.invoke(arg)
+
+fun box(): String {
+    runSuspend {
+        invokeSuspend(::foo, "O")
+    }
+    return test
+}

compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/adaptedWithDefaultArguments.kt

@@ -0,0 +1,24 @@
+// !LANGUAGE: +SuspendConversion
+// WITH_RUNTIME
+// WITH_COROUTINES
+// IGNORE_BACKEND_FIR: JVM_IR
+
+import helpers.*
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+fun runSuspend(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+fun foo(s1: String, s2: String = "K"): String = s1 + s2
+
+suspend fun invokeSuspend(fn: suspend (String) -> String, arg: String) = fn.invoke(arg)
+
+fun box(): String {
+    var test = "failed"
+    runSuspend {
+        test = invokeSuspend(::foo, "O")
+    }
+    return test
+}

compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/adaptedWithVarargs.kt

@@ -0,0 +1,24 @@
+// !LANGUAGE: +SuspendConversion
+// WITH_RUNTIME
+// WITH_COROUTINES
+// IGNORE_BACKEND_FIR: JVM_IR
+
+import helpers.*
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+fun runSuspend(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+fun foo(vararg ss: String): String = ss[0] + "K"
+
+suspend fun invokeSuspend(fn: suspend (String) -> String, arg: String) = fn.invoke(arg)
+
+fun box(): String {
+    var test = "failed"
+    runSuspend {
+        test = invokeSuspend(::foo, "O")
+    }
+    return test
+}

compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/bound.kt

@@ -0,0 +1,30 @@
+// !LANGUAGE: +SuspendConversion
+// WITH_RUNTIME
+// WITH_COROUTINES
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// ^ this test hangs on JS_IR (even if it's IGNOREd)
+// IGNORE_BACKEND: JVM_IR
+
+import helpers.*
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+
+fun runSuspend(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+class C {
+    var test = "failed"
+
+    fun foo() {
+        test = "OK"
+    }
+}
+
+fun box(): String {
+    val c = C()
+    runSuspend(c::foo)
+    return c.test
+}

compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/crossInline.kt

@@ -0,0 +1,25 @@
+// !LANGUAGE: +SuspendConversion
+// WITH_RUNTIME
+// WITH_COROUTINES
+// IGNORE_BACKEND_FIR: JVM_IR
+
+import helpers.*
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+fun runSuspend(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+var test = "failed"
+
+fun foo() { test = "OK" }
+
+inline suspend fun invokeSuspend(crossinline fn: suspend () -> Unit) = suspend { fn() }
+
+fun box(): String {
+    runSuspend {
+        invokeSuspend(::foo)()
+    }
+    return test
+}

compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/inlineAdaptedWithCoercionToUnit.kt

@@ -0,0 +1,28 @@
+// !LANGUAGE: +SuspendConversion
+// WITH_RUNTIME
+// WITH_COROUTINES
+// IGNORE_BACKEND_FIR: JVM_IR
+
+import helpers.*
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+fun runSuspend(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+var test = "failed"
+
+fun foo(s: String): String {
+    test = s + "K"
+    return test
+}
+
+inline suspend fun invokeSuspend(fn: suspend (String) -> Unit, arg: String) = fn.invoke(arg)
+
+fun box(): String {
+    runSuspend {
+        invokeSuspend(::foo, "O")
+    }
+    return test
+}

compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/inlineAdaptedWithDefaultArguments.kt

@@ -0,0 +1,24 @@
+// !LANGUAGE: +SuspendConversion
+// WITH_RUNTIME
+// WITH_COROUTINES
+// IGNORE_BACKEND_FIR: JVM_IR
+
+import helpers.*
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+fun runSuspend(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+fun foo(s1: String, s2: String = "K"): String = s1 + s2
+
+inline suspend fun invokeSuspend(fn: suspend (String) -> String, arg: String) = fn.invoke(arg)
+
+fun box(): String {
+    var test = "failed"
+    runSuspend {
+        test = invokeSuspend(::foo, "O")
+    }
+    return test
+}

compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/inlineAdaptedWithVarargs.kt

@@ -0,0 +1,24 @@
+// !LANGUAGE: +SuspendConversion
+// WITH_RUNTIME
+// WITH_COROUTINES
+// IGNORE_BACKEND_FIR: JVM_IR
+
+import helpers.*
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+fun runSuspend(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+fun foo(vararg ss: String): String = ss[0] + "K"
+
+inline suspend fun invokeSuspend(fn: suspend (String) -> String, arg: String) = fn.invoke(arg)
+
+fun box(): String {
+    var test = "failed"
+    runSuspend {
+        test = invokeSuspend(::foo, "O")
+    }
+    return test
+}

compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/inlineBound.kt

@@ -0,0 +1,34 @@
+// !LANGUAGE: +SuspendConversion
+// WITH_RUNTIME
+// WITH_COROUTINES
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// ^ this test hangs on JS_IR (even if it's IGNOREd)
+// IGNORE_BACKEND: JVM_IR
+
+import helpers.*
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+
+fun runSuspend(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+inline suspend fun invokeSuspend(fn: suspend () -> Unit) = fn()
+
+class C {
+    var test = "failed"
+
+    fun foo() {
+        test = "OK"
+    }
+}
+
+fun box(): String {
+    val c = C()
+    runSuspend {
+        invokeSuspend(c::foo)
+    }
+    return c.test
+}

compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/inlineSimple.kt

@@ -0,0 +1,27 @@
+// !LANGUAGE: +SuspendConversion
+// WITH_RUNTIME
+// WITH_COROUTINES
+// IGNORE_BACKEND_FIR: JVM_IR
+// IGNORE_BACKEND: JS
+
+import helpers.*
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+
+fun runSuspend(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+var test = "failed"
+
+fun foo() { test = "OK" }
+
+inline suspend fun invokeSuspend(fn: suspend () -> Unit) { fn() }
+
+fun box(): String {
+    runSuspend {
+        invokeSuspend(::foo)
+    }
+    return test
+}

compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/inlineWithParameters.kt

@@ -0,0 +1,24 @@
+// !LANGUAGE: +SuspendConversion
+// WITH_RUNTIME
+// WITH_COROUTINES
+// IGNORE_BACKEND_FIR: JVM_IR
+
+import helpers.*
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+fun runSuspend(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+fun foo(s: String): String = s + "K"
+
+inline suspend fun invokeSuspend(fn: suspend (String) -> String, arg: String) = fn.invoke(arg)
+
+fun box(): String {
+    var test = "failed"
+    runSuspend {
+        test = invokeSuspend(::foo, "O")
+    }
+    return test
+}

compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/simple.kt

@@ -0,0 +1,22 @@
+// !LANGUAGE: +SuspendConversion
+// WITH_RUNTIME
+// WITH_COROUTINES
+// IGNORE_BACKEND_FIR: JVM_IR
+
+import helpers.*
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+
+fun runSuspend(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+var test = "failed"
+
+fun foo() { test = "OK" }
+
+fun box(): String {
+    runSuspend(::foo)
+    return test
+}

compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/withParameters.kt

@@ -0,0 +1,24 @@
+// !LANGUAGE: +SuspendConversion
+// WITH_RUNTIME
+// WITH_COROUTINES
+// IGNORE_BACKEND_FIR: JVM_IR
+
+import helpers.*
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+fun runSuspend(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+fun foo(s: String): String = s + "K"
+
+suspend fun invokeSuspend(fn: suspend (String) -> String, arg: String) = fn.invoke(arg)
+
+fun box(): String {
+    var test = "failed"
+    runSuspend {
+        test = invokeSuspend(::foo, "O")
+    }
+    return test
+}