Support mapping of KType to j.l.reflect.Type

2015-08-04 22:29:54 +03:00
parent 49b689f883
commit d3e39812cb
20 changed files with 397 additions and 23 deletions
@@ -0,0 +1,30 @@
+// FULL_JDK
+
+import java.lang.reflect.GenericArrayType
+import java.lang.reflect.TypeVariable
+import java.lang.reflect.ParameterizedType
+import kotlin.reflect.jvm.*
+import kotlin.test.assertEquals
+
+fun foo(strings: Array<String>, integers: Array<Int>, objectArrays: Array<Array<Any>>) {}
+
+fun bar(): Array<List<String>> = null!!
+class A<T> {
+    fun baz(): Array<T> = null!!
+}
+
+fun box(): String {
+    assertEquals(javaClass<Array<String>>(), ::foo.parameters[0].type.javaType)
+    assertEquals(javaClass<Array<Int>>(), ::foo.parameters[1].type.javaType)
+    assertEquals(javaClass<Array<Array<Any>>>(), ::foo.parameters[2].type.javaType)
+
+    val g = ::bar.returnType.javaType
+    if (g !is GenericArrayType || g.genericComponentType !is ParameterizedType)
+        return "Fail: should be array of parameterized type, but was $g (${g.javaClass})"
+
+    val h = A<String>::baz.returnType.javaType
+    if (h !is GenericArrayType || h.genericComponentType !is TypeVariable<*>)
+        return "Fail: should be array of type variable, but was $h (${h.javaClass})"
+
+    return "OK"
+}
@@ -0,0 +1,20 @@
+import kotlin.reflect.*
+import kotlin.reflect.jvm.*
+import kotlin.test.assertEquals
+
+class A(d: Double, s: String, parent: A?) {
+    class Nested(a: A)
+    inner class Inner(nested: Nested)
+}
+
+fun box(): String {
+    assertEquals(listOf(java.lang.Double.TYPE, javaClass<String>(), javaClass<A>()), ::A.parameters.map { it.type.javaType })
+    assertEquals(listOf(javaClass<A>()), A::Nested.parameters.map { it.type.javaType })
+    assertEquals(listOf(javaClass<A>(), javaClass<A.Nested>()), A::Inner.parameters.map { it.type.javaType })
+
+    assertEquals(javaClass<A>(), ::A.returnType.javaType)
+    assertEquals(javaClass<A.Nested>(), A::Nested.returnType.javaType)
+    assertEquals(javaClass<A.Inner>(), A::Inner.returnType.javaType)
+
+    return "OK"
+}
@@ -0,0 +1,21 @@
+import kotlin.platform.platformStatic as static
+import kotlin.reflect.jvm.javaType
+import kotlin.test.assertEquals
+
+class A {
+    fun foo(t: Long?): Long = t!!
+}
+
+object O {
+    static fun bar(a: A): String = ""
+}
+
+fun box(): String {
+    assertEquals(listOf(javaClass<A>(), javaClass<java.lang.Long>()), A::foo.parameters.map { it.type.javaType })
+    assertEquals(listOf(javaClass<O>(), javaClass<A>()), O::bar.parameters.map { it.type.javaType })
+
+    assertEquals(java.lang.Long.TYPE, A::foo.returnType.javaType)
+    assertEquals(javaClass<String>(), O::bar.returnType.javaType)
+
+    return "OK"
+}
@@ -0,0 +1,23 @@
+import kotlin.reflect.jvm.*
+import kotlin.test.*
+
+interface I {
+    fun foo(): Any
+}
+
+class A : I {
+    override fun foo(): Int = 0
+    fun bar(x: Long): Int = x.toInt()
+}
+
+fun box(): String {
+    assertEquals(javaClass<Integer>(), A::foo.returnType.javaType)
+    assertNotEquals(Integer.TYPE, A::foo.returnType.javaType)
+
+    assertNotEquals(javaClass<Integer>(), A::bar.returnType.javaType)
+    assertEquals(Integer.TYPE, A::bar.returnType.javaType)
+
+    assertEquals(java.lang.Long.TYPE, A::bar.parameters.last().type.javaType)
+
+    return "OK"
+}
@@ -0,0 +1,41 @@
+// FULL_JDK
+
+import java.lang.reflect.ParameterizedType
+import kotlin.platform.platformStatic as static
+import kotlin.reflect.*
+import kotlin.reflect.jvm.javaType
+import kotlin.test.assertEquals
+
+class A(private var foo: List<String>)
+
+object O {
+    private static var bar: List<String> = listOf()
+}
+
+fun topLevel(): List<String> = listOf()
+fun Any.extension(): List<String> = listOf()
+
+fun assertGenericType(type: KType) {
+    val javaType = type.javaType
+    if (javaType !is ParameterizedType) {
+        throw AssertionError("Type should be a parameterized type, but was $javaType (${javaType.javaClass})")
+    }
+}
+
+fun box(): String {
+    val foo = A::class.members.single { it.name == "foo" } as KMutableProperty<*>
+    assertGenericType(foo.returnType)
+    assertGenericType(foo.getter.returnType)
+    assertGenericType(foo.setter.parameters.last().type)
+
+    val bar = O::class.members.single { it.name == "bar" } as KMutableProperty<*>
+    assertGenericType(bar.returnType)
+    assertGenericType(bar.getter.returnType)
+    assertGenericType(bar.setter.parameters.last().type)
+
+    assertGenericType(::topLevel.returnType)
+    assertGenericType(Any::extension.returnType)
+    assertGenericType(::A.parameters.single().type)
+
+    return "OK"
+}
@@ -0,0 +1,24 @@
+import kotlin.platform.platformStatic as static
+import kotlin.reflect.KMutableProperty
+import kotlin.reflect.jvm.javaType
+import kotlin.test.assertEquals
+
+class A(private var foo: String)
+
+object O {
+    private static var bar: String = ""
+}
+
+fun box(): String {
+    val foo = A::class.members.single { it.name == "foo" } as KMutableProperty<*>
+    assertEquals(listOf(javaClass<A>()), foo.parameters.map { it.type.javaType })
+    assertEquals(listOf(javaClass<A>()), foo.getter.parameters.map { it.type.javaType })
+    assertEquals(listOf(javaClass<A>(), javaClass<String>()), foo.setter.parameters.map { it.type.javaType })
+
+    val bar = O::class.members.single { it.name == "bar" } as KMutableProperty<*>
+    assertEquals(listOf(javaClass<O>()), bar.parameters.map { it.type.javaType })
+    assertEquals(listOf(javaClass<O>()), bar.getter.parameters.map { it.type.javaType })
+    assertEquals(listOf(javaClass<O>(), javaClass<String>()), bar.setter.parameters.map { it.type.javaType })
+
+    return "OK"
+}
@@ -0,0 +1,15 @@
+import kotlin.reflect.jvm.*
+import kotlin.test.assertEquals
+
+fun free(s: String): Int = s.length()
+
+fun Any.extension() {}
+
+fun box(): String {
+    assertEquals(java.lang.Integer.TYPE, ::free.returnType.javaType)
+    assertEquals(javaClass<String>(), ::free.parameters.single().type.javaType)
+
+    assertEquals(javaClass<Any>(), Any::extension.parameters.single().type.javaType)
+
+    return "OK"
+}
@@ -0,0 +1,20 @@
+// FULL_JDK
+
+import java.lang.reflect.TypeVariable
+import kotlin.reflect.jvm.*
+import kotlin.test.assertEquals
+
+class A<T> {
+    fun foo(t: T) {}
+}
+
+fun box(): String {
+    val f = A<String>::foo
+    val t = f.parameters.last().type.javaType
+    if (t !is TypeVariable<*>) return "Fail, t should be a type variable: $t"
+
+    assertEquals("T", t.name)
+    assertEquals("A", (t.genericDeclaration as Class<*>).name)
+
+    return "OK"
+}
@@ -0,0 +1,21 @@
+import kotlin.reflect.jvm.*
+import kotlin.test.assertEquals
+
+fun foo(unitParam: Unit, nullableUnitParam: Unit?): Unit {}
+
+var bar: Unit = Unit
+
+fun box(): String {
+    assert(javaClass<Unit>() != java.lang.Void.TYPE)
+
+    assertEquals(javaClass<Unit>(), ::foo.parameters[0].type.javaType)
+    assertEquals(javaClass<Unit>(), ::foo.parameters[1].type.javaType)
+    assertEquals(java.lang.Void.TYPE, ::foo.returnType.javaType)
+
+    assertEquals(javaClass<Unit>(), ::bar.returnType.javaType)
+    assertEquals(javaClass<Unit>(), ::bar.getter.returnType.javaType)
+    assertEquals(javaClass<Unit>(), ::bar.setter.parameters.single().type.javaType)
+    assertEquals(java.lang.Void.TYPE, ::bar.setter.returnType.javaType)
+
+    return "OK"
+}