Add diagnostics to test data from NI

compiler/testData/diagnostics/tests/when/BranchBypassVal.kt

@@ -8,5 +8,5 @@ fun test(a: Any): String {
         is A -> q!!
     }
     // When is not exhaustive
-    return <!TYPE_MISMATCH!>q<!>
+    return <!NI;TYPE_MISMATCH, 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 <!TYPE_MISMATCH!>q<!>
+    return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>q<!>
 }

compiler/testData/diagnostics/tests/when/When.kt

@@ -11,7 +11,7 @@ fun foo() : Int {
       <!USELESS_IS_CHECK!>is Any<!> -> <!UNUSED_EXPRESSION!>1<!>
       <!INCOMPATIBLE_TYPES!>s<!> -> <!UNUSED_EXPRESSION!>1<!>
       1 -> <!UNUSED_EXPRESSION!>1<!>
-      1 + <!UNRESOLVED_REFERENCE!>a<!> -> <!UNUSED_EXPRESSION!>1<!>
+      1 <!NI;OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> <!UNRESOLVED_REFERENCE!>a<!> -> <!UNUSED_EXPRESSION!>1<!>
       in 1..<!UNRESOLVED_REFERENCE!>a<!> -> <!UNUSED_EXPRESSION!>1<!>
       !in 1..<!UNRESOLVED_REFERENCE!>a<!> -> <!UNUSED_EXPRESSION!>1<!>
       else -> <!UNUSED_EXPRESSION!>1<!>

compiler/testData/diagnostics/tests/when/kt10439.kt

@@ -2,12 +2,12 @@
 fun foo(x: Int) = x
 
 fun test0(flag: Boolean) {
-    foo(if (flag) <!CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!> else <!TYPE_MISMATCH!>""<!>)
+    foo(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>if (flag) <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!> else <!OI;TYPE_MISMATCH!>""<!><!>)
 }
 
 fun test1(flag: Boolean) {
-    foo(when (flag) {
-        true -> <!CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!>
-        else -> <!TYPE_MISMATCH!>""<!>
-    })
+    foo(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>when (flag) {
+        true -> <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!>
+        else -> <!OI;TYPE_MISMATCH!>""<!>
+    }<!>)
 }

compiler/testData/diagnostics/tests/when/kt10809.kt

@@ -8,7 +8,7 @@ class ListData<T : Item>(val list: List<T>) : Data
 
 fun <T> listOf(vararg items: T): List<T> = null!!
 
-fun test1(o: Any) = <!TYPE_INFERENCE_FAILED_ON_SPECIAL_CONSTRUCT!>when<!> (o) {
+fun test1(o: Any) = <!OI;TYPE_INFERENCE_FAILED_ON_SPECIAL_CONSTRUCT!>when<!> (o) {
     is List<*> ->
         ListData(listOf())
     is Int -> when {
@@ -35,7 +35,7 @@ fun test1x(o: Any): Data? = when (o) {
 }
 
 fun test2() =
-        <!TYPE_INFERENCE_FAILED_ON_SPECIAL_CONSTRUCT!>if<!> (true)
+        <!OI;TYPE_INFERENCE_FAILED_ON_SPECIAL_CONSTRUCT!>if<!> (true)
             ListData(listOf())
         else
             FlagData(true)

compiler/testData/diagnostics/tests/when/kt9929.kt

@@ -1,10 +1,10 @@
 // !WITH_NEW_INFERENCE
-val test: Int = if (true) {
+val test: Int = if (true) <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>{
     when (2) {
         1 -> 1
-        else -> <!NULL_FOR_NONNULL_TYPE!>null<!>
+        else -> <!OI;NULL_FOR_NONNULL_TYPE!>null<!>
     }
-}
+}<!>
 else {
     2
 }

compiler/testData/diagnostics/tests/when/kt9972.kt

@@ -1,18 +1,18 @@
 // !WITH_NEW_INFERENCE
 fun test1(): Int {
-    val x: String = if (true) {
+    val x: String = if (true) <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>{
         when {
-            true -> <!TYPE_MISMATCH!>Any()<!>
-            else -> <!NULL_FOR_NONNULL_TYPE!>null<!>
+            true -> <!OI;TYPE_MISMATCH!>Any()<!>
+            else -> <!OI;NULL_FOR_NONNULL_TYPE!>null<!>
         }
-    } else ""
+    }<!> else ""
     return x.hashCode()
 }
 
 fun test2(): Int {
-    val x: String = when {
-                        true -> <!TYPE_MISMATCH!>Any()<!>
+    val x: String = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>when {
+                        true -> <!OI;TYPE_MISMATCH!>Any()<!>
                         else -> null
-                    } ?: return 0
+                    } ?: return 0<!>
     return x.hashCode()
 }

compiler/testData/diagnostics/tests/when/whenAndLambdaWithExpectedType.kt

@@ -19,7 +19,7 @@ val test3: (String) -> Boolean =
 
 val test4: (String) -> Boolean =
         when {
-            true -> { <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!UNUSED_ANONYMOUS_PARAMETER!>s1<!>, <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>s2<!><!> -> true }
+            true -> <!NI;TYPE_MISMATCH!>{ <!OI;EXPECTED_PARAMETERS_NUMBER_MISMATCH!><!UNUSED_ANONYMOUS_PARAMETER!>s1<!>, <!OI;CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>s2<!><!> -> true }<!>
             else -> null!!
         }
 

compiler/testData/diagnostics/tests/when/whenWithNothingAndLambdas.kt

@@ -1,6 +1,6 @@
 // !WITH_NEW_INFERENCE
-val <!IMPLICIT_NOTHING_PROPERTY_TYPE!>test1<!> = when {
-    true -> { <!TYPE_MISMATCH!>{ true }<!> }
+val <!OI;IMPLICIT_NOTHING_PROPERTY_TYPE!>test1<!> = when {
+    true -> { <!OI;TYPE_MISMATCH!>{ true }<!> }
     else -> TODO()
 }
 
@@ -9,10 +9,10 @@ val test1a: () -> Boolean = when {
     else -> TODO()
 }
 
-val <!IMPLICIT_NOTHING_PROPERTY_TYPE!>test2<!> = when {
-    true -> { <!TYPE_MISMATCH!>{ true }<!> }
+val <!OI;IMPLICIT_NOTHING_PROPERTY_TYPE!>test2<!> = when {
+    true -> { <!OI;TYPE_MISMATCH!>{ true }<!> }
     else -> when {
-        true -> { <!TYPE_MISMATCH!>{ true }<!> }
+        true -> { <!OI;TYPE_MISMATCH!>{ true }<!> }
         else -> TODO()
     }
 }
@@ -20,14 +20,14 @@ val <!IMPLICIT_NOTHING_PROPERTY_TYPE!>test2<!> = when {
 val test2a: () -> Boolean = when {
     true -> { { true } }
     else -> when {
-        true -> { <!TYPE_MISMATCH!>{ true }<!> } // TODO
+        true -> { <!OI;TYPE_MISMATCH!>{ true }<!> } // TODO
         else -> TODO()
     }
 }
 
-val <!IMPLICIT_NOTHING_PROPERTY_TYPE!>test3<!> = when {
-    true -> { <!TYPE_MISMATCH!>{ true }<!> }
-    true -> { <!TYPE_MISMATCH!>{ true }<!> }
+val <!OI;IMPLICIT_NOTHING_PROPERTY_TYPE!>test3<!> = when {
+    true -> { <!OI;TYPE_MISMATCH!>{ true }<!> }
+    true -> { <!OI;TYPE_MISMATCH!>{ true }<!> }
     else -> TODO()
 }