Remove OI/NI attributes from test data

2021-05-24 12:42:39 +03:00
parent 2ecba6ac39
commit ddbdfafa79
441 changed files with 1005 additions and 1037 deletions
@@ -3,7 +3,7 @@ fun <T: Any> fooT22() : T? {
 }

 fun foo1() {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>fooT22<!>()
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooT22<!>()
 }

 val n : Nothing = null.sure()
@@ -4,5 +4,5 @@ fun <T> g(i: Int, a: Any): List<T> {throw Exception()}
 fun <T> g(a: Any, i: Int): Collection<T> {throw Exception()}

 fun <T> test() {
-    val c: List<T> = <!CANNOT_COMPLETE_RESOLVE{OI}, OVERLOAD_RESOLUTION_AMBIGUITY{NI}!>g<!>(1, 1)
+    val c: List<T> = <!OVERLOAD_RESOLUTION_AMBIGUITY!>g<!>(1, 1)
 }
@@ -3,4 +3,4 @@ package f
 fun <R> h(i: Int, a: Any, r: R, f: (Boolean) -> Int) = 1
 fun <R> h(a: Any, i: Int, r: R, f: (Boolean) -> Int) = 1

-fun test() = <!CANNOT_COMPLETE_RESOLVE{OI}, OVERLOAD_RESOLUTION_AMBIGUITY{NI}!>h<!>(1, 1, 1, { <!CANNOT_INFER_PARAMETER_TYPE{OI}!>b<!> -> 42 })
+fun test() = <!OVERLOAD_RESOLUTION_AMBIGUITY!>h<!>(1, 1, 1, { b -> 42 })
@@ -4,7 +4,7 @@ fun <T> f(i: Int, c: Collection<T>): List<T> {throw Exception()}
 fun <T> f(a: Any, l: List<T>): Collection<T> {throw Exception()}

 fun <T> test(l: List<T>) {
-    <!CANNOT_COMPLETE_RESOLVE{OI}, OVERLOAD_RESOLUTION_AMBIGUITY{NI}!>f<!>(1, <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>emptyList<!>())
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>f<!>(1, emptyList())
 }

 fun <T> emptyList(): List<T> {throw Exception()}
@@ -4,6 +4,6 @@ package f
 fun <R> h(f: (Boolean) -> R) = 1
 fun <R> h(f: (String) -> R) = 2

-fun test() = <!CANNOT_COMPLETE_RESOLVE{OI}, OVERLOAD_RESOLUTION_AMBIGUITY{NI}!>h<!>{ <!CANNOT_INFER_PARAMETER_TYPE{OI}!>i<!> -> getAnswer() }
+fun test() = <!OVERLOAD_RESOLUTION_AMBIGUITY!>h<!>{ i -> getAnswer() }

 fun getAnswer() = 42
@@ -4,13 +4,13 @@
 fun <T: Any> bar(a: Array<T>): Array<T?> =  null!!

 fun test1(a: Array<in Int>) {
-    val r: Array<in Int?> = <!TYPE_INFERENCE_CANNOT_CAPTURE_TYPES{OI}!>bar<!>(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>a<!>)
-    <!TYPE_INFERENCE_CANNOT_CAPTURE_TYPES{OI}!>bar<!>(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>a<!>)
+    val r: Array<in Int?> = bar(<!TYPE_MISMATCH, TYPE_MISMATCH!>a<!>)
+    bar(<!TYPE_MISMATCH, TYPE_MISMATCH!>a<!>)
 }

 fun <T: Any> foo(l: Array<T>): Array<Array<T?>> = null!!

 fun test2(a: Array<in Int>) {
-    val r: Array<out Array<in Int?>> = <!TYPE_INFERENCE_CANNOT_CAPTURE_TYPES{OI}!>foo<!>(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>a<!>)
-    <!TYPE_INFERENCE_CANNOT_CAPTURE_TYPES{OI}!>foo<!>(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>a<!>)
+    val r: Array<out Array<in Int?>> = foo(<!TYPE_MISMATCH, TYPE_MISMATCH!>a<!>)
+    foo(<!TYPE_MISMATCH, TYPE_MISMATCH!>a<!>)
 }
@@ -4,15 +4,15 @@
 fun <T: Any> bar(a: Array<T>): Array<T?> =  null!!

 fun test1(a: Array<out Int>) {
-    val r: Array<out Int?> = <!TYPE_MISMATCH{NI}!><!UNSUPPORTED{NI}!>bar<!>(a)<!>
-    val t = <!UNSUPPORTED{NI}!>bar<!>(a)
-    <!UNSUPPORTED{NI}!>t<!> checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><Array<out Int?>>() }
+    val r: Array<out Int?> = <!TYPE_MISMATCH!><!UNSUPPORTED!>bar<!>(a)<!>
+    val t = <!UNSUPPORTED!>bar<!>(a)
+    <!UNSUPPORTED!>t<!> checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Array<out Int?>>() }
 }

 fun <T: Any> foo(l: Array<T>): Array<Array<T?>> = null!!

 fun test2(a: Array<out Int>) {
-    val r: Array<out Array<out Int?>> = <!TYPE_MISMATCH{NI}!><!UNSUPPORTED{NI}!>foo<!>(a)<!>
-    val t = <!UNSUPPORTED{NI}!>foo<!>(a)
-    <!UNSUPPORTED{NI}!>t<!> checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>_<!><Array<out Array<out Int?>>>() }
+    val r: Array<out Array<out Int?>> = <!TYPE_MISMATCH!><!UNSUPPORTED!>foo<!>(a)<!>
+    val t = <!UNSUPPORTED!>foo<!>(a)
+    <!UNSUPPORTED!>t<!> checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Array<out Array<out Int?>>>() }
 }
