diff --git a/nj2k/GenerateJKTreeVisitorAndTransformer.kts b/nj2k/GenerateJKTreeVisitorAndTransformer.kts
new file mode 100644
index 00000000000..9240268affd
--- /dev/null
+++ b/nj2k/GenerateJKTreeVisitorAndTransformer.kts
@@ -0,0 +1,99 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+import java.io.File
+
+
+private val JK_ROOT = File("./nj2k/src/org/jetbrains/kotlin/nj2k/tree")
+
+private val JK_OUT_ROOT = File(JK_ROOT, "visitors")
+
+private val JK_KT_FILE = File(JK_ROOT, "k.kt")
+private val JK_JAVA_FILE = File(JK_ROOT, "j.kt")
+private val JK_COMMON_FILE = File(JK_ROOT, "jk.kt")
+
+
+val interfaceRegex = "(interface|abstract class)\\s+(JK[a-zA-Z]+)\\s+?:?\\s+(JK[a-zA-Z]+)?".toRegex()
+
+
+data class InterfaceData(val name: String, val extends: String?)
+
+fun File.interfaceNames() =
+    sequenceOf(this)
+        .map { it.readText() }
+        .flatMap { interfaceRegex.findAll(it) }
+        .map { match -> InterfaceData(match.groupValues[2], match.groupValues.getOrNull(3)) }
+        .toList()
+
+
+fun String.safeVarName() = when (this) {
+    "class" -> "klass"
+    else -> this
+}
+
+fun genVisitors(commonData: List<InterfaceData>, uncommonData: List<InterfaceData>, visitorName: String, transformerName: String) {
+
+    val interfaceData = commonData + uncommonData
+
+    val pkg = "package org.jetbrains.kotlin.nj2k.tree.visitors"
+
+    File(JK_OUT_ROOT, "$visitorName.kt").writeText(buildString {
+        appendln(pkg)
+        appendln()
+        appendln("import org.jetbrains.kotlin.nj2k.tree.*")
+        appendln()
+        appendln("abstract class $visitorName {")
+        interfaceData.joinTo(this, separator = "\n") { (name, ext) ->
+            val nameWithoutPrefix = name.removePrefix("JK")
+            val argName = nameWithoutPrefix.decapitalize().safeVarName()
+            val generifyCall = if (name != "JKTreeElement") "= visit${ext!!.removePrefix("JK")}($argName)" else ""
+            val modifier = if (name == "JKTreeElement") "abstract" else "open"
+            """
+            |    $modifier fun visit$nameWithoutPrefix($argName: $name) $generifyCall
+            """.trimMargin()
+        }
+        appendln()
+        appendln("}")
+    })
+
+
+    File(JK_OUT_ROOT, "${visitorName}WithCommentsPrinting.kt").writeText(buildString {
+        appendln(pkg)
+        appendln()
+        appendln("import org.jetbrains.kotlin.nj2k.tree.*")
+        appendln()
+
+        appendln("abstract class ${visitorName}WithCommentsPrinting : $visitorName() {")
+        appendln(
+            """
+        |    abstract fun printLeftNonCodeElements(element: JKNonCodeElementsListOwner)
+        |    abstract fun printRightNonCodeElements(element: JKNonCodeElementsListOwner)
+        |
+        """.trimMargin()
+        )
+
+        interfaceData.joinTo(this, separator = "\n\n") { (name, ext) ->
+            val nameWithoutPrefix = name.removePrefix("JK")
+            val argName = nameWithoutPrefix.decapitalize().safeVarName()
+            val arg = "$argName: $name"
+            val rawVisitSuffix = "Raw"
+            val generifyCall = if (name != "JKTreeElement") "= visit${ext!!.removePrefix("JK")}$rawVisitSuffix($argName)" else ""
+            val modifier = if (name == "JKTreeElement") "abstract" else "open"
+            """
+            |    override fun visit$nameWithoutPrefix($arg) {
+            |        printLeftNonCodeElements($argName)
+            |        visit$nameWithoutPrefix$rawVisitSuffix($argName)
+            |        printRightNonCodeElements($argName)
+            |    }
+            |
+            |    $modifier fun visit$nameWithoutPrefix$rawVisitSuffix($arg) $generifyCall
+            """.trimMargin()
+        }
+        appendln()
+        appendln("}")
+    })
+}
+
+genVisitors(JK_COMMON_FILE.interfaceNames(), JK_JAVA_FILE.interfaceNames() + JK_KT_FILE.interfaceNames(), "JKVisitor", "JKTransformer")
diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/NewCodeBuilder.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/NewCodeBuilder.kt
index bc0d96f197e..20811d8f4b9 100644
--- a/nj2k/src/org/jetbrains/kotlin/nj2k/NewCodeBuilder.kt
+++ b/nj2k/src/org/jetbrains/kotlin/nj2k/NewCodeBuilder.kt
@@ -40,7 +40,7 @@ class NewCodeBuilder(context: NewJ2kConverterContext) {
         JKClass.ClassKind.COMPANION -> "companion object"
     }
 
