New J2K: Add Java switch statement to Kotlin when expression conversion

j2k/newSrc/org/jetbrains/kotlin/j2k/ConversionsRunner.kt

@@ -47,6 +47,7 @@ object ConversionsRunner {
             +ClassToObjectPromotionConversion()
             +PolyadicExpressionConversion()
             +BinaryExpressionConversion()
+            +SwitchStatementConversion(context)
         }
 
     fun doApply(trees: List<JKTreeElement>, context: ConversionContext) {

j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt

@@ -40,7 +40,7 @@ class JavaToJKTreeBuilder(var symbolProvider: JKSymbolProvider) {
 
     private val modifierMapper = ModifierMapper()
 
-    val backAnnotation = mutableMapOf<JKElement, PsiElement>()
+    val backAnnotation = mutableMapOf<JKElement, PsiElement>()//TODO preserve consistency
 
     private inner class ExpressionTreeMapper {
         fun PsiExpression?.toJK(): JKExpression {
@@ -72,6 +72,8 @@ class JavaToJKTreeBuilder(var symbolProvider: JKSymbolProvider) {
                 else -> {
                     throw RuntimeException("Not supported: ${this::class}")
                 }
+            }.also {
+                if (this != null) backAnnotation[it] = this
             }
         }
 
@@ -362,9 +364,27 @@ class JavaToJKTreeBuilder(var symbolProvider: JKSymbolProvider) {
                 is PsiBlockStatement -> JKBlockStatementImpl(codeBlock.toJK())
                 is PsiWhileStatement -> JKWhileStatementImpl(with(expressionTreeMapper) { condition.toJK() }, body.toJK())
                 is PsiDoWhileStatement -> JKDoWhileStatementImpl(body.toJK(), with(expressionTreeMapper) { condition.toJK() })
-                is PsiSwitchStatement -> JKSwitchStatementImpl(with(expressionTreeMapper) { expression.toJK() }, body?.toJK() ?: TODO())
+
-                is PsiSwitchLabelStatement -> if (isDefaultCase) JKSwitchDefaultLabelStatementImpl() else
+
-                    JKSwitchLabelStatementImpl(with(expressionTreeMapper) { caseValue.toJK() })
+                is PsiSwitchStatement -> {
+                    val cases = mutableListOf<JKJavaSwitchCase>()
+                    for (statement in body?.statements.orEmpty()) {
+                        when (statement) {
+                            is PsiSwitchLabelStatement ->
+                                cases += if (statement.isDefaultCase)
+                                    JKJavaDefaultSwitchCaseImpl(emptyList())
+                                else
+                                    JKJavaLabelSwitchCaseImpl(
+                                        with(expressionTreeMapper) { statement.caseValue.toJK() },
+                                        emptyList()
+                                    )
+                            else ->
+                                //TODO Handle case then there is no last case
+                                cases.lastOrNull()?.also { it.statements = it.statements + statement.toJK() }
+                        }
+                    }
+                    JKJavaSwitchStatementImpl(with(expressionTreeMapper) { expression.toJK() }, cases)
+                }
                 is PsiBreakStatement -> {
                     if (labelIdentifier != null)
                         JKBreakWithLabelStatementImpl(JKNameIdentifierImpl(labelIdentifier!!.text))
@@ -372,6 +392,8 @@ class JavaToJKTreeBuilder(var symbolProvider: JKSymbolProvider) {
                         JKBreakStatementImpl()
                 }
                 else -> TODO("for ${this::class}")
+            }.also {
+                if (this != null) backAnnotation[it] = this
             }
         }
     }

j2k/newSrc/org/jetbrains/kotlin/j2k/NewCodeBuilder.kt

@@ -53,9 +53,9 @@ class NewCodeBuilder {
             printer.printWithNoIndent("break")
         }
 
-        override fun visitBreakWithLabelStatement(ktBreakWithLabelStatement: JKBreakWithLabelStatement) {
+        override fun visitBreakWithLabelStatement(breakWithLabelStatement: JKBreakWithLabelStatement) {
             printer.printWithNoIndent("break@")
-            printer.printWithNoIndent(ktBreakWithLabelStatement.label.value)
+            printer.printWithNoIndent(breakWithLabelStatement.label.value)
         }
 
         override fun visitModifierList(modifierList: JKModifierList) {
@@ -466,6 +466,31 @@ class NewCodeBuilder {
             printer.printWithNoIndent(" ")
             ktAssignmentStatement.expression.accept(this)
         }
+
+        override fun visitKtWhenStatement(ktWhenStatement: JKKtWhenStatement) {
+            printer.printWithNoIndent("when(")
+            ktWhenStatement.expression.accept(this)
+            printer.printWithNoIndent(")")
+            printer.block(multiline = true) {
+                ktWhenStatement.cases.forEach { it.accept(this) }
+            }
+        }
+
+        override fun visitKtWhenCase(ktWhenCase: JKKtWhenCase) {
+            renderList(ktWhenCase.labels, ", ") {
+                it.accept(this)
+            }
+            printer.printWithNoIndent(" -> ")
+            ktWhenCase.statement.accept(this)
+        }
+
+        override fun visitKtElseWhenLabel(ktElseWhenLabel: JKKtElseWhenLabel) {
+            printer.printWithNoIndent("else")
+        }
+
+        override fun visitKtValueWhenLabel(ktValueWhenLabel: JKKtValueWhenLabel) {
+            ktValueWhenLabel.expression.accept(this)
+        }
     }
 
     private enum class ParenthesisKind(val open: String, val close: String) {
@@ -478,6 +503,8 @@ class NewCodeBuilder {
     }
 }
 
+
+
 private inline fun <T> List<T>.headTail(): Pair<T?, List<T>?> {
     val head = this.firstOrNull()
     val tail = if (size <= 1) null else subList(1, size)

j2k/newSrc/org/jetbrains/kotlin/j2k/TreeCopy.kt

@@ -14,3 +14,9 @@ fun <T : JKElement> T.copyTree(): T =
             this.copy() as T
         else -> TODO("Not supported+$this.toString()")
     }
+
+fun <T : JKElement> T.copyTreeAndDetach(): T =
+    this.copyTree().also {
+        if (it.parent != null) it.detach(it.parent!!)
+    }
+

j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/SwitchStatementConversion.kt

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.j2k.conversions
+
+import com.intellij.psi.PsiElement
+import com.intellij.psi.controlFlow.ControlFlowFactory
+import com.intellij.psi.controlFlow.ControlFlowUtil
+import com.intellij.psi.controlFlow.LocalsOrMyInstanceFieldsControlFlowPolicy
+import org.jetbrains.kotlin.j2k.ConversionContext
+import org.jetbrains.kotlin.j2k.copyTreeAndDetach
+import org.jetbrains.kotlin.j2k.tree.*
+import org.jetbrains.kotlin.j2k.tree.impl.*
+
+
+class SwitchStatementConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+    override fun applyToElement(element: JKTreeElement): JKTreeElement {
+        if (element !is JKJavaSwitchStatementImpl) return recurse(element)
+        element.invalidate()
+        element.cases.forEach { case ->
+            case.statements.forEach { it.detach(case) }
+            if (case is JKJavaLabelSwitchCase) {
+                case.label.detach(case)
+            }
+        }
+        val cases = switchCasesToWhenCases(element.cases)
+        val whenStatement = JKKtWhenStatementImpl(element.expression, cases)
+        return recurse(whenStatement)
+    }
+
+    private fun switchCasesToWhenCases(cases: List<JKJavaSwitchCase>): List<JKKtWhenCase> =
+        if (cases.isEmpty()) emptyList()
+        else {
+            val statements = cases
+                .takeWhileInclusive { it.statements.fallsThrough() }
+                .flatMap { it.statements }
+                .flatMap { it.singleListOrBlockStatements() }
+                .takeWhile { !isSwitchBreak(it) }
+                .map { it.copyTreeAndDetach() }
+                .let {
+                    if (it.size == 1 && cases.first().statements.singleOrNull() is JKBlockStatement)
+                        listOf(JKBlockStatementImpl(JKBlockImpl(it)))
+                    else it
+                }
+            val javaLabels = cases
+                .takeWhileInclusive { it.statements.isEmpty() }
+
+            val statementLabels = javaLabels
+                .filterIsInstance<JKJavaLabelSwitchCase>()
+                .map { JKKtValueWhenLabelImpl(it.label) }
+            val elseLabel = javaLabels
+                .find { it is JKJavaDefaultSwitchCaseImpl }
+                ?.let { JKKtElseWhenLabelImpl() }
+            val elseWhenCase = elseLabel?.let {
+                JKKtWhenCaseImpl(listOf(it), statements.map { it.copyTreeAndDetach() }.blockOrSingle())
+            }
+            val mainWhenCase =
+                if (statementLabels.isNotEmpty()) {
+                    JKKtWhenCaseImpl(statementLabels, statements.blockOrSingle())
+                } else null
+            listOfNotNull(mainWhenCase) +
+                    listOfNotNull(elseWhenCase) +
+                    switchCasesToWhenCases(cases.drop(javaLabels.size))
+        }
+
+    private fun <T> List<T>.takeWhileInclusive(predicate: (T) -> Boolean): List<T> =
+        takeWhile(predicate) + listOfNotNull(find { !predicate(it) })
+
+    private fun List<JKStatement>.blockOrSingle(): JKStatement =
+        singleOrNull()
+            ?: JKBlockStatementImpl(JKBlockImpl(this))
+
+
+    private fun JKStatement.singleListOrBlockStatements(): List<JKStatement> =
+        when (this) {
+            is JKBlockStatement -> block.statements
+            else -> listOf(this)
+        }
+
+    private fun isSwitchBreak(statement: JKStatement) =
+        statement is JKBreakStatement && statement !is JKBreakWithLabelStatement
+
+    private fun List<JKStatement>.fallsThrough(): Boolean =
+        all { it.fallsThrough() }
+
+    private fun JKStatement.fallsThrough(): Boolean =
+        when (this) {
+            //TODO add support of this when will be added
+            // is JKThrowStatement || is JKContinueStatement -> false
+            is JKBreakStatement, is JKReturnStatement -> false
+            is JKBlockStatement -> block.statements.fallsThrough()
+            is JKIfStatement, is JKJavaSwitchStatement, is JKKtWhenStatement ->
+                context.backAnnotator(this)!!.canCompleteNormally()
+            else -> true
+        }
+
+    private fun PsiElement.canCompleteNormally(): Boolean {
+        val controlFlow =
+            ControlFlowFactory.getInstance(project).getControlFlow(this, LocalsOrMyInstanceFieldsControlFlowPolicy.getInstance())
+        val startOffset = controlFlow.getStartOffset(this)
+        val endOffset = controlFlow.getEndOffset(this)
+        return startOffset == -1 || endOffset == -1 || ControlFlowUtil.canCompleteNormally(controlFlow, startOffset, endOffset)
+    }
+}

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/j.kt

@@ -205,3 +205,26 @@ class JKJavaAssignmentExpressionImpl(
 
     override var expression: JKExpression by child(expression)
 }
+
+class JKJavaSwitchStatementImpl(
+    expression: JKExpression,
+    cases: List<JKJavaSwitchCase>
+) : JKJavaSwitchStatement, JKBranchElementBase() {
+    override var expression: JKExpression by child(expression)
+    override var cases: List<JKJavaSwitchCase> by children(cases)
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaSwitchStatement(this, data)
+}
+
+class JKJavaDefaultSwitchCaseImpl(statements: List<JKStatement>) : JKJavaDefaultSwitchCase, JKBranchElementBase() {
+    override var statements: List<JKStatement> by children(statements)
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaDefaultSwitchCase(this, data)
+}
+
+class JKJavaLabelSwitchCaseImpl(
+    label: JKExpression,
+    statements: List<JKStatement>
+) : JKJavaLabelSwitchCase, JKBranchElementBase() {
+    override var statements: List<JKStatement> by children(statements)
+    override var label: JKExpression by child(label)
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaLabelSwitchCase(this, data)
+}

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/jk.kt

@@ -274,20 +274,6 @@ class JKDoWhileStatementImpl(body: JKStatement, condition: JKExpression) : JKDoW
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitDoWhileStatement(this, data)
 }
 
-class JKSwitchStatementImpl(expression: JKExpression, block: JKBlock) : JKSwitchStatement, JKBranchElementBase() {
-    override var block by child(block)
-    override var expression by child(expression)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitSwitchStatement(this, data)
-}
-
-class JKSwitchLabelStatementImpl(expression: JKExpression) : JKSwitchLabelStatement, JKBranchElementBase() {
-    override var expression by child(expression)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitSwitchLabelStatement(this, data)
-}
-
-class JKSwitchDefaultLabelStatementImpl : JKSwitchDefaultLabelStatement, JKElementBase() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitSwitchDefaultLabelStatement(this, data)
-}
 
 class JKBreakStatementImpl : JKBreakStatement, JKElementBase() {
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitBreakStatement(this, data)

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/k.kt

@@ -220,3 +220,28 @@ class JKKtPrimaryConstructorImpl(
 
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtPrimaryConstructor(this, data)
 }
+
+class JKKtWhenStatementImpl(
+    expression: JKExpression,
+    cases: List<JKKtWhenCase>
+) : JKKtWhenStatement, JKBranchElementBase() {
+    override var expression: JKExpression by child(expression)
+    override var cases: List<JKKtWhenCase> by children(cases)
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtWhenStatement(this, data)
+}
+
+class JKKtWhenCaseImpl(labels: List<JKKtWhenLabel>, statement: JKStatement) : JKKtWhenCase, JKBranchElementBase() {
+    override var labels: List<JKKtWhenLabel> by children(labels)
+    override var statement: JKStatement by child(statement)
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtWhenCase(this, data)
+
+}
+
+class JKKtElseWhenLabelImpl : JKKtElseWhenLabel, JKElementBase() {
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtElseWhenLabel(this, data)
+}
+
+class JKKtValueWhenLabelImpl(expression: JKExpression) : JKKtValueWhenLabel, JKBranchElementBase() {
+    override var expression: JKExpression by child(expression)
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtValueWhenLabel(this, data)
+}

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt

@@ -87,3 +87,23 @@ interface JKJavaAssignmentExpression : JKExpression, JKBranchElement {
     var expression: JKExpression
     var operator: JKOperator
 }
+
+interface JKJavaSwitchStatement : JKStatement {
+    var expression: JKExpression
+    var cases: List<JKJavaSwitchCase>
+}
+
+interface JKJavaSwitchCase : JKTreeElement {
+    fun isDefault(): Boolean
+    var statements: List<JKStatement>
+}
+
+interface JKJavaDefaultSwitchCase : JKJavaSwitchCase {
+    override fun isDefault(): Boolean = true
+}
+
+interface JKJavaLabelSwitchCase : JKJavaSwitchCase {
+    override fun isDefault(): Boolean = false
+    var label: JKExpression
+}
+

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt

@@ -216,17 +216,6 @@ interface JKDoWhileStatement : JKLoopStatement {
     var condition: JKExpression
 }
 
-interface JKSwitchStatement : JKStatement {
-    var expression: JKExpression
-    var block: JKBlock
-}
-
-interface JKSwitchLabelStatement : JKStatement {
-    var expression: JKExpression
-}
-
-interface JKSwitchDefaultLabelStatement : JKStatement
-
 interface JKBreakStatement : JKStatement
 
 interface JKBreakWithLabelStatement : JKBreakStatement {

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/k.kt

@@ -57,3 +57,21 @@ interface JKKtAlsoCallExpression : JKKtMethodCallExpression {
 }
 
 interface JKKtLiteralExpression : JKLiteralExpression
+
+interface JKKtWhenStatement : JKStatement {
+    var expression: JKExpression
+    var cases: List<JKKtWhenCase>
+}
+
+interface JKKtWhenCase : JKTreeElement {
+    var labels: List<JKKtWhenLabel>
+    var statement: JKStatement
+}
+
+interface JKKtWhenLabel : JKTreeElement
+
+interface JKKtElseWhenLabel : JKKtWhenLabel
+
+interface JKKtValueWhenLabel : JKKtWhenLabel {
+    var expression: JKExpression
+}

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitor.kt

@@ -46,9 +46,6 @@ interface JKVisitor<out R, in D> {
     fun visitSuperExpression(superExpression: JKSuperExpression, data: D): R = visitExpression(superExpression, data)
     fun visitWhileStatement(whileStatement: JKWhileStatement, data: D): R = visitLoopStatement(whileStatement, data)
     fun visitDoWhileStatement(doWhileStatement: JKDoWhileStatement, data: D): R = visitLoopStatement(doWhileStatement, data)
-    fun visitSwitchStatement(switchStatement: JKSwitchStatement, data: D): R = visitStatement(switchStatement, data)
-    fun visitSwitchLabelStatement(switchLabelStatement: JKSwitchLabelStatement, data: D): R = visitStatement(switchLabelStatement, data)
-    fun visitSwitchDefaultLabelStatement(switchDefaultLabelStatement: JKSwitchDefaultLabelStatement, data: D): R = visitStatement(switchDefaultLabelStatement, data)
     fun visitBreakStatement(breakStatement: JKBreakStatement, data: D): R = visitStatement(breakStatement, data)
     fun visitBreakWithLabelStatement(breakWithLabelStatement: JKBreakWithLabelStatement, data: D): R = visitBreakStatement(breakWithLabelStatement, data)
     fun visitIfStatement(ifStatement: JKIfStatement, data: D): R = visitStatement(ifStatement, data)
@@ -72,6 +69,10 @@ interface JKVisitor<out R, in D> {
     fun visitJavaInstanceOfExpression(javaInstanceOfExpression: JKJavaInstanceOfExpression, data: D): R = visitExpression(javaInstanceOfExpression, data)
     fun visitJavaPolyadicExpression(javaPolyadicExpression: JKJavaPolyadicExpression, data: D): R = visitExpression(javaPolyadicExpression, data)
     fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression, data: D): R = visitExpression(javaAssignmentExpression, data)
+    fun visitJavaSwitchStatement(javaSwitchStatement: JKJavaSwitchStatement, data: D): R = visitStatement(javaSwitchStatement, data)
+    fun visitJavaSwitchCase(javaSwitchCase: JKJavaSwitchCase, data: D): R = visitTreeElement(javaSwitchCase, data)
+    fun visitJavaDefaultSwitchCase(javaDefaultSwitchCase: JKJavaDefaultSwitchCase, data: D): R = visitJavaSwitchCase(javaDefaultSwitchCase, data)
+    fun visitJavaLabelSwitchCase(javaLabelSwitchCase: JKJavaLabelSwitchCase, data: D): R = visitJavaSwitchCase(javaLabelSwitchCase, data)
     fun visitKtProperty(ktProperty: JKKtProperty, data: D): R = visitField(ktProperty, data)
     fun visitKtFunction(ktFunction: JKKtFunction, data: D): R = visitMethod(ktFunction, data)
     fun visitKtConstructor(ktConstructor: JKKtConstructor, data: D): R = visitDeclaration(ktConstructor, data)
@@ -82,4 +83,9 @@ interface JKVisitor<out R, in D> {
     fun visitKtMethodCallExpression(ktMethodCallExpression: JKKtMethodCallExpression, data: D): R = visitMethodCallExpression(ktMethodCallExpression, data)
     fun visitKtAlsoCallExpression(ktAlsoCallExpression: JKKtAlsoCallExpression, data: D): R = visitKtMethodCallExpression(ktAlsoCallExpression, data)
     fun visitKtLiteralExpression(ktLiteralExpression: JKKtLiteralExpression, data: D): R = visitLiteralExpression(ktLiteralExpression, data)
+    fun visitKtWhenStatement(ktWhenStatement: JKKtWhenStatement, data: D): R = visitStatement(ktWhenStatement, data)
+    fun visitKtWhenCase(ktWhenCase: JKKtWhenCase, data: D): R = visitTreeElement(ktWhenCase, data)
+    fun visitKtWhenLabel(ktWhenLabel: JKKtWhenLabel, data: D): R = visitTreeElement(ktWhenLabel, data)
+    fun visitKtElseWhenLabel(ktElseWhenLabel: JKKtElseWhenLabel, data: D): R = visitKtWhenLabel(ktElseWhenLabel, data)
+    fun visitKtValueWhenLabel(ktValueWhenLabel: JKKtValueWhenLabel, data: D): R = visitKtWhenLabel(ktValueWhenLabel, data)
 }

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitorVoid.kt

@@ -89,15 +89,9 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
     override fun visitWhileStatement(whileStatement: JKWhileStatement, data: Nothing?) = visitWhileStatement(whileStatement)
     fun visitDoWhileStatement(doWhileStatement: JKDoWhileStatement) = visitLoopStatement(doWhileStatement, null)
     override fun visitDoWhileStatement(doWhileStatement: JKDoWhileStatement, data: Nothing?) = visitDoWhileStatement(doWhileStatement)
-    fun visitSwitchStatement(switchStatement: JKSwitchStatement) = visitStatement(switchStatement, null)
-    override fun visitSwitchStatement(switchStatement: JKSwitchStatement, data: Nothing?) = visitSwitchStatement(switchStatement)
-    fun visitSwitchLabelStatement(switchLabelStatement: JKSwitchLabelStatement) = visitStatement(switchLabelStatement, null)
-    override fun visitSwitchLabelStatement(switchLabelStatement: JKSwitchLabelStatement, data: Nothing?) = visitSwitchLabelStatement(switchLabelStatement)
-    fun visitSwitchDefaultLabelStatement(switchDefaultLabelStatement: JKSwitchDefaultLabelStatement) = visitStatement(switchDefaultLabelStatement, null)
-    override fun visitSwitchDefaultLabelStatement(switchDefaultLabelStatement: JKSwitchDefaultLabelStatement, data: Nothing?) = visitSwitchDefaultLabelStatement(switchDefaultLabelStatement)
     fun visitBreakStatement(breakStatement: JKBreakStatement) = visitStatement(breakStatement, null)
     override fun visitBreakStatement(breakStatement: JKBreakStatement, data: Nothing?) = visitBreakStatement(breakStatement)
-    fun visitBreakWithLabelStatement(ktBreakWithLabelStatement: JKBreakWithLabelStatement) = visitBreakStatement(ktBreakWithLabelStatement, null)
+    fun visitBreakWithLabelStatement(breakWithLabelStatement: JKBreakWithLabelStatement) = visitBreakStatement(breakWithLabelStatement, null)
     override fun visitBreakWithLabelStatement(breakWithLabelStatement: JKBreakWithLabelStatement, data: Nothing?) = visitBreakWithLabelStatement(breakWithLabelStatement)
     fun visitIfStatement(ifStatement: JKIfStatement) = visitStatement(ifStatement, null)
     override fun visitIfStatement(ifStatement: JKIfStatement, data: Nothing?) = visitIfStatement(ifStatement)
@@ -141,6 +135,14 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
     override fun visitJavaPolyadicExpression(javaPolyadicExpression: JKJavaPolyadicExpression, data: Nothing?) = visitJavaPolyadicExpression(javaPolyadicExpression)
     fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression) = visitExpression(javaAssignmentExpression, null)
     override fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression, data: Nothing?) = visitJavaAssignmentExpression(javaAssignmentExpression)
+    fun visitJavaSwitchStatement(javaSwitchStatement: JKJavaSwitchStatement) = visitStatement(javaSwitchStatement, null)
+    override fun visitJavaSwitchStatement(javaSwitchStatement: JKJavaSwitchStatement, data: Nothing?) = visitJavaSwitchStatement(javaSwitchStatement)
+    fun visitJavaSwitchCase(javaSwitchCase: JKJavaSwitchCase) = visitTreeElement(javaSwitchCase, null)
+    override fun visitJavaSwitchCase(javaSwitchCase: JKJavaSwitchCase, data: Nothing?) = visitJavaSwitchCase(javaSwitchCase)
+    fun visitJavaDefaultSwitchCase(javaDefaultSwitchCase: JKJavaDefaultSwitchCase) = visitJavaSwitchCase(javaDefaultSwitchCase, null)
+    override fun visitJavaDefaultSwitchCase(javaDefaultSwitchCase: JKJavaDefaultSwitchCase, data: Nothing?) = visitJavaDefaultSwitchCase(javaDefaultSwitchCase)
+    fun visitJavaLabelSwitchCase(javaLabelSwitchCase: JKJavaLabelSwitchCase) = visitJavaSwitchCase(javaLabelSwitchCase, null)
+    override fun visitJavaLabelSwitchCase(javaLabelSwitchCase: JKJavaLabelSwitchCase, data: Nothing?) = visitJavaLabelSwitchCase(javaLabelSwitchCase)
     fun visitKtProperty(ktProperty: JKKtProperty) = visitField(ktProperty, null)
     override fun visitKtProperty(ktProperty: JKKtProperty, data: Nothing?) = visitKtProperty(ktProperty)
     fun visitKtFunction(ktFunction: JKKtFunction) = visitMethod(ktFunction, null)
@@ -161,4 +163,14 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
     override fun visitKtAlsoCallExpression(ktAlsoCallExpression: JKKtAlsoCallExpression, data: Nothing?) = visitKtAlsoCallExpression(ktAlsoCallExpression)
     fun visitKtLiteralExpression(ktLiteralExpression: JKKtLiteralExpression) = visitLiteralExpression(ktLiteralExpression, null)
     override fun visitKtLiteralExpression(ktLiteralExpression: JKKtLiteralExpression, data: Nothing?) = visitKtLiteralExpression(ktLiteralExpression)
+    fun visitKtWhenStatement(ktWhenStatement: JKKtWhenStatement) = visitStatement(ktWhenStatement, null)
+    override fun visitKtWhenStatement(ktWhenStatement: JKKtWhenStatement, data: Nothing?) = visitKtWhenStatement(ktWhenStatement)
+    fun visitKtWhenCase(ktWhenCase: JKKtWhenCase) = visitTreeElement(ktWhenCase, null)
+    override fun visitKtWhenCase(ktWhenCase: JKKtWhenCase, data: Nothing?) = visitKtWhenCase(ktWhenCase)
+    fun visitKtWhenLabel(ktWhenLabel: JKKtWhenLabel) = visitTreeElement(ktWhenLabel, null)
+    override fun visitKtWhenLabel(ktWhenLabel: JKKtWhenLabel, data: Nothing?) = visitKtWhenLabel(ktWhenLabel)
+    fun visitKtElseWhenLabel(ktElseWhenLabel: JKKtElseWhenLabel) = visitKtWhenLabel(ktElseWhenLabel, null)
+    override fun visitKtElseWhenLabel(ktElseWhenLabel: JKKtElseWhenLabel, data: Nothing?) = visitKtElseWhenLabel(ktElseWhenLabel)
+    fun visitKtValueWhenLabel(ktValueWhenLabel: JKKtValueWhenLabel) = visitKtWhenLabel(ktValueWhenLabel, null)
+    override fun visitKtValueWhenLabel(ktValueWhenLabel: JKKtValueWhenLabel, data: Nothing?) = visitKtValueWhenLabel(ktValueWhenLabel)
 }