Remove OI/NI attributes from test data

compiler/testData/diagnostics/tests/AutoCreatedIt.kt

@@ -2,17 +2,17 @@ fun text() {
     "direct:a" to "mock:a"
     "direct:a" on {it.body == "<hello/>"} to "mock:a"
     "direct:a" on {it -> it.body == "<hello/>"} to "mock:a"
-    bar <!TYPE_MISMATCH{NI}!><!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!>1}<!>
+    bar <!TYPE_MISMATCH!><!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!>1}<!>
-    bar <!TYPE_MISMATCH{NI}!><!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!><!UNRESOLVED_REFERENCE!>it<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>+<!> 1}<!>
+    bar <!TYPE_MISMATCH!><!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!><!UNRESOLVED_REFERENCE!>it<!> <!DEBUG_INFO_MISSING_UNRESOLVED!>+<!> 1}<!>
     bar {it, it1 -> it}
 
     bar1 {1}
     bar1 {it + 1}
 
-    bar2 <!TYPE_MISMATCH{NI}!>{<!TYPE_MISMATCH!><!>}<!>
+    bar2 <!TYPE_MISMATCH!>{<!TYPE_MISMATCH!><!>}<!>
     bar2 {1}
-    bar2 <!TYPE_MISMATCH{NI}!>{<!UNRESOLVED_REFERENCE!>it<!>}<!>
+    bar2 <!TYPE_MISMATCH!>{<!UNRESOLVED_REFERENCE!>it<!>}<!>
-    bar2 <!TYPE_MISMATCH{NI}!>{<!CANNOT_INFER_PARAMETER_TYPE, EXPECTED_PARAMETERS_NUMBER_MISMATCH!>it<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, TYPE_MISMATCH{NI}!>it<!>}<!>
+    bar2 <!TYPE_MISMATCH!>{<!CANNOT_INFER_PARAMETER_TYPE, EXPECTED_PARAMETERS_NUMBER_MISMATCH!>it<!> -> <!TYPE_MISMATCH!>it<!>}<!>
 }
 
 fun bar(f :  (Int, Int) -> Int) {}

compiler/testData/diagnostics/tests/BinaryCallsOnNullableValues.kt

