Add diagnostics to test data from NI

compiler/testData/diagnostics/tests/generics/innerClasses/bareTypesComplex.kt

@@ -4,7 +4,7 @@ open class SuperOuter<E> {
 }
 
 class DerivedOuter<G> : SuperOuter<G>() {
-    inner class DerivedInner<H> : SuperOuter<G>.SuperInner<H>()
+    inner class DerivedInner<H> : SuperOuter<G>.<!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>SuperInner<!><H>()
 }
 
 fun bare(x: SuperOuter<*>.SuperInner<*>, y: Any?) {

compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocal.kt

@@ -45,7 +45,7 @@ fun test() {
     x().foo().a() checkType { _<A<String, Double, Short, Long>>() }
     x().bar() checkType { _<A<String, Double, Short, Char>>() }
 
-    x = <!TYPE_MISMATCH!>foobar<Int>()<!>
+    x = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>foobar<Int>()<!>
 
     var y = noParameters()
     y = noParameters()

compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocalInsideInner.kt

@@ -46,8 +46,8 @@ class Outer<T> {
             x().foo().a() checkType { _<A<T, F, String, Double, Short, Long>>() }
             x().bar() checkType { _<A<T, F, String, Double, Short, Char>>() }
 
-            x = <!TYPE_MISMATCH!>foobar<Int>()<!>
-            x = <!TYPE_MISMATCH!>z.foobar<String>()<!>
+            x = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>foobar<Int>()<!>
+            x = <!TYPE_MISMATCH!>z.<!NI;TYPE_MISMATCH!>foobar<String>()<!><!>
 
             var y = noParameters()
             y = noParameters()

compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/secondLevelDepth.kt

@@ -9,7 +9,7 @@ open class Outer<E> {
 }
 
 class DerivedOuter : Outer<String>() {
-    inner class DerivedInner : Inner<Int>() {
+    inner class DerivedInner : <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>Inner<!><Int>() {
         fun foo(): Inner2<Char> = null!!
     }
 }

compiler/testData/diagnostics/tests/generics/innerClasses/innerSuperCall.kt

@@ -6,5 +6,5 @@ open class Super<T> {
 
 class Sub : Super<String>() {
     // TODO: it would be nice to have a possibility to omit explicit type argument in supertype
-    inner class SubInner : Super<String>.Inner() {}
+    inner class SubInner : Super<String>.<!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>Inner<!>() {}
 }

compiler/testData/diagnostics/tests/generics/innerClasses/innerSuperCallSecondary.kt

@@ -7,7 +7,7 @@ open class Super<T> {
 
 class Sub : Super<String>() {
     inner class SubInner : Super<String>.Inner {
-        constructor()
-        constructor(x: Int) : super() {}
+        constructor()<!NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!><!>
+        constructor(x: Int) : <!NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>super<!>() {}
     }
 }

compiler/testData/diagnostics/tests/generics/innerClasses/innerTP.kt

@@ -32,7 +32,7 @@ fun main() {
     checkSubtype<Outer<*>.Inner<*>>(outer.Inner<Int>())
 
     checkSubtype<Outer<CharSequence>.Inner<CharSequence>>(<!TYPE_MISMATCH!>outer.bar()<!>)
-    checkSubtype<Outer<CharSequence>.Inner<CharSequence>>(outer.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>Inner()<!>)
+    checkSubtype<Outer<CharSequence>.Inner<CharSequence>>(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>outer.<!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>Inner()<!><!>)
 
     outer.set(outer.bar())
     outer.set(outer.Inner())

compiler/testData/diagnostics/tests/generics/innerClasses/innerUncheckedCast.kt

@@ -15,7 +15,7 @@ class Outer<E> {
         if (y is <!NO_TYPE_ARGUMENTS_ON_RHS!>Inner<!>) return
 
         if (z is Inner) {
-            <!DEBUG_INFO_SMARTCAST!>z<!>.prop.checkType { _<Any?>() }
+            <!OI;DEBUG_INFO_SMARTCAST!>z<!>.prop.checkType { _<Any?>() }
             return
         }
 

compiler/testData/diagnostics/tests/generics/innerClasses/iterator.kt

@@ -29,9 +29,9 @@ fun <E> commonSupertype(x: E, y: E): E = x
 
 fun foo() {
     var myIt = A<String>().iterator()
-    myIt = <!TYPE_MISMATCH!>A<Int>().iterator()<!>
+    myIt = <!TYPE_MISMATCH!>A<Int>().<!NI;TYPE_MISMATCH!>iterator()<!><!>
 
     val csIt: Iterator<CharSequence> = A<String>().iterator()
 
-    commonSupertype(A<String>().iterator(), A<Int>().iterator()).checkType { _<A<out Any>.MyIt>() }
+    commonSupertype(A<String>().iterator(), A<Int>().iterator()).checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><A<out Any>.MyIt>() }
 }

compiler/testData/diagnostics/tests/generics/innerClasses/kt3357.kt

@@ -8,7 +8,7 @@ open class Super<T> {
 }
 
 class Sub<T1>(): Super<T1>() {
-    inner class SubInner : Super<T1>.Inner() { // 'Inner' is unresolved
+    inner class SubInner : Super<T1>.<!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>Inner<!>() { // 'Inner' is unresolved
         // Also, T1 is not resolved to anything, and not marked as resolved
         init {
             val x: Super<T1>.Inner = this // T1 is not resolved to anything

compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedOuter.kt

@@ -6,12 +6,12 @@ class Outer<T> {
     inner class Inner
     fun foo(x: Outer<String>.Inner, y: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer<!>.Inner, z: Inner) {
         var inner = Inner()
-        x.checkType { <!TYPE_MISMATCH!>_<!><Inner>() }
+        x.checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER, OI;TYPE_MISMATCH!>_<!><Inner>() }
         x.checkType { _<Outer<String>.Inner>() }
         z.checkType { _<Inner>() }
         z.checkType { _<Outer<T>.Inner>() }
 
-        inner = <!TYPE_MISMATCH!>x<!>
+        inner = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>x<!>
     }
 
     class Nested

compiler/testData/diagnostics/tests/generics/innerClasses/simpleOutUseSite.kt

@@ -29,9 +29,9 @@ fun main() {
     checkSubtype<Outer<out CharSequence>.Inner>(outer.bar())
     checkSubtype<Outer<out CharSequence>.Inner>(outer.Inner())
 
-    outer.<!MEMBER_PROJECTED_OUT!>set<!>(outer.bar())
-    outer.<!MEMBER_PROJECTED_OUT!>set<!>(outer.Inner())
+    outer.<!OI;MEMBER_PROJECTED_OUT!>set<!>(<!NI;TYPE_MISMATCH!>outer.bar()<!>)
+    outer.<!OI;MEMBER_PROJECTED_OUT!>set<!>(<!NI;TYPE_MISMATCH!>outer.Inner()<!>)
 
     val x: Outer<String>.Inner = factoryString()
-    outer.<!MEMBER_PROJECTED_OUT!>set<!>(x)
+    outer.<!OI;MEMBER_PROJECTED_OUT!>set<!>(<!NI;TYPE_MISMATCH!>x<!>)
 }