[NI] Avoid constraints from expected type for effectively empty system

Expression will be checked against expected type later. Theoretically, this is not very good, but it aligns with the old inference, plus it helps avoiding multiple type mismatch diagnostics.
2019-04-17 03:04:58 +03:00
parent 5dea14f4ce
commit bcc8802014
87 changed files with 130 additions and 125 deletions
@@ -148,6 +148,11 @@ class KotlinCallCompleter(
        if (returnType == null) return
        if (expectedType == null || TypeUtils.noExpectedType(expectedType)) return

+        // This is needed to avoid multiple mismatch errors as we type check resulting type against expected one later
+        // Plus, it helps with IDE-tests where it's important to have particular diagnostics.
+        // Note that it aligns with the old inference, see CallCompleter.completeResolvedCallAndArguments
+        if (csBuilder.currentStorage().notFixedTypeVariables.isEmpty()) return
+
        // We don't add expected type constraint for constant expression like "1 + 1" because of type coercion for numbers:
        // val a: Long = 1 + 1, note that result type of "1 + 1" will be Int and adding constraint with Long will produce type mismatch
        if (!resolutionCallbacks.isCompileTimeConstant(resolvedCall, expectedType)) {
@@ -13,7 +13,7 @@ fun text() {
    bar2 {<!TYPE_MISMATCH!><!>}
    bar2 {1}
    bar2 {<!UNRESOLVED_REFERENCE!>it<!>}
-    bar2 <!NI;TYPE_MISMATCH!>{<!OI;CANNOT_INFER_PARAMETER_TYPE, OI;EXPECTED_PARAMETERS_NUMBER_MISMATCH!>it<!> -> <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>it<!>}<!>
+    bar2 <!NI;TYPE_MISMATCH!>{<!OI;CANNOT_INFER_PARAMETER_TYPE, OI;EXPECTED_PARAMETERS_NUMBER_MISMATCH!>it<!> -> <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>it<!>}<!>
 }

 fun bar(<!UNUSED_PARAMETER!>f<!> :  (Int, Int) -> Int) {}
@@ -10,7 +10,7 @@ fun test() : Int {
 }

 class A() {
-    val x : Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>foo1(<!TOO_MANY_ARGUMENTS, UNRESOLVED_REFERENCE!>xx<!>)<!>
+    val x : Int = <!TYPE_MISMATCH!>foo1(<!TOO_MANY_ARGUMENTS, UNRESOLVED_REFERENCE!>xx<!>)<!>
 }

 fun foo1() {}
@@ -26,7 +26,7 @@ fun f(): Unit {
    <!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>x<!> in 1..2

    val y : Boolean? = true
-    <!UNUSED_EXPRESSION!>false || <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!><!>
-    <!UNUSED_EXPRESSION!><!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!> && true<!>
-    <!UNUSED_EXPRESSION!><!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!> && <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!><!>
+    <!UNUSED_EXPRESSION!>false || <!TYPE_MISMATCH!>y<!><!>
+    <!UNUSED_EXPRESSION!><!TYPE_MISMATCH!>y<!> && true<!>
+    <!UNUSED_EXPRESSION!><!TYPE_MISMATCH!>y<!> && <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!><!>
 }
@@ -1,14 +1,14 @@
 // !WITH_NEW_INFERENCE
 val x = ""

-fun bar(x : Int = <!TYPE_MISMATCH!>""<!>, y : Int = x, <!UNUSED_PARAMETER!>z<!> : String = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!>) {
+fun bar(x : Int = <!TYPE_MISMATCH!>""<!>, y : Int = x, <!UNUSED_PARAMETER!>z<!> : String = <!TYPE_MISMATCH!>y<!>) {

 }

 // KT-371 Resolve default parameters for constructors

 class A(x : Int = <!UNINITIALIZED_PARAMETER!>y<!>, y : Int = x) { // None of the references is resolved, no types checked
-    fun foo(<!UNUSED_PARAMETER!>bool<!>: Boolean, a: Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH, UNINITIALIZED_PARAMETER!>b<!>, b: String = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>a<!>) {}
+    fun foo(<!UNUSED_PARAMETER!>bool<!>: Boolean, a: Int = <!TYPE_MISMATCH, UNINITIALIZED_PARAMETER!>b<!>, b: String = <!TYPE_MISMATCH!>a<!>) {}
 }

 val z = 3
@@ -9,7 +9,7 @@ enum class Color {

 class MyColor(val x: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>, y: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>) : Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> {

-    var z: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> = <!TYPE_MISMATCH!>Color.<!NI;TYPE_MISMATCH!>RED<!><!>
+    var z: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> = <!TYPE_MISMATCH!>Color.RED<!>
    set(arg: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>) { z = arg }

    fun foo(arg: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>): Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> = arg
@@ -17,7 +17,7 @@ class MyColor(val x: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>, y: Color.<!ENUM_ENTRY_A
    fun bar(): Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> {
        class Local : Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>
        fun local(arg: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>): Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> = arg
-        val temp: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> = <!TYPE_MISMATCH!>Color.<!NI;TYPE_MISMATCH!>RED<!><!>
+        val temp: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> = <!TYPE_MISMATCH!>Color.RED<!>
        temp <!USELESS_CAST!>as? Color.<!ENUM_ENTRY_AS_TYPE!>RED<!><!>
        if (<!USELESS_IS_CHECK!>temp is <!IS_ENUM_ENTRY!>Color.<!ENUM_ENTRY_AS_TYPE!>RED<!><!><!>) {
        return temp <!USELESS_CAST!>as Color.<!ENUM_ENTRY_AS_TYPE!>RED<!><!>
@@ -26,7 +26,7 @@ class MyColor(val x: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>, y: Color.<!ENUM_ENTRY_A
        if (<!USELESS_IS_CHECK!>obj is <!IS_ENUM_ENTRY!>Color.<!ENUM_ENTRY_AS_TYPE!>RED<!><!><!>) {
        return obj
    }
-        return <!TYPE_MISMATCH!>Color.<!NI;TYPE_MISMATCH!>RED<!><!>
+        return <!TYPE_MISMATCH!>Color.RED<!>
    }
 }

@@ -45,7 +45,7 @@ fun intFunctionLiteral(): Int = <!TYPE_MISMATCH_DUE_TO_EQUALS_LAMBDA_IN_FUN!>{ 1
 fun blockReturnUnitMismatch() : Int {<!RETURN_TYPE_MISMATCH!>return<!>}
 fun blockReturnValueTypeMismatch() : Int {return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>3.4<!>}
 fun blockReturnValueTypeMatch() : Int {return 1}
-fun blockReturnValueTypeMismatchUnit() : Int {return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>Unit<!>}
+fun blockReturnValueTypeMismatchUnit() : Int {return <!TYPE_MISMATCH!>Unit<!>}

 fun blockAndAndMismatch() : Int {
    <!UNUSED_EXPRESSION!>true && false<!>
@@ -20,7 +20,7 @@ abstract class Foo<T>() {
 package foobar.a
    import java.util.*

-    val b : List<Int>? = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>a<!>
+    val b : List<Int>? = <!TYPE_MISMATCH!>a<!>
    val b1 : <!UNRESOLVED_REFERENCE!>util<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>List<!><Int>? = a

 // FILE: b.kt
@@ -3,5 +3,5 @@ fun Int.gg() = null

 fun ff() {
    val a: Int = 1
-    val <!UNUSED_VARIABLE!>b<!>: Int = <!TYPE_MISMATCH!>a<!UNNECESSARY_SAFE_CALL!>?.<!><!NI;TYPE_MISMATCH!>gg()<!><!>
+    val <!UNUSED_VARIABLE!>b<!>: Int = <!TYPE_MISMATCH!>a<!UNNECESSARY_SAFE_CALL!>?.<!>gg()<!>
 }
@@ -8,14 +8,14 @@ abstract class Producer<out T> {}
 abstract class Usual<T> {}

 fun foo(c: Consumer<Int>, p: Producer<Int>, u: Usual<Int>) {
-    val c1: Consumer<Any> = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>c<!>
+    val c1: Consumer<Any> = <!TYPE_MISMATCH!>c<!>
    val <!UNUSED_VARIABLE!>c2<!>: Consumer<Int> = c1

    val p1: Producer<Any> = p
-    val <!UNUSED_VARIABLE!>p2<!>: Producer<Int> = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>p1<!>
+    val <!UNUSED_VARIABLE!>p2<!>: Producer<Int> = <!TYPE_MISMATCH!>p1<!>

-    val u1: Usual<Any> = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>u<!>
-    val <!UNUSED_VARIABLE!>u2<!>: Usual<Int> = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>u1<!>
+    val u1: Usual<Any> = <!TYPE_MISMATCH!>u<!>
+    val <!UNUSED_VARIABLE!>u2<!>: Usual<Int> = <!NI;TYPE_MISMATCH, OI;TYPE_MISMATCH!>u1<!>
 }

 //Arrays copy example
@@ -4,7 +4,7 @@ fun foo(@<!UNRESOLVED_REFERENCE!>varargs<!> <!UNUSED_PARAMETER!>f<!> : Int) {}
 var bar : Int = 1
  set(@<!UNRESOLVED_REFERENCE!>varargs<!> <!UNUSED_PARAMETER!>v<!>) {}

-val x : (Int) -> Int = {@<!UNRESOLVED_REFERENCE!>varargs<!> <!NI;TYPE_MISMATCH, TYPE_MISMATCH, UNINITIALIZED_VARIABLE!>x<!> <!SYNTAX!>: Int -> x<!>}
+val x : (Int) -> Int = {@<!UNRESOLVED_REFERENCE!>varargs<!> <!TYPE_MISMATCH, UNINITIALIZED_VARIABLE!>x<!> <!SYNTAX!>: Int -> x<!>}

 class Hello(@<!UNRESOLVED_REFERENCE!>varargs<!> <!UNUSED_PARAMETER!>args<!>: Any) {
 }
@@ -8,7 +8,7 @@ fun foo(@test <!UNUSED_PARAMETER!>f<!> : Int) {}
 var bar : Int = 1
    set(@test <!UNUSED_PARAMETER!>v<!>) {}

-val x : (Int) -> Int = {@test <!NI;TYPE_MISMATCH, TYPE_MISMATCH, UNINITIALIZED_VARIABLE!>x<!> <!SYNTAX!>: Int -> x<!>} // todo fix parser annotation on lambda parameter
+val x : (Int) -> Int = {@test <!TYPE_MISMATCH, UNINITIALIZED_VARIABLE!>x<!> <!SYNTAX!>: Int -> x<!>} // todo fix parser annotation on lambda parameter

 class Hello(@test <!UNUSED_PARAMETER!>args<!>: Any) {
 }
@@ -33,5 +33,5 @@ fun <T> test(x: T) {
    val s4: Pair<Int?, String> = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>bar(null, null, ::<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>)<!>

    val s5: Pair<Int, String> = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>bar(1, "", ::foo)<!>
-    val (a1: Int, <!NI;TYPE_MISMATCH!>b1: String<!>) = <!OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>bar(1, "", ::foo)<!>
+    val (a1: Int, b1: String) = <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>bar(1, "", ::foo)<!>
 }
@@ -20,11 +20,11 @@ operator fun Impl2.unaryMinus() = Impl2()
 // See also KT-10384: in non-error functions, as is necessary!
 fun add1(x: Impl2, y: Base): Impl1 = x as Base + y

-fun error1(x: Impl2, y: Base): Impl1 = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>x + y<!>
+fun error1(x: Impl2, y: Base): Impl1 = <!TYPE_MISMATCH!>x + y<!>

 fun add2(x: Base, y: Impl2): Impl1 = x + y as Base

-fun error2(x: Base, y: Impl2): Impl1 = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>x + y<!>
+fun error2(x: Base, y: Impl2): Impl1 = <!TYPE_MISMATCH!>x + y<!>

 fun minus3(x: Impl2): Impl1 = -(x as Base)

@@ -1,7 +1,7 @@
 // !WITH_NEW_INFERENCE
 fun foo1(b: Boolean, c: Int) {
-    if (b && <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>c<!>) {}
-    if (b || <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>c<!>) {}
-    if (<!NI;TYPE_MISMATCH, TYPE_MISMATCH!>c<!> && b) {}
-    if (<!NI;TYPE_MISMATCH, TYPE_MISMATCH!>c<!> || b) {}
+    if (b && <!TYPE_MISMATCH!>c<!>) {}
+    if (b || <!TYPE_MISMATCH!>c<!>) {}
+    if (<!TYPE_MISMATCH!>c<!> && b) {}
+    if (<!TYPE_MISMATCH!>c<!> || b) {}
 }
@@ -27,7 +27,7 @@ fun foo() {
            z = 34
        }
    }
-    val <!UNUSED_VARIABLE!>f<!>: ()-> Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>r<!>
+    val <!UNUSED_VARIABLE!>f<!>: ()-> Int = <!TYPE_MISMATCH!>r<!>
    val <!UNUSED_VARIABLE!>g<!>: ()-> Any = r
 }

@@ -80,7 +80,7 @@ fun testCoercionToUnit() {
            45
        }
    }
-    val <!UNUSED_VARIABLE!>f<!> : () -> String = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>checkType<!>
+    val <!UNUSED_VARIABLE!>f<!> : () -> String = <!TYPE_MISMATCH!>checkType<!>
 }

 fun doSmth(<!UNUSED_PARAMETER!>i<!>: Int) {}
@@ -12,7 +12,7 @@ public class J {
 val testImplicitExclExcl1: String = J.s
 val testImplicitExclExcl2: String? = J.s

-val testImplicitExclExcl3: String = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>J.m[""]<!>
+val testImplicitExclExcl3: String = <!TYPE_MISMATCH!>J.m[""]<!>
 val testImplicitExclExcl4: String? = J.m[""]

 val testExclExcl1: String = J.s!!
@@ -9,4 +9,4 @@ open class Bar() : <!CYCLIC_INHERITANCE_HIERARCHY!>Foo<!>() {

 }

-val x : Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>Foo()<!>
+val x : Int = <!TYPE_MISMATCH!>Foo()<!>
@@ -14,5 +14,5 @@ fun foo(): Int {
    val z: Int? = null
    if (z != null) return if (<!SENSELESS_COMPARISON!>z == null<!>) z else z
    
-    return <!DEBUG_INFO_CONSTANT, NI;TYPE_MISMATCH, TYPE_MISMATCH!>z<!>
+    return <!DEBUG_INFO_CONSTANT, TYPE_MISMATCH!>z<!>
 }
@@ -5,5 +5,5 @@ class A {
 }

 fun a(aa : A) {
-    val (<!NI;TYPE_MISMATCH!><!UNUSED_VARIABLE!>a<!>: String<!>, <!NI;TYPE_MISMATCH!><!UNUSED_VARIABLE!>b1<!>: String<!>) = <!OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>aa<!>
+    val (<!UNUSED_VARIABLE!>a<!>: String, <!UNUSED_VARIABLE!>b1<!>: String) = <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>aa<!>
 }
@@ -9,7 +9,7 @@ class C {
 }

 fun test() {
-    for ((<!NI;TYPE_MISMATCH!><!UNUSED_VARIABLE!>x<!>: Double<!>, <!NI;TYPE_MISMATCH!><!UNUSED_VARIABLE!>y<!>: Int<!>) in <!OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>C()<!>) {
+    for ((<!UNUSED_VARIABLE!>x<!>: Double, <!UNUSED_VARIABLE!>y<!>: Int) in <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>C()<!>) {

    }
 }
@@ -26,7 +26,7 @@ fun test() {
        foo(<!UNRESOLVED_REFERENCE!>_<!>, <!UNRESOLVED_REFERENCE!>_<!>)
    }

-    for ((<!NI;TYPE_MISMATCH!>_ : String<!>, <!NI;TYPE_MISMATCH!>_ : Int<!>) in <!OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>C()<!>) {
+    for ((_ : String, _ : Int) in <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>C()<!>) {
        foo(<!UNRESOLVED_REFERENCE!>_<!>, <!UNRESOLVED_REFERENCE!>_<!>)
    }

@@ -12,8 +12,8 @@ class A(outer: Outer) {

    var b: String by  foo(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())
    var r: String by  foo(outer.getContainer().<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())
-    var e: String by  <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;TYPE_MISMATCH!><!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())<!>
-    var f: String by  <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;TYPE_MISMATCH!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>()) <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>-<!> 1<!>
+    var e: String by  <!NI;DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!><!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> <!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>())<!>
+    var f: String by  <!NI;DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!><!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>getMyProperty<!>()) <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>-<!> 1<!>
 }

 fun <A, B> foo(<!UNUSED_PARAMETER!>a<!>: Any?) = MyProperty<A, B>()
@@ -25,4 +25,4 @@ class C<R>() {
 }

 var c1: Int by C()
-var c2: Int by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;TYPE_MISMATCH, OI;DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!>C<Number>()<!>
+var c2: Int by <!DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!>C<Number>()<!>
@@ -13,6 +13,6 @@ 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 <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;TYPE_MISMATCH, OI;DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!>"OK"<!>
+val test2: Int by <!DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!>"OK"<!>
 val test3 by "OK"

@@ -11,5 +11,5 @@ class WrongDelegate(val x: Int) {
 operator fun String.getValue(thisRef: Any?, prop: Any) = this

 val test1: String by "OK"
-val test2: Int by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;TYPE_MISMATCH, OI;DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!>"OK"<!>
+val test2: Int by <!DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!>"OK"<!>
 val test3 by "OK"
@@ -3,7 +3,7 @@

 import kotlin.reflect.KProperty

-val c: Int by <!NI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, NI;TYPE_MISMATCH, OI;DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!>Delegate()<!>
+val c: Int by <!DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH!>Delegate()<!>

 class Delegate {
  operator fun getValue(t: Any?, p: KProperty<*>): String {
@@ -53,4 +53,4 @@ class CBarT<T> : IBarT<T> {

 <!OVERRIDING_FINAL_MEMBER_BY_DELEGATION!>class Test7<!> : Final(), IBarT<Int> by CBarT<Int>()

-<!OVERRIDING_FINAL_MEMBER_BY_DELEGATION!>class Test8<!> : Final(), IBarT<Int> by <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>CBar()<!>
+<!OVERRIDING_FINAL_MEMBER_BY_DELEGATION!>class Test8<!> : Final(), IBarT<Int> by <!TYPE_MISMATCH!>CBar()<!>
@@ -23,6 +23,6 @@ public abstract class MyClass : Base1, Base2 {
    }
 }

-<!DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE, DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE, MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>class A<!> : MyClass(), Base1 by Delegate1(), <!SUPERTYPE_APPEARS_TWICE!>Base1<!> by <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>Delegate2()<!> {
+<!DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE, DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE, MANY_IMPL_MEMBER_NOT_IMPLEMENTED!>class A<!> : MyClass(), Base1 by Delegate1(), <!SUPERTYPE_APPEARS_TWICE!>Base1<!> by <!TYPE_MISMATCH!>Delegate2()<!> {

 }
@@ -12,7 +12,7 @@ val a7 = <!DIVISION_BY_ZERO!>1.div(a1)<!>
 val a8 = 1.div(a2)
 val a9 = 2 * (<!DIVISION_BY_ZERO!>1.div(0)<!>)

-val b1: Byte = <!DIVISION_BY_ZERO, NI;TYPE_MISMATCH, TYPE_MISMATCH!>1 / 0<!>
+val b1: Byte = <!DIVISION_BY_ZERO, TYPE_MISMATCH!>1 / 0<!>
@Ann(<!ANNOTATION_ARGUMENT_MUST_BE_CONST, DIVISION_BY_ZERO!>1 / 0<!>) val b2 = 1

 annotation class Ann(val i : Int)
@@ -22,8 +22,8 @@ fun bar(aList: List<A>) {
        b checkType { _<String>() }
    }

-    aList.foo { (<!NI;TYPE_MISMATCH, OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>a: String<!>, b) ->
-        <!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!> <!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>checkType<!> { <!NI;UNRESOLVED_REFERENCE!>_<!><Int>() }
+    aList.foo { (<!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>a: String<!>, b) ->
+        a checkType { _<Int>() }
        b checkType { _<String>() }
    }

@@ -42,8 +42,8 @@ fun bar() {
        d checkType { _<Short>() }
    }

-    foo { (<!NI;TYPE_MISMATCH, OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>a: String<!>, b) ->
-        <!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!> <!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>checkType<!> { <!NI;UNRESOLVED_REFERENCE!>_<!><Int>() }
+    foo { (<!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>a: String<!>, b) ->
+        a checkType { _<Int>() }
        b checkType { _<String>() }
    }

@@ -51,7 +51,7 @@ fun bar() {
        _ checkType { _<String>() }
    }

-    foo { (<!NI;TYPE_MISMATCH, OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>_: String<!>, b) ->
+    foo { (<!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>_: String<!>, b) ->
        <!UNRESOLVED_REFERENCE!>_<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>hashCode<!>()
        b checkType { _<String>() }
    }
@@ -20,7 +20,7 @@ private class Outer<E> {
        private var doubleStringInt = Outer<Double>().Inner<String>().foo<Int>()()

        private fun bar() {
-            doubleCharSequenceInt = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>doubleStringNumber<!>
+            doubleCharSequenceInt = <!TYPE_MISMATCH!>doubleStringNumber<!>
            doubleCharSequenceInt = doubleStringInt

            doubleStringInt = Outer<Double>().Inner<String>().foo<Int>()()
@@ -15,7 +15,7 @@ class Q {
    private var y = <!DEBUG_INFO_LEAKING_THIS!>foo<!><String>()()

    fun bar() {
-        x = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!>
+        x = <!TYPE_MISMATCH!>y<!>
        x = foo<CharSequence>()()
        y = foo<String>()()

@@ -13,7 +13,7 @@ class Q {
    private var y = <!DEBUG_INFO_LEAKING_THIS!>foo<!><String>()

    fun bar() {
-        x = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!>
+        x = <!TYPE_MISMATCH!>y<!>
        x = foo<CharSequence>()
        y = foo<String>()

@@ -29,7 +29,7 @@ fun <E> commonSupertype(x: E, y: E): E = x

 fun foo() {
    var myIt = A<String>().iterator()
-    myIt = <!TYPE_MISMATCH!>A<Int>().<!NI;TYPE_MISMATCH!>iterator()<!><!>
+    myIt = <!TYPE_MISMATCH!>A<Int>().iterator()<!>

    val csIt: Iterator<CharSequence> = A<String>().iterator()

@@ -11,7 +11,7 @@ class Outer<T> {
        z.checkType { _<Inner>() }
        z.checkType { _<Outer<T>.Inner>() }

-        inner = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>x<!>
+        inner = <!TYPE_MISMATCH!>x<!>
    }

    class Nested
@@ -1,6 +1,6 @@
 // !LANGUAGE: +NewInference

 inline fun <T, reified S> foo(x: T?, y: T): T {
-    if (x is S) return <!TYPE_MISMATCH, TYPE_MISMATCH!>x<!>
+    if (x is S) return <!TYPE_MISMATCH!>x<!>
    return y
 }
@@ -12,7 +12,7 @@ fun <T : CharSequence?> foo(x: T) {
        if (<!SENSELESS_COMPARISON!>x != null<!>) {}

        y1 = <!DEBUG_INFO_SMARTCAST!>x<!>
-        y2 = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>x<!>
+        y2 = <!TYPE_MISMATCH!>x<!>

        <!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>bar1<!>(<!NI;DEBUG_INFO_SMARTCAST!>x<!>)
        bar1<CharSequence>(<!DEBUG_INFO_SMARTCAST!>x<!>)
@@ -31,7 +31,7 @@ fun <T : CharSequence?> foo(x: T) {

    if (x is CharSequence) {
        y1 = <!DEBUG_INFO_SMARTCAST!>x<!>
-        y2 = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>x<!>
+        y2 = <!TYPE_MISMATCH!>x<!>

        bar1(<!DEBUG_INFO_SMARTCAST!>x<!>)
        bar2(<!DEBUG_INFO_SMARTCAST!>x<!>)
@@ -24,10 +24,10 @@ class A<T : CharSequence?, E1 : T, E2: T?> {
        }

        if (1 == 1) {
-            t = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>tN<!>
+            t = <!TYPE_MISMATCH!>tN<!>
        }

-        t = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!>
+        t = <!TYPE_MISMATCH!>y<!>

        if (y != null) {
            t = <!DEBUG_INFO_SMARTCAST!>y<!>
@@ -9,7 +9,7 @@ fun main() {
    val a : ArrayList<ArrayList<String>> = ArrayList()
    val b : ListOfLists<String> = ListOfLists(a)
    val c : ListOfLists<*> = b
-    val d : ArrayList<ArrayList<*>> = <!TYPE_MISMATCH!>c.<!NI;TYPE_MISMATCH!>x<!><!>
+    val d : ArrayList<ArrayList<*>> = <!TYPE_MISMATCH!>c.x<!>

    c.x checkType { _<ArrayList<out ArrayList<*>>>() }
 }
@@ -18,7 +18,7 @@ fun test(a: A<out CharSequence>, z: Out<CharSequence>) {
    }
    a.bar { <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>Out<CharSequence>()<!> }
    a.bar { <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>Out<!>() }
-    a.bar { <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>z.<!NI;TYPE_MISMATCH!>id()<!><!> }
+    a.bar { <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>z.id()<!> }

    a.foo {
        z.foobar(if (1 > 2) return@foo <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>""<!> else "")
@@ -5,6 +5,6 @@ interface Tr<T> {
 }

 fun test(t: Tr<*>) {
-    <!SETTER_PROJECTED_OUT!>t.v<!> = <!NI;TYPE_MISMATCH!>t<!>
+    <!SETTER_PROJECTED_OUT!>t.v<!> = t
    t.v checkType { _<Tr<*>>() }
 }
@@ -12,7 +12,7 @@ fun foo(): String? {
    run {
        if (true) return@run

-        if (true) return <!TYPE_MISMATCH, TYPE_MISMATCH!>Obj()<!> // correct error, type check against return type of function "foo"
+        if (true) return <!TYPE_MISMATCH!>Obj()<!> // correct error, type check against return type of function "foo"
    }

    run {
@@ -5,7 +5,7 @@ package kt1293

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

@@ -29,5 +29,5 @@ fun testWithoutInference(col: MutableCollection<Int>) {
    
    doAction { col.add(2) }
    
-    val <!UNUSED_VARIABLE!>u<!>: Unit = <!TYPE_MISMATCH!>col.<!NI;TYPE_MISMATCH!>add(2)<!><!>
+    val <!UNUSED_VARIABLE!>u<!>: Unit = <!TYPE_MISMATCH!>col.add(2)<!>
 }
@@ -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 = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>c<!>
+    val <!UNUSED_VARIABLE!>i<!> : Int = <!TYPE_MISMATCH!>c<!>
 }
@@ -149,7 +149,7 @@ fun illegalWhenBody(a: Any): Int = <!NI;TYPE_MISMATCH!><!NO_ELSE_IN_WHEN!>when<!
 fun illegalWhenBlock(a: Any): Int {
    when(a) {
        is Int -> return <!DEBUG_INFO_SMARTCAST!>a<!>
-        is String -> return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>a<!>
+        is String -> return <!TYPE_MISMATCH!>a<!>
    }
 <!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 fun declarations(a: Any?) {
@@ -222,7 +222,7 @@ fun f(): String {
 fun foo(aa: Any?): Int {
    var a = aa
    if (a is Int?) {
-        return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>a<!>
+        return <!TYPE_MISMATCH!>a<!>
    }
    return 1
 }
@@ -7,7 +7,7 @@ inline fun inlineFun(lambda: () -> String) = lambda()
 fun noInlineFun(lambda: () -> String) = lambda()


-inline fun default0_1(lambda: () -> String, <!NOT_YET_SUPPORTED_IN_INLINE!>dlambda: () -> String = { <!NI;TYPE_MISMATCH, TYPE_MISMATCH, USAGE_IS_NOT_INLINABLE!>lambda<!> }<!>) {
+inline fun default0_1(lambda: () -> String, <!NOT_YET_SUPPORTED_IN_INLINE!>dlambda: () -> String = { <!TYPE_MISMATCH, USAGE_IS_NOT_INLINABLE!>lambda<!> }<!>) {
    lambda() + dlambda()
 }

@@ -34,7 +34,7 @@ fun main() {
    }

    A.baz {
-        x -> <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>x.<!NI;TYPE_MISMATCH!>hashCode()<!><!>
+        x -> <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>x.hashCode()<!>
    }

    val block: (String) -> Any? = {
@@ -1,5 +1,5 @@
 // !WITH_NEW_INFERENCE

 fun f(c: LongRange): Int {
-    return c.<!FUNCTION_EXPECTED, NI;TYPE_MISMATCH!>start<!>()
+    return c.<!FUNCTION_EXPECTED!>start<!>()
 }
@@ -8,7 +8,7 @@ fun <T> testCollection(c: Collection<T>, t: T) {
    val <!UNUSED_VARIABLE!>iterator<!>: Iterator<T> = c.iterator()
    c.containsAll(c)

-    val <!UNUSED_VARIABLE!>mutableIterator<!>: MutableIterator<T> = <!TYPE_MISMATCH!>c.<!NI;TYPE_MISMATCH!>iterator()<!><!>
+    val <!UNUSED_VARIABLE!>mutableIterator<!>: MutableIterator<T> = <!TYPE_MISMATCH!>c.iterator()<!>
    c.<!UNRESOLVED_REFERENCE!>add<!>(t)
    c.<!UNRESOLVED_REFERENCE!>remove<!>(1)
    c.<!UNRESOLVED_REFERENCE!>addAll<!>(c)
@@ -45,9 +45,9 @@ fun <T> testList(l: List<T>, <!UNUSED_PARAMETER!>t<!>: T) {
    val <!UNUSED_VARIABLE!>value<!>: T = l.<!UNRESOLVED_REFERENCE!>set<!>(1, t)
    l.<!UNRESOLVED_REFERENCE!>add<!>(1, t)
    l.<!UNRESOLVED_REFERENCE!>remove<!>(1)
-    val <!UNUSED_VARIABLE!>mutableListIterator<!>: MutableListIterator<T> = <!TYPE_MISMATCH!>l.<!NI;TYPE_MISMATCH!>listIterator()<!><!>
-    val <!UNUSED_VARIABLE!>mutableListIterator1<!>: MutableListIterator<T> = <!TYPE_MISMATCH!>l.<!NI;TYPE_MISMATCH!>listIterator(1)<!><!>
-    val <!UNUSED_VARIABLE!>mutableList<!>: MutableList<T> = <!TYPE_MISMATCH!>l.<!NI;TYPE_MISMATCH!>subList(1, 2)<!><!>
+    val <!UNUSED_VARIABLE!>mutableListIterator<!>: MutableListIterator<T> = <!TYPE_MISMATCH!>l.listIterator()<!>
+    val <!UNUSED_VARIABLE!>mutableListIterator1<!>: MutableListIterator<T> = <!TYPE_MISMATCH!>l.listIterator(1)<!>
+    val <!UNUSED_VARIABLE!>mutableList<!>: MutableList<T> = <!TYPE_MISMATCH!>l.subList(1, 2)<!>
 }

 fun <T> testMutableList(l: MutableList<T>, t: T) {
@@ -66,7 +66,7 @@ fun <T> testSet(s: Set<T>, t: T) {
    val <!UNUSED_VARIABLE!>iterator<!>: Iterator<T> = s.iterator()
    s.containsAll(s)

-    val <!UNUSED_VARIABLE!>mutableIterator<!>: MutableIterator<T> = <!TYPE_MISMATCH!>s.<!NI;TYPE_MISMATCH!>iterator()<!><!>
+    val <!UNUSED_VARIABLE!>mutableIterator<!>: MutableIterator<T> = <!TYPE_MISMATCH!>s.iterator()<!>
    s.<!UNRESOLVED_REFERENCE!>add<!>(t)
    s.<!UNRESOLVED_REFERENCE!>remove<!>(1)
    s.<!UNRESOLVED_REFERENCE!>addAll<!>(s)
@@ -97,9 +97,9 @@ fun <K, V> testMap(m: Map<K, V>) {
    val <!UNUSED_VARIABLE!>collection<!>: Collection<V> = m.values
    val <!UNUSED_VARIABLE!>set1<!>: Set<Map.Entry<K, V>> = m.entries

-    val <!UNUSED_VARIABLE!>mutableSet<!>: MutableSet<K> = <!TYPE_MISMATCH!>m.<!NI;TYPE_MISMATCH!>keys<!><!>
-    val <!UNUSED_VARIABLE!>mutableCollection<!>: MutableCollection<V> = <!TYPE_MISMATCH!>m.<!NI;TYPE_MISMATCH!>values<!><!>
-    val <!UNUSED_VARIABLE!>mutableSet1<!>: MutableSet<MutableMap.MutableEntry<K, V>> = <!TYPE_MISMATCH!>m.<!NI;TYPE_MISMATCH!>entries<!><!>
+    val <!UNUSED_VARIABLE!>mutableSet<!>: MutableSet<K> = <!TYPE_MISMATCH!>m.keys<!>
+    val <!UNUSED_VARIABLE!>mutableCollection<!>: MutableCollection<V> = <!TYPE_MISMATCH!>m.values<!>
+    val <!UNUSED_VARIABLE!>mutableSet1<!>: MutableSet<MutableMap.MutableEntry<K, V>> = <!TYPE_MISMATCH!>m.entries<!>
 }

 fun <K, V> testMutableMap(m: MutableMap<K, V>) {
@@ -18,5 +18,5 @@ import p.*
 class A

 fun test() {
-    val a: A = <!TYPE_MISMATCH!>B().<!NI;TYPE_MISMATCH!>a<!><!>
+    val a: A = <!TYPE_MISMATCH!>B().a<!>
 }
@@ -7,13 +7,13 @@ class A {
 }

 fun foo() {
-    val i1: Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>Boo<!>
-    val i2: Int = <!TYPE_MISMATCH!>A.<!NI;TYPE_MISMATCH!>Boo<!><!>
+    val i1: Int = <!TYPE_MISMATCH!>Boo<!>
+    val i2: Int = <!TYPE_MISMATCH!>A.Boo<!>
    useInt(<!TYPE_MISMATCH!>Boo<!>)
    useInt(<!TYPE_MISMATCH!>A.Boo<!>)
 }
 fun bar() {
-    val i1: Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>Unit<!>
+    val i1: Int = <!TYPE_MISMATCH!>Unit<!>
    useInt(<!TYPE_MISMATCH!>Unit<!>)
 }

@@ -18,7 +18,7 @@ var n: J? = J()

 fun test() {
    v = J.staticNN
-    v = <!TYPE_MISMATCH!>J.<!NI;TYPE_MISMATCH!>staticN<!><!>
+    v = <!TYPE_MISMATCH!>J.staticN<!>
    v = J.staticJ

    n = J.staticNN
@@ -23,23 +23,23 @@ fun test() {
    val platformJ = J.staticJ

    if (platformNN) {}
-    if (<!NI;TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>platformN<!>) {}
+    if (<!TYPE_MISMATCH, TYPE_MISMATCH!>platformN<!>) {}
    if (platformJ) {}

    while (platformNN) {}
-    while (<!NI;TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>platformN<!>) {}
+    while (<!TYPE_MISMATCH, TYPE_MISMATCH!>platformN<!>) {}
    while (platformJ) {}

    do {} while (platformNN)
-    do {} while (<!NI;TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>platformN<!>)
+    do {} while (<!TYPE_MISMATCH, TYPE_MISMATCH!>platformN<!>)
    do {} while (platformJ)

    platformNN && false
-    <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>platformN<!> && false
+    <!TYPE_MISMATCH!>platformN<!> && false
    platformJ && false

    platformNN || false
-    <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>platformN<!> || false
+    <!TYPE_MISMATCH!>platformN<!> || false
    platformJ || false

    !platformNN
@@ -16,14 +16,14 @@ public class J {
 fun test() {
    val n = J.staticN
    foo(<!TYPE_MISMATCH!>n<!>)
-    J.staticNN = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>n<!>
+    J.staticNN = <!TYPE_MISMATCH!>n<!>
    if (n != null) {
        foo(<!DEBUG_INFO_SMARTCAST!>n<!>)
        J.staticNN = <!DEBUG_INFO_SMARTCAST!>n<!>
    }

    val x: J? = null
-    J.staticNN = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>x<!>
+    J.staticNN = <!TYPE_MISMATCH!>x<!>
    if (x != null) {
        J.staticNN = <!DEBUG_INFO_SMARTCAST!>x<!>
    }
@@ -22,7 +22,7 @@ fun test() {
    // platform type with no annotation
    val platformJ = J.staticJ

-    fun foo(p: J = platformNN, p1: J = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>platformN<!>, p2: J = platformJ) {}
+    fun foo(p: J = platformNN, p1: J = <!TYPE_MISMATCH!>platformN<!>, p2: J = platformJ) {}

    fun foo1(p: J? = platformNN, p1: J? = platformN, p2: J? = platformJ) {}
 }
@@ -15,5 +15,5 @@ public class J {
 // FILE: k.kt

 class A : List<String> by J.staticNN
-class B : List<String> by <!TYPE_MISMATCH!>J.<!NI;TYPE_MISMATCH!>staticN<!><!>
+class B : List<String> by <!TYPE_MISMATCH!>J.staticN<!>
 class C : List<String> by J.staticJ
@@ -34,8 +34,8 @@ fun test(n: J?, nn: J) {
    // platform type with no annotation
    val platformJ = J.staticJ

-    J.staticNN = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>n<!>
-    J.staticNN = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>platformN<!>
+    J.staticNN = <!TYPE_MISMATCH!>n<!>
+    J.staticNN = <!TYPE_MISMATCH!>platformN<!>
    J.staticNN = nn
    J.staticNN = platformNN
    J.staticNN = platformJ
@@ -58,8 +58,8 @@ fun test(n: J?, nn: J) {
    J.staticSet(<!TYPE_MISMATCH!>platformN<!>, platformN, platformN)
    J.staticSet(platformJ, platformJ, platformJ)

-    J().nn = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>n<!>
-    J().nn = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>platformN<!>
+    J().nn = <!TYPE_MISMATCH!>n<!>
+    J().nn = <!TYPE_MISMATCH!>platformN<!>
    J().nn = nn
    J().nn = platformNN
    J().nn = platformJ
@@ -18,7 +18,7 @@ fun test() {
 }

 fun test1() {
-    throw <!TYPE_MISMATCH!>J.<!NI;TYPE_MISMATCH!>staticN<!><!>
+    throw <!TYPE_MISMATCH!>J.staticN<!>
 }

 fun test2() {
@@ -2,7 +2,7 @@
 fun main() {
    val a : Int? = null;
    var v = 1
-    val <!UNUSED_VARIABLE!>b<!> : String = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>v<!>;
+    val <!UNUSED_VARIABLE!>b<!> : String = <!TYPE_MISMATCH!>v<!>;
    val <!UNUSED_VARIABLE!>f<!> : String = <!NI;TYPE_MISMATCH!><!OI;TYPE_MISMATCH!>a<!>!!<!>;
    val <!UNUSED_VARIABLE!>g<!> : String = <!TYPE_MISMATCH!>v++<!>;
    val <!UNUSED_VARIABLE!>g1<!> : String = <!TYPE_MISMATCH!>++v<!>;
@@ -3,7 +3,7 @@ class A() {
    var x: Int = 0
        get() = <!TYPE_MISMATCH!>"s"<!>
        set(value: <!WRONG_SETTER_PARAMETER_TYPE!>String<!>) {
-            field = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>value<!>
+            field = <!TYPE_MISMATCH!>value<!>
        }
    val y: Int
        get(): <!WRONG_GETTER_RETURN_TYPE("Int", "String")!>String<!> = "s"
@@ -28,7 +28,7 @@ class A() {
        }
    val e = 1
        get(): <!WRONG_GETTER_RETURN_TYPE!>String<!> {
-            return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>field<!>
+            return <!TYPE_MISMATCH!>field<!>
        }

 }
@@ -8,7 +8,7 @@ fun overloadedFun1(c: Any = "", b: String = "", f: Any = "") = Right
 fun overloadedFun1(b: Any = "", c: Any = "", e: String = "") = Wrong

 val test1: Right = overloadedFun1(b = "")
-val test1a: Wrong = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>overloadedFun1(b = "")<!>
+val test1a: Wrong = <!TYPE_MISMATCH!>overloadedFun1(b = "")<!>

 fun overloadedFun2(a: String, b: Any = "") = Right
 fun overloadedFun2(a: Any, b: String = "") = Wrong
@@ -20,7 +20,7 @@ fun test() {

    class B: A() {
        init {
-            val a: Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>foo()<!> // todo
+            val a: Int = <!TYPE_MISMATCH!>foo()<!> // todo
        }
    }
 }
@@ -12,14 +12,14 @@ open class A<T> : J() {
    init {
        foo()
        bar()
-        val a: Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!><!DEBUG_INFO_LEAKING_THIS!>baz<!>()<!>
+        val a: Int = <!TYPE_MISMATCH!><!DEBUG_INFO_LEAKING_THIS!>baz<!>()<!>
        val b: T = <!DEBUG_INFO_LEAKING_THIS!>baz<!>()
    }

    fun test1() {
        foo()
        bar()
-        val a: Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>baz()<!>
+        val a: Int = <!TYPE_MISMATCH!>baz()<!>
        val b: T = baz()
    }

@@ -12,14 +12,14 @@ open class A<T> : J() {
    init {
        <!DEPRECATED_ACCESS_BY_SHORT_NAME!>foo()<!>
        bar()
-        val a: Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!><!DEBUG_INFO_LEAKING_THIS!>baz<!>()<!>
+        val a: Int = <!TYPE_MISMATCH!><!DEBUG_INFO_LEAKING_THIS!>baz<!>()<!>
        val b: T = <!DEBUG_INFO_LEAKING_THIS!>baz<!>()
    }

    fun test1() {
        <!DEPRECATED_ACCESS_BY_SHORT_NAME!>foo()<!>
        bar()
-        val a: Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>baz()<!>
+        val a: Int = <!TYPE_MISMATCH!>baz()<!>
        val b: T = baz()
    }

@@ -21,7 +21,7 @@ fun test() {

    class B: A() {
        init {
-            val a: Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>foo()<!> // todo
+            val a: Int = <!TYPE_MISMATCH!>foo()<!> // todo
        }
    }
 }
@@ -1,6 +1,6 @@
 // !WITH_NEW_INFERENCE
 val (a1, a2) = A()
-val (b1: Int, <!NI;TYPE_MISMATCH!>b2: Int<!>) = <!OI;COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>A()<!>
+val (b1: Int, b2: Int) = <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>A()<!>
 val (c1) = <!UNRESOLVED_REFERENCE!>unresolved<!>

 <!WRONG_MODIFIER_TARGET!>private<!> val (d1) = A()
@@ -10,7 +10,7 @@ class A {
            return <!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>
        }
        return
-        return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>foo()<!>
+        return <!TYPE_MISMATCH!>foo()<!>
    }<!>

    fun foo(): Int = 1
@@ -33,5 +33,5 @@ fun baz(s: String?, r: String?): String {
 fun withNull(s: String?): String {
    val t = s <!USELESS_ELVIS_RIGHT_IS_NULL!>?: null<!>
    // Error: nullable
-    return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>t<!>
+    return <!TYPE_MISMATCH!>t<!>
 }
@@ -5,7 +5,7 @@ class ExplicitAccessorForAnnotation {

    fun foo(): String {
        if (tt is String) {
-            return <!NI;TYPE_MISMATCH, SMARTCAST_IMPOSSIBLE!>tt<!>
+            return <!SMARTCAST_IMPOSSIBLE!>tt<!>
        }
        return ""
    }
@@ -8,7 +8,7 @@ class Immutable(val x: String?) {

 class Mutable(var y: String?) {
    fun foo(): String {
-        if (y != null) return <!NI;TYPE_MISMATCH, SMARTCAST_IMPOSSIBLE!>y<!>
+        if (y != null) return <!SMARTCAST_IMPOSSIBLE!>y<!>
        return ""
    }
 }
@@ -3,6 +3,6 @@
 fun calc(x: List<String>?, y: Int?): Int {
    x?.get(y!! - 1) 
    // y!! above should not provide smart cast here
-    val yy: Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!>
+    val yy: Int = <!TYPE_MISMATCH!>y<!>
    return  yy + (x?.size ?: 0)
 }
@@ -3,5 +3,5 @@
 fun calc(x: List<String>?, y: Int?): Int {
    x?.subList(y!! - 1, <!DEBUG_INFO_SMARTCAST!>y<!>)
    // y!! above should not provide smart cast here
-    return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!>
+    return <!TYPE_MISMATCH!>y<!>
 }
@@ -6,5 +6,5 @@ fun calc(x: String?, y: Int?): Int {
    // Smart cast because of x!! in receiver
    foo(x!!)?.subSequence(y!!, <!DEBUG_INFO_SMARTCAST!>x<!>.length)?.length
    // No smart cast possible
-    return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!>
+    return <!TYPE_MISMATCH!>y<!>
 }
@@ -13,5 +13,5 @@ fun list(start: SomeObject): SomeObject {
        e = e<!UNSAFE_CALL!>.<!>next()
    }
    // Smart cast is not possible here due to next()
-    return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>e<!>
+    return <!TYPE_MISMATCH!>e<!>
 }
@@ -14,5 +14,5 @@ fun list(start: SomeObject): SomeObject {
        <!DEBUG_INFO_SMARTCAST!>e<!>.doSomething()
        e = <!DEBUG_INFO_SMARTCAST!>e<!>.next()
    }
-    return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>e<!>
+    return <!TYPE_MISMATCH!>e<!>
 }
@@ -14,5 +14,5 @@ fun list(start: SomeObject): SomeObject {
        <!DEBUG_INFO_SMARTCAST!>e<!>.doSomething()
        e = <!DEBUG_INFO_SMARTCAST!>e<!>.next()
    }
-    return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>e<!>
+    return <!TYPE_MISMATCH!>e<!>
 }
@@ -2,5 +2,5 @@
 fun foo(): Int {
    var i: Int? = <!VARIABLE_WITH_REDUNDANT_INITIALIZER!>42<!>
    i = null
-    return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!><!OI;DEBUG_INFO_CONSTANT!>i<!> + 1<!>
+    return <!TYPE_MISMATCH!><!OI;DEBUG_INFO_CONSTANT!>i<!> + 1<!>
 }
@@ -15,5 +15,5 @@ private fun foo() = run {

 fun test() {
    var x = foo(1)
-    x = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>foo()<!>
+    x = <!TYPE_MISMATCH!>foo()<!>
 }
@@ -19,5 +19,5 @@ private fun foo() = run {

 fun test() {
    var x = foo(1)
-    x = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>foo()<!>
+    x = <!TYPE_MISMATCH!>foo()<!>
 }
@@ -19,5 +19,5 @@ private fun foo() = run {

 fun test() {
    var x = foo(1)
-    x = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>foo()<!>
+    x = <!TYPE_MISMATCH!>foo()<!>
 }
@@ -2,7 +2,7 @@
 // FILE: KotlinFile.kt
 fun foo(javaClass: JavaClass<Int>): Int {
    val inner = javaClass.createInner<String>()
-    return <!TYPE_MISMATCH!>inner.<!NI;TYPE_MISMATCH!>doSomething(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>, "") <!OI;TYPE_MISMATCH!>{ }<!><!><!>
+    return <!TYPE_MISMATCH!>inner.doSomething(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>, "") <!OI;TYPE_MISMATCH!>{ }<!><!>
 }

 // FILE: JavaClass.java
@@ -8,5 +8,5 @@ fun test(a: Any): String {
        is A -> q!!
    }
    // When is not exhaustive
-    return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>q<!>
+    return <!TYPE_MISMATCH!>q<!>
 }
@@ -8,5 +8,5 @@ fun test(a: Any) {
        is A -> q = "1"
    }
    // When is not exhaustive
-    return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>q<!>
+    return <!TYPE_MISMATCH!>q<!>
 }