Add diagnostics to test data from NI

2017-11-22 08:50:30 +03:00
parent a71238bf94
commit 8757298994
480 changed files with 1136 additions and 1120 deletions
@@ -4,7 +4,7 @@ fun <T: Any> fooT22() : T? {
 }

 fun foo1() {
-    <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooT22<!>()
+    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooT22<!>()
 }

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

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

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

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

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

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

 fun getAnswer() = 42

@@ -5,13 +5,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!>bar<!>(a)
-    <!TYPE_INFERENCE_CANNOT_CAPTURE_TYPES!>bar<!>(a)
+    val r: Array<in Int?> = <!OI;TYPE_INFERENCE_CANNOT_CAPTURE_TYPES!>bar<!>(<!NI;TYPE_MISMATCH!>a<!>)
+    <!OI;TYPE_INFERENCE_CANNOT_CAPTURE_TYPES!>bar<!>(<!NI;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!>foo<!>(a)
-    <!TYPE_INFERENCE_CANNOT_CAPTURE_TYPES!>foo<!>(a)
+    val r: Array<out Array<in Int?>> = <!OI;TYPE_INFERENCE_CANNOT_CAPTURE_TYPES!>foo<!>(<!NI;TYPE_MISMATCH!>a<!>)
+    <!OI;TYPE_INFERENCE_CANNOT_CAPTURE_TYPES!>foo<!>(<!NI;TYPE_MISMATCH!>a<!>)
 }
@@ -5,15 +5,15 @@
 fun <T: Any> bar(a: Array<T>): Array<T?> =  null!!

 fun test1(a: Array<out Int>) {
-    val r: Array<out Int?> = bar(a)
-    val t = bar(a)
-    t checkType { _<Array<out Int?>>() }
+    val r: Array<out Int?> = <!NI;TYPE_MISMATCH!><!NI;UNSUPPORTED!>bar<!>(a)<!>
+    val t = <!NI;UNSUPPORTED!>bar<!>(a)
+    <!NI;UNSUPPORTED!>t<!> checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;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?>> = foo(a)
-    val t = foo(a)
-    t checkType { _<Array<out Array<out Int?>>>() }
+    val r: Array<out Array<out Int?>> = <!NI;TYPE_MISMATCH!><!NI;UNSUPPORTED!>foo<!>(a)<!>
+    val t = <!NI;UNSUPPORTED!>foo<!>(a)
+    <!NI;UNSUPPORTED!>t<!> checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Array<out Array<out Int?>>>() }
 }
@@ -4,11 +4,11 @@
 fun <T : Any> Array<T?>.filterNotNull(): List<T> = throw Exception()

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

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

 fun test(array: Array<Array<out Int>>) {
-    <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>foo<!>(array)
+    <!OI;TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>foo<!>(array)

-    val f: Array<out Array<out Int>> = <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>foo<!>(<!TYPE_MISMATCH!>array<!>)
+    val f: Array<out Array<out Int>> = <!OI;TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>foo<!>(<!OI;TYPE_MISMATCH!>array<!>)
 }
@@ -5,6 +5,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(Int; Any?)!>foo(a1, a2)<!>
+    val c: Int = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>foo(a1, a2)<!>

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

 fun test(array: Array<out Int>) {
    array.foo()
-    <!TYPE_MISMATCH!>array<!>.foo<<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>out<!> Int>()
+    <!OI;TYPE_MISMATCH!>array<!>.<!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>foo<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>out<!> Int>()
 }
@@ -11,8 +11,8 @@ 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!>baz<!>(bOut)
-    baz<Number>(<!TYPE_MISMATCH!>bOut<!>)
+    <!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>baz<!>(bOut)
+    baz<Number>(<!OI;TYPE_MISMATCH!>bOut<!>)

    baz(bOut2)
    baz<Number>(bOut2)
