[FIR] Use static & qualified scopes to access qualified callables

This commit provides more correct logic for creating scopes based on FirResolvedQualifier & eliminates QualifiedReceiverTowerDataConsumer
2020-01-13 17:43:52 +03:00
parent 6bbfb2ffe9
commit f0ced642d9
29 changed files with 250 additions and 221 deletions
@@ -47,18 +47,18 @@ fun test() {
    val ic: I.NC = I.NC()
    val ii: I.NI? = null

-    val bc: B.NC = B.NC()
+    val bc: B.NC = B.<!UNRESOLVED_REFERENCE!>NC<!>()
    val bic: B.IC = B().IC()
    val bi: B.NI? = null

-    val cc: C.NC = C.NC()
+    val cc: C.NC = C.<!UNRESOLVED_REFERENCE!>NC<!>()
    val ci: C.NI? = null

-    val dc: D.NC = D.NC()
+    val dc: D.NC = D.<!UNRESOLVED_REFERENCE!>NC<!>()
    val dic: D.IC = D().IC()
    val di: D.NI? = null

-    val kc: K.NC = K.NC()
+    val kc: K.NC = K.<!UNRESOLVED_REFERENCE!>NC<!>()
    val kic: K.IC = K().IC()
    val ki: K.NI? = null
 }
@@ -31,14 +31,14 @@ fun test() {
    val ic: I.NC = I.NC()
    val ii: I.NI? = null

-    val bc: B.NC = B.NC()
+    val bc: B.NC = B.<!UNRESOLVED_REFERENCE!>NC<!>()
    val bic: B.IC = B().IC()
    val bi: B.NI? = null

-    val cc: C.NC = C.NC()
+    val cc: C.NC = C.<!UNRESOLVED_REFERENCE!>NC<!>()
    val ci: C.NI? = null

-    val dc: D.NC = D.NC()
+    val dc: D.NC = D.<!UNRESOLVED_REFERENCE!>NC<!>()
    val dic: D.IC = D().IC()
    val di: D.NI? = null
 }
@@ -25,8 +25,8 @@ fun main() {
    C.foo()
    C.bar()

-    K.a
-    K.b
-    K.foo()
-    K.bar()
+    K.<!UNRESOLVED_REFERENCE!>a<!>
+    K.<!UNRESOLVED_REFERENCE!>b<!>
+    K.<!UNRESOLVED_REFERENCE!>foo<!>()
+    K.<!UNRESOLVED_REFERENCE!>bar<!>()
 }
