[FIR] Handle unresolved callable references more correctly

2020-01-21 17:35:50 +03:00
parent 97d8f3fa4b
commit e644edfe84
38 changed files with 105 additions and 90 deletions
@@ -1 +1 @@
-fun test() = ("").<!UNRESOLVED_REFERENCE!>hashCode<!>::hashCode
+fun test() = <!UNRESOLVED_REFERENCE!>("").<!UNRESOLVED_REFERENCE!>hashCode<!>::hashCode<!>
@@ -1,6 +1,6 @@
 class Foo {
    fun bar() {}
-    fun f() = <!UNRESOLVED_REFERENCE!>Unresolved<!>()::bar
+    fun f() = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Unresolved<!>()::bar<!>
 }

-val f: () -> Unit = <!UNRESOLVED_REFERENCE!>Unresolved<!>()::foo
+val f: () -> Unit = <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Unresolved<!>()::foo<!>
@@ -5,8 +5,8 @@ annotation class C
 enum class D

 fun main() {
-    ::A
+    <!UNRESOLVED_REFERENCE!>::A<!>
    ::B
    ::C   // KT-3465
-    ::D
+    <!UNRESOLVED_REFERENCE!>::D<!>
 }
@@ -13,4 +13,4 @@ import test.Foo
 fun Foo(): String = ""

 val f = Foo::bar
-val g = Foo::length
+val g = <!UNRESOLVED_REFERENCE!>Foo::length<!>
@@ -21,8 +21,8 @@ import first.foo

 fun main() {
    val x = first.A::foo
-    first.A::bar
-    A::baz
+    <!UNRESOLVED_REFERENCE!>first.A::bar<!>
+    <!UNRESOLVED_REFERENCE!>A::baz<!>

    checkSubtype<KFunction1<A, Unit>>(x)
 }
