Remove some legacy codegen tests, move some to generated

compiler/testData/codegen/box/closures/noRefToOuter.kt

@@ -0,0 +1,19 @@
+// WITH_RUNTIME
+
+class A {
+    fun f(): () -> String {
+        val s = "OK"
+        return { -> s }
+    }
+}
+
+fun box(): String {
+    val lambdaClass = A().f().javaClass
+    val fields = lambdaClass.getDeclaredFields().toList()
+    if (fields.size != 1) return "Fail: lambda should only capture 's': $fields"
+
+    val fieldName = fields[0].getName()
+    if (fieldName != "\$s") return "Fail: captured variable should be named '\$s': $fields"
+
+    return "OK"
+}

compiler/testData/codegen/box/controlStructures/continueInWhile.kt

@@ -0,0 +1,16 @@
+fun foo(i: Int): Int {
+  var count = i;
+  var result = 0;
+  while(count > 0) {
+    count = count - 1;
+    if (count <= 2) continue;
+    result = result + count;
+  }
+  return result;
+}
+
+fun box(): String {
+  if (foo(4) != 3) return "Fail 1"
+  if (foo(5) != 7) return "Fail 2"
+  return "OK"
+}

compiler/testData/codegen/box/controlStructures/factorialTest.kt

@@ -0,0 +1,44 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun facWhile(i: Int): Int {
+    var count = 1;
+    var result = 1;
+    while(count < i) {
+        count = count + 1;
+        result = result * count;
+    }
+    return result;
+}
+
+fun facBreak(i: Int): Int {
+    var count = 1;
+    var result = 1;
+    while(true) {
+        count = count + 1;
+        result = result * count;
+        if (count == i) break;
+    }
+    return result;
+}
+
+fun facDoWhile(i: Int): Int {
+    var count = 1;
+    var result = 1;
+    do {
+        count = count + 1;
+        result = result * count;
+    } while(count != i);
+    return result;
+}
+
+fun box(): String {
+    assertEquals(6, facWhile(3))
+    assertEquals(6, facBreak(3))
+    assertEquals(6, facDoWhile(3))
+    assertEquals(120, facWhile(5))
+    assertEquals(120, facBreak(5))
+    assertEquals(120, facDoWhile(5))
+    return "OK"
+}

compiler/testData/codegen/box/delegation/delegationToVal.kt

@@ -0,0 +1,46 @@
+// WITH_RUNTIME
+// FULL_JDK
+
+interface IActing {
+    fun act(): String
+}
+
+class CActing(val value: String = "OK") : IActing {
+    override fun act(): String = value
+}
+
+// final so no need in delegate field
+class Test(val acting: CActing = CActing()) : IActing by acting {
+}
+
+// even if open so we don't need delegate field
+open class Test2(open val acting: CActing = CActing()) : IActing by acting {
+}
+
+// even if open the backing field is final, so we don't need delegate field
+class Test3() : Test2() {
+    override val acting = CActing("OKOK")
+}
+
+fun box(): String {
+    try {
+        Test::class.java.getDeclaredField("\$delegate_0")
+        return "\$delegate_0 field generated for class Test but should not"
+    }
+    catch (e: NoSuchFieldException) {
+        // ok
+    }
+
+    try {
+        Test2::class.java.getDeclaredField("\$delegate_0")
+        return "\$delegate_0 field generated for class Test but should not"
+    }
+    catch (e: NoSuchFieldException) {
+        // ok
+    }
+
+    if (Test3().acting.act() != "OKOK") return "Fail Test3"
+
+    val test = Test()
+    return test.act()
+}

compiler/testData/codegen/box/enum/classForEnumEntry.kt

