[FIR] Implement UNRESOLVED_REFERENCE_WRONG_RECEIVER

2021-08-10 16:40:51 +03:00
parent 34cc7e5199
commit 84c5f58cab
129 changed files with 322 additions and 481 deletions
@@ -34,7 +34,7 @@ fun test() {
    bar<Int>()
    bar<<!UPPER_BOUND_VIOLATED!>Double?<!>>()
    bar<<!UPPER_BOUND_VIOLATED!>Double<!>>()
-    1.<!INAPPLICABLE_CANDIDATE!>buzz<!><Double>()
+    1.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>buzz<!><Double>()
 }

 fun <T : Any> foo() {}
@@ -15,7 +15,7 @@ operator fun String.unaryPlus(): Int = 0
 fun test() {
    requireInt(+ "")
    requireInt(+ Example())
-    requireString(<!ARGUMENT_TYPE_MISMATCH!><!INAPPLICABLE_CANDIDATE!>+<!> ExampleDeprecated()<!>)
+    requireString(<!ARGUMENT_TYPE_MISMATCH!><!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>+<!> ExampleDeprecated()<!>)
 }

 fun requireInt(n: Int) {}
@@ -26,7 +26,7 @@ class Example2 {
    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun minus() = this

    fun test() {
-        <!INAPPLICABLE_CANDIDATE!>+<!>this
+        <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>+<!>this
        <!UNRESOLVED_REFERENCE!>-<!>this
    }
 }
@@ -21,10 +21,10 @@ import kotlin.reflect.KProperty0
 import kotlin.reflect.KProperty1

 fun case() {
-    (V)::a checkType { <!INAPPLICABLE_CANDIDATE!>_<!><KProperty0<Int>>() }
+    (V)::a checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><KProperty0<Int>>() }
    (V)::a checkType { _<KProperty1<V, String>>() }

-    (test.abc.V)::a checkType { <!INAPPLICABLE_CANDIDATE!>_<!><KProperty0<Int>>() }
+    (test.abc.V)::a checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><KProperty0<Int>>() }
    (test.abc.V)::a checkType { _<KProperty1<V, String>>() }

    V::a checkType { _<KProperty1<V, String>>() }
@@ -15,7 +15,7 @@ fun test1() {
    bar("", 1, ::foo).checkType { _<Pair<String, Int>>() }
    bar("", 1, ::fooReturnInt).checkType { _<Pair<String, Int>>() }
    bar("", 1, ::fooTakeString).checkType { _<Pair<String, Int>>() }
-    bar("", "", ::fooReturnInt).checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Pair<String, Any>>() }
+    bar("", "", ::fooReturnInt).checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Pair<String, Any>>() }

    val x: String = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>bar("", "", ::fooReturnInt)<!>

@@ -10,6 +10,6 @@ fun A.foo() = ""

 class A {
    fun main() {
-        <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>(::<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>) <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<String>() }
+        <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>bar<!>(::<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>) <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>checkType<!> { _<String>() }
    }
 }
@@ -1,11 +0,0 @@
-// !CHECK_TYPE
-
-interface A
-interface B : A
-interface C : B
-
-fun test(b: B) {
-    b checkType { _<B>() }
-    b checkType { <!INAPPLICABLE_CANDIDATE!>_<!><A>() }
-    b checkType { <!INAPPLICABLE_CANDIDATE!>_<!><C>() }
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE

 interface A
@@ -19,5 +19,5 @@ fun check() {
    val f: IntArray = [1]
    [f] checkType { _<Array<IntArray>>() }

-    [1, ""] checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Array<Any>>() }
+    [1, ""] checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Array<Any>>() }
 }
