[Minor] Update test data for NI

compiler/testData/diagnostics/tests/annotations/annotationRenderingInTypes.kt

@@ -1,5 +1,6 @@
 // !RENDER_DIAGNOSTICS_MESSAGES
 // !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE -UNUSED_ANONYMOUS_PARAMETER
+// !WITH_NEW_INFERENCE
 
 fun f1(x: String) {}
 fun f2(f: () -> Unit) {}
@@ -12,7 +13,7 @@ annotation class Ann
 fun <@Ann R : @Ann Any> f3(a: Array<@Ann R>): Array<@Ann R?> =  null!!
 
 fun test2(a: @Ann Array<in @Ann Int>) {
-    val r: Array<in Int?> = <!TYPE_INFERENCE_CANNOT_CAPTURE_TYPES("'R' cannot capture 'in Int'. Type parameter has an upper bound 'Any' that cannot be satisfied capturing 'in' projection")!>f3<!>(a)
+    val r: Array<in Int?> = <!OI;TYPE_INFERENCE_CANNOT_CAPTURE_TYPES("'R' cannot capture 'in Int'. Type parameter has an upper bound 'Any' that cannot be satisfied capturing 'in' projection")!>f3<!>(<!NI;TYPE_MISMATCH("Any", "Int")!>a<!>)
 }
 
 
@@ -22,4 +23,4 @@ var test3: Int = 0
 
 fun f4(fn: (@Ann Int, @Ann Int) -> Unit) {}
 
-val test4 = f4 { <!EXPECTED_PARAMETERS_NUMBER_MISMATCH("2", "Int, Int")!>single<!> -> }
+val test4 = f4 <!NI;TYPE_MISMATCH("(Int, Int) -> Unit", "(Int) -> Unit")!>{ <!EXPECTED_PARAMETERS_NUMBER_MISMATCH("2", "Int, Int")!>single<!> -> }<!>

compiler/testData/diagnostics/tests/annotations/rendering/memberProjectedOut.kt

@@ -1,4 +1,5 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE
 // !RENDER_DIAGNOSTICS_MESSAGES
 
 @Target(AnnotationTarget.FUNCTION, AnnotationTarget.TYPE, AnnotationTarget.CLASS)
@@ -11,5 +12,5 @@ class C<T> {
 }
 
 fun test(a: C<out CharSequence>) {
-    <!MEMBER_PROJECTED_OUT("public final operator fun set(x: Int, y: T): Unit defined in C", "C<out CharSequence>")!>a[1]<!> = 25
+    <!OI;MEMBER_PROJECTED_OUT("public final operator fun set(x: Int, y: T): Unit defined in C", "C<out CharSequence>")!>a[1]<!> = <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH("integer", "Nothing")!>25<!>
 }

compiler/testData/diagnostics/tests/annotations/rendering/typeMismatchDueToTypeProjections.kt

@@ -1,5 +1,6 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 // !RENDER_DIAGNOSTICS_MESSAGES
+// !WITH_NEW_INFERENCE
 
 @Target(AnnotationTarget.FUNCTION, AnnotationTarget.TYPE, AnnotationTarget.CLASS)
 annotation class A
