New J2K, minor: reformat code, optimize imports

2019-06-11 17:52:50 +03:00
parent 59f66d5882
commit b80f2c78a0
24 changed files with 400 additions and 171 deletions
@@ -13,27 +13,19 @@ import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiRecursiveElementVisitor
 import kotlinx.coroutines.withContext
-import org.jetbrains.kotlin.diagnostics.Diagnostic
-import org.jetbrains.kotlin.diagnostics.DiagnosticFactory
-import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.core.util.EDT
-import org.jetbrains.kotlin.idea.core.util.range
 import org.jetbrains.kotlin.idea.inspections.AbstractApplicabilityBasedInspection
 import org.jetbrains.kotlin.idea.inspections.AbstractKotlinInspection
 import org.jetbrains.kotlin.idea.intentions.SelfTargetingIntention
 import org.jetbrains.kotlin.idea.intentions.SelfTargetingRangeIntention
-import org.jetbrains.kotlin.idea.quickfix.KotlinIntentionActionsFactory
 import org.jetbrains.kotlin.idea.quickfix.QuickFixActionBase
 import org.jetbrains.kotlin.idea.util.application.runReadAction
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
 import org.jetbrains.kotlin.j2k.ConverterSettings
 import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
-import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.psi.psiUtil.elementsInRange
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
-import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
 import org.jetbrains.kotlin.utils.mapToIndex
 import java.util.*
 import kotlin.reflect.KClass
@@ -40,7 +40,6 @@ import org.jetbrains.kotlin.nj2k.postProcessing.resolve
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.*
 import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.calls.callUtil.getType
 import org.jetbrains.kotlin.types.isNullable
 import org.jetbrains.kotlin.types.typeUtil.makeNotNullable
 import org.jetbrains.kotlin.utils.addToStdlib.cast
@@ -10,10 +10,8 @@ import com.intellij.psi.search.LocalSearchScope
 import com.intellij.psi.search.searches.ReferencesSearch
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptorIfAny
-import org.jetbrains.kotlin.idea.formatter.commitAndUnblockDocument
 import org.jetbrains.kotlin.idea.references.KtSimpleNameReference
 import org.jetbrains.kotlin.idea.references.mainReference
-import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.collectDescendantsOfType
 import org.jetbrains.kotlin.psi.psiUtil.isAncestor
@@ -5,8 +5,12 @@

 package org.jetbrains.kotlin.nj2k.conversions

-import org.jetbrains.kotlin.nj2k.*
-import org.jetbrains.kotlin.nj2k.tree.*
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
+import org.jetbrains.kotlin.nj2k.kotlinAssert
+import org.jetbrains.kotlin.nj2k.tree.JKJavaAssertStatement
+import org.jetbrains.kotlin.nj2k.tree.JKStubExpression
+import org.jetbrains.kotlin.nj2k.tree.JKTreeElement
+import org.jetbrains.kotlin.nj2k.tree.detached
 import org.jetbrains.kotlin.nj2k.tree.impl.JKExpressionStatementImpl
 import org.jetbrains.kotlin.nj2k.tree.impl.JKLambdaExpressionImpl