@@ -1,20 +0,0 @@
-// !CHECK_TYPE
-// FILE: A.java
-public class A {
-    public static String foo() {
-        return "";
-    }
-}
-
-// FILE: b.kt
-fun <T: Any> exclExcl(t: T?): T = t!!
-
-fun test11() {
-    // not 'String!'
-    exclExcl(A.foo()) checkType { _<String>() }
-    exclExcl(A.foo()) checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String?>() }
-
-    // not 'String!'
-    A.foo()!! checkType { _<String>() }
-    A.foo()!! checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String?>() }
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE
 // FILE: A.java
 public class A {
@@ -4,7 +4,7 @@ fun foo(block: () -> (() -> Int)) {}

 fun test() {
    val x = <!ANONYMOUS_FUNCTION_WITH_NAME!>fun named1(x: Int): Int { return 1 }<!>
-    x <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<Function1<Int, Int>>() }
+    x <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>checkType<!> { _<Function1<Int, Int>>() }

    foo { fun named2(): Int {return 1} }
    foo({ fun named3() = 1 })
@@ -1,19 +0,0 @@
-interface Tr
-
-class A { companion object }
-class B { companion object : Tr }
-
-fun Any.f1() {}
-fun Any?.f2() {}
-fun Tr.f3() {}
-fun Tr?.f4() {}
-fun A.f5() {}
-
-fun test() {
-    A.f1()
-    A.f2()
-    B.f3()
-    B.f4()
-    A.<!INAPPLICABLE_CANDIDATE!>f5<!>()
-    B.<!INAPPLICABLE_CANDIDATE!>f5<!>()
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 interface Tr

 class A { companion object }
@@ -1,16 +0,0 @@
-// KT-3563 Compiler requiring java.io.File, and it's unclear why
-
-package bar
-
-import java.io.File
-
-class Customer(name1: String)
-
-fun foo(f: File, c: Customer) {
-    f.name1
-
-    c.<!INAPPLICABLE_CANDIDATE!>name1<!> // name1 should be unresolved here
-}
-
-val File.name1: String
-    get() = getName()
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // KT-3563 Compiler requiring java.io.File, and it's unclear why

 package bar
@@ -6,19 +6,19 @@ package bar
 fun <R> List<R>.a() {}

 fun test1(i: Int?) {
-    1.<!INAPPLICABLE_CANDIDATE!>a<!>()
-    i.<!INAPPLICABLE_CANDIDATE!>a<!>()
+    1.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>a<!>()
+    i.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>a<!>()
 }

 fun <R> test2(c: Collection<R>) {
-    c.<!INAPPLICABLE_CANDIDATE!>a<!>()
+    c.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>a<!>()
 }

 fun Int.foo() {}

 fun test3(s: String?) {
-    "".<!INAPPLICABLE_CANDIDATE!>foo<!>()
-    s.<!INAPPLICABLE_CANDIDATE!>foo<!>()
+    "".<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>foo<!>()
+    s.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>foo<!>()
    "".foo(<!TOO_MANY_ARGUMENTS!>1<!>)
    s.foo(<!TOO_MANY_ARGUMENTS!>"a"<!>)
 }
@@ -27,7 +27,7 @@ interface A
 fun <T: A> T.c() {}

 fun test4() {
-    1.<!INAPPLICABLE_CANDIDATE!>c<!>()
+    1.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>c<!>()
 }


@@ -40,16 +40,16 @@ fun test5() {
 fun <R: Any> R?.sure() : R = this!!

 fun <T> test6(l: List<T>?) {
-    l.<!INAPPLICABLE_CANDIDATE!>sure<!><T>()
+    l.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>sure<!><T>()
 }


 fun List<String>.b() {}

 fun test7(l: List<String?>) {
-    l.<!INAPPLICABLE_CANDIDATE!>b<!>()
+    l.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>b<!>()
 }

 fun test8(l: List<Any>?) {
-    l.<!INAPPLICABLE_CANDIDATE!>b<!>()
+    l.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>b<!>()
 }
@@ -1,14 +0,0 @@
-package a
-
-class A {}
-
-fun test(a1: A, a2: A) {
-    val range = "island".."isle"
-
-    a1<!INAPPLICABLE_CANDIDATE!>..<!>a2
-}
-
-
-public operator fun <T: Comparable<T>> T.rangeTo(that: T): ClosedRange<T> {
-    throw UnsupportedOperationException()
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 package a

 class A {}
@@ -5,5 +5,5 @@ fun interface Bar {
 operator fun Bar.plus(b: Bar): String = invoke() + b.invoke()

 fun box(): String {
-    return { "O" } <!INAPPLICABLE_CANDIDATE!>+<!> { "K" }
+    return { "O" } <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>+<!> { "K" }
 }
@@ -31,8 +31,8 @@ fun bar(aInstance: A, bInstance: B) {

    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>(bInstance) {
        <!CANNOT_INFER_PARAMETER_TYPE, COMPONENT_FUNCTION_MISSING, COMPONENT_FUNCTION_MISSING!>(a, b)<!>, (c, d) ->
-        a <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<Int>() }
-        b <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<String>() }
+        a <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>checkType<!> { _<Int>() }
+        b <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>checkType<!> { _<String>() }
        c checkType { _<Double>() }
        d checkType { _<Short>() }
    }
@@ -22,12 +22,12 @@ fun bar(aList: List<A>) {
    }

    aList.foo { (<!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>a: String<!>, b) ->
-        a checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+        a checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Int>() }
        b checkType { _<String>() }
    }

    aList.foo <!ARGUMENT_TYPE_MISMATCH!>{ (a, b): B ->
-        b checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
-        a checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+        b checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Int>() }
+        a checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String>() }
    }<!>
 }
@@ -18,7 +18,7 @@ fun bar() {
    y checkType { _<(A) -> Unit>() }

    val y2 = { (a: Number, b): A ->
-        a checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+        a checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Int>() }
        b checkType { _<String>() }
    }

@@ -7,8 +7,8 @@ fun foo(block: (A, B) -> Unit) { }

 fun bar() {
    foo { (a, a), b ->
-        a checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
-        b checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+        a checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Int>() }
+        b checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String>() }
    }

    foo { (a, b), a ->
@@ -17,13 +17,13 @@ fun bar() {
    }

    foo { a, (a, b) ->
-        a checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
-        b checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+        a checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Int>() }
+        b checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String>() }
    }

    foo { (a, b), (c, b) ->
        a checkType { _<Int>() }
-        b checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
-        c checkType { <!INAPPLICABLE_CANDIDATE!>_<!><B>() }
+        b checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String>() }
+        c checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><B>() }
    }
 }
@@ -42,7 +42,7 @@ fun bar() {
    }

    foo { (<!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>a: String<!>, b) ->
-        a checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+        a checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Int>() }
        b checkType { _<String>() }
    }

@@ -24,9 +24,9 @@ private class Outer<E> {

            doubleStringInt = Outer<Double>().Inner<String>().foo<Int>()()

-            doubleStringInt.e.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
-            doubleStringInt.f.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
-            doubleStringInt.g.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+            doubleStringInt.e.checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Double>() }
+            doubleStringInt.f.checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String>() }
+            doubleStringInt.g.checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Int>() }
        }
    }
 }
@@ -18,7 +18,7 @@ class Q {
        x = foo<CharSequence>()()
        y = foo<String>()()

-        x.prop.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><CharSequence>() }
-        y.prop.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+        x.prop.checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><CharSequence>() }
+        y.prop.checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String>() }
    }
 }
