diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/KotlinCallCompleter.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/KotlinCallCompleter.kt
index 6bf753df18b..f66bc91c25b 100644
--- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/KotlinCallCompleter.kt
+++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/KotlinCallCompleter.kt
@@ -148,6 +148,11 @@ class KotlinCallCompleter(
         if (returnType == null) return
         if (expectedType == null || TypeUtils.noExpectedType(expectedType)) return
 
+        // This is needed to avoid multiple mismatch errors as we type check resulting type against expected one later
+        // Plus, it helps with IDE-tests where it's important to have particular diagnostics.
+        // Note that it aligns with the old inference, see CallCompleter.completeResolvedCallAndArguments
+        if (csBuilder.currentStorage().notFixedTypeVariables.isEmpty()) return
+
         // We don't add expected type constraint for constant expression like "1 + 1" because of type coercion for numbers:
         // val a: Long = 1 + 1, note that result type of "1 + 1" will be Int and adding constraint with Long will produce type mismatch
         if (!resolutionCallbacks.isCompileTimeConstant(resolvedCall, expectedType)) {
diff --git a/compiler/testData/diagnostics/tests/AutoCreatedIt.kt b/compiler/testData/diagnostics/tests/AutoCreatedIt.kt
index 7110379adda..db0b1006919 100644
--- a/compiler/testData/diagnostics/tests/AutoCreatedIt.kt
+++ b/compiler/testData/diagnostics/tests/AutoCreatedIt.kt
@@ -13,7 +13,7 @@ fun text() {
     bar2 {<!TYPE_MISMATCH!><!>}
     bar2 {1}
     bar2 {<!UNRESOLVED_REFERENCE!>it<!>}
-    bar2 <!NI;TYPE_MISMATCH!>{<!OI;CANNOT_INFER_PARAMETER_TYPE, OI;EXPECTED_PARAMETERS_NUMBER_MISMATCH!>it<!> -> <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>it<!>}<!>
+    bar2 <!NI;TYPE_MISMATCH!>{<!OI;CANNOT_INFER_PARAMETER_TYPE, OI;EXPECTED_PARAMETERS_NUMBER_MISMATCH!>it<!> -> <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>it<!>}<!>
 }
 
 fun bar(<!UNUSED_PARAMETER!>f<!> :  (Int, Int) -> Int) {}
diff --git a/compiler/testData/diagnostics/tests/Basic.kt b/compiler/testData/diagnostics/tests/Basic.kt
index 3d820e00bb1..c12c76e6811 100644
--- a/compiler/testData/diagnostics/tests/Basic.kt
+++ b/compiler/testData/diagnostics/tests/Basic.kt
@@ -10,7 +10,7 @@ fun test() : Int {
 }
 
 class A() {
-    val x : Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>foo1(<!TOO_MANY_ARGUMENTS, UNRESOLVED_REFERENCE!>xx<!>)<!>
+    val x : Int = <!TYPE_MISMATCH!>foo1(<!TOO_MANY_ARGUMENTS, UNRESOLVED_REFERENCE!>xx<!>)<!>
 }
 
 fun foo1() {}
diff --git a/compiler/testData/diagnostics/tests/BinaryCallsOnNullableValues.kt b/compiler/testData/diagnostics/tests/BinaryCallsOnNullableValues.kt
index c4142161c76..54855bdc82d 100644
--- a/compiler/testData/diagnostics/tests/BinaryCallsOnNullableValues.kt
+++ b/compiler/testData/diagnostics/tests/BinaryCallsOnNullableValues.kt
@@ -26,7 +26,7 @@ fun f(): Unit {
     <!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>x<!> in 1..2
 
     val y : Boolean? = true
-    <!UNUSED_EXPRESSION!>false || <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!><!>
-    <!UNUSED_EXPRESSION!><!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!> && true<!>
-    <!UNUSED_EXPRESSION!><!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!> && <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!><!>
+    <!UNUSED_EXPRESSION!>false || <!TYPE_MISMATCH!>y<!><!>
+    <!UNUSED_EXPRESSION!><!TYPE_MISMATCH!>y<!> && true<!>
+    <!UNUSED_EXPRESSION!><!TYPE_MISMATCH!>y<!> && <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!><!>
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/DefaultValuesTypechecking.kt b/compiler/testData/diagnostics/tests/DefaultValuesTypechecking.kt
index e2e2c7cc335..1d53a3591c7 100644
--- a/compiler/testData/diagnostics/tests/DefaultValuesTypechecking.kt
+++ b/compiler/testData/diagnostics/tests/DefaultValuesTypechecking.kt
@@ -1,14 +1,14 @@
 // !WITH_NEW_INFERENCE
 val x = ""
 
-fun bar(x : Int = <!TYPE_MISMATCH!>""<!>, y : Int = x, <!UNUSED_PARAMETER!>z<!> : String = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!>) {
+fun bar(x : Int = <!TYPE_MISMATCH!>""<!>, y : Int = x, <!UNUSED_PARAMETER!>z<!> : String = <!TYPE_MISMATCH!>y<!>) {
 
 }
 
 // KT-371 Resolve default parameters for constructors
 
 class A(x : Int = <!UNINITIALIZED_PARAMETER!>y<!>, y : Int = x) { // None of the references is resolved, no types checked
-    fun foo(<!UNUSED_PARAMETER!>bool<!>: Boolean, a: Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH, UNINITIALIZED_PARAMETER!>b<!>, b: String = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>a<!>) {}
+    fun foo(<!UNUSED_PARAMETER!>bool<!>: Boolean, a: Int = <!TYPE_MISMATCH, UNINITIALIZED_PARAMETER!>b<!>, b: String = <!TYPE_MISMATCH!>a<!>) {}
 }
 
 val z = 3
diff --git a/compiler/testData/diagnostics/tests/EnumEntryAsType.kt b/compiler/testData/diagnostics/tests/EnumEntryAsType.kt
index 383a58c73ec..ff475d00452 100644
--- a/compiler/testData/diagnostics/tests/EnumEntryAsType.kt
+++ b/compiler/testData/diagnostics/tests/EnumEntryAsType.kt
@@ -9,7 +9,7 @@ enum class Color {
 
 class MyColor(val x: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>, y: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>) : Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> {
 
-    var z: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> = <!TYPE_MISMATCH!>Color.<!NI;TYPE_MISMATCH!>RED<!><!>
+    var z: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> = <!TYPE_MISMATCH!>Color.RED<!>
     set(arg: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>) { z = arg }
 
     fun foo(arg: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>): Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> = arg
@@ -17,7 +17,7 @@ class MyColor(val x: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>, y: Color.<!ENUM_ENTRY_A
     fun bar(): Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> {
         class Local : Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>
         fun local(arg: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>): Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> = arg
-        val temp: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> = <!TYPE_MISMATCH!>Color.<!NI;TYPE_MISMATCH!>RED<!><!>
+        val temp: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> = <!TYPE_MISMATCH!>Color.RED<!>
         temp <!USELESS_CAST!>as? Color.<!ENUM_ENTRY_AS_TYPE!>RED<!><!>
         if (<!USELESS_IS_CHECK!>temp is <!IS_ENUM_ENTRY!>Color.<!ENUM_ENTRY_AS_TYPE!>RED<!><!><!>) {
         return temp <!USELESS_CAST!>as Color.<!ENUM_ENTRY_AS_TYPE!>RED<!><!>
@@ -26,7 +26,7 @@ class MyColor(val x: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>, y: Color.<!ENUM_ENTRY_A
         if (<!USELESS_IS_CHECK!>obj is <!IS_ENUM_ENTRY!>Color.<!ENUM_ENTRY_AS_TYPE!>RED<!><!><!>) {
         return obj
     }
-        return <!TYPE_MISMATCH!>Color.<!NI;TYPE_MISMATCH!>RED<!><!>
+        return <!TYPE_MISMATCH!>Color.RED<!>
     }
 }
 
diff --git a/compiler/testData/diagnostics/tests/FunctionReturnTypes.kt b/compiler/testData/diagnostics/tests/FunctionReturnTypes.kt
index c049c95fb57..8709c938ffc 100644
--- a/compiler/testData/diagnostics/tests/FunctionReturnTypes.kt
+++ b/compiler/testData/diagnostics/tests/FunctionReturnTypes.kt
@@ -45,7 +45,7 @@ fun intFunctionLiteral(): Int = <!TYPE_MISMATCH_DUE_TO_EQUALS_LAMBDA_IN_FUN!>{ 1
 fun blockReturnUnitMismatch() : Int {<!RETURN_TYPE_MISMATCH!>return<!>}
 fun blockReturnValueTypeMismatch() : Int {return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>3.4<!>}
 fun blockReturnValueTypeMatch() : Int {return 1}
-fun blockReturnValueTypeMismatchUnit() : Int {return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>Unit<!>}
+fun blockReturnValueTypeMismatchUnit() : Int {return <!TYPE_MISMATCH!>Unit<!>}
 
 fun blockAndAndMismatch() : Int {
     <!UNUSED_EXPRESSION!>true && false<!>
diff --git a/compiler/testData/diagnostics/tests/PackageQualified.kt b/compiler/testData/diagnostics/tests/PackageQualified.kt
index f37ddce8df4..a0f38399b6b 100644
--- a/compiler/testData/diagnostics/tests/PackageQualified.kt
+++ b/compiler/testData/diagnostics/tests/PackageQualified.kt
@@ -20,7 +20,7 @@ abstract class Foo<T>() {
 package foobar.a
     import java.util.*
 
-    val b : List<Int>? = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>a<!>
+    val b : List<Int>? = <!TYPE_MISMATCH!>a<!>
     val b1 : <!UNRESOLVED_REFERENCE!>util<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>List<!><Int>? = a
 
 // FILE: b.kt
diff --git a/compiler/testData/diagnostics/tests/SafeCallNonNullReceiverReturnNull.kt b/compiler/testData/diagnostics/tests/SafeCallNonNullReceiverReturnNull.kt
index 44d3feb0d78..eccc9ecef1c 100644
--- a/compiler/testData/diagnostics/tests/SafeCallNonNullReceiverReturnNull.kt
+++ b/compiler/testData/diagnostics/tests/SafeCallNonNullReceiverReturnNull.kt
@@ -3,5 +3,5 @@ fun Int.gg() = null
 
 fun ff() {
     val a: Int = 1
-    val <!UNUSED_VARIABLE!>b<!>: Int = <!TYPE_MISMATCH!>a<!UNNECESSARY_SAFE_CALL!>?.<!><!NI;TYPE_MISMATCH!>gg()<!><!>
+    val <!UNUSED_VARIABLE!>b<!>: Int = <!TYPE_MISMATCH!>a<!UNNECESSARY_SAFE_CALL!>?.<!>gg()<!>
 }
diff --git a/compiler/testData/diagnostics/tests/Variance.kt b/compiler/testData/diagnostics/tests/Variance.kt
index 6af79f87cb3..c9bc5517ea6 100644
--- a/compiler/testData/diagnostics/tests/Variance.kt
+++ b/compiler/testData/diagnostics/tests/Variance.kt
@@ -8,14 +8,14 @@ abstract class Producer<out T> {}
 abstract class Usual<T> {}
 
 fun foo(c: Consumer<Int>, p: Producer<Int>, u: Usual<Int>) {
-    val c1: Consumer<Any> = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>c<!>
+    val c1: Consumer<Any> = <!TYPE_MISMATCH!>c<!>
     val <!UNUSED_VARIABLE!>c2<!>: Consumer<Int> = c1
 
     val p1: Producer<Any> = p
-    val <!UNUSED_VARIABLE!>p2<!>: Producer<Int> = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>p1<!>
+    val <!UNUSED_VARIABLE!>p2<!>: Producer<Int> = <!TYPE_MISMATCH!>p1<!>
 
-    val u1: Usual<Any> = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>u<!>
-    val <!UNUSED_VARIABLE!>u2<!>: Usual<Int> = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>u1<!>
+    val u1: Usual<Any> = <!TYPE_MISMATCH!>u<!>
+    val <!UNUSED_VARIABLE!>u2<!>: Usual<Int> = <!NI;TYPE_MISMATCH, OI;TYPE_MISMATCH!>u1<!>
 }
 
 //Arrays copy example
diff --git a/compiler/testData/diagnostics/tests/annotations/kt1860-negative.kt b/compiler/testData/diagnostics/tests/annotations/kt1860-negative.kt
index b9ac57a2ee3..bed18d44445 100644
--- a/compiler/testData/diagnostics/tests/annotations/kt1860-negative.kt
+++ b/compiler/testData/diagnostics/tests/annotations/kt1860-negative.kt
@@ -4,7 +4,7 @@ fun foo(@<!UNRESOLVED_REFERENCE!>varargs<!> <!UNUSED_PARAMETER!>f<!> : Int) {}
 var bar : Int = 1
   set(@<!UNRESOLVED_REFERENCE!>varargs<!> <!UNUSED_PARAMETER!>v<!>) {}
 
-val x : (Int) -> Int = {@<!UNRESOLVED_REFERENCE!>varargs<!> <!NI;TYPE_MISMATCH, TYPE_MISMATCH, UNINITIALIZED_VARIABLE!>x<!> <!SYNTAX!>: Int -> x<!>}
+val x : (Int) -> Int = {@<!UNRESOLVED_REFERENCE!>varargs<!> <!TYPE_MISMATCH, UNINITIALIZED_VARIABLE!>x<!> <!SYNTAX!>: Int -> x<!>}
 
 class Hello(@<!UNRESOLVED_REFERENCE!>varargs<!> <!UNUSED_PARAMETER!>args<!>: Any) {
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/annotations/kt1860-positive.kt b/compiler/testData/diagnostics/tests/annotations/kt1860-positive.kt
index 74d7ad2cb64..3b5cde4b8d8 100644
--- a/compiler/testData/diagnostics/tests/annotations/kt1860-positive.kt
+++ b/compiler/testData/diagnostics/tests/annotations/kt1860-positive.kt
@@ -8,7 +8,7 @@ fun foo(@test <!UNUSED_PARAMETER!>f<!> : Int) {}
 var bar : Int = 1
     set(@test <!UNUSED_PARAMETER!>v<!>) {}
 
-val x : (Int) -> Int = {@test <!NI;TYPE_MISMATCH, TYPE_MISMATCH, UNINITIALIZED_VARIABLE!>x<!> <!SYNTAX!>: Int -> x<!>} // todo fix parser annotation on lambda parameter
+val x : (Int) -> Int = {@test <!TYPE_MISMATCH, UNINITIALIZED_VARIABLE!>x<!> <!SYNTAX!>: Int -> x<!>} // todo fix parser annotation on lambda parameter
 
 class Hello(@test <!UNUSED_PARAMETER!>args<!>: Any) {
 }
diff --git a/compiler/testData/diagnostics/tests/callableReference/generic/genericFunctionsWithNullableTypes.kt b/compiler/testData/diagnostics/tests/callableReference/generic/genericFunctionsWithNullableTypes.kt
index f291e692e14..b3e430d19b8 100644
--- a/compiler/testData/diagnostics/tests/callableReference/generic/genericFunctionsWithNullableTypes.kt
+++ b/compiler/testData/diagnostics/tests/callableReference/generic/genericFunctionsWithNullableTypes.kt
@@ -33,5 +33,5 @@ fun <T> test(x: T) {
     val s4: Pair<Int?, String> = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>bar(null, null, ::<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>)<!>
 
     val s5: Pair<Int, String> = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>bar(1, "", ::foo)<!>
-    val (a1: Int, <!NI;TYPE_MISMATCH!>b1: String<!>) = <!OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>bar(1, "", ::foo)<!>
+    val (a1: Int, b1: String) = <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>bar(1, "", ::foo)<!>
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/cast/AsInBinaryUnary.kt b/compiler/testData/diagnostics/tests/cast/AsInBinaryUnary.kt
index 433edcaa998..e99f82e46bd 100644
--- a/compiler/testData/diagnostics/tests/cast/AsInBinaryUnary.kt
+++ b/compiler/testData/diagnostics/tests/cast/AsInBinaryUnary.kt
@@ -20,11 +20,11 @@ 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 = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>x + y<!>
+fun error1(x: Impl2, y: Base): Impl1 = <!TYPE_MISMATCH!>x + y<!>
 
 fun add2(x: Base, y: Impl2): Impl1 = x + y as Base
 
-fun error2(x: Base, y: Impl2): Impl1 = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>x + y<!>
+fun error2(x: Base, y: Impl2): Impl1 = <!TYPE_MISMATCH!>x + y<!>
 
 fun minus3(x: Impl2): Impl1 = -(x as Base)
 
diff --git a/compiler/testData/diagnostics/tests/checkArguments/booleanExpressions.kt b/compiler/testData/diagnostics/tests/checkArguments/booleanExpressions.kt
index 65c6b28d2b9..ef0b86b1202 100644
--- a/compiler/testData/diagnostics/tests/checkArguments/booleanExpressions.kt
+++ b/compiler/testData/diagnostics/tests/checkArguments/booleanExpressions.kt
@@ -1,7 +1,7 @@
 // !WITH_NEW_INFERENCE
 fun foo1(b: Boolean, c: Int) {
-    if (b && <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>c<!>) {}
-    if (b || <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>c<!>) {}
-    if (<!NI;TYPE_MISMATCH, TYPE_MISMATCH!>c<!> && b) {}
-    if (<!NI;TYPE_MISMATCH, TYPE_MISMATCH!>c<!> || b) {}
+    if (b && <!TYPE_MISMATCH!>c<!>) {}
+    if (b || <!TYPE_MISMATCH!>c<!>) {}
+    if (<!TYPE_MISMATCH!>c<!> && b) {}
+    if (<!TYPE_MISMATCH!>c<!> || b) {}
 }
diff --git a/compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.kt b/compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.kt
index a0f4d3b4d35..d9b4e11148e 100644
--- a/compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.kt
+++ b/compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.kt
@@ -27,7 +27,7 @@ fun foo() {
             z = 34
         }
     }
-    val <!UNUSED_VARIABLE!>f<!>: ()-> Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>r<!>
+    val <!UNUSED_VARIABLE!>f<!>: ()-> Int = <!TYPE_MISMATCH!>r<!>
     val <!UNUSED_VARIABLE!>g<!>: ()-> Any = r
 }
 
@@ -80,7 +80,7 @@ fun testCoercionToUnit() {
             45
         }
     }
-    val <!UNUSED_VARIABLE!>f<!> : () -> String = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>checkType<!>
+    val <!UNUSED_VARIABLE!>f<!> : () -> String = <!TYPE_MISMATCH!>checkType<!>
 }
 
 fun doSmth(<!UNUSED_PARAMETER!>i<!>: Int) {}
diff --git a/compiler/testData/diagnostics/tests/controlStructures/specialConstructsAndPlatformTypes.kt b/compiler/testData/diagnostics/tests/controlStructures/specialConstructsAndPlatformTypes.kt
index 5f6ffc58b5a..6701e083bf1 100644
--- a/compiler/testData/diagnostics/tests/controlStructures/specialConstructsAndPlatformTypes.kt
+++ b/compiler/testData/diagnostics/tests/controlStructures/specialConstructsAndPlatformTypes.kt
@@ -12,7 +12,7 @@ public class J {
 val testImplicitExclExcl1: String = J.s
 val testImplicitExclExcl2: String? = J.s
 
-val testImplicitExclExcl3: String = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>J.m[""]<!>
+val testImplicitExclExcl3: String = <!TYPE_MISMATCH!>J.m[""]<!>
 val testImplicitExclExcl4: String? = J.m[""]
 
 val testExclExcl1: String = J.s!!
diff --git a/compiler/testData/diagnostics/tests/cyclicHierarchy/kt303.kt b/compiler/testData/diagnostics/tests/cyclicHierarchy/kt303.kt
index 6f9879f4238..6a10987081e 100644
--- a/compiler/testData/diagnostics/tests/cyclicHierarchy/kt303.kt
+++ b/compiler/testData/diagnostics/tests/cyclicHierarchy/kt303.kt
@@ -9,4 +9,4 @@ open class Bar() : <!CYCLIC_INHERITANCE_HIERARCHY!>Foo<!>() {
 
 }
 
-val x : Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>Foo()<!>
+val x : Int = <!TYPE_MISMATCH!>Foo()<!>
diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Return.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Return.kt
index 29792de3840..f238bbddf38 100644
--- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Return.kt
+++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Return.kt
@@ -14,5 +14,5 @@ fun foo(): Int {
     val z: Int? = null
     if (z != null) return if (<!SENSELESS_COMPARISON!>z == null<!>) z else z
     
-    return <!DEBUG_INFO_CONSTANT, NI;TYPE_MISMATCH, TYPE_MISMATCH!>z<!>
+    return <!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>z<!>
 }
diff --git a/compiler/testData/diagnostics/tests/declarationChecks/ComponentFunctionReturnTypeMismatch.kt b/compiler/testData/diagnostics/tests/declarationChecks/ComponentFunctionReturnTypeMismatch.kt
index 0e15d8c1d53..71e9390c6d3 100644
--- a/compiler/testData/diagnostics/tests/declarationChecks/ComponentFunctionReturnTypeMismatch.kt
+++ b/compiler/testData/diagnostics/tests/declarationChecks/ComponentFunctionReturnTypeMismatch.kt
@@ -5,5 +5,5 @@ class A {
 }
 
 fun a(aa : A) {
-    val (<!NI;TYPE_MISMATCH!><!UNUSED_VARIABLE!>a<!>: String<!>, <!NI;TYPE_MISMATCH!><!UNUSED_VARIABLE!>b1<!>: String<!>) = <!OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>aa<!>
+    val (<!UNUSED_VARIABLE!>a<!>: String, <!UNUSED_VARIABLE!>b1<!>: String) = <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>aa<!>
 }
diff --git a/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/FolLoopTypeComponentTypeMismatch.kt b/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/FolLoopTypeComponentTypeMismatch.kt
index 18898c2e515..cc370383f35 100644
--- a/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/FolLoopTypeComponentTypeMismatch.kt
+++ b/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/FolLoopTypeComponentTypeMismatch.kt
@@ -9,7 +9,7 @@ class C {
 }
 
 fun test() {
-    for ((<!NI;TYPE_MISMATCH!><!UNUSED_VARIABLE!>x<!>: Double<!>, <!NI;TYPE_MISMATCH!><!UNUSED_VARIABLE!>y<!>: Int<!>) in <!OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>C()<!>) {
+    for ((<!UNUSED_VARIABLE!>x<!>: Double, <!UNUSED_VARIABLE!>y<!>: Int) in <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>C()<!>) {
 
     }
 }
diff --git a/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/underscore.kt b/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/underscore.kt
index 786d0a55f99..8725abe00de 100644
--- a/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/underscore.kt
+++ b/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/underscore.kt
@@ -26,7 +26,7 @@ fun test() {
         foo(<!UNRESOLVED_REFERENCE!>_<!>, <!UNRESOLVED_REFERENCE!>_<!>)
     }
 
-    for ((<!NI;TYPE_MISMATCH!>_ : String<!>, <!NI;TYPE_MISMATCH!>_ : Int<!>) in <!OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>C()<!>) {
+    for ((_ : String, _ : Int) in <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>C()<!>) {
         foo(<!UNRESOLVED_REFERENCE!>_<!>, <!UNRESOLVED_REFERENCE!>_<!>)
     }
 
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/inference/differentDelegatedExpressions.kt b/compiler/testData/diagnostics/tests/delegatedProperty/inference/differentDelegatedExpressions.kt
index 3b587e9a4c0..b4788b32450 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/inference/differentDelegatedExpressions.kt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/inference/differentDelegatedExpressions.kt
@@ -12,8 +12,8 @@ class A(outer: Outer) {
 
     var b: String by  foo(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())
     var r: String by  foo(outer.getContainer().<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())
-    var e: String by  <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;TYPE_MISMATCH!><!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())<!>
-    var f: String by  <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;TYPE_MISMATCH!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>()) <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>-<!> 1<!>
+    var e: String by  <!NI;DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!><!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())<!>
+    var f: String by  <!NI;DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>()) <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>-<!> 1<!>
 }
 
 fun <A, B> foo(<!UNUSED_PARAMETER!>a<!>: Any?) = MyProperty<A, B>()
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethodInGenericClass.kt b/compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethodInGenericClass.kt
index 426f6a8ccef..13cdf6a375e 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethodInGenericClass.kt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethodInGenericClass.kt
@@ -25,4 +25,4 @@ class C<R>() {
 }
 
 var c1: Int by C()
-var c2: Int by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;TYPE_MISMATCH, OI;DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!>C<Number>()<!>
+var c2: Int by <!DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!>C<Number>()<!>
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/noOperatorModifierOnProvideDelegate.kt b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/noOperatorModifierOnProvideDelegate.kt
index e1740e837a5..6cc2b6c2221 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/noOperatorModifierOnProvideDelegate.kt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/noOperatorModifierOnProvideDelegate.kt
@@ -13,6 +13,6 @@ fun String.provideDelegate(a: Any?, p: KProperty<*>) = StringDelegate(this)
 operator fun String.getValue(a: Any?, p: KProperty<*>) = this
 
 val test1: String by "OK"
-val test2: Int by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;TYPE_MISMATCH, OI;DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!>"OK"<!>
+val test2: Int by <!DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!>"OK"<!>
 val test3 by "OK"
 
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/unsupportedOperatorProvideDelegate.kt b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/unsupportedOperatorProvideDelegate.kt
index d73903ce1e0..ce168f0cb2a 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/unsupportedOperatorProvideDelegate.kt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/unsupportedOperatorProvideDelegate.kt
@@ -11,5 +11,5 @@ class WrongDelegate(val x: Int) {
 operator fun String.getValue(thisRef: Any?, prop: Any) = this
 
 val test1: String by "OK"
-val test2: Int by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;TYPE_MISMATCH, OI;DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!>"OK"<!>
+val test2: Int by <!DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!>"OK"<!>
 val test3 by "OK"
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForGetReturnType.kt b/compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForGetReturnType.kt
index 4da869760da..884b0ccfedb 100644
--- a/compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForGetReturnType.kt
+++ b/compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForGetReturnType.kt
@@ -3,7 +3,7 @@
 
 import kotlin.reflect.KProperty
 
-val c: Int by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;TYPE_MISMATCH, OI;DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!>Delegate()<!>
+val c: Int by <!DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!>Delegate()<!>
 
 class Delegate {
   operator fun getValue(t: Any?, p: KProperty<*>): String {
diff --git a/compiler/testData/diagnostics/tests/delegation/clashes/finalMemberOverridden.kt b/compiler/testData/diagnostics/tests/delegation/clashes/finalMemberOverridden.kt
index 5a0a087013d..dc6663af184 100644
--- a/compiler/testData/diagnostics/tests/delegation/clashes/finalMemberOverridden.kt
+++ b/compiler/testData/diagnostics/tests/delegation/clashes/finalMemberOverridden.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 <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>CBar()<!>
+<!OVERRIDING_FINAL_MEMBER_BY_DELEGATION!>class Test8<!> : Final(), IBarT<Int> by <!TYPE_MISMATCH!>CBar()<!>
diff --git a/compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/severalDelegates.kt b/compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/severalDelegates.kt
index 1ff9963b1ee..8260598308f 100644
--- a/compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/severalDelegates.kt
+++ b/compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/severalDelegates.kt
@@ -23,6 +23,6 @@ public abstract class MyClass : Base1, Base2 {
     }
 }
 
-<!DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE, DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE, MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>class A<!> : MyClass(), Base1 by Delegate1(), <!SUPERTYPE_APPEARS_TWICE!>Base1<!> by <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>Delegate2()<!> {
+<!DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE, DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE, MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>class A<!> : MyClass(), Base1 by Delegate1(), <!SUPERTYPE_APPEARS_TWICE!>Base1<!> by <!TYPE_MISMATCH!>Delegate2()<!> {
 
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/evaluate/divisionByZero.kt b/compiler/testData/diagnostics/tests/evaluate/divisionByZero.kt
index ea1c09a76d5..f58114b824e 100644
--- a/compiler/testData/diagnostics/tests/evaluate/divisionByZero.kt
+++ b/compiler/testData/diagnostics/tests/evaluate/divisionByZero.kt
@@ -12,7 +12,7 @@ val a7 = <!DIVISION_BY_ZERO!>1.div(a1)<!>
 val a8 = 1.div(a2)
 val a9 = 2 * (<!DIVISION_BY_ZERO!>1.div(0)<!>)
 
-val b1: Byte = <!DIVISION_BY_ZERO, NI;TYPE_MISMATCH, TYPE_MISMATCH!>1 / 0<!>
+val b1: Byte = <!DIVISION_BY_ZERO, TYPE_MISMATCH!>1 / 0<!>
 @Ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST, DIVISION_BY_ZERO!>1 / 0<!>) val b2 = 1
 
 annotation class Ann(val i : Int)
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/inferredFunctionalType.kt b/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/inferredFunctionalType.kt
index 7e1244e7913..bf44f13a905 100644
--- a/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/inferredFunctionalType.kt
+++ b/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/inferredFunctionalType.kt
@@ -22,8 +22,8 @@ fun bar(aList: List<A>) {
         b checkType { _<String>() }
     }
 
-    aList.foo { (<!NI;TYPE_MISMATCH, OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>a: String<!>, b) ->
-        <!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!> <!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>checkType<!> { <!NI;UNRESOLVED_REFERENCE!>_<!><Int>() }
+    aList.foo { (<!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>a: String<!>, b) ->
+        a checkType { _<Int>() }
         b checkType { _<String>() }
     }
 
diff --git a/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/simple.kt b/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/simple.kt
index d579dc46b2d..7f7ca456609 100644
--- a/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/simple.kt
+++ b/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/simple.kt
@@ -42,8 +42,8 @@ fun bar() {
         d checkType { _<Short>() }
     }
 
-    foo { (<!NI;TYPE_MISMATCH, OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>a: String<!>, b) ->
-        <!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!> <!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>checkType<!> { <!NI;UNRESOLVED_REFERENCE!>_<!><Int>() }
+    foo { (<!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>a: String<!>, b) ->
+        a checkType { _<Int>() }
         b checkType { _<String>() }
     }
 
diff --git a/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/underscore.kt b/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/underscore.kt
index 995ef00f2b6..5bae03b2eff 100644
--- a/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/underscore.kt
+++ b/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/underscore.kt
@@ -51,7 +51,7 @@ fun bar() {
         _ checkType { _<String>() }
     }
 
-    foo { (<!NI;TYPE_MISMATCH, OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>_: String<!>, b) ->
+    foo { (<!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>_: String<!>, b) ->
         <!UNRESOLVED_REFERENCE!>_<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>hashCode<!>()
         b checkType { _<String>() }
     }
diff --git a/compiler/testData/diagnostics/tests/generics/capturedParameters/innerLocalClass.kt b/compiler/testData/diagnostics/tests/generics/capturedParameters/innerLocalClass.kt
index 7a71dcf7276..fba197b17fa 100644
--- a/compiler/testData/diagnostics/tests/generics/capturedParameters/innerLocalClass.kt
+++ b/compiler/testData/diagnostics/tests/generics/capturedParameters/innerLocalClass.kt
@@ -20,7 +20,7 @@ private class Outer<E> {
         private var doubleStringInt = Outer<Double>().Inner<String>().foo<Int>()()
 
         private fun bar() {
-            doubleCharSequenceInt = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>doubleStringNumber<!>
+            doubleCharSequenceInt = <!TYPE_MISMATCH!>doubleStringNumber<!>
             doubleCharSequenceInt = doubleStringInt
 
             doubleStringInt = Outer<Double>().Inner<String>().foo<Int>()()
diff --git a/compiler/testData/diagnostics/tests/generics/capturedParameters/localClass.kt b/compiler/testData/diagnostics/tests/generics/capturedParameters/localClass.kt
index 8f5b7adb8af..983949fc3e9 100644
--- a/compiler/testData/diagnostics/tests/generics/capturedParameters/localClass.kt
+++ b/compiler/testData/diagnostics/tests/generics/capturedParameters/localClass.kt
@@ -15,7 +15,7 @@ class Q {
     private var y = <!DEBUG_INFO_LEAKING_THIS!>foo<!><String>()()
 
     fun bar() {
-        x = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!>
+        x = <!TYPE_MISMATCH!>y<!>
         x = foo<CharSequence>()()
         y = foo<String>()()
 
diff --git a/compiler/testData/diagnostics/tests/generics/capturedParameters/objectLiteral.kt b/compiler/testData/diagnostics/tests/generics/capturedParameters/objectLiteral.kt
index c9ea22ad7b3..08cd7c2008a 100644
--- a/compiler/testData/diagnostics/tests/generics/capturedParameters/objectLiteral.kt
+++ b/compiler/testData/diagnostics/tests/generics/capturedParameters/objectLiteral.kt
@@ -13,7 +13,7 @@ class Q {
     private var y = <!DEBUG_INFO_LEAKING_THIS!>foo<!><String>()
 
     fun bar() {
-        x = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!>
+        x = <!TYPE_MISMATCH!>y<!>
         x = foo<CharSequence>()
         y = foo<String>()
 
diff --git a/compiler/testData/diagnostics/tests/generics/innerClasses/iterator.kt b/compiler/testData/diagnostics/tests/generics/innerClasses/iterator.kt
index 87e065d0ce3..ba8304bdef5 100644
--- a/compiler/testData/diagnostics/tests/generics/innerClasses/iterator.kt
+++ b/compiler/testData/diagnostics/tests/generics/innerClasses/iterator.kt
@@ -29,7 +29,7 @@ fun <E> commonSupertype(x: E, y: E): E = x
 
 fun foo() {
     var myIt = A<String>().iterator()
-    myIt = <!TYPE_MISMATCH!>A<Int>().<!NI;TYPE_MISMATCH!>iterator()<!><!>
+    myIt = <!TYPE_MISMATCH!>A<Int>().iterator()<!>
 
     val csIt: Iterator<CharSequence> = A<String>().iterator()
 
diff --git a/compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedOuter.kt b/compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedOuter.kt
index 4c8e862fbf7..9dab49456cb 100644
--- a/compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedOuter.kt
+++ b/compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedOuter.kt
@@ -11,7 +11,7 @@ class Outer<T> {
         z.checkType { _<Inner>() }
         z.checkType { _<Outer<T>.Inner>() }
 
-        inner = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>x<!>
+        inner = <!TYPE_MISMATCH!>x<!>
     }
 
     class Nested
diff --git a/compiler/testData/diagnostics/tests/generics/nullability/considerTypeNotNullOnlyIfItHasNotNullBound.kt b/compiler/testData/diagnostics/tests/generics/nullability/considerTypeNotNullOnlyIfItHasNotNullBound.kt
index e791f13517f..db106d01917 100644
--- a/compiler/testData/diagnostics/tests/generics/nullability/considerTypeNotNullOnlyIfItHasNotNullBound.kt
+++ b/compiler/testData/diagnostics/tests/generics/nullability/considerTypeNotNullOnlyIfItHasNotNullBound.kt
@@ -1,6 +1,6 @@
 // !LANGUAGE: +NewInference
 
 inline fun <T, reified S> foo(x: T?, y: T): T {
-    if (x is S) return <!TYPE_MISMATCH, TYPE_MISMATCH!>x<!>
+    if (x is S) return <!TYPE_MISMATCH!>x<!>
     return y
 }
diff --git a/compiler/testData/diagnostics/tests/generics/nullability/smartCastsValueArgument.kt b/compiler/testData/diagnostics/tests/generics/nullability/smartCastsValueArgument.kt
index 92486a37bc2..7449ffe9b10 100644
--- a/compiler/testData/diagnostics/tests/generics/nullability/smartCastsValueArgument.kt
+++ b/compiler/testData/diagnostics/tests/generics/nullability/smartCastsValueArgument.kt
@@ -12,7 +12,7 @@ fun <T : CharSequence?> foo(x: T) {
         if (<!SENSELESS_COMPARISON!>x != null<!>) {}
 
         y1 = <!DEBUG_INFO_SMARTCAST!>x<!>
-        y2 = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>x<!>
+        y2 = <!TYPE_MISMATCH!>x<!>
 
         <!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>bar1<!>(<!NI;DEBUG_INFO_SMARTCAST!>x<!>)
         bar1<CharSequence>(<!DEBUG_INFO_SMARTCAST!>x<!>)
@@ -31,7 +31,7 @@ fun <T : CharSequence?> foo(x: T) {
 
     if (x is CharSequence) {
         y1 = <!DEBUG_INFO_SMARTCAST!>x<!>
-        y2 = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>x<!>
+        y2 = <!TYPE_MISMATCH!>x<!>
 
         bar1(<!DEBUG_INFO_SMARTCAST!>x<!>)
         bar2(<!DEBUG_INFO_SMARTCAST!>x<!>)
diff --git a/compiler/testData/diagnostics/tests/generics/nullability/tpInBounds.kt b/compiler/testData/diagnostics/tests/generics/nullability/tpInBounds.kt
index fd2989b84c0..2294e02915e 100644
--- a/compiler/testData/diagnostics/tests/generics/nullability/tpInBounds.kt
+++ b/compiler/testData/diagnostics/tests/generics/nullability/tpInBounds.kt
@@ -24,10 +24,10 @@ class A<T : CharSequence?, E1 : T, E2: T?> {
         }
 
         if (1 == 1) {
-            t = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>tN<!>
+            t = <!TYPE_MISMATCH!>tN<!>
         }
 
-        t = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!>
+        t = <!TYPE_MISMATCH!>y<!>
 
         if (y != null) {
             t = <!DEBUG_INFO_SMARTCAST!>y<!>
diff --git a/compiler/testData/diagnostics/tests/generics/projectionsScope/kt7296.kt b/compiler/testData/diagnostics/tests/generics/projectionsScope/kt7296.kt
index 44c46edf58d..a34babd823e 100644
--- a/compiler/testData/diagnostics/tests/generics/projectionsScope/kt7296.kt
+++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/kt7296.kt
@@ -9,7 +9,7 @@ fun main() {
     val a : ArrayList<ArrayList<String>> = ArrayList()
     val b : ListOfLists<String> = ListOfLists(a)
     val c : ListOfLists<*> = b
-    val d : ArrayList<ArrayList<*>> = <!TYPE_MISMATCH!>c.<!NI;TYPE_MISMATCH!>x<!><!>
+    val d : ArrayList<ArrayList<*>> = <!TYPE_MISMATCH!>c.x<!>
 
     c.x checkType { _<ArrayList<out ArrayList<*>>>() }
 }
diff --git a/compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchInLambda.kt b/compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchInLambda.kt
index ae517f771ab..24eb799068e 100644
--- a/compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchInLambda.kt
+++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchInLambda.kt
@@ -18,7 +18,7 @@ fun test(a: A<out CharSequence>, z: Out<CharSequence>) {
     }
     a.bar { <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>Out<CharSequence>()<!> }
     a.bar { <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>Out<!>() }
-    a.bar { <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>z.<!NI;TYPE_MISMATCH!>id()<!><!> }
+    a.bar { <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>z.id()<!> }
 
     a.foo {
         z.foobar(if (1 > 2) return@foo <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>""<!> else "")
diff --git a/compiler/testData/diagnostics/tests/generics/varProjection/setterNotProjectedOutAssign.kt b/compiler/testData/diagnostics/tests/generics/varProjection/setterNotProjectedOutAssign.kt
index b72c5e14314..3a985d9f749 100644
--- a/compiler/testData/diagnostics/tests/generics/varProjection/setterNotProjectedOutAssign.kt
+++ b/compiler/testData/diagnostics/tests/generics/varProjection/setterNotProjectedOutAssign.kt
@@ -5,6 +5,6 @@ interface Tr<T> {
 }
 
 fun test(t: Tr<*>) {
-    <!SETTER_PROJECTED_OUT!>t.v<!> = <!NI;TYPE_MISMATCH!>t<!>
+    <!SETTER_PROJECTED_OUT!>t.v<!> = t
     t.v checkType { _<Tr<*>>() }
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionToUnitForIfAsLastExpressionInLambda.kt b/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionToUnitForIfAsLastExpressionInLambda.kt
index b232d44632e..056d3472cc6 100644
--- a/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionToUnitForIfAsLastExpressionInLambda.kt
+++ b/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionToUnitForIfAsLastExpressionInLambda.kt
@@ -12,7 +12,7 @@ fun foo(): String? {
     run {
         if (true) return@run
 
-        if (true) return <!TYPE_MISMATCH, TYPE_MISMATCH!>Obj()<!> // correct error, type check against return type of function "foo"
+        if (true) return <!TYPE_MISMATCH!>Obj()<!> // correct error, type check against return type of function "foo"
     }
 
     run {
diff --git a/compiler/testData/diagnostics/tests/inference/kt1293.kt b/compiler/testData/diagnostics/tests/inference/kt1293.kt
index bc4bc63e5ea..9d48301a5cc 100644
--- a/compiler/testData/diagnostics/tests/inference/kt1293.kt
+++ b/compiler/testData/diagnostics/tests/inference/kt1293.kt
@@ -5,7 +5,7 @@ package kt1293
 
 fun main() {
     val intArray = arrayOfNulls<Int>(10)
-    val <!UNUSED_VARIABLE!>i<!> : Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>intArray[0]<!>
+    val <!UNUSED_VARIABLE!>i<!> : Int = <!TYPE_MISMATCH!>intArray[0]<!>
     requiresInt(<!TYPE_MISMATCH!>intArray[0]<!>)
 }
 
diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2883.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt2883.kt
index 572ab5a249b..31cb85319f3 100644
--- a/compiler/testData/diagnostics/tests/inference/regressions/kt2883.kt
+++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2883.kt
@@ -29,5 +29,5 @@ fun testWithoutInference(col: MutableCollection<Int>) {
     
     doAction { col.add(2) }
     
-    val <!UNUSED_VARIABLE!>u<!>: Unit = <!TYPE_MISMATCH!>col.<!NI;TYPE_MISMATCH!>add(2)<!><!>
+    val <!UNUSED_VARIABLE!>u<!>: Unit = <!TYPE_MISMATCH!>col.add(2)<!>
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/inference/upperBounds/useBoundsIfUnknownParameters.kt b/compiler/testData/diagnostics/tests/inference/upperBounds/useBoundsIfUnknownParameters.kt
index 1bb4b7d73a4..fb46c5cf4c5 100644
--- a/compiler/testData/diagnostics/tests/inference/upperBounds/useBoundsIfUnknownParameters.kt
+++ b/compiler/testData/diagnostics/tests/inference/upperBounds/useBoundsIfUnknownParameters.kt
@@ -8,5 +8,5 @@ class Client<T, X: Base<T>>(<!UNUSED_PARAMETER!>x<!>: X)
 
 fun test() {
     val c = Client(StringBase()) // Type inference fails here for T.
-    val <!UNUSED_VARIABLE!>i<!> : Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>c<!>
+    val <!UNUSED_VARIABLE!>i<!> : Int = <!TYPE_MISMATCH!>c<!>
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/infos/SmartCasts.kt b/compiler/testData/diagnostics/tests/infos/SmartCasts.kt
index c4c51b922d9..f410f1e4479 100644
--- a/compiler/testData/diagnostics/tests/infos/SmartCasts.kt
+++ b/compiler/testData/diagnostics/tests/infos/SmartCasts.kt
@@ -149,7 +149,7 @@ fun illegalWhenBody(a: Any): Int = <!NI;TYPE_MISMATCH!><!NO_ELSE_IN_WHEN!>when<!
 fun illegalWhenBlock(a: Any): Int {
     when(a) {
         is Int -> return <!DEBUG_INFO_SMARTCAST!>a<!>
-        is String -> return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>a<!>
+        is String -> return <!TYPE_MISMATCH!>a<!>
     }
 <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 fun declarations(a: Any?) {
@@ -222,7 +222,7 @@ fun f(): String {
 fun foo(aa: Any?): Int {
     var a = aa
     if (a is Int?) {
-        return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>a<!>
+        return <!TYPE_MISMATCH!>a<!>
     }
     return 1
 }
diff --git a/compiler/testData/diagnostics/tests/inline/inlineLambdaInDefaultInlineParameterDisabled.kt b/compiler/testData/diagnostics/tests/inline/inlineLambdaInDefaultInlineParameterDisabled.kt
index 90ae1b88905..ef3dae6f475 100644
--- a/compiler/testData/diagnostics/tests/inline/inlineLambdaInDefaultInlineParameterDisabled.kt
+++ b/compiler/testData/diagnostics/tests/inline/inlineLambdaInDefaultInlineParameterDisabled.kt
@@ -7,7 +7,7 @@ inline fun inlineFun(lambda: () -> String) = lambda()
 fun noInlineFun(lambda: () -> String) = lambda()
 
 
-inline fun default0_1(lambda: () -> String, <!NOT_YET_SUPPORTED_IN_INLINE!>dlambda: () -> String = { <!NI;TYPE_MISMATCH, TYPE_MISMATCH, USAGE_IS_NOT_INLINABLE!>lambda<!> }<!>) {
+inline fun default0_1(lambda: () -> String, <!NOT_YET_SUPPORTED_IN_INLINE!>dlambda: () -> String = { <!TYPE_MISMATCH, USAGE_IS_NOT_INLINABLE!>lambda<!> }<!>) {
     lambda() + dlambda()
 }
 
diff --git a/compiler/testData/diagnostics/tests/j+k/samByProjectedType/genericInReturnType.kt b/compiler/testData/diagnostics/tests/j+k/samByProjectedType/genericInReturnType.kt
index d050d43e045..d5cbb3e3f9b 100644
--- a/compiler/testData/diagnostics/tests/j+k/samByProjectedType/genericInReturnType.kt
+++ b/compiler/testData/diagnostics/tests/j+k/samByProjectedType/genericInReturnType.kt
@@ -34,7 +34,7 @@ fun main() {
     }
 
     A.baz {
-        x -> <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>x.<!NI;TYPE_MISMATCH!>hashCode()<!><!>
+        x -> <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>x.hashCode()<!>
     }
 
     val block: (String) -> Any? = {
diff --git a/compiler/testData/diagnostics/tests/kt310.kt b/compiler/testData/diagnostics/tests/kt310.kt
index d6418045280..a1670061adf 100644
--- a/compiler/testData/diagnostics/tests/kt310.kt
+++ b/compiler/testData/diagnostics/tests/kt310.kt
@@ -1,5 +1,5 @@
 // !WITH_NEW_INFERENCE
 
 fun f(c: LongRange): Int {
-    return c.<!FUNCTION_EXPECTED, NI;TYPE_MISMATCH!>start<!>()
+    return c.<!FUNCTION_EXPECTED!>start<!>()
 }
diff --git a/compiler/testData/diagnostics/tests/library/Collections.kt b/compiler/testData/diagnostics/tests/library/Collections.kt
index 1592e16bab7..0cd0c7e695e 100644
--- a/compiler/testData/diagnostics/tests/library/Collections.kt
+++ b/compiler/testData/diagnostics/tests/library/Collections.kt
@@ -8,7 +8,7 @@ fun <T> testCollection(c: Collection<T>, t: T) {
     val <!UNUSED_VARIABLE!>iterator<!>: Iterator<T> = c.iterator()
     c.containsAll(c)
 
-    val <!UNUSED_VARIABLE!>mutableIterator<!>: MutableIterator<T> = <!TYPE_MISMATCH!>c.<!NI;TYPE_MISMATCH!>iterator()<!><!>
+    val <!UNUSED_VARIABLE!>mutableIterator<!>: MutableIterator<T> = <!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>, <!UNUSED_PARAMETER!>t<!>: T) {
     val <!UNUSED_VARIABLE!>value<!>: T = l.<!UNRESOLVED_REFERENCE!>set<!>(1, t)
     l.<!UNRESOLVED_REFERENCE!>add<!>(1, t)
     l.<!UNRESOLVED_REFERENCE!>remove<!>(1)
-    val <!UNUSED_VARIABLE!>mutableListIterator<!>: MutableListIterator<T> = <!TYPE_MISMATCH!>l.<!NI;TYPE_MISMATCH!>listIterator()<!><!>
-    val <!UNUSED_VARIABLE!>mutableListIterator1<!>: MutableListIterator<T> = <!TYPE_MISMATCH!>l.<!NI;TYPE_MISMATCH!>listIterator(1)<!><!>
-    val <!UNUSED_VARIABLE!>mutableList<!>: MutableList<T> = <!TYPE_MISMATCH!>l.<!NI;TYPE_MISMATCH!>subList(1, 2)<!><!>
+    val <!UNUSED_VARIABLE!>mutableListIterator<!>: MutableListIterator<T> = <!TYPE_MISMATCH!>l.listIterator()<!>
+    val <!UNUSED_VARIABLE!>mutableListIterator1<!>: MutableListIterator<T> = <!TYPE_MISMATCH!>l.listIterator(1)<!>
+    val <!UNUSED_VARIABLE!>mutableList<!>: MutableList<T> = <!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 <!UNUSED_VARIABLE!>iterator<!>: Iterator<T> = s.iterator()
     s.containsAll(s)
 
-    val <!UNUSED_VARIABLE!>mutableIterator<!>: MutableIterator<T> = <!TYPE_MISMATCH!>s.<!NI;TYPE_MISMATCH!>iterator()<!><!>
+    val <!UNUSED_VARIABLE!>mutableIterator<!>: MutableIterator<T> = <!TYPE_MISMATCH!>s.iterator()<!>
     s.<!UNRESOLVED_REFERENCE!>add<!>(t)
     s.<!UNRESOLVED_REFERENCE!>remove<!>(1)
     s.<!UNRESOLVED_REFERENCE!>addAll<!>(s)
@@ -97,9 +97,9 @@ fun <K, V> testMap(m: Map<K, V>) {
     val <!UNUSED_VARIABLE!>collection<!>: Collection<V> = m.values
     val <!UNUSED_VARIABLE!>set1<!>: Set<Map.Entry<K, V>> = m.entries
 
-    val <!UNUSED_VARIABLE!>mutableSet<!>: MutableSet<K> = <!TYPE_MISMATCH!>m.<!NI;TYPE_MISMATCH!>keys<!><!>
-    val <!UNUSED_VARIABLE!>mutableCollection<!>: MutableCollection<V> = <!TYPE_MISMATCH!>m.<!NI;TYPE_MISMATCH!>values<!><!>
-    val <!UNUSED_VARIABLE!>mutableSet1<!>: MutableSet<MutableMap.MutableEntry<K, V>> = <!TYPE_MISMATCH!>m.<!NI;TYPE_MISMATCH!>entries<!><!>
+    val <!UNUSED_VARIABLE!>mutableSet<!>: MutableSet<K> = <!TYPE_MISMATCH!>m.keys<!>
+    val <!UNUSED_VARIABLE!>mutableCollection<!>: MutableCollection<V> = <!TYPE_MISMATCH!>m.values<!>
+    val <!UNUSED_VARIABLE!>mutableSet1<!>: MutableSet<MutableMap.MutableEntry<K, V>> = <!TYPE_MISMATCH!>m.entries<!>
 }
 
 fun <K, V> testMutableMap(m: MutableMap<K, V>) {
diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/sameClassNameDifferentPackages.kt b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/sameClassNameDifferentPackages.kt
index 6222bdb2084..bbbfcb18a17 100644
--- a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/sameClassNameDifferentPackages.kt
+++ b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/sameClassNameDifferentPackages.kt
@@ -18,5 +18,5 @@ import p.*
 class A
 
 fun test() {
-    val a: A = <!TYPE_MISMATCH!>B().<!NI;TYPE_MISMATCH!>a<!><!>
+    val a: A = <!TYPE_MISMATCH!>B().a<!>
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/objects/kt5527.kt b/compiler/testData/diagnostics/tests/objects/kt5527.kt
index 7a91f73e041..0a8853e73f2 100644
--- a/compiler/testData/diagnostics/tests/objects/kt5527.kt
+++ b/compiler/testData/diagnostics/tests/objects/kt5527.kt
@@ -7,13 +7,13 @@ class A {
 }
 
 fun foo() {
-    val i1: Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>Boo<!>
-    val i2: Int = <!TYPE_MISMATCH!>A.<!NI;TYPE_MISMATCH!>Boo<!><!>
+    val i1: Int = <!TYPE_MISMATCH!>Boo<!>
+    val i2: Int = <!TYPE_MISMATCH!>A.Boo<!>
     useInt(<!TYPE_MISMATCH!>Boo<!>)
     useInt(<!TYPE_MISMATCH!>A.Boo<!>)
 }
 fun bar() {
-    val i1: Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>Unit<!>
+    val i1: Int = <!TYPE_MISMATCH!>Unit<!>
     useInt(<!TYPE_MISMATCH!>Unit<!>)
 }
 
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/assignToVar.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/assignToVar.kt
index af8ca09962a..bcc125ee286 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/assignToVar.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/assignToVar.kt
@@ -18,7 +18,7 @@ var n: J? = J()
 
 fun test() {
     v = J.staticNN
-    v = <!TYPE_MISMATCH!>J.<!NI;TYPE_MISMATCH!>staticN<!><!>
+    v = <!TYPE_MISMATCH!>J.staticN<!>
     v = J.staticJ
 
     n = J.staticNN
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/conditions.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/conditions.kt
index f85f0a4ab7d..cda8720e916 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/conditions.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/conditions.kt
@@ -23,23 +23,23 @@ fun test() {
     val platformJ = J.staticJ
 
     if (platformNN) {}
-    if (<!NI;TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>platformN<!>) {}
+    if (<!TYPE_MISMATCH, TYPE_MISMATCH!>platformN<!>) {}
     if (platformJ) {}
 
     while (platformNN) {}
-    while (<!NI;TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>platformN<!>) {}
+    while (<!TYPE_MISMATCH, TYPE_MISMATCH!>platformN<!>) {}
     while (platformJ) {}
 
     do {} while (platformNN)
-    do {} while (<!NI;TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>platformN<!>)
+    do {} while (<!TYPE_MISMATCH, TYPE_MISMATCH!>platformN<!>)
     do {} while (platformJ)
 
     platformNN && false
-    <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>platformN<!> && false
+    <!TYPE_MISMATCH!>platformN<!> && false
     platformJ && false
 
     platformNN || false
-    <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>platformN<!> || false
+    <!TYPE_MISMATCH!>platformN<!> || false
     platformJ || false
 
     !platformNN
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/dataFlowInfo.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/dataFlowInfo.kt
index 95185820c8c..8af77c1813a 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/dataFlowInfo.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/dataFlowInfo.kt
@@ -16,14 +16,14 @@ public class J {
 fun test() {
     val n = J.staticN
     foo(<!TYPE_MISMATCH!>n<!>)
-    J.staticNN = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>n<!>
+    J.staticNN = <!TYPE_MISMATCH!>n<!>
     if (n != null) {
         foo(<!DEBUG_INFO_SMARTCAST!>n<!>)
         J.staticNN = <!DEBUG_INFO_SMARTCAST!>n<!>
     }
 
     val x: J? = null
-    J.staticNN = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>x<!>
+    J.staticNN = <!TYPE_MISMATCH!>x<!>
     if (x != null) {
         J.staticNN = <!DEBUG_INFO_SMARTCAST!>x<!>
     }
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/defaultParameters.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/defaultParameters.kt
index 4fcd0a226e3..6d74135a4b6 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/defaultParameters.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/defaultParameters.kt
@@ -22,7 +22,7 @@ fun test() {
     // platform type with no annotation
     val platformJ = J.staticJ
 
-    fun foo(p: J = platformNN, p1: J = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>platformN<!>, p2: J = platformJ) {}
+    fun foo(p: J = platformNN, p1: J = <!TYPE_MISMATCH!>platformN<!>, p2: J = platformJ) {}
 
     fun foo1(p: J? = platformNN, p1: J? = platformN, p2: J? = platformJ) {}
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegation.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegation.kt
index 9d1d64943ff..6b878d86363 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegation.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegation.kt
@@ -15,5 +15,5 @@ public class J {
 // FILE: k.kt
 
 class A : List<String> by J.staticNN
-class B : List<String> by <!TYPE_MISMATCH!>J.<!NI;TYPE_MISMATCH!>staticN<!><!>
+class B : List<String> by <!TYPE_MISMATCH!>J.staticN<!>
 class C : List<String> by J.staticJ
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/passToJava.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/passToJava.kt
index f24b25d06b2..c2367edb4df 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/passToJava.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/passToJava.kt
@@ -34,8 +34,8 @@ fun test(n: J?, nn: J) {
     // platform type with no annotation
     val platformJ = J.staticJ
 
-    J.staticNN = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>n<!>
-    J.staticNN = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>platformN<!>
+    J.staticNN = <!TYPE_MISMATCH!>n<!>
+    J.staticNN = <!TYPE_MISMATCH!>platformN<!>
     J.staticNN = nn
     J.staticNN = platformNN
     J.staticNN = platformJ
@@ -58,8 +58,8 @@ fun test(n: J?, nn: J) {
     J.staticSet(<!TYPE_MISMATCH!>platformN<!>, platformN, platformN)
     J.staticSet(platformJ, platformJ, platformJ)
 
-    J().nn = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>n<!>
-    J().nn = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>platformN<!>
+    J().nn = <!TYPE_MISMATCH!>n<!>
+    J().nn = <!TYPE_MISMATCH!>platformN<!>
     J().nn = nn
     J().nn = platformNN
     J().nn = platformJ
diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/throw.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/throw.kt
index 3c9cf3d9fb7..87f626a5219 100644
--- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/throw.kt
+++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/throw.kt
@@ -18,7 +18,7 @@ fun test() {
 }
 
 fun test1() {
-    throw <!TYPE_MISMATCH!>J.<!NI;TYPE_MISMATCH!>staticN<!><!>
+    throw <!TYPE_MISMATCH!>J.staticN<!>
 }
 
 fun test2() {
diff --git a/compiler/testData/diagnostics/tests/regressions/TypeMismatchOnUnaryOperations.kt b/compiler/testData/diagnostics/tests/regressions/TypeMismatchOnUnaryOperations.kt
index ec127c52f8a..147fb077a67 100644
--- a/compiler/testData/diagnostics/tests/regressions/TypeMismatchOnUnaryOperations.kt
+++ b/compiler/testData/diagnostics/tests/regressions/TypeMismatchOnUnaryOperations.kt
@@ -2,7 +2,7 @@
 fun main() {
     val a : Int? = null;
     var v = 1
-    val <!UNUSED_VARIABLE!>b<!> : String = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>v<!>;
+    val <!UNUSED_VARIABLE!>b<!> : String = <!TYPE_MISMATCH!>v<!>;
     val <!UNUSED_VARIABLE!>f<!> : String = <!NI;TYPE_MISMATCH!><!OI;TYPE_MISMATCH!>a<!>!!<!>;
     val <!UNUSED_VARIABLE!>g<!> : String = <!TYPE_MISMATCH!>v++<!>;
     val <!UNUSED_VARIABLE!>g1<!> : String = <!TYPE_MISMATCH!>++v<!>;
diff --git a/compiler/testData/diagnostics/tests/regressions/kt251.kt b/compiler/testData/diagnostics/tests/regressions/kt251.kt
index 9d871865dbe..fb980b2f916 100644
--- a/compiler/testData/diagnostics/tests/regressions/kt251.kt
+++ b/compiler/testData/diagnostics/tests/regressions/kt251.kt
@@ -3,7 +3,7 @@ class A() {
     var x: Int = 0
         get() = <!TYPE_MISMATCH!>"s"<!>
         set(value: <!WRONG_SETTER_PARAMETER_TYPE!>String<!>) {
-            field = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>value<!>
+            field = <!TYPE_MISMATCH!>value<!>
         }
     val y: Int
         get(): <!WRONG_GETTER_RETURN_TYPE("Int", "String")!>String<!> = "s"
@@ -28,7 +28,7 @@ class A() {
         }
     val e = 1
         get(): <!WRONG_GETTER_RETURN_TYPE!>String<!> {
-            return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>field<!>
+            return <!TYPE_MISMATCH!>field<!>
         }
 
 }
diff --git a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/originalExamples.kt b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/originalExamples.kt
index cd9609d816e..1123643b69f 100644
--- a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/originalExamples.kt
+++ b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/originalExamples.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 = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>overloadedFun1(b = "")<!>
+val test1a: Wrong = <!TYPE_MISMATCH!>overloadedFun1(b = "")<!>
 
 fun overloadedFun2(a: String, b: Any = "") = Right
 fun overloadedFun2(a: Any, b: String = "") = Wrong
diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/methodsPriority.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/methodsPriority.kt
index a4ebd9f766e..e969432d437 100644
--- a/compiler/testData/diagnostics/tests/scopes/inheritance/methodsPriority.kt
+++ b/compiler/testData/diagnostics/tests/scopes/inheritance/methodsPriority.kt
@@ -20,7 +20,7 @@ fun test() {
 
     class B: A() {
         init {
-            val a: Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>foo()<!> // todo
+            val a: Int = <!TYPE_MISMATCH!>foo()<!> // todo
         }
     }
 }
diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_after.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_after.kt
index 52b535bcf50..44224abe785 100644
--- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_after.kt
+++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_after.kt
@@ -12,14 +12,14 @@ open class A<T> : J() {
     init {
         foo()
         bar()
-        val a: Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!><!DEBUG_INFO_LEAKING_THIS!>baz<!>()<!>
+        val a: Int = <!TYPE_MISMATCH!><!DEBUG_INFO_LEAKING_THIS!>baz<!>()<!>
         val b: T = <!DEBUG_INFO_LEAKING_THIS!>baz<!>()
     }
 
     fun test1() {
         foo()
         bar()
-        val a: Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>baz()<!>
+        val a: Int = <!TYPE_MISMATCH!>baz()<!>
         val b: T = baz()
     }
 
diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_before.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_before.kt
index c14253fe0de..fa1f16a60f9 100644
--- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_before.kt
+++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_before.kt
@@ -12,14 +12,14 @@ open class A<T> : J() {
     init {
         <!DEPRECATED_ACCESS_BY_SHORT_NAME!>foo()<!>
         bar()
-        val a: Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!><!DEBUG_INFO_LEAKING_THIS!>baz<!>()<!>
+        val a: Int = <!TYPE_MISMATCH!><!DEBUG_INFO_LEAKING_THIS!>baz<!>()<!>
         val b: T = <!DEBUG_INFO_LEAKING_THIS!>baz<!>()
     }
 
     fun test1() {
         <!DEPRECATED_ACCESS_BY_SHORT_NAME!>foo()<!>
         bar()
-        val a: Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>baz()<!>
+        val a: Int = <!TYPE_MISMATCH!>baz()<!>
         val b: T = baz()
     }
 
diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/localVsStatic.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/localVsStatic.kt
index 69dc5a99286..912bd91a5c3 100644
--- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/localVsStatic.kt
+++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/localVsStatic.kt
@@ -21,7 +21,7 @@ fun test() {
 
     class B: A() {
         init {
-            val a: Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>foo()<!> // todo
+            val a: Int = <!TYPE_MISMATCH!>foo()<!> // todo
         }
     }
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/script/destructuringDeclarationsScript.kts b/compiler/testData/diagnostics/tests/script/destructuringDeclarationsScript.kts
index f2f56b93dbb..7852cf28d9f 100644
--- a/compiler/testData/diagnostics/tests/script/destructuringDeclarationsScript.kts
+++ b/compiler/testData/diagnostics/tests/script/destructuringDeclarationsScript.kts
@@ -1,6 +1,6 @@
 // !WITH_NEW_INFERENCE
 val (a1, a2) = A()
-val (b1: Int, <!NI;TYPE_MISMATCH!>b2: Int<!>) = <!OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>A()<!>
+val (b1: Int, b2: Int) = <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>A()<!>
 val (c1) = <!UNRESOLVED_REFERENCE!>unresolved<!>
 
 <!WRONG_MODIFIER_TARGET!>private<!> val (d1) = A()
diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/return.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/return.kt
index e1dd6ba90cf..28315408a5a 100644
--- a/compiler/testData/diagnostics/tests/secondaryConstructors/return.kt
+++ b/compiler/testData/diagnostics/tests/secondaryConstructors/return.kt
@@ -10,7 +10,7 @@ class A {
             return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>
         }
         return
-        return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>foo()<!>
+        return <!TYPE_MISMATCH!>foo()<!>
     }<!>
 
     fun foo(): Int = 1
diff --git a/compiler/testData/diagnostics/tests/smartCasts/elvisExprNotNull.kt b/compiler/testData/diagnostics/tests/smartCasts/elvisExprNotNull.kt
index bb233920b03..64769d9391d 100644
--- a/compiler/testData/diagnostics/tests/smartCasts/elvisExprNotNull.kt
+++ b/compiler/testData/diagnostics/tests/smartCasts/elvisExprNotNull.kt
@@ -33,5 +33,5 @@ fun baz(s: String?, r: String?): String {
 fun withNull(s: String?): String {
     val t = s <!USELESS_ELVIS_RIGHT_IS_NULL!>?: null<!>
     // Error: nullable
-    return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>t<!>
+    return <!TYPE_MISMATCH!>t<!>
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/smartCasts/explicitDefaultGetter.kt b/compiler/testData/diagnostics/tests/smartCasts/explicitDefaultGetter.kt
index 5ea8a1752dd..30710c6791b 100644
--- a/compiler/testData/diagnostics/tests/smartCasts/explicitDefaultGetter.kt
+++ b/compiler/testData/diagnostics/tests/smartCasts/explicitDefaultGetter.kt
@@ -5,7 +5,7 @@ class ExplicitAccessorForAnnotation {
 
     fun foo(): String {
         if (tt is String) {
-            return <!NI;TYPE_MISMATCH, SMARTCAST_IMPOSSIBLE!>tt<!>
+            return <!SMARTCAST_IMPOSSIBLE!>tt<!>
         }
         return ""
     }
diff --git a/compiler/testData/diagnostics/tests/smartCasts/propertyToNotNull.kt b/compiler/testData/diagnostics/tests/smartCasts/propertyToNotNull.kt
index 88c4bcc346d..412d720a42b 100644
--- a/compiler/testData/diagnostics/tests/smartCasts/propertyToNotNull.kt
+++ b/compiler/testData/diagnostics/tests/smartCasts/propertyToNotNull.kt
@@ -8,7 +8,7 @@ class Immutable(val x: String?) {
 
 class Mutable(var y: String?) {
     fun foo(): String {
-        if (y != null) return <!NI;TYPE_MISMATCH, SMARTCAST_IMPOSSIBLE!>y<!>
+        if (y != null) return <!SMARTCAST_IMPOSSIBLE!>y<!>
         return ""
     }
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/smartCasts/safecalls/anotherVal.kt b/compiler/testData/diagnostics/tests/smartCasts/safecalls/anotherVal.kt
index 53fe4471413..a8da3729430 100644
--- a/compiler/testData/diagnostics/tests/smartCasts/safecalls/anotherVal.kt
+++ b/compiler/testData/diagnostics/tests/smartCasts/safecalls/anotherVal.kt
@@ -3,6 +3,6 @@
 fun calc(x: List<String>?, y: Int?): Int {
     x?.get(y!! - 1) 
     // y!! above should not provide smart cast here
-    val yy: Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!>
+    val yy: Int = <!TYPE_MISMATCH!>y<!>
     return  yy + (x?.size ?: 0)
 }
diff --git a/compiler/testData/diagnostics/tests/smartCasts/safecalls/falseSecondArgument.kt b/compiler/testData/diagnostics/tests/smartCasts/safecalls/falseSecondArgument.kt
index be5976f2ac4..3a975a23af6 100644
--- a/compiler/testData/diagnostics/tests/smartCasts/safecalls/falseSecondArgument.kt
+++ b/compiler/testData/diagnostics/tests/smartCasts/safecalls/falseSecondArgument.kt
@@ -3,5 +3,5 @@
 fun calc(x: List<String>?, y: Int?): Int {
     x?.subList(y!! - 1, <!DEBUG_INFO_SMARTCAST!>y<!>)
     // y!! above should not provide smart cast here
-    return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!>
+    return <!TYPE_MISMATCH!>y<!>
 }
diff --git a/compiler/testData/diagnostics/tests/smartCasts/safecalls/receiverAndChainFalse.kt b/compiler/testData/diagnostics/tests/smartCasts/safecalls/receiverAndChainFalse.kt
index 977c7d5dffb..7adff29007f 100644
--- a/compiler/testData/diagnostics/tests/smartCasts/safecalls/receiverAndChainFalse.kt
+++ b/compiler/testData/diagnostics/tests/smartCasts/safecalls/receiverAndChainFalse.kt
@@ -6,5 +6,5 @@ fun calc(x: String?, y: Int?): Int {
     // Smart cast because of x!! in receiver
     foo(x!!)?.subSequence(y!!, <!DEBUG_INFO_SMARTCAST!>x<!>.length)?.length
     // No smart cast possible
-    return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!>
+    return <!TYPE_MISMATCH!>y<!>
 }
diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEach.kt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEach.kt
index f94434b040c..3506cfcb632 100644
--- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEach.kt
+++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEach.kt
@@ -13,5 +13,5 @@ fun list(start: SomeObject): SomeObject {
         e = e<!UNSAFE_CALL!>.<!>next()
     }
     // Smart cast is not possible here due to next()
-    return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>e<!>
+    return <!TYPE_MISMATCH!>e<!>
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEachWithBreak.kt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEachWithBreak.kt
index 632cf602232..7516bcd91d0 100644
--- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEachWithBreak.kt
+++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEachWithBreak.kt
@@ -14,5 +14,5 @@ fun list(start: SomeObject): SomeObject {
         <!DEBUG_INFO_SMARTCAST!>e<!>.doSomething()
         e = <!DEBUG_INFO_SMARTCAST!>e<!>.next()
     }
-    return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>e<!>
+    return <!TYPE_MISMATCH!>e<!>
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEachWithContinue.kt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEachWithContinue.kt
index 8d5bd026ddf..2a779baae76 100644
--- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEachWithContinue.kt
+++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEachWithContinue.kt
@@ -14,5 +14,5 @@ fun list(start: SomeObject): SomeObject {
         <!DEBUG_INFO_SMARTCAST!>e<!>.doSomething()
         e = <!DEBUG_INFO_SMARTCAST!>e<!>.next()
     }
-    return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>e<!>
+    return <!TYPE_MISMATCH!>e<!>
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/varIntNull.kt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/varIntNull.kt
index 4d9e5236463..ad110456f2f 100644
--- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/varIntNull.kt
+++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/varIntNull.kt
@@ -2,5 +2,5 @@
 fun foo(): Int {
     var i: Int? = <!VARIABLE_WITH_REDUNDANT_INITIALIZER!>42<!>
     i = null
-    return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!><!OI;DEBUG_INFO_CONSTANT!>i<!> + 1<!>
+    return <!TYPE_MISMATCH!><!OI;DEBUG_INFO_CONSTANT!>i<!> + 1<!>
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/subtyping/localClasses.kt b/compiler/testData/diagnostics/tests/subtyping/localClasses.kt
index 7f974b0e2fb..8f116ad0686 100644
--- a/compiler/testData/diagnostics/tests/subtyping/localClasses.kt
+++ b/compiler/testData/diagnostics/tests/subtyping/localClasses.kt
@@ -15,5 +15,5 @@ private fun foo() = run {
 
 fun test() {
     var x = foo(1)
-    x = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>foo()<!>
+    x = <!TYPE_MISMATCH!>foo()<!>
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/subtyping/nestedIntoLocalClasses.kt b/compiler/testData/diagnostics/tests/subtyping/nestedIntoLocalClasses.kt
index 2dd74687951..53d549c771c 100644
--- a/compiler/testData/diagnostics/tests/subtyping/nestedIntoLocalClasses.kt
+++ b/compiler/testData/diagnostics/tests/subtyping/nestedIntoLocalClasses.kt
@@ -19,5 +19,5 @@ private fun foo() = run {
 
 fun test() {
     var x = foo(1)
-    x = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>foo()<!>
+    x = <!TYPE_MISMATCH!>foo()<!>
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/subtyping/nestedLocalClasses.kt b/compiler/testData/diagnostics/tests/subtyping/nestedLocalClasses.kt
index 4d89c4c30ae..ec238c908a8 100644
--- a/compiler/testData/diagnostics/tests/subtyping/nestedLocalClasses.kt
+++ b/compiler/testData/diagnostics/tests/subtyping/nestedLocalClasses.kt
@@ -19,5 +19,5 @@ private fun foo() = run {
 
 fun test() {
     var x = foo(1)
-    x = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>foo()<!>
+    x = <!TYPE_MISMATCH!>foo()<!>
 }
\ No newline at end of file
diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/InnerClassInGeneric.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/InnerClassInGeneric.kt
index d31957c8eb0..680412ce5dd 100644
--- a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/InnerClassInGeneric.kt
+++ b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/InnerClassInGeneric.kt
@@ -2,7 +2,7 @@
 // FILE: KotlinFile.kt
 fun foo(javaClass: JavaClass<Int>): Int {
     val inner = javaClass.createInner<String>()
-    return <!TYPE_MISMATCH!>inner.<!NI;TYPE_MISMATCH!>doSomething(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>, "") <!OI;TYPE_MISMATCH!>{ }<!><!><!>
+    return <!TYPE_MISMATCH!>inner.doSomething(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>, "") <!OI;TYPE_MISMATCH!>{ }<!><!>
 }
 
 // FILE: JavaClass.java
diff --git a/compiler/testData/diagnostics/tests/when/BranchBypassVal.kt b/compiler/testData/diagnostics/tests/when/BranchBypassVal.kt
index 9b78d51b028..7268250c185 100644
--- a/compiler/testData/diagnostics/tests/when/BranchBypassVal.kt
+++ b/compiler/testData/diagnostics/tests/when/BranchBypassVal.kt
@@ -8,5 +8,5 @@ fun test(a: Any): String {
         is A -> q!!
     }
     // When is not exhaustive
-    return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>q<!>
+    return <!TYPE_MISMATCH!>q<!>
 }
diff --git a/compiler/testData/diagnostics/tests/when/BranchBypassVar.kt b/compiler/testData/diagnostics/tests/when/BranchBypassVar.kt
index 0dd59cbab82..df496b12bfe 100644
--- a/compiler/testData/diagnostics/tests/when/BranchBypassVar.kt
+++ b/compiler/testData/diagnostics/tests/when/BranchBypassVar.kt
@@ -8,5 +8,5 @@ fun test(a: Any) {
         is A -> q = "1"
     }
     // When is not exhaustive
-    return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>q<!>
+    return <!TYPE_MISMATCH!>q<!>
 }