Merge boxWithStdlib testData into box, delete BoxWithStdlib test

compiler/testData/codegen/box/when/enumOptimization/bigEnum.kt

@@ -0,0 +1,52 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+enum class BigEnum {
+    ITEM1, ITEM2, ITEM3, ITEM4, ITEM5, ITEM6, ITEM7, ITEM8, ITEM9, ITEM10,
+    ITEM11, ITEM12, ITEM13, ITEM14, ITEM15, ITEM16, ITEM17, ITEM18, ITEM19, ITEM20
+}
+
+fun bar1(x : BigEnum) : String {
+    when (x) {
+        BigEnum.ITEM1, BigEnum.ITEM2, BigEnum.ITEM3 -> return "123"
+        BigEnum.ITEM4, BigEnum.ITEM5, BigEnum.ITEM6 -> return "456"
+    }
+
+    return "-1";
+
+}
+
+fun bar2(x : BigEnum) : String {
+    when (x) {
+        BigEnum.ITEM7, BigEnum.ITEM8, BigEnum.ITEM9 -> return "789"
+        BigEnum.ITEM10 -> return "10"
+        BigEnum.ITEM11, BigEnum.ITEM12 -> return "1112"
+        else -> return "-1"
+    }
+}
+
+fun box() : String {
+    //bar1
+    assertEquals("123", bar1(BigEnum.ITEM1))
+    assertEquals("123", bar1(BigEnum.ITEM2))
+    assertEquals("123", bar1(BigEnum.ITEM3))
+
+    assertEquals("456", bar1(BigEnum.ITEM4))
+    assertEquals("456", bar1(BigEnum.ITEM5))
+    assertEquals("456", bar1(BigEnum.ITEM6))
+
+    assertEquals("-1", bar1(BigEnum.ITEM7))
+
+    //bar2
+    assertEquals("789", bar2(BigEnum.ITEM7))
+    assertEquals("789", bar2(BigEnum.ITEM8))
+    assertEquals("789", bar2(BigEnum.ITEM9))
+
+    assertEquals("10", bar2(BigEnum.ITEM10))
+
+    assertEquals("1112", bar2(BigEnum.ITEM11))
+    assertEquals("1112", bar2(BigEnum.ITEM12))
+
+    return "OK"
+}

compiler/testData/codegen/box/when/enumOptimization/duplicatingItems.kt

@@ -0,0 +1,27 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+enum class Season {
+    WINTER,
+    SPRING,
+    SUMMER,
+    AUTUMN
+}
+
+fun bar(x : Season) : String {
+    when (x) {
+        Season.WINTER, Season.SPRING -> return "winter_spring"
+        Season.SUMMER, Season.SPRING -> return "summer"
+        else -> return "autumn"
+    }
+}
+
+fun box() : String {
+    assertEquals("winter_spring", bar(Season.WINTER))
+    assertEquals("winter_spring", bar(Season.SPRING))
+    assertEquals("summer", bar(Season.SUMMER))
+    assertEquals("autumn", bar(Season.AUTUMN))
+
+    return "OK"
+}

compiler/testData/codegen/box/when/enumOptimization/enumInsideClassObject.kt

@@ -0,0 +1,31 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+class A {
+    companion object {
+        enum class Season {
+            WINTER,
+            SPRING,
+            SUMMER,
+            AUTUMN
+        }
+    }
+}
+
+fun foo(x : A.Companion.Season) : String {
+    return when (x) {
+        A.Companion.Season.WINTER -> "winter"
+        A.Companion.Season.SPRING -> "spring"
+        A.Companion.Season.SUMMER -> "summer"
+        else -> "other"
+    }
+}
+
+fun box() : String {
+    assertEquals("winter", foo(A.Companion.Season.WINTER))
+    assertEquals("spring", foo(A.Companion.Season.SPRING))
+    assertEquals("summer", foo(A.Companion.Season.SUMMER))
+    assertEquals("other", foo(A.Companion.Season.AUTUMN))
+    return "OK"
+}

compiler/testData/codegen/box/when/enumOptimization/expression.kt

@@ -0,0 +1,39 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+enum class Season {
+    WINTER,
+    SPRING,
+    SUMMER,
+    AUTUMN
+}
+
+fun bar1(x : Season) : String {
+    return when (x) {
+        Season.WINTER, Season.SPRING -> "winter_spring"
+        Season.SUMMER -> "summer"
+        else -> "autumn"
+    }
+}
+
+fun bar2(x : Season) : String {
+    return when (x) {
+        Season.WINTER, Season.SPRING -> "winter_spring"
+        Season.SUMMER -> "summer"
+        Season.AUTUMN -> "autumn"
+    }
+}
+
+fun box() : String {
+    assertEquals("winter_spring", bar1(Season.WINTER))
+    assertEquals("winter_spring", bar1(Season.SPRING))
+    assertEquals("summer", bar1(Season.SUMMER))
+    assertEquals("autumn", bar1(Season.AUTUMN))
+
+    assertEquals("winter_spring", bar2(Season.WINTER))
+    assertEquals("winter_spring", bar2(Season.SPRING))
+    assertEquals("summer", bar2(Season.SUMMER))
+    assertEquals("autumn", bar2(Season.AUTUMN))
+    return "OK"
+}

compiler/testData/codegen/box/when/enumOptimization/functionLiteralInTopLevel.kt

