When by enum:

Generate TABLESWITCH/LOOKUPSWITCH bytecode command in case of "when" by enum entries

compiler/testData/codegen/boxWithStdlib/whenEnumOptimization/bigEnum.kt

@@ -0,0 +1,49 @@
+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/boxWithStdlib/whenEnumOptimization/duplicatingItems.kt

@@ -0,0 +1,25 @@
+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/boxWithStdlib/whenEnumOptimization/enumInsideClassObject.kt

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

compiler/testData/codegen/boxWithStdlib/whenEnumOptimization/expression.kt

@@ -0,0 +1,37 @@
+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/boxWithStdlib/whenEnumOptimization/functionLiteralInTopLevel.kt

@@ -0,0 +1,19 @@
+import kotlin.test.assertEquals
+
+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/boxWithStdlib/whenEnumOptimization/manyWhensWithinClass.kt

@@ -0,0 +1,50 @@
+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/boxWithStdlib/whenEnumOptimization/nonConstantEnum.kt

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

compiler/testData/codegen/boxWithStdlib/whenEnumOptimization/subjectAny.kt

@@ -0,0 +1,26 @@
+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/boxWithStdlib/whenEnumOptimization/withoutElse.kt

@@ -0,0 +1,41 @@
+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"
+}