Added tests for argument mapping

compiler/testData/resolvedCalls/arguments/functionLiterals/chainedLambdas.kt

@@ -0,0 +1,12 @@
+// !ONLY_ARGUMENTS
+// !CALL: foo
+// !ARG_1: ArgumentMatch(t : Int, SUCCESS)
+// !ARG_2: ArgumentMatch(f : (Int) -> String, SUCCESS)
+// !ARG_3: ArgumentMatch(g : (String) -> Int, SUCCESS)
+
+fun <T, S, R> foo(t: T, f: (T) -> S, g: (S) -> R) {}
+
+
+fun test() {
+    foo(1, { x -> "$x"}, { y -> y.length })
+}

compiler/testData/resolvedCalls/arguments/functionLiterals/notInferredLambdaReturnType.kt

@@ -0,0 +1,10 @@
+// !ONLY_ARGUMENTS
+// !CALL: foo
+// !ARG_1: ArgumentMatch(f : () -> ???, SUCCESS)
+
+fun <T> foo(f: () -> T) {}
+
+
+fun test() {
+    foo { b }
+}

compiler/testData/resolvedCalls/arguments/functionLiterals/notInferredLambdaType.kt

@@ -0,0 +1,10 @@
+// !ONLY_ARGUMENTS
+// !CALL: foo
+// !ARG_1: ArgumentMatch(f : (???) -> String, SUCCESS)
+
+fun <T> foo(f: (T) -> String) {}
+
+
+fun test() {
+    foo { x -> "$x"}
+}

compiler/testData/resolvedCalls/arguments/functionLiterals/simpleGenericLambda.kt

@@ -0,0 +1,10 @@
+// !ONLY_ARGUMENTS
+// !CALL: foo
+// !ARG_1: ArgumentMatch(f : (Int) -> String, SUCCESS)
+
+fun <T> foo(f: (T) -> String) {}
+
+
+fun test() {
+    foo { (x: Int) -> "$x"}
+}

compiler/testData/resolvedCalls/arguments/functionLiterals/simpleLambda.kt

@@ -0,0 +1,10 @@
+// !ONLY_ARGUMENTS
+// !CALL: foo
+// !ARG_1: ArgumentMatch(f : (Int) -> String, SUCCESS)
+
+fun foo(f: (Int) -> String) {}
+
+
+fun test() {
+    foo { x -> "$x"}
+}

compiler/testData/resolvedCalls/arguments/functionLiterals/unmappedLambda.kt

@@ -0,0 +1,9 @@
+// !ONLY_ARGUMENTS
+// !CALL: foo
+// !ARG_1: ArgumentUnmapped
+
+fun foo() {}
+
+fun test() {
+    foo { x -> "$x"}
+}

compiler/testData/resolvedCalls/arguments/genericCalls/inferredParameter.kt

@@ -0,0 +1,12 @@
+// !ONLY_ARGUMENTS
+// !CALL: foo
+// !ARG_1: 11 = ArgumentMatch(t : Comparable<out Any?>, SUCCESS)
+// !ARG_2: ls = ArgumentMatch(l : List<Comparable<out Any?>>, SUCCESS)
+
+fun <T> foo(t: T, l: List<T>) {}
+
+fun use(vararg a: Any?) = a
+
+fun test(a: Any, ls: List<String>) {
+    use(foo(11, ls))
+}

compiler/testData/resolvedCalls/arguments/genericCalls/simpleGeneric.kt

@@ -0,0 +1,11 @@
+// !ONLY_ARGUMENTS
+// !CALL: foo
+// !ARG_1: A() = ArgumentMatch(t : A, SUCCESS)
+
+class A {}
+
+fun <T> foo(t: T) {}
+
+fun bar() {
+    foo(A())
+}

compiler/testData/resolvedCalls/arguments/genericCalls/uninferredParameter.kt

@@ -0,0 +1,12 @@
+// !ONLY_ARGUMENTS
+// !CALL: foo
+// !ARG_1: 11 = ArgumentMatch(t : ???, SUCCESS)
+// !ARG_2: ls = ArgumentMatch(l : MutableList<???>, SUCCESS)
+
+fun <T> foo(t: T, l: MutableList<T>) {}
+
+fun use(vararg a: Any?) = a
+
+fun test(ls: MutableList<String>) {
+    use(foo(11, ls))
+}

compiler/testData/resolvedCalls/arguments/genericCalls/uninferredParameterTypeMismatch.kt

