From 4d1b2a8d5b594d0cc4086326389bcafa34fad576 Mon Sep 17 00:00:00 2001 From: Ilya Kirillov Date: Mon, 1 Oct 2018 16:43:15 +0300 Subject: [PATCH] New J2K: Add Java switch statement to Kotlin when expression conversion --- .../jetbrains/kotlin/j2k/ConversionsRunner.kt | 1 + .../kotlin/j2k/JavaToJKTreeBuilder.kt | 30 ++++- .../jetbrains/kotlin/j2k/NewCodeBuilder.kt | 31 ++++- .../org/jetbrains/kotlin/j2k/TreeCopy.kt | 6 + .../conversions/SwitchStatementConversion.kt | 106 ++++++++++++++++++ .../org/jetbrains/kotlin/j2k/tree/impl/j.kt | 25 ++++- .../org/jetbrains/kotlin/j2k/tree/impl/jk.kt | 14 --- .../org/jetbrains/kotlin/j2k/tree/impl/k.kt | 27 ++++- j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt | 22 +++- .../org/jetbrains/kotlin/j2k/tree/jk.kt | 13 +-- j2k/newSrc/org/jetbrains/kotlin/j2k/tree/k.kt | 20 +++- .../kotlin/j2k/tree/visitors/JKVisitor.kt | 12 +- .../kotlin/j2k/tree/visitors/JKVisitorVoid.kt | 26 +++-- 13 files changed, 287 insertions(+), 46 deletions(-) create mode 100644 j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/SwitchStatementConversion.kt diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/ConversionsRunner.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/ConversionsRunner.kt index 1ffe83ba75d..70989138a77 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/ConversionsRunner.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/ConversionsRunner.kt @@ -47,6 +47,7 @@ object ConversionsRunner { +ClassToObjectPromotionConversion() +PolyadicExpressionConversion() +BinaryExpressionConversion() + +SwitchStatementConversion(context) } fun doApply(trees: List, context: ConversionContext) { diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt index 73b194a3d6f..bf3b467412d 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt @@ -40,7 +40,7 @@ class JavaToJKTreeBuilder(var symbolProvider: JKSymbolProvider) { private val modifierMapper = ModifierMapper() - val backAnnotation = mutableMapOf() + val backAnnotation = mutableMapOf()//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() + 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 } } } diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/NewCodeBuilder.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/NewCodeBuilder.kt index 34c33ce2244..a8f8fc7424c 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/NewCodeBuilder.kt +++ b/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 List.headTail(): Pair?> { val head = this.firstOrNull() val tail = if (size <= 1) null else subList(1, size) diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/TreeCopy.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/TreeCopy.kt index a307a2911f1..a87b2ab335d 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/TreeCopy.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/TreeCopy.kt @@ -14,3 +14,9 @@ fun T.copyTree(): T = this.copy() as T else -> TODO("Not supported+$this.toString()") } + +fun T.copyTreeAndDetach(): T = + this.copyTree().also { + if (it.parent != null) it.detach(it.parent!!) + } + diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/SwitchStatementConversion.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/SwitchStatementConversion.kt new file mode 100644 index 00000000000..a26ff4b4c22 --- /dev/null +++ b/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): List = + 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() + .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 List.takeWhileInclusive(predicate: (T) -> Boolean): List = + takeWhile(predicate) + listOfNotNull(find { !predicate(it) }) + + private fun List.blockOrSingle(): JKStatement = + singleOrNull() + ?: JKBlockStatementImpl(JKBlockImpl(this)) + + + private fun JKStatement.singleListOrBlockStatements(): List = + when (this) { + is JKBlockStatement -> block.statements + else -> listOf(this) + } + + private fun isSwitchBreak(statement: JKStatement) = + statement is JKBreakStatement && statement !is JKBreakWithLabelStatement + + private fun List.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) + } +} \ No newline at end of file diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/j.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/j.kt index ca6a192ddef..5c2c96e5dba 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/j.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/j.kt @@ -204,4 +204,27 @@ class JKJavaAssignmentExpressionImpl( override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaAssignmentExpression(this, data) override var expression: JKExpression by child(expression) -} \ No newline at end of file +} + +class JKJavaSwitchStatementImpl( + expression: JKExpression, + cases: List +) : JKJavaSwitchStatement, JKBranchElementBase() { + override var expression: JKExpression by child(expression) + override var cases: List by children(cases) + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaSwitchStatement(this, data) +} + +class JKJavaDefaultSwitchCaseImpl(statements: List) : JKJavaDefaultSwitchCase, JKBranchElementBase() { + override var statements: List by children(statements) + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaDefaultSwitchCase(this, data) +} + +class JKJavaLabelSwitchCaseImpl( + label: JKExpression, + statements: List +) : JKJavaLabelSwitchCase, JKBranchElementBase() { + override var statements: List by children(statements) + override var label: JKExpression by child(label) + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaLabelSwitchCase(this, data) +} diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/jk.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/jk.kt index 0127e9e23ab..2d18ad9266b 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/jk.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/jk.kt @@ -274,20 +274,6 @@ class JKDoWhileStatementImpl(body: JKStatement, condition: JKExpression) : JKDoW override fun accept(visitor: JKVisitor, 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 accept(visitor: JKVisitor, data: D): R = visitor.visitSwitchStatement(this, data) -} - -class JKSwitchLabelStatementImpl(expression: JKExpression) : JKSwitchLabelStatement, JKBranchElementBase() { - override var expression by child(expression) - override fun accept(visitor: JKVisitor, data: D): R = visitor.visitSwitchLabelStatement(this, data) -} - -class JKSwitchDefaultLabelStatementImpl : JKSwitchDefaultLabelStatement, JKElementBase() { - override fun accept(visitor: JKVisitor, data: D): R = visitor.visitSwitchDefaultLabelStatement(this, data) -} class JKBreakStatementImpl : JKBreakStatement, JKElementBase() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitBreakStatement(this, data) diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/k.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/k.kt index b882ef53996..e002aa70c1e 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/k.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/k.kt @@ -219,4 +219,29 @@ class JKKtPrimaryConstructorImpl( override var delegationCall: JKExpression by child(delegationCall) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitKtPrimaryConstructor(this, data) -} \ No newline at end of file +} + +class JKKtWhenStatementImpl( + expression: JKExpression, + cases: List +) : JKKtWhenStatement, JKBranchElementBase() { + override var expression: JKExpression by child(expression) + override var cases: List by children(cases) + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitKtWhenStatement(this, data) +} + +class JKKtWhenCaseImpl(labels: List, statement: JKStatement) : JKKtWhenCase, JKBranchElementBase() { + override var labels: List by children(labels) + override var statement: JKStatement by child(statement) + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitKtWhenCase(this, data) + +} + +class JKKtElseWhenLabelImpl : JKKtElseWhenLabel, JKElementBase() { + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitKtElseWhenLabel(this, data) +} + +class JKKtValueWhenLabelImpl(expression: JKExpression) : JKKtValueWhenLabel, JKBranchElementBase() { + override var expression: JKExpression by child(expression) + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitKtValueWhenLabel(this, data) +} diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt index ec8e342713e..5ea067a6c4c 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt @@ -86,4 +86,24 @@ interface JKJavaAssignmentExpression : JKExpression, JKBranchElement { var field: JKAssignableExpression var expression: JKExpression var operator: JKOperator -} \ No newline at end of file +} + +interface JKJavaSwitchStatement : JKStatement { + var expression: JKExpression + var cases: List +} + +interface JKJavaSwitchCase : JKTreeElement { + fun isDefault(): Boolean + var statements: List +} + +interface JKJavaDefaultSwitchCase : JKJavaSwitchCase { + override fun isDefault(): Boolean = true +} + +interface JKJavaLabelSwitchCase : JKJavaSwitchCase { + override fun isDefault(): Boolean = false + var label: JKExpression +} + diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt index 3d58499f603..655dbac310a 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt +++ b/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 { @@ -260,4 +249,4 @@ interface JKDelegationConstructorCall : JKMethodCallExpression { override val identifier: JKMethodSymbol val expression: JKExpression override val arguments: JKExpressionList -} \ No newline at end of file +} diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/k.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/k.kt index c398a5eed42..364caad75f2 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/k.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/k.kt @@ -56,4 +56,22 @@ interface JKKtAlsoCallExpression : JKKtMethodCallExpression { val parameterName: String } -interface JKKtLiteralExpression : JKLiteralExpression \ No newline at end of file +interface JKKtLiteralExpression : JKLiteralExpression + +interface JKKtWhenStatement : JKStatement { + var expression: JKExpression + var cases: List +} + +interface JKKtWhenCase : JKTreeElement { + var labels: List + var statement: JKStatement +} + +interface JKKtWhenLabel : JKTreeElement + +interface JKKtElseWhenLabel : JKKtWhenLabel + +interface JKKtValueWhenLabel : JKKtWhenLabel { + var expression: JKExpression +} \ No newline at end of file diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitor.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitor.kt index e73fb006d44..37e9adceb13 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitor.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitor.kt @@ -46,9 +46,6 @@ interface JKVisitor { 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 { 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 { 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) } diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitorVoid.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitorVoid.kt index 9b2ddeaaf46..983ee3fe23f 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitorVoid.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitorVoid.kt @@ -89,15 +89,9 @@ interface JKVisitorVoid : JKVisitor { 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 { 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 { 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) }