diff --git a/j2k/src/org/jetbrains/jet/j2k/ast/Statements.kt b/j2k/src/org/jetbrains/jet/j2k/ast/Statements.kt
index d45abc90f50..fd76d98e18a 100644
--- a/j2k/src/org/jetbrains/jet/j2k/ast/Statements.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/ast/Statements.kt
@@ -149,32 +149,34 @@ class CatchStatement(val variable: Parameter, val block: Block) : Statement() {
     }
 }
 
-// Switch --------------------------------------------------------------------------------------------------
+// when --------------------------------------------------------------------------------------------------
 
-class SwitchContainer(val expression: Expression, val caseContainers: List<CaseContainer>) : Statement() {
+class WhenStatement(val subject: Expression, val caseContainers: List<WhenEntry>) : Statement() {
     override fun generateCode(builder: CodeBuilder) {
-        builder.append("when (").append(expression).append(") {\n").append(caseContainers, "\n").append("\n}")
+        builder.append("when (").append(subject).append(") {\n").append(caseContainers, "\n").append("\n}")
     }
 }
 
-class CaseContainer(val caseStatement: List<Element>, statements: List<Statement>) : Statement() {
+class WhenEntry(val selectors: List<WhenEntrySelector>, statements: List<Statement>) : Statement() {
     private val block = run {
         val filteredStatements = statements.filterNot { it is BreakStatement || it is ContinueStatement }
         Block(filteredStatements, LBrace().assignNoPrototype(), RBrace().assignNoPrototype(), true).assignNoPrototype()
     }
 
     override fun generateCode(builder: CodeBuilder) {
-        builder.append(caseStatement, ", ").append(" -> ").append(block)
+        builder.append(selectors, ", ").append(" -> ").append(block)
     }
 }
 
-class SwitchLabelStatement(val expression: Expression) : Statement() {
+abstract class WhenEntrySelector : Statement()
+
+class ValueWhenEntrySelector(val expression: Expression) : WhenEntrySelector() {
     override fun generateCode(builder: CodeBuilder) {
         builder.append(expression)
     }
 }
 
-class DefaultSwitchLabelStatement() : Statement() {
+class ElseWhenEntrySelector() : WhenEntrySelector() {
     override fun generateCode(builder: CodeBuilder) {
         builder.append("else")
     }
diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.kt b/j2k/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.kt
index 6b925bcec26..889c9693da7 100644
--- a/j2k/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.kt
+++ b/j2k/src/org/jetbrains/jet/j2k/visitors/StatementVisitor.kt
@@ -200,57 +200,50 @@ open class StatementVisitor(public val converter: Converter) : JavaElementVisito
 
     override fun visitSwitchLabelStatement(statement: PsiSwitchLabelStatement) {
         result = if (statement.isDefaultCase())
-            DefaultSwitchLabelStatement()
+            ElseWhenEntrySelector()
         else
-            SwitchLabelStatement(converter.convertExpression(statement.getCaseValue()))
+            ValueWhenEntrySelector(converter.convertExpression(statement.getCaseValue()))
     }
 
     override fun visitSwitchStatement(statement: PsiSwitchStatement) {
-        result = SwitchContainer(converter.convertExpression(statement.getExpression()),
-                                   switchBodyToCases(statement.getBody()))
+        result = WhenStatement(converter.convertExpression(statement.getExpression()), switchBodyToWhenEntries(statement.getBody()))
     }
 
-    private fun switchBodyToCases(body: PsiCodeBlock?): List<CaseContainer> {
+    private fun switchBodyToWhenEntries(body: PsiCodeBlock?): List<WhenEntry> {
         val cases: List<List<PsiElement>> = splitToCases(body)
         val allSwitchStatements = ArrayList<PsiElement>()
         if (body != null) {
             allSwitchStatements.addAll(body.getStatements())
         }
-        val result = ArrayList<CaseContainer>()
-        var pendingLabels = ArrayList<Element>()
+        val result = ArrayList<WhenEntry>()
+        var pendingSelectors = ArrayList<WhenEntrySelector>()
         var i = 0
         var hasDefaultCase = false
         for (ls in cases) {
-            if (ls.size() > 0) {
-                var label = ls[0] as PsiSwitchLabelStatement
+            if (ls.isNotEmpty()) {
+                val label = ls[0] as PsiSwitchLabelStatement
                 hasDefaultCase = hasDefaultCase || label.isDefaultCase()
                 // TODO assert {(label is PsiSwitchLabelStatement?)}
                 // TODO assert("not a right index") {allSwitchStatements?.get(i) == label}
+                pendingSelectors.add(converter.convertStatement(label) as WhenEntrySelector)
                 if (ls.size() > 1) {
-                    pendingLabels.add(converter.convertStatement(label))
-                    val slice = ls.subList(1, (ls.size()))
+                    val slice = ls.drop(1)
 
                     fun convertStatements(elements: List<PsiElement>): List<Statement>
                             = elements.map { if (it is PsiStatement) converter.convertStatement(it) else null }.filterNotNull()
 
                     if (!containsBreak(slice)) {
                         val statements = convertStatements(slice) + convertStatements(getAllToNextBreak(allSwitchStatements, i + ls.size()))
-                        result.add(CaseContainer(pendingLabels, statements).assignNoPrototype())
+                        result.add(WhenEntry(pendingSelectors, statements).assignNoPrototype())
                     }
                     else {
-                        result.add(CaseContainer(pendingLabels, convertStatements(slice)).assignNoPrototype())
+                        result.add(WhenEntry(pendingSelectors, convertStatements(slice)).assignNoPrototype())
                     }
-                    pendingLabels = ArrayList()
-                }
-                else {
-                    pendingLabels.add(converter.convertStatement(label))
+                    pendingSelectors = ArrayList()
                 }
                 i += ls.size()
             }
         }
-        if (!hasDefaultCase) {
-            result.add(CaseContainer(listOf(DefaultSwitchLabelStatement().assignNoPrototype()), listOf()).assignNoPrototype())
-        }
         return result
     }
 
diff --git a/j2k/tests/testData/ast/switch/emptySwitch.kt b/j2k/tests/testData/ast/switch/emptySwitch.kt
index dcb6aad751b..2dca28060d9 100644
--- a/j2k/tests/testData/ast/switch/emptySwitch.kt
+++ b/j2k/tests/testData/ast/switch/emptySwitch.kt
@@ -5,8 +5,7 @@ public class NonDefault {
             val value = 3
             val valueString = ""
             when (value) {
-                else -> {
-                }
+
             }
             System.out.println(valueString)
         }
diff --git a/j2k/tests/testData/ast/switch/nondefault.kt b/j2k/tests/testData/ast/switch/nondefault.kt
index 11fca34208a..29c85c4da2b 100644
--- a/j2k/tests/testData/ast/switch/nondefault.kt
+++ b/j2k/tests/testData/ast/switch/nondefault.kt
@@ -14,8 +14,6 @@ public class NonDefault {
                 3 -> {
                     valueString = "THREE"
                 }
-                else -> {
-                }
             }
             System.out.println(valueString)
         }