Move tests on KClass.java* to box/classLiteral/java

Also replace WITH_REFLECT to WITH_RUNTIME to test that these cases correctly
work without reflection in the classpath

compiler/testData/codegen/box/classLiteral/java/java.kt

@@ -0,0 +1,60 @@
+// WITH_RUNTIME
+
+import kotlin.reflect.KClass
+
+fun checkPrimitive(clazz: Class<*>, expected: String) {
+    assert (clazz!!.canonicalName == expected) {
+        "clazz name: ${clazz.canonicalName}"
+    }
+}
+
+fun checkPrimitive(kClass: KClass<*>, expected: String) {
+    checkPrimitive(kClass.java, expected)
+}
+
+fun checkObject(clazz: Class<*>, expected: String) {
+    assert (clazz.canonicalName == "$expected") {
+        "clazz should be object, but found: ${clazz!!.canonicalName}"
+    }
+}
+
+fun checkObject(kClass: KClass<*>, expected: String) {
+    checkObject(kClass.java, expected)
+}
+
+fun box(): String {
+    checkPrimitive(Boolean::class.java, "boolean")
+    checkPrimitive(Boolean::class, "boolean")
+
+    checkPrimitive(Char::class.java, "char")
+    checkPrimitive(Char::class, "char")
+
+    checkPrimitive(Byte::class.java, "byte")
+    checkPrimitive(Byte::class, "byte")
+
+    checkPrimitive(Short::class.java, "short")
+    checkPrimitive(Short::class, "short")
+
+    checkPrimitive(Int::class.java, "int")
+    checkPrimitive(Int::class, "int")
+
+    checkPrimitive(Float::class.java, "float")
+    checkPrimitive(Float::class, "float")
+
+    checkPrimitive(Long::class.java, "long")
+    checkPrimitive(Long::class, "long")
+
+    checkPrimitive(Double::class.java, "double")
+    checkPrimitive(Double::class, "double")
+
+    checkObject(String::class.java, "java.lang.String")
+    checkObject(String::class, "java.lang.String")
+
+    checkObject(Nothing::class.java, "java.lang.Void")
+    checkObject(Nothing::class, "java.lang.Void")
+
+    checkObject(java.lang.Void::class.java, "java.lang.Void")
+    checkObject(java.lang.Void::class, "java.lang.Void")
+
+    return "OK"
+}

compiler/testData/codegen/box/classLiteral/java/javaObjectType.kt

@@ -0,0 +1,50 @@
+// WITH_RUNTIME
+
+import kotlin.reflect.KClass
+
+fun check(clazz: Class<*>?, expected: String) {
+    assert (clazz!!.canonicalName == expected) {
+        "clazz name: ${clazz.canonicalName}"
+    }
+}
+
+fun check(kClass: KClass<*>, expected: String) {
+    check(kClass.javaObjectType, expected)
+}
+
+fun box(): String {
+    check(Boolean::class.javaObjectType, "java.lang.Boolean")
+    check(Boolean::class, "java.lang.Boolean")
+
+    check(Char::class.javaObjectType, "java.lang.Character")
+    check(Char::class, "java.lang.Character")
+
+    check(Byte::class.javaObjectType, "java.lang.Byte")
+    check(Byte::class, "java.lang.Byte")
+
+    check(Short::class.javaObjectType, "java.lang.Short")
+    check(Short::class, "java.lang.Short")
+
+    check(Int::class.javaObjectType, "java.lang.Integer")
+    check(Int::class, "java.lang.Integer")
+
+    check(Float::class.javaObjectType, "java.lang.Float")
+    check(Float::class, "java.lang.Float")
+
+    check(Long::class.javaObjectType, "java.lang.Long")
+    check(Long::class, "java.lang.Long")
+
+    check(Double::class.javaObjectType, "java.lang.Double")
+    check(Double::class, "java.lang.Double")
+
+    check(String::class.javaObjectType, "java.lang.String")
+    check(String::class, "java.lang.String")
+
+    check(Nothing::class.javaObjectType, "java.lang.Void")
+    check(Nothing::class, "java.lang.Void")
+
+    check(Void::class.javaObjectType, "java.lang.Void")
+    check(Void::class, "java.lang.Void")
+
+    return "OK"
+}

compiler/testData/codegen/box/classLiteral/java/javaObjectTypeReified.kt

@@ -0,0 +1,24 @@
+// WITH_RUNTIME
+
+inline fun <reified T : Any> check(expected: String) {
+    val clazz = T::class.javaObjectType!!
+    assert (clazz.canonicalName == "java.lang.$expected") {
+        "clazz name: ${clazz.canonicalName}"
+    }
+}
+
+fun box(): String {
+    check<Boolean>("Boolean")
+    check<Char>("Character")
+    check<Byte>("Byte")
+    check<Short>("Short")
+    check<Int>("Integer")
+    check<Float>("Float")
+    check<Long>("Long")
+    check<Double>("Double")
+
+    check<String>("String")
+    check<Void>("Void")
+
+    return "OK"
+}