@@ -15,8 +15,8 @@ class Q {
    private var x = foo<CharSequence, Number>()()

    fun bar() {
-        x.e.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><CharSequence>() }
-        x.f.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Number>() }
+        x.e.checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><CharSequence>() }
+        x.f.checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Number>() }
        x.g.checkType { _<Number>() }
    }
 }
@@ -20,7 +20,7 @@ class A : Outer<Double, Short>() {

 fun foo() {
    Derived().foo() checkType { _<Outer<String, Int>.Inner<Char>>() }
-    Derived().baz() <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<Map<Char, String>>() }
+    Derived().baz() <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>checkType<!> { _<Map<Char, String>>() }
    A.B().bar() checkType { _<Outer<Float, Long>.Inner<String>>() }
-    A.B().x() <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<Map<String, Float>>() }
+    A.B().x() <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>checkType<!> { _<Map<String, Float>>() }
 }
@@ -41,8 +41,8 @@ fun test() {
    var x = foobar<String>()
    x = foobar<String>()

-    x().foo().a() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><A<String, Double, Short, Long>>() }
-    x().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<A<String, Double, Short, Char>>() }
+    x().foo().a() checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><A<String, Double, Short, Long>>() }
+    x().bar() <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>checkType<!> { _<A<String, Double, Short, Char>>() }

    x = foobar<Int>()

@@ -50,5 +50,5 @@ fun test() {
    y = noParameters()

    y().foo().a() checkType { _<A<Any, Double, Short, Long>>() }
-    y().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<A<Any, Double, Short, Char>>() }
+    y().bar() <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>checkType<!> { _<A<Any, Double, Short, Char>>() }
 }
@@ -42,8 +42,8 @@ class Outer<T> {
            var x = foobar<String>()
            x = foobar<String>()

-            x().foo().a() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><A<T, F, String, Double, Short, Long>>() }
-            x().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<A<T, F, String, Double, Short, Char>>() }
+            x().foo().a() checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><A<T, F, String, Double, Short, Long>>() }
+            x().bar() <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>checkType<!> { _<A<T, F, String, Double, Short, Char>>() }

            x = foobar<Int>()
            x = z.foobar<String>()
@@ -52,7 +52,7 @@ class Outer<T> {
            y = noParameters()

            y().foo().a() checkType { _<A<T, F, Any, Double, Short, Long>>() }
-            y().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<A<T, F, Any, Double, Short, Char>>() }
+            y().bar() <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>checkType<!> { _<A<T, F, Any, Double, Short, Char>>() }
        }
    }
 }
@@ -15,5 +15,5 @@ class Derived : BaseDerived2<Int>() {

 fun foo() {
    Derived().foo() checkType { _<Outer<Int, String>.Inner<Char>>() }
-    Derived().baz() <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<Map<Char, Int>>() }
+    Derived().baz() <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>checkType<!> { _<Map<Char, Int>>() }
 }
@@ -32,5 +32,5 @@ fun foo() {

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

-    commonSupertype(A<String>().iterator(), A<Int>().iterator()).checkType { <!INAPPLICABLE_CANDIDATE!>_<!><A<out Any>.MyIt>() }
+    commonSupertype(A<String>().iterator(), A<Int>().iterator()).checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><A<out Any>.MyIt>() }
 }
@@ -5,7 +5,7 @@ class Outer<T> {
    inner class Inner
    fun foo(x: Outer<String>.Inner, y: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer<!>.Inner, z: Inner) {
        var inner = Inner()
-        x.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Inner>() }
+        x.checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Inner>() }
        x.checkType { _<Outer<String>.Inner>() }
        z.checkType { _<Inner>() }
        z.checkType { _<Outer<T>.Inner>() }
@@ -1,46 +0,0 @@
-// !CHECK_TYPE
-// Incorrect "type mismatch" error for generic extension safe call (required not-null, found nullable)
-
-// FILE: B.java
-
-public class B<T> {
-    public String gav() {
-        return "";
-    }
-
-    public static <T> B<T> create() {
-        return new B();
-    }
-}
-
-// FILE: A.kt
-
-class A<T> {
-    fun gav() = ""
-}
-fun <R> foo(x: R) = x
-fun <T> A<T>.bar() = ""
-fun <T> B<T>.bar() = ""
-
-fun foo(l: A<String>?) {
-    // No errors should be here
-    foo(l?.bar()) checkType { _<String?>() }
-    foo(l?.gav()) checkType { _<String?>() }
-    if (l != null) {
-        foo(l<!UNNECESSARY_SAFE_CALL!>?.<!>bar()) checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
-        foo(l<!UNNECESSARY_SAFE_CALL!>?.<!>gav()) checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
-    }
-}
-
-fun fooNotNull(l: A<String>) {
-    // No errors should be here
-    foo(l<!UNNECESSARY_SAFE_CALL!>?.<!>bar()) checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
-    foo(l<!UNNECESSARY_SAFE_CALL!>?.<!>gav()) checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
-}
-
-fun bar() {
-    val l = B.create<String>()
-    foo(l?.bar()) checkType { _<String?>() }
-    foo(l?.gav()) checkType { _<String?>() }
-}
-
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE
 // Incorrect "type mismatch" error for generic extension safe call (required not-null, found nullable)

@@ -15,5 +15,5 @@ fun <T> test(a: T) where T : B, T : C {
    a.foo = ""
    a.foo = null

-    a.foo.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+    a.foo.checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String>() }
 }
