Reflection: add KType.classifier

#KT-8998 In Progress

compiler/testData/codegen/box/reflection/types/classifierIsClass.kt

@@ -0,0 +1,25 @@
+// WITH_REFLECT
+
+import kotlin.test.assertEquals
+
+class Outer<O> {
+    class Nested
+
+    inner class Inner
+}
+
+fun outer(): Outer<String> = null!!
+fun nested(): Outer.Nested = null!!
+fun inner(): Outer<Int>.Inner = null!!
+
+fun array(): Array<String> = null!!
+
+fun box(): String {
+    assertEquals(Outer::class, ::outer.returnType.classifier)
+    assertEquals(Outer.Nested::class, ::nested.returnType.classifier)
+    assertEquals(Outer.Inner::class, ::inner.returnType.classifier)
+
+    assertEquals(Array<String>::class, ::array.returnType.classifier)
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/types/classifierIsTypeParameter.kt

@@ -0,0 +1,23 @@
+// WITH_REFLECT
+
+import kotlin.reflect.KTypeParameter
+import kotlin.test.*
+
+class A<U> {
+    fun <T> foo(): T = null!!
+    fun bar(): Array<U>? = null!!
+}
+
+fun box(): String {
+    val t = A::class.members.single { it.name == "foo" }.returnType
+    assertFalse(t.isMarkedNullable)
+    val tc = t.classifier
+    if (tc !is KTypeParameter) fail(tc.toString())
+    assertEquals("T", tc.name)
+
+    val u = A::class.members.single { it.name == "bar" }.returnType
+    assertTrue(u.isMarkedNullable)
+    assertEquals(Array<Any>::class, u.classifier)
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/types/classifiersOfBuiltInTypes.kt

@@ -0,0 +1,112 @@
+// WITH_REFLECT
+
+import kotlin.reflect.KClass
+import kotlin.reflect.KFunction
+import kotlin.test.assertEquals
+
+fun primitives(
+        p01: Boolean,
+        p02: Byte,
+        p03: Char,
+        p04: Double,
+        p05: Float,
+        p06: Int,
+        p07: Long,
+        p08: Short
+) {}
+
+fun nullablePrimitives(
+        p01: Boolean?,
+        p02: Byte?,
+        p03: Char?,
+        p04: Double?,
+        p05: Float?,
+        p06: Int?,
+        p07: Long?,
+        p08: Short?
+) {}
+
+fun primitiveArrays(
+        p01: BooleanArray,
+        p02: ByteArray,
+        p03: CharArray,
+        p04: DoubleArray,
+        p05: FloatArray,
+        p06: IntArray,
+        p07: LongArray,
+        p08: ShortArray
+) {}
+
+fun others(
+        p1: Array<*>,
+        p2: Array<String>,
+        p3: Array<Array<Int?>?>,
+        p4: List<*>,
+        p5: List<String>?,
+        p6: Map.Entry<Int, Double>,
+        p7: Unit?,
+        p8: String,
+        p9: Nothing
+) {}
+
+inline fun <reified T : Any> wrapper(): KClass<T> = T::class
+
+fun check(f: KFunction<*>, vararg expected: KClass<*>) {
+    val actual = f.parameters.map { it.type.classifier as KClass<*> }
+    for ((e, a) in expected.toList().zip(actual)) {
+        assertEquals(e, a, "$e (${e.java}) != $a (${a.java})")
+    }
+}
+
+fun box(): String {
+    check(
+            ::primitives,
+            Boolean::class,
+            Byte::class,
+            Char::class,
+            Double::class,
+            Float::class,
+            Int::class,
+            Long::class,
+            Short::class
+    )
+
+    check(
+            ::nullablePrimitives,
+            wrapper<Boolean>(),
+            wrapper<Byte>(),
+            wrapper<Char>(),
+            wrapper<Double>(),
+            wrapper<Float>(),
+            wrapper<Int>(),
+            wrapper<Long>(),
+            wrapper<Short>()
+    )
+
+    check(
+            ::primitiveArrays,
+            BooleanArray::class,
+            ByteArray::class,
+            CharArray::class,
+            DoubleArray::class,
+            FloatArray::class,
+            IntArray::class,
+            LongArray::class,
+            ShortArray::class
+    )
+
+    check(
+            ::others,
+            Array<Any>::class,
+            Array<String>::class,
+            Array<Array<Int?>?>::class,
+            List::class,
+            List::class,
+            Map.Entry::class,
+            Unit::class,
+            String::class,
+            Nothing::class
+    )
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/types/platformTypeClassifier.kt

@@ -0,0 +1,37 @@
+// WITH_REFLECT
+// FILE: J.java
+
+import java.util.List;
+
+public class J {
+    public static String string() {
+        return "";
+    }
+
+    public static List<Object> list() {
+        return null;
+    }
+
+    public static int primitiveInt() {
+        return 0;
+    }
+
+    public static Integer wrapperInt() {
+        return 0;
+    }
+}
+
+// FILE: K.kt
+
+import kotlin.reflect.KClass
+import kotlin.test.assertEquals
+
+fun box(): String {
+    assertEquals(String::class, J::string.returnType.classifier)
+    assertEquals(List::class, J::list.returnType.classifier)
+
+    assertEquals(Int::class.javaPrimitiveType!!, (J::primitiveInt.returnType.classifier as KClass<*>).java)
+    assertEquals(Int::class.javaObjectType, (J::wrapperInt.returnType.classifier as KClass<*>).java)
+
+    return "OK"
+}