@@ -24,11 +24,11 @@ class AssignmentAsExpressionToAlsoConversion(val context: NewJ2kConverterContext
            ), context.symbolProvider.provideMethodSymbol("kotlin.also")
        ).also {
            it.statement.cast<JKBlockStatement>().block.statements.first().cast<JKKtAssignmentStatement>().expression =
-                    JKFieldAccessExpressionImpl(
-                        context.symbolProvider.provideUniverseSymbol(
-                            JKParameterImpl(JKTypeElementImpl(JKContextType), JKNameIdentifierImpl("it"))
-                        )
-                    )//TODO introduce symbol
+                JKFieldAccessExpressionImpl(
+                    context.symbolProvider.provideUniverseSymbol(
+                        JKParameterImpl(JKTypeElementImpl(JKContextType), JKNameIdentifierImpl("it"))
+                    )
+                )//TODO introduce symbol
        }

        return recurse(
@@ -9,8 +9,9 @@ import com.intellij.psi.JavaTokenType
 import org.jetbrains.kotlin.nj2k.copyTreeAndDetach
 import org.jetbrains.kotlin.nj2k.tree.JKKtAssignmentStatement
 import org.jetbrains.kotlin.nj2k.tree.JKTreeElement
-import org.jetbrains.kotlin.nj2k.tree.detached
-import org.jetbrains.kotlin.nj2k.tree.impl.*
+import org.jetbrains.kotlin.nj2k.tree.impl.JKBinaryExpressionImpl
+import org.jetbrains.kotlin.nj2k.tree.impl.JKJavaOperatorImpl
+import org.jetbrains.kotlin.nj2k.tree.impl.JKJavaOperatorToken

 class AssignmentStatementOperatorConversion : RecursiveApplicableConversionBase() {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
@@ -20,11 +21,11 @@ class AssignmentStatementOperatorConversion : RecursiveApplicableConversionBase(
            ?.apply {
                val expression = element.expression.copyTreeAndDetach()
                element.expression =
-                        JKBinaryExpressionImpl(
-                            element.field.copyTreeAndDetach(),
-                            expression,
-                            this
-                        )
+                    JKBinaryExpressionImpl(
+                        element.field.copyTreeAndDetach(),
+                        expression,
+                        this
+                    )
                element.operator = JKJavaOperatorImpl.tokenToOperator[JavaTokenType.EQ]!!
            }
        return recurse(element)
@@ -37,7 +37,7 @@ class AssignmentStatementValCreationConversion(val context: NewJ2kConverterConte
                                JKMutabilityModifierElementImpl(Mutability.UNKNOWN)
                            ).also {
                                assignableExpr.indexExpression =
-                                        JKFieldAccessExpressionImpl(context.symbolProvider.provideUniverseSymbol(it))
+                                    JKFieldAccessExpressionImpl(context.symbolProvider.provideUniverseSymbol(it))
                            }
                        )
                    )
@@ -33,5 +33,5 @@ class FunctionAsAnonymousObjectToLambdaConversion : RecursiveApplicableConversio

    private fun JKClassSymbol.isKtFunction() =
        fqName.matches("""kotlin\.Function(\d+)""".toRegex())
-                ||  fqName.matches("""kotlin\.jvm\.functions\.Function(\d+)""".toRegex())
+                || fqName.matches("""kotlin\.jvm\.functions\.Function(\d+)""".toRegex())
 }
@@ -5,7 +5,7 @@

 package org.jetbrains.kotlin.nj2k.conversions

-import org.jetbrains.kotlin.nj2k.*
+import org.jetbrains.kotlin.nj2k.getOrCreateCompainonObject
 import org.jetbrains.kotlin.nj2k.tree.*


@@ -7,8 +7,8 @@ package org.jetbrains.kotlin.nj2k.conversions

 import com.intellij.psi.PsiMethod
 import org.jetbrains.kotlin.idea.refactoring.fqName.getKotlinFqName
-import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.j2k.ast.Nullability
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*

@@ -29,10 +29,10 @@ class MainFunctionConversion(private val context: NewJ2kConverterContext) : Recu
                type = JKTypeElementImpl(newType)
            }
            element.annotationList.annotations +=
-                    JKAnnotationImpl(
-                        context.symbolProvider.provideClassSymbol("kotlin.jvm.JvmStatic"),
-                        emptyList()
-                    )
+                JKAnnotationImpl(
+                    context.symbolProvider.provideClassSymbol("kotlin.jvm.JvmStatic"),
+                    emptyList()
+                )
        }
        return recurse(element)
    }
@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.nj2k.conversions

 import org.jetbrains.kotlin.nj2k.tree.JKTreeElement