@@ -13,6 +13,6 @@ fun <F : String?> bar(x: F) {
    foo1<<!UPPER_BOUND_VIOLATED!>F<!>>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)

    x<!UNSAFE_CALL!>.<!>foo2()
-    x.<!INAPPLICABLE_CANDIDATE!>foo2<!><F>()
+    x.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>foo2<!><F>()
 }

@@ -1,17 +0,0 @@
-class A<T> {
-    fun T.foo() {}
-    fun Out<T>.bar() {}
-}
-class Out<out E>
-
-fun test(x: A<out CharSequence>, y: Out<CharSequence>) {
-    with(x) {
-        // TODO: this diagnostic could be replaced with TYPE_MISMATCH_DUE_TO_TYPE_PROJECTION
-        "".<!INAPPLICABLE_CANDIDATE!>foo<!>()
-        y.<!INAPPLICABLE_CANDIDATE!>bar<!>()
-
-        with(y) {
-            <!INAPPLICABLE_CANDIDATE!>bar<!>()
-        }
-    }
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 class A<T> {
    fun T.foo() {}
    fun Out<T>.bar() {}
@@ -10,5 +10,5 @@ fun main() {
    val c : ListOfLists<*> = b
    val d : ArrayList<ArrayList<*>> = <!INITIALIZER_TYPE_MISMATCH!>c.x<!>

-    c.x checkType { <!INAPPLICABLE_CANDIDATE!>_<!><ArrayList<out ArrayList<*>>>() }
+    c.x checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><ArrayList<out ArrayList<*>>>() }
 }
@@ -9,10 +9,10 @@ public class Clazz<T> {
 // FILE: main.kt
 fun test(clazz: Clazz<*>) {
    clazz.t checkType { _<Any?>() }
-    clazz.getSuperClass() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Clazz<*>?>() }
+    clazz.getSuperClass() checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Clazz<*>?>() }
    clazz.getSuperClass().t checkType { _<Any?>() }

-    clazz.superClass checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Clazz<*>?>() }
+    clazz.superClass checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Clazz<*>?>() }
    clazz.superClass.t checkType { _<Any?>() }

    // See KT-9294
@@ -12,9 +12,9 @@ class Inv2<T : Inv2<in T>>(val x: T)
 fun main(a: A<*>, j: JavaClass<*>, i2: Inv2<*>) {
    // Probably it's too restrictive to suppose star projection type here as Any?,
    // but looks like we can refine it later
-    a.foo() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any?>() }
-    j.foo() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any?>() }
-    i2.x checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any?>() }
+    a.foo() checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Any?>() }
+    j.foo() checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Any?>() }
+    i2.x checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Any?>() }

    j.bar(<!ARGUMENT_TYPE_MISMATCH!>1<!>, <!ARGUMENT_TYPE_MISMATCH!>2<!>, <!ARGUMENT_TYPE_MISMATCH!>Any()<!>)
    j.bar(null)
@@ -47,7 +47,7 @@ fun test3() {

    fooSetRef.invoke(foo, <!ARGUMENT_TYPE_MISMATCH!>""<!>)

-    foo.x.<!INAPPLICABLE_CANDIDATE!>bar<!>()
+    foo.x.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>bar<!>()
 }

 fun test4() {
@@ -56,5 +56,5 @@ fun test4() {

    fooSetRef.invoke(foo, <!ARGUMENT_TYPE_MISMATCH!>""<!>)

-    foo.x.<!INAPPLICABLE_CANDIDATE!>bar<!>()
+    foo.x.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>bar<!>()
 }
@@ -6,7 +6,7 @@ fun <T: Any> bar(a: Array<T>): Array<T?> =  null!!
 fun test1(a: Array<out Int>) {
    val r: Array<out Int?> = <!INITIALIZER_TYPE_MISMATCH!>bar(a)<!>
    val t = bar(a)
-    t checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Array<out Int?>>() }
+    t checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Array<out Int?>>() }
 }

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

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

 fun test2(vararg a: Int?) {
-    val list = a.<!INAPPLICABLE_CANDIDATE!>filterNotNull<!>()
+    val list = a.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>filterNotNull<!>()
    list checkType { _<List<Int>>() }
 }
@@ -2,5 +2,5 @@ fun <T> Array<T>.foo() {}

 fun test(array: Array<out Int>) {
    array.foo()
-    array.<!INAPPLICABLE_CANDIDATE!>foo<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>out Int<!>>()
+    array.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>foo<!><<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>out Int<!>>()
 }
@@ -20,20 +20,20 @@ fun main(x: Foo<out Number?>, y: Bar<out Number?>, z1: Foo<out Number>, z2: Bar<
    x.foo()
    x.bar()
    x.boo1()
-    x.<!INAPPLICABLE_CANDIDATE!>boo2<!>()
+    x.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>boo2<!>()

-    y.<!INAPPLICABLE_CANDIDATE!>foo<!>()
+    y.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>foo<!>()
    y.bar()
-    y.<!INAPPLICABLE_CANDIDATE!>boo1<!>()
-    y.<!INAPPLICABLE_CANDIDATE!>boo2<!>()
+    y.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>boo1<!>()
+    y.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>boo2<!>()

    z1.foo()
    z1.bar()
    z1.boo1()
-    z1.<!INAPPLICABLE_CANDIDATE!>boo2<!>()
+    z1.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>boo2<!>()

    z2.foo()
    z2.bar()
-    z2.<!INAPPLICABLE_CANDIDATE!>boo1<!>()
-    z2.<!INAPPLICABLE_CANDIDATE!>boo2<!>()
+    z2.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>boo1<!>()
+    z2.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>boo2<!>()
 }