@@ -13,5 +14,5 @@ class C<T> {
 class Out<out F>
 
 fun test(a: C<out CharSequence>, y: Out<CharSequence>) {
-    a + <!TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS("Out<Nothing>", "Out<CharSequence>", "C<out CharSequence>", "public final operator fun plus(x: Out<T>): C<T> defined in C")!>y<!>
+    a + <!NI;TYPE_MISMATCH("Out<Nothing>", "Out<CharSequence>"), OI;TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS("Out<Nothing>", "Out<CharSequence>", "C<out CharSequence>", "public final operator fun plus(x: Out<T>): C<T> defined in C")!>y<!>
 }

compiler/testData/diagnostics/tests/resolve/overloadConflicts/genericClash.kt

@@ -1,4 +1,5 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE
 
 interface A<T> {
     fun foo(x: T)
@@ -14,6 +15,6 @@ fun <E> baz(x: String, y: E) {}
 fun bar(x: A<String>) {
     x.<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>("")
 
-    x.<!CANNOT_COMPLETE_RESOLVE!>baz<!>("", "")
+    x.<!NI;OVERLOAD_RESOLUTION_AMBIGUITY, OI;CANNOT_COMPLETE_RESOLVE!>baz<!>("", "")
-    <!CANNOT_COMPLETE_RESOLVE!>baz<!>("", "")
+    <!NI;OVERLOAD_RESOLUTION_AMBIGUITY, OI;CANNOT_COMPLETE_RESOLVE!>baz<!>("", "")
 }

compiler/testData/diagnostics/testsWithStdLib/addAllProjection.kt

@@ -8,7 +8,7 @@ fun test(mc: MutableCollection<out CharSequence>) {
 
     mc.addAll(<!NI;TYPE_MISMATCH, OI;TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS!>listOf("")<!>)
     mc.addAll(<!NI;TYPE_MISMATCH, OI;TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS!>listOf<String>("")<!>)
-    mc.addAll(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS!>listOf<CharSequence>("")<!>)
+    mc.addAll(<!NI;TYPE_MISMATCH, OI;TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS!>listOf<CharSequence>("")<!>)
 
     mc.addAll(emptyList())
     mc.addAll(emptyList<Nothing>())

compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/javaAnnotationWithVarargArgument.kt

@@ -6,6 +6,6 @@ public @interface A {
 }
 
 // FILE: b.kt
-@A(*<!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>arrayOf(1, "b")<!>)
+@A(*<!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>arrayOf(<!NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>, "b")<!>)
 fun test() {
 }

compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/kotlinAnnotationWithVarargArgument.kt

@@ -2,6 +2,6 @@
 
 annotation class B(vararg val args: String)
 
-@B(*<!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>arrayOf(1, "b")<!>)
+@B(*<!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>arrayOf(<!NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>, "b")<!>)
 fun test() {
 }

compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsInVariance.kt

@@ -14,7 +14,7 @@ class MyClass1
 @Ann1(arrayOf(Any::class))
 class MyClass1a
 
-@Ann1(<!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>arrayOf(B1::class)<!>)
+@Ann1(<!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>arrayOf(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>B1::class<!>)<!>)
 class MyClass2
 
 annotation class Ann2(val arg: Array<KClass<in B1>>)
@@ -25,5 +25,5 @@ class MyClass3
 @Ann2(arrayOf(B1::class))
 class MyClass4
 
-@Ann2(<!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>arrayOf(B2::class)<!>)
+@Ann2(<!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>arrayOf(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>B2::class<!>)<!>)
 class MyClass5

compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsOutVariance.kt

@@ -11,7 +11,7 @@ annotation class Ann1(val arg: Array<KClass<out A>>)
 @Ann1(arrayOf(A::class))
 class MyClass1
 
-@Ann1(<!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>arrayOf(Any::class)<!>)
+@Ann1(<!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>arrayOf(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>Any::class<!>)<!>)
 class MyClass1a
 
 @Ann1(arrayOf(B1::class))
@@ -19,11 +19,11 @@ class MyClass2
 
 annotation class Ann2(val arg: Array<KClass<out B1>>)
 
-@Ann2(<!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>arrayOf(A::class)<!>)
+@Ann2(<!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>arrayOf(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>A::class<!>)<!>)
 class MyClass3
 
 @Ann2(arrayOf(B1::class))
 class MyClass4
 
-@Ann2(<!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>arrayOf(B2::class)<!>)
+@Ann2(<!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>arrayOf(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>B2::class<!>)<!>)
 class MyClass5

compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/nestedSuspendCallInsideLambda.kt

@@ -3,7 +3,7 @@
 
 suspend fun wrapUp2() {
     withContext<Unit> {
-        <!NI;NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>other<!>()
+        other()
     }
 }
 suspend fun <T> withContext(block: suspend () -> T) {}

compiler/testData/diagnostics/testsWithStdLib/coroutines/lambdaExpectedType.kt

@@ -28,7 +28,7 @@ fun foo() {
     i = genericBuilder { 1 }
     genericBuilder { 1 }
     genericBuilder<Int> { 1 }
-    genericBuilder<Int> { <!TYPE_MISMATCH!>""<!> }
+    genericBuilder<Int> { <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>""<!> }
 
     val y = { 1 }
     <!OI;TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>genericBuilder<!>(<!TYPE_MISMATCH!>y<!>)
@@ -43,7 +43,7 @@ fun foo() {
     val s: String = manyArgumentsBuilder({}, { "" }) { 1 }
 
     manyArgumentsBuilder<String>({}, { "" }, { 1 })
-    manyArgumentsBuilder<String>({}, { <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> }, { 2 })
+    manyArgumentsBuilder<String>({}, { <!CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> }, { 2 })
 
     severalParamsInLambda { <!NAME_SHADOWING!>x<!>, <!NAME_SHADOWING!>y<!> ->
         x checkType { _<String>() }

compiler/testData/diagnostics/testsWithStdLib/coroutines/tryCatchLambda.kt

@@ -8,7 +8,7 @@ fun <T> genericBuilder(c: suspend () -> T): T = null!!
 fun foo() {
     var result = ""
     genericBuilder<String> {
-        <!NI;TYPE_MISMATCH!>try {
+        <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>try {
             await("")
         } catch(e: Exception) {
             <!OI;EXPECTED_TYPE_MISMATCH!>result = "fail"<!>

compiler/testData/diagnostics/testsWithStdLib/resolve/kt4711.kt

@@ -10,7 +10,7 @@ fun main() {
     val pi = 4.0.toDouble() * delta <!OI;OVERLOAD_RESOLUTION_AMBIGUITY!>*<!> (1..n).<!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>reduce<!>(
             {t, i ->
                 val x = (i - 0.5) * delta
-                <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>t + 1.0 / (1.0 + x * x)<!>
+                <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>t + 1.0 / (1.0 + x * x)<!>
 
             })
     // !!! pi has error type here

compiler/testData/diagnostics/testsWithStdLib/tryCatch/tryExpression.kt

@@ -30,6 +30,6 @@ fun test2(): Map<Int, Int> = run {
     <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>try {
         emptyMap()
     } catch (e: ExcA) {
-        <!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>mapOf("" to "")<!>
+        <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>mapOf(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>"" to ""<!>)<!>
     }<!>
 }