@@ -15,6 +15,6 @@ class A {
 fun eat(value: Any) {}

 fun main() {
-    A::extInt
-    A::extA
+    <!UNRESOLVED_REFERENCE!>A::extInt<!>
+    <!UNRESOLVED_REFERENCE!>A::extA<!>
 }
@@ -26,7 +26,7 @@ class A {

 class B {
    fun main() {
-        ::Inner
+        <!UNRESOLVED_REFERENCE!>::Inner<!>
        val y = A::Inner

        checkSubtype<KFunction1<A, A.Inner>>(y)
@@ -16,7 +16,7 @@ fun A.main() {
 }

 fun Int.main() {
-    ::Inner
+    <!UNRESOLVED_REFERENCE!>::Inner<!>
    val y = A::Inner

    checkSubtype<KFunction1<A, A.Inner>>(y)
@@ -7,7 +7,7 @@ class A {
 }

 fun main() {
-    ::Inner
+    <!UNRESOLVED_REFERENCE!>::Inner<!>
    val y = A::Inner

    checkSubtype<KFunction1<A, A.Inner>>(y)
@@ -25,7 +25,7 @@ class A {

 class B {
    fun main() {
-        ::Nested
+        <!UNRESOLVED_REFERENCE!>::Nested<!>
        val y = A::Nested

        <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><KFunction0<A.Nested>>(y)
@@ -14,7 +14,7 @@ fun A.main() {
 }

 fun Int.main() {
-    ::Nested
+    <!UNRESOLVED_REFERENCE!>::Nested<!>
    val y = A::Nested

    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><KFunction0<A.Nested>>(y)
@@ -4,21 +4,21 @@
 class A

 fun test1() {
-    val foo = ::foo
+    val foo = <!UNRESOLVED_REFERENCE!>::foo<!>

-    ::bar
+    <!UNRESOLVED_REFERENCE!>::bar<!>

-    A::bar
+    <!UNRESOLVED_REFERENCE!>A::bar<!>

-    <!UNRESOLVED_REFERENCE!>B<!>::bar
+    <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>B<!>::bar<!>
 }

 fun test2() {
    fun foo(x: Any) {}
    fun foo() {}

-    <!UNRESOLVED_REFERENCE!>Unresolved<!>::foo
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(<!UNRESOLVED_REFERENCE!>Unresolved<!>::foo)
-    <!INAPPLICABLE_CANDIDATE!>foo<!>(<!UNRESOLVED_REFERENCE!>Unresolved<!>::unresolved)
-    ::unresolved
+    <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Unresolved<!>::foo<!>
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(<!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Unresolved<!>::foo<!>)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(<!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Unresolved<!>::unresolved<!>)
+    <!UNRESOLVED_REFERENCE!>::unresolved<!>
 }
@@ -4,8 +4,8 @@

 fun main() {
    Configuration().commands {
-        <!INAPPLICABLE_CANDIDATE!>Command1<!> { <!UNRESOLVED_REFERENCE!>someService<!>::execute } // Overload resolution ambiguity. All these functions match.
-        <!INAPPLICABLE_CANDIDATE!>Command2<!> { <!UNRESOLVED_REFERENCE!>someService<!>::execute } // Overload resolution ambiguity. All these functions match.
+        <!INAPPLICABLE_CANDIDATE!>Command1<!> { <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>someService<!>::execute<!> } // Overload resolution ambiguity. All these functions match.
+        <!INAPPLICABLE_CANDIDATE!>Command2<!> { <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>someService<!>::execute<!> } // Overload resolution ambiguity. All these functions match.
        <!INAPPLICABLE_CANDIDATE!>Command1<!> { { <!UNRESOLVED_REFERENCE!>someService<!>.<!UNRESOLVED_REFERENCE!>execute<!>(<!UNRESOLVED_REFERENCE!>it<!>) } } // fine
        <!INAPPLICABLE_CANDIDATE!>Command2<!> { { <!UNRESOLVED_REFERENCE!>someService<!>.<!UNRESOLVED_REFERENCE!>execute<!>(<!UNRESOLVED_REFERENCE!>it<!>) } } // fine
    }
@@ -4,8 +4,8 @@ class Unrelated()

 class Test(val name: String = "") {
    init {
-        Unrelated::name
-        Unrelated::foo
+        <!UNRESOLVED_REFERENCE!>Unrelated::name<!>
+        <!UNRESOLVED_REFERENCE!>Unrelated::foo<!>
    }

    fun foo() {}
@@ -21,6 +21,6 @@ fun test() {
    A.Companion::ext2
    A::ext2

-    A::foo
-    A::bar
+    <!UNRESOLVED_REFERENCE!>A::foo<!>
+    <!UNRESOLVED_REFERENCE!>A::bar<!>
 }
@@ -4,7 +4,7 @@
 package foo

 fun test() {
-    foo::test
+    <!UNRESOLVED_REFERENCE!>foo::test<!>
 }

 // FILE: qualifiedName.kt
@@ -12,5 +12,5 @@ fun test() {
 package foo.bar

 fun test() {
-    foo.bar::test
+    <!UNRESOLVED_REFERENCE!>foo.bar::test<!>
 }
@@ -17,10 +17,10 @@ public class JavaClass {
 import kotlin.reflect.*

 fun test() {
-    val pubFinRef: KProperty1<JavaClass, Int> = JavaClass::publicFinal
-    val pubMutRef: KMutableProperty1<JavaClass, Long> = JavaClass::publicMutable
-    val protFinRef: KProperty1<JavaClass, Double> = JavaClass::protectedFinal
-    val protMutRef: KMutableProperty1<JavaClass, Char> = JavaClass::protectedMutable
-    val privFinRef: KProperty1<JavaClass, String?> = JavaClass::privateFinal
-    val privMutRef: KMutableProperty1<JavaClass, Any?> = JavaClass::privateMutable
+    val pubFinRef: KProperty1<JavaClass, Int> = <!UNRESOLVED_REFERENCE!>JavaClass::publicFinal<!>
+    val pubMutRef: KMutableProperty1<JavaClass, Long> = <!UNRESOLVED_REFERENCE!>JavaClass::publicMutable<!>
+    val protFinRef: KProperty1<JavaClass, Double> = <!UNRESOLVED_REFERENCE!>JavaClass::protectedFinal<!>
+    val protMutRef: KMutableProperty1<JavaClass, Char> = <!UNRESOLVED_REFERENCE!>JavaClass::protectedMutable<!>
+    val privFinRef: KProperty1<JavaClass, String?> = <!UNRESOLVED_REFERENCE!>JavaClass::privateFinal<!>
+    val privMutRef: KMutableProperty1<JavaClass, Any?> = <!UNRESOLVED_REFERENCE!>JavaClass::privateMutable<!>
 }
@@ -19,10 +19,10 @@ import JavaClass.*
 import kotlin.reflect.*

 fun test() {
-    val pubFinRef: KProperty0<String> = ::publicFinal
-    val pubMutRef: KMutableProperty0<Any?> = ::publicMutable
-    val protFinRef: KProperty<Double> = ::protectedFinal
-    val protMutRef: KMutableProperty<Char> = ::protectedMutable
-    val privFinRef: KProperty<JavaClass?> = ::privateFinal
-    val privMutRef: KMutableProperty<Throwable?> = ::privateMutable
+    val pubFinRef: KProperty0<String> = <!UNRESOLVED_REFERENCE!>::publicFinal<!>
+    val pubMutRef: KMutableProperty0<Any?> = <!UNRESOLVED_REFERENCE!>::publicMutable<!>
+    val protFinRef: KProperty<Double> = <!UNRESOLVED_REFERENCE!>::protectedFinal<!>
+    val protMutRef: KMutableProperty<Char> = <!UNRESOLVED_REFERENCE!>::protectedMutable<!>
+    val privFinRef: KProperty<JavaClass?> = <!UNRESOLVED_REFERENCE!>::privateFinal<!>
+    val privMutRef: KMutableProperty<Throwable?> = <!UNRESOLVED_REFERENCE!>::privateMutable<!>
 }
@@ -7,5 +7,5 @@ class TestClass(var prop: Int)
 open class OtherClass
 fun OtherClass.test(prop: KProperty1<TestClass, Int>): Unit = throw Exception()
 class OtherClass2: OtherClass() {
-    val result = <!INAPPLICABLE_CANDIDATE!>test<!>(TestClass::result)
+    val result = <!INAPPLICABLE_CANDIDATE!>test<!>(<!UNRESOLVED_REFERENCE!>TestClass::result<!>)
 }
@@ -3,7 +3,7 @@
 fun eat(value: Any) {}

 fun test(param: String) {
-    val a = ::param
+    val a = <!UNRESOLVED_REFERENCE!>::param<!>

    val local = "local"
    val b = ::local