@@ -0,0 +1,9 @@
+// !ONLY_ARGUMENTS
+// !CALL: foo
+// !ARG_1: 11 = ArgumentMatch(l : List<???>, TYPE_MISMATCH)
+
+fun <T> foo(l: List<T>) {}
+
+fun test() {
+    foo(11)
+}

compiler/testData/resolvedCalls/arguments/namedArguments/positionedAfterNamed.kt

@@ -0,0 +1,13 @@
+// !ONLY_ARGUMENTS
+// !CALL: foo
+// !ARG_1: B() = ArgumentMatch(b : B, SUCCESS)
+// !ARG_2: A() = ArgumentUnmapped
+
+class A {}
+class B {}
+
+fun foo(a: A, b: B) {}
+
+fun bar() {
+    foo(b = B(), A())
+}

compiler/testData/resolvedCalls/arguments/namedArguments/shiftedArgsMatch.kt

@@ -0,0 +1,13 @@
+// !ONLY_ARGUMENTS
+// !CALL: foo
+// !ARG_1: B() = ArgumentMatch(b : B, SUCCESS)
+// !ARG_2: A() = ArgumentMatch(a : A, SUCCESS)
+
+class A {}
+class B {}
+
+fun foo(a: A, b: B) {}
+
+fun bar() {
+    foo(b = B(), a = A())
+}

compiler/testData/resolvedCalls/arguments/oneArgument/argumentHasNoType.kt

@@ -0,0 +1,11 @@
+// !ONLY_ARGUMENTS
+// !CALL: foo
+// !ARG_1: b = ArgumentMatch(a : A, ARGUMENT_HAS_NO_TYPE)
+
+class A {}
+
+fun foo(a: A) {}
+
+fun bar() {
+    foo(b)
+}

compiler/testData/resolvedCalls/arguments/oneArgument/simpleMatch.kt

@@ -0,0 +1,11 @@
+// !ONLY_ARGUMENTS
+// !CALL: foo
+// !ARG_1: A() = ArgumentMatch(a : A, SUCCESS)
+
+class A {}
+
+fun foo(a: A) {}
+
+fun bar() {
+    foo(A())
+}

compiler/testData/resolvedCalls/arguments/oneArgument/typeMismatch.kt

@@ -0,0 +1,11 @@
+// !ONLY_ARGUMENTS
+// !CALL: foo
+// !ARG_1: "" = ArgumentMatch(a : A, TYPE_MISMATCH)
+
+class A {}
+
+fun foo(a: A) {}
+
+fun bar() {
+    foo("")
+}

compiler/testData/resolvedCalls/arguments/oneArgument/unmappedArgument.kt

@@ -0,0 +1,9 @@
+// !ONLY_ARGUMENTS
+// !CALL: foo
+// !ARG_1: "" = ArgumentUnmapped
+
+fun foo() {}
+
+fun bar() {
+    foo("")
+}

compiler/testData/resolvedCalls/arguments/realExamples/emptyList.kt

@@ -0,0 +1,13 @@
+// !ONLY_ARGUMENTS
+// !CALL: foo
+// !ARG_1: emptyList() = ArgumentMatch(t : List<???>, SUCCESS)
+
+class A {}
+
+fun <T> foo(t: T) {}
+
+fun <T> emptyList(): List<T> = throw Exception()
+
+fun bar() {
+    foo(emptyList())
+}

compiler/testData/resolvedCalls/arguments/realExamples/emptyMutableList.kt

@@ -0,0 +1,13 @@
+// !ONLY_ARGUMENTS
+// !CALL: foo
+// !ARG_1: emptyList() = ArgumentMatch(t : MutableList<???>, SUCCESS)
+
+class A {}
+
+fun <T> foo(t: T) {}
+
+fun <T> emptyList(): MutableList<T> = throw Exception()
+
+fun bar() {
+    foo(emptyList())
+}

compiler/testData/resolvedCalls/arguments/severalCandidates/mostSpecific.kt

@@ -0,0 +1,14 @@
+// !ONLY_ARGUMENTS
+// !CALL: foo
+// !ARG_1: A() = ArgumentMatch(a : A, SUCCESS)
+// !ARG_2: "" = ArgumentMatch(s : String, SUCCESS)
+
+class A {}
+
+fun foo(a: A) {}
+fun foo(a: A, s: String) {}
+fun foo(a: A, any: Any) {}
+
+fun bar() {
+    foo(A(), "")
+}