HL API: Fix argument mapping for lambda arguments (+ more tests).

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirCallResolver.kt

@@ -180,10 +180,10 @@ internal class KtFirCallResolver(
         val ktArgumentMapping = LinkedHashMap<KtExpression, KtValueParameterSymbol>()
         argumentMapping?.let {
             fun FirExpression.findKtExpression(): KtExpression? {
-                // For spread and named arguments, the source is the KtValueArgument.
+                // For spread, named, and lambda arguments, the source is the KtValueArgument.
                 // For other arguments (including array indices), the source is the KtExpression.
                 return when (this) {
-                    is FirNamedArgumentExpression, is FirSpreadArgumentExpression ->
+                    is FirNamedArgumentExpression, is FirSpreadArgumentExpression, is FirLambdaArgumentExpression ->
                         realPsi.safeAs<KtValueArgument>()?.getArgumentExpression()
                     else -> realPsi as? KtExpression
                 }

idea/idea-frontend-fir/testData/analysisSession/resolveCall/functionCallWithLambdaArgument.kt

@@ -0,0 +1,7 @@
+fun function(a: Int, b: (String) -> Boolean) {}
+
+fun call() {
+    <expr>function(1) { s -> true }</expr>
+}
+
+// CALL: KtFunctionCall: targetFunction = /function(a: kotlin.Int, b: (kotlin.String) -> kotlin.Boolean): kotlin.Unit

idea/idea-frontend-fir/testData/analysisSession/resolveCall/functionCallWithLambdaArgument.txt

@@ -0,0 +1,3 @@
+KtFunctionCall:
+argumentMapping = { 1 -> (a: kotlin.Int), { s -> true } -> (b: kotlin.Function1<kotlin.String, kotlin.Boolean>) }
+targetFunction = /function(a: kotlin.Int, b: kotlin.Function1<kotlin.String, kotlin.Boolean>): kotlin.Unit

idea/idea-frontend-fir/testData/analysisSession/resolveCall/functionCallWithNamedArgument.kt

@@ -0,0 +1,7 @@
+fun function(a: Int, b: String) {}
+
+fun call() {
+    <expr>function(b = "foo", a = 1)</expr>
+}
+
+// CALL: KtFunctionCall: targetFunction = /function(a: kotlin.Int, b: kotlin.String): kotlin.Unit

idea/idea-frontend-fir/testData/analysisSession/resolveCall/functionCallWithNamedArgument.txt

@@ -0,0 +1,3 @@
+KtFunctionCall:
+argumentMapping = { "foo" -> (b: kotlin.String), 1 -> (a: kotlin.Int) }
+targetFunction = /function(a: kotlin.Int, b: kotlin.String): kotlin.Unit

idea/idea-frontend-fir/testData/analysisSession/resolveCall/functionCallWithNonTrailingLambdaArgument.kt

@@ -0,0 +1,7 @@
+fun function(a: Int, b: (String) -> Boolean) {}
+
+fun call() {
+    <expr>function(1, { s -> true })</expr>
+}
+
+// CALL: KtFunctionCall: targetFunction = /function(a: kotlin.Int, b: (String) -> Boolean): kotlin.Unit

idea/idea-frontend-fir/testData/analysisSession/resolveCall/functionCallWithNonTrailingLambdaArgument.txt

@@ -0,0 +1,3 @@
+KtFunctionCall:
+argumentMapping = { 1 -> (a: kotlin.Int), { s -> true } -> (b: kotlin.Function1<kotlin.String, kotlin.Boolean>) }
+targetFunction = /function(a: kotlin.Int, b: kotlin.Function1<kotlin.String, kotlin.Boolean>): kotlin.Unit

idea/idea-frontend-fir/testData/analysisSession/resolveCall/functionCallWithSpreadArgument.kt

@@ -0,0 +1,8 @@
+fun function(vararg a: Int) {}
+
+fun call() {
+    val args = intArrayOf(1, 2, 3)
+    <expr>function(*args)</expr>
+}
+
+// CALL: KtFunctionCall: targetFunction = /function(vararg a: kotlin.IntArray): kotlin.Unit

idea/idea-frontend-fir/testData/analysisSession/resolveCall/functionCallWithSpreadArgument.txt

@@ -0,0 +1,3 @@
+KtFunctionCall:
+argumentMapping = { args -> (vararg a: kotlin.IntArray) }
+targetFunction = /function(vararg a: kotlin.IntArray): kotlin.Unit

idea/idea-frontend-fir/testData/analysisSession/resolveCall/functionCallWithVarargArgument.kt

@@ -0,0 +1,7 @@
+fun function(vararg a: Int) {}
+
+fun call() {
+    <expr>function(1, 2, 3)</expr>
+}
+
+// CALL: KtFunctionCall: targetFunction = /function(vararg a: kotlin.IntArray): kotlin.Unit

idea/idea-frontend-fir/testData/analysisSession/resolveCall/functionCallWithVarargArgument.txt

@@ -0,0 +1,3 @@
+KtFunctionCall:
+argumentMapping = { 1 -> (vararg a: kotlin.IntArray), 2 -> (vararg a: kotlin.IntArray), 3 -> (vararg a: kotlin.IntArray) }
+targetFunction = /function(vararg a: kotlin.IntArray): kotlin.Unit

idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/fir/frontend/api/fir/AbstractResolveCallTest.kt

@@ -61,13 +61,11 @@ private fun KtCall.stringRepresentation(): String {
                 append("<receiver>: ${receiver.type.render()}")
                 if (valueParameters.isNotEmpty()) append(", ")
             }
-            valueParameters.joinTo(this) { parameter ->
+            valueParameters.joinTo(this) { it.stringValue() }
-                "${parameter.name}: ${parameter.annotatedType.type.render()}"
-            }
             append(")")
             append(": ${annotatedType.type.render()}")
         }
-        is KtValueParameterSymbol -> "$name: ${annotatedType.type.render()}"
+        is KtValueParameterSymbol -> "${if (isVararg) "vararg " else ""}$name: ${annotatedType.type.render()}"
         is KtSuccessCallTarget -> symbol.stringValue()
         is KtErrorCallTarget -> "ERR<${this.diagnostic.defaultMessage}, [${candidates.joinToString { it.stringValue() }}]>"
         is Boolean -> toString()

idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/fir/frontend/api/fir/ResolveCallTestGenerated.java

@@ -54,6 +54,36 @@ public class ResolveCallTestGenerated extends AbstractResolveCallTest {
         runTest("idea/idea-frontend-fir/testData/analysisSession/resolveCall/functionCallInTheSameFile.kt");
     }
 
+    @Test
+    @TestMetadata("functionCallWithLambdaArgument.kt")
+    public void testFunctionCallWithLambdaArgument() throws Exception {
+        runTest("idea/idea-frontend-fir/testData/analysisSession/resolveCall/functionCallWithLambdaArgument.kt");
+    }
+
+    @Test
+    @TestMetadata("functionCallWithNamedArgument.kt")
+    public void testFunctionCallWithNamedArgument() throws Exception {
+        runTest("idea/idea-frontend-fir/testData/analysisSession/resolveCall/functionCallWithNamedArgument.kt");
+    }
+
+    @Test
+    @TestMetadata("functionCallWithNonTrailingLambdaArgument.kt")
+    public void testFunctionCallWithNonTrailingLambdaArgument() throws Exception {
+        runTest("idea/idea-frontend-fir/testData/analysisSession/resolveCall/functionCallWithNonTrailingLambdaArgument.kt");
+    }
+
+    @Test
+    @TestMetadata("functionCallWithSpreadArgument.kt")
+    public void testFunctionCallWithSpreadArgument() throws Exception {
+        runTest("idea/idea-frontend-fir/testData/analysisSession/resolveCall/functionCallWithSpreadArgument.kt");
+    }
+
+    @Test
+    @TestMetadata("functionCallWithVarargArgument.kt")
+    public void testFunctionCallWithVarargArgument() throws Exception {
+        runTest("idea/idea-frontend-fir/testData/analysisSession/resolveCall/functionCallWithVarargArgument.kt");
+    }
+
     @Test
     @TestMetadata("functionWithReceiverCall.kt")
     public void testFunctionWithReceiverCall() throws Exception {