Remove OI/NI attributes from test data

compiler/testData/diagnostics/tests/resolve/specialConstructions/constantsInIf.kt

@@ -1,13 +1,13 @@
 // !DIAGNOSTICS: -USELESS_ELVIS
 
 fun test() {
-    bar(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>if (true) {
-        <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>1<!>
+    bar(<!TYPE_MISMATCH, TYPE_MISMATCH!>if (true) {
+        1
     } else {
-        <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>2<!>
+        2
     }<!>)
 
-    bar(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!><!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> ?: <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!><!>)
+    bar(<!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!><!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> ?: <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!><!>)
 }
 
 fun bar(s: String) = s

compiler/testData/diagnostics/tests/resolve/specialConstructions/elvisAsCall.kt

@@ -13,7 +13,7 @@ fun testElvis(a: Int?, b: Int?) {
     if (a != null) {
         doInt(b ?: <!DEBUG_INFO_SMARTCAST!>a<!>)
     }
-    doList(getList() ?: <!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>emptyListOfA<!>()) //should be an error
+    doList(getList() ?: emptyListOfA()) //should be an error
     doList(getList() ?: strangeList { doInt(it) }) //lambda was not analyzed
 }
 
@@ -32,5 +32,5 @@ fun testDataFlowInfo2(a: Int?, b: Int?) {
 }
 
 fun testTypeMismatch(a: String?, b: Any) {
-    doInt(<!TYPE_MISMATCH{NI}!><!TYPE_MISMATCH{OI}!>a<!> ?: <!TYPE_MISMATCH{OI}!>b<!><!>)
+    doInt(<!TYPE_MISMATCH!>a ?: b<!>)
 }

compiler/testData/diagnostics/tests/resolve/specialConstructions/exclExclAsCall.kt

@@ -12,8 +12,8 @@ fun <T: A> emptyNullableListOfA(): List<T>? = null
 //-------------------------------
 
 fun testExclExcl() {
-    doList(<!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>emptyNullableListOfA<!>()!!) //should be an error here
-    val l: List<Int> = <!TYPE_MISMATCH{NI}!><!TYPE_MISMATCH{NI}!>id<!>(<!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}, TYPE_MISMATCH{NI}!>emptyNullableListOfA<!>()<!TYPE_MISMATCH{NI}!>!!<!>)<!>
+    doList(emptyNullableListOfA()!!) //should be an error here
+    val l: List<Int> = <!TYPE_MISMATCH!><!TYPE_MISMATCH!>id<!>(<!TYPE_MISMATCH!>emptyNullableListOfA<!>()<!TYPE_MISMATCH!>!!<!>)<!>
 
     doList(strangeNullableList { doInt(it) }!!) //lambda should be analyzed (at completion phase)
 }

compiler/testData/diagnostics/tests/resolve/specialConstructions/multipleSuperClasses.kt

@@ -8,7 +8,7 @@ interface D: A, B
 interface E: A, B
 
 fun foo(c: C?, d: D?, e: E?) {
-    val test1: A? = <!TYPE_MISMATCH{OI}!>c ?: d<!> ?: e
+    val test1: A? = c ?: d ?: e
 
     val test2: B? = if (false) if (true) c else d else e
 

compiler/testData/diagnostics/tests/resolve/specialConstructions/reportTypeMismatchDeeplyOnBranches.kt

@@ -3,25 +3,25 @@ package b
 fun bar(i: Int) = i
 
 fun test(a: Int?, b: Int?) {
-    bar(<!TYPE_MISMATCH{NI}!>if (a == null) return else <!TYPE_MISMATCH{OI}!>b<!><!>)
+    bar(<!TYPE_MISMATCH!>if (a == null) return else b<!>)
 }
 
 fun test(a: Int?, b: Int?, c: Int?) {
-    bar(<!TYPE_MISMATCH{NI}!>if (a == null) return else if (b == null) return else <!TYPE_MISMATCH{OI}!>c<!><!>)
+    bar(<!TYPE_MISMATCH!>if (a == null) return else if (b == null) return else c<!>)
 }
 
 fun test(a: Any?, b: Any?, c: Int?) {
-    bar(<!TYPE_MISMATCH{NI}!>if (a == null) if (b == null) <!TYPE_MISMATCH{OI}!>c<!> else return else return<!>)
+    bar(<!TYPE_MISMATCH!>if (a == null) if (b == null) c else return else return<!>)
 }
 
 fun test(a: Int?, b: Any?, c: Int?) {
-    bar(<!TYPE_MISMATCH{NI}!>if (a == null) {
+    bar(<!TYPE_MISMATCH!>if (a == null) {
         return
     } else {
         if (b == null) {
             return
         } else {
-            <!TYPE_MISMATCH{OI}!>c<!>
+            c
         }
     }<!>)
 }