-import org.jetbrains.kotlin.nj2k.tree.impl.JKBranchElementBase

 abstract class MatchBasedConversion : SequentialBaseConversion {

@@ -5,7 +5,9 @@

 package org.jetbrains.kotlin.nj2k.conversions

-import org.jetbrains.kotlin.nj2k.tree.*
+import org.jetbrains.kotlin.nj2k.tree.JKClassBody
+import org.jetbrains.kotlin.nj2k.tree.JKKtInitDeclaration
+import org.jetbrains.kotlin.nj2k.tree.JKTreeElement

 class MoveInitBlocksToTheEndConversion : RecursiveApplicableConversionBase() {
    override fun applyToElement(element: JKTreeElement): JKTreeElement {
@@ -5,7 +5,6 @@

 package org.jetbrains.kotlin.nj2k.conversions

-import org.jetbrains.kotlin.nj2k.tree.JKExpressionStatement
 import org.jetbrains.kotlin.nj2k.tree.JKJavaThrowStatement
 import org.jetbrains.kotlin.nj2k.tree.JKTreeElement
 import org.jetbrains.kotlin.nj2k.tree.detached
@@ -483,7 +483,6 @@ fun List<JKExpression>.toArgumentList(): JKArgumentList =
    JKArgumentListImpl(map { JKArgumentImpl(it) })


-
 fun JKExpression.asStatement(): JKExpressionStatement =
    JKExpressionStatementImpl(this)

@@ -18,7 +18,6 @@ package org.jetbrains.kotlin.nj2k.tree

 import org.jetbrains.kotlin.nj2k.tree.impl.JKClassSymbol
 import org.jetbrains.kotlin.nj2k.tree.impl.JKSymbol
-import org.jetbrains.kotlin.nj2k.tree.impl.JKUniverseSymbol
 import org.jetbrains.kotlin.nj2k.tree.visitors.JKVisitorVoid
 import org.jetbrains.kotlin.utils.Printer

@@ -366,7 +366,8 @@ class JKIfStatementImpl(condition: JKExpression, thenBranch: JKStatement) : JKIf
    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitIfStatement(this, data)
 }

-class JKIfElseStatementImpl(condition: JKExpression, thenBranch: JKStatement, elseBranch: JKStatement) : JKIfElseStatement(), PsiOwner by PsiOwnerImpl() {
+class JKIfElseStatementImpl(condition: JKExpression, thenBranch: JKStatement, elseBranch: JKStatement) : JKIfElseStatement(),
+    PsiOwner by PsiOwnerImpl() {
    override var elseBranch by child(elseBranch)
    override var thenBranch by child(thenBranch)
    override var condition by child(condition)
@@ -429,6 +430,7 @@ class JKFieldAccessExpressionImpl(override var identifier: JKFieldSymbol) : JKFi
    PsiOwner by PsiOwnerImpl() {
    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitFieldAccessExpression(this, data)
 }
+
 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)
@@ -249,7 +249,8 @@ class JKKtValueWhenLabelImpl(expression: JKExpression) : JKKtValueWhenLabel, JKB
 }


-class JKKtIsExpressionImpl(expression: JKExpression, type: JKTypeElement) : JKKtIsExpression, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() {
+class JKKtIsExpressionImpl(expression: JKExpression, type: JKTypeElement) : JKKtIsExpression, JKBranchElementBase(),
+    PsiOwner by PsiOwnerImpl() {
    override var type by child(type)
    override var expression by child(expression)

@@ -281,7 +282,7 @@ class JKKtTryExpressionImpl(
    tryBlock: JKBlock,
    finallyBlock: JKBlock,
    catchSections: List<JKKtTryCatchSection>
-) : JKKtTryExpression, JKBranchElementBase(){
+) : JKKtTryExpression, JKBranchElementBase() {
    override var tryBlock: JKBlock by child(tryBlock)
    override var finallyBlock: JKBlock by child(finallyBlock)
    override var catchSections: List<JKKtTryCatchSection> by children(catchSections)
@@ -20,8 +20,8 @@ import org.jetbrains.kotlin.j2k.ast.Nullability
 import org.jetbrains.kotlin.nj2k.tree.impl.JKBranchElementBase
 import org.jetbrains.kotlin.nj2k.tree.impl.JKClassSymbol
 import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType
-import kotlin.reflect.KProperty0
 import kotlin.jvm.internal.CallableReference
+import kotlin.reflect.KProperty0

 interface JKOperator {
    val token: JKOperatorToken
@@ -134,7 +134,6 @@ fun JKType.isSubtypeOf(other: JKType, symbolProvider: JKSymbolProvider): Boolean
        ?.let { otherType -> this.toKtType(symbolProvider)?.isSubtypeOf(otherType) } == true


-
 fun KotlinType.toJK(symbolProvider: JKSymbolProvider): JKClassTypeImpl =
    JKClassTypeImpl(
        symbolProvider.provideClassSymbol(getJetTypeFqName(false)),
@@ -3,7 +3,7 @@ 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 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)
@@ -14,18 +14,30 @@ interface JKVisitor<out R, in D> {
    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 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(extraModifierElement: JKExtraModifierElement, data: D): R = visitModifierElement(extraModifierElement, data)
-    fun visitExtraModifiersOwner(extraModifiersOwner: JKExtraModifiersOwner, data: D): R = visitModifiersListOwner(extraModifiersOwner, 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(extraModifierElement: JKExtraModifierElement, data: D): R =
+        visitModifierElement(extraModifierElement, data)
+
+    fun visitExtraModifiersOwner(extraModifiersOwner: JKExtraModifiersOwner, data: D): R =
+        visitModifiersListOwner(extraModifiersOwner, 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)
@@ -37,7 +49,9 @@ interface JKVisitor<out R, in D> {
    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 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)
@@ -47,13 +61,25 @@ interface JKVisitor<out R, in D> {
    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 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 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)
@@ -61,23 +87,31 @@ interface JKVisitor<out R, in D> {
    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 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 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 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 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)
@@ -86,49 +120,77 @@ interface JKVisitor<out R, in D> {
    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 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 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 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 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 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 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 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 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 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 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 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)
@@ -137,9 +199,16 @@ interface JKVisitor<out R, in D> {
    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 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)
+    fun visitKtAnnotationArrayInitializerExpression(
+        ktAnnotationArrayInitializerExpression: JKKtAnnotationArrayInitializerExpression,
+        data: D
+    ): R = visitExpression(ktAnnotationArrayInitializerExpression, data)
 }
@@ -3,7 +3,7 @@ package org.jetbrains.kotlin.nj2k.tree.visitors
 import org.jetbrains.kotlin.nj2k.tree.*

 interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
-    fun visitTreeElement(treeElement: JKTreeElement) 
+    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)
@@ -24,11 +24,19 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
    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)
+    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)
+    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)
@@ -39,16 +47,32 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
    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 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(extraModifierElement: JKExtraModifierElement) = visitModifierElement(extraModifierElement, null)
-    override fun visitExtraModifierElement(extraModifierElement: JKExtraModifierElement, data: Nothing?) = visitExtraModifierElement(extraModifierElement)
+    override fun visitExtraModifierElement(extraModifierElement: JKExtraModifierElement, data: Nothing?) =
+        visitExtraModifierElement(extraModifierElement)
+
    fun visitExtraModifiersOwner(extraModifiersOwner: JKExtraModifiersOwner) = visitModifiersListOwner(extraModifiersOwner, null)
-    override fun visitExtraModifiersOwner(extraModifiersOwner: JKExtraModifiersOwner, data: Nothing?) = visitExtraModifiersOwner(extraModifiersOwner)
+    override fun visitExtraModifiersOwner(extraModifiersOwner: JKExtraModifiersOwner, data: Nothing?) =
+        visitExtraModifiersOwner(extraModifiersOwner)
+
    fun visitVisibilityOwner(visibilityOwner: JKVisibilityOwner) = visitModifiersListOwner(visibilityOwner, null)
    override fun visitVisibilityOwner(visibilityOwner: JKVisibilityOwner, data: Nothing?) = visitVisibilityOwner(visibilityOwner)
    fun visitModalityOwner(modalityOwner: JKModalityOwner) = visitModifiersListOwner(modalityOwner, null)
@@ -56,7 +80,9 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
    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)
+    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)
@@ -71,14 +97,24 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
    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 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)
