Introduce module 'reflection', move KFunctionN to it

Metadata for KFunction classes is now longer serialized along with built-in classes. This effectively means that it's no longer possible to find KFunction classes via dependency on built-ins. There should be a kotlin-runtime library in the specified classpath for reflection types to be resolvable. A lot of tests were moved and changed, because tests on callable references require stdlib in classpath from now on
2014-05-07 18:35:45 +04:00
parent c1cd8bf069
commit c7a7f31e82
124 changed files with 619 additions and 847 deletions
@@ -0,0 +1,11 @@
+trait A
+abstract class B
+annotation class C
+enum class D
+
+fun main() {
+    ::<!UNRESOLVED_REFERENCE!>A<!>
+    ::<!CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS!>B<!>
+    ::C   // KT-3465
+    ::<!INVISIBLE_MEMBER!>D<!>
+}
@@ -0,0 +1,8 @@
+fun foo(x: Int, <!UNUSED_PARAMETER!>y<!>: Any) = x
+fun foo(<!UNUSED_PARAMETER!>x<!>: Any, y: Int) = y
+
+fun main() {
+    ::<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!>
+    
+    ::<!OVERLOAD_RESOLUTION_AMBIGUITY!>foo<!> : (Int, Any) -> Unit
+}
@@ -0,0 +1,15 @@
+class A {
+    fun main() {
+        val x = ::A
+
+        x : KFunction0<A>
+    }
+}
+
+class SomeOtherClass {
+    fun main() {
+        val x = ::A
+
+        x : KFunction0<A>
+    }
+}
@@ -0,0 +1,10 @@
+class A
+class B
+
+fun A.ext() {
+    val x = ::A
+    val y = ::B
+
+    x : KFunction0<A>
+    y : KFunction0<B>
+}
@@ -0,0 +1,19 @@
+class A
+
+class B {
+    fun A.ext() {
+        val x = ::A
+        val y = ::B
+
+        x : KFunction0<A>
+        y : KFunction0<B>
+    }
+    
+    fun B.ext() {
+        val x = ::A
+        val y = ::B
+
+        x : KFunction0<A>
+        y : KFunction0<B>
+    }
+}
@@ -0,0 +1,7 @@
+class A
+
+fun main() {
+    val x = ::A
+
+    x : KFunction0<A>
+}
@@ -0,0 +1,25 @@
+// FILE: a.kt
+
+package first
+
+class A {
+    fun foo() {}
+    fun bar(<!UNUSED_PARAMETER!>x<!>: Int) {}
+    fun baz() = "OK"
+}
+
+// FILE: b.kt
+
+package other
+
+import first.A
+
+fun main() {
+    val x = first.A::foo
+    val y = first.A::bar
+    val z = A::baz
+
+    x : KMemberFunction0<A, Unit>
+    y : KMemberFunction1<A, Int, Unit>
+    z : KMemberFunction0<A, String>
+}
@@ -0,0 +1,24 @@
+// FILE: a.kt
+
+package first
+
+class A
+
+fun A.foo() {}
+fun A.bar() {}
+fun A.baz() {}
+
+// FILE: b.kt
+
+package other
+
+import first.A
+import first.foo
+
+fun main() {
+    val x = first.A::foo
+    first.A::<!UNRESOLVED_REFERENCE!>bar<!>
+    A::<!UNRESOLVED_REFERENCE!>baz<!>
+
+    x : KExtensionFunction0<A, Unit>
+}
@@ -0,0 +1,25 @@
+// FILE: a.kt
+
+package first
+
+fun foo() {}
+fun bar(<!UNUSED_PARAMETER!>x<!>: Int) {}
+fun baz() = "OK"
+
+// FILE: b.kt
+
+package other
+
+import first.foo
+import first.bar
+import first.baz
+
+fun main() {
+    val x = ::foo
+    val y = ::bar
+    val z = ::baz
+
+    x : KFunction0<Unit>
+    y : KFunction1<Int, Unit>
+    z : KFunction0<String>
+}
@@ -0,0 +1,6 @@
+class A
+
+fun main() {
+    val x = :: <!SYNTAX!><!>;
+    val y = A::
+<!SYNTAX!><!>}
@@ -0,0 +1,15 @@
+class A {
+    fun main() {
+        val x = ::foo
+        val y = ::bar
+        val z = ::baz
+
+        x : KExtensionFunction0<A, Unit>
+        y : KExtensionFunction1<A, Int, Unit>
+        z : KExtensionFunction0<A, String>
+    }
+}
+
+fun A.foo() {}
+fun A.bar(<!UNUSED_PARAMETER!>x<!>: Int) {}
+fun A.baz() = "OK"
@@ -0,0 +1,15 @@
+class A
+
+fun A.main() {
+    val x = ::foo
+    val y = ::bar
+    val z = ::baz
+
+    x : KExtensionFunction0<A, Unit>
+    y : KExtensionFunction1<A, Int, Unit>
+    z : KExtensionFunction0<A, String>
+}
+
+fun A.foo() {}
+fun A.bar(<!UNUSED_PARAMETER!>x<!>: Int) {}
+fun A.baz() = "OK"
@@ -0,0 +1,17 @@
+class B
+
+class A {
+    fun B.main() {
+        val x = ::foo
+        val y = ::bar
+        val z = ::baz
+
+        x : KExtensionFunction0<A, Unit>
+        y : KExtensionFunction1<A, Int, Unit>
+        z : KExtensionFunction0<A, String>
+    }
+}
+
+fun A.foo() {}
+fun A.bar(<!UNUSED_PARAMETER!>x<!>: Int) {}
+fun A.baz() = "OK"
@@ -0,0 +1,15 @@
+class A
+
+fun A.foo() {}
+fun A.bar(<!UNUSED_PARAMETER!>x<!>: Int) {}
+fun A.baz() = "OK"
+
+fun main() {
+    val x = A::foo
+    val y = A::bar
+    val z = A::baz
+
+    x : KExtensionFunction0<A, Unit>
+    y : KExtensionFunction1<A, Int, Unit>
+    z : KExtensionFunction0<A, String>
+}
@@ -0,0 +1,14 @@
+class A {
+    fun Int.extInt() = 42
+    fun A.extA(x: String) = x
+    
+    fun main() {
+        ::<!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>extInt<!>
+        ::<!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>extA<!>
+    }
+}
+
+fun main() {
+    A::<!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>extInt<!>
+    A::<!EXTENSION_IN_CLASS_REFERENCE_NOT_ALLOWED!>extA<!>
+}
@@ -0,0 +1,9 @@
+class A<T>(val t: T) {
+    fun foo(): T = t
+}
+
+fun bar() {
+    val x = A<String>::foo
+
+    x : KMemberFunction0<A<String>, String>
+}
@@ -0,0 +1,9 @@
+import A.Inner
+
+class A {
+    inner class Inner
+}
+
+fun main() {
+    ::<!UNRESOLVED_REFERENCE!>Inner<!>
+}
@@ -0,0 +1,29 @@
+class A {
+    inner class Inner
+    
+    fun main() {
+        val x = ::Inner
+        val y = A::Inner
+
+        x : KMemberFunction0<A, A.Inner>
+        y : KMemberFunction0<A, Inner>
+    }
+    
+    class object {
+        fun main() {
+            ::<!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>Inner<!>
+            val y = A::Inner
+
+            y : KMemberFunction0<A, A.Inner>
+        }
+    }
+}
+
+class B {
+    fun main() {
+        ::<!UNRESOLVED_REFERENCE!>Inner<!>
+        val y = A::Inner
+
+        y : KMemberFunction0<A, A.Inner>
+    }
+}
@@ -0,0 +1,18 @@
+class A {
+    inner class Inner
+}
+    
+fun A.main() {
+    val x = ::Inner
+    val y = A::Inner
+
+    x : KMemberFunction0<A, A.Inner>
+    y : KMemberFunction0<A, A.Inner>
+}
+
+fun Int.main() {
+    ::<!UNRESOLVED_REFERENCE!>Inner<!>
+    val y = A::Inner
+
+    y : KMemberFunction0<A, A.Inner>
+}
@@ -0,0 +1,10 @@
+class A {
+    inner class Inner
+}
+
+fun main() {
+    ::<!UNRESOLVED_REFERENCE!>Inner<!>
+    val y = A::Inner
+
+    y : KMemberFunction0<A, A.Inner>
+}
@@ -0,0 +1,9 @@
+class A<T, U : Any> {
+    fun foo() = <!CALLABLE_REFERENCE_LHS_NOT_A_CLASS!>T::<!UNRESOLVED_REFERENCE!>toString<!><!>
+
+    fun bar() = <!CALLABLE_REFERENCE_LHS_NOT_A_CLASS!>U::<!UNRESOLVED_REFERENCE!>toString<!><!>
+}
+
+fun <T> foo() = <!CALLABLE_REFERENCE_LHS_NOT_A_CLASS!>T::<!UNRESOLVED_REFERENCE!>toString<!><!>
+
+fun <U : Any> bar() = <!CALLABLE_REFERENCE_LHS_NOT_A_CLASS!>U::<!UNRESOLVED_REFERENCE!>toString<!><!>
@@ -0,0 +1,6 @@
+fun main() {
+    class A
+    
+    val x = ::A
+    x : KFunction0<A>
+}
@@ -0,0 +1,14 @@
+fun main() {
+    class A
+    
+    class B {
+        fun Int.foo() {
+            val x = ::A
+            x : KFunction0<A>
+        }
+        fun A.foo() {
+            val x = ::A
+            x : KFunction0<A>
+        }
+    }
+}
@@ -0,0 +1,8 @@
+fun main() {
+    class A
+    
+    class B {
+        val x = ::A
+        val f: KFunction0<A> = x
+    }
+}
@@ -0,0 +1,13 @@
+fun main() {
+    class A
+    
+    fun A.foo() {
+        val x = ::A
+        x : KFunction0<A>
+    }
+    
+    fun Int.foo() {
+        val x = ::A
+        x : KFunction0<A>
+    }
+}
@@ -0,0 +1,13 @@
+fun main() {
+    fun foo() {}
+    fun bar(<!UNUSED_PARAMETER!>x<!>: Int) {}
+    fun baz() = "OK"
+    
+    val x = ::foo
+    val y = ::bar
+    val z = ::baz
+    
+    x : KFunction0<Unit>
+    y : KFunction1<Int, Unit>
+    z : KFunction0<String>
+}
@@ -0,0 +1,19 @@
+class A
+
+fun main() {
+    fun foo() {}
+    fun bar(<!UNUSED_PARAMETER!>x<!>: Int) {}
+    fun baz() = "OK"
+    
+    class B {
+        fun A.ext() {
+            val x = ::foo
+            val y = ::bar
+            val z = ::baz
+
+            x : KFunction0<Unit>
+            y : KFunction1<Int, Unit>
+            z : KFunction0<String>
+        }
+    }
+}
@@ -0,0 +1,17 @@
+fun main() {
+    fun foo() {}
+    fun bar(<!UNUSED_PARAMETER!>x<!>: Int) {}
+    fun baz() = "OK"
+    
+    class A {
+        val x = ::foo
+        val y = ::bar
+        val z = ::baz
+
+        fun main() {
+            x : KFunction0<Unit>
+            y : KFunction1<Int, Unit>
+            z : KFunction0<String>
+        }
+    }
+}
@@ -0,0 +1,17 @@
+class A
+
+fun main() {
+    fun foo() {}
+    fun bar(<!UNUSED_PARAMETER!>x<!>: Int) {}
+    fun baz() = "OK"
+    
+    fun A.ext() {
+        val x = ::foo
+        val y = ::bar
+        val z = ::baz
+
+        x : KFunction0<Unit>
+        y : KFunction1<Int, Unit>
+        z : KFunction0<String>
+    }
+}
@@ -0,0 +1,15 @@
+// FILE: a.kt
+
+package a.b.c
+
+class D {
+    fun foo() = 42
+}
+
+// FILE: b.kt
+
+fun main() {
+    val x = a.b.c.D::foo
+
+    x : KMemberFunction0<a.b.c.D, Int>
+}
@@ -0,0 +1,15 @@
+// FILE: a.kt
+
+package a.b.c
+
+class D<E, F> {
+    fun foo(<!UNUSED_PARAMETER!>e<!>: E, <!UNUSED_PARAMETER!>f<!>: F) = this
+}
+
+// FILE: b.kt
+
+fun main() {
+    val x = a.b.c.D<String, Int>::foo
+
+    x : KMemberFunction2<a.b.c.D<String, Int>, String, Int, a.b.c.D<String, Int>>
+}
@@ -0,0 +1,15 @@
+class A {
+    fun foo() {}
+    fun bar(<!UNUSED_PARAMETER!>x<!>: Int) {}
+    fun baz() = "OK"
+    
+    fun main() {
+        val x = ::foo
+        val y = ::bar
+        val z = ::baz
+
+        x : KMemberFunction0<A, Unit>
+        y : KMemberFunction1<A, Int, Unit>
+        z : KMemberFunction0<A, String>
+    }
+}
@@ -0,0 +1,15 @@
+class A {
+    fun foo() {}
+    fun bar(<!UNUSED_PARAMETER!>x<!>: Int) {}
+    fun baz() = "OK"
+}
+    
+fun A.main() {
+    val x = ::foo
+    val y = ::bar
+    val z = ::baz
+
+    x : KMemberFunction0<A, Unit>
+    y : KMemberFunction1<A, Int, Unit>
+    z : KMemberFunction0<A, String>
+}
@@ -0,0 +1,17 @@
+class A {
+    fun foo() {}
+    fun bar(<!UNUSED_PARAMETER!>x<!>: Int) {}
+    fun baz() = "OK"
+}
+
+class B {
+    fun A.main() {
+        val x = ::foo
+        val y = ::bar
+        val z = ::baz
+
+        x : KMemberFunction0<A, Unit>
+        y : KMemberFunction1<A, Int, Unit>
+        z : KMemberFunction0<A, String>
+    }
+}
@@ -0,0 +1,15 @@
+class A {
+    fun foo() {}
+    fun bar(<!UNUSED_PARAMETER!>x<!>: Int) {}
+    fun baz() = "OK"
+}
+
+fun main() {
+    val x = A::foo
+    val y = A::bar
+    val z = A::baz
+
+    x : KMemberFunction0<A, Unit>
+    y : KMemberFunction1<A, Int, Unit>
+    z : KMemberFunction0<A, String>
+}
@@ -0,0 +1,29 @@
+class A {
+    class Nested
+    
+    fun main() {
+        val x = ::Nested
+        val y = A::Nested
+
+        x : KFunction0<Nested>
+        y : KFunction0<Nested>
+    }
+    
+    class object {
+        fun main() {
+            ::Nested
+            val y = A::Nested
+
+            y : KFunction0<A.Nested>
+        }
+    }
+}
+
+class B {
+    fun main() {
+        ::<!UNRESOLVED_REFERENCE!>Nested<!>
+        val y = A::Nested
+
+        y : KFunction0<A.Nested>
+    }
+}
@@ -0,0 +1,17 @@
+class A {
+    class Nested
+}
+    
+fun A.main() {
+    ::<!UNRESOLVED_REFERENCE!>Nested<!>
+    val y = A::Nested
+    
+    y : KFunction0<A.Nested>
+}
+
+fun Int.main() {
+    ::<!UNRESOLVED_REFERENCE!>Nested<!>
+    val y = A::Nested
+
+    y : KFunction0<A.Nested>
+}
@@ -0,0 +1,9 @@
+class A {
+    class Nested
+}
+
+fun main() {
+    val x = A::Nested
+
+    x : KFunction0<A.Nested>
+}
@@ -0,0 +1,7 @@
+fun bar() = 42
+
+fun main() {
+    fun bar() = 239
+
+    ::bar
+}
@@ -0,0 +1,11 @@
+class A {
+    fun foo() = 42
+}
+
+fun A.foo() {}
+
+fun main() {
+    val x = A::foo
+
+    x : KMemberFunction0<A, Int>
+}
@@ -0,0 +1,11 @@
+fun foo() {}
+
+class A {
+    fun foo() {}
+    
+    fun main() {
+        val x = ::foo
+
+        x : KMemberFunction0<A, Unit>
+    }
+}
@@ -0,0 +1,27 @@
+// FILE: a.kt
+
+package other
+
+fun foo() {}
+
+class A {
+    fun bar() = 42
+}
+
+fun A.baz(<!UNUSED_PARAMETER!>x<!>: String) {}
+
+// FILE: b.kt
+
+import other.foo as foofoo
+import other.A as AA
+import other.baz as bazbaz
+
+fun main() {
+    val x = ::foofoo
+    val y = AA::bar
+    val z = AA::bazbaz
+
+    x : KFunction0<Unit>
+    y : KMemberFunction0<AA, Int>
+    z : KExtensionFunction1<AA, String, Unit>
+}
@@ -0,0 +1,15 @@
+fun foo() {}
+fun bar(<!UNUSED_PARAMETER!>x<!>: Int) {}
+fun baz() = "OK"
+
+class A {
+    fun main() {
+        val x = ::foo
+        val y = ::bar
+        val z = ::baz
+
+        x : KFunction0<Unit>
+        y : KFunction1<Int, Unit>
+        z : KFunction0<String>
+    }
+}
@@ -0,0 +1,15 @@
+class A
+
+fun foo() {}
+fun bar(<!UNUSED_PARAMETER!>x<!>: Int) {}
+fun baz() = "OK"
+
+fun A.main() {
+    val x = ::foo
+    val y = ::bar
+    val z = ::baz
+
+    x : KFunction0<Unit>
+    y : KFunction1<Int, Unit>
+    z : KFunction0<String>
+}
@@ -0,0 +1,17 @@
+class A
+
+fun foo() {}
+fun bar(<!UNUSED_PARAMETER!>x<!>: Int) {}
+fun baz() = "OK"
+
+class B {
+    fun A.main() {
+        val x = ::foo
+        val y = ::bar
+        val z = ::baz
+
+        x : KFunction0<Unit>
+        y : KFunction1<Int, Unit>
+        z : KFunction0<String>
+    }
+}
@@ -0,0 +1,13 @@
+fun foo() {}
+fun bar(<!UNUSED_PARAMETER!>x<!>: Int) {}
+fun baz() = "OK"
+
+fun main() {
+    val x = ::foo
+    val y = ::bar
+    val z = ::baz
+
+    x : KFunction0<Unit>
+    y : KFunction1<Int, Unit>
+    z : KFunction0<String>
+}
@@ -0,0 +1,11 @@
+class A
+
+fun main() {
+    val <!UNUSED_VARIABLE!>foo<!> = ::<!UNRESOLVED_REFERENCE!>foo<!>
+    
+    ::<!UNRESOLVED_REFERENCE!>bar<!>
+    
+    A::<!UNRESOLVED_REFERENCE!>bar<!>
+    
+    <!UNRESOLVED_REFERENCE!>B<!>::<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>bar<!>
+}