[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.

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)) {

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) {}

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() {}

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!>false || <!TYPE_MISMATCH!>y<!><!>
-    <!UNUSED_EXPRESSION!><!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!> && true<!>
+    <!UNUSED_EXPRESSION!><!TYPE_MISMATCH!>y<!> && true<!>
-    <!UNUSED_EXPRESSION!><!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!> && <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!><!>
+    <!UNUSED_EXPRESSION!><!TYPE_MISMATCH!>y<!> && <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!><!>
 }

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

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

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

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

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

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 u1: Usual<Any> = <!TYPE_MISMATCH!>u<!>
-    val <!UNUSED_VARIABLE!>u2<!>: Usual<Int> = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>u1<!>
+    val <!UNUSED_VARIABLE!>u2<!>: Usual<Int> = <!NI;TYPE_MISMATCH, OI;TYPE_MISMATCH!>u1<!>
 }
 
 //Arrays copy example

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) {
 }

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) {
 }

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

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)
 

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 && <!TYPE_MISMATCH!>c<!>) {}
-    if (b || <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>c<!>) {}
+    if (b || <!TYPE_MISMATCH!>c<!>) {}
-    if (<!NI;TYPE_MISMATCH, TYPE_MISMATCH!>c<!> && b) {}
+    if (<!TYPE_MISMATCH!>c<!> && b) {}
-    if (<!NI;TYPE_MISMATCH, TYPE_MISMATCH!>c<!> || b) {}
+    if (<!TYPE_MISMATCH!>c<!> || 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) {}

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

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()<!>

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

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

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()<!>) {
 
     }
 }

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

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 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_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 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>()

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>()<!>

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"
 

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"

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 {

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()<!>

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()<!> {
 
 }

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)

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) ->
+    aList.foo { (<!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>() }
+        a checkType { _<Int>() }
         b checkType { _<String>() }
     }
 

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) ->
+    foo { (<!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>() }
+        a checkType { _<Int>() }
         b checkType { _<String>() }
     }
 

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>() }
     }

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>()()

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>()()
 

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>()
 

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()
 

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

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
 }

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

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

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<*>>>() }
 }

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 "")

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<*>>() }
 }

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 {

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

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

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

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
 }

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()
 }
 

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? = {

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

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!>mutableListIterator<!>: MutableListIterator<T> = <!TYPE_MISMATCH!>l.listIterator()<!>
-    val <!UNUSED_VARIABLE!>mutableListIterator1<!>: MutableListIterator<T> = <!TYPE_MISMATCH!>l.<!NI;TYPE_MISMATCH!>listIterator(1)<!><!>
+    val <!UNUSED_VARIABLE!>mutableListIterator1<!>: MutableListIterator<T> = <!TYPE_MISMATCH!>l.listIterator(1)<!>
-    val <!UNUSED_VARIABLE!>mutableList<!>: MutableList<T> = <!TYPE_MISMATCH!>l.<!NI;TYPE_MISMATCH!>subList(1, 2)<!><!>
+    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!>mutableSet<!>: MutableSet<K> = <!TYPE_MISMATCH!>m.keys<!>
-    val <!UNUSED_VARIABLE!>mutableCollection<!>: MutableCollection<V> = <!TYPE_MISMATCH!>m.<!NI;TYPE_MISMATCH!>values<!><!>
+    val <!UNUSED_VARIABLE!>mutableCollection<!>: MutableCollection<V> = <!TYPE_MISMATCH!>m.values<!>
-    val <!UNUSED_VARIABLE!>mutableSet1<!>: MutableSet<MutableMap.MutableEntry<K, V>> = <!TYPE_MISMATCH!>m.<!NI;TYPE_MISMATCH!>entries<!><!>
+    val <!UNUSED_VARIABLE!>mutableSet1<!>: MutableSet<MutableMap.MutableEntry<K, V>> = <!TYPE_MISMATCH!>m.entries<!>
 }
 
 fun <K, V> testMutableMap(m: MutableMap<K, V>) {

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

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 i1: Int = <!TYPE_MISMATCH!>Boo<!>
-    val i2: Int = <!TYPE_MISMATCH!>A.<!NI;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<!>)
 }
 

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

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

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

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) {}
 }

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

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 = <!TYPE_MISMATCH!>n<!>
-    J.staticNN = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>platformN<!>
+    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 = <!TYPE_MISMATCH!>n<!>
-    J().nn = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>platformN<!>
+    J().nn = <!TYPE_MISMATCH!>platformN<!>
     J().nn = nn
     J().nn = platformNN
     J().nn = platformJ

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() {

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

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

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

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

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()
     }
 

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()
     }
 

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

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()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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