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/inference/builderInference/specialCallsWithLambdas.fir.kt

@@ -147,7 +147,7 @@ fun poll73(): Flow<String> {
 
 fun poll8(): Flow<String> {
     return flow {
-        val inv = {1} in setOf({1f})
+        val inv = {<!ARGUMENT_TYPE_MISMATCH!>1<!>} in setOf({1f})
         <!UNRESOLVED_REFERENCE!>inv<!>()
     }
 }
@@ -175,7 +175,7 @@ fun poll83(): Flow<String> {
 
 fun poll84(): Flow<String> {
     return flow {
-        val inv = {{1}} in setOf({{1f}})
+        val inv = {<!ARGUMENT_TYPE_MISMATCH!>{1}<!>} in setOf({{1f}})
         <!UNRESOLVED_REFERENCE!>inv<!>()
     }
 }

compiler/testData/diagnostics/tests/inference/capturedTypes/expectedTypeMismatchWithInVariance.fir.kt

@@ -5,6 +5,6 @@ fun <T> foo(a1: Array<T>, a2: Array<out T>): T = null!!
 
 fun test(a1: Array<in Int>, a2: Array<Int>) {
 
-    val c: Int = <!INITIALIZER_TYPE_MISMATCH!>foo(a1, a2)<!>
+    val c: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>foo(a1, a2)<!>
 
 }

compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionToUnitForIfAsLastExpressionInLambda.fir.kt

@@ -12,7 +12,7 @@ fun foo(): String? {
     run {
         if (true) return@run
 
-        if (true) return <!RETURN_TYPE_MISMATCH!>Obj()<!> // correct error, type check against return type of function "foo"
+        if (true) return <!RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>Obj()<!> // correct error, type check against return type of function "foo"
     }
 
     run {
@@ -39,4 +39,4 @@ fun foo(): String? {
     }
 
     return ""
-}
+}

compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionToUnitWithNothingType.fir.kt

@@ -42,7 +42,7 @@ fun test(i: Inv<Nothing>, iUnit: Inv<Unit>) {
     }
     launch {
         @Suppress("UNSUPPORTED")
-        <!INAPPLICABLE_CANDIDATE!>run<!><dynamic> { "" }
+        run<dynamic> <!ARGUMENT_TYPE_MISMATCH!>{ "" }<!>
     }
 
     if (iUnit is String) {

compiler/testData/diagnostics/tests/inference/coercionToUnit/coersionWithAnonymousFunctionsAndUnresolved.fir.kt

@@ -52,7 +52,7 @@ fun testUnit() {
 fun testParameter() {
     takeFnToParameter {  }
     takeFnToParameter { Unit }
-    takeFnToParameter { <!UNRESOLVED_REFERENCE!>unresolved<!>() }
+    takeFnToParameter { <!ARGUMENT_TYPE_MISMATCH!><!UNRESOLVED_REFERENCE!>unresolved<!>()<!> }
     takeFnToParameter { if (true) <!UNRESOLVED_REFERENCE!>unresolved<!>() }
     takeFnToParameter {
         if (true) <!UNRESOLVED_REFERENCE!>unresolved<!>() else <!UNRESOLVED_REFERENCE!>unresolved<!>()
@@ -66,7 +66,7 @@ fun testParameter() {
     takeFnToParameter(fun(): Unit { return Unit })
     takeFnToParameter(fun() { if (true) return })
     takeFnToParameter(fun() { if (true) return Unit })
-    takeFnToParameter(fun() = <!UNRESOLVED_REFERENCE!>unresolved<!>())
+    takeFnToParameter(fun() = <!ARGUMENT_TYPE_MISMATCH!><!UNRESOLVED_REFERENCE!>unresolved<!>()<!>)
     takeFnToParameter(fun() { <!UNRESOLVED_REFERENCE!>unresolved<!>() })
     takeFnToParameter(fun(): Unit { <!UNRESOLVED_REFERENCE!>unresolved<!>() })
     takeFnToParameter(fun() { return <!UNRESOLVED_REFERENCE!>unresolved<!>() })

compiler/testData/diagnostics/tests/inference/completionOfMultipleLambdas.fir.kt

@@ -11,7 +11,7 @@ fun test() {
     select3(
         { a: A, b: A -> Unit },
         { b, a -> Unit },
-        { <!UNRESOLVED_REFERENCE!>it<!>; Unit }
+        <!TYPE_MISMATCH!>{ <!UNRESOLVED_REFERENCE!>it<!>; Unit }<!>
     )
 }
 

compiler/testData/diagnostics/tests/inference/constraints/constraintOnFunctionLiteral.fir.kt

@@ -3,10 +3,9 @@ package c
 
 import java.util.ArrayList
 
-fun Array<Int>.toIntArray(): IntArray = this.mapTo(<!ARGUMENT_TYPE_MISMATCH!>IntArray(size)<!>, {it})
+fun Array<Int>.toIntArray(): IntArray = <!RETURN_TYPE_MISMATCH!>this.mapTo(<!ARGUMENT_TYPE_MISMATCH!>IntArray(size)<!>, {it})<!>
 
 fun Array<Int>.toArrayList(): ArrayList<Int> = this.mapTo(ArrayList<Int>(size), {it})
 
 public fun <T, R, C: MutableCollection<in R>> Array<out T>.mapTo(result: C, transform : (T) -> R) : C =
         throw Exception("$result $transform")
-

compiler/testData/diagnostics/tests/inference/constraints/kt6320.fir.kt

@@ -16,6 +16,6 @@ class C<X, Z, Y : X>
 
 class D<X, Z, Y : X>(foo: C<X, Z, Y>) {
     fun test(a: C<Y, Y, Y>) {
-        val d: D<X, Y, Y> = <!INITIALIZER_TYPE_MISMATCH!>D(a)<!>
+        val d: D<X, Y, Y> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>D(a)<!>
     }
 }

compiler/testData/diagnostics/tests/inference/dependantOnVariance.fir.kt

@@ -25,17 +25,17 @@ fun test1(int: Int, any: Any) {
     val a5 : MyList<in Int> = getMyListToWriteTo(any)
 
 
-    val a6 : MyList<in Any> = <!INITIALIZER_TYPE_MISMATCH!>getMyList<Int>(int)<!>
+    val a6 : MyList<in Any> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>getMyList<Int>(int)<!>
     val a7 : MyList<in Any> = getMyList(int)
 
-    val a8 : MyList<in Any> = <!INITIALIZER_TYPE_MISMATCH!>getMyListToReadFrom<Int>(int)<!>
-    val a9 : MyList<in Any> = <!INITIALIZER_TYPE_MISMATCH!>getMyListToReadFrom(int)<!>
+    val a8 : MyList<in Any> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>getMyListToReadFrom<Int>(int)<!>
+    val a9 : MyList<in Any> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>getMyListToReadFrom(int)<!>
 
-    val a10 : MyList<out Int> = <!INITIALIZER_TYPE_MISMATCH!>getMyList<Any>(any)<!>
-    val a11 : MyList<out Int> = <!INITIALIZER_TYPE_MISMATCH!>getMyList(any)<!>
+    val a10 : MyList<out Int> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>getMyList<Any>(any)<!>
+    val a11 : MyList<out Int> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>getMyList(any)<!>
 
-    val a12 : MyList<out Int> = <!INITIALIZER_TYPE_MISMATCH!>getMyListToWriteTo<Any>(any)<!>
-    val a13 : MyList<out Int> = <!INITIALIZER_TYPE_MISMATCH!>getMyListToWriteTo(any)<!>
+    val a12 : MyList<out Int> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>getMyListToWriteTo<Any>(any)<!>
+    val a13 : MyList<out Int> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>getMyListToWriteTo(any)<!>
 
     useMyList(getMyList(int), int)
     useMyList(getMyList(any), int)

compiler/testData/diagnostics/tests/inference/kt1293.fir.kt

@@ -5,7 +5,7 @@ package kt1293
 
 fun main() {
     val intArray = arrayOfNulls<Int>(10)
-    val i : Int = <!INITIALIZER_TYPE_MISMATCH!>intArray[0]<!>
+    val i : Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>intArray[0]<!>
     requiresInt(<!ARGUMENT_TYPE_MISMATCH!>intArray[0]<!>)
 }
 

compiler/testData/diagnostics/tests/inference/kt28654.fir.kt

@@ -2,7 +2,7 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE
 // Related issue: KT-28654
 
-fun <K> select(): K = <!RETURN_TYPE_MISMATCH!>run { }<!>
+fun <K> select(): K = <!RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>run { }<!>
 
 fun test() {
     val x: Int = select()

compiler/testData/diagnostics/tests/inference/nonFunctionalExpectedTypeForLambdaArgument.fir.kt

@@ -15,7 +15,7 @@ fun testAny() {
 
 fun testAnyCall() {
     callAny {
-        error -> <!UNRESOLVED_REFERENCE!>error<!>()
+        error -> <!ARGUMENT_TYPE_MISMATCH!><!UNRESOLVED_REFERENCE!>error<!>()<!>
     }
 }
 
@@ -27,7 +27,7 @@ fun testParam() {
 
 fun testParamCall() {
     callParam {
-        param -> <!UNRESOLVED_REFERENCE!>param<!>()
+        param -> <!ARGUMENT_TYPE_MISMATCH!><!UNRESOLVED_REFERENCE!>param<!>()<!>
     }
 }
 

compiler/testData/diagnostics/tests/inference/regressions/kt1127.fir.kt

@@ -6,5 +6,5 @@ package d
 fun <T> asList(t: T) : List<T>? {}
 
 fun main() {
-    val list : List<String> = <!INITIALIZER_TYPE_MISMATCH!>asList("")<!>
+    val list : List<String> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>asList("")<!>
 }

compiler/testData/diagnostics/tests/inference/regressions/kt2741.fir.kt

@@ -9,5 +9,5 @@ fun <T> _arrayList(vararg values: T) : List<T> = throw Exception()
 class _Pair<A>(val a: A)
 
 fun test() {
-    _arrayList(_Pair(1))._sortBy { it -> <!UNRESOLVED_REFERENCE!>xxx<!> }
+    _arrayList(_Pair(1))._sortBy { it -> <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>xxx<!> }
 }

compiler/testData/diagnostics/tests/inference/regressions/kt2841.fir.kt

@@ -0,0 +1,17 @@
+// !WITH_NEW_INFERENCE
+
+package a
+
+interface Closeable {}
+class C : Closeable {}
+
+public inline fun <T: Closeable, R> T.use1(block: (T)-> R) : R {
+    return block(this)
+}
+
+fun main() {
+    C().use1 {
+        w ->  // ERROR here
+        <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>x<!>
+    }
+}

compiler/testData/diagnostics/tests/inference/regressions/kt2841.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // !WITH_NEW_INFERENCE
 
 package a

compiler/testData/diagnostics/tests/inference/regressions/kt2841_it.fir.kt

@@ -0,0 +1,20 @@
+// !WITH_NEW_INFERENCE
+
+package a
+
+interface Closeable {
+    fun close() {}
+}
+
+class C : Closeable
+
+public inline fun <T: Closeable, R> T.use(block: (t: T)-> R) : R {
+    return block(this)
+}
+
+fun test() {
+    C().use {
+        it.close()
+        <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>x<!>
+    }
+}

compiler/testData/diagnostics/tests/inference/regressions/kt2841_it.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // !WITH_NEW_INFERENCE
 
 package a
@@ -18,4 +17,4 @@ fun test() {
         it.close()
         <!UNRESOLVED_REFERENCE!>x<!>
     }
-}
+}

compiler/testData/diagnostics/tests/inference/regressions/kt2841_it_this.fir.kt

@@ -0,0 +1,21 @@
+// !WITH_NEW_INFERENCE
+
+package a
+
+interface Closeable {
+    fun close() {}
+}
+
+class C : Closeable
+
+public inline fun <T: Closeable, R> use(t: T, block: T.(T)-> R) : R {
+    return t.block(t)
+}
+
+fun test() {
+    use(C()) {
+        this.close()
+        it.close()
+        <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>xx<!>
+    }
+}

compiler/testData/diagnostics/tests/inference/regressions/kt2841_it_this.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // !WITH_NEW_INFERENCE
 
 package a
@@ -19,4 +18,4 @@ fun test() {
         it.close()
         <!UNRESOLVED_REFERENCE!>xx<!>
     }
-}
+}

compiler/testData/diagnostics/tests/inference/regressions/kt2841_this.fir.kt

@@ -0,0 +1,20 @@
+// !WITH_NEW_INFERENCE
+
+package a
+
+interface Closeable {
+    fun close() {}
+}
+
+class C : Closeable
+
+public inline fun <T: Closeable, R> T.use(block: T.()-> R) : R {
+    return this.block()
+}
+
+fun test() {
+    C().use {
+        this.close()
+        <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>x<!>
+    }
+}

compiler/testData/diagnostics/tests/inference/regressions/kt2841_this.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // !WITH_NEW_INFERENCE
 
 package a
@@ -18,4 +17,4 @@ fun test() {
         this.close()
         <!UNRESOLVED_REFERENCE!>x<!>
     }
-}
+}

compiler/testData/diagnostics/tests/inference/regressions/kt2883.fir.kt

@@ -22,12 +22,12 @@ fun test() {
 
     doAction { bar(12) }
 
-    val u: Unit =  <!INITIALIZER_TYPE_MISMATCH!>bar(11)<!>
+    val u: Unit =  <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>bar(11)<!>
 }
 
 fun testWithoutInference(col: MutableCollection<Int>) {
 
     doAction { col.add(2) }
 
-    val u: Unit = <!INITIALIZER_TYPE_MISMATCH!>col.add(2)<!>
+    val u: Unit = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>col.add(2)<!>
 }

compiler/testData/diagnostics/tests/inference/reportingImprovements/FunctionPlaceholder.fir.kt

@@ -7,9 +7,9 @@ fun <T, R> foo(a: A<T, R>) = a
 fun <T, R> bar(f: (T) -> R) = f
 
 fun test() {
-    foo { <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>it<!> }
-    foo { x -> <!ARGUMENT_TYPE_MISMATCH!>x<!>}
-    foo { x: Int -> <!ARGUMENT_TYPE_MISMATCH!>x<!>}
+    foo <!ARGUMENT_TYPE_MISMATCH!>{ <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>it<!> }<!>
+    foo <!ARGUMENT_TYPE_MISMATCH!>{ x -> x}<!>
+    foo <!ARGUMENT_TYPE_MISMATCH!>{ x: Int -> x}<!>
 
     bar { it <!UNRESOLVED_REFERENCE!>+<!> 1 }
     bar { x -> x <!UNRESOLVED_REFERENCE!>+<!> 1}

compiler/testData/diagnostics/tests/inference/reportingImprovements/NoAmbiguityForDifferentFunctionTypes.fir.kt

@@ -0,0 +1,17 @@
+// !WITH_NEW_INFERENCE
+
+package a
+
+interface Closeable {}
+class C : Closeable {}
+
+fun <T: Closeable, R> T.foo(block: (T)-> R) = block
+
+fun <T: Closeable, R> T.foo(block: (T, T)-> R) = block
+
+fun main() {
+    C().foo { // no ambiguity here
+        www ->
+        <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>xs<!>
+    }
+}

compiler/testData/diagnostics/tests/inference/reportingImprovements/NoAmbiguityForDifferentFunctionTypes.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // !WITH_NEW_INFERENCE
 
 package a