improved reporting TYPE_MISMATCH error for function literals

(introduced EXPECTED_PARAMETER_TYPE_MISMATCH, EXPECTED_RETURN_TYPE_MISMATCH, EXPECTED_PARAMETERS_NUMBER_MISMATCH
instead of reporting TYPE_MISMATCH on the whole function literal)

compiler/testData/diagnostics/tests/AutoCreatedIt.kt

@@ -2,17 +2,17 @@ fun text() {
     "direct:a" to "mock:a"
     "direct:a" on {it.body == "<hello/>"} to "mock:a"
     "direct:a" on {it -> it.body == "<hello/>"} to "mock:a"
-    bar <!TYPE_MISMATCH!>{1}<!>
-    bar <!TYPE_MISMATCH!>{<!UNRESOLVED_REFERENCE!>it<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> 1}<!>
+    bar <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!>1}
+    bar <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!><!UNRESOLVED_REFERENCE!>it<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> 1}
     bar {it, it1 -> it}
 
     bar1 {1}
     bar1 {it + 1}
 
-    bar2 <!TYPE_MISMATCH!>{<!TYPE_MISMATCH!><!>}<!>
+    bar2 {<!TYPE_MISMATCH!><!>}
     bar2 {1}
     bar2 {<!UNRESOLVED_REFERENCE!>it<!>}
-    bar2 <!TYPE_MISMATCH!>{<!CANNOT_INFER_PARAMETER_TYPE!>it<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>it<!>}<!>
+    bar2 {<!EXPECTED_PARAMETERS_NUMBER_MISMATCH, CANNOT_INFER_PARAMETER_TYPE!>it<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>it<!>}
 }
 
 fun bar(<!UNUSED_PARAMETER!>f<!> :  (Int, Int) -> Int) {}

compiler/testData/diagnostics/tests/FunctionCalleeExpressions.kt

@@ -34,8 +34,8 @@ fun main(args : Array<String>) {
     foo2()({})
     foo2()<!TOO_MANY_ARGUMENTS, DANGLING_FUNCTION_LITERAL_ARGUMENT_SUSPECTED!>{}<!>
     (foo2()){}
-    (foo2())<!TYPE_MISMATCH!>{<!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> }<!>
-    foo2()(<!TYPE_MISMATCH!>{<!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> }<!>)
+    (foo2()){<!EXPECTED_PARAMETERS_NUMBER_MISMATCH, CANNOT_INFER_PARAMETER_TYPE!>x<!> -> }
+    foo2()({<!EXPECTED_PARAMETERS_NUMBER_MISMATCH, CANNOT_INFER_PARAMETER_TYPE!>x<!> -> })
 
     val a = fooT1(1)()
     a : Int

compiler/testData/diagnostics/tests/functionLiterals/ExpectedParameterTypeMismatchVariance.kt

@@ -0,0 +1,19 @@
+package a
+
+trait Super
+trait Trait : Super
+class Sub : Trait
+
+fun foo(f: (Trait) -> Trait) = f
+
+fun test(s: Sub) {
+    foo {
+        (<!EXPECTED_PARAMETER_TYPE_MISMATCH!>t: Super<!>): <!EXPECTED_RETURN_TYPE_MISMATCH!>Sub<!> -> s
+    }
+    foo {
+        (t: Trait): Trait -> s
+    }
+    foo {
+        (t: Sub): Super -> s
+    }
+}

compiler/testData/diagnostics/tests/functionLiterals/ExpectedParametersTypesMismatch.kt

@@ -0,0 +1,47 @@
+package a
+
+fun foo0(f: () -> String) = f
+fun foo1(f: (Int) -> String) = f
+fun foo2(f: (Int, String) -> String) = f
+
+fun test1() {
+    foo0 {
+        ""
+    }
+    foo0 {
+        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>(s: String)<!> -> ""
+    }
+    foo0 {
+        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!CANNOT_INFER_PARAMETER_TYPE!>x<!>, <!CANNOT_INFER_PARAMETER_TYPE!>y<!><!> -> ""
+    }
+    foo0 {
+        (): <!EXPECTED_RETURN_TYPE_MISMATCH!>Int<!> -> 42
+    }
+
+    foo1 {
+        ""
+    }
+    foo1 {
+        (<!EXPECTED_PARAMETER_TYPE_MISMATCH!>s: String<!>) -> ""
+    }
+    foo1 {
+        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>x, <!CANNOT_INFER_PARAMETER_TYPE!>y<!><!> -> ""
+    }
+    foo1 {
+        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>()<!>: <!EXPECTED_RETURN_TYPE_MISMATCH!>Int<!> -> 42
+    }
+
+
+    foo2 <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!>
+        ""
+    }
+    foo2 {
+        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>(<!EXPECTED_PARAMETER_TYPE_MISMATCH!>s: String<!>)<!> -> ""
+    }
+    foo2 {
+        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>x<!> -> ""
+    }
+    foo2 {
+        <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>()<!>: <!EXPECTED_RETURN_TYPE_MISMATCH!>Int<!> -> 42
+    }
+}

compiler/testData/diagnostics/tests/regressions/kt352.kt

@@ -2,18 +2,18 @@
 
 package kt352
 
-val f : (Any) -> Unit = <!TYPE_MISMATCH!>{ () : Unit -> }<!>  //type mismatch
+val f : (Any) -> Unit = { <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>()<!> : Unit -> }  //type mismatch
 
 fun foo() {
-    val <!UNUSED_VARIABLE!>f<!> : (Any) -> Unit = <!TYPE_MISMATCH!>{ () : Unit -> }<!>  //!!! no error
+    val <!UNUSED_VARIABLE!>f<!> : (Any) -> Unit = { <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>()<!> : Unit -> }  //!!! no error
 }
 
 class A() {
-    val f : (Any) -> Unit = <!TYPE_MISMATCH!>{ () : Unit -> }<!>  //type mismatch
+    val f : (Any) -> Unit = { <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>()<!> : Unit -> }  //type mismatch
 }
 
 //more tests
-val g : () -> Unit = <!TYPE_MISMATCH!>{ (): Int -> 42 }<!>
+val g : () -> Unit = { (): <!EXPECTED_RETURN_TYPE_MISMATCH!>Int<!> -> 42 }
 
 val h : () -> Unit = { doSmth() }
 
@@ -24,4 +24,4 @@ val testIt : (Any) -> Unit = {
     if (it is String) {
         doSmth(it)
     }
-}
+}