[Tests] KT-74529 call functions with context parameters in reflect

Author: aShalygin

analysis/low-level-api-fir/tests-gen/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLBlackBoxTestGenerated.java

@@ -0,0 +1,26 @@
+// LANGUAGE: +ContextParameters
+// OPT_IN: kotlin.ExperimentalContextParameters
+// TARGET_BACKEND: JVM
+// IGNORE_BACKEND_K1: ANY
+// WITH_REFLECT
+
+import kotlin.reflect.KCallable
+
+class TestClass {
+    context(a: (() -> String) -> String) fun superFunWithContextLambda(b: () -> String) = a.invoke(b)
+}
+
+fun box(): String {
+
+    val f = TestClass::class.members.single { it.name == "superFunWithContextLambda" } as KCallable<String>
+    val contextParam: Function1<Function0<String>, String> = { a: () -> String ->
+        a.invoke()
+    }
+
+
+    return f.call(
+        TestClass(),
+        contextParam,
+        { "OK" }
+    )
+}

analysis/low-level-api-fir/tests-gen/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLReversedBlackBoxTestGenerated.java

@@ -0,0 +1,52 @@
+// LANGUAGE: +ContextParameters
+// OPT_IN: kotlin.ExperimentalContextParameters
+// TARGET_BACKEND: JVM
+// IGNORE_BACKEND_K1: ANY
+// WITH_REFLECT
+// WITH_COROUTINES
+
+
+import helpers.*
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+import kotlin.reflect.KCallable
+import kotlin.reflect.full.callSuspend
+
+suspend fun suspendHere(): String = suspendCoroutineUninterceptedOrReturn { x ->
+    x.resume("")
+    COROUTINE_SUSPENDED
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+class TestClass {
+    suspend context(a: suspend (suspend () -> String) -> String) fun superSuspendWithSuspendContextLambda(b: suspend () -> String): String {
+        suspendHere()
+        return a.invoke(b)
+    }
+}
+
+fun box(): String {
+    var result = ""
+
+    val f = TestClass::class.members.single { it.name == "superSuspendWithSuspendContextLambda" } as KCallable<String>
+    val contextParam: SuspendFunction1<SuspendFunction0<String>, String> = { a: suspend () -> String ->
+        suspendHere()
+        a.invoke()
+    }
+
+    builder {
+        f.callSuspend(
+            TestClass(),
+            contextParam,
+            suspend {
+                suspendHere()
+                result += "OK"
+            }
+        )
+    }
+
+    return result
+}

compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirLightTreeBlackBoxCodegenTestGenerated.java

@@ -0,0 +1,28 @@
+// LANGUAGE: +ContextParameters
+// OPT_IN: kotlin.ExperimentalContextParameters
+// TARGET_BACKEND: JVM
+// IGNORE_BACKEND_K1: ANY
+// WITH_REFLECT
+
+import kotlin.reflect.KCallable
+
+class TestClass {
+    context(a: (() -> String) -> String) fun superFunWithContextLambda(b: () -> String) = a.invoke(b)
+}
+
+fun box(): String {
+
+    val f = TestClass::class.members.single { it.name == "superFunWithContextLambda" } as KCallable<String>
+    val contextParam: Function1<Function0<String>, String> = { a: () -> String ->
+        a.invoke()
+    }
+
+
+    return f.callBy(
+        mapOf(
+            f.parameters[0] to TestClass(),
+            f.parameters[1] to contextParam,
+            f.parameters[2] to { "OK" } as Function0<String>
+        )
+    )
+}

compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirPsiBlackBoxCodegenTestGenerated.java

@@ -0,0 +1,53 @@
+// LANGUAGE: +ContextParameters
+// OPT_IN: kotlin.ExperimentalContextParameters
+// TARGET_BACKEND: JVM
+// IGNORE_BACKEND_K1: ANY
+// WITH_REFLECT
+// WITH_COROUTINES
+
+
+import helpers.*
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+import kotlin.reflect.KCallable
+import kotlin.reflect.full.callSuspendBy
+
+suspend fun suspendHere(): String = suspendCoroutineUninterceptedOrReturn { x ->
+    x.resume("")
+    COROUTINE_SUSPENDED
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+class TestClass {
+    suspend context(a: suspend (suspend () -> String) -> String) fun superSuspendWithSuspendContextLambda(b: suspend () -> String): String {
+        suspendHere()
+        return a.invoke(b)
+    }
+}
+
+fun box(): String {
+    var result = ""
+
+    val f = TestClass::class.members.single { it.name == "superSuspendWithSuspendContextLambda" } as KCallable<String>
+    val contextParam: SuspendFunction1<SuspendFunction0<String>, String> = { a: suspend () -> String ->
+        suspendHere()
+        a.invoke()
+    }
+
+    builder {
+        f.callSuspendBy(
+            mapOf(
+                f.parameters[0] to TestClass(),
+                f.parameters[1] to contextParam,
+                f.parameters[2] to suspend {
+                    suspendHere()
+                    result += "OK"
+                } as SuspendFunction0<String>
+            )
+        )
+    }
+    return result
+}

compiler/testData/codegen/box/reflection/call/contextParameters.kt

@@ -9,12 +9,12 @@ import kotlin.reflect.KParameter.Kind.*
 import kotlin.test.assertEquals
 
 class Z {
-    context(_: String, _: Number)
+    context(_: String, named: Int, _: Number)
     fun f() {}
 }
 
 fun box(): String {
     val f = Z::class.members.single { it.name == "f" }
-    assertEquals(listOf(null, null, null), f.parameters.map { it.name })
+    assertEquals(listOf(null, null, "named", null), f.parameters.map { it.name })
     return "OK"
 }

compiler/testData/codegen/box/reflection/call/contextParametersSuspend.kt

@@ -0,0 +1,15 @@
+// LANGUAGE: +ContextParameters
+// OPT_IN: kotlin.ExperimentalContextParameters
+// TARGET_BACKEND: JVM
+// IGNORE_BACKEND_K1: ANY
+// WITH_REFLECT
+
+import kotlin.reflect.KProperty
+
+class TestClass {
+    context(s: String, i: Int) val Any?.prop: String
+        get() = if(i == 2) this.toString() + s else "FAIL"
+}
+
+fun box() = (TestClass::class.members.single { it.name == "prop" } as KProperty<*>)
+    .getter.call(TestClass(), "K", 2, "O")