@@ -20,20 +20,20 @@ fun main(x: Foo<out Number?>, y: Bar<out Number?>, z1: Foo<out Number>, z2: Bar<
    x.foo()
    x.bar()
    x.boo1()
-    x.<!INAPPLICABLE_CANDIDATE!>boo2<!>()
+    x.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>boo2<!>()

-    y.<!INAPPLICABLE_CANDIDATE!>foo<!>()
+    y.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>foo<!>()
    y.bar()
-    y.<!INAPPLICABLE_CANDIDATE!>boo1<!>()
-    y.<!INAPPLICABLE_CANDIDATE!>boo2<!>()
+    y.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>boo1<!>()
+    y.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>boo2<!>()

    z1.foo()
    z1.bar()
    z1.boo1()
-    z1.<!INAPPLICABLE_CANDIDATE!>boo2<!>()
+    z1.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>boo2<!>()

    z2.foo()
    z2.bar()
-    z2.<!INAPPLICABLE_CANDIDATE!>boo1<!>()
-    z2.<!INAPPLICABLE_CANDIDATE!>boo2<!>()
+    z2.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>boo1<!>()
+    z2.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>boo2<!>()
 }
@@ -17,14 +17,14 @@ class SomeClass {
    val withoutType: LambdaWithReceiver
        get() = when (e) {
            E.VALUE -> { param ->
-                <!INAPPLICABLE_CANDIDATE!>method<!>(param)
+                <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>method<!>(param)
            }
        }

    val withExplicitType: LambdaWithReceiver
        get() = when (e) {
            E.VALUE -> { param: Parameter ->
-                <!INAPPLICABLE_CANDIDATE!>method<!>(param)
+                <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>method<!>(param)
            }
        }
 }
@@ -9,4 +9,4 @@ fun <T, Q> List<T>.map1(f: (T)-> Q): List<T>? = tail!!.map1(f)

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

-fun <T, Q> List<T>.map3(f: (T)-> Q): List<T>? = tail.<!INAPPLICABLE_CANDIDATE!>sure<!><T>().<!INAPPLICABLE_CANDIDATE!>map3<!>(f)
+fun <T, Q> List<T>.map3(f: (T)-> Q): List<T>? = tail.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>sure<!><T>().<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>map3<!>(f)
@@ -36,7 +36,7 @@ fun Number.num() {}
 fun main(b: Base<out Number>) {
    b.foo().num()
    if (b is Derived<*>) {
-        b.foo().<!INAPPLICABLE_CANDIDATE!>num<!>()
+        b.foo().<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>num<!>()
        b.baz().length
    }
 }
@@ -8,7 +8,7 @@ public class A<E> {
 // FILE: main.kt

 fun test(x: List<Int>, y: List<String>) {
-    A("", x) checkType { <!INAPPLICABLE_CANDIDATE!>_<!><A<Any?>>() }
+    A("", x) checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><A<Any?>>() }
    A("", y) checkType { _<A<String?>>() }

    A<CharSequence, String>("", <!ARGUMENT_TYPE_MISMATCH!>x<!>)
@@ -12,6 +12,6 @@ fun test(x: List<Int>, y: List<String>) {
    Outer<Int>().Inner("", y, 1) checkType { _<Outer<Int>.Inner<String>>() }
    Outer<Int>().Inner<CharSequence, String, Int>("", y, 1) checkType { _<Outer<Int>.Inner<CharSequence>>() }

-    Outer<Int>().Inner("", x, 1) checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Outer<Int>.Inner<Any>>() }
+    Outer<Int>().Inner("", x, 1) checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Outer<Int>.Inner<Any>>() }
    Outer<Int>().Inner<CharSequence, String, Int>("", <!ARGUMENT_TYPE_MISMATCH!>x<!>, 1)
 }
@@ -20,9 +20,9 @@ public abstract class CollectionWithSize implements java.util.Collection<String>
 // FILE: main.kt

 fun main(c: CollectionWithSize) {
-    CompressionType.ZIP.<!OVERLOAD_RESOLUTION_AMBIGUITY!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<Double>() }
-    c.<!OVERLOAD_RESOLUTION_AMBIGUITY!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<String>() }
+    CompressionType.ZIP.<!OVERLOAD_RESOLUTION_AMBIGUITY!>name<!> <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>checkType<!> { _<Double>() }
+    c.<!OVERLOAD_RESOLUTION_AMBIGUITY!>size<!> <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>checkType<!> { _<String>() }

-    CompressionType.ZIP::<!OVERLOAD_RESOLUTION_AMBIGUITY!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<kotlin.reflect.KProperty0<Double>>() }
-    c::<!OVERLOAD_RESOLUTION_AMBIGUITY!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<kotlin.reflect.KProperty0<String>>() }
+    CompressionType.ZIP::<!OVERLOAD_RESOLUTION_AMBIGUITY!>name<!> <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>checkType<!> { _<kotlin.reflect.KProperty0<Double>>() }
+    c::<!OVERLOAD_RESOLUTION_AMBIGUITY!>size<!> <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>checkType<!> { _<kotlin.reflect.KProperty0<String>>() }
 }
@@ -11,6 +11,6 @@ public class A {
 // FILE: main.kt

 fun foo(a: A) {
-    a.<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>() <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<String>() }
-    A.<!OVERLOAD_RESOLUTION_AMBIGUITY!>bar<!>() <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<String>() }
+    a.<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>() <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>checkType<!> { _<String>() }
+    A.<!OVERLOAD_RESOLUTION_AMBIGUITY!>bar<!>() <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>checkType<!> { _<String>() }
 }
