Add diagnostics to test data from NI

compiler/testData/diagnostics/tests/j+k/collectorInference.kt

@@ -9,6 +9,6 @@ import java.util.stream.Stream
 fun test(a: Stream<String>) {
     a.collect(Collectors.toList()) checkType { _<MutableList<String>>() }
     // actually the inferred type is platform
-    a.collect(Collectors.toList()) checkType { _<List<String?>>() }
+    a.collect(Collectors.toList()) checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><List<String?>>() }
 }
 

compiler/testData/diagnostics/tests/j+k/genericConstructor/classTypeParameterInferredFromArgument.kt

@@ -9,9 +9,9 @@ public class A<E> {
 // FILE: main.kt
 
 fun test(x: List<Int>, y: List<String>) {
-    A("", x) checkType { _<A<Any?>>() }
-    A("", y) checkType { _<A<String?>>() }
+    A("", x) checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><A<Any?>>() }
+    A("", y) checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><A<String?>>() }
 
-    A<CharSequence, String>("", <!TYPE_MISMATCH!>x<!>)
+    A<CharSequence, String>("", <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>x<!>)
     A<CharSequence, String>("", y)
 }

compiler/testData/diagnostics/tests/j+k/genericConstructor/innerClass.kt

@@ -13,6 +13,6 @@ fun test(x: List<Int>, y: List<String>) {
     Outer<Int>().Inner("", y, 1) checkType { _<Outer<Int>.Inner<String>>() }
     Outer<Int>().Inner<CharSequence, String, Int>("", y, 1) checkType { _<Outer<Int>.Inner<CharSequence>>() }
 
-    Outer<Int>().Inner("", x, 1) checkType { _<Outer<Int>.Inner<Any>>() }
-    Outer<Int>().Inner<CharSequence, String, Int>("", <!TYPE_MISMATCH!>x<!>, 1)
+    Outer<Int>().Inner("", x, 1) checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Outer<Int>.Inner<Any>>() }
+    Outer<Int>().Inner<CharSequence, String, Int>("", <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>x<!>, 1)
 }

compiler/testData/diagnostics/tests/j+k/genericConstructor/noClassTypeParametersInvParameter.kt