compiler/testData/codegen/box/classLiteral/java/javaPrimitiveType.kt

@@ -0,0 +1,60 @@
+// WITH_RUNTIME
+
+import kotlin.reflect.KClass
+
+fun check(clazz: Class<*>?, expected: String) {
+    assert (clazz!!.canonicalName == expected) {
+        "clazz name: ${clazz.canonicalName}"
+    }
+}
+
+fun check(kClass: KClass<*>, expected: String) {
+    check(kClass.javaPrimitiveType, expected)
+}
+
+fun checkNull(clazz: Class<*>?) {
+    assert (clazz == null) {
+        "clazz should be null: ${clazz!!.canonicalName}"
+    }
+}
+
+fun checkNull(kClass: KClass<*>) {
+    checkNull(kClass.javaPrimitiveType)
+}
+
+fun box(): String {
+    check(Boolean::class.javaPrimitiveType, "boolean")
+    check(Boolean::class, "boolean")
+
+    check(Char::class.javaPrimitiveType, "char")
+    check(Char::class, "char")
+
+    check(Byte::class.javaPrimitiveType, "byte")
+    check(Byte::class, "byte")
+
+    check(Short::class.javaPrimitiveType, "short")
+    check(Short::class, "short")
+
+    check(Int::class.javaPrimitiveType, "int")
+    check(Int::class, "int")
+
+    check(Float::class.javaPrimitiveType, "float")
+    check(Float::class, "float")
+
+    check(Long::class.javaPrimitiveType, "long")
+    check(Long::class, "long")
+
+    check(Double::class.javaPrimitiveType, "double")
+    check(Double::class, "double")
+
+    checkNull(String::class.javaPrimitiveType)
+    checkNull(String::class)
+
+    checkNull(Nothing::class.javaPrimitiveType)
+    checkNull(Nothing::class)
+
+    checkNull(Void::class.javaPrimitiveType)
+    checkNull(Void::class)
+
+    return "OK"
+}

compiler/testData/codegen/box/classLiteral/java/javaPrimitiveTypeReified.kt

@@ -0,0 +1,31 @@
+// WITH_RUNTIME
+
+inline fun <reified T : Any> check(expected: String) {
+    val clazz = T::class.javaPrimitiveType!!
+    assert (clazz.canonicalName == expected) {
+        "clazz name: ${clazz.canonicalName}"
+    }
+}
+
+inline fun <reified T : Any> checkNull() {
+    val clazz = T::class.javaPrimitiveType
+    assert (clazz == null) {
+        "clazz should be null: ${clazz!!.canonicalName}"
+    }
+}
+
+fun box(): String {
+    check<Boolean>("boolean")
+    check<Char>("char")
+    check<Byte>("byte")
+    check<Short>("short")
+    check<Int>("int")
+    check<Float>("float")
+    check<Long>("long")
+    check<Double>("double")
+
+    checkNull<String>()
+    checkNull<Void>()
+
+    return "OK"
+}

compiler/testData/codegen/box/classLiteral/java/javaReified.kt

@@ -0,0 +1,24 @@
+// WITH_RUNTIME
+
+inline fun <reified T : Any> check(expected: String) {
+    val clazz = T::class.java!!
+    assert (clazz.canonicalName == "java.lang.$expected") {
+        "clazz name: ${clazz.canonicalName}"
+    }
+}
+
+fun box(): String {
+    check<Boolean>("Boolean")
+    check<Char>("Character")
+    check<Byte>("Byte")
+    check<Short>("Short")
+    check<Int>("Integer")
+    check<Float>("Float")
+    check<Long>("Long")
+    check<Double>("Double")
+
+    check<String>("String")
+    check<Void>("Void")
+
+    return "OK"
+}

compiler/testData/codegen/box/classLiteral/java/kt11943.kt

@@ -0,0 +1,16 @@
+// WITH_RUNTIME
+
+import kotlin.reflect.KClass
+
+val <T : KClass<*>> T.myjava1: Class<*>
+    get() = java
+
+val <E : Any, T : KClass<E>> T.myjava2: Class<E>
+    get() = java
+
+class O
+class K
+
+fun box(): String =
+        O::class.myjava1.getSimpleName() + K::class.myjava2.getSimpleName()
+

compiler/testData/codegen/box/classLiteral/java/objectSuperConstructorCall.kt

@@ -0,0 +1,18 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+abstract class S<T>(val klass: Class<T>) {
+    val result = klass.simpleName
+}
+
+object OK : S<OK>(OK::class.java)
+
+class C {
+    companion object Companion : S<Companion>(Companion::class.java)
+}
+
+fun box(): String {
+    assertEquals("Companion", C.Companion.result)
+    return OK.result
+}