-    inner class Visitor : JKVisitorWithCommentsPrinting {
+    inner class Visitor : JKVisitorWithCommentsPrinting() {
         private val printedTokens = mutableSetOf<JKNonCodeElement>()
 
         //TODO move to ast transformation phase
diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/base.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/base.kt
index 0f35aa1391e..7e62717f0ae 100644
--- a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/base.kt
+++ b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/base.kt
@@ -69,9 +69,9 @@ abstract class JKElementBase : JKTreeElement, Cloneable {
 
     }
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitTreeElement(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitTreeElement(this)
 
-    override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {}
+    override fun acceptChildren(visitor: JKVisitor) {}
 
     override fun copy(): JKTreeElement =
         clone() as JKTreeElement
@@ -96,8 +96,8 @@ abstract class JKBranchElementBase : JKElementBase(), JKBranchElement {
         return JKListChild(childNum++)
     }
 
-    override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {
-        forEachChild { it.accept(visitor, data) }
+    override fun acceptChildren(visitor: JKVisitor) {
+        forEachChild { it.accept(visitor) }
     }
 
     protected inline fun forEachChild(block: (JKTreeElement) -> Unit) {
diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/j.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/j.kt
index 934bbb3fd5f..fac98d18998 100644
--- a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/j.kt
+++ b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/j.kt
@@ -36,7 +36,7 @@ class JKJavaFieldImpl(
     modalityElement: JKModalityModifierElement,
     mutabilityElement: JKMutabilityModifierElement
 ) : JKJavaField(), PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaField(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitJavaField(this)
 
     override var annotationList: JKAnnotationList by child(annotationList)
     override var initializer: JKExpression by child(initializer)
@@ -61,7 +61,7 @@ class JKJavaMethodImpl(
     visibilityElement: JKVisibilityModifierElement,
     modalityElement: JKModalityModifierElement
 ) : JKJavaMethod(), PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaMethod(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitJavaMethod(this)
 
     override var returnType: JKTypeElement by child(returnType)
     override var name: JKNameIdentifier by child(name)
@@ -80,7 +80,7 @@ class JKJavaLiteralExpressionImpl(
     override val literal: String,
     override val type: JKLiteralExpression.LiteralType
 ) : JKJavaLiteralExpression, JKElementBase(), PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaLiteralExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitJavaLiteralExpression(this)
 
     init {
         require(type in setOf(STRING, CHAR, INT, LONG, FLOAT, DOUBLE))
@@ -217,7 +217,7 @@ class JKJavaMethodCallExpressionImpl(
     arguments: JKArgumentList,
     typeArgumentList: JKTypeArgumentList = JKTypeArgumentListImpl()
 ) : JKJavaMethodCallExpression, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaMethodCallExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitJavaMethodCallExpression(this)
 
     override var arguments: JKArgumentList by child(arguments)
     override var typeArgumentList: JKTypeArgumentList by child(typeArgumentList)
@@ -225,13 +225,13 @@ class JKJavaMethodCallExpressionImpl(
 
 class JKClassBodyImpl(declarations: List<JKDeclaration> = emptyList()) : JKClassBody() {
     override var declarations: List<JKDeclaration> by children(declarations)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitClassBody(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitClassBody(this)
 }
 
 class JKEmptyClassBodyImpl : JKEmptyClassBody() {
     override var declarations: List<JKDeclaration> by children(emptyList())
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitEmptyClassBody(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitEmptyClassBody(this)
 }
 
 class JKJavaNewExpressionImpl(
@@ -244,21 +244,21 @@ class JKJavaNewExpressionImpl(
     override var typeArgumentList: JKTypeArgumentList by child(typeArgumentList)
     override var classBody: JKClassBody by child(classBody)
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaNewExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitJavaNewExpression(this)
 }
 
 class JKJavaNewEmptyArrayImpl(initializer: List<JKExpression>, type: JKTypeElement) : JKJavaNewEmptyArray, JKBranchElementBase(),
     PsiOwner by PsiOwnerImpl() {
     override val type by child(type)
     override var initializer by children(initializer)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaNewEmptyArray(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitJavaNewEmptyArray(this)
 }
 
 class JKJavaNewArrayImpl(initializer: List<JKExpression>, type: JKTypeElement) : JKJavaNewArray, JKBranchElementBase(),
     PsiOwner by PsiOwnerImpl() {
     override val type by child(type)
     override var initializer by children(initializer)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaNewArray(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitJavaNewArray(this)
 }
 
 class JKJavaPrimitiveTypeImpl(override val jvmPrimitiveType: JvmPrimitiveType) : JKJavaPrimitiveType {
@@ -298,7 +298,7 @@ class JKReturnStatementImpl(
     expression: JKExpression,
     label: JKLabel = JKLabelEmptyImpl()
 ) : JKReturnStatement(), PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitReturnStatement(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitReturnStatement(this)
 
     override val expression by child(expression)
     override var label by child(label)
@@ -309,7 +309,7 @@ class JKJavaAssertStatementImpl(condition: JKExpression, description: JKExpressi
     override val description by child(description)
     override val condition by child(condition)
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaAssertStatement(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitJavaAssertStatement(this)
 }
 
 class JKJavaForLoopStatementImpl(initializer: JKStatement, condition: JKExpression, updaters: List<JKStatement>, body: JKStatement) :
@@ -319,7 +319,7 @@ class JKJavaForLoopStatementImpl(initializer: JKStatement, condition: JKExpressi
     override var condition by child(condition)
     override var initializer by child(initializer)
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaForLoopStatement(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitJavaForLoopStatement(this)
 }
 
 
@@ -332,7 +332,7 @@ class JKJavaPolyadicExpressionImpl(operands: List<JKExpression>, override var to
         return if (index < 1 || index > tokens.size) null else tokens[index - 1]
     }
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaPolyadicExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitJavaPolyadicExpression(this)
 }
 
 class JKJavaAssignmentExpressionImpl(
@@ -340,7 +340,7 @@ class JKJavaAssignmentExpressionImpl(
     expression: JKExpression,
     override var operator: JKOperator
 ) : JKBranchElementBase(), JKJavaAssignmentExpression, PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaAssignmentExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitJavaAssignmentExpression(this)
     override var field: JKAssignableExpression by child(field)
     override var expression: JKExpression by child(expression)
 }
@@ -351,13 +351,13 @@ class JKJavaSwitchStatementImpl(
 ) : JKJavaSwitchStatement(), PsiOwner by PsiOwnerImpl() {
     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)
+    override fun accept(visitor: JKVisitor) = visitor.visitJavaSwitchStatement(this)
 }
 
 class JKJavaDefaultSwitchCaseImpl(statements: List<JKStatement>) : JKJavaDefaultSwitchCase, JKBranchElementBase(),
     PsiOwner by PsiOwnerImpl() {
     override var statements: List<JKStatement> by children(statements)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaDefaultSwitchCase(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitJavaDefaultSwitchCase(this)
 }
 
 class JKJavaLabelSwitchCaseImpl(
@@ -366,12 +366,12 @@ class JKJavaLabelSwitchCaseImpl(
 ) : JKJavaLabelSwitchCase, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() {
     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)
+    override fun accept(visitor: JKVisitor) = visitor.visitJavaLabelSwitchCase(this)
 }
 
 class JKJavaThrowStatementImpl(exception: JKExpression) : JKJavaThrowStatement(), PsiOwner by PsiOwnerImpl() {
     override var exception: JKExpression by child(exception)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaThrowStatement(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitJavaThrowStatement(this)
 }
 
 class JKJavaTryStatementImpl(
@@ -384,7 +384,7 @@ class JKJavaTryStatementImpl(
     override var tryBlock: JKBlock by child(tryBlock)
     override var finallyBlock: JKBlock by child(finallyBlock)
     override var catchSections: List<JKJavaTryCatchSection> by children(catchSections)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaTryStatement(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitJavaTryStatement(this)
 }
 
 class JKJavaTryCatchSectionImpl(
@@ -393,7 +393,7 @@ class JKJavaTryCatchSectionImpl(
 ) : JKJavaTryCatchSection, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() {
     override var parameter: JKParameter by child(parameter)
     override var block: JKBlock by child(block)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaTryCatchSection(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitJavaTryCatchSection(this)
 }
 
 class JKJavaSynchronizedStatementImpl(
@@ -402,7 +402,7 @@ class JKJavaSynchronizedStatementImpl(
 ) : JKJavaSynchronizedStatement(), PsiOwner by PsiOwnerImpl() {
     override val lockExpression: JKExpression by child(lockExpression)
     override val body: JKBlock by child(body)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaSynchronizedStatement(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitJavaSynchronizedStatement(this)
 }
 
 class JKJavaAnnotationMethodImpl(
@@ -418,7 +418,7 @@ class JKJavaAnnotationMethodImpl(
     override var typeParameterList: JKTypeParameterList by child(JKTypeParameterListImpl())
     override var annotationList: JKAnnotationList by child(JKAnnotationListImpl())
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaAnnotationMethod(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitJavaAnnotationMethod(this)
 }
 
 class JKKtAnnotationArrayInitializerExpressionImpl(initializers: List<JKAnnotationMemberValue>) : JKKtAnnotationArrayInitializerExpression,
@@ -427,10 +427,10 @@ class JKKtAnnotationArrayInitializerExpressionImpl(initializers: List<JKAnnotati
 
     override val initializers: List<JKAnnotationMemberValue> by children(initializers)
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtAnnotationArrayInitializerExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitKtAnnotationArrayInitializerExpression(this)
 }
 
 class JKJavaStaticInitDeclarationImpl(block: JKBlock) : JKJavaStaticInitDeclaration() {
     override var block: JKBlock by child(block)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaStaticInitDeclaration(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitJavaStaticInitDeclaration(this)
 }
\ No newline at end of file
diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/jk.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/jk.kt
index b9739fe19f8..2cd0a502595 100644
--- a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/jk.kt
+++ b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/jk.kt
@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.psi.KtClass
 
 class JKTreeRootImpl(element: JKTreeElement) : JKTreeRoot, JKBranchElementBase() {
     override var element by child(element)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitTreeRoot(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitTreeRoot(this)
 }
 
 class JKFileImpl(
@@ -40,7 +40,7 @@ class JKFileImpl(
     declarationList: List<JKDeclaration>
 ) : JKFile, JKBranchElementBase(),
     PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitFile(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitFile(this)
 
     override var packageDeclaration: JKPackageDeclaration by child(packageDeclaration)
     override var importList: JKImportList by child(importList)
@@ -58,7 +58,7 @@ class JKClassImpl(
     visibilityElement: JKVisibilityModifierElement,
     modalityElement: JKModalityModifierElement
 ) : JKClass(), PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitClass(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitClass(this)
 
     override var name by child(name)
     override val inheritance by child(inheritance)
@@ -72,7 +72,7 @@ class JKClassImpl(
 }
 
 class JKNameIdentifierImpl(override val value: String) : JKNameIdentifier, JKElementBase(), PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitNameIdentifier(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitNameIdentifier(this)
 }
 
 class JKForLoopVariableImpl(
@@ -86,7 +86,7 @@ class JKForLoopVariableImpl(
     override var type by child(type)
     override var annotationList by child(annotationList)
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitForLoopVariable(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitForLoopVariable(this)
 }
 
 
@@ -97,7 +97,7 @@ class JKParameterImpl(
     initializer: JKExpression = JKStubExpressionImpl(),
     annotationList: JKAnnotationList = JKAnnotationListImpl()
 ) : JKParameter(), PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitParameter(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitParameter(this)
 
     override var initializer by child(initializer)
     override var name by child(name)
@@ -108,7 +108,7 @@ class JKParameterImpl(
 class JKBlockImpl(statements: List<JKStatement> = emptyList()) : JKBlock(), PsiOwner by PsiOwnerImpl() {
     constructor(vararg statements: JKStatement) : this(statements.toList())
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitBlock(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitBlock(this)
 
     override var statements by children(statements)
 }
@@ -118,7 +118,7 @@ class JKBinaryExpressionImpl(
     right: JKExpression,
     override var operator: JKOperator
 ) : JKBinaryExpression, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitBinaryExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitBinaryExpression(this)
     override var right by child(right)
     override var left by child(left)
 }
@@ -126,14 +126,14 @@ class JKBinaryExpressionImpl(
 
 class JKPrefixExpressionImpl(expression: JKExpression, override var operator: JKOperator) : JKPrefixExpression, JKBranchElementBase(),
     PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitPrefixExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitPrefixExpression(this)
 
     override var expression by child(expression)
 }
 
 class JKPostfixExpressionImpl(expression: JKExpression, override var operator: JKOperator) : JKPostfixExpression, JKBranchElementBase(),
     PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitPostfixExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitPostfixExpression(this)
 
     override var expression by child(expression)
 }
@@ -142,7 +142,7 @@ class JKExpressionListImpl(expressions: List<JKExpression> = emptyList()) : JKEx
     PsiOwner by PsiOwnerImpl() {
     constructor(vararg expresions: JKExpression) : this(expresions.asList())
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitExpressionList(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitExpressionList(this)
 
     override var expressions by children(expressions)
 }
@@ -152,14 +152,14 @@ class JKQualifiedExpressionImpl(
     override var operator: JKQualifier,
     selector: JKExpression
 ) : JKQualifiedExpression, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitQualifiedExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitQualifiedExpression(this)
 
     override var receiver: JKExpression by child(receiver)
     override var selector: JKExpression by child(selector)
 }
 
 class JKExpressionStatementImpl(expression: JKExpression) : JKExpressionStatement(), PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitExpressionStatement(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitExpressionStatement(this)
 
     override val expression: JKExpression by child(expression)
 }
@@ -168,7 +168,7 @@ class JKDeclarationStatementImpl(declaredStatements: List<JKDeclaration>) : JKDe
     PsiOwner by PsiOwnerImpl() {
     override val declaredStatements by children(declaredStatements)
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitDeclarationStatement(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitDeclarationStatement(this)
 
     override var rightNonCodeElements: List<JKNonCodeElement> = listOf(JKSpaceElementImpl("\n"))
 }
@@ -177,7 +177,7 @@ class JKArrayAccessExpressionImpl(
     expression: JKExpression,
     indexExpression: JKExpression
 ) : JKArrayAccessExpression, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitArrayAccessExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitArrayAccessExpression(this)
 
     override var expression: JKExpression by child(expression)
     override var indexExpression: JKExpression by child(indexExpression)
@@ -185,21 +185,21 @@ class JKArrayAccessExpressionImpl(
 
 class JKParenthesizedExpressionImpl(expression: JKExpression) : JKParenthesizedExpression, JKBranchElementBase(),
     PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitParenthesizedExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitParenthesizedExpression(this)
 
     override var expression: JKExpression by child(expression)
 }
 
 class JKTypeCastExpressionImpl(expression: JKExpression, type: JKTypeElement) : JKTypeCastExpression, JKBranchElementBase(),
     PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitTypeCastExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitTypeCastExpression(this)
 
     override var expression by child(expression)
     override var type by child(type)
 }
 
 class JKTypeElementImpl(override var type: JKType) : JKTypeElement, JKElementBase(), PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitTypeElement(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitTypeElement(this)
 }
 
 data class JKClassTypeImpl(
@@ -233,7 +233,7 @@ class JKNullLiteral : JKLiteralExpression, JKElementBase(), PsiOwner by PsiOwner
     override val type: LiteralType
         get() = NULL
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitLiteralExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitLiteralExpression(this)
 }
 
 class JKBooleanLiteral(val value: Boolean) : JKLiteralExpression, JKElementBase(), PsiOwner by PsiOwnerImpl() {
@@ -242,7 +242,7 @@ class JKBooleanLiteral(val value: Boolean) : JKLiteralExpression, JKElementBase(
     override val type: LiteralType
         get() = BOOLEAN
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitLiteralExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitLiteralExpression(this)
 }
 
 fun JKLiteralExpression.LiteralType.toJkType(symbolProvider: JKSymbolProvider): JKType {
@@ -279,11 +279,11 @@ class JKLocalVariableImpl(
 
     override var mutabilityElement by child(mutabilityElement)
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitLocalVariable(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitLocalVariable(this)
 }
 
 class JKStubExpressionImpl : JKStubExpression, JKElementBase(), PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitStubExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitStubExpression(this)
 }
 
 object JKBodyStubImpl : JKBodyStub() {
@@ -296,13 +296,13 @@ object JKBodyStubImpl : JKBodyStub() {
         get() = emptyList()
         set(value) {}
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitBodyStub(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitBodyStub(this)
 
-    override fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D) {}
+    override fun acceptChildren(visitor: JKVisitor) {}
 
     override var parent: JKElement?
         get() = null
-        set (it) {}
+        set(it) {}
 
     override fun detach(from: JKElement) {
     }
@@ -314,48 +314,48 @@ object JKBodyStubImpl : JKBodyStub() {
 class JKBlockStatementImpl(block: JKBlock) : JKBlockStatement(), PsiOwner by PsiOwnerImpl() {
     override var block by child(block)
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitBlockStatement(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitBlockStatement(this)
 }
 
 class JKBlockStatementWithoutBracketsImpl(statements: List<JKStatement>) : JKBlockStatementWithoutBrackets(),
     PsiOwner by PsiOwnerImpl() {
     override var statements by children(statements)
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitBlockStatementWithoutBrackets(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitBlockStatementWithoutBrackets(this)
 }
 
 class JKThisExpressionImpl(qualifierLabel: JKLabel) : JKThisExpression, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() {
     override var qualifierLabel: JKLabel by child(qualifierLabel)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitThisExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitThisExpression(this)
 }
 
 class JKSuperExpressionImpl(qualifierLabel: JKLabel = JKLabelEmptyImpl()) : JKSuperExpression, JKBranchElementBase(),
     PsiOwner by PsiOwnerImpl() {
     override var qualifierLabel: JKLabel by child(qualifierLabel)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitSuperExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitSuperExpression(this)
 }
 
 class JKWhileStatementImpl(condition: JKExpression, body: JKStatement) : JKWhileStatement(),
     PsiOwner by PsiOwnerImpl() {
     override var condition by child(condition)
     override var body by child(body)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitWhileStatement(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitWhileStatement(this)
 }
 
 class JKDoWhileStatementImpl(body: JKStatement, condition: JKExpression) : JKDoWhileStatement(),
     PsiOwner by PsiOwnerImpl() {
     override var condition by child(condition)
     override var body by child(body)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitDoWhileStatement(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitDoWhileStatement(this)
 }
 
 class JKBreakStatementImpl : JKBreakStatement(), PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitBreakStatement(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitBreakStatement(this)
 }
 
 class JKBreakWithLabelStatementImpl(override var label: JKNameIdentifier) : JKBreakWithLabelStatement(),
     PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitBreakWithLabelStatement(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitBreakWithLabelStatement(this)
 }
 
 class JKIfStatementImpl(condition: JKExpression, thenBranch: JKStatement) : JKIfStatement(),
@@ -363,7 +363,7 @@ class JKIfStatementImpl(condition: JKExpression, thenBranch: JKStatement) : JKIf
     override var thenBranch by child(thenBranch)
     override var condition by child(condition)
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitIfStatement(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitIfStatement(this)
 }
 
 class JKIfElseStatementImpl(condition: JKExpression, thenBranch: JKStatement, elseBranch: JKStatement) : JKIfElseStatement(),
@@ -372,7 +372,7 @@ class JKIfElseStatementImpl(condition: JKExpression, thenBranch: JKStatement, el
     override var thenBranch by child(thenBranch)
     override var condition by child(condition)
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitIfElseStatement(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitIfElseStatement(this)
 }
 
 class JKIfElseExpressionImpl(condition: JKExpression, thenBranch: JKExpression, elseBranch: JKExpression) : JKIfElseExpression,
@@ -381,12 +381,12 @@ class JKIfElseExpressionImpl(condition: JKExpression, thenBranch: JKExpression,
     override var thenBranch by child(thenBranch)
     override var condition by child(condition)
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitIfElseExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitIfElseExpression(this)
 }
 
 class JKClassAccessExpressionImpl(override var identifier: JKClassSymbol) : JKClassAccessExpression, JKElementBase(),
     PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitClassAccessExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitClassAccessExpression(this)
 }
 
 class JKLambdaExpressionImpl(
@@ -400,7 +400,7 @@ class JKLambdaExpressionImpl(
     override var parameters by children(parameters)
     override var functionalType by child(functionalType)
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitLambdaExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitLambdaExpression(this)
 }
 
 class JKInheritanceInfoImpl(
@@ -410,7 +410,7 @@ class JKInheritanceInfoImpl(
     override var extends: List<JKTypeElement> by children(extends)
     override var implements: List<JKTypeElement> by children(implements)
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitInheritanceInfo(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitInheritanceInfo(this)
 }
 
 
@@ -423,17 +423,17 @@ class JKDelegationConstructorCallImpl(
     override val expression: JKExpression by child(expression)
     override var arguments: JKArgumentList by child(arguments)
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitDelegationConstructorCall(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitDelegationConstructorCall(this)
 }
 
 class JKFieldAccessExpressionImpl(override var identifier: JKFieldSymbol) : JKFieldAccessExpression, JKElementBase(),
     PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitFieldAccessExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitFieldAccessExpression(this)
 }
 
 class JKPackageAccessExpressionImpl(override var identifier: JKPackageSymbol) : JKPackageAccessExpression, JKElementBase(),
     PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitPackageAccessExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitPackageAccessExpression(this)
 }
 
 
@@ -445,28 +445,28 @@ val JKStatement.statements: List<JKStatement>
         }
 
 class JKLabelEmptyImpl : JKLabelEmpty, JKElementBase(), PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitLabelEmpty(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitLabelEmpty(this)
 }
 
 class JKLabelTextImpl(label: JKNameIdentifier) : JKLabelText, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() {
     override val label: JKNameIdentifier by child(label)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitLabelText(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitLabelText(this)
 }
 
 class JKContinueStatementImpl(label: JKLabel) : JKContinueStatement(), PsiOwner by PsiOwnerImpl() {
     override var label: JKLabel by child(label)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitContinueStatement(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitContinueStatement(this)
 }
 
 class JKLabeledStatementImpl(statement: JKStatement, labels: List<JKNameIdentifier>) : JKLabeledStatement, JKBranchElementBase(),
     PsiOwner by PsiOwnerImpl() {
     override var statement: JKStatement by child(statement)
     override val labels: List<JKNameIdentifier> by children(labels)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitLabeledStatement(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitLabeledStatement(this)
 }
 
 class JKEmptyStatementImpl : JKEmptyStatement(), PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitEmptyStatement(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitEmptyStatement(this)
 }
 
 class PsiOwnerImpl(override var psi: PsiElement? = null) : PsiOwner
@@ -478,13 +478,13 @@ inline fun <reified Elem : PsiElement> JKElement.psi(): Elem? = (this as? PsiOwn
 
 class JKTypeParameterListImpl(typeParameters: List<JKTypeParameter> = emptyList()) : JKTypeParameterList, JKBranchElementBase() {
     override var typeParameters by children(typeParameters)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitTypeParameterList(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitTypeParameterList(this)
 }
 
 class JKTypeParameterImpl(name: JKNameIdentifier, upperBounds: List<JKTypeElement>) : JKTypeParameter, JKBranchElementBase() {
     override var name: JKNameIdentifier by child(name)
     override var upperBounds: List<JKTypeElement> by children(upperBounds)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitTypeParameter(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitTypeParameter(this)
 }
 
 data class JKVarianceTypeParameterTypeImpl(
@@ -511,7 +511,7 @@ class JKEnumConstantImpl(
     override var initializer: JKExpression by child(JKStubExpressionImpl())
     override var annotationList by child(annotationList)
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitEnumConstant(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitEnumConstant(this)
 }
 
 fun JKTypeElement.present(): Boolean =
@@ -522,7 +522,7 @@ class JKForInStatementImpl(declaration: JKDeclaration, iterationExpression: JKEx
     override var declaration: JKDeclaration by child(declaration)
     override var iterationExpression: JKExpression by child(iterationExpression)
     override var body: JKStatement by child(body)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitForInStatement(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitForInStatement(this)
 }
 
 fun JKStatement.isEmpty(): Boolean =
@@ -535,12 +535,12 @@ fun JKStatement.isEmpty(): Boolean =
 
 class JKPackageDeclarationImpl(packageName: JKNameIdentifier) : JKPackageDeclaration() {
     override var packageName: JKNameIdentifier by child(packageName)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitPackageDeclaration(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitPackageDeclaration(this)
 }
 
 class JKAnnotationListImpl(annotations: List<JKAnnotation> = emptyList()) : JKAnnotationList, JKBranchElementBase() {
     override var annotations: List<JKAnnotation> by children(annotations)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitAnnotationList(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitAnnotationList(this)
 }
 
 class JKAnnotationImpl(
@@ -548,7 +548,7 @@ class JKAnnotationImpl(
     arguments: List<JKAnnotationParameter> = emptyList()
 ) : JKAnnotation, JKBranchElementBase() {
     override var arguments: List<JKAnnotationParameter> by children(arguments)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitAnnotation(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitAnnotation(this)
 
     override var rightNonCodeElements: List<JKNonCodeElement> = listOf(JKSpaceElementImpl("\n"))
 }
@@ -556,7 +556,7 @@ class JKAnnotationImpl(
 class JKTypeArgumentListImpl(typeArguments: List<JKTypeElement> = emptyList()) : JKTypeArgumentList, JKBranchElementBase(),
     PsiOwner by PsiOwnerImpl() {
     override val typeArguments: List<JKTypeElement> by children(typeArguments)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitTypeArgumentList(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitTypeArgumentList(this)
 
 }
 
@@ -566,27 +566,27 @@ class JKClassLiteralExpressionImpl(
 ) : JKClassLiteralExpression, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() {
     override val classType: JKTypeElement by child(classType)
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitClassLiteralExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitClassLiteralExpression(this)
 }
 
 class JKImportStatementImpl(name: JKNameIdentifier) : JKImportStatement, JKBranchElementBase() {
     override val name: JKNameIdentifier by child(name)
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitImportStatement(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitImportStatement(this)
 
     override var rightNonCodeElements: List<JKNonCodeElement> = listOf(JKSpaceElementImpl("\n"))
 }
 
 class JKImportListImpl(imports: List<JKImportStatement>) : JKImportList, JKBranchElementBase() {
     override var imports by children(imports)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitImportList(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitImportList(this)
 }
 
 
 class JKAnnotationParameterImpl(value: JKAnnotationMemberValue) : JKAnnotationParameter, JKBranchElementBase() {
     override var value: JKAnnotationMemberValue by child(value)
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitAnnotationParameter(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitAnnotationParameter(this)
 }
 
 class JKAnnotationNameParameterImpl(
@@ -596,7 +596,7 @@ class JKAnnotationNameParameterImpl(
     override var value: JKAnnotationMemberValue by child(value)
     override val name: JKNameIdentifier by child(name)
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitAnnotationNameParameter(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitAnnotationNameParameter(this)
 }
 
 class JKNamedArgumentImpl(
@@ -606,12 +606,12 @@ class JKNamedArgumentImpl(
     override var value by child(value)
     override val name by child(name)
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitNamedArgument(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitNamedArgument(this)
 }
 
 class JKArgumentImpl(value: JKExpression) : JKArgument, JKBranchElementBase() {
     override var value by child(value)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitArgument(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitArgument(this)
 }
 
 class JKArgumentListImpl(arguments: List<JKArgument> = emptyList()) : JKArgumentList, JKBranchElementBase() {
@@ -620,24 +620,24 @@ class JKArgumentListImpl(arguments: List<JKArgument> = emptyList()) : JKArgument
 
     override var arguments by children(arguments)
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitArgumentList(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitArgumentList(this)
 }
 
 
 class JKMutabilityModifierElementImpl(override var mutability: Mutability) : JKMutabilityModifierElement() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitMutabilityModifierElement(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitMutabilityModifierElement(this)
 }
 
 class JKModalityModifierElementImpl(override var modality: Modality) : JKModalityModifierElement() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitModalityModifierElement(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitModalityModifierElement(this)
 }
 
 class JKVisibilityModifierElementImpl(override var visibility: Visibility) : JKVisibilityModifierElement() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitVisibilityModifierElement(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitVisibilityModifierElement(this)
 }
 
 class JKOtherModifierElementImpl(override var otherModifier: OtherModifier) : JKOtherModifierElement() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitExtraModifierElement(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitOtherModifierElement(this)
 }
 
 class JKMethodReferenceExpressionImpl(
@@ -650,5 +650,5 @@ class JKMethodReferenceExpressionImpl(
     override val functionalType by child(functionalType)
 
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitMethodReferenceExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitMethodReferenceExpression(this)
 }
\ No newline at end of file
diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/k.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/k.kt
index 7c77a0501a0..fb97d4cf580 100644
--- a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/k.kt
+++ b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/k.kt
@@ -35,7 +35,7 @@ class JKKtPropertyImpl(
     modalityElement: JKModalityModifierElement,
     mutabilityElement: JKMutabilityModifierElement
 ) : JKKtProperty(), PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtProperty(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitKtProperty(this)
 
     override var annotationList: JKAnnotationList by child(annotationList)
     override var type by child(type)
@@ -63,7 +63,7 @@ class JKKtFunctionImpl(
     visibilityElement: JKVisibilityModifierElement,
     modalityElement: JKModalityModifierElement
 ) : JKKtFunction(), PsiOwner by PsiOwnerImpl() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtFunction(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitKtFunction(this)
 
     override var returnType: JKTypeElement by child(returnType)
     override var name: JKNameIdentifier by child(name)
@@ -88,7 +88,7 @@ class JKKtCallExpressionImpl(
     arguments: JKArgumentList,
     typeArgumentList: JKTypeArgumentList = JKTypeArgumentListImpl()
 ) : JKKtMethodCallExpression, JKBranchElementBase() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtMethodCallExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitKtMethodCallExpression(this)
 
     override var arguments: JKArgumentList by child(arguments)
     override var typeArgumentList: JKTypeArgumentList by child(typeArgumentList)
@@ -99,7 +99,7 @@ class JKKtLiteralExpressionImpl(
     override val type: JKLiteralExpression.LiteralType
 ) : JKKtLiteralExpression,
     JKElementBase() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtLiteralExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitKtLiteralExpression(this)
 }
 
 class JKKtSingleValueOperatorToken(val psiToken: KtSingleValueToken) : JKKtOperatorToken {
@@ -141,7 +141,7 @@ class JKKtAlsoCallExpressionImpl(
     override val identifier: JKMethodSymbol,
     typeArgumentList: JKTypeArgumentList = JKTypeArgumentListImpl()
 ) : JKKtAlsoCallExpression, JKBranchElementBase() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtAlsoCallExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitKtAlsoCallExpression(this)
     override var statement
         get() = arguments.arguments.first().value.cast<JKLambdaExpressionImpl>().statement
         set(it) {
@@ -162,7 +162,7 @@ class JKKtAssignmentStatementImpl(
 ) : JKKtAssignmentStatement() {
     override var field: JKAssignableExpression by child(field)
     override var expression by child(expression)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtAssignmentStatement(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitKtAssignmentStatement(this)
 
     override var rightNonCodeElements: List<JKNonCodeElement> = listOf(JKSpaceElementImpl("\n"))
 }
@@ -195,7 +195,7 @@ class JKKtConstructorImpl(
     override var visibilityElement by child(visibilityElement)
     override var modalityElement by child(modalityElement)
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtConstructor(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitKtConstructor(this)
 }
 
 class JKKtPrimaryConstructorImpl(
@@ -220,7 +220,7 @@ class JKKtPrimaryConstructorImpl(
     override var visibilityElement by child(visibilityElement)
     override var modalityElement by child(modalityElement)
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtPrimaryConstructor(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitKtPrimaryConstructor(this)
 }
 
 class JKKtWhenStatementImpl(
@@ -229,23 +229,23 @@ class JKKtWhenStatementImpl(
 ) : JKKtWhenStatement() {
     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)
+    override fun accept(visitor: JKVisitor) = visitor.visitKtWhenStatement(this)
 }
 
 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)
+    override fun accept(visitor: JKVisitor) = visitor.visitKtWhenCase(this)
 
 }
 
 class JKKtElseWhenLabelImpl : JKKtElseWhenLabel, JKElementBase() {
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtElseWhenLabel(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitKtElseWhenLabel(this)
 }
 
 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)
+    override fun accept(visitor: JKVisitor) = visitor.visitKtValueWhenLabel(this)
 }
 
 
@@ -254,12 +254,12 @@ class JKKtIsExpressionImpl(expression: JKExpression, type: JKTypeElement) : JKKt
     override var type by child(type)
     override var expression by child(expression)
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtIsExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitKtIsExpression(this)
 }
 
 class JKKtInitDeclarationImpl(block: JKBlock) : JKKtInitDeclaration() {
     override var block: JKBlock by child(block)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtInitDeclaration(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitKtInitDeclaration(this)
 }
 
 
@@ -269,13 +269,13 @@ class JKKtConvertedFromForLoopSyntheticWhileStatementImpl(
 ) : JKKtConvertedFromForLoopSyntheticWhileStatement(), PsiOwner by PsiOwnerImpl() {
     override var variableDeclaration: JKStatement by child(variableDeclaration)
     override var whileStatement: JKWhileStatement by child(whileStatement)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R =
-        visitor.visitKtConvertedFromForLoopSyntheticWhileStatement(this, data)
+    override fun accept(visitor: JKVisitor) =
+        visitor.visitKtConvertedFromForLoopSyntheticWhileStatement(this)
 }
 
 class JKKtThrowExpressionImpl(exception: JKExpression) : JKKtThrowExpression, JKBranchElementBase() {
     override var exception: JKExpression by child(exception)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtThrowExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitKtThrowExpression(this)
 }
 
 class JKKtTryExpressionImpl(
@@ -286,7 +286,7 @@ class JKKtTryExpressionImpl(
     override var tryBlock: JKBlock by child(tryBlock)
     override var finallyBlock: JKBlock by child(finallyBlock)
     override var catchSections: List<JKKtTryCatchSection> by children(catchSections)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtTryExpression(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitKtTryExpression(this)
 }
 
 class JKKtTryCatchSectionImpl(
@@ -295,7 +295,7 @@ class JKKtTryCatchSectionImpl(
 ) : JKKtTryCatchSection, JKBranchElementBase() {
     override var parameter: JKParameter by child(parameter)
     override var block: JKBlock by child(block)
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtTryCatchSection(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitKtTryCatchSection(this)
 }
 
 class JKKtGetterOrSetterImpl(
@@ -307,7 +307,7 @@ class JKKtGetterOrSetterImpl(
 
     override var visibilityElement by child(visibilityElement)
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtGetterOrSetter(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitKtGetterOrSetter(this)
 }
 
 class JKKtEmptyGetterOrSetterImpl : JKKtEmptyGetterOrSetter, JKBranchElementBase() {
@@ -317,5 +317,5 @@ class JKKtEmptyGetterOrSetterImpl : JKKtEmptyGetterOrSetter, JKBranchElementBase
 
     override var visibilityElement by child(JKVisibilityModifierElementImpl(Visibility.PUBLIC))
 
-    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtEmptyGetterOrSetter(this, data)
+    override fun accept(visitor: JKVisitor) = visitor.visitKtEmptyGetterOrSetter(this)
 }
\ No newline at end of file
diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/jk.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/jk.kt
index c96b4a55d6c..b6939321817 100644
--- a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/jk.kt
+++ b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/jk.kt
@@ -21,14 +21,8 @@ import org.jetbrains.kotlin.nj2k.tree.impl.*
 import org.jetbrains.kotlin.nj2k.tree.visitors.JKVisitor
 
 interface JKTreeElement : JKElement, JKNonCodeElementsListOwner {
-    fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R
-
-    fun <R> accept(visitor: JKVisitor<R, Nothing?>): R = accept(visitor, null)
-
-    fun <D> acceptChildren(visitor: JKVisitor<Unit, D>, data: D)
-
-    fun acceptChildren(visitor: JKVisitor<Unit, Nothing?>) = acceptChildren(visitor, null)
-
+    fun accept(visitor: JKVisitor)
+    fun acceptChildren(visitor: JKVisitor)
     fun copy(): JKTreeElement
 }
 
diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/GenerateJKTreeVisitorAndTransformer.kts b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/GenerateJKTreeVisitorAndTransformer.kts
deleted file mode 100644
index 12af8ecec0d..00000000000
--- a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/GenerateJKTreeVisitorAndTransformer.kts
+++ /dev/null
@@ -1,220 +0,0 @@
-/*
- * 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.
- */
-
-/*
- * 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.
- */
-
-/*
- * 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
-
-
-val JK_ROOT = File("./nj2k/src/org/jetbrains/kotlin/nj2k/tree")
-
-val JK_OUT_ROOT = File(JK_ROOT, "visitors")
-
-val JK_KT_FILE = File(JK_ROOT, "k.kt")
-val JK_JAVA_FILE = File(JK_ROOT, "j.kt")
-val JK_COMMON_FILE = File(JK_ROOT, "jk.kt")
-
-
-val interfaceRegex = "(interface|abstract class)\\s+(JK[a-zA-Z]+)\\s+?:?\\s+(JK[a-zA-Z]+)?".toRegex()
-
-
-data class InterfaceData(val name: String, val extends: String?)
-
-fun File.interfaceNames() =
-    sequenceOf(this)
-        .map { it.readText() }
-        .flatMap { interfaceRegex.findAll(it) }
-        .map { match -> InterfaceData(match.groupValues[2], match.groupValues.getOrNull(3)) }
-        .toList()
-
-
-fun String.safeVarName() = when (this) {
-    "class" -> "klass"
-    else -> this
-}
-
-fun genVisitors(commonData: List<InterfaceData>, uncommonData: List<InterfaceData>, visitorName: String, transformerName: String) {
-
-    val interfaceData = commonData + uncommonData
-
-    val pkg = "package org.jetbrains.kotlin.nj2k.tree.visitors"
-
-    fun String.firstCommonInterfaceName(): String {
-        val data = interfaceData.find { it.name == this }!!
-        if (commonData.contains(data))
-            return this
-        return data.extends!!.firstCommonInterfaceName()
-    }
-
-    File(JK_OUT_ROOT, "$visitorName.kt").writeText(buildString {
-        appendln(pkg)
-        appendln()
-        appendln("import org.jetbrains.kotlin.nj2k.tree.*")
-        appendln()
-        appendln("interface $visitorName<out R, in D> {")
-        interfaceData.joinTo(this, separator = "\n") { (name, ext) ->
-            val nameWithoutPrefix = name.removePrefix("JK")
-            val argName = nameWithoutPrefix.decapitalize().safeVarName()
-            val generifyCall = if (name != "JKTreeElement") "= visit${ext!!.removePrefix("JK")}($argName, data)" else ""
-            """
-            |    fun visit$nameWithoutPrefix($argName: $name, data: D): R $generifyCall
-            """.trimMargin()
-        }
-        appendln()
-        appendln("}")
-    })
-
-
-    File(JK_OUT_ROOT, "${visitorName}Void.kt").writeText(buildString {
-        appendln(pkg)
-        appendln()
-        appendln("import org.jetbrains.kotlin.nj2k.tree.*")
-        appendln()
-
-        appendln("interface ${visitorName}Void : $visitorName<Unit, Nothing?> {")
-        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 != "JKTreeElement") "= visit${ext!!.removePrefix("JK")}($argName, null)" else ""
-            """
-            |    fun visit$nameWithoutPrefix($arg) $generifyCall
-            |    override fun visit$nameWithoutPrefix($arg, data: Nothing?) = visit$nameWithoutPrefix($argName)
-            """.trimMargin()
-        }
-        appendln()
-        appendln("}")
-    })
-
-    File(JK_OUT_ROOT, "${visitorName}WithCommentsPrinting.kt").writeText(buildString {
-        appendln(pkg)
-        appendln()
-        appendln("import org.jetbrains.kotlin.nj2k.tree.*")
-        appendln()
-
-        appendln("interface ${visitorName}WithCommentsPrinting : ${visitorName}Void {")
-        appendln(
-            """
-        |    fun printLeftNonCodeElements(element: JKNonCodeElementsListOwner)
-        |    fun printRightNonCodeElements(element: JKNonCodeElementsListOwner)
-        |
-        """.trimMargin()
-        )
-
-        interfaceData.joinTo(this, separator = "\n\n") { (name, ext) ->
-            val nameWithoutPrefix = name.removePrefix("JK")
-            val argName = nameWithoutPrefix.decapitalize().safeVarName()
-            val arg = "$argName: $name"
-            val rawVisitSuffix = "Raw"
-            val generifyCall = if (name != "JKTreeElement") "= visit${ext!!.removePrefix("JK")}$rawVisitSuffix($argName)" else ""
-            """
-            |    override fun visit$nameWithoutPrefix($arg) {
-            |        printLeftNonCodeElements($argName)
-            |        visit$nameWithoutPrefix$rawVisitSuffix($argName)
-            |        printRightNonCodeElements($argName)
-            |    }
-            |
-            |    fun visit$nameWithoutPrefix$rawVisitSuffix($arg) $generifyCall
-            """.trimMargin()
-        }
-        appendln()
-        appendln("}")
-    })
-
-    /*File(JK_OUT_ROOT, "$transformerName.kt").writeText(buildString {
-        appendln(pkg)
-        appendln()
-        appendln("import org.jetbrains.kotlin.nj2k.tree.*")
-        appendln()
-
-        appendln("interface $transformerName<in D> : JKVisitor<JKTreeElement, D> {")
-
-        interfaceData.joinTo(this, separator = "\n") { (name, ext) ->
-            val nameWithoutPrefix = name.removePrefix("JK")
-            val argName = nameWithoutPrefix.decapitalize().safeVarName()
-
-            val leastCommonName = name.firstCommonInterfaceName()
-            val cast = "as $leastCommonName".takeIf { leastCommonName == name } ?: ""
-
-            val generifyCall = if (name != "JKTreeElement") "= visit${ext!!.removePrefix("JK")}($argName, data) $cast" else ""
-
-            """
-            |    override fun visit$nameWithoutPrefix($argName: $name, data: D): $leastCommonName $generifyCall
-            """.trimMargin()
-        }
-        appendln()
-        appendln("}")
-    })
-
-
-    File(JK_OUT_ROOT, "${transformerName}Void.kt").writeText(buildString {
-        appendln(pkg)
-        appendln()
-        appendln("import org.jetbrains.kotlin.nj2k.tree.*")
-        appendln()
-
-
-        appendln("interface ${transformerName}Void : $transformerName<Nothing?> {")
-        interfaceData.joinTo(this, separator = "\n") { (name, ext) ->
-            val nameWithoutPrefix = name.removePrefix("JK")
-            val argName = nameWithoutPrefix.decapitalize().safeVarName()
-            val arg = "$argName: $name"
-
-            val leastCommonName = name.firstCommonInterfaceName()
-            val cast = "as $leastCommonName".takeIf { leastCommonName == name } ?: ""
-            val generifyCall = if (name != "JKTreeElement") "= visit${ext!!.removePrefix("JK")}($argName) $cast" else ""
-
-            """
-            |    fun visit$nameWithoutPrefix($arg): $leastCommonName $generifyCall
-            |    override fun visit$nameWithoutPrefix($arg, data: Nothing?): $leastCommonName = visit$nameWithoutPrefix($argName)
-            """.trimMargin()
-        }
-        appendln()
-        appendln("}")
-    })*/
-}
-
-genVisitors(JK_COMMON_FILE.interfaceNames(), JK_JAVA_FILE.interfaceNames() + JK_KT_FILE.interfaceNames(), "JKVisitor", "JKTransformer")
diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitor.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitor.kt
index 921ab9bd651..676411321ed 100644
--- a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitor.kt
+++ b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitor.kt
@@ -2,213 +2,144 @@ package org.jetbrains.kotlin.nj2k.tree.visitors
 
 import org.jetbrains.kotlin.nj2k.tree.*
 
-interface JKVisitor<out R, in D> {
-    fun visitTreeElement(treeElement: JKTreeElement, data: D): R
-    fun visitTreeRoot(treeRoot: JKTreeRoot, data: D): R = visitTreeElement(treeRoot, data)
-    fun visitDeclaration(declaration: JKDeclaration, data: D): R = visitTreeElement(declaration, data)
-    fun visitImportStatement(importStatement: JKImportStatement, data: D): R = visitTreeElement(importStatement, data)
-    fun visitImportList(importList: JKImportList, data: D): R = visitTreeElement(importList, data)
-    fun visitFile(file: JKFile, data: D): R = visitTreeElement(file, data)
-    fun visitClass(klass: JKClass, data: D): R = visitDeclaration(klass, data)
-    fun visitInheritanceInfo(inheritanceInfo: JKInheritanceInfo, data: D): R = visitTreeElement(inheritanceInfo, data)
-    fun visitAnnotationList(annotationList: JKAnnotationList, data: D): R = visitTreeElement(annotationList, data)
-    fun visitAnnotation(annotation: JKAnnotation, data: D): R = visitAnnotationMemberValue(annotation, data)
-    fun visitAnnotationParameter(annotationParameter: JKAnnotationParameter, data: D): R = visitTreeElement(annotationParameter, data)
-    fun visitAnnotationNameParameter(annotationNameParameter: JKAnnotationNameParameter, data: D): R =
-        visitAnnotationParameter(annotationNameParameter, data)
-
-    fun visitAnnotationListOwner(annotationListOwner: JKAnnotationListOwner, data: D): R = visitTreeElement(annotationListOwner, data)
-    fun visitMethod(method: JKMethod, data: D): R = visitDeclaration(method, data)
-    fun visitVariable(variable: JKVariable, data: D): R = visitDeclaration(variable, data)
-    fun visitForLoopVariable(forLoopVariable: JKForLoopVariable, data: D): R = visitVariable(forLoopVariable, data)
-    fun visitLocalVariable(localVariable: JKLocalVariable, data: D): R = visitVariable(localVariable, data)
-    fun visitModifierElement(modifierElement: JKModifierElement, data: D): R = visitTreeElement(modifierElement, data)
-    fun visitMutabilityModifierElement(mutabilityModifierElement: JKMutabilityModifierElement, data: D): R =
-        visitModifierElement(mutabilityModifierElement, data)
-
-    fun visitModalityModifierElement(modalityModifierElement: JKModalityModifierElement, data: D): R =
-        visitModifierElement(modalityModifierElement, data)
-
-    fun visitVisibilityModifierElement(visibilityModifierElement: JKVisibilityModifierElement, data: D): R =
-        visitModifierElement(visibilityModifierElement, data)
-
-    fun visitExtraModifierElement(otherModifierElement: JKOtherModifierElement, data: D): R =
-        visitModifierElement(otherModifierElement, data)
-
-    fun visitExtraModifiersOwner(otherModifiersOwner: JKOtherModifiersOwner, data: D): R =
-        visitModifiersListOwner(otherModifiersOwner, data)
-
-    fun visitVisibilityOwner(visibilityOwner: JKVisibilityOwner, data: D): R = visitModifiersListOwner(visibilityOwner, data)
-    fun visitModalityOwner(modalityOwner: JKModalityOwner, data: D): R = visitModifiersListOwner(modalityOwner, data)
-    fun visitMutabilityOwner(mutabilityOwner: JKMutabilityOwner, data: D): R = visitModifiersListOwner(mutabilityOwner, data)
-    fun visitModifiersListOwner(modifiersListOwner: JKModifiersListOwner, data: D): R = visitTreeElement(modifiersListOwner, data)
-    fun visitTypeElement(typeElement: JKTypeElement, data: D): R = visitTreeElement(typeElement, data)
-    fun visitStatement(statement: JKStatement, data: D): R = visitTreeElement(statement, data)
-    fun visitBlock(block: JKBlock, data: D): R = visitTreeElement(block, data)
-    fun visitBodyStub(bodyStub: JKBodyStub, data: D): R = visitBlock(bodyStub, data)
-    fun visitIdentifier(identifier: JKIdentifier, data: D): R = visitTreeElement(identifier, data)
-    fun visitNameIdentifier(nameIdentifier: JKNameIdentifier, data: D): R = visitIdentifier(nameIdentifier, data)
-    fun visitExpression(expression: JKExpression, data: D): R = visitTreeElement(expression, data)
-    fun visitMethodReferenceExpression(methodReferenceExpression: JKMethodReferenceExpression, data: D): R =
-        visitExpression(methodReferenceExpression, data)
-
-    fun visitExpressionStatement(expressionStatement: JKExpressionStatement, data: D): R = visitStatement(expressionStatement, data)
-    fun visitDeclarationStatement(declarationStatement: JKDeclarationStatement, data: D): R = visitStatement(declarationStatement, data)
-    fun visitOperatorExpression(operatorExpression: JKOperatorExpression, data: D): R = visitExpression(operatorExpression, data)
-    fun visitBinaryExpression(binaryExpression: JKBinaryExpression, data: D): R = visitOperatorExpression(binaryExpression, data)
-    fun visitUnaryExpression(unaryExpression: JKUnaryExpression, data: D): R = visitOperatorExpression(unaryExpression, data)
-    fun visitPrefixExpression(prefixExpression: JKPrefixExpression, data: D): R = visitUnaryExpression(prefixExpression, data)
-    fun visitPostfixExpression(postfixExpression: JKPostfixExpression, data: D): R = visitUnaryExpression(postfixExpression, data)
-    fun visitQualifiedExpression(qualifiedExpression: JKQualifiedExpression, data: D): R = visitExpression(qualifiedExpression, data)
-    fun visitTypeArgumentList(typeArgumentList: JKTypeArgumentList, data: D): R = visitTreeElement(typeArgumentList, data)
-    fun visitTypeArgumentListOwner(typeArgumentListOwner: JKTypeArgumentListOwner, data: D): R =
-        visitTreeElement(typeArgumentListOwner, data)
-
-    fun visitMethodCallExpression(methodCallExpression: JKMethodCallExpression, data: D): R = visitExpression(methodCallExpression, data)
-    fun visitFieldAccessExpression(fieldAccessExpression: JKFieldAccessExpression, data: D): R =
-        visitAssignableExpression(fieldAccessExpression, data)
-
-    fun visitPackageAccessExpression(packageAccessExpression: JKPackageAccessExpression, data: D): R =
-        visitAssignableExpression(packageAccessExpression, data)
-
-    fun visitClassAccessExpression(classAccessExpression: JKClassAccessExpression, data: D): R =
-        visitExpression(classAccessExpression, data)
-
-    fun visitArrayAccessExpression(arrayAccessExpression: JKArrayAccessExpression, data: D): R =
-        visitAssignableExpression(arrayAccessExpression, data)
-
-    fun visitParenthesizedExpression(parenthesizedExpression: JKParenthesizedExpression, data: D): R =
-        visitExpression(parenthesizedExpression, data)
-
-    fun visitTypeCastExpression(typeCastExpression: JKTypeCastExpression, data: D): R = visitExpression(typeCastExpression, data)
-    fun visitExpressionList(expressionList: JKExpressionList, data: D): R = visitTreeElement(expressionList, data)
-    fun visitArgument(argument: JKArgument, data: D): R = visitTreeElement(argument, data)
-    fun visitNamedArgument(namedArgument: JKNamedArgument, data: D): R = visitArgument(namedArgument, data)
-    fun visitArgumentList(argumentList: JKArgumentList, data: D): R = visitTreeElement(argumentList, data)
-    fun visitLiteralExpression(literalExpression: JKLiteralExpression, data: D): R = visitExpression(literalExpression, data)
-    fun visitParameter(parameter: JKParameter, data: D): R = visitVariable(parameter, data)
-    fun visitStringLiteralExpression(stringLiteralExpression: JKStringLiteralExpression, data: D): R =
-        visitLiteralExpression(stringLiteralExpression, data)
-
-    fun visitStubExpression(stubExpression: JKStubExpression, data: D): R = visitExpression(stubExpression, data)
-    fun visitLoopStatement(loopStatement: JKLoopStatement, data: D): R = visitStatement(loopStatement, data)
-    fun visitBlockStatement(blockStatement: JKBlockStatement, data: D): R = visitStatement(blockStatement, data)
-    fun visitBlockStatementWithoutBrackets(blockStatementWithoutBrackets: JKBlockStatementWithoutBrackets, data: D): R =
-        visitStatement(blockStatementWithoutBrackets, data)
-
-    fun visitThisExpression(thisExpression: JKThisExpression, data: D): R = visitExpression(thisExpression, data)
-    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 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)
-    fun visitIfElseStatement(ifElseStatement: JKIfElseStatement, data: D): R = visitIfStatement(ifElseStatement, data)
-    fun visitIfElseExpression(ifElseExpression: JKIfElseExpression, data: D): R = visitExpression(ifElseExpression, data)
-    fun visitAssignableExpression(assignableExpression: JKAssignableExpression, data: D): R = visitExpression(assignableExpression, data)
-    fun visitLambdaExpression(lambdaExpression: JKLambdaExpression, data: D): R = visitExpression(lambdaExpression, data)
-    fun visitDelegationConstructorCall(delegationConstructorCall: JKDelegationConstructorCall, data: D): R =
-        visitMethodCallExpression(delegationConstructorCall, data)
-
-    fun visitLabel(label: JKLabel, data: D): R = visitTreeElement(label, data)
-    fun visitLabelEmpty(labelEmpty: JKLabelEmpty, data: D): R = visitLabel(labelEmpty, data)
-    fun visitLabelText(labelText: JKLabelText, data: D): R = visitLabel(labelText, data)
-    fun visitContinueStatement(continueStatement: JKContinueStatement, data: D): R = visitStatement(continueStatement, data)
-    fun visitLabeledStatement(labeledStatement: JKLabeledStatement, data: D): R = visitExpression(labeledStatement, data)
-    fun visitEmptyStatement(emptyStatement: JKEmptyStatement, data: D): R = visitStatement(emptyStatement, data)
-    fun visitTypeParameterList(typeParameterList: JKTypeParameterList, data: D): R = visitTreeElement(typeParameterList, data)
-    fun visitTypeParameter(typeParameter: JKTypeParameter, data: D): R = visitTreeElement(typeParameter, data)
-    fun visitTypeParameterListOwner(typeParameterListOwner: JKTypeParameterListOwner, data: D): R =
-        visitTreeElement(typeParameterListOwner, data)
-
-    fun visitEnumConstant(enumConstant: JKEnumConstant, data: D): R = visitVariable(enumConstant, data)
-    fun visitForInStatement(forInStatement: JKForInStatement, data: D): R = visitStatement(forInStatement, data)
-    fun visitPackageDeclaration(packageDeclaration: JKPackageDeclaration, data: D): R = visitDeclaration(packageDeclaration, data)
-    fun visitClassLiteralExpression(classLiteralExpression: JKClassLiteralExpression, data: D): R =
-        visitExpression(classLiteralExpression, data)
-
-    fun visitAnnotationMemberValue(annotationMemberValue: JKAnnotationMemberValue, data: D): R =
-        visitTreeElement(annotationMemberValue, data)
-
-    fun visitField(field: JKField, data: D): R = visitVariable(field, data)
-    fun visitJavaField(javaField: JKJavaField, data: D): R = visitField(javaField, data)
-    fun visitJavaMethod(javaMethod: JKJavaMethod, data: D): R = visitMethod(javaMethod, data)
-    fun visitJavaMethodCallExpression(javaMethodCallExpression: JKJavaMethodCallExpression, data: D): R =
-        visitMethodCallExpression(javaMethodCallExpression, data)
-
-    fun visitClassBody(classBody: JKClassBody, data: D): R = visitTreeElement(classBody, data)
-    fun visitEmptyClassBody(emptyClassBody: JKEmptyClassBody, data: D): R = visitClassBody(emptyClassBody, data)
-    fun visitJavaNewExpression(javaNewExpression: JKJavaNewExpression, data: D): R = visitExpression(javaNewExpression, data)
-    fun visitJavaDefaultNewExpression(javaDefaultNewExpression: JKJavaDefaultNewExpression, data: D): R =
-        visitExpression(javaDefaultNewExpression, data)
-
-    fun visitJavaNewEmptyArray(javaNewEmptyArray: JKJavaNewEmptyArray, data: D): R = visitExpression(javaNewEmptyArray, data)
-    fun visitJavaNewArray(javaNewArray: JKJavaNewArray, data: D): R = visitExpression(javaNewArray, data)
-    fun visitJavaLiteralExpression(javaLiteralExpression: JKJavaLiteralExpression, data: D): R =
-        visitLiteralExpression(javaLiteralExpression, data)
-
-    fun visitReturnStatement(returnStatement: JKReturnStatement, data: D): R = visitStatement(returnStatement, data)
-    fun visitJavaAssertStatement(javaAssertStatement: JKJavaAssertStatement, data: D): R = visitStatement(javaAssertStatement, data)
-    fun visitJavaForLoopStatement(javaForLoopStatement: JKJavaForLoopStatement, data: D): R = visitLoopStatement(javaForLoopStatement, data)
-    fun visitJavaPolyadicExpression(javaPolyadicExpression: JKJavaPolyadicExpression, data: D): R =
-        visitExpression(javaPolyadicExpression, data)
-
-    fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression, data: D): R =
-        visitExpression(javaAssignmentExpression, data)
-
-    fun visitJavaThrowStatement(javaThrowStatement: JKJavaThrowStatement, data: D): R = visitStatement(javaThrowStatement, data)
-    fun visitJavaTryStatement(javaTryStatement: JKJavaTryStatement, data: D): R = visitStatement(javaTryStatement, data)
-    fun visitJavaTryCatchSection(javaTryCatchSection: JKJavaTryCatchSection, data: D): R = visitTreeElement(javaTryCatchSection, 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 visitJavaContinueStatement(javaContinueStatement: JKJavaContinueStatement, data: D): R = visitStatement(javaContinueStatement, data)
-    fun visitJavaSynchronizedStatement(javaSynchronizedStatement: JKJavaSynchronizedStatement, data: D): R =
-        visitStatement(javaSynchronizedStatement, data)
-
-    fun visitJavaAnnotationMethod(javaAnnotationMethod: JKJavaAnnotationMethod, data: D): R = visitMethod(javaAnnotationMethod, data)
-    fun visitJavaStaticInitDeclaration(javaStaticInitDeclaration: JKJavaStaticInitDeclaration, data: D): R =
-        visitDeclaration(javaStaticInitDeclaration, data)
-
-    fun visitKtGetterOrSetter(ktGetterOrSetter: JKKtGetterOrSetter, data: D): R = visitTreeElement(ktGetterOrSetter, data)
-    fun visitKtEmptyGetterOrSetter(ktEmptyGetterOrSetter: JKKtEmptyGetterOrSetter, data: D): R =
-        visitKtGetterOrSetter(ktEmptyGetterOrSetter, 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 = visitMethod(ktConstructor, data)
-    fun visitKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor, data: D): R = visitKtConstructor(ktPrimaryConstructor, data)
-    fun visitKtAssignmentStatement(ktAssignmentStatement: JKKtAssignmentStatement, data: D): R = visitStatement(ktAssignmentStatement, data)
-    fun visitKtCall(ktCall: JKKtCall, data: D): R = visitMethodCallExpression(ktCall, data)
-    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)
-    fun visitKtIsExpression(ktIsExpression: JKKtIsExpression, data: D): R = visitExpression(ktIsExpression, data)
-    fun visitKtInitDeclaration(ktInitDeclaration: JKKtInitDeclaration, data: D): R = visitDeclaration(ktInitDeclaration, data)
-    fun visitKtConvertedFromForLoopSyntheticWhileStatement(
-        ktConvertedFromForLoopSyntheticWhileStatement: JKKtConvertedFromForLoopSyntheticWhileStatement,
-        data: D
-    ): R = visitStatement(ktConvertedFromForLoopSyntheticWhileStatement, data)
-
-    fun visitKtThrowExpression(ktThrowExpression: JKKtThrowExpression, data: D): R = visitExpression(ktThrowExpression, data)
-    fun visitKtTryExpression(ktTryExpression: JKKtTryExpression, data: D): R = visitExpression(ktTryExpression, data)
-    fun visitKtTryCatchSection(ktTryCatchSection: JKKtTryCatchSection, data: D): R = visitTreeElement(ktTryCatchSection, data)
-    fun visitKtAnnotationArrayInitializerExpression(
-        ktAnnotationArrayInitializerExpression: JKKtAnnotationArrayInitializerExpression,
-        data: D
-    ): R = visitExpression(ktAnnotationArrayInitializerExpression, data)
+abstract class JKVisitor {
+    abstract fun visitTreeElement(treeElement: JKTreeElement) 
+    open fun visitTreeRoot(treeRoot: JKTreeRoot) = visitTreeElement(treeRoot)
+    open fun visitDeclaration(declaration: JKDeclaration) = visitTreeElement(declaration)
+    open fun visitImportStatement(importStatement: JKImportStatement) = visitTreeElement(importStatement)
+    open fun visitImportList(importList: JKImportList) = visitTreeElement(importList)
+    open fun visitFile(file: JKFile) = visitTreeElement(file)
+    open fun visitClass(klass: JKClass) = visitDeclaration(klass)
+    open fun visitInheritanceInfo(inheritanceInfo: JKInheritanceInfo) = visitTreeElement(inheritanceInfo)
+    open fun visitAnnotationList(annotationList: JKAnnotationList) = visitTreeElement(annotationList)
+    open fun visitAnnotation(annotation: JKAnnotation) = visitAnnotationMemberValue(annotation)
+    open fun visitAnnotationParameter(annotationParameter: JKAnnotationParameter) = visitTreeElement(annotationParameter)
+    open fun visitAnnotationNameParameter(annotationNameParameter: JKAnnotationNameParameter) = visitAnnotationParameter(annotationNameParameter)
+    open fun visitAnnotationListOwner(annotationListOwner: JKAnnotationListOwner) = visitTreeElement(annotationListOwner)
+    open fun visitMethod(method: JKMethod) = visitDeclaration(method)
+    open fun visitVariable(variable: JKVariable) = visitDeclaration(variable)
+    open fun visitForLoopVariable(forLoopVariable: JKForLoopVariable) = visitVariable(forLoopVariable)
+    open fun visitLocalVariable(localVariable: JKLocalVariable) = visitVariable(localVariable)
+    open fun visitModifierElement(modifierElement: JKModifierElement) = visitTreeElement(modifierElement)
+    open fun visitMutabilityModifierElement(mutabilityModifierElement: JKMutabilityModifierElement) = visitModifierElement(mutabilityModifierElement)
+    open fun visitModalityModifierElement(modalityModifierElement: JKModalityModifierElement) = visitModifierElement(modalityModifierElement)
+    open fun visitVisibilityModifierElement(visibilityModifierElement: JKVisibilityModifierElement) = visitModifierElement(visibilityModifierElement)
+    open fun visitOtherModifierElement(otherModifierElement: JKOtherModifierElement) = visitModifierElement(otherModifierElement)
+    open fun visitOtherModifiersOwner(otherModifiersOwner: JKOtherModifiersOwner) = visitModifiersListOwner(otherModifiersOwner)
+    open fun visitVisibilityOwner(visibilityOwner: JKVisibilityOwner) = visitModifiersListOwner(visibilityOwner)
+    open fun visitModalityOwner(modalityOwner: JKModalityOwner) = visitModifiersListOwner(modalityOwner)
+    open fun visitMutabilityOwner(mutabilityOwner: JKMutabilityOwner) = visitModifiersListOwner(mutabilityOwner)
+    open fun visitModifiersListOwner(modifiersListOwner: JKModifiersListOwner) = visitTreeElement(modifiersListOwner)
+    open fun visitTypeElement(typeElement: JKTypeElement) = visitTreeElement(typeElement)
+    open fun visitStatement(statement: JKStatement) = visitTreeElement(statement)
+    open fun visitBlock(block: JKBlock) = visitTreeElement(block)
+    open fun visitBodyStub(bodyStub: JKBodyStub) = visitBlock(bodyStub)
+    open fun visitIdentifier(identifier: JKIdentifier) = visitTreeElement(identifier)
+    open fun visitNameIdentifier(nameIdentifier: JKNameIdentifier) = visitIdentifier(nameIdentifier)
+    open fun visitExpression(expression: JKExpression) = visitTreeElement(expression)
+    open fun visitMethodReferenceExpression(methodReferenceExpression: JKMethodReferenceExpression) = visitExpression(methodReferenceExpression)
+    open fun visitExpressionStatement(expressionStatement: JKExpressionStatement) = visitStatement(expressionStatement)
+    open fun visitDeclarationStatement(declarationStatement: JKDeclarationStatement) = visitStatement(declarationStatement)
+    open fun visitOperatorExpression(operatorExpression: JKOperatorExpression) = visitExpression(operatorExpression)
+    open fun visitBinaryExpression(binaryExpression: JKBinaryExpression) = visitOperatorExpression(binaryExpression)
+    open fun visitUnaryExpression(unaryExpression: JKUnaryExpression) = visitOperatorExpression(unaryExpression)
+    open fun visitPrefixExpression(prefixExpression: JKPrefixExpression) = visitUnaryExpression(prefixExpression)
+    open fun visitPostfixExpression(postfixExpression: JKPostfixExpression) = visitUnaryExpression(postfixExpression)
+    open fun visitQualifiedExpression(qualifiedExpression: JKQualifiedExpression) = visitExpression(qualifiedExpression)
+    open fun visitTypeArgumentList(typeArgumentList: JKTypeArgumentList) = visitTreeElement(typeArgumentList)
+    open fun visitTypeArgumentListOwner(typeArgumentListOwner: JKTypeArgumentListOwner) = visitTreeElement(typeArgumentListOwner)
+    open fun visitMethodCallExpression(methodCallExpression: JKMethodCallExpression) = visitExpression(methodCallExpression)
+    open fun visitFieldAccessExpression(fieldAccessExpression: JKFieldAccessExpression) = visitAssignableExpression(fieldAccessExpression)
+    open fun visitPackageAccessExpression(packageAccessExpression: JKPackageAccessExpression) = visitAssignableExpression(packageAccessExpression)
+    open fun visitClassAccessExpression(classAccessExpression: JKClassAccessExpression) = visitExpression(classAccessExpression)
+    open fun visitArrayAccessExpression(arrayAccessExpression: JKArrayAccessExpression) = visitAssignableExpression(arrayAccessExpression)
+    open fun visitParenthesizedExpression(parenthesizedExpression: JKParenthesizedExpression) = visitExpression(parenthesizedExpression)
+    open fun visitTypeCastExpression(typeCastExpression: JKTypeCastExpression) = visitExpression(typeCastExpression)
+    open fun visitExpressionList(expressionList: JKExpressionList) = visitTreeElement(expressionList)
+    open fun visitArgument(argument: JKArgument) = visitTreeElement(argument)
+    open fun visitNamedArgument(namedArgument: JKNamedArgument) = visitArgument(namedArgument)
+    open fun visitArgumentList(argumentList: JKArgumentList) = visitTreeElement(argumentList)
+    open fun visitLiteralExpression(literalExpression: JKLiteralExpression) = visitExpression(literalExpression)
+    open fun visitParameter(parameter: JKParameter) = visitVariable(parameter)
+    open fun visitStringLiteralExpression(stringLiteralExpression: JKStringLiteralExpression) = visitLiteralExpression(stringLiteralExpression)
+    open fun visitStubExpression(stubExpression: JKStubExpression) = visitExpression(stubExpression)
+    open fun visitLoopStatement(loopStatement: JKLoopStatement) = visitStatement(loopStatement)
+    open fun visitBlockStatement(blockStatement: JKBlockStatement) = visitStatement(blockStatement)
+    open fun visitBlockStatementWithoutBrackets(blockStatementWithoutBrackets: JKBlockStatementWithoutBrackets) = visitStatement(blockStatementWithoutBrackets)
+    open fun visitThisExpression(thisExpression: JKThisExpression) = visitExpression(thisExpression)
+    open fun visitSuperExpression(superExpression: JKSuperExpression) = visitExpression(superExpression)
+    open fun visitWhileStatement(whileStatement: JKWhileStatement) = visitLoopStatement(whileStatement)
+    open fun visitDoWhileStatement(doWhileStatement: JKDoWhileStatement) = visitLoopStatement(doWhileStatement)
+    open fun visitBreakStatement(breakStatement: JKBreakStatement) = visitStatement(breakStatement)
+    open fun visitBreakWithLabelStatement(breakWithLabelStatement: JKBreakWithLabelStatement) = visitBreakStatement(breakWithLabelStatement)
+    open fun visitIfStatement(ifStatement: JKIfStatement) = visitStatement(ifStatement)
+    open fun visitIfElseStatement(ifElseStatement: JKIfElseStatement) = visitIfStatement(ifElseStatement)
+    open fun visitIfElseExpression(ifElseExpression: JKIfElseExpression) = visitExpression(ifElseExpression)
+    open fun visitAssignableExpression(assignableExpression: JKAssignableExpression) = visitExpression(assignableExpression)
+    open fun visitLambdaExpression(lambdaExpression: JKLambdaExpression) = visitExpression(lambdaExpression)
+    open fun visitDelegationConstructorCall(delegationConstructorCall: JKDelegationConstructorCall) = visitMethodCallExpression(delegationConstructorCall)
+    open fun visitLabel(label: JKLabel) = visitTreeElement(label)
+    open fun visitLabelEmpty(labelEmpty: JKLabelEmpty) = visitLabel(labelEmpty)
+    open fun visitLabelText(labelText: JKLabelText) = visitLabel(labelText)
+    open fun visitContinueStatement(continueStatement: JKContinueStatement) = visitStatement(continueStatement)
+    open fun visitLabeledStatement(labeledStatement: JKLabeledStatement) = visitExpression(labeledStatement)
+    open fun visitEmptyStatement(emptyStatement: JKEmptyStatement) = visitStatement(emptyStatement)
+    open fun visitTypeParameterList(typeParameterList: JKTypeParameterList) = visitTreeElement(typeParameterList)
+    open fun visitTypeParameter(typeParameter: JKTypeParameter) = visitTreeElement(typeParameter)
+    open fun visitTypeParameterListOwner(typeParameterListOwner: JKTypeParameterListOwner) = visitTreeElement(typeParameterListOwner)
+    open fun visitEnumConstant(enumConstant: JKEnumConstant) = visitVariable(enumConstant)
+    open fun visitForInStatement(forInStatement: JKForInStatement) = visitStatement(forInStatement)
+    open fun visitPackageDeclaration(packageDeclaration: JKPackageDeclaration) = visitDeclaration(packageDeclaration)
+    open fun visitClassLiteralExpression(classLiteralExpression: JKClassLiteralExpression) = visitExpression(classLiteralExpression)
+    open fun visitAnnotationMemberValue(annotationMemberValue: JKAnnotationMemberValue) = visitTreeElement(annotationMemberValue)
+    open fun visitField(field: JKField) = visitVariable(field)
+    open fun visitJavaField(javaField: JKJavaField) = visitField(javaField)
+    open fun visitJavaMethod(javaMethod: JKJavaMethod) = visitMethod(javaMethod)
+    open fun visitJavaMethodCallExpression(javaMethodCallExpression: JKJavaMethodCallExpression) = visitMethodCallExpression(javaMethodCallExpression)
+    open fun visitClassBody(classBody: JKClassBody) = visitTreeElement(classBody)
+    open fun visitEmptyClassBody(emptyClassBody: JKEmptyClassBody) = visitClassBody(emptyClassBody)
+    open fun visitJavaNewExpression(javaNewExpression: JKJavaNewExpression) = visitExpression(javaNewExpression)
+    open fun visitJavaDefaultNewExpression(javaDefaultNewExpression: JKJavaDefaultNewExpression) = visitExpression(javaDefaultNewExpression)
+    open fun visitJavaNewEmptyArray(javaNewEmptyArray: JKJavaNewEmptyArray) = visitExpression(javaNewEmptyArray)
+    open fun visitJavaNewArray(javaNewArray: JKJavaNewArray) = visitExpression(javaNewArray)
+    open fun visitJavaLiteralExpression(javaLiteralExpression: JKJavaLiteralExpression) = visitLiteralExpression(javaLiteralExpression)
+    open fun visitReturnStatement(returnStatement: JKReturnStatement) = visitStatement(returnStatement)
+    open fun visitJavaAssertStatement(javaAssertStatement: JKJavaAssertStatement) = visitStatement(javaAssertStatement)
+    open fun visitJavaForLoopStatement(javaForLoopStatement: JKJavaForLoopStatement) = visitLoopStatement(javaForLoopStatement)
+    open fun visitJavaPolyadicExpression(javaPolyadicExpression: JKJavaPolyadicExpression) = visitExpression(javaPolyadicExpression)
+    open fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression) = visitExpression(javaAssignmentExpression)
+    open fun visitJavaThrowStatement(javaThrowStatement: JKJavaThrowStatement) = visitStatement(javaThrowStatement)
+    open fun visitJavaTryStatement(javaTryStatement: JKJavaTryStatement) = visitStatement(javaTryStatement)
+    open fun visitJavaTryCatchSection(javaTryCatchSection: JKJavaTryCatchSection) = visitTreeElement(javaTryCatchSection)
+    open fun visitJavaSwitchStatement(javaSwitchStatement: JKJavaSwitchStatement) = visitStatement(javaSwitchStatement)
+    open fun visitJavaSwitchCase(javaSwitchCase: JKJavaSwitchCase) = visitTreeElement(javaSwitchCase)
+    open fun visitJavaDefaultSwitchCase(javaDefaultSwitchCase: JKJavaDefaultSwitchCase) = visitJavaSwitchCase(javaDefaultSwitchCase)
+    open fun visitJavaLabelSwitchCase(javaLabelSwitchCase: JKJavaLabelSwitchCase) = visitJavaSwitchCase(javaLabelSwitchCase)
+    open fun visitJavaContinueStatement(javaContinueStatement: JKJavaContinueStatement) = visitStatement(javaContinueStatement)
+    open fun visitJavaSynchronizedStatement(javaSynchronizedStatement: JKJavaSynchronizedStatement) = visitStatement(javaSynchronizedStatement)
+    open fun visitJavaAnnotationMethod(javaAnnotationMethod: JKJavaAnnotationMethod) = visitMethod(javaAnnotationMethod)
+    open fun visitJavaStaticInitDeclaration(javaStaticInitDeclaration: JKJavaStaticInitDeclaration) = visitDeclaration(javaStaticInitDeclaration)
+    open fun visitKtGetterOrSetter(ktGetterOrSetter: JKKtGetterOrSetter) = visitTreeElement(ktGetterOrSetter)
+    open fun visitKtEmptyGetterOrSetter(ktEmptyGetterOrSetter: JKKtEmptyGetterOrSetter) = visitKtGetterOrSetter(ktEmptyGetterOrSetter)
+    open fun visitKtProperty(ktProperty: JKKtProperty) = visitField(ktProperty)
+    open fun visitKtFunction(ktFunction: JKKtFunction) = visitMethod(ktFunction)
+    open fun visitKtConstructor(ktConstructor: JKKtConstructor) = visitMethod(ktConstructor)
+    open fun visitKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor) = visitKtConstructor(ktPrimaryConstructor)
+    open fun visitKtAssignmentStatement(ktAssignmentStatement: JKKtAssignmentStatement) = visitStatement(ktAssignmentStatement)
+    open fun visitKtCall(ktCall: JKKtCall) = visitMethodCallExpression(ktCall)
+    open fun visitKtMethodCallExpression(ktMethodCallExpression: JKKtMethodCallExpression) = visitMethodCallExpression(ktMethodCallExpression)
+    open fun visitKtAlsoCallExpression(ktAlsoCallExpression: JKKtAlsoCallExpression) = visitKtMethodCallExpression(ktAlsoCallExpression)
+    open fun visitKtLiteralExpression(ktLiteralExpression: JKKtLiteralExpression) = visitLiteralExpression(ktLiteralExpression)
+    open fun visitKtWhenStatement(ktWhenStatement: JKKtWhenStatement) = visitStatement(ktWhenStatement)
+    open fun visitKtWhenCase(ktWhenCase: JKKtWhenCase) = visitTreeElement(ktWhenCase)
+    open fun visitKtWhenLabel(ktWhenLabel: JKKtWhenLabel) = visitTreeElement(ktWhenLabel)
+    open fun visitKtElseWhenLabel(ktElseWhenLabel: JKKtElseWhenLabel) = visitKtWhenLabel(ktElseWhenLabel)
+    open fun visitKtValueWhenLabel(ktValueWhenLabel: JKKtValueWhenLabel) = visitKtWhenLabel(ktValueWhenLabel)
+    open fun visitKtIsExpression(ktIsExpression: JKKtIsExpression) = visitExpression(ktIsExpression)
+    open fun visitKtInitDeclaration(ktInitDeclaration: JKKtInitDeclaration) = visitDeclaration(ktInitDeclaration)
+    open fun visitKtConvertedFromForLoopSyntheticWhileStatement(ktConvertedFromForLoopSyntheticWhileStatement: JKKtConvertedFromForLoopSyntheticWhileStatement) = visitStatement(ktConvertedFromForLoopSyntheticWhileStatement)
+    open fun visitKtThrowExpression(ktThrowExpression: JKKtThrowExpression) = visitExpression(ktThrowExpression)
+    open fun visitKtTryExpression(ktTryExpression: JKKtTryExpression) = visitExpression(ktTryExpression)
+    open fun visitKtTryCatchSection(ktTryCatchSection: JKKtTryCatchSection) = visitTreeElement(ktTryCatchSection)
+    open fun visitKtAnnotationArrayInitializerExpression(ktAnnotationArrayInitializerExpression: JKKtAnnotationArrayInitializerExpression) = visitExpression(ktAnnotationArrayInitializerExpression)
 }
diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitorVoid.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitorVoid.kt
deleted file mode 100644
index 6ed7c5c3725..00000000000
--- a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitorVoid.kt
+++ /dev/null
@@ -1,433 +0,0 @@
-package org.jetbrains.kotlin.nj2k.tree.visitors
-
-import org.jetbrains.kotlin.nj2k.tree.*
-
-interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
-    fun visitTreeElement(treeElement: JKTreeElement)
-    override fun visitTreeElement(treeElement: JKTreeElement, data: Nothing?) = visitTreeElement(treeElement)
-    fun visitTreeRoot(treeRoot: JKTreeRoot) = visitTreeElement(treeRoot, null)
-    override fun visitTreeRoot(treeRoot: JKTreeRoot, data: Nothing?) = visitTreeRoot(treeRoot)
-    fun visitDeclaration(declaration: JKDeclaration) = visitTreeElement(declaration, null)
-    override fun visitDeclaration(declaration: JKDeclaration, data: Nothing?) = visitDeclaration(declaration)
-    fun visitImportStatement(importStatement: JKImportStatement) = visitTreeElement(importStatement, null)
-    override fun visitImportStatement(importStatement: JKImportStatement, data: Nothing?) = visitImportStatement(importStatement)
-    fun visitImportList(importList: JKImportList) = visitTreeElement(importList, null)
-    override fun visitImportList(importList: JKImportList, data: Nothing?) = visitImportList(importList)
-    fun visitFile(file: JKFile) = visitTreeElement(file, null)
-    override fun visitFile(file: JKFile, data: Nothing?) = visitFile(file)
-    fun visitClass(klass: JKClass) = visitDeclaration(klass, null)
-    override fun visitClass(klass: JKClass, data: Nothing?) = visitClass(klass)
-    fun visitInheritanceInfo(inheritanceInfo: JKInheritanceInfo) = visitTreeElement(inheritanceInfo, null)
-    override fun visitInheritanceInfo(inheritanceInfo: JKInheritanceInfo, data: Nothing?) = visitInheritanceInfo(inheritanceInfo)
-    fun visitAnnotationList(annotationList: JKAnnotationList) = visitTreeElement(annotationList, null)
-    override fun visitAnnotationList(annotationList: JKAnnotationList, data: Nothing?) = visitAnnotationList(annotationList)
-    fun visitAnnotation(annotation: JKAnnotation) = visitAnnotationMemberValue(annotation, null)
-    override fun visitAnnotation(annotation: JKAnnotation, data: Nothing?) = visitAnnotation(annotation)
-    fun visitAnnotationParameter(annotationParameter: JKAnnotationParameter) = visitTreeElement(annotationParameter, null)
-    override fun visitAnnotationParameter(annotationParameter: JKAnnotationParameter, data: Nothing?) =
-        visitAnnotationParameter(annotationParameter)
-
-    fun visitAnnotationNameParameter(annotationNameParameter: JKAnnotationNameParameter) =
-        visitAnnotationParameter(annotationNameParameter, null)
-
-    override fun visitAnnotationNameParameter(annotationNameParameter: JKAnnotationNameParameter, data: Nothing?) =
-        visitAnnotationNameParameter(annotationNameParameter)
-
-    fun visitAnnotationListOwner(annotationListOwner: JKAnnotationListOwner) = visitTreeElement(annotationListOwner, null)
-    override fun visitAnnotationListOwner(annotationListOwner: JKAnnotationListOwner, data: Nothing?) =
-        visitAnnotationListOwner(annotationListOwner)
-
-    fun visitMethod(method: JKMethod) = visitDeclaration(method, null)
-    override fun visitMethod(method: JKMethod, data: Nothing?) = visitMethod(method)
-    fun visitVariable(variable: JKVariable) = visitDeclaration(variable, null)
-    override fun visitVariable(variable: JKVariable, data: Nothing?) = visitVariable(variable)
-    fun visitForLoopVariable(forLoopVariable: JKForLoopVariable) = visitVariable(forLoopVariable, null)
-    override fun visitForLoopVariable(forLoopVariable: JKForLoopVariable, data: Nothing?) = visitForLoopVariable(forLoopVariable)
-    fun visitLocalVariable(localVariable: JKLocalVariable) = visitVariable(localVariable, null)
-    override fun visitLocalVariable(localVariable: JKLocalVariable, data: Nothing?) = visitLocalVariable(localVariable)
-    fun visitModifierElement(modifierElement: JKModifierElement) = visitTreeElement(modifierElement, null)
-    override fun visitModifierElement(modifierElement: JKModifierElement, data: Nothing?) = visitModifierElement(modifierElement)
-    fun visitMutabilityModifierElement(mutabilityModifierElement: JKMutabilityModifierElement) =
-        visitModifierElement(mutabilityModifierElement, null)
-
-    override fun visitMutabilityModifierElement(mutabilityModifierElement: JKMutabilityModifierElement, data: Nothing?) =
-        visitMutabilityModifierElement(mutabilityModifierElement)
-
-    fun visitModalityModifierElement(modalityModifierElement: JKModalityModifierElement) =
-        visitModifierElement(modalityModifierElement, null)
-
-    override fun visitModalityModifierElement(modalityModifierElement: JKModalityModifierElement, data: Nothing?) =
-        visitModalityModifierElement(modalityModifierElement)
-
-    fun visitVisibilityModifierElement(visibilityModifierElement: JKVisibilityModifierElement) =
-        visitModifierElement(visibilityModifierElement, null)
-
-    override fun visitVisibilityModifierElement(visibilityModifierElement: JKVisibilityModifierElement, data: Nothing?) =
-        visitVisibilityModifierElement(visibilityModifierElement)
-
-    fun visitExtraModifierElement(otherModifierElement: JKOtherModifierElement) = visitModifierElement(otherModifierElement, null)
-    override fun visitExtraModifierElement(otherModifierElement: JKOtherModifierElement, data: Nothing?) =
-        visitExtraModifierElement(otherModifierElement)
-
-    fun visitExtraModifiersOwner(otherModifiersOwner: JKOtherModifiersOwner) = visitModifiersListOwner(otherModifiersOwner, null)
-    override fun visitExtraModifiersOwner(otherModifiersOwner: JKOtherModifiersOwner, data: Nothing?) =
-        visitExtraModifiersOwner(otherModifiersOwner)
-
-    fun visitVisibilityOwner(visibilityOwner: JKVisibilityOwner) = visitModifiersListOwner(visibilityOwner, null)
-    override fun visitVisibilityOwner(visibilityOwner: JKVisibilityOwner, data: Nothing?) = visitVisibilityOwner(visibilityOwner)
-    fun visitModalityOwner(modalityOwner: JKModalityOwner) = visitModifiersListOwner(modalityOwner, null)
-    override fun visitModalityOwner(modalityOwner: JKModalityOwner, data: Nothing?) = visitModalityOwner(modalityOwner)
-    fun visitMutabilityOwner(mutabilityOwner: JKMutabilityOwner) = visitModifiersListOwner(mutabilityOwner, null)
-    override fun visitMutabilityOwner(mutabilityOwner: JKMutabilityOwner, data: Nothing?) = visitMutabilityOwner(mutabilityOwner)
-    fun visitModifiersListOwner(modifiersListOwner: JKModifiersListOwner) = visitTreeElement(modifiersListOwner, null)
-    override fun visitModifiersListOwner(modifiersListOwner: JKModifiersListOwner, data: Nothing?) =
-        visitModifiersListOwner(modifiersListOwner)
-
-    fun visitTypeElement(typeElement: JKTypeElement) = visitTreeElement(typeElement, null)
-    override fun visitTypeElement(typeElement: JKTypeElement, data: Nothing?) = visitTypeElement(typeElement)
-    fun visitStatement(statement: JKStatement) = visitTreeElement(statement, null)
-    override fun visitStatement(statement: JKStatement, data: Nothing?) = visitStatement(statement)
-    fun visitBlock(block: JKBlock) = visitTreeElement(block, null)
-    override fun visitBlock(block: JKBlock, data: Nothing?) = visitBlock(block)
-    fun visitBodyStub(bodyStub: JKBodyStub) = visitBlock(bodyStub, null)
-    override fun visitBodyStub(bodyStub: JKBodyStub, data: Nothing?) = visitBodyStub(bodyStub)
-    fun visitIdentifier(identifier: JKIdentifier) = visitTreeElement(identifier, null)
-    override fun visitIdentifier(identifier: JKIdentifier, data: Nothing?) = visitIdentifier(identifier)
-    fun visitNameIdentifier(nameIdentifier: JKNameIdentifier) = visitIdentifier(nameIdentifier, null)
-    override fun visitNameIdentifier(nameIdentifier: JKNameIdentifier, data: Nothing?) = visitNameIdentifier(nameIdentifier)
-    fun visitExpression(expression: JKExpression) = visitTreeElement(expression, null)
-    override fun visitExpression(expression: JKExpression, data: Nothing?) = visitExpression(expression)
-    fun visitMethodReferenceExpression(methodReferenceExpression: JKMethodReferenceExpression) =
-        visitExpression(methodReferenceExpression, null)
-
-    override fun visitMethodReferenceExpression(methodReferenceExpression: JKMethodReferenceExpression, data: Nothing?) =
-        visitMethodReferenceExpression(methodReferenceExpression)
-
-    fun visitExpressionStatement(expressionStatement: JKExpressionStatement) = visitStatement(expressionStatement, null)
-    override fun visitExpressionStatement(expressionStatement: JKExpressionStatement, data: Nothing?) =
-        visitExpressionStatement(expressionStatement)
-
-    fun visitDeclarationStatement(declarationStatement: JKDeclarationStatement) = visitStatement(declarationStatement, null)
-    override fun visitDeclarationStatement(declarationStatement: JKDeclarationStatement, data: Nothing?) =
-        visitDeclarationStatement(declarationStatement)
-
-    fun visitOperatorExpression(operatorExpression: JKOperatorExpression) = visitExpression(operatorExpression, null)
-    override fun visitOperatorExpression(operatorExpression: JKOperatorExpression, data: Nothing?) =
-        visitOperatorExpression(operatorExpression)
-
-    fun visitBinaryExpression(binaryExpression: JKBinaryExpression) = visitOperatorExpression(binaryExpression, null)
-    override fun visitBinaryExpression(binaryExpression: JKBinaryExpression, data: Nothing?) = visitBinaryExpression(binaryExpression)
-    fun visitUnaryExpression(unaryExpression: JKUnaryExpression) = visitOperatorExpression(unaryExpression, null)
-    override fun visitUnaryExpression(unaryExpression: JKUnaryExpression, data: Nothing?) = visitUnaryExpression(unaryExpression)
-    fun visitPrefixExpression(prefixExpression: JKPrefixExpression) = visitUnaryExpression(prefixExpression, null)
-    override fun visitPrefixExpression(prefixExpression: JKPrefixExpression, data: Nothing?) = visitPrefixExpression(prefixExpression)
-    fun visitPostfixExpression(postfixExpression: JKPostfixExpression) = visitUnaryExpression(postfixExpression, null)
-    override fun visitPostfixExpression(postfixExpression: JKPostfixExpression, data: Nothing?) = visitPostfixExpression(postfixExpression)
-    fun visitQualifiedExpression(qualifiedExpression: JKQualifiedExpression) = visitExpression(qualifiedExpression, null)
-    override fun visitQualifiedExpression(qualifiedExpression: JKQualifiedExpression, data: Nothing?) =
-        visitQualifiedExpression(qualifiedExpression)
-
-    fun visitTypeArgumentList(typeArgumentList: JKTypeArgumentList) = visitTreeElement(typeArgumentList, null)
-    override fun visitTypeArgumentList(typeArgumentList: JKTypeArgumentList, data: Nothing?) = visitTypeArgumentList(typeArgumentList)
-    fun visitTypeArgumentListOwner(typeArgumentListOwner: JKTypeArgumentListOwner) = visitTreeElement(typeArgumentListOwner, null)
-    override fun visitTypeArgumentListOwner(typeArgumentListOwner: JKTypeArgumentListOwner, data: Nothing?) =
-        visitTypeArgumentListOwner(typeArgumentListOwner)
-
-    fun visitMethodCallExpression(methodCallExpression: JKMethodCallExpression) = visitExpression(methodCallExpression, null)
-    override fun visitMethodCallExpression(methodCallExpression: JKMethodCallExpression, data: Nothing?) =
-        visitMethodCallExpression(methodCallExpression)
-
-    fun visitFieldAccessExpression(fieldAccessExpression: JKFieldAccessExpression) = visitAssignableExpression(fieldAccessExpression, null)
-    override fun visitFieldAccessExpression(fieldAccessExpression: JKFieldAccessExpression, data: Nothing?) =
-        visitFieldAccessExpression(fieldAccessExpression)
-
-    fun visitPackageAccessExpression(packageAccessExpression: JKPackageAccessExpression) =
-        visitAssignableExpression(packageAccessExpression, null)
-
-    override fun visitPackageAccessExpression(packageAccessExpression: JKPackageAccessExpression, data: Nothing?) =
-        visitPackageAccessExpression(packageAccessExpression)
-
-    fun visitClassAccessExpression(classAccessExpression: JKClassAccessExpression) = visitExpression(classAccessExpression, null)
-    override fun visitClassAccessExpression(classAccessExpression: JKClassAccessExpression, data: Nothing?) =
-        visitClassAccessExpression(classAccessExpression)
-
-    fun visitArrayAccessExpression(arrayAccessExpression: JKArrayAccessExpression) = visitAssignableExpression(arrayAccessExpression, null)
-    override fun visitArrayAccessExpression(arrayAccessExpression: JKArrayAccessExpression, data: Nothing?) =
-        visitArrayAccessExpression(arrayAccessExpression)
-
-    fun visitParenthesizedExpression(parenthesizedExpression: JKParenthesizedExpression) = visitExpression(parenthesizedExpression, null)
-    override fun visitParenthesizedExpression(parenthesizedExpression: JKParenthesizedExpression, data: Nothing?) =
-        visitParenthesizedExpression(parenthesizedExpression)
-
-    fun visitTypeCastExpression(typeCastExpression: JKTypeCastExpression) = visitExpression(typeCastExpression, null)
-    override fun visitTypeCastExpression(typeCastExpression: JKTypeCastExpression, data: Nothing?) =
-        visitTypeCastExpression(typeCastExpression)
-
-    fun visitExpressionList(expressionList: JKExpressionList) = visitTreeElement(expressionList, null)
-    override fun visitExpressionList(expressionList: JKExpressionList, data: Nothing?) = visitExpressionList(expressionList)
-    fun visitArgument(argument: JKArgument) = visitTreeElement(argument, null)
-    override fun visitArgument(argument: JKArgument, data: Nothing?) = visitArgument(argument)
-    fun visitNamedArgument(namedArgument: JKNamedArgument) = visitArgument(namedArgument, null)
-    override fun visitNamedArgument(namedArgument: JKNamedArgument, data: Nothing?) = visitNamedArgument(namedArgument)
-    fun visitArgumentList(argumentList: JKArgumentList) = visitTreeElement(argumentList, null)
-    override fun visitArgumentList(argumentList: JKArgumentList, data: Nothing?) = visitArgumentList(argumentList)
-    fun visitLiteralExpression(literalExpression: JKLiteralExpression) = visitExpression(literalExpression, null)
-    override fun visitLiteralExpression(literalExpression: JKLiteralExpression, data: Nothing?) = visitLiteralExpression(literalExpression)
-    fun visitParameter(parameter: JKParameter) = visitVariable(parameter, null)
-    override fun visitParameter(parameter: JKParameter, data: Nothing?) = visitParameter(parameter)
-    fun visitStringLiteralExpression(stringLiteralExpression: JKStringLiteralExpression) =
-        visitLiteralExpression(stringLiteralExpression, null)
-
-    override fun visitStringLiteralExpression(stringLiteralExpression: JKStringLiteralExpression, data: Nothing?) =
-        visitStringLiteralExpression(stringLiteralExpression)
-
-    fun visitStubExpression(stubExpression: JKStubExpression) = visitExpression(stubExpression, null)
-    override fun visitStubExpression(stubExpression: JKStubExpression, data: Nothing?) = visitStubExpression(stubExpression)
-    fun visitLoopStatement(loopStatement: JKLoopStatement) = visitStatement(loopStatement, null)
-    override fun visitLoopStatement(loopStatement: JKLoopStatement, data: Nothing?) = visitLoopStatement(loopStatement)
-    fun visitBlockStatement(blockStatement: JKBlockStatement) = visitStatement(blockStatement, null)
-    override fun visitBlockStatement(blockStatement: JKBlockStatement, data: Nothing?) = visitBlockStatement(blockStatement)
-    fun visitBlockStatementWithoutBrackets(blockStatementWithoutBrackets: JKBlockStatementWithoutBrackets) =
-        visitStatement(blockStatementWithoutBrackets, null)
-
-    override fun visitBlockStatementWithoutBrackets(blockStatementWithoutBrackets: JKBlockStatementWithoutBrackets, data: Nothing?) =
-        visitBlockStatementWithoutBrackets(blockStatementWithoutBrackets)
-
-    fun visitThisExpression(thisExpression: JKThisExpression) = visitExpression(thisExpression, null)
-    override fun visitThisExpression(thisExpression: JKThisExpression, data: Nothing?) = visitThisExpression(thisExpression)
-    fun visitSuperExpression(superExpression: JKSuperExpression) = visitExpression(superExpression, null)
-    override fun visitSuperExpression(superExpression: JKSuperExpression, data: Nothing?) = visitSuperExpression(superExpression)
-    fun visitWhileStatement(whileStatement: JKWhileStatement) = visitLoopStatement(whileStatement, null)
-    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 visitBreakStatement(breakStatement: JKBreakStatement) = visitStatement(breakStatement, null)
-    override fun visitBreakStatement(breakStatement: JKBreakStatement, data: Nothing?) = visitBreakStatement(breakStatement)
-    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)
-    fun visitIfElseStatement(ifElseStatement: JKIfElseStatement) = visitIfStatement(ifElseStatement, null)
-    override fun visitIfElseStatement(ifElseStatement: JKIfElseStatement, data: Nothing?) = visitIfElseStatement(ifElseStatement)
-    fun visitIfElseExpression(ifElseExpression: JKIfElseExpression) = visitExpression(ifElseExpression, null)
-    override fun visitIfElseExpression(ifElseExpression: JKIfElseExpression, data: Nothing?) = visitIfElseExpression(ifElseExpression)
-    fun visitAssignableExpression(assignableExpression: JKAssignableExpression) = visitExpression(assignableExpression, null)
-    override fun visitAssignableExpression(assignableExpression: JKAssignableExpression, data: Nothing?) =
-        visitAssignableExpression(assignableExpression)
-
-    fun visitLambdaExpression(lambdaExpression: JKLambdaExpression) = visitExpression(lambdaExpression, null)
-    override fun visitLambdaExpression(lambdaExpression: JKLambdaExpression, data: Nothing?) = visitLambdaExpression(lambdaExpression)
-    fun visitDelegationConstructorCall(delegationConstructorCall: JKDelegationConstructorCall) =
-        visitMethodCallExpression(delegationConstructorCall, null)
-
-    override fun visitDelegationConstructorCall(delegationConstructorCall: JKDelegationConstructorCall, data: Nothing?) =
-        visitDelegationConstructorCall(delegationConstructorCall)
-
-    fun visitLabel(label: JKLabel) = visitTreeElement(label, null)
-    override fun visitLabel(label: JKLabel, data: Nothing?) = visitLabel(label)
-    fun visitLabelEmpty(labelEmpty: JKLabelEmpty) = visitLabel(labelEmpty, null)
-    override fun visitLabelEmpty(labelEmpty: JKLabelEmpty, data: Nothing?) = visitLabelEmpty(labelEmpty)
-    fun visitLabelText(labelText: JKLabelText) = visitLabel(labelText, null)
-    override fun visitLabelText(labelText: JKLabelText, data: Nothing?) = visitLabelText(labelText)
-    fun visitContinueStatement(continueStatement: JKContinueStatement) = visitStatement(continueStatement, null)
-    override fun visitContinueStatement(continueStatement: JKContinueStatement, data: Nothing?) = visitContinueStatement(continueStatement)
-    fun visitLabeledStatement(labeledStatement: JKLabeledStatement) = visitExpression(labeledStatement, null)
-    override fun visitLabeledStatement(labeledStatement: JKLabeledStatement, data: Nothing?) = visitLabeledStatement(labeledStatement)
-    fun visitEmptyStatement(emptyStatement: JKEmptyStatement) = visitStatement(emptyStatement, null)
-    override fun visitEmptyStatement(emptyStatement: JKEmptyStatement, data: Nothing?) = visitEmptyStatement(emptyStatement)
-    fun visitTypeParameterList(typeParameterList: JKTypeParameterList) = visitTreeElement(typeParameterList, null)
-    override fun visitTypeParameterList(typeParameterList: JKTypeParameterList, data: Nothing?) = visitTypeParameterList(typeParameterList)
-    fun visitTypeParameter(typeParameter: JKTypeParameter) = visitTreeElement(typeParameter, null)
-    override fun visitTypeParameter(typeParameter: JKTypeParameter, data: Nothing?) = visitTypeParameter(typeParameter)
-    fun visitTypeParameterListOwner(typeParameterListOwner: JKTypeParameterListOwner) = visitTreeElement(typeParameterListOwner, null)
-    override fun visitTypeParameterListOwner(typeParameterListOwner: JKTypeParameterListOwner, data: Nothing?) =
-        visitTypeParameterListOwner(typeParameterListOwner)
-
-    fun visitEnumConstant(enumConstant: JKEnumConstant) = visitVariable(enumConstant, null)
-    override fun visitEnumConstant(enumConstant: JKEnumConstant, data: Nothing?) = visitEnumConstant(enumConstant)
-    fun visitForInStatement(forInStatement: JKForInStatement) = visitStatement(forInStatement, null)
-    override fun visitForInStatement(forInStatement: JKForInStatement, data: Nothing?) = visitForInStatement(forInStatement)
-    fun visitPackageDeclaration(packageDeclaration: JKPackageDeclaration) = visitDeclaration(packageDeclaration, null)
-    override fun visitPackageDeclaration(packageDeclaration: JKPackageDeclaration, data: Nothing?) =
-        visitPackageDeclaration(packageDeclaration)
-
-    fun visitClassLiteralExpression(classLiteralExpression: JKClassLiteralExpression) = visitExpression(classLiteralExpression, null)
-    override fun visitClassLiteralExpression(classLiteralExpression: JKClassLiteralExpression, data: Nothing?) =
-        visitClassLiteralExpression(classLiteralExpression)
-
-    fun visitAnnotationMemberValue(annotationMemberValue: JKAnnotationMemberValue) = visitTreeElement(annotationMemberValue, null)
-    override fun visitAnnotationMemberValue(annotationMemberValue: JKAnnotationMemberValue, data: Nothing?) =
-        visitAnnotationMemberValue(annotationMemberValue)
-
-    fun visitField(field: JKField) = visitVariable(field, null)
-    override fun visitField(field: JKField, data: Nothing?) = visitField(field)
-    fun visitJavaField(javaField: JKJavaField) = visitField(javaField, null)
-    override fun visitJavaField(javaField: JKJavaField, data: Nothing?) = visitJavaField(javaField)
-    fun visitJavaMethod(javaMethod: JKJavaMethod) = visitMethod(javaMethod, null)
-    override fun visitJavaMethod(javaMethod: JKJavaMethod, data: Nothing?) = visitJavaMethod(javaMethod)
-    fun visitJavaMethodCallExpression(javaMethodCallExpression: JKJavaMethodCallExpression) =
-        visitMethodCallExpression(javaMethodCallExpression, null)
-
-    override fun visitJavaMethodCallExpression(javaMethodCallExpression: JKJavaMethodCallExpression, data: Nothing?) =
-        visitJavaMethodCallExpression(javaMethodCallExpression)
-
-    fun visitClassBody(classBody: JKClassBody) = visitTreeElement(classBody, null)
-    override fun visitClassBody(classBody: JKClassBody, data: Nothing?) = visitClassBody(classBody)
-    fun visitEmptyClassBody(emptyClassBody: JKEmptyClassBody) = visitClassBody(emptyClassBody, null)
-    override fun visitEmptyClassBody(emptyClassBody: JKEmptyClassBody, data: Nothing?) = visitEmptyClassBody(emptyClassBody)
-    fun visitJavaNewExpression(javaNewExpression: JKJavaNewExpression) = visitExpression(javaNewExpression, null)
-    override fun visitJavaNewExpression(javaNewExpression: JKJavaNewExpression, data: Nothing?) = visitJavaNewExpression(javaNewExpression)
-    fun visitJavaDefaultNewExpression(javaDefaultNewExpression: JKJavaDefaultNewExpression) =
-        visitExpression(javaDefaultNewExpression, null)
-
-    override fun visitJavaDefaultNewExpression(javaDefaultNewExpression: JKJavaDefaultNewExpression, data: Nothing?) =
-        visitJavaDefaultNewExpression(javaDefaultNewExpression)
-
-    fun visitJavaNewEmptyArray(javaNewEmptyArray: JKJavaNewEmptyArray) = visitExpression(javaNewEmptyArray, null)
-    override fun visitJavaNewEmptyArray(javaNewEmptyArray: JKJavaNewEmptyArray, data: Nothing?) = visitJavaNewEmptyArray(javaNewEmptyArray)
-    fun visitJavaNewArray(javaNewArray: JKJavaNewArray) = visitExpression(javaNewArray, null)
-    override fun visitJavaNewArray(javaNewArray: JKJavaNewArray, data: Nothing?) = visitJavaNewArray(javaNewArray)
-    fun visitJavaLiteralExpression(javaLiteralExpression: JKJavaLiteralExpression) = visitLiteralExpression(javaLiteralExpression, null)
-    override fun visitJavaLiteralExpression(javaLiteralExpression: JKJavaLiteralExpression, data: Nothing?) =
-        visitJavaLiteralExpression(javaLiteralExpression)
-
-    fun visitReturnStatement(returnStatement: JKReturnStatement) = visitStatement(returnStatement, null)
-    override fun visitReturnStatement(returnStatement: JKReturnStatement, data: Nothing?) = visitReturnStatement(returnStatement)
-    fun visitJavaAssertStatement(javaAssertStatement: JKJavaAssertStatement) = visitStatement(javaAssertStatement, null)
-    override fun visitJavaAssertStatement(javaAssertStatement: JKJavaAssertStatement, data: Nothing?) =
-        visitJavaAssertStatement(javaAssertStatement)
-
-    fun visitJavaForLoopStatement(javaForLoopStatement: JKJavaForLoopStatement) = visitLoopStatement(javaForLoopStatement, null)
-    override fun visitJavaForLoopStatement(javaForLoopStatement: JKJavaForLoopStatement, data: Nothing?) =
-        visitJavaForLoopStatement(javaForLoopStatement)
-
-    fun visitJavaPolyadicExpression(javaPolyadicExpression: JKJavaPolyadicExpression) = visitExpression(javaPolyadicExpression, null)
-    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 visitJavaThrowStatement(javaThrowStatement: JKJavaThrowStatement) = visitStatement(javaThrowStatement, null)
-    override fun visitJavaThrowStatement(javaThrowStatement: JKJavaThrowStatement, data: Nothing?) =
-        visitJavaThrowStatement(javaThrowStatement)
-
-    fun visitJavaTryStatement(javaTryStatement: JKJavaTryStatement) = visitStatement(javaTryStatement, null)
-    override fun visitJavaTryStatement(javaTryStatement: JKJavaTryStatement, data: Nothing?) = visitJavaTryStatement(javaTryStatement)
-    fun visitJavaTryCatchSection(javaTryCatchSection: JKJavaTryCatchSection) = visitTreeElement(javaTryCatchSection, null)
-    override fun visitJavaTryCatchSection(javaTryCatchSection: JKJavaTryCatchSection, data: Nothing?) =
-        visitJavaTryCatchSection(javaTryCatchSection)
-
-    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 visitJavaContinueStatement(javaContinueStatement: JKJavaContinueStatement) = visitStatement(javaContinueStatement, null)
-    override fun visitJavaContinueStatement(javaContinueStatement: JKJavaContinueStatement, data: Nothing?) =
-        visitJavaContinueStatement(javaContinueStatement)
-
-    fun visitJavaSynchronizedStatement(javaSynchronizedStatement: JKJavaSynchronizedStatement) =
-        visitStatement(javaSynchronizedStatement, null)
-
-    override fun visitJavaSynchronizedStatement(javaSynchronizedStatement: JKJavaSynchronizedStatement, data: Nothing?) =
-        visitJavaSynchronizedStatement(javaSynchronizedStatement)
-
-    fun visitJavaAnnotationMethod(javaAnnotationMethod: JKJavaAnnotationMethod) = visitMethod(javaAnnotationMethod, null)
-    override fun visitJavaAnnotationMethod(javaAnnotationMethod: JKJavaAnnotationMethod, data: Nothing?) =
-        visitJavaAnnotationMethod(javaAnnotationMethod)
-
-    fun visitJavaStaticInitDeclaration(javaStaticInitDeclaration: JKJavaStaticInitDeclaration) =
-        visitDeclaration(javaStaticInitDeclaration, null)
-
-    override fun visitJavaStaticInitDeclaration(javaStaticInitDeclaration: JKJavaStaticInitDeclaration, data: Nothing?) =
-        visitJavaStaticInitDeclaration(javaStaticInitDeclaration)
-
-    fun visitKtGetterOrSetter(ktGetterOrSetter: JKKtGetterOrSetter) = visitTreeElement(ktGetterOrSetter, null)
-    override fun visitKtGetterOrSetter(ktGetterOrSetter: JKKtGetterOrSetter, data: Nothing?) = visitKtGetterOrSetter(ktGetterOrSetter)
-    fun visitKtEmptyGetterOrSetter(ktEmptyGetterOrSetter: JKKtEmptyGetterOrSetter) = visitKtGetterOrSetter(ktEmptyGetterOrSetter, null)
-    override fun visitKtEmptyGetterOrSetter(ktEmptyGetterOrSetter: JKKtEmptyGetterOrSetter, data: Nothing?) =
-        visitKtEmptyGetterOrSetter(ktEmptyGetterOrSetter)
-
-    fun visitKtProperty(ktProperty: JKKtProperty) = visitField(ktProperty, null)
-    override fun visitKtProperty(ktProperty: JKKtProperty, data: Nothing?) = visitKtProperty(ktProperty)
-    fun visitKtFunction(ktFunction: JKKtFunction) = visitMethod(ktFunction, null)
-    override fun visitKtFunction(ktFunction: JKKtFunction, data: Nothing?) = visitKtFunction(ktFunction)
-    fun visitKtConstructor(ktConstructor: JKKtConstructor) = visitMethod(ktConstructor, null)
-    override fun visitKtConstructor(ktConstructor: JKKtConstructor, data: Nothing?) = visitKtConstructor(ktConstructor)
-    fun visitKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor) = visitKtConstructor(ktPrimaryConstructor, null)
-    override fun visitKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor, data: Nothing?) =
-        visitKtPrimaryConstructor(ktPrimaryConstructor)
-
-    fun visitKtAssignmentStatement(ktAssignmentStatement: JKKtAssignmentStatement) = visitStatement(ktAssignmentStatement, null)
-    override fun visitKtAssignmentStatement(ktAssignmentStatement: JKKtAssignmentStatement, data: Nothing?) =
-        visitKtAssignmentStatement(ktAssignmentStatement)
-
-    fun visitKtCall(ktCall: JKKtCall) = visitMethodCallExpression(ktCall, null)
-    override fun visitKtCall(ktCall: JKKtCall, data: Nothing?) = visitKtCall(ktCall)
-    fun visitKtMethodCallExpression(ktMethodCallExpression: JKKtMethodCallExpression) =
-        visitMethodCallExpression(ktMethodCallExpression, null)
-
-    override fun visitKtMethodCallExpression(ktMethodCallExpression: JKKtMethodCallExpression, data: Nothing?) =
-        visitKtMethodCallExpression(ktMethodCallExpression)
-
-    fun visitKtAlsoCallExpression(ktAlsoCallExpression: JKKtAlsoCallExpression) = visitKtMethodCallExpression(ktAlsoCallExpression, null)
-    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)
-    fun visitKtIsExpression(ktIsExpression: JKKtIsExpression) = visitExpression(ktIsExpression, null)
-    override fun visitKtIsExpression(ktIsExpression: JKKtIsExpression, data: Nothing?) = visitKtIsExpression(ktIsExpression)
-    fun visitKtInitDeclaration(ktInitDeclaration: JKKtInitDeclaration) = visitDeclaration(ktInitDeclaration, null)
-    override fun visitKtInitDeclaration(ktInitDeclaration: JKKtInitDeclaration, data: Nothing?) = visitKtInitDeclaration(ktInitDeclaration)
-    fun visitKtConvertedFromForLoopSyntheticWhileStatement(ktConvertedFromForLoopSyntheticWhileStatement: JKKtConvertedFromForLoopSyntheticWhileStatement) =
-        visitStatement(ktConvertedFromForLoopSyntheticWhileStatement, null)
-
-    override fun visitKtConvertedFromForLoopSyntheticWhileStatement(
-        ktConvertedFromForLoopSyntheticWhileStatement: JKKtConvertedFromForLoopSyntheticWhileStatement,
-        data: Nothing?
-    ) = visitKtConvertedFromForLoopSyntheticWhileStatement(ktConvertedFromForLoopSyntheticWhileStatement)
-
-    fun visitKtThrowExpression(ktThrowExpression: JKKtThrowExpression) = visitExpression(ktThrowExpression, null)
-    override fun visitKtThrowExpression(ktThrowExpression: JKKtThrowExpression, data: Nothing?) = visitKtThrowExpression(ktThrowExpression)
-    fun visitKtTryExpression(ktTryExpression: JKKtTryExpression) = visitExpression(ktTryExpression, null)
-    override fun visitKtTryExpression(ktTryExpression: JKKtTryExpression, data: Nothing?) = visitKtTryExpression(ktTryExpression)
-    fun visitKtTryCatchSection(ktTryCatchSection: JKKtTryCatchSection) = visitTreeElement(ktTryCatchSection, null)
-    override fun visitKtTryCatchSection(ktTryCatchSection: JKKtTryCatchSection, data: Nothing?) = visitKtTryCatchSection(ktTryCatchSection)
-    fun visitKtAnnotationArrayInitializerExpression(ktAnnotationArrayInitializerExpression: JKKtAnnotationArrayInitializerExpression) =
-        visitExpression(ktAnnotationArrayInitializerExpression, null)
-
-    override fun visitKtAnnotationArrayInitializerExpression(
-        ktAnnotationArrayInitializerExpression: JKKtAnnotationArrayInitializerExpression,
-        data: Nothing?
-    ) = visitKtAnnotationArrayInitializerExpression(ktAnnotationArrayInitializerExpression)
-}
diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitorWithCommentsPrinting.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitorWithCommentsPrinting.kt
index 0767cf8fb49..a219e6ad6d0 100644
--- a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitorWithCommentsPrinting.kt
+++ b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitorWithCommentsPrinting.kt
@@ -2,9 +2,9 @@ package org.jetbrains.kotlin.nj2k.tree.visitors
 
 import org.jetbrains.kotlin.nj2k.tree.*
 
-interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
-    fun printLeftNonCodeElements(element: JKNonCodeElementsListOwner)
-    fun printRightNonCodeElements(element: JKNonCodeElementsListOwner)
+abstract class JKVisitorWithCommentsPrinting : JKVisitor() {
+    abstract fun printLeftNonCodeElements(element: JKNonCodeElementsListOwner)
+    abstract fun printRightNonCodeElements(element: JKNonCodeElementsListOwner)
 
     override fun visitTreeElement(treeElement: JKTreeElement) {
         printLeftNonCodeElements(treeElement)
@@ -12,7 +12,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(treeElement)
     }
 
-    fun visitTreeElementRaw(treeElement: JKTreeElement)
+    abstract fun visitTreeElementRaw(treeElement: JKTreeElement) 
 
     override fun visitTreeRoot(treeRoot: JKTreeRoot) {
         printLeftNonCodeElements(treeRoot)
@@ -20,7 +20,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(treeRoot)
     }
 
-    fun visitTreeRootRaw(treeRoot: JKTreeRoot) = visitTreeElementRaw(treeRoot)
+    open fun visitTreeRootRaw(treeRoot: JKTreeRoot) = visitTreeElementRaw(treeRoot)
 
     override fun visitDeclaration(declaration: JKDeclaration) {
         printLeftNonCodeElements(declaration)
@@ -28,7 +28,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(declaration)
     }
 
-    fun visitDeclarationRaw(declaration: JKDeclaration) = visitTreeElementRaw(declaration)
+    open fun visitDeclarationRaw(declaration: JKDeclaration) = visitTreeElementRaw(declaration)
 
     override fun visitImportStatement(importStatement: JKImportStatement) {
         printLeftNonCodeElements(importStatement)
@@ -36,7 +36,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(importStatement)
     }
 
-    fun visitImportStatementRaw(importStatement: JKImportStatement) = visitTreeElementRaw(importStatement)
+    open fun visitImportStatementRaw(importStatement: JKImportStatement) = visitTreeElementRaw(importStatement)
 
     override fun visitImportList(importList: JKImportList) {
         printLeftNonCodeElements(importList)
@@ -44,7 +44,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(importList)
     }
 
-    fun visitImportListRaw(importList: JKImportList) = visitTreeElementRaw(importList)
+    open fun visitImportListRaw(importList: JKImportList) = visitTreeElementRaw(importList)
 
     override fun visitFile(file: JKFile) {
         printLeftNonCodeElements(file)
@@ -52,7 +52,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(file)
     }
 
-    fun visitFileRaw(file: JKFile) = visitTreeElementRaw(file)
+    open fun visitFileRaw(file: JKFile) = visitTreeElementRaw(file)
 
     override fun visitClass(klass: JKClass) {
         printLeftNonCodeElements(klass)
@@ -60,7 +60,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(klass)
     }
 
-    fun visitClassRaw(klass: JKClass) = visitDeclarationRaw(klass)
+    open fun visitClassRaw(klass: JKClass) = visitDeclarationRaw(klass)
 
     override fun visitInheritanceInfo(inheritanceInfo: JKInheritanceInfo) {
         printLeftNonCodeElements(inheritanceInfo)
@@ -68,7 +68,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(inheritanceInfo)
     }
 
-    fun visitInheritanceInfoRaw(inheritanceInfo: JKInheritanceInfo) = visitTreeElementRaw(inheritanceInfo)
+    open fun visitInheritanceInfoRaw(inheritanceInfo: JKInheritanceInfo) = visitTreeElementRaw(inheritanceInfo)
 
     override fun visitAnnotationList(annotationList: JKAnnotationList) {
         printLeftNonCodeElements(annotationList)
@@ -76,7 +76,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(annotationList)
     }
 
-    fun visitAnnotationListRaw(annotationList: JKAnnotationList) = visitTreeElementRaw(annotationList)
+    open fun visitAnnotationListRaw(annotationList: JKAnnotationList) = visitTreeElementRaw(annotationList)
 
     override fun visitAnnotation(annotation: JKAnnotation) {
         printLeftNonCodeElements(annotation)
@@ -84,7 +84,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(annotation)
     }
 
-    fun visitAnnotationRaw(annotation: JKAnnotation) = visitAnnotationMemberValueRaw(annotation)
+    open fun visitAnnotationRaw(annotation: JKAnnotation) = visitAnnotationMemberValueRaw(annotation)
 
     override fun visitAnnotationParameter(annotationParameter: JKAnnotationParameter) {
         printLeftNonCodeElements(annotationParameter)
@@ -92,7 +92,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(annotationParameter)
     }
 
-    fun visitAnnotationParameterRaw(annotationParameter: JKAnnotationParameter) = visitTreeElementRaw(annotationParameter)
+    open fun visitAnnotationParameterRaw(annotationParameter: JKAnnotationParameter) = visitTreeElementRaw(annotationParameter)
 
     override fun visitAnnotationNameParameter(annotationNameParameter: JKAnnotationNameParameter) {
         printLeftNonCodeElements(annotationNameParameter)
@@ -100,8 +100,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(annotationNameParameter)
     }
 
-    fun visitAnnotationNameParameterRaw(annotationNameParameter: JKAnnotationNameParameter) =
-        visitAnnotationParameterRaw(annotationNameParameter)
+    open fun visitAnnotationNameParameterRaw(annotationNameParameter: JKAnnotationNameParameter) = visitAnnotationParameterRaw(annotationNameParameter)
 
     override fun visitAnnotationListOwner(annotationListOwner: JKAnnotationListOwner) {
         printLeftNonCodeElements(annotationListOwner)
@@ -109,7 +108,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(annotationListOwner)
     }
 
-    fun visitAnnotationListOwnerRaw(annotationListOwner: JKAnnotationListOwner) = visitTreeElementRaw(annotationListOwner)
+    open fun visitAnnotationListOwnerRaw(annotationListOwner: JKAnnotationListOwner) = visitTreeElementRaw(annotationListOwner)
 
     override fun visitMethod(method: JKMethod) {
         printLeftNonCodeElements(method)
@@ -117,7 +116,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(method)
     }
 
-    fun visitMethodRaw(method: JKMethod) = visitDeclarationRaw(method)
+    open fun visitMethodRaw(method: JKMethod) = visitDeclarationRaw(method)
 
     override fun visitVariable(variable: JKVariable) {
         printLeftNonCodeElements(variable)
@@ -125,7 +124,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(variable)
     }
 
-    fun visitVariableRaw(variable: JKVariable) = visitDeclarationRaw(variable)
+    open fun visitVariableRaw(variable: JKVariable) = visitDeclarationRaw(variable)
 
     override fun visitForLoopVariable(forLoopVariable: JKForLoopVariable) {
         printLeftNonCodeElements(forLoopVariable)
@@ -133,7 +132,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(forLoopVariable)
     }
 
-    fun visitForLoopVariableRaw(forLoopVariable: JKForLoopVariable) = visitVariableRaw(forLoopVariable)
+    open fun visitForLoopVariableRaw(forLoopVariable: JKForLoopVariable) = visitVariableRaw(forLoopVariable)
 
     override fun visitLocalVariable(localVariable: JKLocalVariable) {
         printLeftNonCodeElements(localVariable)
@@ -141,7 +140,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(localVariable)
     }
 
-    fun visitLocalVariableRaw(localVariable: JKLocalVariable) = visitVariableRaw(localVariable)
+    open fun visitLocalVariableRaw(localVariable: JKLocalVariable) = visitVariableRaw(localVariable)
 
     override fun visitModifierElement(modifierElement: JKModifierElement) {
         printLeftNonCodeElements(modifierElement)
@@ -149,7 +148,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(modifierElement)
     }
 
-    fun visitModifierElementRaw(modifierElement: JKModifierElement) = visitTreeElementRaw(modifierElement)
+    open fun visitModifierElementRaw(modifierElement: JKModifierElement) = visitTreeElementRaw(modifierElement)
 
     override fun visitMutabilityModifierElement(mutabilityModifierElement: JKMutabilityModifierElement) {
         printLeftNonCodeElements(mutabilityModifierElement)
@@ -157,8 +156,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(mutabilityModifierElement)
     }
 
-    fun visitMutabilityModifierElementRaw(mutabilityModifierElement: JKMutabilityModifierElement) =
-        visitModifierElementRaw(mutabilityModifierElement)
+    open fun visitMutabilityModifierElementRaw(mutabilityModifierElement: JKMutabilityModifierElement) = visitModifierElementRaw(mutabilityModifierElement)
 
     override fun visitModalityModifierElement(modalityModifierElement: JKModalityModifierElement) {
         printLeftNonCodeElements(modalityModifierElement)
@@ -166,8 +164,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(modalityModifierElement)
     }
 
-    fun visitModalityModifierElementRaw(modalityModifierElement: JKModalityModifierElement) =
-        visitModifierElementRaw(modalityModifierElement)
+    open fun visitModalityModifierElementRaw(modalityModifierElement: JKModalityModifierElement) = visitModifierElementRaw(modalityModifierElement)
 
     override fun visitVisibilityModifierElement(visibilityModifierElement: JKVisibilityModifierElement) {
         printLeftNonCodeElements(visibilityModifierElement)
@@ -175,24 +172,23 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(visibilityModifierElement)
     }
 
-    fun visitVisibilityModifierElementRaw(visibilityModifierElement: JKVisibilityModifierElement) =
-        visitModifierElementRaw(visibilityModifierElement)
+    open fun visitVisibilityModifierElementRaw(visibilityModifierElement: JKVisibilityModifierElement) = visitModifierElementRaw(visibilityModifierElement)
 
-    override fun visitExtraModifierElement(otherModifierElement: JKOtherModifierElement) {
+    override fun visitOtherModifierElement(otherModifierElement: JKOtherModifierElement) {
         printLeftNonCodeElements(otherModifierElement)
-        visitExtraModifierElementRaw(otherModifierElement)
+        visitOtherModifierElementRaw(otherModifierElement)
         printRightNonCodeElements(otherModifierElement)
     }
 
-    fun visitExtraModifierElementRaw(otherModifierElement: JKOtherModifierElement) = visitModifierElementRaw(otherModifierElement)
+    open fun visitOtherModifierElementRaw(otherModifierElement: JKOtherModifierElement) = visitModifierElementRaw(otherModifierElement)
 
-    override fun visitExtraModifiersOwner(otherModifiersOwner: JKOtherModifiersOwner) {
+    override fun visitOtherModifiersOwner(otherModifiersOwner: JKOtherModifiersOwner) {
         printLeftNonCodeElements(otherModifiersOwner)
-        visitExtraModifiersOwnerRaw(otherModifiersOwner)
+        visitOtherModifiersOwnerRaw(otherModifiersOwner)
         printRightNonCodeElements(otherModifiersOwner)
     }
 
-    fun visitExtraModifiersOwnerRaw(otherModifiersOwner: JKOtherModifiersOwner) = visitModifiersListOwnerRaw(otherModifiersOwner)
+    open fun visitOtherModifiersOwnerRaw(otherModifiersOwner: JKOtherModifiersOwner) = visitModifiersListOwnerRaw(otherModifiersOwner)
 
     override fun visitVisibilityOwner(visibilityOwner: JKVisibilityOwner) {
         printLeftNonCodeElements(visibilityOwner)
@@ -200,7 +196,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(visibilityOwner)
     }
 
-    fun visitVisibilityOwnerRaw(visibilityOwner: JKVisibilityOwner) = visitModifiersListOwnerRaw(visibilityOwner)
+    open fun visitVisibilityOwnerRaw(visibilityOwner: JKVisibilityOwner) = visitModifiersListOwnerRaw(visibilityOwner)
 
     override fun visitModalityOwner(modalityOwner: JKModalityOwner) {
         printLeftNonCodeElements(modalityOwner)
@@ -208,7 +204,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(modalityOwner)
     }
 
-    fun visitModalityOwnerRaw(modalityOwner: JKModalityOwner) = visitModifiersListOwnerRaw(modalityOwner)
+    open fun visitModalityOwnerRaw(modalityOwner: JKModalityOwner) = visitModifiersListOwnerRaw(modalityOwner)
 
     override fun visitMutabilityOwner(mutabilityOwner: JKMutabilityOwner) {
         printLeftNonCodeElements(mutabilityOwner)
@@ -216,7 +212,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(mutabilityOwner)
     }
 
-    fun visitMutabilityOwnerRaw(mutabilityOwner: JKMutabilityOwner) = visitModifiersListOwnerRaw(mutabilityOwner)
+    open fun visitMutabilityOwnerRaw(mutabilityOwner: JKMutabilityOwner) = visitModifiersListOwnerRaw(mutabilityOwner)
 
     override fun visitModifiersListOwner(modifiersListOwner: JKModifiersListOwner) {
         printLeftNonCodeElements(modifiersListOwner)
@@ -224,7 +220,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(modifiersListOwner)
     }
 
-    fun visitModifiersListOwnerRaw(modifiersListOwner: JKModifiersListOwner) = visitTreeElementRaw(modifiersListOwner)
+    open fun visitModifiersListOwnerRaw(modifiersListOwner: JKModifiersListOwner) = visitTreeElementRaw(modifiersListOwner)
 
     override fun visitTypeElement(typeElement: JKTypeElement) {
         printLeftNonCodeElements(typeElement)
@@ -232,7 +228,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(typeElement)
     }
 
-    fun visitTypeElementRaw(typeElement: JKTypeElement) = visitTreeElementRaw(typeElement)
+    open fun visitTypeElementRaw(typeElement: JKTypeElement) = visitTreeElementRaw(typeElement)
 
     override fun visitStatement(statement: JKStatement) {
         printLeftNonCodeElements(statement)
@@ -240,7 +236,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(statement)
     }
 
-    fun visitStatementRaw(statement: JKStatement) = visitTreeElementRaw(statement)
+    open fun visitStatementRaw(statement: JKStatement) = visitTreeElementRaw(statement)
 
     override fun visitBlock(block: JKBlock) {
         printLeftNonCodeElements(block)
@@ -248,7 +244,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(block)
     }
 
-    fun visitBlockRaw(block: JKBlock) = visitTreeElementRaw(block)
+    open fun visitBlockRaw(block: JKBlock) = visitTreeElementRaw(block)
 
     override fun visitBodyStub(bodyStub: JKBodyStub) {
         printLeftNonCodeElements(bodyStub)
@@ -256,7 +252,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(bodyStub)
     }
 
-    fun visitBodyStubRaw(bodyStub: JKBodyStub) = visitBlockRaw(bodyStub)
+    open fun visitBodyStubRaw(bodyStub: JKBodyStub) = visitBlockRaw(bodyStub)
 
     override fun visitIdentifier(identifier: JKIdentifier) {
         printLeftNonCodeElements(identifier)
@@ -264,7 +260,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(identifier)
     }
 
-    fun visitIdentifierRaw(identifier: JKIdentifier) = visitTreeElementRaw(identifier)
+    open fun visitIdentifierRaw(identifier: JKIdentifier) = visitTreeElementRaw(identifier)
 
     override fun visitNameIdentifier(nameIdentifier: JKNameIdentifier) {
         printLeftNonCodeElements(nameIdentifier)
@@ -272,7 +268,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(nameIdentifier)
     }
 
-    fun visitNameIdentifierRaw(nameIdentifier: JKNameIdentifier) = visitIdentifierRaw(nameIdentifier)
+    open fun visitNameIdentifierRaw(nameIdentifier: JKNameIdentifier) = visitIdentifierRaw(nameIdentifier)
 
     override fun visitExpression(expression: JKExpression) {
         printLeftNonCodeElements(expression)
@@ -280,7 +276,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(expression)
     }
 
-    fun visitExpressionRaw(expression: JKExpression) = visitTreeElementRaw(expression)
+    open fun visitExpressionRaw(expression: JKExpression) = visitTreeElementRaw(expression)
 
     override fun visitMethodReferenceExpression(methodReferenceExpression: JKMethodReferenceExpression) {
         printLeftNonCodeElements(methodReferenceExpression)
@@ -288,8 +284,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(methodReferenceExpression)
     }
 
-    fun visitMethodReferenceExpressionRaw(methodReferenceExpression: JKMethodReferenceExpression) =
-        visitExpressionRaw(methodReferenceExpression)
+    open fun visitMethodReferenceExpressionRaw(methodReferenceExpression: JKMethodReferenceExpression) = visitExpressionRaw(methodReferenceExpression)
 
     override fun visitExpressionStatement(expressionStatement: JKExpressionStatement) {
         printLeftNonCodeElements(expressionStatement)
@@ -297,7 +292,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(expressionStatement)
     }
 
-    fun visitExpressionStatementRaw(expressionStatement: JKExpressionStatement) = visitStatementRaw(expressionStatement)
+    open fun visitExpressionStatementRaw(expressionStatement: JKExpressionStatement) = visitStatementRaw(expressionStatement)
 
     override fun visitDeclarationStatement(declarationStatement: JKDeclarationStatement) {
         printLeftNonCodeElements(declarationStatement)
@@ -305,7 +300,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(declarationStatement)
     }
 
-    fun visitDeclarationStatementRaw(declarationStatement: JKDeclarationStatement) = visitStatementRaw(declarationStatement)
+    open fun visitDeclarationStatementRaw(declarationStatement: JKDeclarationStatement) = visitStatementRaw(declarationStatement)
 
     override fun visitOperatorExpression(operatorExpression: JKOperatorExpression) {
         printLeftNonCodeElements(operatorExpression)
@@ -313,7 +308,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(operatorExpression)
     }
 
-    fun visitOperatorExpressionRaw(operatorExpression: JKOperatorExpression) = visitExpressionRaw(operatorExpression)
+    open fun visitOperatorExpressionRaw(operatorExpression: JKOperatorExpression) = visitExpressionRaw(operatorExpression)
 
     override fun visitBinaryExpression(binaryExpression: JKBinaryExpression) {
         printLeftNonCodeElements(binaryExpression)
@@ -321,7 +316,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(binaryExpression)
     }
 
-    fun visitBinaryExpressionRaw(binaryExpression: JKBinaryExpression) = visitOperatorExpressionRaw(binaryExpression)
+    open fun visitBinaryExpressionRaw(binaryExpression: JKBinaryExpression) = visitOperatorExpressionRaw(binaryExpression)
 
     override fun visitUnaryExpression(unaryExpression: JKUnaryExpression) {
         printLeftNonCodeElements(unaryExpression)
@@ -329,7 +324,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(unaryExpression)
     }
 
-    fun visitUnaryExpressionRaw(unaryExpression: JKUnaryExpression) = visitOperatorExpressionRaw(unaryExpression)
+    open fun visitUnaryExpressionRaw(unaryExpression: JKUnaryExpression) = visitOperatorExpressionRaw(unaryExpression)
 
     override fun visitPrefixExpression(prefixExpression: JKPrefixExpression) {
         printLeftNonCodeElements(prefixExpression)
@@ -337,7 +332,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(prefixExpression)
     }
 
-    fun visitPrefixExpressionRaw(prefixExpression: JKPrefixExpression) = visitUnaryExpressionRaw(prefixExpression)
+    open fun visitPrefixExpressionRaw(prefixExpression: JKPrefixExpression) = visitUnaryExpressionRaw(prefixExpression)
 
     override fun visitPostfixExpression(postfixExpression: JKPostfixExpression) {
         printLeftNonCodeElements(postfixExpression)
@@ -345,7 +340,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(postfixExpression)
     }
 
-    fun visitPostfixExpressionRaw(postfixExpression: JKPostfixExpression) = visitUnaryExpressionRaw(postfixExpression)
+    open fun visitPostfixExpressionRaw(postfixExpression: JKPostfixExpression) = visitUnaryExpressionRaw(postfixExpression)
 
     override fun visitQualifiedExpression(qualifiedExpression: JKQualifiedExpression) {
         printLeftNonCodeElements(qualifiedExpression)
@@ -353,7 +348,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(qualifiedExpression)
     }
 
-    fun visitQualifiedExpressionRaw(qualifiedExpression: JKQualifiedExpression) = visitExpressionRaw(qualifiedExpression)
+    open fun visitQualifiedExpressionRaw(qualifiedExpression: JKQualifiedExpression) = visitExpressionRaw(qualifiedExpression)
 
     override fun visitTypeArgumentList(typeArgumentList: JKTypeArgumentList) {
         printLeftNonCodeElements(typeArgumentList)
@@ -361,7 +356,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(typeArgumentList)
     }
 
-    fun visitTypeArgumentListRaw(typeArgumentList: JKTypeArgumentList) = visitTreeElementRaw(typeArgumentList)
+    open fun visitTypeArgumentListRaw(typeArgumentList: JKTypeArgumentList) = visitTreeElementRaw(typeArgumentList)
 
     override fun visitTypeArgumentListOwner(typeArgumentListOwner: JKTypeArgumentListOwner) {
         printLeftNonCodeElements(typeArgumentListOwner)
@@ -369,7 +364,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(typeArgumentListOwner)
     }
 
-    fun visitTypeArgumentListOwnerRaw(typeArgumentListOwner: JKTypeArgumentListOwner) = visitTreeElementRaw(typeArgumentListOwner)
+    open fun visitTypeArgumentListOwnerRaw(typeArgumentListOwner: JKTypeArgumentListOwner) = visitTreeElementRaw(typeArgumentListOwner)
 
     override fun visitMethodCallExpression(methodCallExpression: JKMethodCallExpression) {
         printLeftNonCodeElements(methodCallExpression)
@@ -377,7 +372,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(methodCallExpression)
     }
 
-    fun visitMethodCallExpressionRaw(methodCallExpression: JKMethodCallExpression) = visitExpressionRaw(methodCallExpression)
+    open fun visitMethodCallExpressionRaw(methodCallExpression: JKMethodCallExpression) = visitExpressionRaw(methodCallExpression)
 
     override fun visitFieldAccessExpression(fieldAccessExpression: JKFieldAccessExpression) {
         printLeftNonCodeElements(fieldAccessExpression)
@@ -385,7 +380,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(fieldAccessExpression)
     }
 
-    fun visitFieldAccessExpressionRaw(fieldAccessExpression: JKFieldAccessExpression) = visitAssignableExpressionRaw(fieldAccessExpression)
+    open fun visitFieldAccessExpressionRaw(fieldAccessExpression: JKFieldAccessExpression) = visitAssignableExpressionRaw(fieldAccessExpression)
 
     override fun visitPackageAccessExpression(packageAccessExpression: JKPackageAccessExpression) {
         printLeftNonCodeElements(packageAccessExpression)
@@ -393,8 +388,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(packageAccessExpression)
     }
 
-    fun visitPackageAccessExpressionRaw(packageAccessExpression: JKPackageAccessExpression) =
-        visitAssignableExpressionRaw(packageAccessExpression)
+    open fun visitPackageAccessExpressionRaw(packageAccessExpression: JKPackageAccessExpression) = visitAssignableExpressionRaw(packageAccessExpression)
 
     override fun visitClassAccessExpression(classAccessExpression: JKClassAccessExpression) {
         printLeftNonCodeElements(classAccessExpression)
@@ -402,7 +396,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(classAccessExpression)
     }
 
-    fun visitClassAccessExpressionRaw(classAccessExpression: JKClassAccessExpression) = visitExpressionRaw(classAccessExpression)
+    open fun visitClassAccessExpressionRaw(classAccessExpression: JKClassAccessExpression) = visitExpressionRaw(classAccessExpression)
 
     override fun visitArrayAccessExpression(arrayAccessExpression: JKArrayAccessExpression) {
         printLeftNonCodeElements(arrayAccessExpression)
@@ -410,7 +404,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(arrayAccessExpression)
     }
 
-    fun visitArrayAccessExpressionRaw(arrayAccessExpression: JKArrayAccessExpression) = visitAssignableExpressionRaw(arrayAccessExpression)
+    open fun visitArrayAccessExpressionRaw(arrayAccessExpression: JKArrayAccessExpression) = visitAssignableExpressionRaw(arrayAccessExpression)
 
     override fun visitParenthesizedExpression(parenthesizedExpression: JKParenthesizedExpression) {
         printLeftNonCodeElements(parenthesizedExpression)
@@ -418,7 +412,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(parenthesizedExpression)
     }
 
-    fun visitParenthesizedExpressionRaw(parenthesizedExpression: JKParenthesizedExpression) = visitExpressionRaw(parenthesizedExpression)
+    open fun visitParenthesizedExpressionRaw(parenthesizedExpression: JKParenthesizedExpression) = visitExpressionRaw(parenthesizedExpression)
 
     override fun visitTypeCastExpression(typeCastExpression: JKTypeCastExpression) {
         printLeftNonCodeElements(typeCastExpression)
@@ -426,7 +420,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(typeCastExpression)
     }
 
-    fun visitTypeCastExpressionRaw(typeCastExpression: JKTypeCastExpression) = visitExpressionRaw(typeCastExpression)
+    open fun visitTypeCastExpressionRaw(typeCastExpression: JKTypeCastExpression) = visitExpressionRaw(typeCastExpression)
 
     override fun visitExpressionList(expressionList: JKExpressionList) {
         printLeftNonCodeElements(expressionList)
@@ -434,7 +428,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(expressionList)
     }
 
-    fun visitExpressionListRaw(expressionList: JKExpressionList) = visitTreeElementRaw(expressionList)
+    open fun visitExpressionListRaw(expressionList: JKExpressionList) = visitTreeElementRaw(expressionList)
 
     override fun visitArgument(argument: JKArgument) {
         printLeftNonCodeElements(argument)
@@ -442,7 +436,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(argument)
     }
 
-    fun visitArgumentRaw(argument: JKArgument) = visitTreeElementRaw(argument)
+    open fun visitArgumentRaw(argument: JKArgument) = visitTreeElementRaw(argument)
 
     override fun visitNamedArgument(namedArgument: JKNamedArgument) {
         printLeftNonCodeElements(namedArgument)
@@ -450,7 +444,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(namedArgument)
     }
 
-    fun visitNamedArgumentRaw(namedArgument: JKNamedArgument) = visitArgumentRaw(namedArgument)
+    open fun visitNamedArgumentRaw(namedArgument: JKNamedArgument) = visitArgumentRaw(namedArgument)
 
     override fun visitArgumentList(argumentList: JKArgumentList) {
         printLeftNonCodeElements(argumentList)
@@ -458,7 +452,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(argumentList)
     }
 
-    fun visitArgumentListRaw(argumentList: JKArgumentList) = visitTreeElementRaw(argumentList)
+    open fun visitArgumentListRaw(argumentList: JKArgumentList) = visitTreeElementRaw(argumentList)
 
     override fun visitLiteralExpression(literalExpression: JKLiteralExpression) {
         printLeftNonCodeElements(literalExpression)
@@ -466,7 +460,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(literalExpression)
     }
 
-    fun visitLiteralExpressionRaw(literalExpression: JKLiteralExpression) = visitExpressionRaw(literalExpression)
+    open fun visitLiteralExpressionRaw(literalExpression: JKLiteralExpression) = visitExpressionRaw(literalExpression)
 
     override fun visitParameter(parameter: JKParameter) {
         printLeftNonCodeElements(parameter)
@@ -474,7 +468,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(parameter)
     }
 
-    fun visitParameterRaw(parameter: JKParameter) = visitVariableRaw(parameter)
+    open fun visitParameterRaw(parameter: JKParameter) = visitVariableRaw(parameter)
 
     override fun visitStringLiteralExpression(stringLiteralExpression: JKStringLiteralExpression) {
         printLeftNonCodeElements(stringLiteralExpression)
@@ -482,8 +476,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(stringLiteralExpression)
     }
 
-    fun visitStringLiteralExpressionRaw(stringLiteralExpression: JKStringLiteralExpression) =
-        visitLiteralExpressionRaw(stringLiteralExpression)
+    open fun visitStringLiteralExpressionRaw(stringLiteralExpression: JKStringLiteralExpression) = visitLiteralExpressionRaw(stringLiteralExpression)
 
     override fun visitStubExpression(stubExpression: JKStubExpression) {
         printLeftNonCodeElements(stubExpression)
@@ -491,7 +484,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(stubExpression)
     }
 
-    fun visitStubExpressionRaw(stubExpression: JKStubExpression) = visitExpressionRaw(stubExpression)
+    open fun visitStubExpressionRaw(stubExpression: JKStubExpression) = visitExpressionRaw(stubExpression)
 
     override fun visitLoopStatement(loopStatement: JKLoopStatement) {
         printLeftNonCodeElements(loopStatement)
@@ -499,7 +492,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(loopStatement)
     }
 
-    fun visitLoopStatementRaw(loopStatement: JKLoopStatement) = visitStatementRaw(loopStatement)
+    open fun visitLoopStatementRaw(loopStatement: JKLoopStatement) = visitStatementRaw(loopStatement)
 
     override fun visitBlockStatement(blockStatement: JKBlockStatement) {
         printLeftNonCodeElements(blockStatement)
@@ -507,7 +500,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(blockStatement)
     }
 
-    fun visitBlockStatementRaw(blockStatement: JKBlockStatement) = visitStatementRaw(blockStatement)
+    open fun visitBlockStatementRaw(blockStatement: JKBlockStatement) = visitStatementRaw(blockStatement)
 
     override fun visitBlockStatementWithoutBrackets(blockStatementWithoutBrackets: JKBlockStatementWithoutBrackets) {
         printLeftNonCodeElements(blockStatementWithoutBrackets)
@@ -515,8 +508,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(blockStatementWithoutBrackets)
     }
 
-    fun visitBlockStatementWithoutBracketsRaw(blockStatementWithoutBrackets: JKBlockStatementWithoutBrackets) =
-        visitStatementRaw(blockStatementWithoutBrackets)
+    open fun visitBlockStatementWithoutBracketsRaw(blockStatementWithoutBrackets: JKBlockStatementWithoutBrackets) = visitStatementRaw(blockStatementWithoutBrackets)
 
     override fun visitThisExpression(thisExpression: JKThisExpression) {
         printLeftNonCodeElements(thisExpression)
@@ -524,7 +516,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(thisExpression)
     }
 
-    fun visitThisExpressionRaw(thisExpression: JKThisExpression) = visitExpressionRaw(thisExpression)
+    open fun visitThisExpressionRaw(thisExpression: JKThisExpression) = visitExpressionRaw(thisExpression)
 
     override fun visitSuperExpression(superExpression: JKSuperExpression) {
         printLeftNonCodeElements(superExpression)
@@ -532,7 +524,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(superExpression)
     }
 
-    fun visitSuperExpressionRaw(superExpression: JKSuperExpression) = visitExpressionRaw(superExpression)
+    open fun visitSuperExpressionRaw(superExpression: JKSuperExpression) = visitExpressionRaw(superExpression)
 
     override fun visitWhileStatement(whileStatement: JKWhileStatement) {
         printLeftNonCodeElements(whileStatement)
@@ -540,7 +532,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(whileStatement)
     }
 
-    fun visitWhileStatementRaw(whileStatement: JKWhileStatement) = visitLoopStatementRaw(whileStatement)
+    open fun visitWhileStatementRaw(whileStatement: JKWhileStatement) = visitLoopStatementRaw(whileStatement)
 
     override fun visitDoWhileStatement(doWhileStatement: JKDoWhileStatement) {
         printLeftNonCodeElements(doWhileStatement)
@@ -548,7 +540,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(doWhileStatement)
     }
 
-    fun visitDoWhileStatementRaw(doWhileStatement: JKDoWhileStatement) = visitLoopStatementRaw(doWhileStatement)
+    open fun visitDoWhileStatementRaw(doWhileStatement: JKDoWhileStatement) = visitLoopStatementRaw(doWhileStatement)
 
     override fun visitBreakStatement(breakStatement: JKBreakStatement) {
         printLeftNonCodeElements(breakStatement)
@@ -556,7 +548,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(breakStatement)
     }
 
-    fun visitBreakStatementRaw(breakStatement: JKBreakStatement) = visitStatementRaw(breakStatement)
+    open fun visitBreakStatementRaw(breakStatement: JKBreakStatement) = visitStatementRaw(breakStatement)
 
     override fun visitBreakWithLabelStatement(breakWithLabelStatement: JKBreakWithLabelStatement) {
         printLeftNonCodeElements(breakWithLabelStatement)
@@ -564,8 +556,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(breakWithLabelStatement)
     }
 
-    fun visitBreakWithLabelStatementRaw(breakWithLabelStatement: JKBreakWithLabelStatement) =
-        visitBreakStatementRaw(breakWithLabelStatement)
+    open fun visitBreakWithLabelStatementRaw(breakWithLabelStatement: JKBreakWithLabelStatement) = visitBreakStatementRaw(breakWithLabelStatement)
 
     override fun visitIfStatement(ifStatement: JKIfStatement) {
         printLeftNonCodeElements(ifStatement)
@@ -573,7 +564,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(ifStatement)
     }
 
-    fun visitIfStatementRaw(ifStatement: JKIfStatement) = visitStatementRaw(ifStatement)
+    open fun visitIfStatementRaw(ifStatement: JKIfStatement) = visitStatementRaw(ifStatement)
 
     override fun visitIfElseStatement(ifElseStatement: JKIfElseStatement) {
         printLeftNonCodeElements(ifElseStatement)
@@ -581,7 +572,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(ifElseStatement)
     }
 
-    fun visitIfElseStatementRaw(ifElseStatement: JKIfElseStatement) = visitIfStatementRaw(ifElseStatement)
+    open fun visitIfElseStatementRaw(ifElseStatement: JKIfElseStatement) = visitIfStatementRaw(ifElseStatement)
 
     override fun visitIfElseExpression(ifElseExpression: JKIfElseExpression) {
         printLeftNonCodeElements(ifElseExpression)
@@ -589,7 +580,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(ifElseExpression)
     }
 
-    fun visitIfElseExpressionRaw(ifElseExpression: JKIfElseExpression) = visitExpressionRaw(ifElseExpression)
+    open fun visitIfElseExpressionRaw(ifElseExpression: JKIfElseExpression) = visitExpressionRaw(ifElseExpression)
 
     override fun visitAssignableExpression(assignableExpression: JKAssignableExpression) {
         printLeftNonCodeElements(assignableExpression)
@@ -597,7 +588,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(assignableExpression)
     }
 
-    fun visitAssignableExpressionRaw(assignableExpression: JKAssignableExpression) = visitExpressionRaw(assignableExpression)
+    open fun visitAssignableExpressionRaw(assignableExpression: JKAssignableExpression) = visitExpressionRaw(assignableExpression)
 
     override fun visitLambdaExpression(lambdaExpression: JKLambdaExpression) {
         printLeftNonCodeElements(lambdaExpression)
@@ -605,7 +596,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(lambdaExpression)
     }
 
-    fun visitLambdaExpressionRaw(lambdaExpression: JKLambdaExpression) = visitExpressionRaw(lambdaExpression)
+    open fun visitLambdaExpressionRaw(lambdaExpression: JKLambdaExpression) = visitExpressionRaw(lambdaExpression)
 
     override fun visitDelegationConstructorCall(delegationConstructorCall: JKDelegationConstructorCall) {
         printLeftNonCodeElements(delegationConstructorCall)
@@ -613,8 +604,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(delegationConstructorCall)
     }
 
-    fun visitDelegationConstructorCallRaw(delegationConstructorCall: JKDelegationConstructorCall) =
-        visitMethodCallExpressionRaw(delegationConstructorCall)
+    open fun visitDelegationConstructorCallRaw(delegationConstructorCall: JKDelegationConstructorCall) = visitMethodCallExpressionRaw(delegationConstructorCall)
 
     override fun visitLabel(label: JKLabel) {
         printLeftNonCodeElements(label)
@@ -622,7 +612,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(label)
     }
 
-    fun visitLabelRaw(label: JKLabel) = visitTreeElementRaw(label)
+    open fun visitLabelRaw(label: JKLabel) = visitTreeElementRaw(label)
 
     override fun visitLabelEmpty(labelEmpty: JKLabelEmpty) {
         printLeftNonCodeElements(labelEmpty)
@@ -630,7 +620,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(labelEmpty)
     }
 
-    fun visitLabelEmptyRaw(labelEmpty: JKLabelEmpty) = visitLabelRaw(labelEmpty)
+    open fun visitLabelEmptyRaw(labelEmpty: JKLabelEmpty) = visitLabelRaw(labelEmpty)
 
     override fun visitLabelText(labelText: JKLabelText) {
         printLeftNonCodeElements(labelText)
@@ -638,7 +628,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(labelText)
     }
 
-    fun visitLabelTextRaw(labelText: JKLabelText) = visitLabelRaw(labelText)
+    open fun visitLabelTextRaw(labelText: JKLabelText) = visitLabelRaw(labelText)
 
     override fun visitContinueStatement(continueStatement: JKContinueStatement) {
         printLeftNonCodeElements(continueStatement)
@@ -646,7 +636,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(continueStatement)
     }
 
-    fun visitContinueStatementRaw(continueStatement: JKContinueStatement) = visitStatementRaw(continueStatement)
+    open fun visitContinueStatementRaw(continueStatement: JKContinueStatement) = visitStatementRaw(continueStatement)
 
     override fun visitLabeledStatement(labeledStatement: JKLabeledStatement) {
         printLeftNonCodeElements(labeledStatement)
@@ -654,7 +644,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(labeledStatement)
     }
 
-    fun visitLabeledStatementRaw(labeledStatement: JKLabeledStatement) = visitExpressionRaw(labeledStatement)
+    open fun visitLabeledStatementRaw(labeledStatement: JKLabeledStatement) = visitExpressionRaw(labeledStatement)
 
     override fun visitEmptyStatement(emptyStatement: JKEmptyStatement) {
         printLeftNonCodeElements(emptyStatement)
@@ -662,7 +652,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(emptyStatement)
     }
 
-    fun visitEmptyStatementRaw(emptyStatement: JKEmptyStatement) = visitStatementRaw(emptyStatement)
+    open fun visitEmptyStatementRaw(emptyStatement: JKEmptyStatement) = visitStatementRaw(emptyStatement)
 
     override fun visitTypeParameterList(typeParameterList: JKTypeParameterList) {
         printLeftNonCodeElements(typeParameterList)
@@ -670,7 +660,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(typeParameterList)
     }
 
-    fun visitTypeParameterListRaw(typeParameterList: JKTypeParameterList) = visitTreeElementRaw(typeParameterList)
+    open fun visitTypeParameterListRaw(typeParameterList: JKTypeParameterList) = visitTreeElementRaw(typeParameterList)
 
     override fun visitTypeParameter(typeParameter: JKTypeParameter) {
         printLeftNonCodeElements(typeParameter)
@@ -678,7 +668,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(typeParameter)
     }
 
-    fun visitTypeParameterRaw(typeParameter: JKTypeParameter) = visitTreeElementRaw(typeParameter)
+    open fun visitTypeParameterRaw(typeParameter: JKTypeParameter) = visitTreeElementRaw(typeParameter)
 
     override fun visitTypeParameterListOwner(typeParameterListOwner: JKTypeParameterListOwner) {
         printLeftNonCodeElements(typeParameterListOwner)
@@ -686,7 +676,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(typeParameterListOwner)
     }
 
-    fun visitTypeParameterListOwnerRaw(typeParameterListOwner: JKTypeParameterListOwner) = visitTreeElementRaw(typeParameterListOwner)
+    open fun visitTypeParameterListOwnerRaw(typeParameterListOwner: JKTypeParameterListOwner) = visitTreeElementRaw(typeParameterListOwner)
 
     override fun visitEnumConstant(enumConstant: JKEnumConstant) {
         printLeftNonCodeElements(enumConstant)
@@ -694,7 +684,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(enumConstant)
     }
 
-    fun visitEnumConstantRaw(enumConstant: JKEnumConstant) = visitVariableRaw(enumConstant)
+    open fun visitEnumConstantRaw(enumConstant: JKEnumConstant) = visitVariableRaw(enumConstant)
 
     override fun visitForInStatement(forInStatement: JKForInStatement) {
         printLeftNonCodeElements(forInStatement)
@@ -702,7 +692,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(forInStatement)
     }
 
-    fun visitForInStatementRaw(forInStatement: JKForInStatement) = visitStatementRaw(forInStatement)
+    open fun visitForInStatementRaw(forInStatement: JKForInStatement) = visitStatementRaw(forInStatement)
 
     override fun visitPackageDeclaration(packageDeclaration: JKPackageDeclaration) {
         printLeftNonCodeElements(packageDeclaration)
@@ -710,7 +700,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(packageDeclaration)
     }
 
-    fun visitPackageDeclarationRaw(packageDeclaration: JKPackageDeclaration) = visitDeclarationRaw(packageDeclaration)
+    open fun visitPackageDeclarationRaw(packageDeclaration: JKPackageDeclaration) = visitDeclarationRaw(packageDeclaration)
 
     override fun visitClassLiteralExpression(classLiteralExpression: JKClassLiteralExpression) {
         printLeftNonCodeElements(classLiteralExpression)
@@ -718,7 +708,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(classLiteralExpression)
     }
 
-    fun visitClassLiteralExpressionRaw(classLiteralExpression: JKClassLiteralExpression) = visitExpressionRaw(classLiteralExpression)
+    open fun visitClassLiteralExpressionRaw(classLiteralExpression: JKClassLiteralExpression) = visitExpressionRaw(classLiteralExpression)
 
     override fun visitAnnotationMemberValue(annotationMemberValue: JKAnnotationMemberValue) {
         printLeftNonCodeElements(annotationMemberValue)
@@ -726,7 +716,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(annotationMemberValue)
     }
 
-    fun visitAnnotationMemberValueRaw(annotationMemberValue: JKAnnotationMemberValue) = visitTreeElementRaw(annotationMemberValue)
+    open fun visitAnnotationMemberValueRaw(annotationMemberValue: JKAnnotationMemberValue) = visitTreeElementRaw(annotationMemberValue)
 
     override fun visitField(field: JKField) {
         printLeftNonCodeElements(field)
@@ -734,7 +724,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(field)
     }
 
-    fun visitFieldRaw(field: JKField) = visitVariableRaw(field)
+    open fun visitFieldRaw(field: JKField) = visitVariableRaw(field)
 
     override fun visitJavaField(javaField: JKJavaField) {
         printLeftNonCodeElements(javaField)
@@ -742,7 +732,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(javaField)
     }
 
-    fun visitJavaFieldRaw(javaField: JKJavaField) = visitFieldRaw(javaField)
+    open fun visitJavaFieldRaw(javaField: JKJavaField) = visitFieldRaw(javaField)
 
     override fun visitJavaMethod(javaMethod: JKJavaMethod) {
         printLeftNonCodeElements(javaMethod)
@@ -750,7 +740,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(javaMethod)
     }
 
-    fun visitJavaMethodRaw(javaMethod: JKJavaMethod) = visitMethodRaw(javaMethod)
+    open fun visitJavaMethodRaw(javaMethod: JKJavaMethod) = visitMethodRaw(javaMethod)
 
     override fun visitJavaMethodCallExpression(javaMethodCallExpression: JKJavaMethodCallExpression) {
         printLeftNonCodeElements(javaMethodCallExpression)
@@ -758,8 +748,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(javaMethodCallExpression)
     }
 
-    fun visitJavaMethodCallExpressionRaw(javaMethodCallExpression: JKJavaMethodCallExpression) =
-        visitMethodCallExpressionRaw(javaMethodCallExpression)
+    open fun visitJavaMethodCallExpressionRaw(javaMethodCallExpression: JKJavaMethodCallExpression) = visitMethodCallExpressionRaw(javaMethodCallExpression)
 
     override fun visitClassBody(classBody: JKClassBody) {
         printLeftNonCodeElements(classBody)
@@ -767,7 +756,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(classBody)
     }
 
-    fun visitClassBodyRaw(classBody: JKClassBody) = visitTreeElementRaw(classBody)
+    open fun visitClassBodyRaw(classBody: JKClassBody) = visitTreeElementRaw(classBody)
 
     override fun visitEmptyClassBody(emptyClassBody: JKEmptyClassBody) {
         printLeftNonCodeElements(emptyClassBody)
@@ -775,7 +764,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(emptyClassBody)
     }
 
-    fun visitEmptyClassBodyRaw(emptyClassBody: JKEmptyClassBody) = visitClassBodyRaw(emptyClassBody)
+    open fun visitEmptyClassBodyRaw(emptyClassBody: JKEmptyClassBody) = visitClassBodyRaw(emptyClassBody)
 
     override fun visitJavaNewExpression(javaNewExpression: JKJavaNewExpression) {
         printLeftNonCodeElements(javaNewExpression)
@@ -783,7 +772,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(javaNewExpression)
     }
 
-    fun visitJavaNewExpressionRaw(javaNewExpression: JKJavaNewExpression) = visitExpressionRaw(javaNewExpression)
+    open fun visitJavaNewExpressionRaw(javaNewExpression: JKJavaNewExpression) = visitExpressionRaw(javaNewExpression)
 
     override fun visitJavaDefaultNewExpression(javaDefaultNewExpression: JKJavaDefaultNewExpression) {
         printLeftNonCodeElements(javaDefaultNewExpression)
@@ -791,8 +780,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(javaDefaultNewExpression)
     }
 
-    fun visitJavaDefaultNewExpressionRaw(javaDefaultNewExpression: JKJavaDefaultNewExpression) =
-        visitExpressionRaw(javaDefaultNewExpression)
+    open fun visitJavaDefaultNewExpressionRaw(javaDefaultNewExpression: JKJavaDefaultNewExpression) = visitExpressionRaw(javaDefaultNewExpression)
 
     override fun visitJavaNewEmptyArray(javaNewEmptyArray: JKJavaNewEmptyArray) {
         printLeftNonCodeElements(javaNewEmptyArray)
@@ -800,7 +788,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(javaNewEmptyArray)
     }
 
-    fun visitJavaNewEmptyArrayRaw(javaNewEmptyArray: JKJavaNewEmptyArray) = visitExpressionRaw(javaNewEmptyArray)
+    open fun visitJavaNewEmptyArrayRaw(javaNewEmptyArray: JKJavaNewEmptyArray) = visitExpressionRaw(javaNewEmptyArray)
 
     override fun visitJavaNewArray(javaNewArray: JKJavaNewArray) {
         printLeftNonCodeElements(javaNewArray)
@@ -808,7 +796,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(javaNewArray)
     }
 
-    fun visitJavaNewArrayRaw(javaNewArray: JKJavaNewArray) = visitExpressionRaw(javaNewArray)
+    open fun visitJavaNewArrayRaw(javaNewArray: JKJavaNewArray) = visitExpressionRaw(javaNewArray)
 
     override fun visitJavaLiteralExpression(javaLiteralExpression: JKJavaLiteralExpression) {
         printLeftNonCodeElements(javaLiteralExpression)
@@ -816,7 +804,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(javaLiteralExpression)
     }
 
-    fun visitJavaLiteralExpressionRaw(javaLiteralExpression: JKJavaLiteralExpression) = visitLiteralExpressionRaw(javaLiteralExpression)
+    open fun visitJavaLiteralExpressionRaw(javaLiteralExpression: JKJavaLiteralExpression) = visitLiteralExpressionRaw(javaLiteralExpression)
 
     override fun visitReturnStatement(returnStatement: JKReturnStatement) {
         printLeftNonCodeElements(returnStatement)
@@ -824,7 +812,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(returnStatement)
     }
 
-    fun visitReturnStatementRaw(returnStatement: JKReturnStatement) = visitStatementRaw(returnStatement)
+    open fun visitReturnStatementRaw(returnStatement: JKReturnStatement) = visitStatementRaw(returnStatement)
 
     override fun visitJavaAssertStatement(javaAssertStatement: JKJavaAssertStatement) {
         printLeftNonCodeElements(javaAssertStatement)
@@ -832,7 +820,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(javaAssertStatement)
     }
 
-    fun visitJavaAssertStatementRaw(javaAssertStatement: JKJavaAssertStatement) = visitStatementRaw(javaAssertStatement)
+    open fun visitJavaAssertStatementRaw(javaAssertStatement: JKJavaAssertStatement) = visitStatementRaw(javaAssertStatement)
 
     override fun visitJavaForLoopStatement(javaForLoopStatement: JKJavaForLoopStatement) {
         printLeftNonCodeElements(javaForLoopStatement)
@@ -840,7 +828,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(javaForLoopStatement)
     }
 
-    fun visitJavaForLoopStatementRaw(javaForLoopStatement: JKJavaForLoopStatement) = visitLoopStatementRaw(javaForLoopStatement)
+    open fun visitJavaForLoopStatementRaw(javaForLoopStatement: JKJavaForLoopStatement) = visitLoopStatementRaw(javaForLoopStatement)
 
     override fun visitJavaPolyadicExpression(javaPolyadicExpression: JKJavaPolyadicExpression) {
         printLeftNonCodeElements(javaPolyadicExpression)
@@ -848,7 +836,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(javaPolyadicExpression)
     }
 
-    fun visitJavaPolyadicExpressionRaw(javaPolyadicExpression: JKJavaPolyadicExpression) = visitExpressionRaw(javaPolyadicExpression)
+    open fun visitJavaPolyadicExpressionRaw(javaPolyadicExpression: JKJavaPolyadicExpression) = visitExpressionRaw(javaPolyadicExpression)
 
     override fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression) {
         printLeftNonCodeElements(javaAssignmentExpression)
@@ -856,8 +844,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(javaAssignmentExpression)
     }
 
-    fun visitJavaAssignmentExpressionRaw(javaAssignmentExpression: JKJavaAssignmentExpression) =
-        visitExpressionRaw(javaAssignmentExpression)
+    open fun visitJavaAssignmentExpressionRaw(javaAssignmentExpression: JKJavaAssignmentExpression) = visitExpressionRaw(javaAssignmentExpression)
 
     override fun visitJavaThrowStatement(javaThrowStatement: JKJavaThrowStatement) {
         printLeftNonCodeElements(javaThrowStatement)
@@ -865,7 +852,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(javaThrowStatement)
     }
 
-    fun visitJavaThrowStatementRaw(javaThrowStatement: JKJavaThrowStatement) = visitStatementRaw(javaThrowStatement)
+    open fun visitJavaThrowStatementRaw(javaThrowStatement: JKJavaThrowStatement) = visitStatementRaw(javaThrowStatement)
 
     override fun visitJavaTryStatement(javaTryStatement: JKJavaTryStatement) {
         printLeftNonCodeElements(javaTryStatement)
@@ -873,7 +860,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(javaTryStatement)
     }
 
-    fun visitJavaTryStatementRaw(javaTryStatement: JKJavaTryStatement) = visitStatementRaw(javaTryStatement)
+    open fun visitJavaTryStatementRaw(javaTryStatement: JKJavaTryStatement) = visitStatementRaw(javaTryStatement)
 
     override fun visitJavaTryCatchSection(javaTryCatchSection: JKJavaTryCatchSection) {
         printLeftNonCodeElements(javaTryCatchSection)
@@ -881,7 +868,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(javaTryCatchSection)
     }
 
-    fun visitJavaTryCatchSectionRaw(javaTryCatchSection: JKJavaTryCatchSection) = visitTreeElementRaw(javaTryCatchSection)
+    open fun visitJavaTryCatchSectionRaw(javaTryCatchSection: JKJavaTryCatchSection) = visitTreeElementRaw(javaTryCatchSection)
 
     override fun visitJavaSwitchStatement(javaSwitchStatement: JKJavaSwitchStatement) {
         printLeftNonCodeElements(javaSwitchStatement)
@@ -889,7 +876,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(javaSwitchStatement)
     }
 
-    fun visitJavaSwitchStatementRaw(javaSwitchStatement: JKJavaSwitchStatement) = visitStatementRaw(javaSwitchStatement)
+    open fun visitJavaSwitchStatementRaw(javaSwitchStatement: JKJavaSwitchStatement) = visitStatementRaw(javaSwitchStatement)
 
     override fun visitJavaSwitchCase(javaSwitchCase: JKJavaSwitchCase) {
         printLeftNonCodeElements(javaSwitchCase)
@@ -897,7 +884,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(javaSwitchCase)
     }
 
-    fun visitJavaSwitchCaseRaw(javaSwitchCase: JKJavaSwitchCase) = visitTreeElementRaw(javaSwitchCase)
+    open fun visitJavaSwitchCaseRaw(javaSwitchCase: JKJavaSwitchCase) = visitTreeElementRaw(javaSwitchCase)
 
     override fun visitJavaDefaultSwitchCase(javaDefaultSwitchCase: JKJavaDefaultSwitchCase) {
         printLeftNonCodeElements(javaDefaultSwitchCase)
@@ -905,7 +892,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(javaDefaultSwitchCase)
     }
 
-    fun visitJavaDefaultSwitchCaseRaw(javaDefaultSwitchCase: JKJavaDefaultSwitchCase) = visitJavaSwitchCaseRaw(javaDefaultSwitchCase)
+    open fun visitJavaDefaultSwitchCaseRaw(javaDefaultSwitchCase: JKJavaDefaultSwitchCase) = visitJavaSwitchCaseRaw(javaDefaultSwitchCase)
 
     override fun visitJavaLabelSwitchCase(javaLabelSwitchCase: JKJavaLabelSwitchCase) {
         printLeftNonCodeElements(javaLabelSwitchCase)
@@ -913,7 +900,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(javaLabelSwitchCase)
     }
 
-    fun visitJavaLabelSwitchCaseRaw(javaLabelSwitchCase: JKJavaLabelSwitchCase) = visitJavaSwitchCaseRaw(javaLabelSwitchCase)
+    open fun visitJavaLabelSwitchCaseRaw(javaLabelSwitchCase: JKJavaLabelSwitchCase) = visitJavaSwitchCaseRaw(javaLabelSwitchCase)
 
     override fun visitJavaContinueStatement(javaContinueStatement: JKJavaContinueStatement) {
         printLeftNonCodeElements(javaContinueStatement)
@@ -921,7 +908,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(javaContinueStatement)
     }
 
-    fun visitJavaContinueStatementRaw(javaContinueStatement: JKJavaContinueStatement) = visitStatementRaw(javaContinueStatement)
+    open fun visitJavaContinueStatementRaw(javaContinueStatement: JKJavaContinueStatement) = visitStatementRaw(javaContinueStatement)
 
     override fun visitJavaSynchronizedStatement(javaSynchronizedStatement: JKJavaSynchronizedStatement) {
         printLeftNonCodeElements(javaSynchronizedStatement)
@@ -929,8 +916,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(javaSynchronizedStatement)
     }
 
-    fun visitJavaSynchronizedStatementRaw(javaSynchronizedStatement: JKJavaSynchronizedStatement) =
-        visitStatementRaw(javaSynchronizedStatement)
+    open fun visitJavaSynchronizedStatementRaw(javaSynchronizedStatement: JKJavaSynchronizedStatement) = visitStatementRaw(javaSynchronizedStatement)
 
     override fun visitJavaAnnotationMethod(javaAnnotationMethod: JKJavaAnnotationMethod) {
         printLeftNonCodeElements(javaAnnotationMethod)
@@ -938,7 +924,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(javaAnnotationMethod)
     }
 
-    fun visitJavaAnnotationMethodRaw(javaAnnotationMethod: JKJavaAnnotationMethod) = visitMethodRaw(javaAnnotationMethod)
+    open fun visitJavaAnnotationMethodRaw(javaAnnotationMethod: JKJavaAnnotationMethod) = visitMethodRaw(javaAnnotationMethod)
 
     override fun visitJavaStaticInitDeclaration(javaStaticInitDeclaration: JKJavaStaticInitDeclaration) {
         printLeftNonCodeElements(javaStaticInitDeclaration)
@@ -946,8 +932,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(javaStaticInitDeclaration)
     }
 
-    fun visitJavaStaticInitDeclarationRaw(javaStaticInitDeclaration: JKJavaStaticInitDeclaration) =
-        visitDeclarationRaw(javaStaticInitDeclaration)
+    open fun visitJavaStaticInitDeclarationRaw(javaStaticInitDeclaration: JKJavaStaticInitDeclaration) = visitDeclarationRaw(javaStaticInitDeclaration)
 
     override fun visitKtGetterOrSetter(ktGetterOrSetter: JKKtGetterOrSetter) {
         printLeftNonCodeElements(ktGetterOrSetter)
@@ -955,7 +940,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(ktGetterOrSetter)
     }
 
-    fun visitKtGetterOrSetterRaw(ktGetterOrSetter: JKKtGetterOrSetter) = visitTreeElementRaw(ktGetterOrSetter)
+    open fun visitKtGetterOrSetterRaw(ktGetterOrSetter: JKKtGetterOrSetter) = visitTreeElementRaw(ktGetterOrSetter)
 
     override fun visitKtEmptyGetterOrSetter(ktEmptyGetterOrSetter: JKKtEmptyGetterOrSetter) {
         printLeftNonCodeElements(ktEmptyGetterOrSetter)
@@ -963,7 +948,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(ktEmptyGetterOrSetter)
     }
 
-    fun visitKtEmptyGetterOrSetterRaw(ktEmptyGetterOrSetter: JKKtEmptyGetterOrSetter) = visitKtGetterOrSetterRaw(ktEmptyGetterOrSetter)
+    open fun visitKtEmptyGetterOrSetterRaw(ktEmptyGetterOrSetter: JKKtEmptyGetterOrSetter) = visitKtGetterOrSetterRaw(ktEmptyGetterOrSetter)
 
     override fun visitKtProperty(ktProperty: JKKtProperty) {
         printLeftNonCodeElements(ktProperty)
@@ -971,7 +956,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(ktProperty)
     }
 
-    fun visitKtPropertyRaw(ktProperty: JKKtProperty) = visitFieldRaw(ktProperty)
+    open fun visitKtPropertyRaw(ktProperty: JKKtProperty) = visitFieldRaw(ktProperty)
 
     override fun visitKtFunction(ktFunction: JKKtFunction) {
         printLeftNonCodeElements(ktFunction)
@@ -979,7 +964,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(ktFunction)
     }
 
-    fun visitKtFunctionRaw(ktFunction: JKKtFunction) = visitMethodRaw(ktFunction)
+    open fun visitKtFunctionRaw(ktFunction: JKKtFunction) = visitMethodRaw(ktFunction)
 
     override fun visitKtConstructor(ktConstructor: JKKtConstructor) {
         printLeftNonCodeElements(ktConstructor)
@@ -987,7 +972,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(ktConstructor)
     }
 
-    fun visitKtConstructorRaw(ktConstructor: JKKtConstructor) = visitMethodRaw(ktConstructor)
+    open fun visitKtConstructorRaw(ktConstructor: JKKtConstructor) = visitMethodRaw(ktConstructor)
 
     override fun visitKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor) {
         printLeftNonCodeElements(ktPrimaryConstructor)
@@ -995,7 +980,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(ktPrimaryConstructor)
     }
 
-    fun visitKtPrimaryConstructorRaw(ktPrimaryConstructor: JKKtPrimaryConstructor) = visitKtConstructorRaw(ktPrimaryConstructor)
+    open fun visitKtPrimaryConstructorRaw(ktPrimaryConstructor: JKKtPrimaryConstructor) = visitKtConstructorRaw(ktPrimaryConstructor)
 
     override fun visitKtAssignmentStatement(ktAssignmentStatement: JKKtAssignmentStatement) {
         printLeftNonCodeElements(ktAssignmentStatement)
@@ -1003,7 +988,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(ktAssignmentStatement)
     }
 
-    fun visitKtAssignmentStatementRaw(ktAssignmentStatement: JKKtAssignmentStatement) = visitStatementRaw(ktAssignmentStatement)
+    open fun visitKtAssignmentStatementRaw(ktAssignmentStatement: JKKtAssignmentStatement) = visitStatementRaw(ktAssignmentStatement)
 
     override fun visitKtCall(ktCall: JKKtCall) {
         printLeftNonCodeElements(ktCall)
@@ -1011,7 +996,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(ktCall)
     }
 
-    fun visitKtCallRaw(ktCall: JKKtCall) = visitMethodCallExpressionRaw(ktCall)
+    open fun visitKtCallRaw(ktCall: JKKtCall) = visitMethodCallExpressionRaw(ktCall)
 
     override fun visitKtMethodCallExpression(ktMethodCallExpression: JKKtMethodCallExpression) {
         printLeftNonCodeElements(ktMethodCallExpression)
@@ -1019,8 +1004,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(ktMethodCallExpression)
     }
 
-    fun visitKtMethodCallExpressionRaw(ktMethodCallExpression: JKKtMethodCallExpression) =
-        visitMethodCallExpressionRaw(ktMethodCallExpression)
+    open fun visitKtMethodCallExpressionRaw(ktMethodCallExpression: JKKtMethodCallExpression) = visitMethodCallExpressionRaw(ktMethodCallExpression)
 
     override fun visitKtAlsoCallExpression(ktAlsoCallExpression: JKKtAlsoCallExpression) {
         printLeftNonCodeElements(ktAlsoCallExpression)
@@ -1028,7 +1012,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(ktAlsoCallExpression)
     }
 
-    fun visitKtAlsoCallExpressionRaw(ktAlsoCallExpression: JKKtAlsoCallExpression) = visitKtMethodCallExpressionRaw(ktAlsoCallExpression)
+    open fun visitKtAlsoCallExpressionRaw(ktAlsoCallExpression: JKKtAlsoCallExpression) = visitKtMethodCallExpressionRaw(ktAlsoCallExpression)
 
     override fun visitKtLiteralExpression(ktLiteralExpression: JKKtLiteralExpression) {
         printLeftNonCodeElements(ktLiteralExpression)
@@ -1036,7 +1020,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(ktLiteralExpression)
     }
 
-    fun visitKtLiteralExpressionRaw(ktLiteralExpression: JKKtLiteralExpression) = visitLiteralExpressionRaw(ktLiteralExpression)
+    open fun visitKtLiteralExpressionRaw(ktLiteralExpression: JKKtLiteralExpression) = visitLiteralExpressionRaw(ktLiteralExpression)
 
     override fun visitKtWhenStatement(ktWhenStatement: JKKtWhenStatement) {
         printLeftNonCodeElements(ktWhenStatement)
@@ -1044,7 +1028,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(ktWhenStatement)
     }
 
-    fun visitKtWhenStatementRaw(ktWhenStatement: JKKtWhenStatement) = visitStatementRaw(ktWhenStatement)
+    open fun visitKtWhenStatementRaw(ktWhenStatement: JKKtWhenStatement) = visitStatementRaw(ktWhenStatement)
 
     override fun visitKtWhenCase(ktWhenCase: JKKtWhenCase) {
         printLeftNonCodeElements(ktWhenCase)
@@ -1052,7 +1036,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(ktWhenCase)
     }
 
-    fun visitKtWhenCaseRaw(ktWhenCase: JKKtWhenCase) = visitTreeElementRaw(ktWhenCase)
+    open fun visitKtWhenCaseRaw(ktWhenCase: JKKtWhenCase) = visitTreeElementRaw(ktWhenCase)
 
     override fun visitKtWhenLabel(ktWhenLabel: JKKtWhenLabel) {
         printLeftNonCodeElements(ktWhenLabel)
@@ -1060,7 +1044,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(ktWhenLabel)
     }
 
-    fun visitKtWhenLabelRaw(ktWhenLabel: JKKtWhenLabel) = visitTreeElementRaw(ktWhenLabel)
+    open fun visitKtWhenLabelRaw(ktWhenLabel: JKKtWhenLabel) = visitTreeElementRaw(ktWhenLabel)
 
     override fun visitKtElseWhenLabel(ktElseWhenLabel: JKKtElseWhenLabel) {
         printLeftNonCodeElements(ktElseWhenLabel)
@@ -1068,7 +1052,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(ktElseWhenLabel)
     }
 
-    fun visitKtElseWhenLabelRaw(ktElseWhenLabel: JKKtElseWhenLabel) = visitKtWhenLabelRaw(ktElseWhenLabel)
+    open fun visitKtElseWhenLabelRaw(ktElseWhenLabel: JKKtElseWhenLabel) = visitKtWhenLabelRaw(ktElseWhenLabel)
 
     override fun visitKtValueWhenLabel(ktValueWhenLabel: JKKtValueWhenLabel) {
         printLeftNonCodeElements(ktValueWhenLabel)
@@ -1076,7 +1060,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(ktValueWhenLabel)
     }
 
-    fun visitKtValueWhenLabelRaw(ktValueWhenLabel: JKKtValueWhenLabel) = visitKtWhenLabelRaw(ktValueWhenLabel)
+    open fun visitKtValueWhenLabelRaw(ktValueWhenLabel: JKKtValueWhenLabel) = visitKtWhenLabelRaw(ktValueWhenLabel)
 
     override fun visitKtIsExpression(ktIsExpression: JKKtIsExpression) {
         printLeftNonCodeElements(ktIsExpression)
@@ -1084,7 +1068,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(ktIsExpression)
     }
 
-    fun visitKtIsExpressionRaw(ktIsExpression: JKKtIsExpression) = visitExpressionRaw(ktIsExpression)
+    open fun visitKtIsExpressionRaw(ktIsExpression: JKKtIsExpression) = visitExpressionRaw(ktIsExpression)
 
     override fun visitKtInitDeclaration(ktInitDeclaration: JKKtInitDeclaration) {
         printLeftNonCodeElements(ktInitDeclaration)
@@ -1092,7 +1076,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(ktInitDeclaration)
     }
 
-    fun visitKtInitDeclarationRaw(ktInitDeclaration: JKKtInitDeclaration) = visitDeclarationRaw(ktInitDeclaration)
+    open fun visitKtInitDeclarationRaw(ktInitDeclaration: JKKtInitDeclaration) = visitDeclarationRaw(ktInitDeclaration)
 
     override fun visitKtConvertedFromForLoopSyntheticWhileStatement(ktConvertedFromForLoopSyntheticWhileStatement: JKKtConvertedFromForLoopSyntheticWhileStatement) {
         printLeftNonCodeElements(ktConvertedFromForLoopSyntheticWhileStatement)
@@ -1100,8 +1084,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(ktConvertedFromForLoopSyntheticWhileStatement)
     }
 
-    fun visitKtConvertedFromForLoopSyntheticWhileStatementRaw(ktConvertedFromForLoopSyntheticWhileStatement: JKKtConvertedFromForLoopSyntheticWhileStatement) =
-        visitStatementRaw(ktConvertedFromForLoopSyntheticWhileStatement)
+    open fun visitKtConvertedFromForLoopSyntheticWhileStatementRaw(ktConvertedFromForLoopSyntheticWhileStatement: JKKtConvertedFromForLoopSyntheticWhileStatement) = visitStatementRaw(ktConvertedFromForLoopSyntheticWhileStatement)
 
     override fun visitKtThrowExpression(ktThrowExpression: JKKtThrowExpression) {
         printLeftNonCodeElements(ktThrowExpression)
@@ -1109,7 +1092,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(ktThrowExpression)
     }
 
-    fun visitKtThrowExpressionRaw(ktThrowExpression: JKKtThrowExpression) = visitExpressionRaw(ktThrowExpression)
+    open fun visitKtThrowExpressionRaw(ktThrowExpression: JKKtThrowExpression) = visitExpressionRaw(ktThrowExpression)
 
     override fun visitKtTryExpression(ktTryExpression: JKKtTryExpression) {
         printLeftNonCodeElements(ktTryExpression)
@@ -1117,7 +1100,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(ktTryExpression)
     }
 
-    fun visitKtTryExpressionRaw(ktTryExpression: JKKtTryExpression) = visitExpressionRaw(ktTryExpression)
+    open fun visitKtTryExpressionRaw(ktTryExpression: JKKtTryExpression) = visitExpressionRaw(ktTryExpression)
 
     override fun visitKtTryCatchSection(ktTryCatchSection: JKKtTryCatchSection) {
         printLeftNonCodeElements(ktTryCatchSection)
@@ -1125,7 +1108,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(ktTryCatchSection)
     }
 
-    fun visitKtTryCatchSectionRaw(ktTryCatchSection: JKKtTryCatchSection) = visitTreeElementRaw(ktTryCatchSection)
+    open fun visitKtTryCatchSectionRaw(ktTryCatchSection: JKKtTryCatchSection) = visitTreeElementRaw(ktTryCatchSection)
 
     override fun visitKtAnnotationArrayInitializerExpression(ktAnnotationArrayInitializerExpression: JKKtAnnotationArrayInitializerExpression) {
         printLeftNonCodeElements(ktAnnotationArrayInitializerExpression)
@@ -1133,6 +1116,5 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
         printRightNonCodeElements(ktAnnotationArrayInitializerExpression)
     }
 
-    fun visitKtAnnotationArrayInitializerExpressionRaw(ktAnnotationArrayInitializerExpression: JKKtAnnotationArrayInitializerExpression) =
-        visitExpressionRaw(ktAnnotationArrayInitializerExpression)
+    open fun visitKtAnnotationArrayInitializerExpressionRaw(ktAnnotationArrayInitializerExpression: JKKtAnnotationArrayInitializerExpression) = visitExpressionRaw(ktAnnotationArrayInitializerExpression)
 }