azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Ilya Kirillov
2018-10-01 16:43:15 +03:00
committed by Ilya Kirillov
parent 6e079e38fe
commit 4d1b2a8d5b
13 changed files with 287 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files
j2k/newSrc/org/jetbrains/kotlin/j2k/ConversionsRunner.kt
+1
View File
@@ -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
+26 -4
View File
@@ -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
+29 -2
View File
@@ -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
+6
View File
@@ -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
+106
View File
@@ -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
+24 -1
View File
@@ -204,4 +204,27 @@ class JKJavaAssignmentExpressionImpl(
override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaAssignmentExpression(this, data)
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
-14
View File
@@ -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
+26 -1
View File
@@ -219,4 +219,29 @@ class JKKtPrimaryConstructorImpl(
override var delegationCall: JKExpression by child(delegationCall)
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
+21 -1
View File
@@ -86,4 +86,24 @@ interface JKJavaAssignmentExpression : JKExpression, JKBranchElement {
var field: JKAssignableExpression
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
+1 -12
View File
@@ -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
}
}
j2k/newSrc/org/jetbrains/kotlin/j2k/tree/k.kt
+19 -1
View File
@@ -56,4 +56,22 @@ interface JKKtAlsoCallExpression : JKKtMethodCallExpression {
val parameterName: String
}
interface JKKtLiteralExpression : JKLiteralExpression
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
+9 -3
View File
@@ -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
+19 -7
View File
@@ -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)
}