From bcc88020140c4e01fcf24730dced3594d2147390 Mon Sep 17 00:00:00 2001
From: Mikhail Zarechenskiy <mikhail.zarechenskiy@jetbrains.com>
Date: Wed, 17 Apr 2019 03:04:58 +0300
Subject: [PATCH] [NI] Avoid constraints from expected type for effectively
 empty system

 Expression will be checked against expected type later.

 Theoretically, this is not very good, but it aligns with the old
 inference, plus it helps avoiding multiple type mismatch diagnostics.
---
 .../calls/components/KotlinCallCompleter.kt      |  5 +++++
 .../testData/diagnostics/tests/AutoCreatedIt.kt  |  2 +-
 compiler/testData/diagnostics/tests/Basic.kt     |  2 +-
 .../tests/BinaryCallsOnNullableValues.kt         |  6 +++---
 .../tests/DefaultValuesTypechecking.kt           |  4 ++--
 .../diagnostics/tests/EnumEntryAsType.kt         |  6 +++---
 .../diagnostics/tests/FunctionReturnTypes.kt     |  2 +-
 .../diagnostics/tests/PackageQualified.kt        |  2 +-
 .../tests/SafeCallNonNullReceiverReturnNull.kt   |  2 +-
 compiler/testData/diagnostics/tests/Variance.kt  |  8 ++++----
 .../tests/annotations/kt1860-negative.kt         |  2 +-
 .../tests/annotations/kt1860-positive.kt         |  2 +-
 .../generic/genericFunctionsWithNullableTypes.kt |  2 +-
 .../diagnostics/tests/cast/AsInBinaryUnary.kt    |  4 ++--
 .../tests/checkArguments/booleanExpressions.kt   |  8 ++++----
 .../kt770.kt351.kt735_StatementType.kt           |  4 ++--
 .../specialConstructsAndPlatformTypes.kt         |  2 +-
 .../diagnostics/tests/cyclicHierarchy/kt303.kt   |  2 +-
 .../tests/dataFlowInfoTraversal/Return.kt        |  2 +-
 .../ComponentFunctionReturnTypeMismatch.kt       |  2 +-
 .../FolLoopTypeComponentTypeMismatch.kt          |  2 +-
 .../destructuringDeclarations/underscore.kt      |  2 +-
 .../inference/differentDelegatedExpressions.kt   |  4 ++--
 .../inference/genericMethodInGenericClass.kt     |  2 +-
 .../noOperatorModifierOnProvideDelegate.kt       |  2 +-
 .../unsupportedOperatorProvideDelegate.kt        |  2 +-
 .../typeMismatchForGetReturnType.kt              |  2 +-
 .../delegation/clashes/finalMemberOverridden.kt  |  2 +-
 .../severalDelegates.kt                          |  2 +-
 .../diagnostics/tests/evaluate/divisionByZero.kt |  2 +-
 .../inferredFunctionalType.kt                    |  4 ++--
 .../destructuringInLambdas/simple.kt             |  4 ++--
 .../destructuringInLambdas/underscore.kt         |  2 +-
 .../capturedParameters/innerLocalClass.kt        |  2 +-
 .../generics/capturedParameters/localClass.kt    |  2 +-
 .../generics/capturedParameters/objectLiteral.kt |  2 +-
 .../tests/generics/innerClasses/iterator.kt      |  2 +-
 .../generics/innerClasses/qualifiedOuter.kt      |  2 +-
 ...considerTypeNotNullOnlyIfItHasNotNullBound.kt |  2 +-
 .../nullability/smartCastsValueArgument.kt       |  4 ++--
 .../tests/generics/nullability/tpInBounds.kt     |  4 ++--
 .../tests/generics/projectionsScope/kt7296.kt    |  2 +-
 .../projectionsScope/typeMismatchInLambda.kt     |  2 +-
 .../varProjection/setterNotProjectedOutAssign.kt |  2 +-
 ...oercionToUnitForIfAsLastExpressionInLambda.kt |  2 +-
 .../diagnostics/tests/inference/kt1293.kt        |  2 +-
 .../tests/inference/regressions/kt2883.kt        |  2 +-
 .../upperBounds/useBoundsIfUnknownParameters.kt  |  2 +-
 .../diagnostics/tests/infos/SmartCasts.kt        |  4 ++--
 ...lineLambdaInDefaultInlineParameterDisabled.kt |  2 +-
 .../samByProjectedType/genericInReturnType.kt    |  2 +-
 compiler/testData/diagnostics/tests/kt310.kt     |  2 +-
 .../diagnostics/tests/library/Collections.kt     | 16 ++++++++--------
 .../sameClassNameDifferentPackages.kt            |  2 +-
 .../testData/diagnostics/tests/objects/kt5527.kt |  6 +++---
 .../nullabilityWarnings/assignToVar.kt           |  2 +-
 .../nullabilityWarnings/conditions.kt            | 10 +++++-----
 .../nullabilityWarnings/dataFlowInfo.kt          |  4 ++--
 .../nullabilityWarnings/defaultParameters.kt     |  2 +-
 .../nullabilityWarnings/delegation.kt            |  2 +-
 .../nullabilityWarnings/passToJava.kt            |  8 ++++----
 .../platformTypes/nullabilityWarnings/throw.kt   |  2 +-
 .../regressions/TypeMismatchOnUnaryOperations.kt |  2 +-
 .../diagnostics/tests/regressions/kt251.kt       |  4 ++--
 .../overloadConflicts/originalExamples.kt        |  2 +-
 .../tests/scopes/inheritance/methodsPriority.kt  |  2 +-
 .../inheritFromContainingClass_after.kt          |  4 ++--
 .../inheritFromContainingClass_before.kt         |  4 ++--
 .../scopes/inheritance/statics/localVsStatic.kt  |  2 +-
 .../script/destructuringDeclarationsScript.kts   |  2 +-
 .../tests/secondaryConstructors/return.kt        |  2 +-
 .../tests/smartCasts/elvisExprNotNull.kt         |  2 +-
 .../tests/smartCasts/explicitDefaultGetter.kt    |  2 +-
 .../tests/smartCasts/propertyToNotNull.kt        |  2 +-
 .../tests/smartCasts/safecalls/anotherVal.kt     |  2 +-
 .../smartCasts/safecalls/falseSecondArgument.kt  |  2 +-
 .../safecalls/receiverAndChainFalse.kt           |  2 +-
 .../tests/smartCasts/varnotnull/forEach.kt       |  2 +-
 .../smartCasts/varnotnull/forEachWithBreak.kt    |  2 +-
 .../smartCasts/varnotnull/forEachWithContinue.kt |  2 +-
 .../tests/smartCasts/varnotnull/varIntNull.kt    |  2 +-
 .../diagnostics/tests/subtyping/localClasses.kt  |  2 +-
 .../tests/subtyping/nestedIntoLocalClasses.kt    |  2 +-
 .../tests/subtyping/nestedLocalClasses.kt        |  2 +-
 .../samAdapters/InnerClassInGeneric.kt           |  2 +-
 .../diagnostics/tests/when/BranchBypassVal.kt    |  2 +-
 .../diagnostics/tests/when/BranchBypassVar.kt    |  2 +-
 87 files changed, 130 insertions(+), 125 deletions(-)

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<!>
 }