FIR: Update test data (repeated diagnostics)

They are a bit redundant, but it needs additional work to be done
to avoid them

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

@@ -16,6 +16,6 @@ fun test(s: Sub) {
         t: Trait -> s
     }
 
-    foo(fun(t: Sub) = <!ARGUMENT_TYPE_MISMATCH!>s<!>)
-    foo(fun(t): Super = <!ARGUMENT_TYPE_MISMATCH!>s<!>)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>fun(t: Sub) = s<!>)
+    foo(<!ARGUMENT_TYPE_MISMATCH!>fun(t): Super = s<!>)
 }

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

@@ -9,37 +9,37 @@ fun test1() {
     foo0 {
         ""
     }
-    foo0 {
-        s: String-> <!ARGUMENT_TYPE_MISMATCH!>""<!>
-    }
-    foo0 {
-        <!CANNOT_INFER_PARAMETER_TYPE!>x<!>, <!CANNOT_INFER_PARAMETER_TYPE!>y<!> -> <!ARGUMENT_TYPE_MISMATCH!>""<!>
-    }
+    foo0 <!ARGUMENT_TYPE_MISMATCH!>{
+        s: String-> ""
+    }<!>
+    foo0 <!ARGUMENT_TYPE_MISMATCH!>{
+        <!CANNOT_INFER_PARAMETER_TYPE!>x<!>, <!CANNOT_INFER_PARAMETER_TYPE!>y<!> -> ""
+    }<!>
 
     foo1 {
         ""
     }
+    foo1 <!ARGUMENT_TYPE_MISMATCH!>{
+        s: String -> ""
+    }<!>
+    foo1 <!ARGUMENT_TYPE_MISMATCH!>{
+        x, <!CANNOT_INFER_PARAMETER_TYPE!>y<!> -> ""
+    }<!>
     foo1 {
-        s: String -> <!ARGUMENT_TYPE_MISMATCH!>""<!>
-    }
-    foo1 {
-        x, <!CANNOT_INFER_PARAMETER_TYPE!>y<!> -> <!ARGUMENT_TYPE_MISMATCH!>""<!>
-    }
-    foo1 {
-        -> 42
+        -> <!ARGUMENT_TYPE_MISMATCH!>42<!>
     }
 
 
-    foo2 {
-        <!ARGUMENT_TYPE_MISMATCH!>""<!>
-    }
-    foo2 {
-        s: String -> <!ARGUMENT_TYPE_MISMATCH!>""<!>
-    }
-    foo2 {
-        x -> <!ARGUMENT_TYPE_MISMATCH!>""<!>
-    }
-    foo2 {
+    foo2 <!ARGUMENT_TYPE_MISMATCH!>{
+        ""
+    }<!>
+    foo2 <!ARGUMENT_TYPE_MISMATCH!>{
+        s: String -> ""
+    }<!>
+    foo2 <!ARGUMENT_TYPE_MISMATCH!>{
+        x -> ""
+    }<!>
+    foo2 <!ARGUMENT_TYPE_MISMATCH!>{
          -> <!ARGUMENT_TYPE_MISMATCH!>42<!>
-    }
+    }<!>
 }

compiler/testData/diagnostics/tests/functionLiterals/assignmentOperationInLambdaWithExpectedType.fir.kt

@@ -12,5 +12,5 @@ fun test(bal: Array<Int>) {
 
     val e: Unit = run { bar += 4 }
 
-    val f: Int = <!INITIALIZER_TYPE_MISMATCH!>run { bar += 4 }<!>
+    val f: Int = <!INITIALIZER_TYPE_MISMATCH!>run <!TYPE_MISMATCH!>{ bar += 4 }<!><!>
 }

compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/inferredFunctionalType.fir.kt

@@ -27,8 +27,8 @@ fun bar(aList: List<A>) {
         b checkType { _<String>() }
     }
 
-    aList.<!INAPPLICABLE_CANDIDATE!>foo<!> { (a, b): B ->
+    aList.foo <!ARGUMENT_TYPE_MISMATCH!>{ (a, b): B ->
         b checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
         a checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
-    }
+    }<!>
 }