@@ -0,0 +1,32 @@
+// WITH_RUNTIME
+
+enum class IssueState {
+    DEFAULT,
+    FIXED {
+        override fun ToString() = "K"
+    };
+
+    open fun ToString(): String = "O"
+}
+
+fun box(): String {
+    val field = IssueState::class.java.getField("FIXED")
+
+    val typeName = field.type.name
+    if (typeName != "IssueState") return "Fail type name: $typeName"
+
+    val className = field.get(null).javaClass.name
+    if (className != "IssueState\$FIXED") return "Fail class name: $className"
+
+    val classLoader = IssueState::class.java.classLoader
+    classLoader.loadClass("IssueState\$FIXED")
+    try {
+        classLoader.loadClass("IssueState\$DEFAULT")
+        return "Fail: no class should have been generated for DEFAULT"
+    }
+    catch (e: Exception) {
+        // ok
+    }
+
+    return IssueState.DEFAULT.ToString() + IssueState.FIXED.ToString()
+}

compiler/testData/codegen/box/enum/modifierFlags.kt

@@ -0,0 +1,27 @@
+// WITH_RUNTIME
+// FULL_JDK
+
+import java.lang.reflect.Modifier
+
+enum class En {
+    Y
+}
+
+fun box(): String {
+    val klass = En::class.java
+    val superclass = klass.superclass.name
+    if (superclass != "java.lang.Enum") "Fail superclass: $superclass"
+
+    val enumModifiers = klass.modifiers
+    if ((enumModifiers and 0x4000) == 0) return "Fail ACC_ENUM on class"
+    if ((enumModifiers and Modifier.FINAL) == 0) return "Fail FINAL on class"
+
+    val entry = klass.getField("Y")
+    val entryModifiers = entry.modifiers
+    if ((entryModifiers and 0x4000) == 0) return "Fail ACC_ENUM on entry"
+    if ((entryModifiers and Modifier.FINAL) == 0) return "Fail FINAL on entry"
+    if ((entryModifiers and Modifier.STATIC) == 0) return "Fail FINAL on entry"
+    if ((entryModifiers and Modifier.PUBLIC) == 0) return "Fail FINAL on entry"
+
+    return "OK"
+}

compiler/testData/codegen/box/enum/name.kt

@@ -1,6 +0,0 @@
-enum class State {
-  O,
-  K
-}
-
-fun box() = "${State.O.name}${State.K.name}"

compiler/testData/codegen/box/enum/noClassForSimpleEnum.kt

@@ -0,0 +1,14 @@
+// WITH_RUNTIME
+
+enum class State {
+    O,
+    K
+}
+
+fun box(): String {
+    val field = State::class.java.getField("O")
+    val className = field.get(null).javaClass.name
+    if (className != "State") return "Fail: $className"
+
+    return "${State.O.name}${State.K.name}"
+}

compiler/testData/codegen/box/enum/openMethod.kt

@@ -1,10 +0,0 @@
-fun box() = IssueState.DEFAULT.ToString() + IssueState.FIXED.ToString()
-
-enum class IssueState {
-   DEFAULT,
-   FIXED {
-       override fun ToString() = "K"
-   };
-
-   open fun ToString() : String = "O"
-}

compiler/testData/codegen/box/typeMapping/kt309.kt

@@ -0,0 +1,12 @@
+// WITH_RUNTIME
+
+class N {
+    fun foo() = null
+}
+
+fun box(): String {
+    val method = N::class.java.getDeclaredMethod("foo")
+    if (method.returnType.name != "java.lang.Void") return "Fail: Nothing should be mapped to Void"
+    
+    return "OK"
+}

compiler/testData/codegen/box/when/exceptionOnNoMatch.kt

@@ -0,0 +1,14 @@
+fun isZero(x: Int) = when(x) {
+    0 -> true
+    else -> throw Exception()
+}
+
+fun box(): String {
+    try {
+	isZero(1)
+    }
+    catch (e: Exception) {
+        return "OK"
+    }
+    return "Fail"
+}

compiler/testData/codegen/box/when/multipleEntries.kt

@@ -0,0 +1,12 @@
+fun foo(x: Any) =
+        when (x) {
+            0, 1 -> "bit"
+            else -> "something"
+        }
+
+fun box(): String {
+    if (foo(0) != "bit") return "Fail 0"
+    if (foo(1) != "bit") return "Fail 1"
+    if (foo(2) != "something") return "Fail 2"
+    return "OK"
+}