@@ -12,6 +12,6 @@ fun <T: Any> joinT(<!UNUSED_PARAMETER!>x<!>: Comparable<*>, <!UNUSED_PARAMETER!>
 }

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

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

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

 fun <T> list(value: T) : ArrayList<T> {
@@ -3,7 +3,7 @@ package c

 import java.util.ArrayList

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

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

@@ -9,8 +9,8 @@ inline fun <reified T> foo2(f: (T) -> Unit): Foo<T> = Foo()

 fun test1() {
    val f1: Foo<out Int> = foo1 { it checkType { _<Int>() } }
-    val f2: Foo<in Nothing> = foo1 { it <!UNREACHABLE_CODE!>checkType { _<Nothing>() }<!> }
+    val f2: Foo<in Nothing> = foo1 { it <!UNREACHABLE_CODE!>checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Nothing>() }<!> }

    val f3: Foo<out Int> = foo2 { it checkType { _<Int>() } }
-    val f4: Foo<in Nothing> = <!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>foo2<!> { it <!UNREACHABLE_CODE!>checkType { _<Nothing>() }<!> }
+    val f4: Foo<in Nothing> = <!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>foo2<!> { it <!UNREACHABLE_CODE!>checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Nothing>() }<!> }
 }
@@ -16,6 +16,6 @@ class C<X, Z, Y : X>

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

 fun test() {
-    <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>())
+    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>())
 }
@@ -18,8 +18,8 @@ fun test(out: Out<Int>, i: In<Int>, inv: A<Int>) {
    r checkType { _<Int>() }

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

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

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

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

-    val a3 : MyList<out Any> = getMyListToReadFrom(int)
+    val a3 : MyList<out Any> = <!NI;TYPE_MISMATCH!>getMyListToReadFrom(int)<!>

    val a4 : MyList<in Int> = getMyList(any)

    val a5 : MyList<in Int> = getMyListToWriteTo(any)


-    val a6 : MyList<in Any> = <!TYPE_MISMATCH!>getMyList<Int>(int)<!>
+    val a6 : MyList<in Any> = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>getMyList<Int>(int)<!>
    val a7 : MyList<in Any> = getMyList(int)

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

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

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

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

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

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

    readFromMyList(getMyListToReadFrom(int), any)
@@ -54,14 +54,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!>writeToMyList<!>(getMyList(int), any)
+    <!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>writeToMyList<!>(getMyList(int), any)

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

    readFromMyList(getMyListToWriteTo(any), any)

-    <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>writeToMyList<!>(getMyListToReadFrom(any), any)
+    <!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>writeToMyList<!>(getMyListToReadFrom(any), any)

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

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

-val test = <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo2<!>().<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>plus<!>("") as String
+val test = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo2<!>().<!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>plus<!>("") <!NI;USELESS_CAST!>as String<!>

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

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

-val asA = <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>().<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>fooA<!>() as A
+val asA = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>().<!NI;UNRESOLVED_REFERENCE, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>fooA<!>() as A

-val receiverParenthesized = (<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>()).<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>fooA<!>() as A
-val no2A = A().<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooA<!>().<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>fooA<!>() as A
+val receiverParenthesized = (<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>()).<!NI;UNRESOLVED_REFERENCE, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>fooA<!>() as A
+val no2A = A().<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>fooA<!>().<!NI;UNRESOLVED_REFERENCE, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>fooA<!>() as A

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

 val asString = foo() as String

-val viaId = <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!>(<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>()) as String
+val viaId = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>id<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>()) as String

 val insideId = id(foo() as String)

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

 val safeAs = foo() as? String

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

-    val <!UNUSED_VARIABLE!>y<!> = <!TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>foo<!>() as Int
+    val <!UNUSED_VARIABLE!>y<!> = <!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>foo<!>() as Int

-    val <!UNUSED_VARIABLE!>y2<!> = foo() as D
+    val <!UNUSED_VARIABLE!>y2<!> = foo() <!NI;UNCHECKED_CAST!>as D<!>
 }
@@ -31,7 +31,7 @@ val xCastExplicitType = Test().findViewById<X>(0) as X
 val xSafeCastExplicitType = Test().findViewById<X>(0) <!USELESS_CAST!>as? X<!>

 val yExplicit: Y<String> = Test().findViewById(0)