@@ -28,7 +28,7 @@ class X: A {
    init {
        A_S()
        A.A_S()
-        X.A_S()
+        X.<!UNRESOLVED_REFERENCE!>A_S<!>()
    }

    object xD {
@@ -51,7 +51,7 @@ class Y: B() {

        B_S()
        B.B_S()
-        Y.B_S()
+        Y.<!UNRESOLVED_REFERENCE!>B_S<!>()
    }

    object X {
@@ -43,20 +43,20 @@ class X: D() {

        A_S()
        A.A_S()
-        C.A_S()
-        D.A_S()
-        X.A_S()
+        C.<!UNRESOLVED_REFERENCE!>A_S<!>()
+        D.<!UNRESOLVED_REFERENCE!>A_S<!>()
+        X.<!UNRESOLVED_REFERENCE!>A_S<!>()

        B_S()
        B.B_S()
-        C.B_S()
-        D.B_S()
-        X.B_S()
+        C.<!UNRESOLVED_REFERENCE!>B_S<!>()
+        D.<!UNRESOLVED_REFERENCE!>B_S<!>()
+        X.<!UNRESOLVED_REFERENCE!>B_S<!>()

        E_S()
        E.E_S()
-        D.E_S()
-        X.E_S()
+        D.<!UNRESOLVED_REFERENCE!>E_S<!>()
+        X.<!UNRESOLVED_REFERENCE!>E_S<!>()
    }
 }

@@ -68,15 +68,15 @@ class Y: F() {
        Y.<!UNRESOLVED_REFERENCE!>B_<!>()

        A_S()
-        F.A_S()
-        Y.A_S()
+        F.<!UNRESOLVED_REFERENCE!>A_S<!>()
+        Y.<!UNRESOLVED_REFERENCE!>A_S<!>()

        B_S()
-        F.B_S()
-        Y.B_S()
+        F.<!UNRESOLVED_REFERENCE!>B_S<!>()
+        Y.<!UNRESOLVED_REFERENCE!>B_S<!>()

        E_S()
-        F.E_S()
-        Y.E_S()
+        F.<!UNRESOLVED_REFERENCE!>E_S<!>()
+        Y.<!UNRESOLVED_REFERENCE!>E_S<!>()
    }
 }
@@ -31,9 +31,9 @@ fun test() {
    C.b
    C.bar()

-    K.a
-    K.b
-    K.bar()
+    K.<!UNRESOLVED_REFERENCE!>a<!>
+    K.<!UNRESOLVED_REFERENCE!>b<!>
+    K.<!UNRESOLVED_REFERENCE!>bar<!>()

    D.a
    D.b
@@ -37,9 +37,9 @@ fun test() {
    C.b
    C.bar()

-    K.a
-    K.b
-    K.bar()
+    K.<!UNRESOLVED_REFERENCE!>a<!>
+    K.<!UNRESOLVED_REFERENCE!>b<!>
+    K.<!UNRESOLVED_REFERENCE!>bar<!>()

    D.a
    D.b
@@ -31,8 +31,8 @@ class XN: X() {
    init {
        foo()
        A.foo()
-        X.foo()
-        XN.foo()
+        X.<!UNRESOLVED_REFERENCE!>foo<!>()
+        XN.<!UNRESOLVED_REFERENCE!>foo<!>()
    }
 }

@@ -40,12 +40,12 @@ class YN: Y() {
    init {
        foo()
        A.foo()
-        Y.foo()
-        YN.foo()
+        Y.<!UNRESOLVED_REFERENCE!>foo<!>()
+        YN.<!UNRESOLVED_REFERENCE!>foo<!>()

        bar()
        B.bar()
-        Y.bar()
-        YN.bar()
+        Y.<!UNRESOLVED_REFERENCE!>bar<!>()
+        YN.<!UNRESOLVED_REFERENCE!>bar<!>()
    }
 }
@@ -16,12 +16,12 @@ class D: C() {
    init {
        foo()
        A.foo()
-        B.foo()
+        B.<!UNRESOLVED_REFERENCE!>foo<!>()
        C.foo()
-        D.foo()
+        D.<!UNRESOLVED_REFERENCE!>foo<!>()

        bar()
        C.bar()
-        D.bar()
+        D.<!UNRESOLVED_REFERENCE!>bar<!>()
    }
 }
@@ -47,8 +47,8 @@ fun test(a: KotlinClass, b: KotlinClass2) {
    JavaClass.<!INAPPLICABLE_CANDIDATE!>bar1<!>()
    JavaClass.<!INAPPLICABLE_CANDIDATE!>CONST1<!>

-    KotlinClass.<!INAPPLICABLE_CANDIDATE!>bar1<!>() // Currently it's unresolved, but it should be prohibited even in case it would be resolved
-    KotlinClass.<!INAPPLICABLE_CANDIDATE!>CONST1<!>
+    KotlinClass.<!UNRESOLVED_REFERENCE!>bar1<!>() // Currently it's unresolved, but it should be prohibited even in case it would be resolved
+    KotlinClass.<!UNRESOLVED_REFERENCE!>CONST1<!>

    JavaClassSamePackage.<!INAPPLICABLE_CANDIDATE!>bar1<!>()
    JavaClassSamePackage.bar2()
@@ -10,6 +10,6 @@ class C {
 typealias CA = C

 val test1 = CA
-val test2 = CA.<!UNRESOLVED_REFERENCE!>Companion<!>
+val test2 = CA.Companion
 val test3 = CA.<!UNRESOLVED_REFERENCE!>x<!>
-val test4 = CA.<!UNRESOLVED_REFERENCE!>Companion<!>.<!UNRESOLVED_REFERENCE!>x<!>
+val test4 = CA.Companion.x
@@ -8,4 +8,4 @@ object Since_1_1 {
 typealias Since_1_1_Alias = Since_1_1

 val test1 = Since_1_1_Alias
-val test2 = Since_1_1_Alias.<!UNRESOLVED_REFERENCE!>x<!>
+val test2 = Since_1_1_Alias.x
@@ -7,8 +7,8 @@ typealias GenericTestObject<T> = AnObject

 val test11: AnObject = GenericTestObject
 val test12: GenericTestObject<*> = GenericTestObject
-val test13: String = GenericTestObject.<!UNRESOLVED_REFERENCE!>ok<!>
-val test14: String = GenericTestObject.<!UNRESOLVED_REFERENCE!>foo<!>()
+val test13: String = GenericTestObject.ok
+val test14: String = GenericTestObject.foo()

 class GenericClassWithCompanion<T> {
    companion object {
@@ -33,7 +33,7 @@ val seeAlsoDerivedFoo: String = JDerived.foo()

 // Referencing nested classes via type alias should be prohibited
 // (in type position and in expression position)
-val testNested1: JT.Nested = JT.Nested()
+val testNested1: JT.Nested = JT.<!UNRESOLVED_REFERENCE!>Nested<!>()
 val testNested2: KT.Nested = KT.Nested()
 val testNested3: IT.Nested = IT.Nested()
 val testInner1: JT.Inner = JT.<!UNRESOLVED_REFERENCE!>Inner<!>()
@@ -13,9 +13,9 @@ class C {
    }
 }

-val c = C.Self.<!UNRESOLVED_REFERENCE!>Self<!>()
-val n = C.Self.Nested()
-val x = C.Self.<!UNRESOLVED_REFERENCE!>X<!>
-val n2 = C.Nested.Root.<!UNRESOLVED_REFERENCE!>Nested<!>.<!UNRESOLVED_REFERENCE!>N2<!>()
-val ic = C.Self.<!UNRESOLVED_REFERENCE!>InCompanion<!>()
-val ok = C.Self.<!UNRESOLVED_REFERENCE!>ok<!>
+val c = C.<!UNRESOLVED_REFERENCE!>Self<!>.<!UNRESOLVED_REFERENCE!>Self<!>()
+val n = C.<!UNRESOLVED_REFERENCE!>Self<!>.<!UNRESOLVED_REFERENCE!>Nested<!>()
+val x = C.<!UNRESOLVED_REFERENCE!>Self<!>.<!UNRESOLVED_REFERENCE!>X<!>
+val n2 = C.Nested.<!UNRESOLVED_REFERENCE!>Root<!>.<!UNRESOLVED_REFERENCE!>Nested<!>.<!UNRESOLVED_REFERENCE!>N2<!>()
+val ic = C.<!UNRESOLVED_REFERENCE!>Self<!>.<!UNRESOLVED_REFERENCE!>InCompanion<!>()
+val ok = C.<!UNRESOLVED_REFERENCE!>Self<!>.<!UNRESOLVED_REFERENCE!>ok<!>
@@ -7,15 +7,15 @@ typealias TestObject = AnObject

 val test11: AnObject = TestObject
 val test12: TestObject = TestObject
-val test13: String = TestObject.<!UNRESOLVED_REFERENCE!>ok<!>
-val test14: String = TestObject.<!UNRESOLVED_REFERENCE!>foo<!>()
+val test13: String = TestObject.ok
+val test14: String = TestObject.foo()

 typealias TestObject2 = TestObject

 val test21: AnObject = TestObject2
 val test22: TestObject2 = TestObject2
-val test23: String = TestObject2.<!UNRESOLVED_REFERENCE!>ok<!>
-val test24: String = TestObject2.<!UNRESOLVED_REFERENCE!>foo<!>()
+val test23: String = TestObject2.ok
+val test24: String = TestObject2.foo()

 class ClassWithCompanion {
    companion object {
@@ -53,7 +53,7 @@ fun foo(
    test.ClassAlias::func

    test.ClassSample.Nested::func
-    test.ClassAlias.<!UNRESOLVED_REFERENCE!>Nested<!>::func
+    test.ClassAlias.Nested::func

    test.ObjectSample::Nested
    test.ObjectAlias::Nested
@@ -62,7 +62,7 @@ fun foo(
    test.ObjectAlias::func

    test.ObjectSample.Nested::func
-    test.ObjectAlias.<!UNRESOLVED_REFERENCE!>Nested<!>::func
+    test.ObjectAlias.Nested::func

    test.EnumSample::Nested
    test.EnumAlias::Nested
@@ -71,5 +71,5 @@ fun foo(
    test.EnumAlias::func

    test.EnumSample.Nested::func
-    test.EnumAlias.<!UNRESOLVED_REFERENCE!>Nested<!>::func
+    test.EnumAlias.Nested::func
 }