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 03ae34cb636..8fa9a4ef58e 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/jk.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/jk.kt @@ -23,9 +23,9 @@ import org.jetbrains.kotlin.j2k.tree.visitors.JKVisitor abstract class JKElementBase : JKElement { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitElement(this, data) - override fun acceptChildren(visitor: JKVisitor, data: D) {} + override fun transform(transformer: JKTransformer, data: D): R = accept(transformer, data) as R - override fun transform(transformer: JKTransformer, data: D): E = transformer.transformElement(this, data) + override fun acceptChildren(visitor: JKVisitor, data: D) {} override fun transformChildren(transformer: JKTransformer, data: D) {} } diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt index 4a9654acbae..3d691d5a28b 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt @@ -22,11 +22,9 @@ import org.jetbrains.kotlin.j2k.tree.visitors.JKVisitor interface JKElement { fun accept(visitor: JKVisitor, data: D): R + fun transform(transformer: JKTransformer, data: D): R fun acceptChildren(visitor: JKVisitor, data: D) - - fun transform(transformer: JKTransformer, data: D): E - fun transformChildren(transformer: JKTransformer, data: D) } diff --git a/j2k/GenerateJKTreeVisitorAndTransformer.kts b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/GenerateJKTreeVisitorAndTransformer.kts similarity index 78% rename from j2k/GenerateJKTreeVisitorAndTransformer.kts rename to j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/GenerateJKTreeVisitorAndTransformer.kts index 8349d0b9c12..62ef87de832 100644 --- a/j2k/GenerateJKTreeVisitorAndTransformer.kts +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/GenerateJKTreeVisitorAndTransformer.kts @@ -30,6 +30,22 @@ * limitations under the License. */ +/* + * Copyright 2010-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + import java.io.File @@ -60,7 +76,7 @@ fun String.safeVarName() = when (this) { else -> this } -fun genVisitors(commonData: List, uncommonData: List, visitorName: String, transformerName: String, visitorExtends: String? = null, transformerExtends: String? = null) { +fun genVisitors(commonData: List, uncommonData: List, visitorName: String, transformerName: String) { val interfaceData = commonData + uncommonData @@ -78,8 +94,7 @@ fun genVisitors(commonData: List, uncommonData: List" } ?: "" - appendln("interface $visitorName$extends {") + appendln("interface $visitorName {") interfaceData.joinTo(this, separator = "\n") { (name, ext) -> val nameWithoutPrefix = name.removePrefix("JK") val argName = nameWithoutPrefix.decapitalize().safeVarName() @@ -98,9 +113,8 @@ fun genVisitors(commonData: List, uncommonData: List$extends {") + appendln("interface ${visitorName}Void : $visitorName {") interfaceData.joinTo(this, separator = "\n") { (name, ext) -> val nameWithoutPrefix = name.removePrefix("JK") val argName = nameWithoutPrefix.decapitalize().safeVarName() @@ -120,18 +134,20 @@ fun genVisitors(commonData: List, uncommonData: List" } ?: "" - appendln("interface $transformerName$extends {") + appendln("interface $transformerName : JKVisitor {") interfaceData.joinTo(this, separator = "\n") { (name, ext) -> val nameWithoutPrefix = name.removePrefix("JK") val argName = nameWithoutPrefix.decapitalize().safeVarName() - val generifyCall = if (name != "JKElement") "= transform${ext!!.removePrefix("JK")}($argName, data)" else "" val leastCommonName = name.firstCommonInterfaceName() + val cast = "as $leastCommonName".takeIf { leastCommonName == name } ?: "" + + val generifyCall = if (name != "JKElement") "= visit${ext!!.removePrefix("JK")}($argName, data) $cast" else "" + """ - | fun transform$nameWithoutPrefix($argName: $name, data: D): E $generifyCall + | override fun visit$nameWithoutPrefix($argName: $name, data: D): $leastCommonName $generifyCall """.trimMargin() } appendln() @@ -144,19 +160,21 @@ fun genVisitors(commonData: List, uncommonData: List$extends {") + + appendln("interface ${transformerName}Void : $transformerName {") interfaceData.joinTo(this, separator = "\n") { (name, ext) -> val nameWithoutPrefix = name.removePrefix("JK") val argName = nameWithoutPrefix.decapitalize().safeVarName() val arg = "$argName: $name" - val generifyCall = if (name != "JKElement") "= transform${ext!!.removePrefix("JK")}($argName, null)" else "" val leastCommonName = name.firstCommonInterfaceName() + val cast = "as $leastCommonName".takeIf { leastCommonName == name } ?: "" + val generifyCall = if (name != "JKElement") "= visit${ext!!.removePrefix("JK")}($argName) $cast" else "" + """ - | fun transform$nameWithoutPrefix($arg): E $generifyCall - | override fun transform$nameWithoutPrefix($arg, data: Nothing?): E = transform$nameWithoutPrefix($argName) + | fun visit$nameWithoutPrefix($arg): $leastCommonName $generifyCall + | override fun visit$nameWithoutPrefix($arg, data: Nothing?): $leastCommonName = visit$nameWithoutPrefix($argName) """.trimMargin() } appendln() diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKTransformer.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKTransformer.kt index aeba7975348..1f3b3408e9f 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKTransformer.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKTransformer.kt @@ -2,33 +2,33 @@ package org.jetbrains.kotlin.j2k.tree.visitors import org.jetbrains.kotlin.j2k.tree.* -interface JKTransformer { - fun transformElement(element: JKElement, data: D): E - fun transformClass(klass: JKClass, data: D): E = transformDeclaration(klass, data) - fun transformStatement(statement: JKStatement, data: D): E = transformElement(statement, data) - fun transformExpression(expression: JKExpression, data: D): E = transformStatement(expression, data) - fun transformLoop(loop: JKLoop, data: D): E = transformStatement(loop, data) - fun transformDeclaration(declaration: JKDeclaration, data: D): E = transformElement(declaration, data) - fun transformBlock(block: JKBlock, data: D): E = transformElement(block, data) - fun transformCall(call: JKCall, data: D): E = transformExpression(call, data) - fun transformIdentifier(identifier: JKIdentifier, data: D): E = transformElement(identifier, data) - fun transformTypeIdentifier(typeIdentifier: JKTypeIdentifier, data: D): E = transformIdentifier(typeIdentifier, data) - fun transformNameIdentifier(nameIdentifier: JKNameIdentifier, data: D): E = transformIdentifier(nameIdentifier, data) - fun transformLiteralExpression(literalExpression: JKLiteralExpression, data: D): E = transformExpression(literalExpression, data) - fun transformModifierList(modifierList: JKModifierList, data: D): E = transformElement(modifierList, data) - fun transformModifier(modifier: JKModifier, data: D): E = transformElement(modifier, data) - fun transformAccessModifier(accessModifier: JKAccessModifier, data: D): E = transformModifier(accessModifier, data) - fun transformJavaField(javaField: JKJavaField, data: D): E = transformDeclaration(javaField, data) - fun transformJavaMethod(javaMethod: JKJavaMethod, data: D): E = transformDeclaration(javaMethod, data) - fun transformJavaForLoop(javaForLoop: JKJavaForLoop, data: D): E = transformLoop(javaForLoop, data) - fun transformJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression, data: D): E = transformExpression(javaAssignmentExpression, data) - fun transformJavaCall(javaCall: JKJavaCall, data: D): E = transformCall(javaCall, data) - fun transformJavaTypeIdentifier(javaTypeIdentifier: JKJavaTypeIdentifier, data: D): E = transformTypeIdentifier(javaTypeIdentifier, data) - fun transformJavaStringLiteralExpression(javaStringLiteralExpression: JKJavaStringLiteralExpression, data: D): E = transformLiteralExpression(javaStringLiteralExpression, data) - fun transformJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier, data: D): E = transformAccessModifier(javaAccessModifier, data) - fun transformKtFun(ktFun: JKKtFun, data: D): E = transformDeclaration(ktFun, data) - fun transformKtConstructor(ktConstructor: JKKtConstructor, data: D): E = transformDeclaration(ktConstructor, data) - fun transformKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor, data: D): E = transformKtConstructor(ktPrimaryConstructor, data) - fun transformKtAssignmentStatement(ktAssignmentStatement: JKKtAssignmentStatement, data: D): E = transformStatement(ktAssignmentStatement, data) - fun transformKtCall(ktCall: JKKtCall, data: D): E = transformCall(ktCall, data) +interface JKTransformer : JKVisitor { + override fun visitElement(element: JKElement, data: D): JKElement + override fun visitClass(klass: JKClass, data: D): JKClass = visitDeclaration(klass, data) as JKClass + override fun visitStatement(statement: JKStatement, data: D): JKStatement = visitElement(statement, data) as JKStatement + override fun visitExpression(expression: JKExpression, data: D): JKExpression = visitStatement(expression, data) as JKExpression + override fun visitLoop(loop: JKLoop, data: D): JKLoop = visitStatement(loop, data) as JKLoop + override fun visitDeclaration(declaration: JKDeclaration, data: D): JKDeclaration = visitElement(declaration, data) as JKDeclaration + override fun visitBlock(block: JKBlock, data: D): JKBlock = visitElement(block, data) as JKBlock + override fun visitCall(call: JKCall, data: D): JKCall = visitExpression(call, data) as JKCall + override fun visitIdentifier(identifier: JKIdentifier, data: D): JKIdentifier = visitElement(identifier, data) as JKIdentifier + override fun visitTypeIdentifier(typeIdentifier: JKTypeIdentifier, data: D): JKTypeIdentifier = visitIdentifier(typeIdentifier, data) as JKTypeIdentifier + override fun visitNameIdentifier(nameIdentifier: JKNameIdentifier, data: D): JKNameIdentifier = visitIdentifier(nameIdentifier, data) as JKNameIdentifier + override fun visitLiteralExpression(literalExpression: JKLiteralExpression, data: D): JKLiteralExpression = visitExpression(literalExpression, data) as JKLiteralExpression + override fun visitModifierList(modifierList: JKModifierList, data: D): JKModifierList = visitElement(modifierList, data) as JKModifierList + override fun visitModifier(modifier: JKModifier, data: D): JKModifier = visitElement(modifier, data) as JKModifier + override fun visitAccessModifier(accessModifier: JKAccessModifier, data: D): JKAccessModifier = visitModifier(accessModifier, data) as JKAccessModifier + override fun visitJavaField(javaField: JKJavaField, data: D): JKDeclaration = visitDeclaration(javaField, data) + override fun visitJavaMethod(javaMethod: JKJavaMethod, data: D): JKDeclaration = visitDeclaration(javaMethod, data) + override fun visitJavaForLoop(javaForLoop: JKJavaForLoop, data: D): JKLoop = visitLoop(javaForLoop, data) + override fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression, data: D): JKExpression = visitExpression(javaAssignmentExpression, data) + override fun visitJavaCall(javaCall: JKJavaCall, data: D): JKCall = visitCall(javaCall, data) + override fun visitJavaTypeIdentifier(javaTypeIdentifier: JKJavaTypeIdentifier, data: D): JKTypeIdentifier = visitTypeIdentifier(javaTypeIdentifier, data) + override fun visitJavaStringLiteralExpression(javaStringLiteralExpression: JKJavaStringLiteralExpression, data: D): JKLiteralExpression = visitLiteralExpression(javaStringLiteralExpression, data) + override fun visitJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier, data: D): JKAccessModifier = visitAccessModifier(javaAccessModifier, data) + override fun visitKtFun(ktFun: JKKtFun, data: D): JKDeclaration = visitDeclaration(ktFun, data) + override fun visitKtConstructor(ktConstructor: JKKtConstructor, data: D): JKDeclaration = visitDeclaration(ktConstructor, data) + override fun visitKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor, data: D): JKDeclaration = visitKtConstructor(ktPrimaryConstructor, data) + override fun visitKtAssignmentStatement(ktAssignmentStatement: JKKtAssignmentStatement, data: D): JKStatement = visitStatement(ktAssignmentStatement, data) + override fun visitKtCall(ktCall: JKKtCall, data: D): JKCall = visitCall(ktCall, data) } diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKTransformerVoid.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKTransformerVoid.kt index 3d3edc0c2c2..32549edff1e 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKTransformerVoid.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKTransformerVoid.kt @@ -3,60 +3,60 @@ package org.jetbrains.kotlin.j2k.tree.visitors import org.jetbrains.kotlin.j2k.tree.* interface JKTransformerVoid : JKTransformer { - fun transformElement(element: JKElement): E - override fun transformElement(element: JKElement, data: Nothing?): E = transformElement(element) - fun transformClass(klass: JKClass): E = transformDeclaration(klass, null) - override fun transformClass(klass: JKClass, data: Nothing?): E = transformClass(klass) - fun transformStatement(statement: JKStatement): E = transformElement(statement, null) - override fun transformStatement(statement: JKStatement, data: Nothing?): E = transformStatement(statement) - fun transformExpression(expression: JKExpression): E = transformStatement(expression, null) - override fun transformExpression(expression: JKExpression, data: Nothing?): E = transformExpression(expression) - fun transformLoop(loop: JKLoop): E = transformStatement(loop, null) - override fun transformLoop(loop: JKLoop, data: Nothing?): E = transformLoop(loop) - fun transformDeclaration(declaration: JKDeclaration): E = transformElement(declaration, null) - override fun transformDeclaration(declaration: JKDeclaration, data: Nothing?): E = transformDeclaration(declaration) - fun transformBlock(block: JKBlock): E = transformElement(block, null) - override fun transformBlock(block: JKBlock, data: Nothing?): E = transformBlock(block) - fun transformCall(call: JKCall): E = transformExpression(call, null) - override fun transformCall(call: JKCall, data: Nothing?): E = transformCall(call) - fun transformIdentifier(identifier: JKIdentifier): E = transformElement(identifier, null) - override fun transformIdentifier(identifier: JKIdentifier, data: Nothing?): E = transformIdentifier(identifier) - fun transformTypeIdentifier(typeIdentifier: JKTypeIdentifier): E = transformIdentifier(typeIdentifier, null) - override fun transformTypeIdentifier(typeIdentifier: JKTypeIdentifier, data: Nothing?): E = transformTypeIdentifier(typeIdentifier) - fun transformNameIdentifier(nameIdentifier: JKNameIdentifier): E = transformIdentifier(nameIdentifier, null) - override fun transformNameIdentifier(nameIdentifier: JKNameIdentifier, data: Nothing?): E = transformNameIdentifier(nameIdentifier) - fun transformLiteralExpression(literalExpression: JKLiteralExpression): E = transformExpression(literalExpression, null) - override fun transformLiteralExpression(literalExpression: JKLiteralExpression, data: Nothing?): E = transformLiteralExpression(literalExpression) - fun transformModifierList(modifierList: JKModifierList): E = transformElement(modifierList, null) - override fun transformModifierList(modifierList: JKModifierList, data: Nothing?): E = transformModifierList(modifierList) - fun transformModifier(modifier: JKModifier): E = transformElement(modifier, null) - override fun transformModifier(modifier: JKModifier, data: Nothing?): E = transformModifier(modifier) - fun transformAccessModifier(accessModifier: JKAccessModifier): E = transformModifier(accessModifier, null) - override fun transformAccessModifier(accessModifier: JKAccessModifier, data: Nothing?): E = transformAccessModifier(accessModifier) - fun transformJavaField(javaField: JKJavaField): E = transformDeclaration(javaField, null) - override fun transformJavaField(javaField: JKJavaField, data: Nothing?): E = transformJavaField(javaField) - fun transformJavaMethod(javaMethod: JKJavaMethod): E = transformDeclaration(javaMethod, null) - override fun transformJavaMethod(javaMethod: JKJavaMethod, data: Nothing?): E = transformJavaMethod(javaMethod) - fun transformJavaForLoop(javaForLoop: JKJavaForLoop): E = transformLoop(javaForLoop, null) - override fun transformJavaForLoop(javaForLoop: JKJavaForLoop, data: Nothing?): E = transformJavaForLoop(javaForLoop) - fun transformJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression): E = transformExpression(javaAssignmentExpression, null) - override fun transformJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression, data: Nothing?): E = transformJavaAssignmentExpression(javaAssignmentExpression) - fun transformJavaCall(javaCall: JKJavaCall): E = transformCall(javaCall, null) - override fun transformJavaCall(javaCall: JKJavaCall, data: Nothing?): E = transformJavaCall(javaCall) - fun transformJavaTypeIdentifier(javaTypeIdentifier: JKJavaTypeIdentifier): E = transformTypeIdentifier(javaTypeIdentifier, null) - override fun transformJavaTypeIdentifier(javaTypeIdentifier: JKJavaTypeIdentifier, data: Nothing?): E = transformJavaTypeIdentifier(javaTypeIdentifier) - fun transformJavaStringLiteralExpression(javaStringLiteralExpression: JKJavaStringLiteralExpression): E = transformLiteralExpression(javaStringLiteralExpression, null) - override fun transformJavaStringLiteralExpression(javaStringLiteralExpression: JKJavaStringLiteralExpression, data: Nothing?): E = transformJavaStringLiteralExpression(javaStringLiteralExpression) - fun transformJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier): E = transformAccessModifier(javaAccessModifier, null) - override fun transformJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier, data: Nothing?): E = transformJavaAccessModifier(javaAccessModifier) - fun transformKtFun(ktFun: JKKtFun): E = transformDeclaration(ktFun, null) - override fun transformKtFun(ktFun: JKKtFun, data: Nothing?): E = transformKtFun(ktFun) - fun transformKtConstructor(ktConstructor: JKKtConstructor): E = transformDeclaration(ktConstructor, null) - override fun transformKtConstructor(ktConstructor: JKKtConstructor, data: Nothing?): E = transformKtConstructor(ktConstructor) - fun transformKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor): E = transformKtConstructor(ktPrimaryConstructor, null) - override fun transformKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor, data: Nothing?): E = transformKtPrimaryConstructor(ktPrimaryConstructor) - fun transformKtAssignmentStatement(ktAssignmentStatement: JKKtAssignmentStatement): E = transformStatement(ktAssignmentStatement, null) - override fun transformKtAssignmentStatement(ktAssignmentStatement: JKKtAssignmentStatement, data: Nothing?): E = transformKtAssignmentStatement(ktAssignmentStatement) - fun transformKtCall(ktCall: JKKtCall): E = transformCall(ktCall, null) - override fun transformKtCall(ktCall: JKKtCall, data: Nothing?): E = transformKtCall(ktCall) + fun visitElement(element: JKElement): JKElement + override fun visitElement(element: JKElement, data: Nothing?): JKElement = visitElement(element) + fun visitClass(klass: JKClass): JKClass = visitDeclaration(klass) as JKClass + override fun visitClass(klass: JKClass, data: Nothing?): JKClass = visitClass(klass) + fun visitStatement(statement: JKStatement): JKStatement = visitElement(statement) as JKStatement + override fun visitStatement(statement: JKStatement, data: Nothing?): JKStatement = visitStatement(statement) + fun visitExpression(expression: JKExpression): JKExpression = visitStatement(expression) as JKExpression + override fun visitExpression(expression: JKExpression, data: Nothing?): JKExpression = visitExpression(expression) + fun visitLoop(loop: JKLoop): JKLoop = visitStatement(loop) as JKLoop + override fun visitLoop(loop: JKLoop, data: Nothing?): JKLoop = visitLoop(loop) + fun visitDeclaration(declaration: JKDeclaration): JKDeclaration = visitElement(declaration) as JKDeclaration + override fun visitDeclaration(declaration: JKDeclaration, data: Nothing?): JKDeclaration = visitDeclaration(declaration) + fun visitBlock(block: JKBlock): JKBlock = visitElement(block) as JKBlock + override fun visitBlock(block: JKBlock, data: Nothing?): JKBlock = visitBlock(block) + fun visitCall(call: JKCall): JKCall = visitExpression(call) as JKCall + override fun visitCall(call: JKCall, data: Nothing?): JKCall = visitCall(call) + fun visitIdentifier(identifier: JKIdentifier): JKIdentifier = visitElement(identifier) as JKIdentifier + override fun visitIdentifier(identifier: JKIdentifier, data: Nothing?): JKIdentifier = visitIdentifier(identifier) + fun visitTypeIdentifier(typeIdentifier: JKTypeIdentifier): JKTypeIdentifier = visitIdentifier(typeIdentifier) as JKTypeIdentifier + override fun visitTypeIdentifier(typeIdentifier: JKTypeIdentifier, data: Nothing?): JKTypeIdentifier = visitTypeIdentifier(typeIdentifier) + fun visitNameIdentifier(nameIdentifier: JKNameIdentifier): JKNameIdentifier = visitIdentifier(nameIdentifier) as JKNameIdentifier + override fun visitNameIdentifier(nameIdentifier: JKNameIdentifier, data: Nothing?): JKNameIdentifier = visitNameIdentifier(nameIdentifier) + fun visitLiteralExpression(literalExpression: JKLiteralExpression): JKLiteralExpression = visitExpression(literalExpression) as JKLiteralExpression + override fun visitLiteralExpression(literalExpression: JKLiteralExpression, data: Nothing?): JKLiteralExpression = visitLiteralExpression(literalExpression) + fun visitModifierList(modifierList: JKModifierList): JKModifierList = visitElement(modifierList) as JKModifierList + override fun visitModifierList(modifierList: JKModifierList, data: Nothing?): JKModifierList = visitModifierList(modifierList) + fun visitModifier(modifier: JKModifier): JKModifier = visitElement(modifier) as JKModifier + override fun visitModifier(modifier: JKModifier, data: Nothing?): JKModifier = visitModifier(modifier) + fun visitAccessModifier(accessModifier: JKAccessModifier): JKAccessModifier = visitModifier(accessModifier) as JKAccessModifier + override fun visitAccessModifier(accessModifier: JKAccessModifier, data: Nothing?): JKAccessModifier = visitAccessModifier(accessModifier) + fun visitJavaField(javaField: JKJavaField): JKDeclaration = visitDeclaration(javaField) + override fun visitJavaField(javaField: JKJavaField, data: Nothing?): JKDeclaration = visitJavaField(javaField) + fun visitJavaMethod(javaMethod: JKJavaMethod): JKDeclaration = visitDeclaration(javaMethod) + override fun visitJavaMethod(javaMethod: JKJavaMethod, data: Nothing?): JKDeclaration = visitJavaMethod(javaMethod) + fun visitJavaForLoop(javaForLoop: JKJavaForLoop): JKLoop = visitLoop(javaForLoop) + override fun visitJavaForLoop(javaForLoop: JKJavaForLoop, data: Nothing?): JKLoop = visitJavaForLoop(javaForLoop) + fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression): JKExpression = visitExpression(javaAssignmentExpression) + override fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression, data: Nothing?): JKExpression = visitJavaAssignmentExpression(javaAssignmentExpression) + fun visitJavaCall(javaCall: JKJavaCall): JKCall = visitCall(javaCall) + override fun visitJavaCall(javaCall: JKJavaCall, data: Nothing?): JKCall = visitJavaCall(javaCall) + fun visitJavaTypeIdentifier(javaTypeIdentifier: JKJavaTypeIdentifier): JKTypeIdentifier = visitTypeIdentifier(javaTypeIdentifier) + override fun visitJavaTypeIdentifier(javaTypeIdentifier: JKJavaTypeIdentifier, data: Nothing?): JKTypeIdentifier = visitJavaTypeIdentifier(javaTypeIdentifier) + fun visitJavaStringLiteralExpression(javaStringLiteralExpression: JKJavaStringLiteralExpression): JKLiteralExpression = visitLiteralExpression(javaStringLiteralExpression) + override fun visitJavaStringLiteralExpression(javaStringLiteralExpression: JKJavaStringLiteralExpression, data: Nothing?): JKLiteralExpression = visitJavaStringLiteralExpression(javaStringLiteralExpression) + fun visitJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier): JKAccessModifier = visitAccessModifier(javaAccessModifier) + override fun visitJavaAccessModifier(javaAccessModifier: JKJavaAccessModifier, data: Nothing?): JKAccessModifier = visitJavaAccessModifier(javaAccessModifier) + fun visitKtFun(ktFun: JKKtFun): JKDeclaration = visitDeclaration(ktFun) + override fun visitKtFun(ktFun: JKKtFun, data: Nothing?): JKDeclaration = visitKtFun(ktFun) + fun visitKtConstructor(ktConstructor: JKKtConstructor): JKDeclaration = visitDeclaration(ktConstructor) + override fun visitKtConstructor(ktConstructor: JKKtConstructor, data: Nothing?): JKDeclaration = visitKtConstructor(ktConstructor) + fun visitKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor): JKDeclaration = visitKtConstructor(ktPrimaryConstructor) + override fun visitKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor, data: Nothing?): JKDeclaration = visitKtPrimaryConstructor(ktPrimaryConstructor) + fun visitKtAssignmentStatement(ktAssignmentStatement: JKKtAssignmentStatement): JKStatement = visitStatement(ktAssignmentStatement) + override fun visitKtAssignmentStatement(ktAssignmentStatement: JKKtAssignmentStatement, data: Nothing?): JKStatement = visitKtAssignmentStatement(ktAssignmentStatement) + fun visitKtCall(ktCall: JKKtCall): JKCall = visitCall(ktCall) + override fun visitKtCall(ktCall: JKKtCall, data: Nothing?): JKCall = visitKtCall(ktCall) }