+    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)
+    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)
+    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)
@@ -88,25 +124,45 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
@@ -119,16 +175,24 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
    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 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 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)
@@ -139,8 +203,12 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
    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 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)
@@ -148,11 +216,17 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
    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)
+    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 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)
@@ -170,75 +244,127 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
    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)
+    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)
+    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)
+    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)
+    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 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 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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
@@ -246,17 +372,29 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
    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)
+    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)
+    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 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)
+    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)
+    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)
@@ -271,14 +409,25 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
    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 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)
+    fun visitKtAnnotationArrayInitializerExpression(ktAnnotationArrayInitializerExpression: JKKtAnnotationArrayInitializerExpression) =
+        visitExpression(ktAnnotationArrayInitializerExpression, null)
+
+    override fun visitKtAnnotationArrayInitializerExpression(
+        ktAnnotationArrayInitializerExpression: JKKtAnnotationArrayInitializerExpression,
+        data: Nothing?
+    ) = visitKtAnnotationArrayInitializerExpression(ktAnnotationArrayInitializerExpression)
 }
@@ -12,7 +12,7 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
        printRightNonCodeElements(treeElement)
    }

-    fun visitTreeElementRaw(treeElement: JKTreeElement) 
+    fun visitTreeElementRaw(treeElement: JKTreeElement)

    override fun visitTreeRoot(treeRoot: JKTreeRoot) {
        printLeftNonCodeElements(treeRoot)
@@ -100,7 +100,8 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
        printRightNonCodeElements(annotationNameParameter)
    }