@@ -3,11 +3,11 @@
 fun <T : Any> Array<T?>.filterNotNull(): List<T> = throw Exception()

 fun test1(a: Array<out Int?>) {
-    val list = a.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>filterNotNull<!>()
-    <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{NI}!>list<!> <!DEBUG_INFO_MISSING_UNRESOLVED{NI}!>checkType<!> { <!UNRESOLVED_REFERENCE{NI}!>_<!><List<Int>>() }
+    val list = a.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>filterNotNull<!>()
+    <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>list<!> <!DEBUG_INFO_MISSING_UNRESOLVED!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><List<Int>>() }
 }

 fun test2(vararg a: Int?) {
-    val list = a.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>filterNotNull<!>()
-    <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{NI}!>list<!> <!DEBUG_INFO_MISSING_UNRESOLVED{NI}!>checkType<!> { <!UNRESOLVED_REFERENCE{NI}!>_<!><List<Int>>() }
+    val list = a.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>filterNotNull<!>()
+    <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>list<!> <!DEBUG_INFO_MISSING_UNRESOLVED!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><List<Int>>() }
 }
@@ -3,7 +3,7 @@
 fun <T> foo(array: Array<Array<T>>): Array<Array<T>> = array

 fun test(array: Array<Array<out Int>>) {
-    <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>foo<!>(<!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>array<!>)
+    foo(<!TYPE_MISMATCH, TYPE_MISMATCH!>array<!>)

-    val f: Array<out Array<out Int>> = <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>foo<!>(<!TYPE_MISMATCH, TYPE_MISMATCH!>array<!>)
+    val f: Array<out Array<out Int>> = foo(<!TYPE_MISMATCH, TYPE_MISMATCH!>array<!>)
 }
@@ -4,6 +4,6 @@ fun <T> foo(a1: Array<T>, a2: Array<out T>): T = null!!

 fun test(a1: Array<in Int>, a2: Array<Int>) {

-    val c: Int = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>foo(a1, a2)<!>
+    val c: Int = <!TYPE_MISMATCH, TYPE_MISMATCH!>foo(a1, a2)<!>

 }
@@ -2,5 +2,5 @@ fun <T> Array<T>.foo() {}

 fun test(array: Array<out Int>) {
    array.foo()
-    <!TYPE_MISMATCH{OI}!>array<!>.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>foo<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>out<!> Int>()
+    array.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>foo<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>out<!> Int>()
 }
