[NI] Testdata changes after fixes in error types

2017-11-30 20:28:57 +03:00
parent 957bbe291d
commit ea72c76a37
44 changed files with 72 additions and 67 deletions
@@ -4,7 +4,7 @@ fun text() {
    "direct:a" on {it.body == "<hello/>"} to "mock:a"
    "direct:a" on {it -> it.body == "<hello/>"} to "mock:a"
    bar <!NI;TYPE_MISMATCH!><!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!>1}<!>
-    bar <!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!><!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!><!UNRESOLVED_REFERENCE!>it<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> 1<!>}
+    bar <!NI;TYPE_MISMATCH!><!EXPECTED_PARAMETERS_NUMBER_MISMATCH!>{<!><!UNRESOLVED_REFERENCE!>it<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> 1}<!>
    bar {it, <!UNUSED_ANONYMOUS_PARAMETER!>it1<!> -> it}

    bar1 {1}
@@ -1,6 +1,6 @@
 // !WITH_NEW_INFERENCE
 fun test() {
-  if (<!UNRESOLVED_REFERENCE!>x<!> <!NI;COMPARE_TO_TYPE_MISMATCH, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>><!> 0) {
+  if (<!UNRESOLVED_REFERENCE!>x<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>><!> 0) {

  }
 }
@@ -1,7 +1,7 @@
 package

 public interface T {
-    public open val a: kotlin.Any?
+    public open val a: [ERROR : <ERROR FUNCTION RETURN TYPE>]
    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
@@ -26,13 +26,13 @@ fun <T> fooT2() : (t : T) -> T {
 fun main(args : Array<String>) {
    args.foo()()
    args.foo1()(<!NO_VALUE_FOR_PARAMETER!>)<!>
-    <!NI;FUNCTION_EXPECTED!><!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>foo1<!>()<!>()
-    <!NI;FUNCTION_EXPECTED!><!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>foo1<!>()<!>(<!UNRESOLVED_REFERENCE!>a<!>)
+    <!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>foo1<!>()()
+    <!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>foo1<!>()(<!UNRESOLVED_REFERENCE!>a<!>)

    args.foo1()(1)
    args.foo1()(<!TYPE_MISMATCH!>"1"<!>)
-    <!NI;FUNCTION_EXPECTED!><!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>foo1<!>()<!>("1")
-    <!NI;FUNCTION_EXPECTED!><!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>foo1<!>()<!>(<!UNRESOLVED_REFERENCE!>a<!>)
+    <!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>foo1<!>()("1")
+    <!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>foo1<!>()(<!UNRESOLVED_REFERENCE!>a<!>)

    foo2()({})
    foo2()<!TOO_MANY_ARGUMENTS!>{}<!>
@@ -21,7 +21,7 @@ public final class B {

 public final class C {
    public constructor C()
-    public final val bar: kotlin.Any?
+    public final val bar: [ERROR : <ERROR FUNCTION RETURN TYPE>]
    public final val test: [ERROR : Type for bar()]
    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
@@ -23,5 +23,5 @@ fun main(args : Array<String>) {
    <!INVISIBLE_MEMBER!>System<!>()
    (<!NO_COMPANION_OBJECT!>System<!>)
    foo@ <!NO_COMPANION_OBJECT!>System<!>
-    null <!NI;RESULT_TYPE_MISMATCH!>in<!> <!NO_COMPANION_OBJECT!>System<!>
+    null in <!NO_COMPANION_OBJECT!>System<!>
 }
@@ -1,18 +1,18 @@
 package

 package a {
-    public val foo: kotlin.Any?
+    public val foo: [ERROR : Error function type]
    public fun bar(): [ERROR : Error function type]
 }

 package b {
    public fun bar(): [ERROR : Error function type]
-    public fun foo(): kotlin.Any?
+    public fun foo(): [ERROR : Error function type]
 }

 package c {
-    public fun bar(): kotlin.Any?
-    public fun bazz(): kotlin.Any?
+    public fun bar(): [ERROR : Error function type]
+    public fun bazz(): [ERROR : Error function type]
    public fun foo(): [ERROR : Error function type]
 }

@@ -28,7 +28,7 @@ abstract class My(<!WRONG_ANNOTATION_TARGET!>@Field<!> arg: Int, @Field val w: I
    fun foo() {}

    <!WRONG_ANNOTATION_TARGET!>@Field<!>
-    val v: Int by <!NI;DELEGATE_SPECIAL_FUNCTION_MISSING!><!UNRESOLVED_REFERENCE!>Delegates<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>lazy<!> { 42 }<!>
+    val v: Int by <!UNRESOLVED_REFERENCE!>Delegates<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>lazy<!> { 42 }
 }

 enum class Your {
@@ -1,6 +1,6 @@
 package

-public fun test(/*0*/ tr: Tr): Tr
+public fun test(/*0*/ tr: Tr): [ERROR : G]

 public interface G</*0*/ T> {
    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
@@ -29,7 +29,7 @@ private fun <T> lazy(init: () -> T): kotlin.<!UNRESOLVED_REFERENCE!>Lazy<!><T> {
 }

 object DefaultHttpClientWithBy : HttpClient by client {
-    val client by <!NI;DELEGATE_SPECIAL_FUNCTION_MISSING!>lazy { HttpClientImpl() }<!>
+    val client by lazy { HttpClientImpl() }
 }

 object DefaultFqHttpClient : HttpClient by DefaultFqHttpClient.<!UNINITIALIZED_VARIABLE!>client<!> {
@@ -21,7 +21,7 @@ public object DefaultHttpClient : HttpClient {

 public object DefaultHttpClientWithBy : HttpClient {
    private constructor DefaultHttpClientWithBy()
-    public final val client: [ERROR : Type from delegate]
+    public final val client: [ERROR : <ERROR FUNCTION RETURN TYPE>]
    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
@@ -1,4 +1,6 @@
+// !WITH_NEW_INFERENCE
 // See KT-6665: unresolved reference (v.bar) should not produce "unreachable code" after it
+
 fun foo(): Int {
    val v = 1
    val <!UNUSED_VARIABLE!>c<!> = v.<!UNRESOLVED_REFERENCE!>bar<!> ?: return 0
@@ -27,14 +29,14 @@ fun foo3(): Int {
 fun bar(): Int {
    val v = 1
    val c = v.<!UNRESOLVED_REFERENCE!>bar<!> ?: 42
-    return c
+    return <!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>c<!>
 }

 fun bar2(): Int {
    val v = 1
    val c = if (true) v.<!UNRESOLVED_REFERENCE!>bar<!> else 3
-    val b = c
-    return b
+    val b = <!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>c<!>
+    return <!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>b<!>
 }

 fun bar3(): Int {
@@ -43,6 +45,6 @@ fun bar3(): Int {
        true -> v.<!UNRESOLVED_REFERENCE!>bar<!>
        else -> 3
    }
-    val b = c
-    return b
+    val b = <!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>c<!>
+    return <!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>b<!>
 }
@@ -1,8 +1,8 @@
 // !WITH_NEW_INFERENCE
 fun useDeclaredVariables() {
    for ((a, b)<!SYNTAX!><!>) {
-        <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, UNUSED_EXPRESSION!>a<!>
-        <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, UNUSED_EXPRESSION!>b<!>
+        <!UNUSED_EXPRESSION, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!>
+        <!UNUSED_EXPRESSION, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>b<!>
    }
 }

@@ -1,9 +1,10 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE
 // NI_EXPECTED_FILE
 import kotlin.reflect.KProperty

 var a: Int by A()
-var a1 by <!DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>A()<!>
+var a1 by <!OI;DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE, DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE!>A()<!>

 var b: Int by B()

@@ -8,7 +8,7 @@ val a by <!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, OI;TYPECHECKER_HAS_RUN_INTO_RE

 val b by Delegate(<!OI;TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>b<!>)

-val c by <!NI;DELEGATE_SPECIAL_FUNCTION_MISSING, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, UNINITIALIZED_VARIABLE!>d<!>
+val c by <!UNINITIALIZED_VARIABLE, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>d<!>
 val d by <!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, OI;TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>c<!>

 class Delegate(i: Int) {
@@ -1,9 +1,9 @@
 package

-public val a: kotlin.Any?
+public val a: [ERROR : <ERROR FUNCTION RETURN TYPE>]
 public val b: kotlin.Int
-public val c: [ERROR : Type from delegate]
-public val d: kotlin.Any?
+public val c: [ERROR : <ERROR FUNCTION RETURN TYPE>]
+public val d: [ERROR : <ERROR FUNCTION RETURN TYPE>]

 public final class Delegate {
    public constructor Delegate(/*0*/ i: kotlin.Int)
@@ -2,6 +2,6 @@
 enum class E : Cloneable {
    A;
    <!OVERRIDING_FINAL_MEMBER!>override<!> fun clone(): Any {
-        return <!NI;TYPE_MISMATCH!><!AMBIGUOUS_SUPER!>super<!>.<!NI;TYPE_MISMATCH!><!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>clone<!>()<!><!>
+        return <!AMBIGUOUS_SUPER!>super<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>clone<!>()
    }
 }
@@ -10,7 +10,7 @@ val returnTypeWithParameter = { (<!COMPONENT_FUNCTION_MISSING!><!UNUSED_DESTRUCT

 val receiverWithFunctionType = { ((Int)<!SYNTAX!><!> <!SYNTAX!>-> Int).() -><!> }

-val parenthesizedParameters = { <!CANNOT_INFER_PARAMETER_TYPE!>(<!NI;TYPE_MISMATCH!><!UNUSED_DESTRUCTURED_PARAMETER_ENTRY!>a<!>: Int<!>)<!> -> }
+val parenthesizedParameters = { <!CANNOT_INFER_PARAMETER_TYPE!>(<!UNUSED_DESTRUCTURED_PARAMETER_ENTRY!>a<!>: Int)<!> -> }
 val parenthesizedParameters2 = { <!CANNOT_INFER_PARAMETER_TYPE!>(<!UNUSED_DESTRUCTURED_PARAMETER_ENTRY!>b<!>)<!> -> }

 val none = { -> }
@@ -25,7 +25,7 @@ fun bar() {

    y2 checkType { _<(A) -> Unit>() }

-    val z = { <!CANNOT_INFER_PARAMETER_TYPE!>(<!NI;TYPE_MISMATCH!>a: Int<!>, <!NI;TYPE_MISMATCH!>b: String<!>)<!> ->
+    val z = { <!CANNOT_INFER_PARAMETER_TYPE!>(a: Int, b: String)<!> ->
        <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
        <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>b<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><String>() }
    }
@@ -1,18 +1,18 @@
 // !WITH_NEW_INFERENCE
 fun test() {
    run {<!RETURN_NOT_ALLOWED!>return<!>}
-    <!NI;UNREACHABLE_CODE!>run {}<!>
+    run {}
 }

 fun test2() {
    run {<!RETURN_NOT_ALLOWED!>return@test2<!>}
-    <!NI;UNREACHABLE_CODE!>run {}<!>
+    run {}
 }

 fun test3() {
    fun test4() {
        run {<!RETURN_NOT_ALLOWED!>return@test3<!>}
-        <!NI;UNREACHABLE_CODE!>run {}<!>
+        run {}
    }
 }

@@ -72,5 +72,5 @@ fun test(b: B) {
    b_3.m2()

    val b_4 = <!UNRESOLVED_REFERENCE!>a<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>B<!>()
-    <!OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>b_4<!>.<!NI;UNRESOLVED_REFERENCE, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>m2<!>()
+    <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>b_4<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>m2<!>()
 }
@@ -82,7 +82,7 @@ object C {
 }

 fun foo() {
-    if (<!UNRESOLVED_REFERENCE!>i<!> <!NI;RESULT_TYPE_MISMATCH, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>==<!> 3) <!UNRESOLVED_REFERENCE!>f<!>()
+    if (<!UNRESOLVED_REFERENCE!>i<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>==<!> 3) <!UNRESOLVED_REFERENCE!>f<!>()
 }

 //FILE:d.kt
@@ -3,7 +3,7 @@ package a

 fun foo() {
    val a = <!UNRESOLVED_REFERENCE!>getErrorType<!>()
-    if (<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!> <!NI;RESULT_TYPE_MISMATCH, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>==<!> null) { //no senseless comparison
+    if (<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>a<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>==<!> null) { //no senseless comparison

    }
 }
@@ -4,5 +4,5 @@ package bar
 fun main(args : Array<String>) {
    class Some

-    <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!><!NO_COMPANION_OBJECT!>Some<!>[<!SYNTAX!><!>]<!> <!NI;UNRESOLVED_REFERENCE, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>names<!> <!DEBUG_INFO_MISSING_UNRESOLVED!><!SYNTAX!>=<!> ["ads"]<!>
+    <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!><!NO_COMPANION_OBJECT!>Some<!>[<!SYNTAX!><!>]<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>names<!> <!DEBUG_INFO_MISSING_UNRESOLVED!><!SYNTAX!>=<!> ["ads"]<!>
 }
@@ -3,7 +3,7 @@ fun foo() {
    fun bar1() = <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!NI;DEBUG_INFO_MISSING_UNRESOLVED!>bar1<!>()<!>

    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 bar3() = id(<!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!><!NI;DEBUG_INFO_MISSING_UNRESOLVED!>bar3<!>()<!>)
 }

 fun <T> id(x: T) = x
@@ -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>? = <!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)<!><!>
+fun <T, Q> List<T>.map3(f: (T)-> Q): List<T>? = <!OI;TYPE_MISMATCH!>tail<!>.<!NI;DEBUG_INFO_UNRESOLVED_WITH_TARGET, NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>sure<!><<!OI;UPPER_BOUND_VIOLATED!>T<!>>().<!NI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, OI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>map3<!>(f)
@@ -202,7 +202,7 @@ fun mergeSmartCasts(a: Any?) {
    val <!UNUSED_VARIABLE!>i<!>: Int = <!DEBUG_INFO_SMARTCAST!>a<!>.compareTo("")
  }
  if (a is String && <!DEBUG_INFO_SMARTCAST!>a<!>.compareTo("") == 0) {}
-  if (a is String || a.<!UNRESOLVED_REFERENCE!>compareTo<!>("") <!NI;RESULT_TYPE_MISMATCH, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>==<!> 0) {}
+  if (a is String || a.<!UNRESOLVED_REFERENCE!>compareTo<!>("") <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>==<!> 0) {}
 }

 //mutability
@@ -18,16 +18,16 @@ public final class Outer : Trait {

    public final class Nested {
        public constructor Nested()
-        public final val s: kotlin.Any?
-        public final val t: kotlin.Any?
+        public final val s: [ERROR : <ERROR FUNCTION RETURN TYPE>]
+        public final val t: [ERROR : <ERROR FUNCTION RETURN TYPE>]
        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String

        public final inner class NestedInner {
            public constructor NestedInner()
-            public final val s: kotlin.Any?
-            public final val t: kotlin.Any?
+            public final val s: [ERROR : <ERROR FUNCTION RETURN TYPE>]
+            public final val t: [ERROR : <ERROR FUNCTION RETURN TYPE>]
            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
@@ -35,7 +35,7 @@ public final class Outer {
        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
        public final fun f(): [ERROR : Error function type]
        public final fun g(): [ERROR : Error function type]
-        public final fun h(): kotlin.Any?
+        public final fun h(): [ERROR : <ERROR FUNCTION RETURN TYPE>]
        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
        public final fun i(): [ERROR : <ERROR PROPERTY TYPE>]
        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
@@ -37,7 +37,7 @@ fun test() {
        takeNotNull(dependOn(dependOn(x) as? String) <!NI;USELESS_ELVIS!>?: ""<!>)
    }

-    takeNotNull(<!NI;TYPE_MISMATCH!>bar()!!<!>)
+    takeNotNull(bar()!!)
 }

 inline fun <reified T : Any> reifiedNull(): T? = null
@@ -1,7 +1,7 @@
 package

 package localObjects {
-    public val bb: kotlin.Any?
+    public val bb: [ERROR : <ERROR FUNCTION RETURN TYPE>]
    public fun test(): kotlin.Unit

    public object A {
@@ -1,4 +1,5 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE -SENSELESS_COMPARISON, -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE

 // FILE: J.java

@@ -61,7 +62,7 @@ fun test() {
    takeNotNull(J.getNAny() ?: J())

    val x = <!UNRESOLVED_REFERENCE!>unresolved<!> ?: null
-    <!UNREACHABLE_CODE!>val y =<!> <!UNRESOLVED_REFERENCE!>unresolved<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>foo<!> ?: return
+    <!OI;UNREACHABLE_CODE!>val y =<!> <!UNRESOLVED_REFERENCE!>unresolved<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>foo<!> ?: return
 }

 fun takeNotNull(s: J) {}
@@ -10,7 +10,7 @@ class A {
    val a get() = <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>b<!>
    val b get() = <!NI;DEBUG_INFO_MISSING_UNRESOLVED, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>a<!>

-    val <!NI;IMPLICIT_NOTHING_PROPERTY_TYPE!>z1<!> get() = id(<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>z1<!>)
+    val z1 get() = id(<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>z1<!>)
    val z2 get() = l(<!NI;DEBUG_INFO_MISSING_UNRESOLVED, OI;DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>z2<!>)

    val u get() = <!UNRESOLVED_REFERENCE!>field<!>
@@ -10,8 +10,8 @@ public final class A {
    public final val b: [ERROR : Error function type]
    public final val u: [ERROR : Error function type]
    public final val y: [ERROR : Error function type]
-    public final val z1: kotlin.Nothing
-    public final val z2: kotlin.collections.List<kotlin.Nothing>
+    public final val z1: [ERROR : Error type for ParseError-argument VALUE_ARGUMENT]
+    public final val z2: kotlin.collections.List<[ERROR : Error type for ParseError-argument VALUE_ARGUMENT]>
    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
@@ -1,4 +1,5 @@
 // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -UNREACHABLE_CODE
+// !WITH_NEW_INFERENCE

 class A {
    class B {
@@ -1,2 +1,2 @@
 // !WITH_NEW_INFERENCE
-val unwrapped = <!UNRESOLVED_REFERENCE!>some<!><!NI;COMPARE_TO_TYPE_MISMATCH, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!><<!><!DEBUG_INFO_MISSING_UNRESOLVED!>sdf<!>()()<out <!DEBUG_INFO_MISSING_UNRESOLVED!>Any<!>>::<!DEBUG_INFO_MISSING_UNRESOLVED!>unwrap<!>
+val unwrapped = <!UNRESOLVED_REFERENCE!>some<!><!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!><<!><!DEBUG_INFO_MISSING_UNRESOLVED!>sdf<!>()()<out <!DEBUG_INFO_MISSING_UNRESOLVED!>Any<!>>::<!DEBUG_INFO_MISSING_UNRESOLVED!>unwrap<!>
@@ -1,3 +1,3 @@
 package

-public val unwrapped: kotlin.Any?
+public val unwrapped: [ERROR : <ERROR FUNCTION RETURN TYPE>]
@@ -8,9 +8,9 @@ fun composite() {
 }

 fun html() {
-    <!SYNTAX!><<!><!FUNCTION_CALL_EXPECTED!>html<!><!UNRESOLVED_REFERENCE!>><!><!SYNTAX!><<!><!DEBUG_INFO_MISSING_UNRESOLVED!>/<!><!DEBUG_INFO_MISSING_UNRESOLVED!>html<!><!NI;COMPARE_TO_TYPE_MISMATCH, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>><!><!SYNTAX!><!>
+    <!SYNTAX!><<!><!FUNCTION_CALL_EXPECTED!>html<!><!UNRESOLVED_REFERENCE!>><!><!SYNTAX!><<!><!DEBUG_INFO_MISSING_UNRESOLVED!>/<!><!DEBUG_INFO_MISSING_UNRESOLVED!>html<!><!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>><!><!SYNTAX!><!>
 }

 fun html1() {
-    <!SYNTAX!><<!><!FUNCTION_CALL_EXPECTED!>html<!><!UNRESOLVED_REFERENCE!>><!><!SYNTAX!><<!><!DEBUG_INFO_MISSING_UNRESOLVED!>/<!><!DEBUG_INFO_MISSING_UNRESOLVED!>html<!><!NI;COMPARE_TO_TYPE_MISMATCH, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>><!><!FUNCTION_CALL_EXPECTED!>html<!>
+    <!SYNTAX!><<!><!FUNCTION_CALL_EXPECTED!>html<!><!UNRESOLVED_REFERENCE!>><!><!SYNTAX!><<!><!DEBUG_INFO_MISSING_UNRESOLVED!>/<!><!DEBUG_INFO_MISSING_UNRESOLVED!>html<!><!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>><!><!FUNCTION_CALL_EXPECTED!>html<!>
 }
@@ -4,7 +4,7 @@ private fun doUpdateRegularTasks() {
    try {
        while (f) {
            val xmlText = <!UNRESOLVED_REFERENCE!>getText<!>()
-            if (<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>xmlText<!> <!NI;RESULT_TYPE_MISMATCH, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>==<!> null) {}
+            if (<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>xmlText<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>==<!> null) {}
            else {
                <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>xmlText<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>value<!> = 0 // !!!
            }
@@ -2,7 +2,7 @@ package

 package i {
    public val i.C.bar: i.C.D
-    public val kotlin.String.bd: kotlin.Any?
+    public val kotlin.String.bd: [ERROR : <ERROR FUNCTION RETURN TYPE>]
    public val kotlin.String.bd1: kotlin.String
    public val i.A.foo: [ERROR : Type for ii]
    public val i.C.foo: i.C.D
@@ -12,7 +12,7 @@ operator fun Long?.inc() = this?.let { it + 1 }
 fun bar(arg: Long?): Long {
    var i = arg
    if (i++ == 5L) {
-        return <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>i<!UNSAFE_CALL!>--<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> i<!>
+        return i<!UNSAFE_CALL!>--<!> <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>+<!> i
    }
    if (i++ == 7L) {
        return i++ <!NI;NONE_APPLICABLE, OI;UNSAFE_OPERATOR_CALL!>+<!> <!OI;TYPE_MISMATCH!>i<!>
@@ -14,7 +14,7 @@ class GenericDerivedClass<T> : GenericBaseClass<T>(), GenericBaseInterface<T> {
    override fun bar(x: T): T = super.bar(x)

    override fun ambiguous(x: T): T =
-            <!NI;TYPE_MISMATCH!><!AMBIGUOUS_SUPER!>super<!>.<!NI;TYPE_MISMATCH!><!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>ambiguous<!>(x)<!><!>
+            <!AMBIGUOUS_SUPER!>super<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>ambiguous<!>(x)
 }

 class <!CONFLICTING_JVM_DECLARATIONS!>SpecializedDerivedClass<!> : GenericBaseClass<Int>(), GenericBaseInterface<String> {
@@ -22,9 +22,9 @@ class <!CONFLICTING_JVM_DECLARATIONS!>SpecializedDerivedClass<!> : GenericBaseCl
    override fun bar(x: String): String = super.bar(x)

    override fun ambiguous(x: String): String =
-            <!NI;TYPE_MISMATCH!><!AMBIGUOUS_SUPER!>super<!>.<!NI;TYPE_MISMATCH!><!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>ambiguous<!>(x)<!><!>
+            <!AMBIGUOUS_SUPER!>super<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>ambiguous<!>(x)
    override fun ambiguous(x: Int): Int =
-            <!NI;TYPE_MISMATCH!><!AMBIGUOUS_SUPER!>super<!>.<!NI;TYPE_MISMATCH!><!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>ambiguous<!>(x)<!><!>
+            <!AMBIGUOUS_SUPER!>super<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>ambiguous<!>(x)
 }

 class <!CONFLICTING_JVM_DECLARATIONS!>MixedDerivedClass<!><T> : GenericBaseClass<Int>(), GenericBaseInterface<T> {
@@ -32,7 +32,7 @@ class <!CONFLICTING_JVM_DECLARATIONS!>MixedDerivedClass<!><T> : GenericBaseClass
    override fun bar(x: T): T = super.bar(x)

    override fun ambiguous(x: Int): Int =
-            <!NI;TYPE_MISMATCH!><!AMBIGUOUS_SUPER!>super<!>.<!NI;TYPE_MISMATCH!><!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>ambiguous<!>(x)<!><!>
+            <!AMBIGUOUS_SUPER!>super<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>ambiguous<!>(x)
    <!CONFLICTING_JVM_DECLARATIONS!>override fun ambiguous(x: T): T<!> =
-            <!NI;TYPE_MISMATCH!><!AMBIGUOUS_SUPER!>super<!>.<!NI;TYPE_MISMATCH!><!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>ambiguous<!>(x)<!><!>
+            <!AMBIGUOUS_SUPER!>super<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>ambiguous<!>(x)
 }
@@ -14,7 +14,7 @@ interface InterfaceWithFun {

 class DerivedUsingFun : BaseWithCallableProp(), InterfaceWithFun {
    fun foo(): String =
-    <!NI;TYPE_MISMATCH!><!AMBIGUOUS_SUPER!>super<!>.<!NI;TYPE_MISMATCH!><!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>fn<!>()<!><!>
+    <!AMBIGUOUS_SUPER!>super<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>fn<!>()

    override fun bar(): String =
            super.bar()
@@ -3,7 +3,7 @@ package
 public val c: [ERROR : Type for C.Self.Self()]
 public val ic: [ERROR : Type for C.Self.InCompanion()]
 public val n: [ERROR : Type for C.Self.Nested()]
-public val n2: kotlin.Any?
+public val n2: [ERROR : <ERROR FUNCTION RETURN TYPE>]
 public val ok: kotlin.String = "OK"
 public val x: [ERROR : Type for C.Self.X]