@@ -10,12 +10,12 @@ public class A {
 class Inv<T>
 
 fun test(x: Inv<Int>, y: Inv<String>) {
-    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>A<!>("", x)
+    <!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>A<!>("", <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>x<!>)
     A("", y)
 
-    A<String>("", <!TYPE_MISMATCH!>x<!>)
+    A<String>("", <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>x<!>)
 
-    A<Any>("", <!TYPE_MISMATCH!>x<!>)
+    A<Any>("", <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>x<!>)
     A<String>("", y)
     A<CharSequence>("", <!TYPE_MISMATCH!>y<!>)
 }

compiler/testData/diagnostics/tests/j+k/genericConstructor/recursive.kt

@@ -9,4 +9,4 @@ public class C {
 
 // FILE: main.kt
 
-fun foo() = <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>C<!>(<!NO_VALUE_FOR_PARAMETER!>)<!>
+fun foo() = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>C<!>(<!NO_VALUE_FOR_PARAMETER!>)<!>

compiler/testData/diagnostics/tests/j+k/genericConstructor/superCall.kt

@@ -10,9 +10,9 @@ public class A<E> {
 // FILE: main.kt
 
 class B1(x: List<String>) : A<CharSequence>("", x)
-class B2(x: List<Int>) : <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>A<CharSequence>("", x)<!>
+class B2(x: List<Int>) : <!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>A<CharSequence>("", x)<!>
 
 class C : A<CharSequence> {
     constructor(x: List<String>) : super("", x)
-    constructor(x: List<Int>, y: Int) : <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>super<!>("", x)
+    constructor(x: List<Int>, y: Int) : <!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>super<!>("", x)
 }

compiler/testData/diagnostics/tests/j+k/genericConstructor/superCallImpossibleToInfer.kt

@@ -12,10 +12,10 @@ public class A<E> {
 // TODO: It's effectively impossible to perform super call to such constructor
 // if there is not enough information to infer corresponding arguments
 // May be we could add some special syntax for such arguments
-class B1(x: List<String>) : <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>A<!><CharSequence>("", x)
-class B2(x: List<Int>) : <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>A<CharSequence>("", x)<!>
+class B1(x: List<String>) : <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>A<!><CharSequence>("", x)
+class B2(x: List<Int>) : <!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>A<CharSequence>("", x)<!>
 
 class C : A<CharSequence> {
-    constructor(x: List<String>) : <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>super<!>("", x)
-    constructor(x: List<Int>, y: Int) : <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>super<!>("", x)
+    constructor(x: List<String>) : <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>super<!>("", x)
+    constructor(x: List<Int>, y: Int) : <!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>super<!>("", x)
 }

compiler/testData/diagnostics/tests/j+k/genericConstructorWithMultipleBounds.kt

@@ -11,8 +11,8 @@ public class J {
 
 import java.io.Serializable
 
-fun cloneable(c: Cloneable) = <!TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>J<!>(c)
+fun cloneable(c: Cloneable) = <!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>J<!>(<!NI;TYPE_MISMATCH!>c<!>)
 
-fun serializable(s: Serializable) = <!TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>J<!>(s)
+fun serializable(s: Serializable) = <!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>J<!>(<!NI;TYPE_MISMATCH!>s<!>)
 
 fun <T> both(t: T) where T : Cloneable, T : Serializable = J(t)

compiler/testData/diagnostics/tests/j+k/sam/enhancedSamConstructor.kt

@@ -16,13 +16,13 @@ public interface J2 extends J {
 
 // FILE: main.kt
 fun main() {
-    J { <!EXPECTED_PARAMETER_TYPE_MISMATCH!>s: String<!> -> s} // should be prohibited, because SAM value parameter has nullable type
+    J <!NI;TYPE_MISMATCH!>{ <!OI;EXPECTED_PARAMETER_TYPE_MISMATCH!>s: String<!> -> s}<!> // should be prohibited, because SAM value parameter has nullable type
     J { "" + it<!UNSAFE_CALL!>.<!>length }
-    J { <!NULL_FOR_NONNULL_TYPE!>null<!> }
-    J { <!TYPE_MISMATCH!>it?.length?.toString()<!> }
+    J { <!NI;NULL_FOR_NONNULL_TYPE, NI;NULL_FOR_NONNULL_TYPE, NULL_FOR_NONNULL_TYPE!>null<!> }
+    J { <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>it?.length?.toString()<!> }
 
-    J2 { <!EXPECTED_PARAMETER_TYPE_MISMATCH!>s: String<!> -> s}
+    J2 <!NI;TYPE_MISMATCH!>{ <!OI;EXPECTED_PARAMETER_TYPE_MISMATCH!>s: String<!> -> s}<!>
     J2 { "" + it<!UNSAFE_CALL!>.<!>length }
-    J2 { <!NULL_FOR_NONNULL_TYPE!>null<!> }
-    J2 { <!TYPE_MISMATCH!>it?.length?.toString()<!> }
+    J2 { <!NI;NULL_FOR_NONNULL_TYPE, NI;NULL_FOR_NONNULL_TYPE, NULL_FOR_NONNULL_TYPE!>null<!> }
+    J2 { <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>it?.length?.toString()<!> }
 }

compiler/testData/diagnostics/tests/j+k/samByProjectedType/genericInReturnType.kt

@@ -34,7 +34,7 @@ fun main() {
     }
 
     A.baz {
-        x -> <!TYPE_MISMATCH!>x.hashCode()<!>
+        x -> <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>x.<!NI;TYPE_MISMATCH!>hashCode()<!><!>
     }
 
     val block: (String) -> Any? = {

compiler/testData/diagnostics/tests/j+k/samByProjectedType/noAdapterBecuaseOfRecursiveUpperBound.kt

@@ -17,12 +17,12 @@ public class A {
 // FILE: main.kt
 fun main() {
     A().foo <!TYPE_MISMATCH!>{
-        <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>x<!> ->
+        <!OI;CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>x<!> ->
         ""
     }<!>
 
     A.bar <!TYPE_MISMATCH!>{
-        <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>x<!> ->
+        <!OI;CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>x<!> ->
         ""
     }<!>
 }

compiler/testData/diagnostics/tests/j+k/wrongVarianceInJava.kt

@@ -20,5 +20,5 @@ class In<in F> {
 
 fun test() {
     A.foo().x() checkType { _<Any?>() }
-    A.bar().<!MEMBER_PROJECTED_OUT!>y<!>(null)
+    A.bar().<!OI;MEMBER_PROJECTED_OUT!>y<!>(<!NI;NULL_FOR_NONNULL_TYPE!>null<!>)
 }