-    fun visitAnnotationNameParameterRaw(annotationNameParameter: JKAnnotationNameParameter) = visitAnnotationParameterRaw(annotationNameParameter)
+    fun visitAnnotationNameParameterRaw(annotationNameParameter: JKAnnotationNameParameter) =
+        visitAnnotationParameterRaw(annotationNameParameter)

    override fun visitAnnotationListOwner(annotationListOwner: JKAnnotationListOwner) {
        printLeftNonCodeElements(annotationListOwner)
@@ -156,7 +157,8 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
        printRightNonCodeElements(mutabilityModifierElement)
    }

-    fun visitMutabilityModifierElementRaw(mutabilityModifierElement: JKMutabilityModifierElement) = visitModifierElementRaw(mutabilityModifierElement)
+    fun visitMutabilityModifierElementRaw(mutabilityModifierElement: JKMutabilityModifierElement) =
+        visitModifierElementRaw(mutabilityModifierElement)

    override fun visitModalityModifierElement(modalityModifierElement: JKModalityModifierElement) {
        printLeftNonCodeElements(modalityModifierElement)
@@ -164,7 +166,8 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
        printRightNonCodeElements(modalityModifierElement)
    }

-    fun visitModalityModifierElementRaw(modalityModifierElement: JKModalityModifierElement) = visitModifierElementRaw(modalityModifierElement)
+    fun visitModalityModifierElementRaw(modalityModifierElement: JKModalityModifierElement) =
+        visitModifierElementRaw(modalityModifierElement)

    override fun visitVisibilityModifierElement(visibilityModifierElement: JKVisibilityModifierElement) {
        printLeftNonCodeElements(visibilityModifierElement)
@@ -172,7 +175,8 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
        printRightNonCodeElements(visibilityModifierElement)
    }

-    fun visitVisibilityModifierElementRaw(visibilityModifierElement: JKVisibilityModifierElement) = visitModifierElementRaw(visibilityModifierElement)
+    fun visitVisibilityModifierElementRaw(visibilityModifierElement: JKVisibilityModifierElement) =
+        visitModifierElementRaw(visibilityModifierElement)

    override fun visitExtraModifierElement(extraModifierElement: JKExtraModifierElement) {
        printLeftNonCodeElements(extraModifierElement)
@@ -284,7 +288,8 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
        printRightNonCodeElements(methodReferenceExpression)
    }

-    fun visitMethodReferenceExpressionRaw(methodReferenceExpression: JKMethodReferenceExpression) = visitExpressionRaw(methodReferenceExpression)
+    fun visitMethodReferenceExpressionRaw(methodReferenceExpression: JKMethodReferenceExpression) =
+        visitExpressionRaw(methodReferenceExpression)

    override fun visitExpressionStatement(expressionStatement: JKExpressionStatement) {
        printLeftNonCodeElements(expressionStatement)
@@ -388,7 +393,8 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
        printRightNonCodeElements(packageAccessExpression)
    }