@@ -35,7 +35,7 @@ fun test() {
    otherGeneric(<!ARGUMENT_TYPE_MISMATCH!>1<!>)

    val r = either(1, "")
-    r checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }
+    r checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Any>() }

    use(a, b, c, d, e, f, g, r)
 }
@@ -60,7 +60,7 @@ fun <T> lowerBound(t: T, l : Cov<T>): T = throw Exception("$t $l")

 fun testLowerBound(cov: Cov<String>, covN: Cov<Number>) {
    val r = lowerBound(1, cov)
-    r checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }
+    r checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Any>() }

    val n = lowerBound(1, covN)
    n checkType { _<Number>() }
@@ -29,7 +29,7 @@ fun test() {
    oldAndNew %= 1

    val onlyOld = OnlyOld()
-    onlyOld <!INAPPLICABLE_CANDIDATE!>%=<!> 1
+    <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>onlyOld %= 1<!>

    val onlyNew = OnlyNew()
    onlyNew %= 1
@@ -26,11 +26,11 @@ class IntAndUnit {

 fun test() {
    OldAndNew() % 1
-    OnlyOld() <!INAPPLICABLE_CANDIDATE!>%<!> 1
+    OnlyOld() <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>%<!> 1
    OnlyNew() % 1
    Sample() % 1

    takeInt(IntAndUnit() % 1)
 }

-fun takeInt(x: Int) {}
+fun takeInt(x: Int) {}
@@ -9,5 +9,5 @@ object RemExtension
 operator fun RemExtension.rem(x: Int) {}

 fun foo() {
-    OldMod <!INAPPLICABLE_CANDIDATE!>%<!> 123
-}
+    OldMod <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>%<!> 123
+}
@@ -1,26 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER
-// !CHECK_TYPE
-// SKIP_JAVAC
-// NI_EXPECTED_FILE
-// FILE: p/J.java
-
-package p;
-
-public class J {
-    public static J j() { return null; }
-}
-
-// FILE: k.kt
-
-import p.*
-
-interface Out<out T1>
-
-fun <T> f(a: Out<T>, b: Out<T>, c: Out<T>): T = null!!
-fun <T> out(t: T): Out<MutableList<T>> = null!!
-
-fun test(a: Out<Nothing>, b: Out<MutableList<J>>) {
-    val v = f(a, b, out(J.j()))
-    v checkType { _<MutableList<J>>() }
-    v checkType { <!INAPPLICABLE_CANDIDATE!>_<!><MutableList<J?>>() }
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 // !CHECK_TYPE
 // SKIP_JAVAC
@@ -11,7 +11,7 @@ class Outer {
 fun Activity.toast() = Unit
 class Activity(){
    class Fragment{
-        fun call() = <!INAPPLICABLE_CANDIDATE!>toast<!>()
+        fun call() = <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>toast<!>()
    }
 }

@@ -27,4 +27,4 @@ public class Manager {
            <!ARGUMENT_TYPE_MISMATCH!>callback<!>() // Manager is not accessible here, but no error is shown
        }
    }
-}
+}
@@ -1,11 +0,0 @@
-// KT-557 Wrong type inference near sure extension function
-
-fun <T : Any> T?.sure() : T = this!!
-
-fun Array<String>.length() : Int {
-    return 0;
-}
-
-fun test(array : Array<String?>?) {
-    array?.sure<Array<String?>>().<!INAPPLICABLE_CANDIDATE!>length<!>()
-}
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // KT-557 Wrong type inference near sure extension function

 fun <T : Any> T?.sure() : T = this!!
@@ -3,7 +3,7 @@
 fun String.invoke(i: Int) {}

 fun foo(i: Int) {
-    <!INAPPLICABLE_CANDIDATE!>i<!>(1)
+    <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>i<!>(1)

-    <!INAPPLICABLE_CANDIDATE!>1<!>(1)
-}
+    <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>1(1)<!>
+}
@@ -16,7 +16,7 @@ fun test(a: A, b: B) {

        b.(foo)()

-        <!ARGUMENT_TYPE_MISMATCH!>(b.<!INAPPLICABLE_CANDIDATE!>foo<!>)()<!>
+        <!ARGUMENT_TYPE_MISMATCH!>(b.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>foo<!>)()<!>

        foo(b)
        (foo)(b)
@@ -5,7 +5,7 @@ fun Int.invoke() {}
 class SomeClass

 fun test(identifier: SomeClass, fn: String.() -> Unit) {
-    <!INAPPLICABLE_CANDIDATE!>identifier<!>()
+    <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>identifier<!>()
    identifier(<!TOO_MANY_ARGUMENTS!>123<!>)
    identifier(<!TOO_MANY_ARGUMENTS!>1<!>, <!TOO_MANY_ARGUMENTS!>2<!>)
    <!ARGUMENT_TYPE_MISMATCH!>1<!>.fn()
@@ -20,7 +20,7 @@ import test.E

 fun foo() {
    E.Entry checkType { _<E>() }
-    E.Entry checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+    E.Entry checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String>() }
    E.Companion.Entry checkType { _<String>() }
    E.NotEntry checkType { _<String>() }
    Entry checkType { _<E>() }
@@ -33,8 +33,8 @@ fun foo() {
 import test.E as U

 fun bar() {
-    U.Entry checkType { <!INAPPLICABLE_CANDIDATE!>_<!><<!UNRESOLVED_REFERENCE!>E<!>>() }
-    U.Entry checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+    U.Entry checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><<!UNRESOLVED_REFERENCE!>E<!>>() }
+    U.Entry checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String>() }
    U.Companion.Entry checkType { _<String>() }
    U.NotEntry checkType { _<String>() }
 }
@@ -10,11 +10,11 @@ fun Int.extFun() = 4
 fun String.test() {
    <!EXPRESSION_EXPECTED_PACKAGE_FOUND!>some<!>
    some.A()
-    "".<!INAPPLICABLE_CANDIDATE!>some<!>
+    "".<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>some<!>

-    <!INAPPLICABLE_CANDIDATE!>foo<!>
-    "".<!INAPPLICABLE_CANDIDATE!>foo<!>
+    <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>foo<!>
+    "".<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>foo<!>

-    <!INAPPLICABLE_CANDIDATE!>extFun<!>()
-    "".<!INAPPLICABLE_CANDIDATE!>extFun<!>()
-}
+    <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>extFun<!>()
+    "".<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>extFun<!>()
+}
@@ -22,10 +22,10 @@ public interface J {

 // FILE: 1.kt
 fun test(j: J) {
-    j.<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>({ <!UNRESOLVED_REFERENCE!>it<!> checkType { _<Any>() }; "" }, "") <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<Int>() }
+    j.<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>({ <!UNRESOLVED_REFERENCE!>it<!> checkType { _<Any>() }; "" }, "") <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>checkType<!> { _<Int>() }

-    j.<!OVERLOAD_RESOLUTION_AMBIGUITY!>bas<!>({ <!UNRESOLVED_REFERENCE!>it<!> checkType { _<Any>() }; "" }, "") <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<Int>() }
+    j.<!OVERLOAD_RESOLUTION_AMBIGUITY!>bas<!>({ <!UNRESOLVED_REFERENCE!>it<!> checkType { _<Any>() }; "" }, "") <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>checkType<!> { _<Int>() }

    // NI: TODO