@@ -5,10 +5,10 @@ class A() {
 fun f(): Unit {
     var x: Int? = <!VARIABLE_WITH_REDUNDANT_INITIALIZER!>1<!>
     x = null
-    <!DEBUG_INFO_CONSTANT{OI}!>x<!> + 1
+    x + 1
     <!DEBUG_INFO_CONSTANT!>x<!> <!INFIX_MODIFIER_REQUIRED!>plus<!> 1
     <!DEBUG_INFO_CONSTANT!>x<!> <!UNSAFE_OPERATOR_CALL!><<!> 1
-    <!TYPE_MISMATCH!><!DEBUG_INFO_CONSTANT{OI}!>x<!> += 1<!>
+    <!TYPE_MISMATCH!>x += 1<!>
 
     <!DEBUG_INFO_CONSTANT!>x<!> == 1
     <!DEBUG_INFO_CONSTANT!>x<!> != 1
@@ -21,7 +21,7 @@ fun f(): Unit {
     <!IMPLICIT_BOXING_IN_IDENTITY_EQUALS!><!DEBUG_INFO_CONSTANT!>x<!> === 1<!>
     <!IMPLICIT_BOXING_IN_IDENTITY_EQUALS!><!DEBUG_INFO_CONSTANT!>x<!> !== 1<!>
 
-    <!DEBUG_INFO_CONSTANT{OI}!>x<!><!UNSAFE_OPERATOR_CALL!>..<!>2
+    x<!UNSAFE_OPERATOR_CALL!>..<!>2
     <!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>x<!> in 1..2
 
     val y : Boolean? = true

compiler/testData/diagnostics/tests/CompareToWithErrorType.kt

@@ -1,5 +1,5 @@
 fun test() {
-  if (<!UNRESOLVED_REFERENCE!>x<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>><!> 0) {
+  if (<!UNRESOLVED_REFERENCE!>x<!> <!DEBUG_INFO_MISSING_UNRESOLVED!>><!> 0) {
 
   }
 }

compiler/testData/diagnostics/tests/DefaultValuesTypechecking.kt

@@ -15,13 +15,13 @@ val z = 3
 
 fun foo(x: Int = <!UNINITIALIZED_PARAMETER!>y<!>, y: Int = x, i : Int = z): Int = x + y
 
-fun foo(x: () -> Int = { <!UNINITIALIZED_PARAMETER{OI}!>y<!> }, y: Int = x(), i : Int = z): Int = x() + y
+fun foo(x: () -> Int = { y }, y: Int = x(), i : Int = z): Int = x() + y
 
-fun bar(x: () -> Int = { <!UNINITIALIZED_PARAMETER{OI}!>y<!>; 1 }, y: Int) {}
+fun bar(x: () -> Int = { y; 1 }, y: Int) {}
 
 fun baz(
     x: () -> Int = {
-        fun bar(xx: () -> Int = { <!UNINITIALIZED_PARAMETER{OI}!>y<!>; 1 }) = xx
+        fun bar(xx: () -> Int = { y; 1 }) = xx
         bar()()
     },
     y: Int
@@ -30,7 +30,7 @@ fun baz(
 
 fun boo(
     x: () -> Int = {
-        fun bar(): Int = <!UNINITIALIZED_PARAMETER{OI}!>y<!>
+        fun bar(): Int = y
         bar()
     },
     y: Int

compiler/testData/diagnostics/tests/FunctionCalleeExpressions.kt

@@ -29,26 +29,26 @@ fun <T> fooT2() : (t : T) -> T {
 fun main(args : Array<String>) {
     args.foo()()
     args.foo1()(<!NO_VALUE_FOR_PARAMETER!>)<!>
-    <!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>foo1<!>()()
+    <!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>foo1<!>()()
-    <!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>foo1<!>()(<!UNRESOLVED_REFERENCE!>a<!>)
+    <!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>foo1<!>()(<!UNRESOLVED_REFERENCE!>a<!>)
 
     args.foo1()(1)
     args.foo1()(<!TYPE_MISMATCH!>"1"<!>)
-    <!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>foo1<!>()("1")
+    <!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>foo1<!>()("1")
-    <!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>foo1<!>()(<!UNRESOLVED_REFERENCE!>a<!>)
+    <!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>foo1<!>()(<!UNRESOLVED_REFERENCE!>a<!>)
 
     foo2()({})
     foo2()<!TOO_MANY_ARGUMENTS!>{}<!>
     (foo2()){}
-    (foo2())<!TYPE_MISMATCH{NI}!>{<!CANNOT_INFER_PARAMETER_TYPE, EXPECTED_PARAMETERS_NUMBER_MISMATCH!>x<!> -> }<!>
+    (foo2())<!TYPE_MISMATCH!>{<!CANNOT_INFER_PARAMETER_TYPE, EXPECTED_PARAMETERS_NUMBER_MISMATCH!>x<!> -> }<!>
-    foo2()(<!TYPE_MISMATCH{NI}!>{<!CANNOT_INFER_PARAMETER_TYPE, EXPECTED_PARAMETERS_NUMBER_MISMATCH!>x<!> -> }<!>)
+    foo2()(<!TYPE_MISMATCH!>{<!CANNOT_INFER_PARAMETER_TYPE, EXPECTED_PARAMETERS_NUMBER_MISMATCH!>x<!> -> }<!>)
 
     val a = fooT1(1)()
     checkSubtype<Int>(a)
 
     val b = fooT2<Int>()(1)
     checkSubtype<Int>(b)
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>fooT2<!>()(1) // : Any?
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooT2<!>()(1) // : Any?
 
     <!FUNCTION_EXPECTED!>1<!>()
     <!FUNCTION_EXPECTED!>1<!>{}
@@ -78,7 +78,7 @@ fun main1() {
 fun test() {
     {x : Int -> 1}(<!NO_VALUE_FOR_PARAMETER!>)<!>;
     (fun Int.() = 1)(<!NO_VALUE_FOR_PARAMETER!>)<!>
-    <!TYPE_MISMATCH{OI}!>"sd"<!>.<!FUNCTION_EXPECTED{NI}!>(fun Int.() = 1)<!>()
+    "sd".<!FUNCTION_EXPECTED!>(fun Int.() = 1)<!>()
     val i : Int? = null
     i<!UNSAFE_CALL!>.<!>(fun Int.() = 1)();
     {}<!WRONG_NUMBER_OF_TYPE_ARGUMENTS!><Int><!>()

compiler/testData/diagnostics/tests/FunctionReturnTypes.kt

@@ -145,14 +145,14 @@ fun illegalConstantBlock(): String {
     return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>
 }
 fun illegalIfBody(): Int =
-        if (1 < 2) <!CONSTANT_EXPECTED_TYPE_MISMATCH!>'a'<!> else <!TYPE_MISMATCH{NI}!>{ <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>1.0<!> }<!>
+        if (1 < 2) <!CONSTANT_EXPECTED_TYPE_MISMATCH!>'a'<!> else <!TYPE_MISMATCH!>{ 1.0 }<!>
 fun illegalIfBlock(): Boolean {
     if (1 < 2)
         return false
     else { return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> }
 }
 fun illegalReturnIf(): Char {
-    return if (1 < 2) 'a' else <!TYPE_MISMATCH{NI}!>{ <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>1<!> }<!>
+    return if (1 < 2) 'a' else <!TYPE_MISMATCH!>{ 1 }<!>
 }
 
 fun returnNothing(): Nothing {

compiler/testData/diagnostics/tests/InvokeAndRecursiveResolve.kt

@@ -13,6 +13,6 @@ class B {
 }
 
 class C {
-    val bar = <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}!><!DEBUG_INFO_MISSING_UNRESOLVED{NI}, UNINITIALIZED_VARIABLE{OI}!>test<!>()<!>
+    val bar = <!DEBUG_INFO_MISSING_UNRESOLVED!>test<!>()
-    val test = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM{NI}!><!DEBUG_INFO_MISSING_UNRESOLVED{NI}, FUNCTION_EXPECTED{OI}!>bar<!>()<!>
+    val test = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!DEBUG_INFO_MISSING_UNRESOLVED!>bar<!>()<!>
 }

compiler/testData/diagnostics/tests/Nullability.fir.kt

@@ -145,7 +145,7 @@ fun test() {
   out?.println();
 
   val out2 : java.io.PrintStream? = null
-  
+
   while (out2 == null) {
     out2?.println();
     out2<!UNSAFE_CALL!>.<!>println();

compiler/testData/diagnostics/tests/Nullability.kt

@@ -145,10 +145,10 @@ fun test() {
   <!DEBUG_INFO_CONSTANT!>out<!>?.println();
 
   val out2 : java.io.PrintStream? = null
-  
+
   while (out2 == null) {
     <!DEBUG_INFO_CONSTANT!>out2<!>?.println();
-    <!DEBUG_INFO_CONSTANT{OI}!>out2<!><!UNSAFE_CALL!>.<!>println();
+    out2<!UNSAFE_CALL!>.<!>println();
   }
   <!DEBUG_INFO_SMARTCAST!>out2<!>.println()
 

compiler/testData/diagnostics/tests/PackageQualified.kt

@@ -24,7 +24,7 @@ package foobar.a
 
 // FILE: d.kt
 package foobar
-val x1 = <!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>a<!>
+val x1 = <!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>a<!>
 val x2 = foobar.a.a
 
 val y1 = foobar.a.b

compiler/testData/diagnostics/tests/QualifiedExpressions.kt

@@ -4,8 +4,8 @@ fun test(s: IntRange?) {
    val a: Int = <!TYPE_MISMATCH!>s?.start<!>
    val b: Int? = s?.start
    val c: Int = s?.start ?: -11
-   val d: Int = <!TYPE_MISMATCH{NI}!>s?.start ?: <!TYPE_MISMATCH{OI}!>"empty"<!><!>
+   val d: Int = <!TYPE_MISMATCH!>s?.start ?: "empty"<!>
-   val e: String = <!TYPE_MISMATCH{NI}!><!TYPE_MISMATCH{OI}!>s?.start<!> ?: "empty"<!>
+   val e: String = <!TYPE_MISMATCH!>s?.start ?: "empty"<!>
    val f: Int = s?.endInclusive ?: b ?: 1
    val g: Boolean? = e.startsWith("s")//?.length
 }

compiler/testData/diagnostics/tests/RecursiveTypeInference.kt

@@ -4,7 +4,7 @@
 package a
     val foo = bar()
 
-    fun bar() = <!DEBUG_INFO_MISSING_UNRESOLVED{NI}, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>foo<!>
+    fun bar() = <!DEBUG_INFO_MISSING_UNRESOLVED, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>foo<!>
 
 // FILE: b.kt
 package b

compiler/testData/diagnostics/tests/ReserveYield.kt

@@ -19,7 +19,7 @@ fun yield(yield: Int) {
     val foo = <!YIELD_IS_RESERVED!>yield<!> + <!YIELD_IS_RESERVED!>yield<!>
     val foo2 = <!YIELD_IS_RESERVED!>yield<!>
 
-    bar(<!YIELD_IS_RESERVED{OI}!>yield<!> = 5)
+    bar(yield = 5)
 
     yield(4)
     <!YIELD_IS_RESERVED!>yield<!> {}

compiler/testData/diagnostics/tests/ResolveOfJavaGenerics.kt

@@ -4,7 +4,7 @@ fun test(a : java.lang.annotation.RetentionPolicy) {
 }
 
 fun test() {
-  java.util.Collections.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>emptyList<!>()
+  java.util.Collections.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()
   val a : Collection<String>? = java.util.Collections.emptyList()
 }
 

compiler/testData/diagnostics/tests/ResolveToJava.kt

@@ -21,10 +21,10 @@ fun test(l : <!PLATFORM_CLASS_MAPPED_TO_KOTLIN!>java.util.List<Int><!>) {
 
   val f : java.io.File? = null
 
-  Collections.<!FUNCTION_CALL_EXPECTED, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>emptyList<!>
+  Collections.<!FUNCTION_CALL_EXPECTED, NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>
   Collections.<!FUNCTION_CALL_EXPECTED!>emptyList<Int><!>
   Collections.emptyList<Int>()
-  Collections.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>emptyList<!>()
+  Collections.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()
 
   checkSubtype<Set<Int>?>(Collections.singleton<Int>(1))
   Collections.singleton<Int>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1.0<!>)

compiler/testData/diagnostics/tests/SafeCallUnknownType.kt

@@ -2,5 +2,5 @@ import <!UNRESOLVED_REFERENCE!>com<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>unknown<!
 
 fun ff() {
     val a = <!UNRESOLVED_REFERENCE!>unknown<!>()
-    val b = <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!>?.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>plus<!>(42)
+    val b = <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!>?.<!DEBUG_INFO_MISSING_UNRESOLVED!>plus<!>(42)
 }

compiler/testData/diagnostics/tests/StarsInFunctionCalls.kt

@@ -1,14 +1,13 @@
-
 fun <T> getT() {}
 fun <A, B> getTT() {}
 fun <A, B, C> getTTT(x : Any) {}
 fun foo(a : Any?) {}
 
 public fun main() {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>getT<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getT<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
     <!UNRESOLVED_REFERENCE!>ggetT<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>getTT<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>, <!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getTT<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>, <!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>getTT<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>, Int>()
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getTT<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>, Int>()
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>getTT<!><Int, <!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getTT<!><Int, <!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>>()
-    foo(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>getTTT<!><Int, <!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>, Int>(1))
+    foo(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getTTT<!><Int, <!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>*<!>, Int>(1))
 }

compiler/testData/diagnostics/tests/TypeInference.kt

@@ -9,10 +9,10 @@ fun main() {
   val a : C<Int> = C();
   val x : C<in String> = C()
   val y : C<out String> = C()
-  val z : C<*> = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>C<!>()
+  val z : C<*> = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>C<!>()
 
   val ba : C<Int> = bar();
   val bx : C<in String> = bar()
   val by : C<out String> = bar()
-  val bz : C<*> = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>bar<!>()
+  val bz : C<*> = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>()
 }

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

@@ -1,5 +1,5 @@
 import java.util.ArrayList
 
-<!NOT_AN_ANNOTATION_CLASS{NI}!>@<!NONE_APPLICABLE{OI}!>ArrayList<!><Int>(<!TOO_MANY_ARGUMENTS{NI}!>1<!>, <!TOO_MANY_ARGUMENTS{NI}!>1<!>)<!> fun b() {}
+<!NOT_AN_ANNOTATION_CLASS!>@ArrayList<Int>(<!TOO_MANY_ARGUMENTS!>1<!>, <!TOO_MANY_ARGUMENTS!>1<!>)<!> fun b() {}
 @<!UNRESOLVED_REFERENCE!>Xoo<!>(<!UNRESOLVED_REFERENCE!>x<!>) fun c() {}
 <!DEPRECATED_JAVA_ANNOTATION!>@java.lang.Deprecated(<!TOO_MANY_ARGUMENTS, UNRESOLVED_REFERENCE!>x<!>)<!> fun a() {}

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

@@ -12,7 +12,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{OI}("'R' cannot capture 'in Int'. Type parameter has an upper bound 'Any' that cannot be satisfied capturing 'in' projection")!>f3<!>(<!TYPE_MISMATCH{NI}("Any; Int"), TYPE_MISMATCH{NI}("Any; Int")!>a<!>)
+    val r: Array<in Int?> = f3(<!TYPE_MISMATCH("Any; Int"), TYPE_MISMATCH("Any; Int")!>a<!>)
 }
 
 
@@ -22,4 +22,4 @@ var test3: Int = 0
 
 fun f4(fn: (@Ann Int, @Ann Int) -> Unit) {}
 
-val test4 = f4 <!TYPE_MISMATCH{NI}("(Int, Int) -> Unit; (Int) -> Unit")!>{ <!EXPECTED_PARAMETERS_NUMBER_MISMATCH("2; Int, Int")!>single<!> -> }<!>
+val test4 = f4 <!TYPE_MISMATCH("(Int, Int) -> Unit; (Int) -> Unit")!>{ <!EXPECTED_PARAMETERS_NUMBER_MISMATCH("2; Int, Int")!>single<!> -> }<!>

compiler/testData/diagnostics/tests/annotations/options/functions.kt

@@ -33,7 +33,7 @@ fun foo(arg: Int) {
     val f = @FunAnn fun(): Int { return 42 }
     // But here, f and gav should be annotated instead
     bar(<!WRONG_ANNOTATION_TARGET!>@FunAnn<!> f)
-    bar(<!WRONG_ANNOTATION_TARGET{OI}!>@<!DEBUG_INFO_MISSING_UNRESOLVED{NI}!>FunAnn<!><!> ::gav)
+    bar(@<!DEBUG_INFO_MISSING_UNRESOLVED!>FunAnn<!> ::gav)
     // Function expression, ok
     fast(f)
 }

compiler/testData/diagnostics/tests/annotations/options/targets/field.fir.kt

@@ -1,4 +1,4 @@
-@Target(AnnotationTarget.FIELD) 
+@Target(AnnotationTarget.FIELD)
 annotation class Field
 
 <!WRONG_ANNOTATION_TARGET!>@Field<!>

compiler/testData/diagnostics/tests/annotations/options/targets/field.kt

@@ -1,4 +1,4 @@
-@Target(AnnotationTarget.FIELD) 
+@Target(AnnotationTarget.FIELD)
 annotation class Field
 
 <!WRONG_ANNOTATION_TARGET!>@Field<!>
@@ -27,7 +27,7 @@ abstract class My(<!WRONG_ANNOTATION_TARGET!>@Field<!> arg: Int, @Field val w: I
     fun foo() {}
 
     <!WRONG_ANNOTATION_TARGET!>@Field<!>
-    val v: Int by <!UNRESOLVED_REFERENCE!>Delegates<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>lazy<!> { 42 }
+    val v: Int by <!UNRESOLVED_REFERENCE!>Delegates<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>lazy<!> { 42 }
 }
 
 enum class Your {

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

@@ -11,5 +11,5 @@ class C<T> {
 }
 
 fun test(a: C<out CharSequence>) {
-    <!MEMBER_PROJECTED_OUT{OI}("public final operator fun set(x: Int, y: T): Unit defined in C; C<out CharSequence>")!>a[1]<!> = <!CONSTANT_EXPECTED_TYPE_MISMATCH{NI}("integer; Nothing")!>25<!>
+    a[1] = <!CONSTANT_EXPECTED_TYPE_MISMATCH("integer; Nothing")!>25<!>
 }

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

@@ -13,5 +13,5 @@ class C<T> {
 class Out<out F>
 
 fun test(a: C<out CharSequence>, y: Out<CharSequence>) {
-    a + <!TYPE_MISMATCH{NI}("Out<Nothing>; Out<CharSequence>"), TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS{OI}!>y<!>
+    a + <!TYPE_MISMATCH("Out<Nothing>; Out<CharSequence>")!>y<!>
 }

compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax3.kt

@@ -22,7 +22,7 @@ class Test {
     val Int.c: Int get() = 42
 
     val test1: () -> Right = <!RESERVED_SYNTAX_IN_CALLABLE_REFERENCE_LHS!><!DEBUG_INFO_MISSING_UNRESOLVED!>a<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>b<!><<!DEBUG_INFO_MISSING_UNRESOLVED!>Int<!>>.<!DEBUG_INFO_MISSING_UNRESOLVED!>c<!><!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
-    val test1a: () -> Right = a.<!DEBUG_INFO_LEAKING_THIS{NI}!>b<!>.<!DEBUG_INFO_LEAKING_THIS{NI}!>c<!>::foo
+    val test1a: () -> Right = a.<!DEBUG_INFO_LEAKING_THIS!>b<!>.<!DEBUG_INFO_LEAKING_THIS!>c<!>::foo
 
     val test2: () -> Right = <!RESERVED_SYNTAX_IN_CALLABLE_REFERENCE_LHS!><!DEBUG_INFO_MISSING_UNRESOLVED!>a<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>b<!><<!DEBUG_INFO_MISSING_UNRESOLVED!>Int<!>>.<!DEBUG_INFO_MISSING_UNRESOLVED!>c<!><!>?::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
 }

compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirection.kt

@@ -18,6 +18,6 @@ fun <K, V> B<K>.star(p: KProperty1<*, V>): B<V> = TODO()
 fun <R : A> B<R>.test(){
     foo(A::bla)
     bar(A::bla)
-    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>baz<!>(<!TYPE_MISMATCH{NI}!>A::bla<!>)
+    baz(<!TYPE_MISMATCH!>A::bla<!>)
     star(A::bla)
 }

compiler/testData/diagnostics/tests/callableReference/expectedTypeAsSubtypeOfFunctionType.kt

@@ -7,6 +7,6 @@ fun <T> takeIt(x: T, f: SubFunction) {}
 fun cr() {}
 
 fun test() {
-    <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>takeIt<!>(42, <!TYPE_MISMATCH!>::cr<!>)
+    takeIt(42, <!TYPE_MISMATCH!>::cr<!>)
-    <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>takeIt<!>(42, <!TYPE_MISMATCH!>{ }<!>)
+    takeIt(42, <!TYPE_MISMATCH!>{ }<!>)
 }

compiler/testData/diagnostics/tests/callableReference/function/lhsNotAClass.kt

@@ -1,13 +1,12 @@
-
 class A<T, U : Any> {
     fun foo() = <!CALLABLE_REFERENCE_LHS_NOT_A_CLASS!>T::<!UNRESOLVED_REFERENCE!>toString<!><!>
 
     fun bar() = <!CALLABLE_REFERENCE_LHS_NOT_A_CLASS!>U::<!UNRESOLVED_REFERENCE!>toString<!><!>
 
     fun baz() {
-        take(<!CALLABLE_REFERENCE_LHS_NOT_A_CLASS!>T::<!UNRESOLVED_REFERENCE{OI}!>toString<!><!>)
+        take(<!CALLABLE_REFERENCE_LHS_NOT_A_CLASS!>T::toString<!>)
 
-        take(<!CALLABLE_REFERENCE_LHS_NOT_A_CLASS!>U::<!UNRESOLVED_REFERENCE{OI}!>toString<!><!>)
+        take(<!CALLABLE_REFERENCE_LHS_NOT_A_CLASS!>U::toString<!>)
     }
 }
 

compiler/testData/diagnostics/tests/callableReference/function/unresolved.kt

@@ -17,7 +17,7 @@ fun test2() {
     fun foo() {}
 
     <!UNRESOLVED_REFERENCE!>Unresolved<!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
-    foo(<!UNRESOLVED_REFERENCE!>Unresolved<!>::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, DEBUG_INFO_MISSING_UNRESOLVED{OI}!>foo<!>)
+    foo(<!UNRESOLVED_REFERENCE!>Unresolved<!>::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>foo<!>)
-    foo(<!UNRESOLVED_REFERENCE!>Unresolved<!>::<!DEBUG_INFO_MISSING_UNRESOLVED{OI}, UNRESOLVED_REFERENCE{NI}!>unresolved<!>)
+    foo(<!UNRESOLVED_REFERENCE!>Unresolved<!>::<!UNRESOLVED_REFERENCE!>unresolved<!>)
     ::<!UNRESOLVED_REFERENCE!>unresolved<!>
 }

compiler/testData/diagnostics/tests/callableReference/functionReferenceWithDefaultValueAsOtherFunctionType.kt

@@ -1,4 +1,3 @@
-
 fun foo(a: String, b: Int = 5): String {
     return a + b
 }
@@ -12,6 +11,6 @@ fun bar2(body: (String, Int) -> String): String {
 }
 
 fun test() {
-    bar1(<!TYPE_MISMATCH{OI}!>::foo<!>)
+    bar1(::foo)
     bar2(::foo)
 }

compiler/testData/diagnostics/tests/callableReference/generic/argumentAndReturnExpectedType.kt

@@ -15,9 +15,9 @@ fun test1() {
     bar("", 1, ::foo).checkType { _<Pair<String, Int>>() }
     bar("", 1, ::fooReturnInt).checkType { _<Pair<String, Int>>() }
     bar("", 1, ::fooTakeString).checkType { _<Pair<String, Int>>() }
-    bar("", "", ::fooReturnInt).checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><Pair<String, Any>>() }
+    bar("", "", ::fooReturnInt).checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Pair<String, Any>>() }
 
-    val x: String = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>bar("", "", ::fooReturnInt)<!>
+    val x: String = <!TYPE_MISMATCH, TYPE_MISMATCH!>bar("", "", ::fooReturnInt)<!>
 
     baz(Int::toString, ::foo).checkType { _<Pair<Int, String>>() }
 }

compiler/testData/diagnostics/tests/callableReference/generic/explicitTypeArguments.kt

@@ -13,12 +13,12 @@ fun <T> Wrapper<T>.baz(transform: (T) -> Unit): T = TODO()
 
 fun test() {
     takeFun<String>(::foo)
-    takeFun<String>(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>::<!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>fooInt<!><!>)
+    takeFun<String>(<!TYPE_MISMATCH, TYPE_MISMATCH!>::fooInt<!>)
 
     callFun<String, Wrapper<String>>(::createWrapper)
     callFun<Int, Wrapper<Number>>(::createWrapper)
     callFun<String, Wrapper<*>>(::createWrapper)
-    callFun<String, Wrapper<Int>>(::<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!>createWrapper<!>)
+    callFun<String, Wrapper<Int>>(::createWrapper)
 
     callFun<Int, Wrapper<Int>>(::createWrapper).baz(::foo)
 }

compiler/testData/diagnostics/tests/callableReference/generic/genericExtensionFunction.kt

@@ -22,8 +22,8 @@ fun test1() {
 fun <T> test2() {
     bar<Wrapper, Int, String>(Wrapper::fooReturnString).checkType { _<Tripple<Wrapper, Int, String>>() }
     bar<Wrapper, T, String>(Wrapper::fooReturnString).checkType { _<Tripple<Wrapper, T, String>>() }
-    bar<Wrapper, T, T>(<!TYPE_MISMATCH{NI}!>Wrapper::<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!>fooReturnString<!><!>)
+    bar<Wrapper, T, T>(<!TYPE_MISMATCH!>Wrapper::fooReturnString<!>)
-    bar<Wrapper, Int, Int>(<!TYPE_MISMATCH{NI}!>Wrapper::<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!>fooReturnString<!><!>)
+    bar<Wrapper, Int, Int>(<!TYPE_MISMATCH!>Wrapper::fooReturnString<!>)
 
     bar<Wrapper, Int, T>(Wrapper::fooTakeInt).checkType { _<Tripple<Wrapper, Int, T>>() }
     bar<Wrapper, Int, String>(Wrapper::fooTakeInt).checkType { _<Tripple<Wrapper, Int, String>>() }

compiler/testData/diagnostics/tests/callableReference/generic/genericFunctionsWithNullableTypes.kt

@@ -28,9 +28,9 @@ fun <T> test(x: T) {
     <!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>baz<!>(1, null, ::foo)
     <!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION, REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>baz<!>(null, null, ::foo)
 
-    val s3: Pair<Int, String?> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>bar(null, null, ::<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>foo<!>)<!>
+    val s3: Pair<Int, String?> = <!TYPE_MISMATCH, TYPE_MISMATCH!>bar(null, null, ::foo)<!>
-    val s4: Pair<Int?, String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>bar(null, null, ::<!IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>foo<!>)<!>
+    val s4: Pair<Int?, String> = <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>bar(null, null, ::<!IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION!>foo<!>)<!>
 
-    val s5: Pair<Int, String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>bar(1, "", ::foo)<!>
+    val s5: Pair<Int, String> = <!TYPE_MISMATCH, TYPE_MISMATCH!>bar(1, "", ::foo)<!>
     val (a1: Int, b1: String) = <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>bar(1, "", ::foo)<!>
 }

compiler/testData/diagnostics/tests/callableReference/generic/nestedCallWithOverload.kt

@@ -10,7 +10,7 @@ fun test() {
     val x2: (Int) -> Unit = baz(id(::foo), ::foo)
     val x3: (Int) -> Unit = baz(id(::foo), id(id(::foo)))
     val x4: (String) -> Unit = baz(id(::foo), id(id(::foo)))
-    val x5: (Double) -> Unit = baz(id(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, NONE_APPLICABLE{OI}!>foo<!>), id(id(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, NONE_APPLICABLE{OI}!>foo<!>)))
+    val x5: (Double) -> Unit = baz(id(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>foo<!>), id(id(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>foo<!>)))
 
 
     id<(Int) -> Unit>(id(id(::foo)))

compiler/testData/diagnostics/tests/callableReference/generic/resolutionGenericCallableWithNullableTypes.kt

@@ -16,7 +16,7 @@ fun test1() {
     baz<String>(::foo).checkType { _<String?>() }
     baz<Boolean>(::foo).checkType { _<Boolean?>() }
 
-    val b1: Int = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>baz(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}!>foo<!>)<!>
+    val b1: Int = <!TYPE_MISMATCH, TYPE_MISMATCH!>baz(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>foo<!>)<!>
-    val b2: String = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>baz(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}!>foo<!>)<!>
+    val b2: String = <!TYPE_MISMATCH, TYPE_MISMATCH!>baz(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>foo<!>)<!>
-    val b3: Boolean = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>baz(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}!>foo<!>)<!>
+    val b3: Boolean = <!TYPE_MISMATCH, TYPE_MISMATCH!>baz(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>foo<!>)<!>
 }

compiler/testData/diagnostics/tests/callableReference/generic/resolutionWithGenericCallable.kt

@@ -4,9 +4,9 @@ fun test() {
     val a1: Array<Double.(Double) -> Double> = arrayOf(Double::plus, Double::minus)
     val a2: Array<Double.(Int) -> Double> = arrayOf(Double::plus, Double::minus)
 
-    val a3: Array<Int.(Int) -> Double> = arrayOf(Double::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, NONE_APPLICABLE{OI}!>plus<!>, Double::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, NONE_APPLICABLE{OI}!>minus<!>)
+    val a3: Array<Int.(Int) -> Double> = arrayOf(Double::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>plus<!>, Double::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>minus<!>)
-    val a4: Array<Int.(Double) -> Double> = arrayOf(Int::plus, Double::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, NONE_APPLICABLE{OI}!>minus<!>)
+    val a4: Array<Int.(Double) -> Double> = arrayOf(Int::plus, Double::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>minus<!>)
-    val a5: Array<Double.(Double) -> Double> = arrayOf(Double::plus, Int::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, NONE_APPLICABLE{OI}!>minus<!>)
+    val a5: Array<Double.(Double) -> Double> = arrayOf(Double::plus, Int::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>minus<!>)
 }
 
 fun foo(x: Int) {}
@@ -17,5 +17,5 @@ fun <T> bar(x: T, f: (T) -> Unit) {}
 fun test2() {
     bar(1, ::foo)
     bar("", ::foo)
-    bar(1.0, ::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, NONE_APPLICABLE{OI}!>foo<!>)
+    bar(1.0, ::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>foo<!>)
 }

compiler/testData/diagnostics/tests/callableReference/kt34314.kt

@@ -1,5 +1,5 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE
 
 fun main() {
-    val x = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>run<!> { <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>::<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>run<!><!> } // no error
+    val x = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>run<!> { <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>::run<!> } // no error
 }

compiler/testData/diagnostics/tests/callableReference/kt34314_lambda.kt

@@ -3,5 +3,5 @@
 fun <T> materialize(): T = TODO()
 
 fun main() {
-    val x = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>run<!> { <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>materialize<!>() }
+    val x = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>run<!> { <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materialize<!>() }
 }

compiler/testData/diagnostics/tests/callableReference/resolve/byGenericArgType.kt

@@ -7,4 +7,4 @@ fun foo(s: String) {}
 
 val x1 = ofType<() -> Unit>(::foo)
 val x2 = ofType<(String) -> Unit>(::foo)
-val x3 = ofType<(Int) -> Unit>(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, NONE_APPLICABLE{OI}!>foo<!>)
+val x3 = ofType<(Int) -> Unit>(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>foo<!>)

compiler/testData/diagnostics/tests/callableReference/resolve/intersectionTypeOverloadWithWrongParameter.kt

@@ -10,7 +10,7 @@ class Foo {
     }
 
     fun foo() {
-        <!NONE_APPLICABLE{NI}, OVERLOAD_RESOLUTION_AMBIGUITY{OI}!>installRoute<!><Any>(::route)
+        <!NONE_APPLICABLE!>installRoute<!><Any>(::route)
     }
 
 }

compiler/testData/diagnostics/tests/callableReference/resolve/withGenericFun.kt

@@ -8,4 +8,4 @@ fun foo(s: String) {}
 
 val x1 = apply(1, ::foo)
 val x2 = apply("hello", ::foo)
-val x3 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>apply<!>(true, ::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, NONE_APPLICABLE{OI}!>foo<!>)
+val x3 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>apply<!>(true, ::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>foo<!>)

compiler/testData/diagnostics/tests/callableReference/resolve/withPlaceholderTypes.kt

@@ -21,7 +21,7 @@ val x1 = fn1(1, ::foo, ::foo)
 val x2 = fn1(1, ::foo, ::bar)
 
 val x3 = fn2(::bar, ::foo)
-val x4 = <!OVERLOAD_RESOLUTION_AMBIGUITY!>fn2<!>(::<!DEBUG_INFO_MISSING_UNRESOLVED{NI}, OVERLOAD_RESOLUTION_AMBIGUITY{OI}!>foo<!>, ::bar)
+val x4 = <!OVERLOAD_RESOLUTION_AMBIGUITY!>fn2<!>(::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>, ::bar)
-val x5 = <!OVERLOAD_RESOLUTION_AMBIGUITY!>fn2<!>(::<!DEBUG_INFO_MISSING_UNRESOLVED{NI}, OVERLOAD_RESOLUTION_AMBIGUITY{OI}!>foo<!>, ::<!DEBUG_INFO_MISSING_UNRESOLVED{NI}, OVERLOAD_RESOLUTION_AMBIGUITY{OI}!>foo<!>)
+val x5 = <!OVERLOAD_RESOLUTION_AMBIGUITY!>fn2<!>(::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>, ::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>)
 
 val x6 = fn3(1, ::qux)

compiler/testData/diagnostics/tests/cast/AsInBlockWithReturnType.kt

@@ -5,7 +5,7 @@ fun runWithoutReturn(r: () -> Unit) = r()
 fun testRun() {
     run {
         1 <!USELESS_CAST!>as Any<!>
-        1 <!USELESS_CAST{NI}!>as Any<!>
+        1 <!USELESS_CAST!>as Any<!>
     }
 
     run<Any> {
@@ -16,11 +16,11 @@ fun testRun() {
     fun foo(): Int = 1
 
     run {
-        foo() <!USELESS_CAST{NI}!>as Any<!>
+        foo() <!USELESS_CAST!>as Any<!>
     }
 
     run {
-        (if (true) 1 else 2) <!USELESS_CAST{NI}!>as Any<!>
+        (if (true) 1 else 2) <!USELESS_CAST!>as Any<!>
     }
 
     run<Int?> {
@@ -35,17 +35,17 @@ fun testRun() {
 }
 
 fun testReturn(): Number {
-    run { 1 <!USELESS_CAST{NI}!>as Number<!> }
+    run { 1 <!USELESS_CAST!>as Number<!> }
     return run { 1 <!USELESS_CAST!>as Number<!> }
 }
 
 fun <T> testDependent() {
     listOf(1).map {
         it <!USELESS_CAST!>as Any<!>
-        it <!USELESS_CAST{NI}!>as Any<!>
+        it <!USELESS_CAST!>as Any<!>
     }
 
-    listOf<T>().map { it <!USELESS_CAST{NI}!>as Any?<!> }
+    listOf<T>().map { it <!USELESS_CAST!>as Any?<!> }
 }
 
 fun <T> listOf(vararg elements: T): List<T> = TODO()

compiler/testData/diagnostics/tests/cast/UselessSafeCast.kt

@@ -10,7 +10,7 @@ fun test(x: Int?) {
     val a7: Number? = 1 <!USELESS_CAST!>as? Number<!>
 
     run { x <!USELESS_CAST!>as? Int<!> }
-    run { x <!USELESS_CAST{NI}!>as? Number<!> }
+    run { x <!USELESS_CAST!>as? Number<!> }
 
     foo(x as? Number)
 

compiler/testData/diagnostics/tests/cast/kt15161.kt

@@ -1,6 +1,6 @@
 class Array<E>(e: E) {
     val k = Array(1) {
         1 <!USELESS_CAST!>as Any<!>
-        e <!USELESS_CAST{NI}!>as Any?<!>
+        e <!USELESS_CAST!>as Any?<!>
     }
 }

compiler/testData/diagnostics/tests/checkArguments/SpreadVarargs.kt

@@ -43,10 +43,10 @@ fun main() {
 
     joinG(1, "2")
     joinG(<!NON_VARARG_SPREAD!>*<!>1, "2")
-    <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>joinG<!>(1, *<!TYPE_MISMATCH!>"2"<!>)
+    joinG(1, *<!TYPE_MISMATCH!>"2"<!>)
     joinG(x = 1, a = a)
-    <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>joinG<!>(x = 1, a = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR, TYPE_MISMATCH!>"2"<!>)
+    joinG(x = 1, a = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR, TYPE_MISMATCH!>"2"<!>)
-    <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>joinG<!>(x = <!NON_VARARG_SPREAD!>*<!>1, a = *<!TYPE_MISMATCH!>"2"<!>)
+    joinG(x = <!NON_VARARG_SPREAD!>*<!>1, a = *<!TYPE_MISMATCH!>"2"<!>)
     joinG(1, *a)
     joinG(1, *a, "3")
     joinG(1, "4", *a, "3")

compiler/testData/diagnostics/tests/checkArguments/arrayAccessSetTooManyArgs.kt

@@ -5,6 +5,6 @@ class A {
     operator fun set(x: String, value: Int) {}
 
     fun d(x: Int) {
-        this["", <!TOO_MANY_ARGUMENTS{OI}!>1<!>] = <!TOO_MANY_ARGUMENTS{NI}!>1<!>
+        this["", 1] = <!TOO_MANY_ARGUMENTS!>1<!>
     }
 }

compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.kt

@@ -20,7 +20,7 @@ fun test() {
 
     foo(<!TYPE_MISMATCH!>""<!>, s = <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!>)
 
-    foo(i = <!TYPE_MISMATCH!>""<!>, s = <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!>, <!MIXING_NAMED_AND_POSITIONED_ARGUMENTS{OI}, TOO_MANY_ARGUMENTS{NI}!>33<!>)
+    foo(i = <!TYPE_MISMATCH!>""<!>, s = <!CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!>, <!TOO_MANY_ARGUMENTS!>33<!>)
 
     foo(<!TYPE_MISMATCH!>""<!>, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>) <!TOO_MANY_ARGUMENTS!>{}<!>
 

compiler/testData/diagnostics/tests/checkArguments/overloadedFunction.kt

@@ -11,6 +11,6 @@ fun test() {
     <!NONE_APPLICABLE!>foo<!>(1, 2)
     foo(<!TYPE_MISMATCH!>""<!>)
 
-    <!NONE_APPLICABLE{OI}!>bar<!>(1, <!TOO_MANY_ARGUMENTS{NI}!>2<!>)
+    bar(1, <!TOO_MANY_ARGUMENTS!>2<!>)
     <!NONE_APPLICABLE!>bar<!>()
 }

compiler/testData/diagnostics/tests/checkType.kt

@@ -6,6 +6,6 @@ interface C : B
 
 fun test(b: B) {
     b checkType { _<B>() }
-    b checkType { <!TYPE_MISMATCH{OI}, UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><A>() }
+    b checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><A>() }
-    b checkType { <!TYPE_MISMATCH{OI}, UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><C>() }
+    b checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><C>() }
 }

compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotation.kt

@@ -8,7 +8,7 @@ fun test1() {}
 @Foo([], [], [])
 fun test2() {}
 
-@Foo([<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1f<!>], <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>[' ']<!>, [<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>])
+@Foo([<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1f<!>], <!TYPE_MISMATCH, TYPE_MISMATCH!>[' ']<!>, [<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>])
 fun test3() {}
 
 @Foo(c = [1f], b = [""], a = [1])

compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotationWithKClass.kt

@@ -20,10 +20,10 @@ fun test3() {}
 @Foo([<!CLASS_LITERAL_LHS_NOT_A_CLASS!>Gen<Int>::class<!>])
 fun test4() {}
 
-@Foo(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>[""]<!>)
+@Foo(<!TYPE_MISMATCH, TYPE_MISMATCH!>[""]<!>)
 fun test5() {}
 
-@Foo(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>[Int::class, 1]<!>)
+@Foo(<!TYPE_MISMATCH, TYPE_MISMATCH!>[Int::class, 1]<!>)
 fun test6() {}
 
 @Bar

compiler/testData/diagnostics/tests/collectionLiterals/basicCollectionLiterals.kt

@@ -2,11 +2,11 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE, -UNSUPPORTED
 
 fun test() {
-    val a = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>[]<!>
+    val a = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>[]<!>
     val b: Array<Int> = []
     val c = [1, 2]
     val d: Array<Int> = [1, 2]
-    val e: Array<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>[1]<!>
+    val e: Array<String> = <!TYPE_MISMATCH, TYPE_MISMATCH!>[1]<!>
 
     val f: IntArray = [1, 2]
     val g = [f]
@@ -19,5 +19,5 @@ fun check() {
     val f: IntArray = [1]
     [f] checkType { _<Array<IntArray>>() }
 
-    [1, ""] checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><Array<Any>>() }
+    [1, ""] checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Array<Any>>() }
 }

compiler/testData/diagnostics/tests/collectionLiterals/collectionLiteralsWithVarargs.kt

@@ -16,7 +16,7 @@ fun test1_0() {}
 @Ann1(*["a", "b"])
 fun test1_1() {}
 
-@Ann1(*<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>["a", 1, <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>null<!>]<!>)
+@Ann1(*<!TYPE_MISMATCH, TYPE_MISMATCH!>["a", 1, <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>null<!>]<!>)
 fun test1_2() {}
 
 @Ann2(*[])
@@ -33,8 +33,8 @@ fun test6() {}
 
 annotation class AnnArray(val a: Array<String>)
 
-@AnnArray(<!NON_VARARG_SPREAD{OI}!>*<!>["/"])
+@AnnArray(*["/"])
 fun testArray() {}
 
-@Ann1(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH, TYPE_MISMATCH!>[""]<!>)
+@Ann1(<!TYPE_MISMATCH, TYPE_MISMATCH!>[""]<!>)
 fun testVararg() {}

compiler/testData/diagnostics/tests/collectionLiterals/defaultValuesInAnnotation.kt

@@ -7,9 +7,9 @@ annotation class Foo(
 )
 
 annotation class Bar(
-        val a: Array<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>[' ']<!>,
+        val a: Array<String> = <!TYPE_MISMATCH, TYPE_MISMATCH!>[' ']<!>,
-        val b: Array<String> = <!ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT, TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>["", <!EMPTY_CHARACTER_LITERAL!>''<!>]<!>,
+        val b: Array<String> = <!ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT, TYPE_MISMATCH!>["", <!EMPTY_CHARACTER_LITERAL!>''<!>]<!>,
-        val c: Array<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>[1]<!>
+        val c: Array<String> = <!TYPE_MISMATCH, TYPE_MISMATCH!>[1]<!>
 )
 
 annotation class Base(
@@ -21,5 +21,5 @@ annotation class Base(
 
 annotation class Err(
         val a: IntArray = [<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1L<!>],
-        val b: Array<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>[1]<!>
+        val b: Array<String> = <!TYPE_MISMATCH, TYPE_MISMATCH!>[1]<!>
 )

compiler/testData/diagnostics/tests/collectionLiterals/noCollectionLiterals.kt

@@ -5,7 +5,7 @@ fun test(): Array<Int> {
 
     foo(<!UNSUPPORTED!>[""]<!>)
 
-    val p = <!UNSUPPORTED!>[1, 2]<!> <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>+<!> <!UNSUPPORTED{OI}!>[3, 4]<!>
+    val p = <!UNSUPPORTED!>[1, 2]<!> <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>+<!> [3, 4]
 
     return <!UNSUPPORTED!>[1, 2]<!>
 }

compiler/testData/diagnostics/tests/controlFlowAnalysis/UninitializedOrReassignedVariables.kt

@@ -240,7 +240,7 @@ class Outer() {
 }
 
 class ForwardAccessToBackingField() { //kt-147
-    val a = <!DEBUG_INFO_MISSING_UNRESOLVED{NI}, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM, UNINITIALIZED_VARIABLE{OI}!>a<!> // error
+    val a = <!DEBUG_INFO_MISSING_UNRESOLVED, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>a<!> // error
     val b = <!UNINITIALIZED_VARIABLE!>c<!> // error
     val c = 1
 }

compiler/testData/diagnostics/tests/controlFlowAnalysis/elvisNotProcessed.kt

@@ -11,16 +11,16 @@ else {
 }
 
 val ww = if (true) {
-    <!TYPE_MISMATCH{OI}!>{ true }<!> <!USELESS_ELVIS!>?: null!!<!>
+    { true } <!USELESS_ELVIS!>?: null!!<!>
 }
 else if (true) {
-    <!TYPE_MISMATCH{OI}!>{ true }<!> <!USELESS_ELVIS!>?: null!!<!>
+    { true } <!USELESS_ELVIS!>?: null!!<!>
 }
 else {
     null!!
 }
 
-val <!IMPLICIT_NOTHING_PROPERTY_TYPE{OI}!>n<!> = null ?: (null ?: <!TYPE_MISMATCH{OI}!>{ true }<!>)
+val n = null ?: (null ?: { true })
 
 fun l(): (() -> Boolean)? = null
 
@@ -33,6 +33,6 @@ val bbb = null ?: ( l() <!USELESS_ELVIS_RIGHT_IS_NULL!>?: null<!>)
 val bbbb = ( l() <!USELESS_ELVIS_RIGHT_IS_NULL!>?: null<!>) ?: ( l() <!USELESS_ELVIS_RIGHT_IS_NULL!>?: null<!>)
 
 fun f(x : Long?): Long {
-    var a = x ?: (<!TYPE_MISMATCH{OI}!>fun() {}<!> <!USELESS_ELVIS!>?: <!TYPE_MISMATCH{OI}!>fun() {}<!><!>)
+    var a = x ?: (fun() {} <!USELESS_ELVIS!>?: fun() {}<!>)
-    return <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, TYPE_MISMATCH{NI}!>a<!>
+    return <!TYPE_MISMATCH!>a<!>
 }

compiler/testData/diagnostics/tests/controlFlowAnalysis/kt10805.kt

@@ -1,11 +1,11 @@
 // AssertionError for nested ifs with lambdas and Nothing as results
 // NI_EXPECTED_FILE
 
-val <!IMPLICIT_NOTHING_PROPERTY_TYPE{OI}!>fn<!> = if (true) {
+val fn = if (true) {
-    <!TYPE_MISMATCH{OI}!>{ true }<!>
+    { true }
-} 
+}
 else if (true) {
-    <!TYPE_MISMATCH{OI}!>{ true }<!>
+    { true }
 }
 else {
     null!!

compiler/testData/diagnostics/tests/controlStructures/ifElseIntersection.kt

@@ -8,7 +8,7 @@ class None<T> : Option<T>
 fun <T> bind(r: Option<T>): Option<T> {
     return if (r is Some) {
         // Ideally we should infer Option<T> here (see KT-10896)
-        (<!TYPE_INFERENCE_FAILED_ON_SPECIAL_CONSTRUCT{OI}!>if<!> (true) <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!>None()<!> else <!DEBUG_INFO_SMARTCAST{OI}!>r<!>) checkType { <!TYPE_MISMATCH{OI}!>_<!><Option<T>>() }
+        (if (true) None() else r) checkType { _<Option<T>>() }
         // Works correctly
         if (true) None() else r
     }
@@ -24,9 +24,9 @@ fun <T> bind2(r: Option<T>): Option<T> {
 }
 
 fun <T, R> bind3(r: Option<T>): Option<T> {
-    return if (r is Some) <!TYPE_MISMATCH{NI}!>{
+    return if (r is Some) <!TYPE_MISMATCH!>{
         // Diagnoses an error correctly
-        if (true) <!TYPE_MISMATCH{OI}!>None<R>()<!> else r
+        if (true) None<R>() else r
     }<!>
     else r
 }

compiler/testData/diagnostics/tests/controlStructures/ifInResultOfLambda.kt

@@ -1,8 +1,8 @@
 // NI_EXPECTED_FILE
 
-val test1 = { if (true) <!IMPLICIT_CAST_TO_ANY{OI}!>1<!> else <!IMPLICIT_CAST_TO_ANY{OI}!>""<!> }
+val test1 = { if (true) 1 else "" }
 
-val test2 = { { if (true) <!IMPLICIT_CAST_TO_ANY{OI}!>1<!> else <!IMPLICIT_CAST_TO_ANY{OI}!>""<!> } }
+val test2 = { { if (true) 1 else "" } }
 
 val test3: (Boolean) -> Any = { if (it) 1 else "" }
 

compiler/testData/diagnostics/tests/controlStructures/ifToAnyDiscriminatingUsages.kt

@@ -16,8 +16,8 @@ fun testResultOfLambda2() =
 
 fun testResultOfAnonFun1() =
         run(fun () =
-                if (true) <!IMPLICIT_CAST_TO_ANY{OI}!>42<!>
+                if (true) 42
-                else <!IMPLICIT_CAST_TO_ANY{OI}!>println()<!>
+                else println()
         )
 
 fun testResultOfAnonFun2() =
@@ -27,7 +27,7 @@ fun testResultOfAnonFun2() =
 
 fun testReturnFromAnonFun() =
         run(fun () {
-            return <!TYPE_MISMATCH{NI}!>if (true) <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>42<!> else println()<!>
+            return <!TYPE_MISMATCH!>if (true) 42 else println()<!>
         })
 
 fun <!IMPLICIT_NOTHING_RETURN_TYPE!>testReturn1<!>() =

compiler/testData/diagnostics/tests/controlStructures/ifWhenWithoutElse.kt

@@ -19,10 +19,10 @@ val xx6 = null ?: <!INVALID_IF_AS_EXPRESSION!>if<!> (true) 42
 val xx7 = "" + <!INVALID_IF_AS_EXPRESSION!>if<!> (true) 42
 
 val wxx1 = <!NO_ELSE_IN_WHEN!>when<!> { true -> 42 }
-val wxx2: Unit = <!TYPE_MISMATCH{NI}!><!NO_ELSE_IN_WHEN!>when<!> { true -> <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>42<!> }<!>
+val wxx2: Unit = <!TYPE_MISMATCH!><!NO_ELSE_IN_WHEN!>when<!> { true -> 42 }<!>
 val wxx3 = idAny(<!NO_ELSE_IN_WHEN!>when<!> { true -> 42 })
 val wxx4 = id(<!NO_ELSE_IN_WHEN!>when<!> { true -> 42 })
-val wxx5 = idUnit(<!TYPE_MISMATCH{NI}!><!NO_ELSE_IN_WHEN!>when<!> { true -> <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>42<!> }<!>)
+val wxx5 = idUnit(<!TYPE_MISMATCH!><!NO_ELSE_IN_WHEN!>when<!> { true -> 42 }<!>)
 val wxx6 = null ?: <!NO_ELSE_IN_WHEN!>when<!> { true -> 42 }
 val wxx7 = "" + <!NO_ELSE_IN_WHEN!>when<!> { true -> 42 }
 
@@ -50,8 +50,8 @@ fun g1() = <!NO_ELSE_IN_WHEN!>when<!> { true -> work() }
 fun g2() = <!NO_ELSE_IN_WHEN!>when<!> { true -> mlist.add() }
 fun g3() = <!NO_ELSE_IN_WHEN!>when<!> { true -> 42 }
 fun g4(): Unit = <!NO_ELSE_IN_WHEN!>when<!> { true -> work() }
-fun g5(): Unit = <!TYPE_MISMATCH{NI}!><!NO_ELSE_IN_WHEN!>when<!> { true -> <!TYPE_MISMATCH{OI}!>mlist.add()<!> }<!>
+fun g5(): Unit = <!TYPE_MISMATCH!><!NO_ELSE_IN_WHEN!>when<!> { true -> mlist.add() }<!>
-fun g6(): Unit = <!TYPE_MISMATCH{NI}!><!NO_ELSE_IN_WHEN!>when<!> { true -> <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>42<!> }<!>
+fun g6(): Unit = <!TYPE_MISMATCH!><!NO_ELSE_IN_WHEN!>when<!> { true -> 42 }<!>
 
 fun foo1(x: String?) {
     "" + <!INVALID_IF_AS_EXPRESSION!>if<!> (true) 42

compiler/testData/diagnostics/tests/controlStructures/improperElseInExpression.kt

@@ -29,5 +29,5 @@ fun example() {
         return <!TYPE_MISMATCH!><!INVALID_IF_AS_EXPRESSION!>if<!> (true) true<!>
     }
 
-    return <!TYPE_MISMATCH{NI}!>if (true) <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>true<!> else {}<!>
+    return <!TYPE_MISMATCH!>if (true) true else {}<!>
 }

compiler/testData/diagnostics/tests/controlStructures/kt1075.kt

@@ -4,7 +4,7 @@ package kt1075
 
 fun foo(b: String) {
     if (<!TYPE_MISMATCH!>b<!> in 1..10) {} //type mismatch
-    when (<!TYPE_MISMATCH{NI}!>b<!>) {
+    when (<!TYPE_MISMATCH!>b<!>) {
         <!TYPE_MISMATCH_IN_RANGE!>in<!> 1..10 -> 1 //no type mismatch, but it should be here
         else -> 2
     }

compiler/testData/diagnostics/tests/controlStructures/kt4310.kt

@@ -3,9 +3,9 @@ package f
 fun test(a: Boolean, b: Boolean): Int {
     return if(a) {
         1
-    } else <!TYPE_MISMATCH{NI}!>{
+    } else <!TYPE_MISMATCH!>{
-        <!TYPE_MISMATCH{OI}!><!INVALID_IF_AS_EXPRESSION!>if<!> (b) {
+        <!INVALID_IF_AS_EXPRESSION!>if<!> (b) {
             3
-        }<!>
+        }
     }<!>
 }

compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.kt

@@ -104,8 +104,8 @@ fun testImplicitCoercion() {
     val g = <!INVALID_IF_AS_EXPRESSION!>if<!> (true) 4
     val h = if (false) <!IMPLICIT_CAST_TO_ANY!>4<!> else <!IMPLICIT_CAST_TO_ANY!>{}<!>
 
-    bar(<!TYPE_MISMATCH{NI}!>if (true) {
+    bar(<!TYPE_MISMATCH!>if (true) {
-        <!CONSTANT_EXPECTED_TYPE_MISMATCH{OI}!>4<!>
+        4
     } else {
         z = 342
     }<!>)

compiler/testData/diagnostics/tests/controlStructures/lambdasInExclExclAndElvis.kt

@@ -7,9 +7,9 @@ fun test() {
     use({ }<!NOT_NULL_ASSERTION_ON_LAMBDA_EXPRESSION!>!!<!>);
 
     // KT-KT-9070
-    <!TYPE_MISMATCH{OI}!>{ }<!> <!USELESS_ELVIS!>?: 1<!>
+    { } <!USELESS_ELVIS!>?: 1<!>
     use({ 2 } <!USELESS_ELVIS!>?: 1<!>);
 
-    1 <!USELESS_ELVIS!>?: <!TYPE_MISMATCH{OI}!>{ }<!><!>
+    1 <!USELESS_ELVIS!>?: { }<!>
     use(1 <!USELESS_ELVIS!>?: { }<!>)
 }

compiler/testData/diagnostics/tests/controlStructures/tryReturnType.kt

@@ -13,11 +13,11 @@ fun foo() : Int {
 }
 
 fun bar() : Int =
-    try <!TYPE_MISMATCH{NI}!>{
+    try <!TYPE_MISMATCH!>{
-        <!TYPE_MISMATCH{OI}!>doSmth()<!>
+        doSmth()
     }<!>
-    catch (e: Exception) <!TYPE_MISMATCH{NI}!>{
+    catch (e: Exception) <!TYPE_MISMATCH!>{
-        <!TYPE_MISMATCH{OI}!>""<!>
+        ""
     }<!>
     finally {
         ""

compiler/testData/diagnostics/tests/controlStructures/typeInferenceForExclExcl.kt

@@ -12,9 +12,9 @@ fun <T: Any> exclExcl(t: T?): T = t!!
 fun test11() {
     // not 'String!'
     exclExcl(A.foo()) checkType { _<String>() }
-    exclExcl(A.foo()) checkType { <!TYPE_MISMATCH{OI}, UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><String?>() }
+    exclExcl(A.foo()) checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String?>() }
 
     // not 'String!'
     A.foo()!! checkType { _<String>() }
-    A.foo()!! checkType { <!TYPE_MISMATCH{OI}, UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><String?>() }
+    A.foo()!! checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String?>() }
 }

compiler/testData/diagnostics/tests/controlStructures/whenInResultOfLambda.kt

@@ -1,8 +1,8 @@
 // NI_EXPECTED_FILE
 
-val test1 = { when (true) { true -> <!IMPLICIT_CAST_TO_ANY{OI}!>1<!>; else -> <!IMPLICIT_CAST_TO_ANY{OI}!>""<!> } }
+val test1 = { when (true) { true -> 1; else -> "" } }
 
-val test2 = { { when (true) { true -> <!IMPLICIT_CAST_TO_ANY{OI}!>1<!>; else -> <!IMPLICIT_CAST_TO_ANY{OI}!>""<!> } } }
+val test2 = { { when (true) { true -> 1; else -> "" } } }
 
 val test3: (Boolean) -> Any = { when (true) { true -> 1; else -> "" } }
 

compiler/testData/diagnostics/tests/dataClasses/extensionComponentsOnNullable.kt

@@ -8,7 +8,7 @@ fun foo(): Int {
     val d: Data<Int>? = null
     // An error must be here
     val (x, y) = <!COMPONENT_FUNCTION_ON_NULLABLE, COMPONENT_FUNCTION_ON_NULLABLE!>d<!>
-    return <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{NI}!>x<!> <!DEBUG_INFO_MISSING_UNRESOLVED{NI}!>+<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{NI}!>y<!>
+    return <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!> <!DEBUG_INFO_MISSING_UNRESOLVED!>+<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>y<!>
 }
 
 data class NormalData<T>(val x: T, val y: T)
@@ -17,5 +17,5 @@ fun bar(): Int {
     val d: NormalData<Int>? = null
     // An error must be here
     val (x, y) = <!COMPONENT_FUNCTION_ON_NULLABLE, COMPONENT_FUNCTION_ON_NULLABLE!>d<!>
-    return <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>+<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>y<!>
+    return <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!> <!DEBUG_INFO_MISSING_UNRESOLVED!>+<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>y<!>
 }

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpression.kt

@@ -5,6 +5,6 @@ fun foo() {
     val x: Int? = null
 
     bar(1 + (if (x == null) 0 else x))
-    bar(<!TYPE_MISMATCH{NI}!>if (x == null) <!DEBUG_INFO_CONSTANT, TYPE_MISMATCH{OI}!>x<!> else x<!>)
+    bar(<!TYPE_MISMATCH!>if (x == null) <!DEBUG_INFO_CONSTANT!>x<!> else x<!>)
     if (x != null) bar(x + x/(x-x*x))
 }

compiler/testData/diagnostics/tests/declarationChecks/MultiDeclarationErrors.kt

@@ -11,7 +11,7 @@ class MyClass2 {}
 
 fun test(mc1: MyClass, mc2: MyClass2) {
     val (<!OPERATOR_MODIFIER_REQUIRED!>a<!>, b) = <!COMPONENT_FUNCTION_MISSING, COMPONENT_FUNCTION_MISSING!>mc1<!>
-    val (c) = <!COMPONENT_FUNCTION_AMBIGUITY{OI}, COMPONENT_FUNCTION_MISSING{NI}!>mc2<!>
+    val (c) = <!COMPONENT_FUNCTION_MISSING!>mc2<!>
 
     //a,b,c are error types
     use(<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!>, <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>b<!>, <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>c<!>)

compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_3.kt

@@ -10,7 +10,7 @@ fun test() {
     <!WRONG_MODIFIER_TARGET!>const<!> val <!LOCAL_VARIABLE_WITH_TYPE_PARAMETERS_WARNING!><T><!> a3 = 0
     <!INAPPLICABLE_LATEINIT_MODIFIER, INAPPLICABLE_LATEINIT_MODIFIER, INAPPLICABLE_LATEINIT_MODIFIER!>lateinit<!> val <!LOCAL_VARIABLE_WITH_TYPE_PARAMETERS_WARNING!><T><!> a4 = 0
     val <!LOCAL_VARIABLE_WITH_TYPE_PARAMETERS_WARNING!><T><!> a5 by Delegate<Int>()
-    val <!LOCAL_VARIABLE_WITH_TYPE_PARAMETERS_WARNING!><T><!> a6 by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}!>Delegate<<!UNRESOLVED_REFERENCE!>T<!>>()<!>
+    val <!LOCAL_VARIABLE_WITH_TYPE_PARAMETERS_WARNING!><T><!> a6 by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate<<!UNRESOLVED_REFERENCE!>T<!>>()<!>
 }
 
 class Delegate<F> {

compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_4.kt

@@ -10,7 +10,7 @@ fun test() {
     <!WRONG_MODIFIER_TARGET!>const<!> val <!LOCAL_VARIABLE_WITH_TYPE_PARAMETERS!><T><!> a3 = 0
     <!INAPPLICABLE_LATEINIT_MODIFIER, INAPPLICABLE_LATEINIT_MODIFIER, INAPPLICABLE_LATEINIT_MODIFIER!>lateinit<!> val <!LOCAL_VARIABLE_WITH_TYPE_PARAMETERS!><T><!> a4 = 0
     val <!LOCAL_VARIABLE_WITH_TYPE_PARAMETERS!><T><!> a5 by Delegate<Int>()
-    val <!LOCAL_VARIABLE_WITH_TYPE_PARAMETERS!><T><!> a6 by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}!>Delegate<<!UNRESOLVED_REFERENCE!>T<!>>()<!>
+    val <!LOCAL_VARIABLE_WITH_TYPE_PARAMETERS!><T><!> a6 by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate<<!UNRESOLVED_REFERENCE!>T<!>>()<!>
 }
 
 class Delegate<F> {

compiler/testData/diagnostics/tests/declarationChecks/namedFunAsLastExpressionInBlock.kt

@@ -6,8 +6,8 @@ fun test() {
     val x = fun <!ANONYMOUS_FUNCTION_WITH_NAME!>named1<!>(x: Int): Int { return 1 }
     x checkType { _<Function1<Int, Int>>() }
 
-    foo <!TYPE_MISMATCH{NI}!>{ <!EXPECTED_TYPE_MISMATCH("() -> Int")!>fun named2(): Int {return 1}<!> }<!>
+    foo <!TYPE_MISMATCH!>{ <!EXPECTED_TYPE_MISMATCH("() -> Int")!>fun named2(): Int {return 1}<!> }<!>
-    foo(<!TYPE_MISMATCH{NI}!>{ <!EXPECTED_TYPE_MISMATCH!>fun named3() = 1<!> }<!>)
+    foo(<!TYPE_MISMATCH!>{ <!EXPECTED_TYPE_MISMATCH!>fun named3() = 1<!> }<!>)
 
     val x1 =
     <!INVALID_IF_AS_EXPRESSION!>if<!> (1 == 1)
@@ -26,15 +26,15 @@ fun test() {
     <!SYNTAX!><!>fun named7() = 1
 
     val x3 = when (1) {
-        0 -> <!EXPECTED_TYPE_MISMATCH{OI}!>fun <!ANONYMOUS_FUNCTION_WITH_NAME{NI}!>named8<!>(): Int {return 1}<!>
+        0 -> fun <!ANONYMOUS_FUNCTION_WITH_NAME!>named8<!>(): Int {return 1}
-        else -> <!EXPECTED_TYPE_MISMATCH{OI}!>fun <!ANONYMOUS_FUNCTION_WITH_NAME{NI}!>named9<!>() = 1<!>
+        else -> fun <!ANONYMOUS_FUNCTION_WITH_NAME!>named9<!>() = 1
     }
 
     val x31 = when (1) {
         0 -> {
-            <!EXPECTED_TYPE_MISMATCH{OI}!>fun named10(): Int {return 1}<!>
+            fun named10(): Int {return 1}
         }
-        else -> <!EXPECTED_TYPE_MISMATCH{OI}!>fun <!ANONYMOUS_FUNCTION_WITH_NAME{NI}!>named11<!>() = 1<!>
+        else -> fun <!ANONYMOUS_FUNCTION_WITH_NAME!>named11<!>() = 1
     }
 
     val x4 = {
@@ -64,11 +64,11 @@ fun success() {
 
     val y = when (1) {
         0 -> {
-            <!EXPECTED_TYPE_MISMATCH{OI}!>fun named4(): Int {return 1}<!>
+            fun named4(): Int {return 1}
         }
         else -> {
-            <!EXPECTED_TYPE_MISMATCH{OI}!>fun named5(): Int {return 1}<!>
+            fun named5(): Int {return 1}
         }
     }
-    y checkType { <!TYPE_MISMATCH{OI}!>_<!><Unit>() }
+    y checkType { _<Unit>() }
 }

compiler/testData/diagnostics/tests/delegatedProperty/inference/differentDelegatedExpressions.kt

@@ -9,10 +9,10 @@ class A(outer: Outer) {
     var g: String by  outer.getContainer().getMyProperty()
 
 
-    var b: String by  <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}!>foo(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>getMyProperty<!>())<!>
+    var b: String by  <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>foo(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())<!>
-    var r: String by  <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}!>foo(outer.getContainer().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>getMyProperty<!>())<!>
+    var r: String by  <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>foo(outer.getContainer().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())<!>
-    var e: String by  <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>+<!> <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>foo<!>(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>getMyProperty<!>())
+    var e: String by  <!DEBUG_INFO_MISSING_UNRESOLVED!>+<!> <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())
-    var f: String by  <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>foo<!>(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>getMyProperty<!>()) <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>-<!> 1
+    var f: String by  <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>()) <!DEBUG_INFO_MISSING_UNRESOLVED!>-<!> 1
 }
 
 fun <A, B> foo(a: Any?) = MyProperty<A, B>()

compiler/testData/diagnostics/tests/delegatedProperty/inference/extensionProperty.kt

@@ -3,10 +3,10 @@ package foo
 import kotlin.reflect.KProperty
 
 open class A {
-    val B.w: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}!><!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>MyProperty<!>()<!>
+    val B.w: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>MyProperty()<!>
 }
 
-val B.r: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}!><!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>MyProperty<!>()<!>
+val B.r: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>MyProperty()<!>
 
 val A.e: Int by MyProperty()
 

compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethodInGenericClass.kt

@@ -7,7 +7,7 @@ class A<R>() {
     operator fun <T> setValue(t: Any?, p: KProperty<*>, x: T) = Unit
 }
 
-var a1: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>A<!>()<!>
+var a1: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>A<!>()<!>
 var a2: Int by A<String>()
 
 class B<R>() {
@@ -24,4 +24,4 @@ class C<R>() {
 }
 
 var c1: Int by C()
-var c2: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}, DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH{OI}!>C<Number>()<!>
+var c2: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>C<Number>()<!>

compiler/testData/diagnostics/tests/delegatedProperty/inference/manyIncompleteCandidates.kt

@@ -4,7 +4,7 @@ package test
 import first.*
 import second.*
 
-val a12 by <!DELEGATE_SPECIAL_FUNCTION_AMBIGUITY{NI}, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{OI}!>A()<!>
+val a12 by <!DELEGATE_SPECIAL_FUNCTION_AMBIGUITY!>A()<!>
 
 // FILE: first.kt
 package first

compiler/testData/diagnostics/tests/delegatedProperty/inference/noErrorsForImplicitConstraints.kt

@@ -3,8 +3,8 @@ package foo
 import kotlin.reflect.KProperty
 
 class A {
-    var a5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>MyProperty1<!>()<!>
+    var a5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>MyProperty1<!>()<!>
-    var b5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>getMyProperty1<!>()<!>
+    var b5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty1<!>()<!>
 }
 
 fun <A, B> getMyProperty1() = MyProperty1<A, B>()
@@ -23,8 +23,8 @@ class MyProperty1<T, R> {
 // -----------------
 
 class B {
-    var a5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>MyProperty2<!>()<!>
+    var a5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>MyProperty2<!>()<!>
-    var b5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>getMyProperty2<!>()<!>
+    var b5: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty2<!>()<!>
 }
 
 fun <A, B> getMyProperty2() = MyProperty2<A, B>()

compiler/testData/diagnostics/tests/delegatedProperty/inference/noExpectedTypeForSupertypeConstraint.kt

@@ -2,7 +2,7 @@
 import kotlin.reflect.KProperty
 
 class A {
-    var a by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>MyProperty<!>()<!>
+    var a by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>MyProperty<!>()<!>
 }
 
 class MyProperty<T, R> {

compiler/testData/diagnostics/tests/delegatedProperty/propertyDefferedType.kt

@@ -4,7 +4,7 @@
 import kotlin.reflect.KProperty
 
 class B {
-    val c by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}!>Delegate(<!UNRESOLVED_REFERENCE!>ag<!>)<!>
+    val c by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate(<!UNRESOLVED_REFERENCE!>ag<!>)<!>
 }
 
 class Delegate<T: Any>(val init: T) {

compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/commonCaseForInference.kt

@@ -8,6 +8,6 @@ object CommonCase {
     operator fun <D, E, R> Fas<D, E, R>.provideDelegate(host: D, p: Any?): Fas<D, E, R> = TODO()
     operator fun <D, E, R> Fas<D, E, R>.getValue(receiver: E, p: Any?): R = TODO()
 
-    val Long.test1: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>delegate<!>()<!> // common test, not working because of Inference1
+    val Long.test1: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>delegate<!>()<!> // common test, not working because of Inference1
     val Long.test2: String by delegate<CommonCase, Long, String>() // should work
 }

compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver2.kt

@@ -9,5 +9,5 @@ object T2 {
     operator fun <T> Foo<T>.getValue(receiver: String, p: Any?): T = TODO()
 
     val String.test1: String by delegate()
-    val test2: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}!><!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>delegate<!>()<!>
+    val test2: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>delegate()<!>
 }

compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/inferenceFromReceiver1.kt

@@ -8,7 +8,7 @@ object Inference1 {
     operator fun <T> Foo<T>.getValue(receiver: T, p: Any?): String = TODO()
 
     // not working because resulting descriptor for getValue contains type `???` instead of `T`
-    val test1: String by <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>delegate<!>()
+    val test1: String by delegate()
 
     val test2: String by delegate<Inference1>()
 }

compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/inferenceFromReceiver2.kt

@@ -8,6 +8,6 @@ object Inference2 {
     operator fun <T> Foo<T>.provideDelegate(host: T, p: Any?): Foo<T> = TODO()
     operator fun <T> Foo<T>.getValue(receiver: Inference2, p: Any?): String = TODO()
 
-    val test1: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>delegate<!>()<!> // same story like in Inference1
+    val test1: String by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>delegate<!>()<!> // same story like in Inference1
     val test2: String by delegate<Inference2>()
 }

compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/noOperatorModifierOnProvideDelegate.kt

@@ -12,6 +12,5 @@ fun String.provideDelegate(a: Any?, p: KProperty<*>) = StringDelegate(this)
 operator fun String.getValue(a: Any?, p: KProperty<*>) = this
 
 val test1: String by "OK"
-val test2: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}, DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH{OI}!>"OK"<!>
+val test2: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>"OK"<!>
 val test3 by "OK"
-

compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/setValue.kt

@@ -7,10 +7,10 @@ operator fun <T> Delegate<T>.setValue(receiver: Any?, p: Any, value: T) {}
 
 operator fun <T> String.provideDelegate(receiver: Any?, p: Any) = Delegate<T>()
 
-var test1: String by <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>Delegate<!>()
+var test1: String by Delegate()
 var test2: String by Delegate<String>()
 
 var test3: String by <!DELEGATE_SPECIAL_FUNCTION_MISSING, DELEGATE_SPECIAL_FUNCTION_MISSING, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>"OK"<!>
 
-var test4: String by "OK".<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>provideDelegate<!>(null, "")
+var test4: String by "OK".provideDelegate(null, "")
 var test5: String by "OK".provideDelegate<String>(null, "")

compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/unsupportedOperatorProvideDelegate.kt

@@ -10,5 +10,5 @@ class WrongDelegate(val x: Int) {
 operator fun String.getValue(thisRef: Any?, prop: Any) = this
 
 val test1: String by "OK"
-val test2: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}, DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH{OI}!>"OK"<!>
+val test2: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>"OK"<!>
 val test3 by "OK"

compiler/testData/diagnostics/tests/delegatedProperty/recursiveType.kt

@@ -3,12 +3,12 @@
 
 import kotlin.reflect.KProperty
 
-val a by <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{NI}, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM{OI}!>a<!>
+val a by <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!>
 
-val b by Delegate(<!DEBUG_INFO_MISSING_UNRESOLVED{NI}, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>b<!>)
+val b by Delegate(<!DEBUG_INFO_MISSING_UNRESOLVED, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>b<!>)
 
 val c by <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, UNINITIALIZED_VARIABLE!>d<!>
-val d by <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{NI}, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM{OI}!>c<!>
+val d by <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>c<!>
 
 class Delegate(i: Int) {
   operator fun getValue(t: Any?, p: KProperty<*>): Int {

compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForGetReturnType.kt

@@ -2,7 +2,7 @@
 
 import kotlin.reflect.KProperty
 
-val c: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE{NI}, DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH{OI}!>Delegate()<!>
+val c: Int by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>Delegate()<!>
 
 class Delegate {
   operator fun getValue(t: Any?, p: KProperty<*>): String {

compiler/testData/diagnostics/tests/delegation/DelegationExpectedType.kt

@@ -20,6 +20,6 @@ class D : A<Int> by baz({ it + 1 })
 
 fun <T> boo(t: T): A<T> = AImpl()
 
-class E : A<Int> by <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>boo("")<!>
+class E : A<Int> by <!TYPE_MISMATCH, TYPE_MISMATCH!>boo("")<!>
 
 class F : A<Int> by <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>AImpl<String>()<!>

compiler/testData/diagnostics/tests/enum/kt8972_cloneNotAllowed.kt

@@ -1,6 +1,6 @@
 enum class E : Cloneable {
     A;
     <!OVERRIDING_FINAL_MEMBER!>override<!> fun clone(): Any {
-        return <!AMBIGUOUS_SUPER!>super<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>clone<!>()
+        return <!AMBIGUOUS_SUPER!>super<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>clone<!>()
     }
 }

compiler/testData/diagnostics/tests/extensions/ExtensionFunctions.kt

@@ -19,7 +19,7 @@ class A
 infix operator fun A.plus(a : Any) {
 
   1.foo()
-  true.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>foo<!>(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
+  true.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
 
   1
 }

compiler/testData/diagnostics/tests/extensions/throwOutCandidatesByReceiver.kt

@@ -34,22 +34,22 @@ fun test4() {
 // should be an error on receiver, shouldn't be thrown away
 
 fun test5() {
-    <!TYPE_MISMATCH{OI}!>1<!>.<!FUNCTION_EXPECTED{NI}!>(fun String.()=1)<!>()
+    1.<!FUNCTION_EXPECTED!>(fun String.()=1)<!>()
 }
 
 fun <R: Any> R?.sure() : R = this!!
 
 fun <T> test6(l: List<T>?) {
-    <!TYPE_MISMATCH{OI}!>l<!>.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>sure<!><<!UPPER_BOUND_VIOLATED{OI}!>T<!>>()
+    l.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>sure<!><T>()
 }
 
 
 fun List<String>.b() {}
 
 fun test7(l: List<String?>) {
-    <!TYPE_MISMATCH{OI}!>l<!>.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>b<!>()
+    l.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>b<!>()
 }
 
 fun test8(l: List<Any>?) {
-    <!TYPE_MISMATCH{OI}!>l<!>.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>b<!>()
+    l.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>b<!>()
 }

compiler/testData/diagnostics/tests/functionAsExpression/InferenceParametersTypes.kt

@@ -11,7 +11,7 @@ fun test(a: (Int) -> Int) {
 }
 
 fun test2(a: () -> List<Int>) {
-    test2(fun () = <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>listOf<!>())
+    test2(fun () = listOf())
 }
 
 val a: (Int) -> Unit = fun(x) { checkSubtype<Int>(x) }