-    fun visitPackageAccessExpressionRaw(packageAccessExpression: JKPackageAccessExpression) = visitAssignableExpressionRaw(packageAccessExpression)
+    fun visitPackageAccessExpressionRaw(packageAccessExpression: JKPackageAccessExpression) =
+        visitAssignableExpressionRaw(packageAccessExpression)

    override fun visitClassAccessExpression(classAccessExpression: JKClassAccessExpression) {
        printLeftNonCodeElements(classAccessExpression)
@@ -476,7 +482,8 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
        printRightNonCodeElements(stringLiteralExpression)
    }

-    fun visitStringLiteralExpressionRaw(stringLiteralExpression: JKStringLiteralExpression) = visitLiteralExpressionRaw(stringLiteralExpression)
+    fun visitStringLiteralExpressionRaw(stringLiteralExpression: JKStringLiteralExpression) =
+        visitLiteralExpressionRaw(stringLiteralExpression)

    override fun visitStubExpression(stubExpression: JKStubExpression) {
        printLeftNonCodeElements(stubExpression)
@@ -508,7 +515,8 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
        printRightNonCodeElements(blockStatementWithoutBrackets)
    }

-    fun visitBlockStatementWithoutBracketsRaw(blockStatementWithoutBrackets: JKBlockStatementWithoutBrackets) = visitStatementRaw(blockStatementWithoutBrackets)
+    fun visitBlockStatementWithoutBracketsRaw(blockStatementWithoutBrackets: JKBlockStatementWithoutBrackets) =
+        visitStatementRaw(blockStatementWithoutBrackets)

    override fun visitThisExpression(thisExpression: JKThisExpression) {
        printLeftNonCodeElements(thisExpression)
@@ -556,7 +564,8 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
        printRightNonCodeElements(breakWithLabelStatement)
    }

-    fun visitBreakWithLabelStatementRaw(breakWithLabelStatement: JKBreakWithLabelStatement) = visitBreakStatementRaw(breakWithLabelStatement)
+    fun visitBreakWithLabelStatementRaw(breakWithLabelStatement: JKBreakWithLabelStatement) =
+        visitBreakStatementRaw(breakWithLabelStatement)

    override fun visitIfStatement(ifStatement: JKIfStatement) {
        printLeftNonCodeElements(ifStatement)
@@ -604,7 +613,8 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
        printRightNonCodeElements(delegationConstructorCall)
    }

-    fun visitDelegationConstructorCallRaw(delegationConstructorCall: JKDelegationConstructorCall) = visitMethodCallExpressionRaw(delegationConstructorCall)
+    fun visitDelegationConstructorCallRaw(delegationConstructorCall: JKDelegationConstructorCall) =
+        visitMethodCallExpressionRaw(delegationConstructorCall)

    override fun visitLabel(label: JKLabel) {
        printLeftNonCodeElements(label)
@@ -748,7 +758,8 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
        printRightNonCodeElements(javaMethodCallExpression)
    }

-    fun visitJavaMethodCallExpressionRaw(javaMethodCallExpression: JKJavaMethodCallExpression) = visitMethodCallExpressionRaw(javaMethodCallExpression)
+    fun visitJavaMethodCallExpressionRaw(javaMethodCallExpression: JKJavaMethodCallExpression) =
+        visitMethodCallExpressionRaw(javaMethodCallExpression)

    override fun visitClassBody(classBody: JKClassBody) {
        printLeftNonCodeElements(classBody)
@@ -780,7 +791,8 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
        printRightNonCodeElements(javaDefaultNewExpression)
    }

-    fun visitJavaDefaultNewExpressionRaw(javaDefaultNewExpression: JKJavaDefaultNewExpression) = visitExpressionRaw(javaDefaultNewExpression)
+    fun visitJavaDefaultNewExpressionRaw(javaDefaultNewExpression: JKJavaDefaultNewExpression) =
+        visitExpressionRaw(javaDefaultNewExpression)

    override fun visitJavaNewEmptyArray(javaNewEmptyArray: JKJavaNewEmptyArray) {
        printLeftNonCodeElements(javaNewEmptyArray)
@@ -844,7 +856,8 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
        printRightNonCodeElements(javaAssignmentExpression)
    }