-    j.bar { it checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" } checkType { _<Int>() }
+    j.bar { it checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Any>() }; "" } checkType { _<Int>() }
 }
@@ -21,10 +21,10 @@ interface K {
 }

 fun test(k: K) {
-    k.<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!> { <!UNRESOLVED_REFERENCE!>it<!> checkType { _<Any>() }; "" } <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<Int>() }
+    k.<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!> { <!UNRESOLVED_REFERENCE!>it<!> checkType { _<Any>() }; "" } <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>checkType<!> { _<Int>() }

-    k.<!OVERLOAD_RESOLUTION_AMBIGUITY!>bas<!> { <!UNRESOLVED_REFERENCE!>it<!> checkType { _<Any?>() }; "" } <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<Int>() }
+    k.<!OVERLOAD_RESOLUTION_AMBIGUITY!>bas<!> { <!UNRESOLVED_REFERENCE!>it<!> checkType { _<Any?>() }; "" } <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>checkType<!> { _<Int>() }

    // NI: TODO
-    k.bar { it checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" } checkType { _<Int>() }
+    k.bar { it checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Any>() }; "" } checkType { _<Int>() }
 }
@@ -20,6 +20,6 @@ public class AppServiceModule : AbstractModule<String>() {
    inline fun <reified T> AbstractModule<Int>.bind() {
        val x = <!PROTECTED_CALL_FROM_PUBLIC_INLINE!>bind<!>(javaClass<T>())

-        x checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() } // check that Class receiver is used instead of extension one
+        x checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String>() } // check that Class receiver is used instead of extension one
    }
 }
@@ -11,7 +11,7 @@ fun BaseOuter.foo(): String = ""
 class Derived : BaseOuter() {
    fun test(foo: Foo) {
        if (foo.base is Derived) {
-            foo.base.foo() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() } // Resolved to extension
+            foo.base.foo() checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String>() } // Resolved to extension
            foo.base.bar()
        }
    }
@@ -7,6 +7,6 @@ class A {
    constructor(x: Any?)
    constructor() : this(object {
        fun bar() = <!UNRESOLVED_REFERENCE!>foo<!>() + this<!UNRESOLVED_LABEL!>@A<!>.foo() +
-                    <!INAPPLICABLE_CANDIDATE!>foobar<!>() + super<!UNRESOLVED_LABEL!>@A<!>.hashCode()
+                    <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>foobar<!>() + super<!UNRESOLVED_LABEL!>@A<!>.hashCode()
    })
 }
@@ -6,6 +6,6 @@ class A {
    fun foo() = 1
    constructor( x: Any = object {
        fun bar() = <!UNRESOLVED_REFERENCE!>foo<!>() + this<!UNRESOLVED_LABEL!>@A<!>.foo() +
-                    <!INAPPLICABLE_CANDIDATE!>foobar<!>()
+                    <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>foobar<!>()
    })
 }
@@ -16,37 +16,37 @@ interface C {

 fun foo(x: Any?) {
    if (x is A && x is B) {
-        x.foo().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+        x.foo().checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String>() }
        x.foo().checkType { _<String?>() }
    }

    if (x is B && x is A) {
-        x.foo().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+        x.foo().checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String>() }
        x.foo().checkType { _<String?>() }
    }

    if (x is A && x is C) {
        x.foo().checkType { _<String>() }
-        x.foo().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String?>() }
+        x.foo().checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String?>() }
    }

    if (x is C && x is A) {
        x.foo().checkType { _<String>() }
-        x.foo().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String?>() }
+        x.foo().checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String?>() }
    }

    if (x is A && x is B && x is C) {
        x.foo().checkType { _<String>() }
-        x.foo().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String?>() }
+        x.foo().checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String?>() }
    }

    if (x is B && x is A && x is C) {
        x.foo().checkType { _<String>() }
-        x.foo().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String?>() }
+        x.foo().checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String?>() }
    }

    if (x is B && x is C && x is A) {
        x.foo().checkType { _<String>() }
-        x.foo().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String?>() }
+        x.foo().checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String?>() }
    }
 }
