FIR: Update test data (repeated diagnostics)

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

compiler/fir/analysis-tests/testData/resolve/diagnostics/returnTypeMismatchOnOverride.kt

@@ -57,7 +57,7 @@ open class J() : S() {
 }
 
 open class Base<T : X, Z : T> {
-    open fun kek(): Z = <!RETURN_TYPE_MISMATCH!>Z()<!>
+    open fun kek(): Z = <!RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>Z()<!>
 }
 
 open class GoodDerrived : Base<Y, W>() {

compiler/fir/analysis-tests/testData/resolve/samConversions/genericSam.kt

@@ -21,9 +21,9 @@ fun main() {
         x.toInt().toString()
     }
 
-    JavaUsage.foo2 { x: Int ->
+    JavaUsage.foo2 <!ARGUMENT_TYPE_MISMATCH!>{ x: Int ->
-        <!ARGUMENT_TYPE_MISMATCH!>x.toString()<!>
+        x.toString()
-    }
+    }<!>
 
     JavaUsage.foo3(
         { x ->

compiler/fir/analysis-tests/testData/resolve/samConversions/kotlinSam.kt

@@ -29,10 +29,10 @@ fun main() {
     foo1 { x -> x > 1 }
     foo1(f)
 
-    foo2 { x -> <!ARGUMENT_TYPE_MISMATCH!><!ARGUMENT_TYPE_MISMATCH!>x<!> <!UNRESOLVED_REFERENCE!>><!> 1<!> }
+    foo2 <!ARGUMENT_TYPE_MISMATCH!>{ x -> x <!UNRESOLVED_REFERENCE!>><!> 1 }<!>
     foo2(<!ARGUMENT_TYPE_MISMATCH!>f<!>)
 
-    foo3 { x -> <!ARGUMENT_TYPE_MISMATCH!><!ARGUMENT_TYPE_MISMATCH!>x<!> <!UNRESOLVED_REFERENCE!>><!> 1<!> }
+    foo3 <!ARGUMENT_TYPE_MISMATCH!>{ x -> x <!UNRESOLVED_REFERENCE!>><!> 1 }<!>
     foo3(<!ARGUMENT_TYPE_MISMATCH!>f<!>)
 
     foo4 { x -> x > 1 }

compiler/fir/analysis-tests/testData/resolve/samConversions/notSamBecauseOfSupertype.kt

@@ -18,12 +18,11 @@ public class JavaUsage {
 fun foo(m: MyRunnable) {}
 
 fun main() {
-    JavaUsage.foo {
+    JavaUsage.foo <!ARGUMENT_TYPE_MISMATCH!>{
-            x ->
+            x -> x <!UNRESOLVED_REFERENCE!>><!> 1
-        <!ARGUMENT_TYPE_MISMATCH!><!ARGUMENT_TYPE_MISMATCH!>x<!> <!UNRESOLVED_REFERENCE!>><!> 1<!>
+    }<!>
-    }
 
-    JavaUsage.foo({ <!ARGUMENT_TYPE_MISMATCH!><!UNRESOLVED_REFERENCE!>it<!> > 1<!> })
+    JavaUsage.foo(<!ARGUMENT_TYPE_MISMATCH!>{ <!UNRESOLVED_REFERENCE!>it<!> > 1 }<!>)
 
     val x = { x: Int -> x > 1 }
 

compiler/fir/analysis-tests/testData/resolveWithStdlib/diagnostics/functionReturnTypeMismatchChecker/basic.kt

@@ -12,7 +12,7 @@ fun ok(): Int {
 }
 
 fun okOneLineFunction(): Int = 10 + 1
-fun errorOneLineFunction(): String = <!RETURN_TYPE_MISMATCH!>10 + 1<!>
+fun errorOneLineFunction(): String = <!RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>10 + 1<!>
 
 class A {
     fun bar() {}
@@ -52,4 +52,4 @@ fun blockReturnValueTypeMatch2() : Int {
     if (1 > 2)
     else return <!RETURN_TYPE_MISMATCH!>1.0<!>
     return <!RETURN_TYPE_MISMATCH!>2.0<!>
-}
+}

compiler/testData/cli/jvm/instanceAccessBeforeSuperCall.out

@@ -13,6 +13,9 @@ compiler/testData/cli/jvm/instanceAccessBeforeSuperCall.kt:2:74: error: unresolv
 compiler/testData/cli/jvm/instanceAccessBeforeSuperCall.kt:7:20: error: 'this' is not defined in this context
 class B(other: B = this)
                    ^
+compiler/testData/cli/jvm/instanceAccessBeforeSuperCall.kt:10:32: error: argument type mismatch: actual type is kotlin/Int but kotlin/Function0<TypeVariable(_L)> was expected
+    constructor(x: Int) : this({
+                               ^
 compiler/testData/cli/jvm/instanceAccessBeforeSuperCall.kt:12:9: error: argument type mismatch: actual type is ERROR CLASS: Cannot access ''<this>'' before superclass constructor has been called but TypeVariable(_L) was expected
         this
         ^

compiler/testData/diagnostics/tests/AutoCreatedIt.fir.kt

@@ -3,17 +3,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 {<!ARGUMENT_TYPE_MISMATCH!>1<!>}
+    bar <!ARGUMENT_TYPE_MISMATCH!>{1}<!>
-    bar {<!ARGUMENT_TYPE_MISMATCH!><!UNRESOLVED_REFERENCE!>it<!> + 1<!>}
+    bar <!ARGUMENT_TYPE_MISMATCH!>{<!ARGUMENT_TYPE_MISMATCH!><!UNRESOLVED_REFERENCE!>it<!> + 1<!>}<!>
     bar {it, it1 -> it}
 
     bar1 {1}
     bar1 {it + 1}
 
-    <!INAPPLICABLE_CANDIDATE!>bar2<!> {}
+    bar2 <!ARGUMENT_TYPE_MISMATCH!>{}<!>
     bar2 {1}
     bar2 {<!UNRESOLVED_REFERENCE!>it<!>}
-    bar2 {<!CANNOT_INFER_PARAMETER_TYPE!>it<!> -> <!ARGUMENT_TYPE_MISMATCH!>it<!>}
+    bar2 <!ARGUMENT_TYPE_MISMATCH!>{<!CANNOT_INFER_PARAMETER_TYPE!>it<!> -> it}<!>
 }
 
 fun bar(f :  (Int, Int) -> Int) {}

compiler/testData/diagnostics/tests/Bounds.fir.kt

@@ -21,7 +21,7 @@ package boundsWithSubstitutors
 
   class Pair<A, B>
 
-  abstract class C<T : B<Int>, X :  (B<Char>) -> Pair<B<Any>, B<A>>>() : B<Any>() { // 2 errors
+  abstract class C<T : B<Int>, X :  (B<Char>) -> Pair<B<Any>, B<A>>>() : <!UPPER_BOUND_VIOLATED!>B<Any><!>() { // 2 errors
     val a = B<<!UPPER_BOUND_VIOLATED!>Char<!>>() // error
 
     abstract val x :  (B<Char>) -> B<Any>

compiler/testData/diagnostics/tests/SafeCallNonNullReceiverReturnNull.fir.kt

@@ -3,5 +3,5 @@ fun Int.gg() = null
 
 fun ff() {
     val a: Int = 1
-    val b: Int = <!INITIALIZER_TYPE_MISMATCH!>a<!UNNECESSARY_SAFE_CALL!>?.<!>gg()<!>
+    val b: Int = <!INITIALIZER_TYPE_MISMATCH!>a<!UNNECESSARY_SAFE_CALL!>?.<!><!TYPE_MISMATCH!>gg()<!><!>
 }

compiler/testData/diagnostics/tests/callableReference/generic/argumentAndReturnExpectedType.fir.kt

@@ -18,7 +18,7 @@ fun test1() {
     bar("", 1, ::fooTakeString).checkType { _<Pair<String, Int>>() }
     bar("", "", ::fooReturnInt).checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Pair<String, Any>>() }
 
-    val x: String = <!INITIALIZER_TYPE_MISMATCH!>bar("", "", ::fooReturnInt)<!>
+    val x: String = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>bar("", "", ::fooReturnInt)<!>
 
     baz(Int::toString, ::foo).checkType { _<Pair<Int, String>>() }
 }

compiler/testData/diagnostics/tests/callableReference/generic/genericFunctionsWithNullableTypes.fir.kt

@@ -29,9 +29,9 @@ fun <T> test(x: T) {
     baz(1, null, ::foo)
     baz(null, null, ::foo)
 
-    val s3: Pair<Int, String?> = bar(null, null, ::foo)
+    val s3: Pair<Int, String?> = <!TYPE_MISMATCH, TYPE_MISMATCH!>bar(null, null, ::foo)<!>
-    val s4: Pair<Int?, String> = <!INITIALIZER_TYPE_MISMATCH!>bar(null, null, ::foo)<!>
+    val s4: Pair<Int?, String> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>bar(null, null, ::foo)<!>
 
-    val s5: Pair<Int, String> = <!INITIALIZER_TYPE_MISMATCH!>bar(1, "", ::foo)<!>
+    val s5: Pair<Int, String> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>bar(1, "", ::foo)<!>
     val (a1: Int, b1: String) = <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>bar(1, "", ::foo)<!>
 }

compiler/testData/diagnostics/tests/callableReference/generic/resolutionGenericCallableWithNullableTypes.fir.kt

@@ -17,7 +17,7 @@ fun test1() {
     baz<String>(::foo).checkType { _<String?>() }
     baz<Boolean>(::foo).checkType { _<Boolean?>() }
 
-    val b1: Int = <!INITIALIZER_TYPE_MISMATCH!>baz(::<!UNRESOLVED_REFERENCE!>foo<!>)<!>
+    val b1: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>baz(::<!UNRESOLVED_REFERENCE!>foo<!>)<!>
-    val b2: String = <!INITIALIZER_TYPE_MISMATCH!>baz(::<!UNRESOLVED_REFERENCE!>foo<!>)<!>
+    val b2: String = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>baz(::<!UNRESOLVED_REFERENCE!>foo<!>)<!>
-    val b3: Boolean = <!INITIALIZER_TYPE_MISMATCH!>baz(::<!UNRESOLVED_REFERENCE!>foo<!>)<!>
+    val b3: Boolean = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>baz(::<!UNRESOLVED_REFERENCE!>foo<!>)<!>
 }

compiler/testData/diagnostics/tests/callableReference/unitAdaptationForReferenceCompatibility.fir.kt

@@ -20,6 +20,6 @@ public interface Executor {
 fun f(): String = "test"
 
 class A {
-    fun schedule1(e: Executor): Future<String> = <!RETURN_TYPE_MISMATCH!>e.submit(::f)<!>
+    fun schedule1(e: Executor): Future<String> = <!RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>e.submit(::f)<!>
-    fun schedule2(e: Executor): Future<String> = <!RETURN_TYPE_MISMATCH!>e.submit { f() }<!>
+    fun schedule2(e: Executor): Future<String> = <!RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>e.submit { f() }<!>
-}
+}

compiler/testData/diagnostics/tests/cast/AsInBinaryUnary.fir.kt

@@ -20,12 +20,12 @@ operator fun Impl2.unaryMinus() = Impl2()
 // See also KT-10384: in non-error functions, as is necessary!
 fun add1(x: Impl2, y: Base): Impl1 = x as Base + y
 
-fun error1(x: Impl2, y: Base): Impl1 = <!RETURN_TYPE_MISMATCH!>x + y<!>
+fun error1(x: Impl2, y: Base): Impl1 = <!RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>x + y<!>
 
 fun add2(x: Base, y: Impl2): Impl1 = x + y as Base
 
-fun error2(x: Base, y: Impl2): Impl1 = <!RETURN_TYPE_MISMATCH!>x + y<!>
+fun error2(x: Base, y: Impl2): Impl1 = <!RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>x + y<!>
 
 fun minus3(x: Impl2): Impl1 = -(x as Base)
 
-fun error3(x: Impl2): Impl1 = <!RETURN_TYPE_MISMATCH!>-x<!>
+fun error3(x: Impl2): Impl1 = <!RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>-x<!>

compiler/testData/diagnostics/tests/classLiteral/expressionWithNullableType.fir.kt

@@ -0,0 +1,16 @@
+// FILE: J.java
+
+public interface J {
+    String platformString();
+}
+
+// FILE: test.kt
+
+fun f1(x: Int?): Any = <!EXPRESSION_OF_NULLABLE_TYPE_IN_CLASS_LITERAL_LHS!>x<!>::class
+fun <T> f2(t: T): Any = <!EXPRESSION_OF_NULLABLE_TYPE_IN_CLASS_LITERAL_LHS!>t<!>::class
+fun <T> f21(t: T): Any where T : Any?, T : Comparable<T> = t::class
+fun <S : String?> f3(s: S): Any = <!EXPRESSION_OF_NULLABLE_TYPE_IN_CLASS_LITERAL_LHS!>s<!>::class
+fun <U : Any> f4(u: U?): Any = <!EXPRESSION_OF_NULLABLE_TYPE_IN_CLASS_LITERAL_LHS!>u<!>::class
+fun f5(c: List<*>): Any = <!EXPRESSION_OF_NULLABLE_TYPE_IN_CLASS_LITERAL_LHS, TYPE_MISMATCH!>c[0]<!>::class
+
+fun f6(j: J): Any = j.platformString()::class

compiler/testData/diagnostics/tests/classLiteral/expressionWithNullableType.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // FILE: J.java
 
 public interface J {

compiler/testData/diagnostics/tests/controlStructures/specialConstructsAndPlatformTypes.fir.kt

@@ -12,7 +12,7 @@ public class J {
 val testImplicitExclExcl1: String = J.s
 val testImplicitExclExcl2: String? = J.s
 
-val testImplicitExclExcl3: String = <!INITIALIZER_TYPE_MISMATCH!>J.m[""]<!>
+val testImplicitExclExcl3: String = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>J.m[""]<!>
 val testImplicitExclExcl4: String? = J.m[""]
 
 val testExclExcl1: String = J.s!!

compiler/testData/diagnostics/tests/cyclicHierarchy/kt303.fir.kt

@@ -9,4 +9,4 @@ open class Bar() : <!OTHER_ERROR!>Foo<!>() {
 
 }
 
-val x : Int = <!INITIALIZER_TYPE_MISMATCH!>Foo()<!>
+val x : Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>Foo()<!>

compiler/testData/diagnostics/tests/delegation/clashes/finalMemberOverridden.fir.kt

@@ -53,4 +53,4 @@ class CBarT<T> : IBarT<T> {
 
 <!OVERRIDING_FINAL_MEMBER_BY_DELEGATION!>class Test7<!> : Final(), IBarT<Int> by CBarT<Int>()
 
-<!OVERRIDING_FINAL_MEMBER_BY_DELEGATION!>class Test8<!> : Final(), IBarT<Int> by CBar()
+<!OVERRIDING_FINAL_MEMBER_BY_DELEGATION!>class Test8<!> : Final(), IBarT<Int> by <!TYPE_MISMATCH!>CBar()<!>

compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/severalDelegates.fir.kt

@@ -23,6 +23,6 @@ public abstract class MyClass : Base1, Base2 {
     }
 }
 
-<!DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE!>class A<!> : MyClass(), Base1 by Delegate1(), <!SUPERTYPE_APPEARS_TWICE!>Base1<!> by Delegate2() {
+<!DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE!>class A<!> : MyClass(), Base1 by Delegate1(), <!SUPERTYPE_APPEARS_TWICE!>Base1<!> by <!TYPE_MISMATCH!>Delegate2()<!> {
 
-}
+}

compiler/testData/diagnostics/tests/extensions/extensionMemberInClassObject.fir.kt

@@ -0,0 +1,19 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE
+
+interface JPAEntityClass<D> {
+    fun <T> T.findByName(s: String): D {null!!}
+}
+
+class Foo {
+    companion object : JPAEntityClass<Foo>
+}
+
+fun main() {
+    with("", {
+        <!ARGUMENT_TYPE_MISMATCH!>Foo.<!UNRESOLVED_REFERENCE!>findByName<!>("")<!>
+    })
+    with(Foo) {
+        findByName("")
+    }
+}

compiler/testData/diagnostics/tests/extensions/extensionMemberInClassObject.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 // !WITH_NEW_INFERENCE
 

compiler/testData/diagnostics/tests/functionAsExpression/ReceiverByExpectedType.fir.kt

@@ -1,3 +1,3 @@
 // !WITH_NEW_INFERENCE
 fun foo(f: String.() -> Int) {}
-val test = foo(fun () = <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>length<!>)
+val test = foo(<!ARGUMENT_TYPE_MISMATCH!>fun () = <!UNRESOLVED_REFERENCE!>length<!><!>)

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(<!ARGUMENT_TYPE_MISMATCH!>fun(t: Sub) = s<!>)
-    foo(fun(t): Super = <!ARGUMENT_TYPE_MISMATCH!>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 {
+    foo0 <!ARGUMENT_TYPE_MISMATCH!>{
-        s: String-> <!ARGUMENT_TYPE_MISMATCH!>""<!>
+        s: String-> ""
-    }
+    }<!>
-    foo0 {
+    foo0 <!ARGUMENT_TYPE_MISMATCH!>{
-        <!CANNOT_INFER_PARAMETER_TYPE!>x<!>, <!CANNOT_INFER_PARAMETER_TYPE!>y<!> -> <!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!>""<!>
+        -> <!ARGUMENT_TYPE_MISMATCH!>42<!>
-    }
-    foo1 {
-        x, <!CANNOT_INFER_PARAMETER_TYPE!>y<!> -> <!ARGUMENT_TYPE_MISMATCH!>""<!>
-    }
-    foo1 {
-        -> 42
     }
 
 
-    foo2 {
+    foo2 <!ARGUMENT_TYPE_MISMATCH!>{
-        <!ARGUMENT_TYPE_MISMATCH!>""<!>
+        ""
-    }
+    }<!>
-    foo2 {
+    foo2 <!ARGUMENT_TYPE_MISMATCH!>{
-        s: String -> <!ARGUMENT_TYPE_MISMATCH!>""<!>
+        s: String -> ""
-    }
+    }<!>
-    foo2 {
+    foo2 <!ARGUMENT_TYPE_MISMATCH!>{
-        x -> <!ARGUMENT_TYPE_MISMATCH!>""<!>
+        x -> ""
-    }
+    }<!>
-    foo2 {
+    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>() }
-    }
+    }<!>
 }

compiler/testData/diagnostics/tests/generics/suppressVarianceConflict.fir.kt

@@ -13,5 +13,5 @@ fun foo(x: A<String, Any?>, cs: CharSequence, ls: List<CharSequence>) {
     y.foo(<!ARGUMENT_TYPE_MISMATCH!>cs<!>)
     val s: String = <!INITIALIZER_TYPE_MISMATCH!>y.foo(<!ARGUMENT_TYPE_MISMATCH!>cs<!>, <!ARGUMENT_TYPE_MISMATCH!>ls<!>)<!>
 
-    val ls2: List<String> = <!INITIALIZER_TYPE_MISMATCH!>y.bar()<!>
+    val ls2: List<String> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>y.bar()<!>
 }

compiler/testData/diagnostics/tests/imports/InaccessiblePrivateClass.fir.kt

@@ -14,5 +14,5 @@ package p1
 
 import p2.*
 
-val <!EXPOSED_PROPERTY_TYPE!>x<!>: X = <!INITIALIZER_TYPE_MISMATCH!>X()<!>
+val <!EXPOSED_PROPERTY_TYPE!>x<!>: X = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>X()<!>
 val <!EXPOSED_PROPERTY_TYPE!>y<!>: Y = <!INVISIBLE_REFERENCE!>Y<!>()

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 a8 : MyList<in Any> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>getMyListToReadFrom<Int>(int)<!>
-    val a9 : MyList<in Any> = <!INITIALIZER_TYPE_MISMATCH!>getMyListToReadFrom(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 a10 : MyList<out Int> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>getMyList<Any>(any)<!>
-    val a11 : MyList<out Int> = <!INITIALIZER_TYPE_MISMATCH!>getMyList(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 a12 : MyList<out Int> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>getMyListToWriteTo<Any>(any)<!>
-    val a13 : MyList<out Int> = <!INITIALIZER_TYPE_MISMATCH!>getMyListToWriteTo(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 <!ARGUMENT_TYPE_MISMATCH!>{ <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>it<!> }<!>
-    foo { x -> <!ARGUMENT_TYPE_MISMATCH!>x<!>}
+    foo <!ARGUMENT_TYPE_MISMATCH!>{ x -> x}<!>
-    foo { x: Int -> <!ARGUMENT_TYPE_MISMATCH!>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

compiler/testData/diagnostics/tests/j+k/sam/enhancedSamConstructor.fir.kt

@@ -16,13 +16,13 @@ public interface J2 extends J {
 
 // FILE: main.kt
 fun main() {
-    J { s: String -> <!ARGUMENT_TYPE_MISMATCH!>s<!>} // should be prohibited, because SAM value parameter has nullable type
+    J <!ARGUMENT_TYPE_MISMATCH!>{ s: String -> s}<!> // should be prohibited, because SAM value parameter has nullable type
     J { "" + it<!UNSAFE_CALL!>.<!>length }
-    J { null }
+    J { <!NULL_FOR_NONNULL_TYPE!>null<!> }
-    J { it?.length?.toString() }
+    J { it?.length?.<!ARGUMENT_TYPE_MISMATCH!>toString()<!> }
 
-    J2 { s: String -> <!ARGUMENT_TYPE_MISMATCH!>s<!>}
+    J2 <!ARGUMENT_TYPE_MISMATCH!>{ s: String -> s}<!>
     J2 { "" + it<!UNSAFE_CALL!>.<!>length }
-    J2 { null }
+    J2 { <!NULL_FOR_NONNULL_TYPE!>null<!> }
-    J2 { it?.length?.toString() }
+    J2 { it?.length?.<!ARGUMENT_TYPE_MISMATCH!>toString()<!> }
 }

compiler/testData/diagnostics/tests/library/Collections.fir.kt

@@ -8,7 +8,7 @@ fun <T> testCollection(c: Collection<T>, t: T) {
     val iterator: Iterator<T> = c.iterator()
     c.containsAll(c)
 
-    val mutableIterator: MutableIterator<T> = <!INITIALIZER_TYPE_MISMATCH!>c.iterator()<!>
+    val mutableIterator: MutableIterator<T> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>c.iterator()<!>
     c.<!UNRESOLVED_REFERENCE!>add<!>(t)
     c.<!UNRESOLVED_REFERENCE!>remove<!>(1)
     c.<!UNRESOLVED_REFERENCE!>addAll<!>(c)
@@ -45,9 +45,9 @@ fun <T> testList(l: List<T>, t: T) {
     val value: T = l.<!UNRESOLVED_REFERENCE!>set<!>(1, t)
     l.<!UNRESOLVED_REFERENCE!>add<!>(1, t)
     l.<!UNRESOLVED_REFERENCE!>remove<!>(1)
-    val mutableListIterator: MutableListIterator<T> = <!INITIALIZER_TYPE_MISMATCH!>l.listIterator()<!>
+    val mutableListIterator: MutableListIterator<T> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>l.listIterator()<!>
-    val mutableListIterator1: MutableListIterator<T> = <!INITIALIZER_TYPE_MISMATCH!>l.listIterator(1)<!>
+    val mutableListIterator1: MutableListIterator<T> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>l.listIterator(1)<!>
-    val mutableList: MutableList<T> = <!INITIALIZER_TYPE_MISMATCH!>l.subList(1, 2)<!>
+    val mutableList: MutableList<T> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>l.subList(1, 2)<!>
 }
 
 fun <T> testMutableList(l: MutableList<T>, t: T) {
@@ -66,7 +66,7 @@ fun <T> testSet(s: Set<T>, t: T) {
     val iterator: Iterator<T> = s.iterator()
     s.containsAll(s)
 
-    val mutableIterator: MutableIterator<T> = <!INITIALIZER_TYPE_MISMATCH!>s.iterator()<!>
+    val mutableIterator: MutableIterator<T> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>s.iterator()<!>
     s.<!UNRESOLVED_REFERENCE!>add<!>(t)
     s.<!UNRESOLVED_REFERENCE!>remove<!>(1)
     s.<!UNRESOLVED_REFERENCE!>addAll<!>(s)

compiler/testData/diagnostics/tests/numbers/doublesInSimpleConstraints.fir.kt

@@ -21,5 +21,5 @@ fun test() {
     val d = either(11, 2.3)
     checkSubtype<Any>(d)
 
-    val e: Float = <!INITIALIZER_TYPE_MISMATCH!>id(1)<!>
+    val e: Float = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>id(1)<!>
 }

compiler/testData/diagnostics/tests/regressions/OutProjections.fir.kt

@@ -9,7 +9,7 @@ fun <T> f(expression : T) : G<out T> = G<T>()
 
 fun foo() : G<Point> {
   val p = Point()
-  return <!RETURN_TYPE_MISMATCH!>f<Point>(p)<!>
+  return <!RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>f<Point>(p)<!>
 }
 
 class Out<out T>() {}

compiler/testData/diagnostics/tests/regressions/TypeMismatchOnUnaryOperations.fir.kt

@@ -8,9 +8,9 @@ fun main() {
     val g1 : String = ++v;
     val h : String = v--;
     val h1 : String = --v;
-    val i : String = <!INITIALIZER_TYPE_MISMATCH!>!true<!>;
+    val i : String = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>!true<!>;
     val j : String = <!INITIALIZER_TYPE_MISMATCH!>foo@ true<!>;
     val k : String = <!INITIALIZER_TYPE_MISMATCH!>foo@ bar@ true<!>;
     val l : String = <!INITIALIZER_TYPE_MISMATCH!>-1<!>;
     val m : String = <!INITIALIZER_TYPE_MISMATCH!>+1<!>;
-}
+}

compiler/testData/diagnostics/tests/regressions/kt312.fir.kt

@@ -6,5 +6,5 @@ fun <T> Array<out T>.safeGet(index : Int) : T? {
 }
 
 val args : Array<String> = Array<String>(1, {""})
-val name : String = <!INITIALIZER_TYPE_MISMATCH!>args.safeGet<String>(0)<!> // No error, must be type mismatch
+val name : String = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>args.safeGet<String>(0)<!> // No error, must be type mismatch
 val name1 : String? = args.safeGet(0)

compiler/testData/diagnostics/tests/resolve/overloadConflicts/originalExamples.fir.kt

@@ -8,7 +8,7 @@ fun overloadedFun1(c: Any = "", b: String = "", f: Any = "") = Right
 fun overloadedFun1(b: Any = "", c: Any = "", e: String = "") = Wrong
 
 val test1: Right = overloadedFun1(b = "")
-val test1a: Wrong = <!INITIALIZER_TYPE_MISMATCH!>overloadedFun1(b = "")<!>
+val test1a: Wrong = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>overloadedFun1(b = "")<!>
 
 fun overloadedFun2(a: String, b: Any = "") = Right
 fun overloadedFun2(a: Any, b: String = "") = Wrong

compiler/testData/diagnostics/tests/samConversions/javaMemberAgainstExtension.fir.kt

@@ -16,7 +16,7 @@ fun <T> LiveData<T>.observe(a: Any, observer: (T) -> Unit): Observer<T> {
 }
 
 // FILE: test.kt
-fun <T> test1(r: Runnable, l: LiveData<T>): Observer<T> = <!RETURN_TYPE_MISMATCH!>l.observe(r) {  }<!> // partial conversion
+fun <T> test1(r: Runnable, l: LiveData<T>): Observer<T> = <!RETURN_TYPE_MISMATCH, TYPE_MISMATCH!>l.observe(r) {  }<!> // partial conversion
 
 fun <T> test2(r: Runnable, o: Observer<T>, l: LiveData<T>) {
     val a = l.observe(r, o) // no conversion
@@ -28,4 +28,3 @@ fun <T> test2(r: Runnable, o: Observer<T>, l: LiveData<T>) {
     val c = l.observe({}) {} // conversion for all arguments
     <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit")!>c<!>
 }
-

compiler/testData/diagnostics/tests/scopes/inheritance/methodsPriority.fir.kt

@@ -20,7 +20,7 @@ fun test() {
 
     class B: A() {
         init {
-            val a: Int = <!INITIALIZER_TYPE_MISMATCH!>foo()<!> // todo
+            val a: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>foo()<!> // todo
         }
     }
 }
@@ -31,4 +31,4 @@ class E: A() {
     init {
         val a: A = foo() // todo: discuss
     }
-}
+}

compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_after.fir.kt

@@ -12,14 +12,14 @@ open class A<T> : J() {
     init {
         foo()
         bar()
-        val a: Int = <!INITIALIZER_TYPE_MISMATCH!>baz()<!>
+        val a: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>baz()<!>
         val b: T = baz()
     }
 
     fun test1() {
         foo()
         bar()
-        val a: Int = <!INITIALIZER_TYPE_MISMATCH!>baz()<!>
+        val a: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>baz()<!>
         val b: T = baz()
     }
 

compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_before.fir.kt

@@ -12,14 +12,14 @@ open class A<T> : J() {
     init {
         foo()
         bar()
-        val a: Int = <!INITIALIZER_TYPE_MISMATCH!>baz()<!>
+        val a: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>baz()<!>
         val b: T = baz()
     }
 
     fun test1() {
         foo()
         bar()
-        val a: Int = <!INITIALIZER_TYPE_MISMATCH!>baz()<!>
+        val a: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>baz()<!>
         val b: T = baz()
     }
 

compiler/testData/diagnostics/tests/scopes/inheritance/statics/localVsStatic.fir.kt

@@ -21,7 +21,7 @@ fun test() {
 
     class B: A() {
         init {
-            val a: Int = <!INITIALIZER_TYPE_MISMATCH!>foo()<!> // todo
+            val a: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>foo()<!> // todo
         }
     }
-}
+}

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/lambdaAsArgument.fir.kt

@@ -7,9 +7,9 @@ class A {
     constructor(x: () -> Int)
     constructor() : this(
             {
-                <!UNRESOLVED_REFERENCE!>foo<!>() +
+                <!ARGUMENT_TYPE_MISMATCH, TYPE_MISMATCH!><!UNRESOLVED_REFERENCE!>foo<!>() +
                 <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>() +
                 <!UNRESOLVED_LABEL!>this@A<!>.<!UNRESOLVED_REFERENCE!>foo<!>() +
-                <!UNRESOLVED_REFERENCE!>foobar<!>()
+                <!UNRESOLVED_REFERENCE!>foobar<!>()<!>
             })
 }

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/memberFunAccess.fir.kt

@@ -2,6 +2,6 @@
 class A {
     fun foo() = 1
     constructor(x: Int)
-    constructor(x: Int, y: Int, z: Int = x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>()) :
+    constructor(x: Int, y: Int, z: Int = <!TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>()<!>) :
         this(<!ARGUMENT_TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>()<!>)
 }

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/propertyAccess.fir.kt

@@ -2,6 +2,6 @@
 class A {
     val prop = 1
     constructor(x: Int)
-    constructor(x: Int, y: Int, z: Int = x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!>) :
+    constructor(x: Int, y: Int, z: Int = <!TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!><!>) :
         this(<!ARGUMENT_TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!><!>)
 }

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/propertyAccessUnitialized.fir.kt

@@ -2,6 +2,6 @@
 open class B(x: Int)
 class A : B {
     val prop = 1
-    constructor(x: Int, y: Int = x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!>) :
+    constructor(x: Int, y: Int = <!TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!><!>) :
         super(<!ARGUMENT_TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!><!>)
 }

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superFunAccess.fir.kt

@@ -3,6 +3,6 @@ open class B(x: Int) {
     fun foo() = 1
 }
 class A : B {
-    constructor(x: Int, y: Int = x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>() + super.<!UNRESOLVED_REFERENCE!>foo<!>()) :
+    constructor(x: Int, y: Int = <!TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>() + super.<!UNRESOLVED_REFERENCE!>foo<!>()<!>) :
         super(<!ARGUMENT_TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>() + super.<!UNRESOLVED_REFERENCE!>foo<!>()<!>)
 }

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superFunAccessOverriden.fir.kt

@@ -4,6 +4,6 @@ open class B(x: Int) {
 }
 class A : B {
     override fun foo() = 2
-    constructor(x: Int, y: Int = x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>() + super.<!UNRESOLVED_REFERENCE!>foo<!>()) :
+    constructor(x: Int, y: Int = <!TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>() + super.<!UNRESOLVED_REFERENCE!>foo<!>()<!>) :
         super(<!ARGUMENT_TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>foo<!>() + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>foo<!>() + super.<!UNRESOLVED_REFERENCE!>foo<!>()<!>)
 }

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superPropertyAccess.fir.kt

@@ -1,6 +1,6 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 open class B(val prop: Int)
 class A : B {
-    constructor(x: Int, y: Int = x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!> + super.<!UNRESOLVED_REFERENCE!>prop<!>) :
+    constructor(x: Int, y: Int = <!TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!> + super.<!UNRESOLVED_REFERENCE!>prop<!><!>) :
         super(<!ARGUMENT_TYPE_MISMATCH!>x <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>prop<!> + <!INSTANCE_ACCESS_BEFORE_SUPER_CALL!>this<!>.<!UNRESOLVED_REFERENCE!>prop<!> + super.<!UNRESOLVED_REFERENCE!>prop<!><!>)
 }

compiler/testData/diagnostics/tests/smartCasts/inference/intersectionTypes.fir.kt

@@ -31,7 +31,7 @@ fun test(a: A, b: B, c: C) {
         val k = three(a, b, c)
         checkSubtype<A>(k)
         checkSubtype<B>(<!ARGUMENT_TYPE_MISMATCH!>k<!>)
-        val l: Int = <!INITIALIZER_TYPE_MISMATCH!>three(a, b, c)<!>
+        val l: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>three(a, b, c)<!>
 
         use(d, e, f, g, h, k, l)
     }

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericClass.fir.kt

@@ -2,7 +2,7 @@
 // JAVAC_EXPECTED_FILE
 // FILE: KotlinFile.kt
 fun foo(javaClass: JavaClass<String>): String {
-    return javaClass.doSomething("", 1) { s: String -> <!ARGUMENT_TYPE_MISMATCH!>""<!> }
+    return javaClass.doSomething("", 1) <!ARGUMENT_TYPE_MISMATCH!>{ s: String -> "" }<!>
 }
 
 // FILE: JavaClass.java

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethod.fir.kt

@@ -2,7 +2,7 @@
 // JAVAC_EXPECTED_FILE
 // FILE: KotlinFile.kt
 fun foo(javaClass: JavaClass): String {
-    return javaClass.doSomething("") { <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>it<!> }
+    return javaClass.doSomething("") <!ARGUMENT_TYPE_MISMATCH!>{ <!ARGUMENT_TYPE_MISMATCH, UNRESOLVED_REFERENCE!>it<!> }<!>
 }
 
 // FILE: JavaClass.java

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethodInGenericClass.fir.kt

@@ -2,8 +2,8 @@
 // JAVAC_EXPECTED_FILE
 // FILE: KotlinFile.kt
 fun foo(javaClass: JavaClass<Int>) {
-    val a: String = javaClass.doSomething1("", 1) { p: String -> <!ARGUMENT_TYPE_MISMATCH!>p<!> }
+    val a: String = javaClass.doSomething1("", 1) <!ARGUMENT_TYPE_MISMATCH!>{ p: String -> p }<!>
-    val b: String = javaClass.doSomething2("", 1, true) { p: Int -> <!ARGUMENT_TYPE_MISMATCH!>p<!> }
+    val b: String = javaClass.doSomething2("", 1, true) <!ARGUMENT_TYPE_MISMATCH!>{ p: Int -> p }<!>
 }
 
 // FILE: JavaClass.java

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/Simple.fir.kt

@@ -16,9 +16,9 @@ fun foo(javaClass: JavaClass, kotlinClass: KotlinClass) {
         bar()
     }
 
-    javaClass.doSomething2 {
+    javaClass.doSomething2 <!ARGUMENT_TYPE_MISMATCH!>{
-        <!ARGUMENT_TYPE_MISMATCH!>bar()<!>
+        bar()
-    }
+    }<!>
 }
 
 fun bar(){}
@@ -27,4 +27,4 @@ fun bar(){}
 public class JavaClass {
     public void doSomething(Runnable runnable) { runnable.run(); }
     public void doSomething2(I i) { i.doIt(); }
-}
+}

compiler/testData/diagnostics/tests/typeParameters/dontIntersectUpperBoundWithExpectedType.fir.kt

@@ -9,9 +9,9 @@ fun <T : Foo> foo(): T? {
 }
 
 fun main() {
-    val a: Bar? = <!DEBUG_INFO_EXPRESSION_TYPE("Foo? & Bar?")!>foo()<!>
+    val a: Bar? = <!DEBUG_INFO_EXPRESSION_TYPE("Foo?"), INITIALIZER_TYPE_MISMATCH, NEW_INFERENCE_ERROR!>foo()<!>
 }
 
 
 fun <T : Appendable> wtf(): T = TODO()
-val bar: Int = wtf() // happily compiles
+val bar: Int = <!INITIALIZER_TYPE_MISMATCH, NEW_INFERENCE_ERROR!>wtf()<!> // happily compiles

compiler/testData/diagnostics/tests/typeParameters/kt42042.fir.kt

@@ -8,6 +8,6 @@ sealed class Subtype<A1, B1> {
 }
 
 fun <A, B> unsafeCast(value: A): B {
-    val proof: Subtype<A, B> = <!UPPER_BOUND_VIOLATED!>Subtype.Trivial()<!>
+    val proof: Subtype<A, B> = <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>Subtype.Trivial()<!>
     return proof.cast(value)
 }

compiler/testData/diagnostics/tests/typeParameters/kt42042Error.fir.kt

@@ -8,6 +8,6 @@ sealed class Subtype<A1, B1> {
 }
 
 fun <A, B> unsafeCast(value: A): B {
-    val proof: Subtype<A, B> = <!UPPER_BOUND_VIOLATED!>Subtype.Trivial()<!>
+    val proof: Subtype<A, B> = <!TYPE_MISMATCH, TYPE_MISMATCH!>Subtype.Trivial()<!>
     return proof.cast(value)
 }

compiler/testData/diagnostics/tests/typealias/boundViolationInTypeAliasConstructor.fir.kt

@@ -13,6 +13,6 @@ class TColl<T, C : Collection<T>>
 typealias TC<T, C> = TColl<T, C>
 typealias TC2<T, C> = TC<T, C>
 
-val y1 = TColl<Any, <!UPPER_BOUND_VIOLATED!>Any<!>>()
+val y1 = TColl<Any, <!UPPER_BOUND_VIOLATED, UPPER_BOUND_VIOLATED!>Any<!>>()
 val y2 = TC<Any, Any>()
 val y3 = TC2<Any, Any>()

compiler/testData/diagnostics/testsWithStdLib/elvisOnJavaList.fir.kt

@@ -15,5 +15,5 @@ public class P {
 
 fun foo(c: P): MutableList<Int> {
     // Error should be here: see KT-8168 Typechecker fails for platform collection type
-    return <!RETURN_TYPE_MISMATCH!>c.getList() ?: listOf()<!>
+    return <!RETURN_TYPE_MISMATCH!>c.getList() ?: <!TYPE_MISMATCH!>listOf()<!><!>
 }

compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndLowPriority.fir.kt

@@ -18,7 +18,7 @@ public fun <K, V> Map<K, V>.get1(key: Any?): Int = null!!
 public fun <@kotlin.internal.OnlyInputTypes K, V> Map<out K, V>.get1(key: K): V? = null!!
 
 fun test(map: Map<Int, String>) {
-    val a: Int = <!INITIALIZER_TYPE_MISMATCH!>listOf(1).contains1("")<!>
+    val a: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>listOf(1).contains1("")<!>
     val b: Boolean = listOf(1).contains1(1)
 
     val c: String? = map.get1("")

compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/suspendFunctions.fir.kt

@@ -19,7 +19,7 @@ fun main() {
     val x1: suspend (Int) -> Unit = takeSuspend(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.coroutines.SuspendFunction1<kotlin.Int, kotlin.Unit>")!>id { it }<!>, <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.coroutines.SuspendFunction1<kotlin.Int, kotlin.Unit>")!>{ x -> x }<!>)
 
     // Here, the error should be
-    val x2: (Int) -> Unit = takeSuspend(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.coroutines.SuspendFunction1<kotlin.Int, kotlin.Unit>")!>id { it }<!>, <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.coroutines.SuspendFunction1<kotlin.Int, kotlin.Unit>")!>{ x -> x }<!>)
+    val x2: (Int) -> Unit = takeSuspend(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.coroutines.SuspendFunction1<kotlin.Int, kotlin.Unit>")!>id <!TYPE_MISMATCH, TYPE_MISMATCH!>{ it }<!><!>, <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.coroutines.SuspendFunction1<kotlin.Int, kotlin.Unit>"), TYPE_MISMATCH, TYPE_MISMATCH!>{ x -> x }<!>)
-    val x3: suspend (Int) -> Unit = takeSimpleFunction(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.coroutines.SuspendFunction1<kotlin.Int, kotlin.Unit>")!>id { it }<!>, <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.coroutines.SuspendFunction1<kotlin.Int, kotlin.Unit>")!>{ x -> x }<!>)
+    val x3: suspend (Int) -> Unit = takeSimpleFunction(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.coroutines.SuspendFunction1<kotlin.Int, kotlin.Unit>")!>id <!TYPE_MISMATCH, TYPE_MISMATCH!>{ it }<!><!>, <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.coroutines.SuspendFunction1<kotlin.Int, kotlin.Unit>"), TYPE_MISMATCH, TYPE_MISMATCH!>{ x -> x }<!>)
     val x4: (Int) -> Unit = takeSimpleFunction(<!ARGUMENT_TYPE_MISMATCH!>id<suspend (Int) -> Unit> {}<!>, <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Function1<kotlin.Int, kotlin.Unit>")!>{}<!>)
 }

compiler/testData/diagnostics/testsWithStdLib/kt9078.fir.kt

@@ -3,10 +3,10 @@ abstract class KFunctionKt9005WorkAround<out R: Any?>(private val _functionInsta
     private val _reflectedFunction: kotlin.reflect.KFunction<R> = _functionInstance.<!UNRESOLVED_REFERENCE!>reflect<!>() ?: throw IllegalStateException("")
 
     private val _parameters: List<kotlin.reflect.KParameter> = run {
-        _functionInstance.javaClass.methods.first().<!UNRESOLVED_REFERENCE!>parameters<!>.map {
+        <!ARGUMENT_TYPE_MISMATCH!>_functionInstance.javaClass.methods.first().<!UNRESOLVED_REFERENCE!>parameters<!>.map {
             <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>object<!> : kotlin.reflect.KParameter {
                 override val index: Int = 0
             }
-        }
+        }<!>
     }
 }

compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/maps.fir.kt

@@ -26,8 +26,8 @@ fun hashMapTest() {
     val b4: Map<String?, Int?> = x
     val b5: Map<String, Int?> = x
 
-    val b6: Int = <!INITIALIZER_TYPE_MISMATCH!>x[""]<!>
+    val b6: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x[""]<!>
-    val b7: Int = <!INITIALIZER_TYPE_MISMATCH!>x.get("")<!>
+    val b7: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x.get("")<!>
 
     val b8: Int? = x.get("")
 }
@@ -50,8 +50,8 @@ fun treeMapTest() {
     val b4: Map<String?, Int?> = x
     val b5: Map<String, Int?> = x
 
-    val b6: Int = <!INITIALIZER_TYPE_MISMATCH!>x[""]<!>
+    val b6: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x[""]<!>
-    val b7: Int = <!INITIALIZER_TYPE_MISMATCH!>x.get("")<!>
+    val b7: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x.get("")<!>
 
     val b8: Int? = x.get("")
 }
@@ -74,8 +74,8 @@ fun concurrentHashMapTest() {
     val b4: Map<String?, Int?> = x
     val b5: Map<String, Int?> = x
 
-    val b6: Int = <!INITIALIZER_TYPE_MISMATCH!>x[""]<!>
+    val b6: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x[""]<!>
-    val b7: Int = <!INITIALIZER_TYPE_MISMATCH!>x.get("")<!>
+    val b7: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x.get("")<!>
 
     val b8: Int? = x.get("")
 }

compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableKey.fir.kt

@@ -25,9 +25,9 @@ fun hashMapTest() {
     val b4: Map<String?, Int?> = x
     val b5: Map<String, Int?> = <!INITIALIZER_TYPE_MISMATCH!>x<!>
 
-    val b6: Int = <!INITIALIZER_TYPE_MISMATCH!>x[""]<!>
+    val b6: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x[""]<!>
-    val b7: Int = <!INITIALIZER_TYPE_MISMATCH!>x[null]<!>
+    val b7: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x[null]<!>
-    val b8: Int = <!INITIALIZER_TYPE_MISMATCH!>x.get("")<!>
+    val b8: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x.get("")<!>
 
     val b9: Int? = x.get("")
 }
@@ -50,8 +50,8 @@ fun treeMapTest() {
     val b4: Map<String?, Int?> = x
     val b5: Map<String, Int?> = <!INITIALIZER_TYPE_MISMATCH!>x<!>
 
-    val b6: Int = <!INITIALIZER_TYPE_MISMATCH!>x[""]<!>
+    val b6: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x[""]<!>
-    val b7: Int = <!INITIALIZER_TYPE_MISMATCH!>x.get("")<!>
+    val b7: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x.get("")<!>
 
     val b8: Int? = x.get("")
 }

compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableValues.fir.kt

@@ -25,8 +25,8 @@ fun hashMapTest() {
     val b4: Map<String, Int?> = x
     val b5: Map<String?, Int?> = x
 
-    val b6: Int = <!INITIALIZER_TYPE_MISMATCH!>x[""]<!>
+    val b6: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x[""]<!>
-    val b7: Int = <!INITIALIZER_TYPE_MISMATCH!>x.get("")<!>
+    val b7: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x.get("")<!>
 
     val b8: Int? = x.get("")
 }
@@ -49,8 +49,8 @@ fun treeMapTest() {
     val b4: Map<String, Int?> = x
     val b5: Map<String?, Int?> = x
 
-    val b6: Int = <!INITIALIZER_TYPE_MISMATCH!>x[""]<!>
+    val b6: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x[""]<!>
-    val b7: Int = <!INITIALIZER_TYPE_MISMATCH!>x.get("")<!>
+    val b7: Int = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x.get("")<!>
 
     val b8: Int? = x.get("")
 }

compiler/testData/diagnostics/testsWithStdLib/when/kt10807.fir.kt

@@ -10,8 +10,8 @@ fun getComp(): Comparator<Foo?> =
         }<!>
 
 fun getCompInverted(): Comparator<Foo?> =
-        nullsLast(
+        <!TYPE_MISMATCH!>nullsLast(
                 when {
                     else -> compareBy({ it.<!UNRESOLVED_REFERENCE!>a<!> }, { it.<!UNRESOLVED_REFERENCE!>b<!> })
                 }
-        )
+        )<!>

compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/72.fir.kt

@@ -13,5 +13,5 @@ fun case_1() {
     val strs = list as MutableList<String>
     strs.add("two")
     <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.collections.MutableList<kotlin.String> & kotlin.collections.MutableList<kotlin.Int> & kotlin.collections.MutableList<kotlin.String>")!>list<!>
-    val s: String = <!INITIALIZER_TYPE_MISMATCH!><!DEBUG_INFO_EXPRESSION_TYPE("kotlin.collections.MutableList<kotlin.String> & kotlin.collections.MutableList<kotlin.Int> & kotlin.collections.MutableList<kotlin.String>")!>list<!>[0]<!>
+    val s: String = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!><!DEBUG_INFO_EXPRESSION_TYPE("kotlin.collections.MutableList<kotlin.String> & kotlin.collections.MutableList<kotlin.Int> & kotlin.collections.MutableList<kotlin.String>")!>list<!>[0]<!>
 }

idea/testData/checker/trivialHierarchyLoop.fir.kt

@@ -1,3 +1,3 @@
 class A : <error descr="[OTHER_ERROR] Unknown (other) error">A</error>() {}
 
-val x : Int = <error descr="[INITIALIZER_TYPE_MISMATCH] Initializer type mismatch: expected kotlin/Int, actual A">A()</error>
+val x : Int = <error descr="[INITIALIZER_TYPE_MISMATCH] Initializer type mismatch: expected kotlin/Int, actual A"><error descr="[TYPE_MISMATCH] Type mismatch: inferred type is A but kotlin/Int was expected">A()</error></error>