-    fun visitJavaAssignmentExpressionRaw(javaAssignmentExpression: JKJavaAssignmentExpression) = visitExpressionRaw(javaAssignmentExpression)
+    fun visitJavaAssignmentExpressionRaw(javaAssignmentExpression: JKJavaAssignmentExpression) =
+        visitExpressionRaw(javaAssignmentExpression)

    override fun visitJavaThrowStatement(javaThrowStatement: JKJavaThrowStatement) {
        printLeftNonCodeElements(javaThrowStatement)
@@ -916,7 +929,8 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
        printRightNonCodeElements(javaSynchronizedStatement)
    }

-    fun visitJavaSynchronizedStatementRaw(javaSynchronizedStatement: JKJavaSynchronizedStatement) = visitStatementRaw(javaSynchronizedStatement)
+    fun visitJavaSynchronizedStatementRaw(javaSynchronizedStatement: JKJavaSynchronizedStatement) =
+        visitStatementRaw(javaSynchronizedStatement)

    override fun visitJavaAnnotationMethod(javaAnnotationMethod: JKJavaAnnotationMethod) {
        printLeftNonCodeElements(javaAnnotationMethod)
@@ -932,7 +946,8 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
        printRightNonCodeElements(javaStaticInitDeclaration)
    }

-    fun visitJavaStaticInitDeclarationRaw(javaStaticInitDeclaration: JKJavaStaticInitDeclaration) = visitDeclarationRaw(javaStaticInitDeclaration)
+    fun visitJavaStaticInitDeclarationRaw(javaStaticInitDeclaration: JKJavaStaticInitDeclaration) =
+        visitDeclarationRaw(javaStaticInitDeclaration)

    override fun visitKtGetterOrSetter(ktGetterOrSetter: JKKtGetterOrSetter) {
        printLeftNonCodeElements(ktGetterOrSetter)
@@ -1004,7 +1019,8 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
        printRightNonCodeElements(ktMethodCallExpression)
    }

-    fun visitKtMethodCallExpressionRaw(ktMethodCallExpression: JKKtMethodCallExpression) = visitMethodCallExpressionRaw(ktMethodCallExpression)
+    fun visitKtMethodCallExpressionRaw(ktMethodCallExpression: JKKtMethodCallExpression) =
+        visitMethodCallExpressionRaw(ktMethodCallExpression)

    override fun visitKtAlsoCallExpression(ktAlsoCallExpression: JKKtAlsoCallExpression) {
        printLeftNonCodeElements(ktAlsoCallExpression)
@@ -1084,7 +1100,8 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
        printRightNonCodeElements(ktConvertedFromForLoopSyntheticWhileStatement)
    }

-    fun visitKtConvertedFromForLoopSyntheticWhileStatementRaw(ktConvertedFromForLoopSyntheticWhileStatement: JKKtConvertedFromForLoopSyntheticWhileStatement) = visitStatementRaw(ktConvertedFromForLoopSyntheticWhileStatement)
+    fun visitKtConvertedFromForLoopSyntheticWhileStatementRaw(ktConvertedFromForLoopSyntheticWhileStatement: JKKtConvertedFromForLoopSyntheticWhileStatement) =
+        visitStatementRaw(ktConvertedFromForLoopSyntheticWhileStatement)

    override fun visitKtThrowExpression(ktThrowExpression: JKKtThrowExpression) {
        printLeftNonCodeElements(ktThrowExpression)
@@ -1116,5 +1133,6 @@ interface JKVisitorWithCommentsPrinting : JKVisitorVoid {
        printRightNonCodeElements(ktAnnotationArrayInitializerExpression)
    }

-    fun visitKtAnnotationArrayInitializerExpressionRaw(ktAnnotationArrayInitializerExpression: JKKtAnnotationArrayInitializerExpression) = visitExpressionRaw(ktAnnotationArrayInitializerExpression)
+    fun visitKtAnnotationArrayInitializerExpressionRaw(ktAnnotationArrayInitializerExpression: JKKtAnnotationArrayInitializerExpression) =
+        visitExpressionRaw(ktAnnotationArrayInitializerExpression)
 }
@@ -11,7 +11,6 @@ import com.intellij.psi.util.parentsOfType
 import org.jetbrains.kotlin.lexer.KtKeywordToken
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.load.java.JvmAbi
-import org.jetbrains.kotlin.psi.KtFunction

 fun <T> List<T>.replace(element: T, replacer: T): List<T> {
    val mutableList = toMutableList()