@@ -10,7 +10,7 @@ fun bar(b: B<in A<out Number>>, bOut: B<out A<out Number>>, bOut2: B<out A<Numbe
    foo(b)
    foo<Number>(b)

-    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>baz<!>(<!TYPE_MISMATCH{NI}!>bOut<!>)
+    baz(<!TYPE_MISMATCH!>bOut<!>)
    baz<Number>(<!TYPE_MISMATCH!>bOut<!>)

    baz(bOut2)
@@ -1,12 +1,11 @@
-
 fun <T : Number> materializeNumber(): T = TODO()

 fun a(): Unit = run {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>materializeNumber<!>()
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materializeNumber<!>()
 }

 fun b(): Unit = run {
    run {
-        <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>materializeNumber<!>()
+        <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materializeNumber<!>()
    }
 }
@@ -1,4 +1,3 @@
-
 fun <T> materialize(): T = TODO()

 fun implicitCoercion() {
@@ -13,6 +12,6 @@ fun implicitCoercion() {

    val c = l@{
        // Error: block doesn't have an expected type, so call can't be inferred!
-        return@l <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>materialize<!>()
+        return@l <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materialize<!>()
    }
 }
@@ -53,7 +53,7 @@ fun testParameter() {
    takeFnToParameter { Unit }
    takeFnToParameter { <!UNRESOLVED_REFERENCE!>unresolved<!>() }
    takeFnToParameter { if (true) <!UNRESOLVED_REFERENCE!>unresolved<!>() }
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>takeFnToParameter<!> {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>takeFnToParameter<!> {
        if (true) <!UNRESOLVED_REFERENCE!>unresolved<!>() else <!UNRESOLVED_REFERENCE!>unresolved<!>()
    }
    takeFnToParameter(fun() = Unit)
@@ -1,4 +1,3 @@
-
 fun <T> materialize(): T = TODO()

 fun a(): Unit = run {
@@ -18,13 +17,13 @@ fun c(): Unit = run {
        // Attention!
        // In OI expected type 'Unit' isn't applied here because of implementation quirks (note that OI still applies Unit in case 'e')
        // In NI, it is applied and call is correctly inferred, which is consistent with the previous case
-        <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>materialize<!>()
+        materialize()
    }
 }

 fun d(): Unit = run outer@{
    run inner@{
-        return@inner <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>materialize<!>()
+        return@inner materialize()
    }
 }

@@ -3,5 +3,5 @@
 fun <T : Any> nullable(): T? = null

 fun test() {
-    val value = nullable<Int>() ?: <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!>nullable()<!>
+    val value = nullable<Int>() ?: nullable()
 }
@@ -13,6 +13,6 @@ fun <T: Any> joinT(x: Comparable<*>, y: T): T? {
 }

 fun test() {
-    val x2 = <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>joinT<!>(<!TYPE_MISMATCH!>Unit<!>, "2")
+    val x2 = joinT(<!TYPE_MISMATCH!>Unit<!>, "2")
    checkSubtype<String?>(x2)
 }
@@ -7,9 +7,9 @@ fun <R> elemAndList(r: R, t: MutableList<R>): R = r
 fun <R> R.elemAndListWithReceiver(r: R, t: MutableList<R>): R = r

 fun test() {
-    val s = <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>elemAndList<!>(11, list("72"))
+    val s = elemAndList(11, list("72"))

-    val u = 11.<!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>elemAndListWithReceiver<!>(4, list("7"))
+    val u = 11.elemAndListWithReceiver(4, list("7"))
 }

 fun <T> list(value: T) : ArrayList<T> {
@@ -10,6 +10,6 @@ fun <R> choose3(c: Inv<Inv<R>>) {}

 fun f(o: Out<Out<*>>, i: In<In<*>>, inv: Inv<Inv<*>>) {
    choose1(o)
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>choose2<!>(i)
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}, TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>choose3<!>(<!TYPE_MISMATCH!>inv<!>)
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>choose2<!>(i)
+    choose3(<!TYPE_MISMATCH!>inv<!>)
 }
@@ -2,10 +2,9 @@ package c

 import java.util.ArrayList

-fun Array<Int>.toIntArray(): IntArray = this.<!TYPE_MISMATCH{NI}!><!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>mapTo<!>(<!TYPE_MISMATCH{NI}!>IntArray(size)<!>, {it})<!>
+fun Array<Int>.toIntArray(): IntArray = this.<!TYPE_MISMATCH!>mapTo(<!TYPE_MISMATCH!>IntArray(size)<!>, {it})<!>

 fun Array<Int>.toArrayList(): ArrayList<Int> = this.mapTo(ArrayList<Int>(size), {it})

 public fun <T, R, C: MutableCollection<in R>> Array<out T>.mapTo(result: C, transform : (T) -> R) : C =
        throw Exception("$result $transform")
-
@@ -15,6 +15,6 @@ class C<X, Z, Y : X>

 class D<X, Z, Y : X>(foo: C<X, Z, Y>) {
    fun test(a: C<Y, Y, Y>) {
-        val d: D<X, Y, Y> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>D(a)<!>
+        val d: D<X, Y, Y> = <!TYPE_MISMATCH, TYPE_MISMATCH!>D(a)<!>
    }
 }
@@ -8,5 +8,5 @@ fun <T: Inv2<T>> foo(klass: Inv<T>): String? = null
 fun <X> bar(): Inv<X> = null!!

 fun test() {
-    <!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}!>bar<!>())
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>())
 }
@@ -27,5 +27,5 @@ abstract class MySettingsListener<S extends MyComparableSettings> {}
 fun test() {
    val a = MySettings.getSettings()
    a.getLinkedProjectsSettings()
-    a.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>linkedProjectsSettings<!>
+    a.linkedProjectsSettings
 }
@@ -17,8 +17,8 @@ fun test(out: Out<Int>, i: In<Int>, inv: A<Int>) {
    r checkType { _<Int>() }

    // T? <: Int => error
-    <!TYPE_INFERENCE_INCORPORATION_ERROR{OI}!>doIn<!>(<!TYPE_MISMATCH!>i<!>)
+    doIn(<!TYPE_MISMATCH!>i<!>)

    // T? >: Int => error
-    <!TYPE_INFERENCE_INCORPORATION_ERROR{OI}!>doA<!>(<!TYPE_MISMATCH!>inv<!>)
+    doA(<!TYPE_MISMATCH!>inv<!>)
 }
@@ -13,7 +13,7 @@ fun <T> readFromMyList(l: MyList<out T>, t: T) {}
 fun test1(int: Int, any: Any) {
    val a0 : MyList<Any> = getMyList(int)

-    val a1 : MyList<Int> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>getMyList(any)<!>
+    val a1 : MyList<Int> = <!TYPE_MISMATCH, TYPE_MISMATCH!>getMyList(any)<!>

    val a2 : MyList<out Any> = getMyList(int)

@@ -28,23 +28,23 @@ fun test1(int: Int, any: Any) {
    val a7 : MyList<in Any> = getMyList(int)

    val a8 : MyList<in Any> = <!TYPE_MISMATCH, TYPE_MISMATCH!>getMyListToReadFrom<Int>(int)<!>
-    val a9 : MyList<in Any> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>getMyListToReadFrom(int)<!>
+    val a9 : MyList<in Any> = <!TYPE_MISMATCH, TYPE_MISMATCH!>getMyListToReadFrom(int)<!>

    val a10 : MyList<out Int> = <!TYPE_MISMATCH, TYPE_MISMATCH!>getMyList<Any>(any)<!>
-    val a11 : MyList<out Int> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>getMyList(any)<!>
+    val a11 : MyList<out Int> = <!TYPE_MISMATCH, TYPE_MISMATCH!>getMyList(any)<!>

    val a12 : MyList<out Int> = <!TYPE_MISMATCH, TYPE_MISMATCH!>getMyListToWriteTo<Any>(any)<!>
-    val a13 : MyList<out Int> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>getMyListToWriteTo(any)<!>
+    val a13 : MyList<out Int> = <!TYPE_MISMATCH, TYPE_MISMATCH!>getMyListToWriteTo(any)<!>

    useMyList(getMyList(int), int)
    useMyList(getMyList(any), int)
-    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>useMyList<!>(getMyList(int), any)
+    useMyList(getMyList(int), any)

    readFromMyList(getMyList(int), any)
    readFromMyList(getMyList(any), int)
-    readFromMyList<Int>(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>getMyList(any)<!>, int)
+    readFromMyList<Int>(<!TYPE_MISMATCH, TYPE_MISMATCH!>getMyList(any)<!>, int)

-    readFromMyList<Int>(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>getMyListToReadFrom(any)<!>, int)
+    readFromMyList<Int>(<!TYPE_MISMATCH!>getMyListToReadFrom(any)<!>, int)
    readFromMyList(getMyListToReadFrom(any), int)

    readFromMyList(getMyListToReadFrom(int), any)
@@ -53,14 +53,14 @@ fun test1(int: Int, any: Any) {
    writeToMyList(getMyList(any), int)
    writeToMyList<Any>(getMyList(int), any)
    writeToMyList(getMyList<Any>(int), any)
-    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>writeToMyList<!>(getMyList(int), any)
+    writeToMyList(getMyList(int), any)

    writeToMyList(getMyListToWriteTo(any), int)
-    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>writeToMyList<!>(getMyListToWriteTo(int), any)
+    writeToMyList(getMyListToWriteTo(int), any)

    readFromMyList(getMyListToWriteTo(any), any)

-    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>writeToMyList<!>(getMyListToReadFrom(any), <!TYPE_MISMATCH{NI}!>any<!>)
+    writeToMyList(getMyListToReadFrom(any), <!TYPE_MISMATCH!>any<!>)

    use(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13)
 }
@@ -6,7 +6,7 @@ fun <T> foo() = foo() <!UNCHECKED_CAST!>as T<!>

 fun <T> foo2(): T = TODO()

-val test = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>foo2<!>().<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>plus<!>("") as String
+val test = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo2<!>().<!DEBUG_INFO_MISSING_UNRESOLVED!>plus<!>("") as String

 fun <T> T.bar() = this
 val barTest = "".bar() <!CAST_NEVER_SUCCEEDS!>as<!> Number
@@ -8,12 +8,11 @@ class A {

 fun <V> id(value: V) = value

-val asA = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>foo<!>().<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>fooA<!>() as A
+val asA = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>().<!DEBUG_INFO_MISSING_UNRESOLVED!>fooA<!>() as A

-val receiverParenthesized = (<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>foo<!>()).<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>fooA<!>() as A
-val no2A = A().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>fooA<!>().<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>fooA<!>() as A
+val receiverParenthesized = (<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>()).<!DEBUG_INFO_MISSING_UNRESOLVED!>fooA<!>() as A
+val no2A = A().<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooA<!>().<!DEBUG_INFO_MISSING_UNRESOLVED!>fooA<!>() as A

 val correct1 = A().fooA() as A
 val correct2 = foo<A>().fooA() as A
 val correct3 = A().fooA<A>().fooA() as A
-
@@ -6,7 +6,7 @@ fun <V> id(value: V) = value

 val asString = foo() as String

-val viaId = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>id<!>(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>foo<!>()) as String
+val viaId = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!>(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>()) as String

 val insideId = id(foo() as String)

@@ -16,5 +16,5 @@ val asStarList = foo() as List<*>

 val safeAs = foo() as? String

-val fromIs = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>foo<!>() is String
-val fromNoIs = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>foo<!>() !is String
+val fromIs = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() is String
+val fromNoIs = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>() !is String
@@ -11,7 +11,7 @@ fun test(x: X<Number>) {
 fun <S, D: S> g() {
    fun <T : S> foo(): T = TODO()

-    val y = <!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}, TYPE_MISMATCH{NI}!>foo<!>() as Int
+    val y = <!TYPE_MISMATCH!>foo<!>() as Int

    val y2 = foo() as D
 }
@@ -3,4 +3,4 @@ fun <X, Y, Z> foo(f: (Y) -> Z, g: (X) -> Y, x: X): Z = f(g(x))

 // TODO: Actually, this is a bug and will work when new inference is enabled
 // see ([NI] Select variable with proper non-trivial constraint first) for more details
-fun test() = <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>foo<!>({ it + 1 }, { it.length }, "")
+fun test() = foo({ it + 1 }, { it.length }, "")
@@ -12,5 +12,5 @@ fun test() {
    val q = foo(fun Int.() {}, emptyList()) //type inference no information for parameter error
    checkSubtype<Int>(q)

-    <!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}!>emptyList<!>())
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>({}, <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>())
 }
@@ -24,5 +24,5 @@ fun test(s: SelectorFor<State>): Double {
    val e = s { return p1 }
    e checkType { _<AbstractSelector<State, Nothing>>() }

-    <!UNREACHABLE_CODE{OI}!>return<!> null!!
+    return null!!
 }
@@ -2,7 +2,7 @@

 fun case_1(a: MutableList<out MutableList<MutableList<MutableList<MutableList<MutableList<MutableList<Int?>?>?>?>?>?>?>?) {
    if (a != null) {
-        val b = <!DEBUG_INFO_SMARTCAST{OI}!>a<!>[0] // no SMARTCAST diagnostic
+        val b = a[0] // no SMARTCAST diagnostic
        if (b != null) {
            val c = <!DEBUG_INFO_SMARTCAST!>b<!>[0]
            if (c != null) {
@@ -30,19 +30,19 @@ fun case_1(a: MutableList<out MutableList<MutableList<MutableList<MutableList<Mu

 fun case_2(a: MutableList<out MutableList<MutableList<MutableList<out MutableList<MutableList<MutableList<out Int?>?>?>?>?>?>?>?) {
    if (a != null) {
-        val b = <!DEBUG_INFO_SMARTCAST{OI}!>a<!>[0] // no SMARTCAST diagnostic
+        val b = a[0] // no SMARTCAST diagnostic
        if (b != null) {
            val c = <!DEBUG_INFO_SMARTCAST!>b<!>[0]
            if (c != null) {
                val d = <!DEBUG_INFO_SMARTCAST!>c<!>[0]
                if (d != null) {
-                    val e = <!DEBUG_INFO_SMARTCAST{OI}!>d<!>[0] // no SMARTCAST diagnostic
+                    val e = d[0] // no SMARTCAST diagnostic
                    if (e != null) {
                        val f = <!DEBUG_INFO_SMARTCAST!>e<!>[0]
                        if (f != null) {
                            val g = <!DEBUG_INFO_SMARTCAST!>f<!>[0]
                            if (g != null) {
-                                val h = <!DEBUG_INFO_SMARTCAST{OI}!>g<!>[0] // no SMARTCAST diagnostic
+                                val h = g[0] // no SMARTCAST diagnostic
                                if (h != null) {
                                    <!DEBUG_INFO_SMARTCAST!>h<!>.inc()
                                }
@@ -1,9 +1,9 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE
 // Related issue: KT-28654

-fun <K> select(): K = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>run <!TYPE_MISMATCH{NI}!>{ <!TYPE_MISMATCH{OI}!><!>}<!><!>
+fun <K> select(): K = <!TYPE_MISMATCH!>run <!TYPE_MISMATCH!>{ }<!><!>

 fun test() {
    val x: Int = select()
-    val t = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>select<!>()
+    val t = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>select<!>()
 }
@@ -3,10 +3,10 @@
 fun <T, R : Any> foo(body: (R?) -> T): T = fail()

 fun test1() {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>foo<!> {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> {
        true
    }
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>foo<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
        true
    }
 }
@@ -15,10 +15,10 @@ fun test1() {
 fun <T, R> bar(body: (R) -> T): T = fail()

 fun test2() {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>bar<!> {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> {
        true
    }
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>bar<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
        true
    }
 }
@@ -26,10 +26,10 @@ fun test2() {
 fun <T, R> baz(body: (List<R>) -> T): T = fail()

 fun test3() {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>baz<!> {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>baz<!> {
        true
    }
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>baz<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>baz<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
        true
    }
 }
@@ -37,10 +37,10 @@ fun test3() {
 fun <T, R : Any> brr(body: (List<R?>) -> T): T = fail()

 fun test4() {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>brr<!> {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>brr<!> {
        true
    }
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>brr<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>brr<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
        true
    }
 }
@@ -13,7 +13,7 @@ fun <T> id(t: T): T = t
 infix fun <T> Z.foo(a: A<T>): A<T> = a

 fun test(z: Z) {
-    z <!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}!>newA<!>()
+    z <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>()
    val a: A<Int> = id(z foo newA())
    val b: A<Int> = id(z.foo(newA()))
    use(a, b)
@@ -23,7 +23,7 @@ fun test(z: Z) {
 operator fun <T> Z.plus(a: A<T>): A<T> = a

 fun test1(z: Z) {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>id<!>(z <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>+<!> <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>newA<!>())
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!>(z <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>+<!> <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>())
    val a: A<Z> = z + newA()
    val b: A<Z> = z.plus(newA())
    val c: A<Z> = id(z + newA())
@@ -35,7 +35,7 @@ fun test1(z: Z) {
 operator fun <T> Z.compareTo(a: A<T>): Int { use(a); return 1 }

 fun test2(z: Z) {
-    val a: Boolean = id(z <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!><<!> <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>newA<!>())
+    val a: Boolean = id(z <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!><<!> <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>())
    val b: Boolean = id(z < newA<Z>())
    use(a, b)
 }
@@ -44,18 +44,18 @@ fun test2(z: Z) {
 fun Z.<!EXTENSION_SHADOWED_BY_MEMBER!>equals<!>(any: Any): Int { use(any); return 1 }

 fun test3(z: Z) {
-    z <!EQUALS_MISSING{NI}!>==<!> <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>newA<!>()
+    z <!EQUALS_MISSING!>==<!> <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>()
    z == newA<Z>()
-    id(z <!EQUALS_MISSING{NI}!>==<!> <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>newA<!>())
+    id(z <!EQUALS_MISSING!>==<!> <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>())
    id(z == newA<Z>())

-    id(z === <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>newA<!>())
+    id(z === <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>())
    id(z === newA<Z>())
 }

 //'in' operation
 fun test4(collection: Collection<A<*>>) {
-    id(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>newA<!>() in collection)
+    id(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>() in collection)
    id(newA<Int>() in collection)
 }

@@ -63,7 +63,7 @@ fun test4(collection: Collection<A<*>>) {
 fun <T> toBeOrNot(): Boolean = throw Exception()

 fun test5() {
-    if (<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>toBeOrNot<!>() && <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>toBeOrNot<!>()) {}
+    if (<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>toBeOrNot<!>() && <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>toBeOrNot<!>()) {}
    if (toBeOrNot<Int>() && toBeOrNot<Int>()) {}
 }

@@ -4,7 +4,7 @@ package noInformationForParameter
 import java.util.*

 fun test() {
-    val n = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>newList<!>()
+    val n = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newList<!>()

    val n1 : List<String> = newList()
 }
@@ -14,19 +14,19 @@ fun testAny() {

 fun testAnyCall() {
    callAny {
-        <!CANNOT_INFER_PARAMETER_TYPE!>error<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}!><!DEBUG_INFO_MISSING_UNRESOLVED{NI}!>error<!>()<!>
+        <!CANNOT_INFER_PARAMETER_TYPE!>error<!> -> <!DEBUG_INFO_MISSING_UNRESOLVED!>error<!>()
    }
 }

 fun testParam() {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>callParam<!> {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>callParam<!> {
        <!CANNOT_INFER_PARAMETER_TYPE!>param<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>param<!>
    }
 }

 fun testParamCall() {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>callParam<!> {
-        <!CANNOT_INFER_PARAMETER_TYPE!>param<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}!><!DEBUG_INFO_MISSING_UNRESOLVED{NI}!>param<!>()<!>
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>callParam<!> {
+        <!CANNOT_INFER_PARAMETER_TYPE!>param<!> -> <!DEBUG_INFO_MISSING_UNRESOLVED!>param<!>()
    }
 }

@@ -10,9 +10,9 @@ fun foo(action: (Int) -> Unit) {
 }

 fun test1() {
-    call({ <!CANNOT_INFER_PARAMETER_TYPE{NI}!>x<!> -> println(<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{NI}!>x<!>::class) }) // x inside the lambda is inferred to `Nothing`, the lambda is `(Nothing) -> Unit`.
+    call({ <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> println(<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!>::class) }) // x inside the lambda is inferred to `Nothing`, the lambda is `(Nothing) -> Unit`.
 }

 fun test2() {
-    ::foo.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>call<!>({ <!CANNOT_INFER_PARAMETER_TYPE{NI}!>x<!> -> println(<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{NI}!>x<!>::class) })
+    ::foo.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>call<!>({ <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> println(<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!>::class) })
 }
@@ -4,8 +4,8 @@ fun <K> select2(x: K, y: K): K = TODO()
 fun <K> select3(x: K, y: K, z: K): K = TODO()

 fun test2(f: ((String) -> Int)?) {
-    val a0: ((Int) -> Int)? = select2(<!TYPE_MISMATCH{OI}!>{ <!CANNOT_INFER_PARAMETER_TYPE{OI}!>it<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}!>it<!> }<!>, null)
-    val b0: ((Nothing) -> Unit)? = select2(<!TYPE_MISMATCH{OI}!>{ <!CANNOT_INFER_PARAMETER_TYPE{OI}!>it<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}!>it<!> }<!>, null)
+    val a0: ((Int) -> Int)? = select2({ it -> it }, null)
+    val b0: ((Nothing) -> Unit)? = select2({ it -> it }, null)

    select3({ it.length }, f, null)
 }
@@ -5,11 +5,11 @@ fun <I> id(arg: I): I = arg
 fun <S> select(vararg args: S): S = TODO()

 fun test() {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>id<!>(
-        <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>make<!>()
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!>(
+        <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>make<!>()
    )

    select(<!IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION!>make<!>(), null)

-    <!TYPE_INFERENCE_FAILED_ON_SPECIAL_CONSTRUCT{OI}!>if<!> (true) <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!><!IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION!>make<!>()<!> else TODO()
+    if (true) <!IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION!>make<!>() else TODO()
 }
@@ -6,8 +6,8 @@ fun <T> g (f: () -> List<T>) : T {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

 fun test() {
    //here possibly can be a cycle on constraints
-    val x = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>g<!> { Collections.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>emptyList<!>() }
+    val x = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>g<!> { Collections.<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>() }

    val y = g<Int> { Collections.emptyList() }
-    val z : List<Int> = g { Collections.<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>emptyList<!>() }
+    val z : List<Int> = g { Collections.emptyList() }
 }
@@ -28,6 +28,6 @@ fun chained2(arg: First) = run {
 }

 fun test(arg: First) {
-    chained1(arg).<!UNRESOLVED_REFERENCE{NI}!>first<!>()
-    chained2(arg).<!UNRESOLVED_REFERENCE{NI}!>first<!>()
+    chained1(arg).<!UNRESOLVED_REFERENCE!>first<!>()
+    chained2(arg).<!UNRESOLVED_REFERENCE!>first<!>()
 }
@@ -16,11 +16,11 @@ fun <S> intersect(vararg elements: S): S = TODO()
 fun intersectAfterSmartCast(arg: Base, arg2: Base) = intersect(
    run {
        if (arg !is One) throw Exception()
-        <!DEBUG_INFO_SMARTCAST{NI}!>arg<!>
+        <!DEBUG_INFO_SMARTCAST!>arg<!>
    },
    run {
        if (arg2 !is Two) throw Exception()
-        <!DEBUG_INFO_SMARTCAST{NI}!>arg2<!>
+        <!DEBUG_INFO_SMARTCAST!>arg2<!>
    }
 )

@@ -32,6 +32,6 @@ fun intersectArgWithSmartCastFromLambda(arg: One, arg2: Base) = argOrFn(arg) {
 }

 fun test() {
-    intersectAfterSmartCast(O1, O2).<!UNRESOLVED_REFERENCE{NI}!>base<!>()
-    intersectArgWithSmartCastFromLambda(O1, O2).<!UNRESOLVED_REFERENCE{NI}!>base<!>()
+    intersectAfterSmartCast(O1, O2).<!UNRESOLVED_REFERENCE!>base<!>()
+    intersectArgWithSmartCastFromLambda(O1, O2).<!UNRESOLVED_REFERENCE!>base<!>()
 }
@@ -17,5 +17,5 @@ fun smartCastAfterIntersection(a: One, b: Two) = run {
 }

 fun test(one: One, two: Two) {
-    smartCastAfterIntersection(one, two)<!UNNECESSARY_SAFE_CALL{NI}!>?.<!><!UNRESOLVED_REFERENCE{NI}!>base<!>()
+    smartCastAfterIntersection(one, two)<!UNNECESSARY_SAFE_CALL!>?.<!><!UNRESOLVED_REFERENCE!>base<!>()
 }
@@ -20,5 +20,5 @@ fun <S> intersectNoBound(vararg elements: S): S = TODO()
 fun some(a: One, b: Two, c: Three) = intersectNoBound(intersect(a, b), c)

 fun test(arg: Base, arg2: Base) {
-    some(O1, O2, O3).<!UNRESOLVED_REFERENCE{NI}!>base<!>()
+    some(O1, O2, O3).<!UNRESOLVED_REFERENCE!>base<!>()
 }
@@ -3,7 +3,7 @@
 fun foo() {
    fun fact(n: Int) = {
        if (n > 0) {
-            <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!DEBUG_INFO_MISSING_UNRESOLVED!>fact<!>(<!DEBUG_INFO_MISSING_UNRESOLVED!>n<!> <!DEBUG_INFO_MISSING_UNRESOLVED!>-<!> 1)<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>*<!> n
+            <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!DEBUG_INFO_MISSING_UNRESOLVED!>fact<!>(<!DEBUG_INFO_MISSING_UNRESOLVED!>n<!> <!DEBUG_INFO_MISSING_UNRESOLVED!>-<!> 1)<!> <!DEBUG_INFO_MISSING_UNRESOLVED!>*<!> n
        }
        else {
            1
@@ -2,8 +2,8 @@
 fun foo() {
    fun bar1() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!DEBUG_INFO_MISSING_UNRESOLVED!>bar1<!>()<!>

-    fun bar2() = 1 + <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!DEBUG_INFO_MISSING_UNRESOLVED{NI}!>bar2<!>()<!>
-    fun bar3() = id(<!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!DEBUG_INFO_MISSING_UNRESOLVED{NI}!>bar3<!>()<!>)
+    fun bar2() = 1 + <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!DEBUG_INFO_MISSING_UNRESOLVED!>bar2<!>()<!>
+    fun bar3() = id(<!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!DEBUG_INFO_MISSING_UNRESOLVED!>bar3<!>()<!>)
 }

 fun <T> id(x: T) = x
@@ -5,5 +5,5 @@ package d
 fun <T> asList(t: T) : List<T>? {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>

 fun main() {
-    val list : List<String> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>asList("")<!>
+    val list : List<String> = <!TYPE_MISMATCH, TYPE_MISMATCH!>asList("")<!>
 }
@@ -5,7 +5,7 @@ package n
 import checkSubtype

 fun main() {
-    val a = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>array<!>(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>array<!>())
+    val a = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>array<!>(<!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>array<!>())
    val a0 : Array<Array<Int>> = array(array())
    val a1 = array(array<Int>())
    checkSubtype<Array<Array<Int>>>(a1)
@@ -9,5 +9,5 @@ fun <A, B> Foo<A>.map(f: (A) -> B): Foo<B> = object : Foo<B> {}

 fun foo() {
    val l: Foo<String> = object : Foo<String> {}
-    val m: Foo<String> = l.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!>map { ppp -> <!CONSTANT_EXPECTED_TYPE_MISMATCH{NI}, CONSTANT_EXPECTED_TYPE_MISMATCH{NI}!>1<!> }<!>
+    val m: Foo<String> = l.map { ppp -> <!CONSTANT_EXPECTED_TYPE_MISMATCH, CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> }
 }
@@ -11,14 +11,14 @@ abstract class Buggy {
    }

    val anotherThree : Int
-        get() = <!TYPE_MISMATCH{NI}!>coll.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>find{ it > 3 }<!><!> // does not work here
+        get() = <!TYPE_MISMATCH!>coll.<!TYPE_MISMATCH!>find{ it > 3 }<!><!> // does not work here

    val yetAnotherThree : Int
-        get() = <!TYPE_MISMATCH{NI}!>coll.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>find({ v:Int -> v > 3 })<!><!> // neither here
+        get() = <!TYPE_MISMATCH!>coll.<!TYPE_MISMATCH!>find({ v:Int -> v > 3 })<!><!> // neither here

    val extendedGetter : Int
        get() {
-            return <!TYPE_MISMATCH{NI}!>coll.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>find{ it > 3 }<!><!>  // not even here!
+            return <!TYPE_MISMATCH!>coll.<!TYPE_MISMATCH!>find{ it > 3 }<!><!>  // not even here!
        }

 }
@@ -3,7 +3,7 @@
 package a

 fun main() {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>test<!> {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>test<!> {

    }
 }
@@ -8,5 +8,5 @@ fun <T> _arrayList(vararg values: T) : List<T> = throw Exception()
 class _Pair<A>(val a: A)

 fun test() {
-    _arrayList(_Pair(1))._sortBy <!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>{ it -> <!UNRESOLVED_REFERENCE!>xxx<!> }<!>
+    _arrayList(_Pair(1))._sortBy <!TYPE_MISMATCH, TYPE_MISMATCH!>{ it -> <!UNRESOLVED_REFERENCE!>xxx<!> }<!>
 }
@@ -7,7 +7,7 @@ fun <T> bar(a: T, b: Map<T, String>) = b.get(a)

 fun test(a: Int) {
    foo(a, null)
-    <!TYPE_INFERENCE_INCORPORATION_ERROR{OI}!>bar<!>(a, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    bar(a, <!NULL_FOR_NONNULL_TYPE!>null<!>)
 }
 fun test1(a: Int) {
    foo(a, throw Exception())
@@ -21,7 +21,7 @@ fun test() {

    doAction { bar(12) }

-    val u: Unit =  <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>bar(11)<!>
+    val u: Unit =  <!TYPE_MISMATCH, TYPE_MISMATCH!>bar(11)<!>
 }

 fun testWithoutInference(col: MutableCollection<Int>) {
@@ -11,5 +11,5 @@ fun <V, T : V?> G<T>.foo(vararg values: V2<V?>) = build()
 fun forReference(ref: Any?) {}

 fun test() {
-    forReference(G<Int?>::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, CANNOT_COMPLETE_RESOLVE{OI}!>foo<!>)
+    forReference(G<Int?>::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>foo<!>)
 }
@@ -6,5 +6,5 @@ fun foo(i: Long) {}
 fun bar(f: (Boolean) -> Unit) {}

 fun test() {
-    bar(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY{NI}, NONE_APPLICABLE{OI}!>foo<!>)
+    bar(::<!CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY!>foo<!>)
 }
@@ -16,5 +16,5 @@ fun acquireIntervals(): List<Interval> = TODO()

 fun main() {
    buildTree(acquireIntervals())
-        ?: <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!><!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}!>emptyList<!>()<!>
+        ?: <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()
 }
@@ -1,11 +1,10 @@
-
 import java.lang.Exception

 fun <K> id(arg: K): K = arg

 fun test() {
    id(<!UNRESOLVED_REFERENCE!>unresolved<!>)<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>
-    <!UNRESOLVED_REFERENCE!>unresolved<!>!!<!UNNECESSARY_NOT_NULL_ASSERTION{NI}!>!!<!>
+    <!UNRESOLVED_REFERENCE!>unresolved<!>!!<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>
    try {
        id(<!UNRESOLVED_REFERENCE!>unresolved<!>)
    } catch (e: Exception) {
@@ -1,13 +1,12 @@
-
 fun <K> id(arg: K): K = arg
 fun <M> materialize(): M = TODO()

 fun test(b: Boolean) {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>id<!>(if (b) {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!>(if (b) {
        id(<!UNRESOLVED_REFERENCE!>unresolved<!>)
    } else {
-        <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>id<!>(
-            <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>materialize<!>()
+        <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!>(
+            <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materialize<!>()
        )
    })
 }
@@ -15,6 +15,6 @@ fun <T, G> A<T>.foo(x: (T)-> G): G {

 fun main() {
    val a = A(1)
-    val t: String = <!TYPE_MISMATCH{NI}!>a.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}!>foo({p -> <!TYPE_MISMATCH!>p<!>})<!><!>
+    val t: String = <!TYPE_MISMATCH!>a.foo({p -> <!TYPE_MISMATCH!>p<!>})<!>
    checkSubtype<String>(t)
 }
@@ -9,4 +9,4 @@ fun <T, Q> List<T>.map1(f: (T)-> Q): List<T>? = tail!!.map1(f)

 fun <T, Q> List<T>.map2(f: (T)-> Q): List<T>? = tail.sure().map2(f)

-fun <T, Q> List<T>.map3(f: (T)-> Q): List<T>? = <!TYPE_MISMATCH{OI}!>tail<!>.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER{NI}!>sure<!><<!UPPER_BOUND_VIOLATED{OI}!>T<!>>().<!DEBUG_INFO_MISSING_UNRESOLVED{NI}, UNRESOLVED_REFERENCE_WRONG_RECEIVER{OI}!>map3<!>(f)
+fun <T, Q> List<T>.map3(f: (T)-> Q): List<T>? = tail.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>sure<!><T>().<!DEBUG_INFO_MISSING_UNRESOLVED!>map3<!>(f)
@@ -6,5 +6,5 @@ fun <T> fooT2() : (t : T) -> T {
 }

 fun test() {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>fooT2<!>()(1) // here 1 should not be marked with an error
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooT2<!>()(1) // here 1 should not be marked with an error
 }
@@ -12,7 +12,7 @@ fun <T> emptyList() : List<T>? = ArrayList<T>()
 fun foo() {
    // type arguments shouldn't be required
    val l : List<Int> = emptyList()!!
-    val l1 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>emptyList<!>()!!
+    val l1 = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()!!

    checkSubtype<List<Int>>(emptyList()!!)
    checkSubtype<List<Int>?>(emptyList())
@@ -6,11 +6,11 @@ fun <T, R> foo(a: A<T, R>) = a
 fun <T, R> bar(f: (T) -> R) = f

 fun test() {
-    <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>foo<!> <!TYPE_MISMATCH!>{ <!UNRESOLVED_REFERENCE!>it<!> }<!>
-    <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>foo<!> <!TYPE_MISMATCH!>{ <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!>}<!>
-    <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>foo<!> <!TYPE_MISMATCH!>{ x: Int -> x}<!>
+    foo <!TYPE_MISMATCH!>{ <!UNRESOLVED_REFERENCE!>it<!> }<!>
+    foo <!TYPE_MISMATCH!>{ <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!>}<!>
+    foo <!TYPE_MISMATCH!>{ x: Int -> x}<!>

-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>bar<!> { <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>it<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>+<!> 1 }
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>bar<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE{OI}, DEBUG_INFO_MISSING_UNRESOLVED{NI}!>+<!> 1}
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> { <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>it<!> <!DEBUG_INFO_MISSING_UNRESOLVED!>+<!> 1 }
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!> <!DEBUG_INFO_MISSING_UNRESOLVED!>+<!> 1}
    bar { x: Int -> x + 1}
 }
@@ -3,7 +3,7 @@ package aa
 fun <T, R> foo(block: (T)-> R) = block

 fun test1() {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>foo<!> {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> {
        <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->  // here we have 'cannot infer parameter type' error
        43
    }
@@ -7,6 +7,6 @@ fun test() {
    id2(<!UNRESOLVED_REFERENCE!>unresolved<!>, "foo")
    id2(<!UNRESOLVED_REFERENCE!>unresolved<!>, <!CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>)

-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>ret<!>("foo")
-    <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>ret<!>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>)
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>ret<!>("foo")
+    ret(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>42<!>)
 }
@@ -4,8 +4,8 @@ fun <R> foo (f: ()->R, r: MutableList<R>) = r.add(f())
 fun <R> bar (r: MutableList<R>, f: ()->R) = r.add(f())

 fun test() {
-    val a = <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>foo<!>({1}, arrayListOf("")) //no type inference error on 'arrayListOf'
-    val b = <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>bar<!>(arrayListOf(""), {1})
+    val a = foo({1}, arrayListOf("")) //no type inference error on 'arrayListOf'
+    val b = bar(arrayListOf(""), {1})
 }

 // from standard library
@@ -5,5 +5,5 @@ class X
 operator fun <T> X.component1(): T = TODO()

 fun test() {
-    val (y) = <!COMPONENT_FUNCTION_MISSING{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>X()<!>
+    val (y) = <!COMPONENT_FUNCTION_MISSING!>X()<!>
 }
@@ -3,6 +3,6 @@ class X
 operator fun <T> X.iterator(): Iterable<T> = TODO()

 fun test() {
-    for (i in <!ITERATOR_MISSING{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>X()<!>) {
+    for (i in <!ITERATOR_MISSING!>X()<!>) {
    }
 }
@@ -4,9 +4,9 @@ package typeConstructorMismatch
 import java.util.*

 fun test(set: Set<String>) {
-    <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>elemAndList<!>("2", <!TYPE_MISMATCH!>set<!>)
+    elemAndList("2", <!TYPE_MISMATCH!>set<!>)

-    "".<!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR{OI}!>elemAndListWithReceiver<!>("", <!TYPE_MISMATCH!>set<!>)
+    "".elemAndListWithReceiver("", <!TYPE_MISMATCH!>set<!>)
 }

 fun <R> elemAndList(r: R, t: List<R>): R = r
@@ -3,7 +3,7 @@ package typeInferenceExpectedTypeMismatch
 import java.util.*

 fun test() {
-    val s : Set<Int> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>newList()<!>
+    val s : Set<Int> = <!TYPE_MISMATCH!>newList()<!>
    use(s)
 }

@@ -25,16 +25,16 @@ fun <T, R> foo(o: Out<T>, i: In<R>): Two<T, R> = throw Exception("$o $i")
 fun test1(outA: Out<A>, inB: In<B>) {
    foo(outA, inB)

-    val b: Two<A, C> = <!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH{OI}, TYPE_MISMATCH{NI}!>foo(outA, inB)<!>
+    val b: Two<A, C> = <!TYPE_MISMATCH!>foo(outA, inB)<!>
    use(b)
 }

 fun <T> bar(o: Out<T>, i: In<T>): Two<T, T> = throw Exception("$o $i")

 fun test2(outA: Out<A>, inC: In<C>) {
-    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>bar<!>(outA, <!TYPE_MISMATCH{NI}!>inC<!>)
+    bar(outA, <!TYPE_MISMATCH!>inC<!>)

-    val b: Two<A, B> = <!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!><!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>bar<!>(outA, <!TYPE_MISMATCH{NI}!>inC<!>)<!>
+    val b: Two<A, B> = <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>bar(outA, <!TYPE_MISMATCH!>inC<!>)<!>
    use(b)
 }

@@ -5,7 +5,7 @@ interface A
 fun <T> emptyList(): List<T> = throw Exception()

 fun test1() {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>emptyList<!>()
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()
 }

 //--------------
@@ -13,7 +13,7 @@ fun test1() {
 fun <T: A> emptyListOfA(): List<T> = throw Exception()

 fun test2() {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>emptyListOfA<!>()
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyListOfA<!>()
 }

 //--------------
@@ -21,7 +21,7 @@ fun test2() {
 fun <T: A, R: T> emptyStrangeMap(): Map<T, R> = throw Exception()

 fun test3() {
-    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER{NI}, TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER{OI}!>emptyStrangeMap<!>()
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyStrangeMap<!>()
 }

 //--------------
@@ -14,7 +14,7 @@ fun <T> foo(in1: In<T>, in2: In<T>): T = throw Exception("$in1 $in2")

 fun test(inA: In<A>, inB: In<B>, inC: In<C>) {

-    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS{OI}!>foo<!>(inA, inB)
+    foo(inA, inB)

    val r = foo(inA, inC)
    checkSubtype<C>(r)
@@ -15,7 +15,7 @@ fun <T> checkItIsExactlyAny(t: T, l: MutableList<T>) {}
 fun <V : U, U> baz(v: V, u: MutableSet<U>) = u

 fun test(a: Any, s: MutableSet<String>) {
-    <!TYPE_INFERENCE_UPPER_BOUND_VIOLATED{OI}!>baz<!>(a, <!TYPE_MISMATCH{NI}, TYPE_MISMATCH{NI}!>s<!>)
+    baz(a, <!TYPE_MISMATCH, TYPE_MISMATCH!>s<!>)
 }

 //from standard library