-val yCast = Test().findViewById(0) as Y<String>
+val yCast = Test().findViewById(0) <!NI;UNCHECKED_CAST!>as Y<String><!>


 class TestChild : Test() {
@@ -39,7 +39,7 @@ class TestChild : Test() {
    val xCast = findViewById(0) as X

    val yExplicit: Y<String> = findViewById(0)
-    val yCast = findViewById(0) as Y<String>
+    val yCast = findViewById(0) <!NI;UNCHECKED_CAST!>as Y<String><!>
 }

 fun test(t: Test) {
@@ -47,7 +47,7 @@ fun test(t: Test) {
    val xCast = t.findViewById(0) as X

    val yExplicit: Y<String> = t.findViewById(0)
-    val yCast = t.findViewById(0) as Y<String>
+    val yCast = t.findViewById(0) <!NI;UNCHECKED_CAST!>as Y<String><!>
 }

 fun test2(t: Test?) {
@@ -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!>foo<!>({ it + 1 }, { it.length }, "")
+fun test() = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>({ it + 1 }, { it.length }, "")
@@ -11,5 +11,5 @@ fun test() {
    val q = foo(fun Int.() {}, emptyList()) //type inference no information for parameter error
    checkSubtype<Int>(q)

-    <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>({}, <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>())
+    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>({}, <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>())
 }
@@ -23,7 +23,7 @@ fun test(s: SelectorFor<State>): Double {
    d checkType { _<AbstractSelector<State, Unit>>() }

    val e = s { return p1 }
-    e checkType { _<AbstractSelector<State, Nothing>>() }
+    e checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><AbstractSelector<State, Nothing>>() }

-    <!UNREACHABLE_CODE!>return<!> null!!
+    <!OI;UNREACHABLE_CODE!>return<!> null!!
 }
@@ -13,5 +13,5 @@ fun test(s: String): String {
    a checkType { _<String>() }

    <!UNREACHABLE_CODE!>val b =<!> TestClass { return s }
-    <!UNREACHABLE_CODE!>b checkType { _<Nothing>() }<!>
+    <!UNREACHABLE_CODE!>b checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Nothing>() }<!>
 }
@@ -11,5 +11,5 @@ fun test(s: String): String {
    a checkType { _<TestClass>() }

    <!UNREACHABLE_CODE!>val b =<!> TestClass { return s }
-    <!UNREACHABLE_CODE!>b checkType { _<Nothing>() }<!>
+    <!UNREACHABLE_CODE!>b checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Nothing>() }<!>
 }