@@ -0,0 +1,17 @@
+enum class Season {
+    WINTER,
+    SPRING,
+    SUMMER,
+    AUTUMN
+}
+
+fun foo(x : Season, block : (Season) -> String) = block(x)
+
+fun box() : String {
+    return foo(Season.SPRING) {
+        x -> when (x) {
+            Season.SPRING -> "OK"
+            else -> "fail"
+        }
+    }
+}

compiler/testData/codegen/box/when/enumOptimization/manyWhensWithinClass.kt

@@ -0,0 +1,52 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+enum class Season {
+    WINTER,
+    SPRING,
+    SUMMER,
+    AUTUMN
+}
+
+class A {
+    public fun bar1(x : Season) : String {
+        when (x) {
+            Season.WINTER, Season.SPRING -> return "winter_spring"
+            Season.SPRING -> return "spring"
+            Season.SUMMER -> return "summer"
+        }
+
+        return "autumn";
+    }
+
+    public fun bar2(y : Season) : String {
+        return bar3(y) { x ->
+            when (x) {
+                Season.WINTER, Season.SPRING -> "winter_spring"
+                Season.SPRING -> "spring"
+                Season.SUMMER -> "summer"
+                else -> "autumn"
+            }
+        }
+    }
+
+    private fun bar3(x : Season, block : (Season) -> String) = block(x)
+}
+
+fun box() : String {
+    val a = A()
+
+    assertEquals("winter_spring", a.bar1(Season.WINTER))
+    assertEquals("winter_spring", a.bar1(Season.SPRING))
+    assertEquals("summer", a.bar1(Season.SUMMER))
+    assertEquals("autumn", a.bar1(Season.AUTUMN))
+
+    assertEquals("winter_spring", a.bar2(Season.WINTER))
+    assertEquals("winter_spring", a.bar2(Season.SPRING))
+    assertEquals("summer", a.bar2(Season.SUMMER))
+    assertEquals("autumn", a.bar2(Season.AUTUMN))
+
+
+    return "OK"
+}

compiler/testData/codegen/box/when/enumOptimization/nullability.kt

@@ -0,0 +1,42 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+enum class Season {
+    WINTER,
+    SPRING,
+    SUMMER,
+    AUTUMN
+}
+
+fun foo1(x : Season?) : String {
+    when(x) {
+        Season.AUTUMN, Season.SPRING -> return "autumn_or_spring";
+        Season.SUMMER, null -> return "summer_or_null"
+    }
+
+    return "other"
+}
+
+fun foo2(x : Season?) : String {
+    when(x) {
+        Season.AUTUMN, Season.SPRING -> return "autumn_or_spring";
+        Season.SUMMER -> return "summer"
+    }
+
+    return "other"
+}
+
+fun box() : String {
+    assertEquals("autumn_or_spring", foo1(Season.AUTUMN))
+    assertEquals("autumn_or_spring", foo1(Season.SPRING))
+    assertEquals("summer_or_null", foo1(Season.SUMMER))
+    assertEquals("summer_or_null", foo1(null))
+
+    assertEquals("autumn_or_spring", foo2(Season.AUTUMN))
+    assertEquals("autumn_or_spring", foo2(Season.SPRING))
+    assertEquals("summer", foo2(Season.SUMMER))
+    assertEquals("other", foo2(null))
+
+    return "OK"
+}

compiler/testData/codegen/box/when/enumOptimization/subjectAny.kt

@@ -0,0 +1,28 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+enum class Season {
+    WINTER,
+    SPRING,
+    SUMMER,
+    AUTUMN
+}
+
+fun foo(x : Any) : String {
+    return when (x) {
+        Season.WINTER -> "winter"
+        Season.SPRING -> "spring"
+        Season.SUMMER -> "summer"
+        else -> "other"
+    }
+}
+
+fun box() : String {
+    assertEquals("winter", foo(Season.WINTER))
+    assertEquals("spring", foo(Season.SPRING))
+    assertEquals("summer", foo(Season.SUMMER))
+    assertEquals("other", foo(Season.AUTUMN))
+    assertEquals("other", foo(123))
+    return "OK"
+}

compiler/testData/codegen/box/when/enumOptimization/withoutElse.kt

@@ -0,0 +1,43 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+enum class Season {
+    WINTER,
+    SPRING,
+    SUMMER,
+    AUTUMN
+}
+
+fun bar1(x : Season) : String {
+    when (x) {
+        Season.WINTER, Season.SPRING -> return "winter_spring"
+        Season.SPRING -> return "spring"
+        Season.SUMMER -> return "summer"
+    }
+    return "autumn"
+}
+
+fun bar2(x : Season) : String {
+    when (x) {
+        Season.WINTER, Season.SPRING -> return "winter_spring"
+        Season.SPRING -> return "spring"
+        Season.SUMMER -> return "summer"
+        Season.AUTUMN -> return "autumn"
+    }
+
+    return "fail unknown"
+}
+
+fun box() : String {
+    assertEquals("winter_spring", bar1(Season.WINTER))
+    assertEquals("winter_spring", bar1(Season.SPRING))
+    assertEquals("summer", bar1(Season.SUMMER))
+    assertEquals("autumn", bar1(Season.AUTUMN))
+
+    assertEquals("winter_spring", bar2(Season.WINTER))
+    assertEquals("winter_spring", bar2(Season.SPRING))
+    assertEquals("summer", bar2(Season.SUMMER))
+    assertEquals("autumn", bar2(Season.AUTUMN))
+    return "OK"
+}