Add WITH_RUNTIME and WITH_REFLECT directives to box tests

Currently all tests in boxWithStdlib/ run with both runtime and reflection
included; eventually they'll be merged into box/ using these directives

compiler/testData/codegen/box/reflection/defaultImplsGenericSignature.kt

@@ -0,0 +1,44 @@
+// FILE: J.java
+
+public class J {
+
+    public static int test1() {
+        A<String, B<String>> x = new X<String, B<String>>("O", new B<String>("K"));
+        return A.DefaultImpls.test1(x, 1, 1.0);
+    }
+
+
+    public static A<String, B<String>> test2(){
+        X<String, B<String>> x = new X<String, B<String>>("O", new B<String>("K"));
+        return A.DefaultImpls.test2(x, 1);
+    }
+}
+
+// FILE: K.kt
+
+class B<T>(val value: T)
+
+interface A<T, Y : B<T>> {
+
+    fun <T, L> test1(p: T, z: L): T {
+        return p
+    }
+
+    fun <L> test2(p: L): A<T, Y> {
+        return this
+    }
+}
+
+
+class X<T, Y : B<T>>(val p1: T, val p2: Y) : A<T, Y> {
+
+}
+
+fun box(): String {
+    val test1 = J.test1()
+    if (test1 != 1) return "fail 1: $test1 != 1"
+
+    val test2: X<String, B<String>> = J.test2() as X<String, B<String>>
+
+    return test2.p1 + test2.p2.value
+}

compiler/testData/codegen/box/reflection/noKotlinReflect/javaClass.kt