@@ -7,7 +7,7 @@ fun case_0() {
        this as Int
        this // error in NI: required Int, found Any?; just inferred to Any? in OI
    }
-    y checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any?>() }
+    y checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Any?>() }
    y checkType { _<Int>() }
 }

@@ -19,7 +19,7 @@ fun case_1(z: Any?) {
            else -> return@run ""
        }
    }
-    y checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any?>() }
+    y checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Any?>() }
    y checkType { _<kotlin.String>() }
    // y is inferred to Any?
 }
@@ -44,7 +44,7 @@ fun case_3(z: Any?) {
            else -> return@let ""
        }
    }
-    y checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any?>() }
+    y checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Any?>() }
    y checkType { _<kotlin.String>() }
    // y is inferred to String
 }
@@ -7,5 +7,5 @@ val <T : Any> KClass<T>.java: Class<T> get() = null!!

 val <T : Any> KClass<T>.javaObjectType: Class<T>
    get() {
-        return java.<!UNRESOLVED_REFERENCE!>lang<!>.Class::class.<!INAPPLICABLE_CANDIDATE!>java<!> as Class<T>
+        return java.<!UNRESOLVED_REFERENCE!>lang<!>.Class::class.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>java<!> as Class<T>
    }
@@ -17,7 +17,7 @@ interface B<R, T: B<List<R>, <!UPPER_BOUND_VIOLATED!>T<!>>> {

 fun testB(b: B<*, *>) {
    b.r().checkType { _<Any?>() }
-    b.t().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><B<List<*>, *>>() }
+    b.t().checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><B<List<*>, *>>() }

    b.t().r().size
 }
@@ -12,8 +12,8 @@ public class A {
 // FILE: 1.kt
 fun fn() {}
 fun x(r: Runnable) {
-    A.foo(::fn) checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
-    A.foo {} checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+    A.foo(::fn) checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String>() }
+    A.foo {} checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String>() }

    A.foo(null) checkType { _<Int>() }
    A.foo(Runnable { }) checkType { _<Int>() }
@@ -12,8 +12,8 @@ public class A {
 // FILE: 1.kt
 fun fn() {}
 fun x(a: A, r: Runnable) {
-    a.foo(::fn) checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
-    a.foo {} checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+    a.foo(::fn) checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String>() }
+    a.foo {} checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String>() }

    a.foo(null) checkType { _<Int>() }
    a.foo(Runnable { }) checkType { _<Int>() }
@@ -1,23 +0,0 @@
-// NI_EXPECTED_FILE
-
-class Outer {
-    inner class Inner
-}
-
-typealias OI = Outer.Inner
-
-fun test1(x: Outer) = x.OI()
-
-
-class Generic<T> {
-    inner class Inner
-}
-
-typealias GI<T> = Generic<T>.Inner
-typealias GIntI = Generic<Int>.Inner
-
-fun test2(x: Generic<Int>) = x.GI()
-fun <T> test3(x: Generic<T>) = x.GI()
-fun <T> test4(x: Generic<List<T>>) = x.GI()
-fun <T> test5(x: Generic<T>) = x.<!INAPPLICABLE_CANDIDATE!>GIntI<!>()
-fun Generic<Int>.test6() = GIntI()
@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // NI_EXPECTED_FILE

 class Outer {
@@ -9,11 +9,11 @@ fun <K> select(x: K, y: K): K = TODO()
 fun takeUByte(u: UByte) {}

 fun foo() {
-    <!NEW_INFERENCE_ERROR!>select(1, 1u)<!> checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Comparable<*>>() }
+    <!NEW_INFERENCE_ERROR!>select(1, 1u)<!> checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Comparable<*>>() }
    takeUByte(<!ARGUMENT_TYPE_MISMATCH!>id(1)<!>)

    1 <!NONE_APPLICABLE!>+<!> 1u
-    (1u <!NONE_APPLICABLE!>+<!> 1) <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<UInt>() }
+    (1u <!NONE_APPLICABLE!>+<!> 1) <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>checkType<!> { _<UInt>() }

    id<UInt>(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
 }
@@ -4,10 +4,10 @@ fun UShort.fUShort() {}
 fun ULong.fULong() {}

 fun test() {
-    1.<!INAPPLICABLE_CANDIDATE!>fUInt<!>()
-    1.<!INAPPLICABLE_CANDIDATE!>fUByte<!>()
-    1.<!INAPPLICABLE_CANDIDATE!>fUShort<!>()
-    1.<!INAPPLICABLE_CANDIDATE!>fULong<!>()
+    1.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>fUInt<!>()
+    1.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>fUByte<!>()
+    1.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>fUShort<!>()
+    1.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>fULong<!>()

    3000000000 <!NONE_APPLICABLE!>until<!> 3000000004UL
    0 <!NONE_APPLICABLE!>until<!> 10u
@@ -21,7 +21,7 @@ fun test() {
    foo(1) checkType { _<Int>() }
    foo(1u) checkType { _<String>() }

-    <!NONE_APPLICABLE!>foo<!>(2147483648) <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<String>() }
+    <!NONE_APPLICABLE!>foo<!>(2147483648) <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>checkType<!> { _<String>() }
    foo(2147483647 + 1) checkType { _<Int>() }

    fooByte(1) checkType { _<Int>() }