@@ -8,7 +8,7 @@ class TestClass {

 fun <T> test(value: T, test: TestClass): T {
    <!UNREACHABLE_CODE!>val x =<!> test { return value }
-    <!UNREACHABLE_CODE!>x checkType { _<Nothing>() }<!>
+    <!UNREACHABLE_CODE!>x checkType { <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Nothing>() }<!>

    <!UNREACHABLE_CODE!>return value<!>
 }
@@ -1,10 +1,11 @@
+// !WITH_NEW_INFERENCE
 //KT-1293 Kompiler doesn't show error when element of Array<Int?> is assigned to Int

 package kt1293

 fun main(args : Array<String>) {
    val intArray = arrayOfNulls<Int>(10)
-    val <!UNUSED_VARIABLE!>i<!> : Int = <!TYPE_MISMATCH!>intArray[0]<!>
+    val <!UNUSED_VARIABLE!>i<!> : Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>intArray[0]<!>
    requiresInt(<!TYPE_MISMATCH!>intArray[0]<!>)
 }

@@ -4,46 +4,46 @@
 fun <T, R : Any> foo(body: (R?) -> T): T = fail()

 fun test1() {
-    <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> {
-        true
-    }
-    <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
-        true
+    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> {
+        <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!>
    }
+    <!NI;UNREACHABLE_CODE!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> { <!OI;CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
+        <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!>
+    }<!>
 }


 fun <T, R> bar(body: (R) -> T): T = fail()

 fun test2() {
-    <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> {
-        true
-    }
-    <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
-        true
+    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> {
+        <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!>
    }
+    <!NI;UNREACHABLE_CODE!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> { <!OI;CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
+        <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!>
+    }<!>
 }

 fun <T, R> baz(body: (List<R>) -> T): T = fail()

 fun test3() {
-    <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>baz<!> {
-        true
-    }
-    <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>baz<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
-        true
+    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>baz<!> {
+        <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!>
    }
+    <!NI;UNREACHABLE_CODE!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>baz<!> { <!OI;CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
+        <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!>
+    }<!>
 }

 fun <T, R : Any> brr(body: (List<R?>) -> T): T = fail()

 fun test4() {
-    <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>brr<!> {
-        true
-    }
-    <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>brr<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
-        true
+    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>brr<!> {
+        <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!>
    }
+    <!NI;UNREACHABLE_CODE!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>brr<!> { <!OI;CANNOT_INFER_PARAMETER_TYPE!>x<!> ->
+        <!NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>true<!>
+    }<!>
 }

 fun fail(): Nothing = throw Exception()
@@ -6,5 +6,5 @@ val test2f: suspend Any.() -> Unit = fun Any.() {}

 // This is a bug in the old inference and should be fixed in new inference
 // see "Fix anonymous function literals handling in type checker" for more deatils
-val test3f: suspend Any.(Int) -> Int = <!TYPE_MISMATCH!>fun (k: Int) = k + 1<!>
-val test4f: SuspendFn = <!TYPE_MISMATCH!>fun Any.() {}<!>
+val test3f: suspend Any.(Int) -> Int = <!OI;TYPE_MISMATCH!>fun (k: Int) = k + 1<!>
+val test4f: SuspendFn = <!OI;TYPE_MISMATCH!>fun Any.() {}<!>
@@ -14,7 +14,7 @@ fun <T> id(t: T): T = t
 infix fun <T> Z.foo(a: A<T>): A<T> = a

 fun test(z: Z) {
-    z <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>()
+    z <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> <!OI;TYPE_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)
@@ -24,19 +24,19 @@ fun test(z: Z) {
 operator fun <T> Z.plus(a: A<T>): A<T> = a

 fun test1(z: Z) {
-    id(z <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>+<!> <!TYPE_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())
-    val d: A<Z> = id(z.plus(newA()))
-    use(a, b, c, d)
+    id(z <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>+<!> <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>())
+    <!NI;UNREACHABLE_CODE!>val a: A<Z> = z + newA()<!>
+    <!NI;UNREACHABLE_CODE!>val b: A<Z> = z.plus(newA())<!>
+    <!NI;UNREACHABLE_CODE!>val c: A<Z> = id(z + newA())<!>
+    <!NI;UNREACHABLE_CODE!>val d: A<Z> = id(z.plus(newA()))<!>
+    <!NI;UNREACHABLE_CODE!>use(a, b, c, d)<!>
 }

 //comparison operation
 operator fun <T> Z.compareTo(a: A<T>): Int { use(a); return 1 }

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

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

-    id(z === <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>())
+    id(z === <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newA<!>())
    id(z === newA<Z>())
 }

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

 //boolean operations
 fun <T> toBeOrNot(): Boolean = throw Exception()

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

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

 fun test() {
-    val <!UNUSED_VARIABLE!>n<!> = <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newList<!>()
+    val <!UNUSED_VARIABLE!>n<!> = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>newList<!>()

    val <!UNUSED_VARIABLE!>n1<!> : List<String> = newList()
 }
@@ -7,8 +7,8 @@ fun <T> g (<!UNUSED_PARAMETER!>f<!>: () -> List<T>) : T {<!NO_RETURN_IN_FUNCTION

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

-    val <!UNUSED_VARIABLE!>y<!> = g<Int> { Collections.emptyList() }
-    val <!UNUSED_VARIABLE!>z<!> : List<Int> = g { Collections.<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>() }
+    <!NI;UNREACHABLE_CODE!>val <!OI;UNUSED_VARIABLE!>y<!> = g<Int> { Collections.emptyList() }<!>
+    <!NI;UNREACHABLE_CODE!>val <!OI;UNUSED_VARIABLE!>z<!> : List<Int> = g { Collections.<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>() }<!>
 }
@@ -3,7 +3,7 @@
 fun foo() {
    fun fact(n: Int) = {
        if (n > 0) {
-            <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>fact(n - 1)<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>*<!> n
+            <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!NI;DEBUG_INFO_MISSING_UNRESOLVED!>fact<!>(<!NI;DEBUG_INFO_MISSING_UNRESOLVED!>n<!> <!NI;DEBUG_INFO_MISSING_UNRESOLVED!>-<!> 1)<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>*<!> n
        }
        else {
            1
@@ -1,4 +1,4 @@
 // !WITH_NEW_INFERENCE
 fun foo() {
-    fun bar() = (fun() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>bar()<!>)
+    fun bar() = (fun() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!NI;DEBUG_INFO_MISSING_UNRESOLVED!>bar<!>()<!>)
 }
@@ -1,6 +1,6 @@
 // !WITH_NEW_INFERENCE
 fun foo() {
    fun bar() = {
-        <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>bar()<!>
+        <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!NI;DEBUG_INFO_MISSING_UNRESOLVED!>bar<!>()<!>
    }
 }
@@ -1,9 +1,9 @@
 // !WITH_NEW_INFERENCE
 fun foo() {
-    fun bar1() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>bar1()<!>
+    fun bar1() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!NI;DEBUG_INFO_MISSING_UNRESOLVED!>bar1<!>()<!>

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

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

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

 fun main(args: Array<String>) {
-    val <!UNUSED_VARIABLE!>a<!> = <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>array<!>(<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>array<!>())
+    val <!UNUSED_VARIABLE!>a<!> = <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>array<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>array<!>())
    val <!UNUSED_VARIABLE!>a0<!> : Array<Array<Int>> = array(array())
    val a1 = array(array<Int>())
    checkSubtype<Array<Array<Int>>>(a1)
@@ -10,5 +10,5 @@ fun <A, B> Foo<A>.map(<!UNUSED_PARAMETER!>f<!>: (A) -> B): Foo<B> = object : Foo

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

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

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

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

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

 fun main(args: Array<String>) {
-    <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>test<!> {
+    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>test<!> {

    }
 }
@@ -8,7 +8,7 @@ fun <T> bar(a: T, b: Map<T, String>) = b.get(a)

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

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

 fun testWithoutInference(col: MutableCollection<Int>) {
    
    doAction { col.add(2) }
    
-    val <!UNUSED_VARIABLE!>u<!>: Unit = <!TYPE_MISMATCH!>col.add(2)<!>
+    val <!UNUSED_VARIABLE!>u<!>: Unit = <!TYPE_MISMATCH!>col.<!NI;TYPE_MISMATCH!>add(2)<!><!>
 }
@@ -13,7 +13,7 @@ fun <T, G> A<T>.foo(x: (T)-> G): G {
 }

 fun main(args: Array<String>) {
-    val a = A(1)
-    val t: String = a.<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>foo({p -> <!TYPE_MISMATCH!>p<!>})<!>
+    val <!NI;UNUSED_VARIABLE!>a<!> = A(1)
+    val t: String = a.<!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!><!NI;UNRESOLVED_REFERENCE!>foo<!>({p -> <!OI;TYPE_MISMATCH!>p<!>})<!>
    checkSubtype<String>(t)
 }
@@ -10,4 +10,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!>tail<!>.sure<<!UPPER_BOUND_VIOLATED!>T<!>>().<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>map3<!>(f)
+fun <T, Q> List<T>.map3(f: (T)-> Q): List<T>? = <!NI;TYPE_MISMATCH!><!OI;TYPE_MISMATCH!>tail<!>.<!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>sure<!><<!OI;UPPER_BOUND_VIOLATED!>T<!>>().<!NI;TYPE_MISMATCH!><!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, OI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>map3<!>(f)<!><!>
@@ -7,5 +7,5 @@ fun <T> fooT2() : (t : T) -> T {
 }

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

-    checkSubtype<List<Int>>(emptyList()!!)
-    checkSubtype<List<Int>?>(emptyList())
+    <!NI;UNREACHABLE_CODE!>checkSubtype<List<Int>>(emptyList()!!)<!>
+    <!NI;UNREACHABLE_CODE!>checkSubtype<List<Int>?>(emptyList())<!>

-    doWithList(emptyList()!!)
+    <!NI;UNREACHABLE_CODE!>doWithList(emptyList()!!)<!>
 }

 fun doWithList(list: List<Int>) = list
@@ -7,11 +7,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!>foo<!> <!TYPE_MISMATCH!>{ <!UNRESOLVED_REFERENCE!>it<!> }<!>
-    <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>foo<!> <!TYPE_MISMATCH!>{ <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!>}<!>
-    <!TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>foo<!> <!TYPE_MISMATCH!>{ x: Int -> x}<!>
+    <!OI;TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>foo<!> <!TYPE_MISMATCH!>{ <!UNRESOLVED_REFERENCE!>it<!> }<!>
+    <!OI;TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>foo<!> <!TYPE_MISMATCH!>{ <!OI;CANNOT_INFER_PARAMETER_TYPE!>x<!> -> <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!>}<!>
+    <!OI;TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>foo<!> <!TYPE_MISMATCH!>{ x: Int -> x}<!>

-    <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> { <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>it<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> 1 }
-    <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> { <!CANNOT_INFER_PARAMETER_TYPE!>x<!> -> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> 1}
+    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> { <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>it<!> <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> 1 }
+    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!> { <!OI;CANNOT_INFER_PARAMETER_TYPE!>x<!> -> <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>x<!> <!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> 1}
    bar { x: Int -> x + 1}
 }
@@ -4,8 +4,8 @@ package aa
 fun <T, R> foo(block: (T)-> R) = block

 fun test1() {
-    <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> {
-        <!CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>x<!> ->  // here we have 'cannot infer parameter type' error
+    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!> {
+        <!OI;CANNOT_INFER_PARAMETER_TYPE, UNUSED_ANONYMOUS_PARAMETER!>x<!> ->  // here we have 'cannot infer parameter type' error
        43
    }
 }
@@ -5,8 +5,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 <!UNUSED_VARIABLE!>a<!> = <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>foo<!>({1}, arrayListOf("")) //no type inference error on 'arrayListOf'
-    val <!UNUSED_VARIABLE!>b<!> = <!TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>bar<!>(arrayListOf(""), {1})
+    val <!UNUSED_VARIABLE!>a<!> = <!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>foo<!>({1}, arrayListOf("")) //no type inference error on 'arrayListOf'
+    val <!UNUSED_VARIABLE!>b<!> = <!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>bar<!>(arrayListOf(""), {1})
 }

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

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

 fun test() {
-    for (i in <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>X()<!>) {
+    for (i in <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>X()<!>) {
    }
 }
@@ -13,7 +13,7 @@ fun test(f: Runnable.(Int) -> Unit, runnable: Runnable) {

 fun Int.test(f: String.(Int) -> Unit) {
    f("", 0)
-    f(""<!NO_VALUE_FOR_PARAMETER!>)<!>
+    <!NI;DEBUG_INFO_MISSING_UNRESOLVED!><!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>f<!>(""<!OI;NO_VALUE_FOR_PARAMETER!>)<!><!>
    with("") {
        f(0)
        f(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>0.0<!>)
@@ -5,9 +5,9 @@ package typeConstructorMismatch
 import java.util.*

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

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

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

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

@@ -26,16 +26,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!>foo(outA, inB)<!>
+    val b: Two<A, C> = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_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!>bar<!>(outA, inC)
+    <!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>bar<!>(outA, <!NI;TYPE_MISMATCH!>inC<!>)

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

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

 fun test1() {
-    <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()
+    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyList<!>()
 }

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

 fun test2() {
-    <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyListOfA<!>()
+    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyListOfA<!>()
 }

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

 fun test3() {
-    <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyStrangeMap<!>()
+    <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>emptyStrangeMap<!>()
 }

 //--------------
@@ -13,7 +13,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!>foo<!>(inA, inB)
+    <!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>foo<!>(inA, inB)

    val r = foo(inA, inC)
    checkSubtype<C>(r)
@@ -8,5 +8,5 @@ class Client<T, X: Base<T>>(<!UNUSED_PARAMETER!>x<!>: X)

 fun test() {
    val c = Client(StringBase()) // Type inference fails here for T.
-    val <!UNUSED_VARIABLE!>i<!> : Int = <!TYPE_MISMATCH!>c<!>
+    val <!UNUSED_VARIABLE!>i<!> : Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>c<!>
 }
@@ -16,7 +16,7 @@ fun <T> checkItIsExactlyAny(<!UNUSED_PARAMETER!>t<!>: T, <!UNUSED_PARAMETER!>l<!
 fun <V : U, U> baz(<!UNUSED_PARAMETER!>v<!>: V, u: MutableSet<U>) = u

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

 //from standard library