@@ -0,0 +1,33 @@
+// WITH_RUNTIME
+
+import kotlin.test.*
+
+class Klass
+
+fun box(): String {
+    val kClass = Klass::class
+    val jClass = kClass.java
+    val kjClass = Klass::class.java
+    val kkClass = jClass.kotlin
+    val jjClass = kkClass.java
+
+    assertEquals("Klass", jClass.getSimpleName())
+    assertEquals("Klass", kjClass.getSimpleName())
+    assertEquals("Klass", kkClass.java.simpleName)
+    assertEquals(kjClass, jjClass)
+
+    try { kClass.simpleName; return "Fail 1" } catch (e: Error) {}
+    try { kClass.qualifiedName; return "Fail 2" } catch (e: Error) {}
+    try { kClass.members; return "Fail 3" } catch (e: Error) {}
+
+    val jlError = Error::class.java
+    val kljError = Error::class
+    val jljError = kljError.java
+    val jlkError = jlError.kotlin
+
+    assertEquals("Error", jlError.getSimpleName())
+    assertEquals("Error", jljError.getSimpleName())
+    assertEquals("Error", jlkError.java.simpleName)
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/noKotlinReflect/methodsFromAny/callableReferences.kt

@@ -0,0 +1,31 @@
+// WITH_RUNTIME
+
+import kotlin.reflect.KCallable
+import kotlin.test.*
+
+class M {
+    fun foo() {}
+    val bar = 1
+}
+
+fun checkEquals(x: KCallable<*>, y: KCallable<*>) {
+    assertEquals(x, y)
+    assertEquals(y, x)
+    assertEquals(x.hashCode(), y.hashCode())
+}
+
+fun checkToString(x: KCallable<*>, expected: String) {
+    assertEquals(expected + " (Kotlin reflection is not available)", x.toString())
+}
+
+fun box(): String {
+    checkEquals(M::foo, M::foo)
+    checkEquals(M::bar, M::bar)
+    checkEquals(::M, ::M)
+
+    checkToString(M::foo, "function foo")
+    checkToString(M::bar, "property bar")
+    checkToString(::M, "constructor")
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/noKotlinReflect/methodsFromAny/classReference.kt

@@ -0,0 +1,24 @@
+// WITH_RUNTIME
+
+import kotlin.reflect.KClass
+import kotlin.test.*
+
+class M
+
+fun check(x: KClass<*>) {
+    assertEquals(x, x.java.kotlin)
+    assertEquals(x.hashCode(), x.java.kotlin.hashCode())
+    assertEquals(x.java.toString() + " (Kotlin reflection is not available)", x.toString())
+}
+
+fun box(): String {
+    check(M::class)
+    check(String::class)
+    check(Error::class)
+    check(Int::class)
+    check(java.lang.Integer::class)
+    check(MutableList::class)
+    check(Array<String>::class)
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/noKotlinReflect/primitiveJavaClass.kt

@@ -0,0 +1,20 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun check(name: String, c: Class<*>) {
+    assertEquals(name, c.simpleName)
+}
+
+fun box(): String {
+    check("boolean", Boolean::class.java)
+    check("byte", Byte::class.java)
+    check("char", Char::class.java)
+    check("short", Short::class.java)
+    check("int", Int::class.java)
+    check("float", Float::class.java)
+    check("long", Long::class.java)
+    check("double", Double::class.java)
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/noKotlinReflect/propertyGetSetName.kt

@@ -0,0 +1,16 @@
+// WITH_RUNTIME
+
+import kotlin.reflect.*
+
+data class Box(val value: String)
+
+var pr = Box("first")
+
+fun box(): String {
+    val p = ::pr
+    if (p.get().value != "first") return "Fail value 1: ${p.get()}"
+    if (p.name != "pr") return "Fail name: ${p.name}"
+    p.set(Box("second"))
+    if (p.get().value != "second") return "Fail value 2: ${p.get()}"
+    return "OK"
+}

compiler/testData/codegen/box/reflection/noKotlinReflect/propertyInstanceof.kt

@@ -0,0 +1,37 @@
+// WITH_RUNTIME
+
+import kotlin.reflect.*
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+
+class A {
+    val readonly: String = ""
+    var mutable: String = ""
+}
+
+val readonly: String = ""
+var mutable: String = ""
+
+fun box(): String {
+    assertTrue(::readonly is KProperty0<*>)
+    assertFalse(::readonly is KMutableProperty0<*>)
+    assertFalse(::readonly is KProperty1<*, *>)
+    assertFalse(::readonly is KProperty2<*, *, *>)
+
+    assertTrue(::mutable is KProperty0<*>)
+    assertTrue(::mutable is KMutableProperty0<*>)
+    assertFalse(::mutable is KProperty1<*, *>)
+    assertFalse(::mutable is KProperty2<*, *, *>)
+
+    assertFalse(A::readonly is KProperty0<*>)
+    assertTrue(A::readonly is KProperty1<*, *>)
+    assertFalse(A::readonly is KMutableProperty1<*, *>)
+    assertFalse(A::readonly is KProperty2<*, *, *>)
+
+    assertFalse(A::mutable is KProperty0<*>)
+    assertTrue(A::mutable is KProperty1<*, *>)
+    assertTrue(A::mutable is KMutableProperty1<*, *>)
+    assertFalse(A::mutable is KProperty2<*, *, *>)
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/noKotlinReflect/reifiedTypeJavaClass.kt

@@ -0,0 +1,22 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+class Klass
+
+inline fun <reified T : Any> simpleName(): String =
+        T::class.java.getSimpleName()
+
+inline fun <reified T : Any> simpleName2(): String {
+    val kClass = T::class // Intrinsic for T::class.java is not used
+    return kClass.java.getSimpleName()
+}
+
+
+fun box(): String {
+    assertEquals("Integer", simpleName<Int>())
+    assertEquals("Integer", simpleName2<Int>())
+    assertEquals("Klass", simpleName<Klass>())
+
+    return "OK"
+}

compiler/testData/codegen/box/reflection/noKotlinReflect/simpleClassLiterals.kt

@@ -0,0 +1,14 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertNotNull
+
+class Klass
+
+fun box(): String {
+    assertNotNull(Int::class)
+    assertNotNull(String::class)
+    assertNotNull(Klass::class)
+    assertNotNull(Error::class)
+
+    return "OK"
+}