New J2K, minor: reformat code, optimize imports

nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/postProcessing/inspectionLikePostProcessings.kt

@@ -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

nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/postProcessing/processings/inspeсtionLikeProcessings.kt

@@ -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

nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/postProcessing/utils.kt

@@ -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

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AssertStatementConversion.kt

@@ -5,8 +5,12 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.nj2k.*
+import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
-import org.jetbrains.kotlin.nj2k.tree.*
+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
 

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AssignmentAsExpressionToAlsoConversion.kt

@@ -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(
+                JKFieldAccessExpressionImpl(
-                        context.symbolProvider.provideUniverseSymbol(
+                    context.symbolProvider.provideUniverseSymbol(
-                            JKParameterImpl(JKTypeElementImpl(JKContextType), JKNameIdentifierImpl("it"))
+                        JKParameterImpl(JKTypeElementImpl(JKContextType), JKNameIdentifierImpl("it"))
-                        )
+                    )
-                    )//TODO introduce symbol
+                )//TODO introduce symbol
         }
 
         return recurse(

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AssignmentStatementOperatorConversion.kt

@@ -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.JKBinaryExpressionImpl
-import org.jetbrains.kotlin.nj2k.tree.impl.*
+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(
+                    JKBinaryExpressionImpl(
-                            element.field.copyTreeAndDetach(),
+                        element.field.copyTreeAndDetach(),
-                            expression,
+                        expression,
-                            this
+                        this
-                        )
+                    )
                 element.operator = JKJavaOperatorImpl.tokenToOperator[JavaTokenType.EQ]!!
             }
         return recurse(element)

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AssignmentStatementValCreationConversion.kt

@@ -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))
                             }
                         )
                     )

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/FunctionAsAnonymousObjectToLambdaConversion.kt

@@ -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())
 }

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/InterfaceWithFieldConversion.kt

@@ -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.*
 
 

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/JavaStandardMethodsConversion.kt

@@ -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.*
 

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/MainFunctionConversion.kt

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

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/MatchBasedConversion.kt

@@ -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 {
 

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/MoveInitBlocksToTheEndConversion.kt

@@ -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 {

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ThrowStatementConversion.kt

@@ -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

nj2k/src/org/jetbrains/kotlin/nj2k/expressions.kt

@@ -483,7 +483,6 @@ fun List<JKExpression>.toArgumentList(): JKArgumentList =
     JKArgumentListImpl(map { JKArgumentImpl(it) })
 
 
-
 fun JKExpression.asStatement(): JKExpressionStatement =
     JKExpressionStatementImpl(this)
 

nj2k/src/org/jetbrains/kotlin/nj2k/tree/DebugTreePrinter.kt

@@ -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
 

nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/jk.kt

@@ -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)

nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/k.kt

@@ -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)

nj2k/src/org/jetbrains/kotlin/nj2k/tree/markers.kt

@@ -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

nj2k/src/org/jetbrains/kotlin/nj2k/tree/types.kt

@@ -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)),

nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitor.kt

@@ -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 visitMutabilityModifierElement(mutabilityModifierElement: JKMutabilityModifierElement, data: D): R =
-    fun visitModalityModifierElement(modalityModifierElement: JKModalityModifierElement, data: D): R = visitModifierElement(modalityModifierElement, data)
+        visitModifierElement(mutabilityModifierElement, data)
-    fun visitVisibilityModifierElement(visibilityModifierElement: JKVisibilityModifierElement, data: D): R = visitModifierElement(visibilityModifierElement, data)
+
-    fun visitExtraModifierElement(extraModifierElement: JKExtraModifierElement, data: D): R = visitModifierElement(extraModifierElement, data)
+    fun visitModalityModifierElement(modalityModifierElement: JKModalityModifierElement, data: D): R =
-    fun visitExtraModifiersOwner(extraModifiersOwner: JKExtraModifiersOwner, data: D): R = visitModifiersListOwner(extraModifiersOwner, data)
+        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 visitFieldAccessExpression(fieldAccessExpression: JKFieldAccessExpression, data: D): R =
-    fun visitPackageAccessExpression(packageAccessExpression: JKPackageAccessExpression, data: D): R = visitAssignableExpression(packageAccessExpression, data)
+        visitAssignableExpression(fieldAccessExpression, data)
-    fun visitClassAccessExpression(classAccessExpression: JKClassAccessExpression, data: D): R = visitExpression(classAccessExpression, data)
+
-    fun visitArrayAccessExpression(arrayAccessExpression: JKArrayAccessExpression, data: D): R = visitAssignableExpression(arrayAccessExpression, data)
+    fun visitPackageAccessExpression(packageAccessExpression: JKPackageAccessExpression, data: D): R =
-    fun visitParenthesizedExpression(parenthesizedExpression: JKParenthesizedExpression, data: D): R = visitExpression(parenthesizedExpression, data)
+        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 visitClassLiteralExpression(classLiteralExpression: JKClassLiteralExpression, data: D): R =
-    fun visitAnnotationMemberValue(annotationMemberValue: JKAnnotationMemberValue, data: D): R = visitTreeElement(annotationMemberValue, data)
+        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 visitJavaPolyadicExpression(javaPolyadicExpression: JKJavaPolyadicExpression, data: D): R =
-    fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression, data: D): R = visitExpression(javaAssignmentExpression, data)
+        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 visitKtMethodCallExpression(ktMethodCallExpression: JKKtMethodCallExpression, data: D): R =
-    fun visitKtAlsoCallExpression(ktAlsoCallExpression: JKKtAlsoCallExpression, data: D): R = visitKtMethodCallExpression(ktAlsoCallExpression, data)
+        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)
 }

nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitorVoid.kt

@@ -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)
+    override fun visitAnnotationParameter(annotationParameter: JKAnnotationParameter, data: Nothing?) =
-    fun visitAnnotationNameParameter(annotationNameParameter: JKAnnotationNameParameter) = visitAnnotationParameter(annotationNameParameter, null)
+        visitAnnotationParameter(annotationParameter)
-    override fun visitAnnotationNameParameter(annotationNameParameter: JKAnnotationNameParameter, data: Nothing?) = visitAnnotationNameParameter(annotationNameParameter)
+
+    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)
+    fun visitMutabilityModifierElement(mutabilityModifierElement: JKMutabilityModifierElement) =
-    override fun visitMutabilityModifierElement(mutabilityModifierElement: JKMutabilityModifierElement, data: Nothing?) = visitMutabilityModifierElement(mutabilityModifierElement)
+        visitModifierElement(mutabilityModifierElement, null)
-    fun visitModalityModifierElement(modalityModifierElement: JKModalityModifierElement) = visitModifierElement(modalityModifierElement, null)
+
-    override fun visitModalityModifierElement(modalityModifierElement: JKModalityModifierElement, data: Nothing?) = visitModalityModifierElement(modalityModifierElement)
+    override fun visitMutabilityModifierElement(mutabilityModifierElement: JKMutabilityModifierElement, data: Nothing?) =
-    fun visitVisibilityModifierElement(visibilityModifierElement: JKVisibilityModifierElement) = visitModifierElement(visibilityModifierElement, null)
+        visitMutabilityModifierElement(mutabilityModifierElement)
-    override fun visitVisibilityModifierElement(visibilityModifierElement: JKVisibilityModifierElement, data: Nothing?) = visitVisibilityModifierElement(visibilityModifierElement)
+
+    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)
+    fun visitMethodReferenceExpression(methodReferenceExpression: JKMethodReferenceExpression) =
-    override fun visitMethodReferenceExpression(methodReferenceExpression: JKMethodReferenceExpression, data: Nothing?) = visitMethodReferenceExpression(methodReferenceExpression)
+        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)
+    override fun visitFieldAccessExpression(fieldAccessExpression: JKFieldAccessExpression, data: Nothing?) =
-    fun visitPackageAccessExpression(packageAccessExpression: JKPackageAccessExpression) = visitAssignableExpression(packageAccessExpression, null)
+        visitFieldAccessExpression(fieldAccessExpression)
-    override fun visitPackageAccessExpression(packageAccessExpression: JKPackageAccessExpression, data: Nothing?) = visitPackageAccessExpression(packageAccessExpression)
+
+    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)
+    fun visitStringLiteralExpression(stringLiteralExpression: JKStringLiteralExpression) =
-    override fun visitStringLiteralExpression(stringLiteralExpression: JKStringLiteralExpression, data: Nothing?) = visitStringLiteralExpression(stringLiteralExpression)
+        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)
+    fun visitBlockStatementWithoutBrackets(blockStatementWithoutBrackets: JKBlockStatementWithoutBrackets) =
-    override fun visitBlockStatementWithoutBrackets(blockStatementWithoutBrackets: JKBlockStatementWithoutBrackets, data: Nothing?) = visitBlockStatementWithoutBrackets(blockStatementWithoutBrackets)
+        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)
+    fun visitBreakWithLabelStatement(breakWithLabelStatement: JKBreakWithLabelStatement) =
-    override fun visitBreakWithLabelStatement(breakWithLabelStatement: JKBreakWithLabelStatement, data: Nothing?) = visitBreakWithLabelStatement(breakWithLabelStatement)
+        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)
+    fun visitDelegationConstructorCall(delegationConstructorCall: JKDelegationConstructorCall) =
-    override fun visitDelegationConstructorCall(delegationConstructorCall: JKDelegationConstructorCall, data: Nothing?) = visitDelegationConstructorCall(delegationConstructorCall)
+        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)
+    fun visitJavaMethodCallExpression(javaMethodCallExpression: JKJavaMethodCallExpression) =
-    override fun visitJavaMethodCallExpression(javaMethodCallExpression: JKJavaMethodCallExpression, data: Nothing?) = visitJavaMethodCallExpression(javaMethodCallExpression)
+        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)
+    fun visitJavaDefaultNewExpression(javaDefaultNewExpression: JKJavaDefaultNewExpression) =
-    override fun visitJavaDefaultNewExpression(javaDefaultNewExpression: JKJavaDefaultNewExpression, data: Nothing?) = visitJavaDefaultNewExpression(javaDefaultNewExpression)
+        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)
+    override fun visitJavaPolyadicExpression(javaPolyadicExpression: JKJavaPolyadicExpression, data: Nothing?) =
-    fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression) = visitExpression(javaAssignmentExpression, null)
+        visitJavaPolyadicExpression(javaPolyadicExpression)
-    override fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression, data: Nothing?) = visitJavaAssignmentExpression(javaAssignmentExpression)
+
+    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)
+    override fun visitJavaContinueStatement(javaContinueStatement: JKJavaContinueStatement, data: Nothing?) =
-    fun visitJavaSynchronizedStatement(javaSynchronizedStatement: JKJavaSynchronizedStatement) = visitStatement(javaSynchronizedStatement, null)
+        visitJavaContinueStatement(javaContinueStatement)
-    override fun visitJavaSynchronizedStatement(javaSynchronizedStatement: JKJavaSynchronizedStatement, data: Nothing?) = visitJavaSynchronizedStatement(javaSynchronizedStatement)
+
+    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)
+    override fun visitJavaAnnotationMethod(javaAnnotationMethod: JKJavaAnnotationMethod, data: Nothing?) =
-    fun visitJavaStaticInitDeclaration(javaStaticInitDeclaration: JKJavaStaticInitDeclaration) = visitDeclaration(javaStaticInitDeclaration, null)
+        visitJavaAnnotationMethod(javaAnnotationMethod)
-    override fun visitJavaStaticInitDeclaration(javaStaticInitDeclaration: JKJavaStaticInitDeclaration, data: Nothing?) = visitJavaStaticInitDeclaration(javaStaticInitDeclaration)
+
+    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)
+    fun visitKtMethodCallExpression(ktMethodCallExpression: JKKtMethodCallExpression) =
-    override fun visitKtMethodCallExpression(ktMethodCallExpression: JKKtMethodCallExpression, data: Nothing?) = visitKtMethodCallExpression(ktMethodCallExpression)
+        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)
+    fun visitKtConvertedFromForLoopSyntheticWhileStatement(ktConvertedFromForLoopSyntheticWhileStatement: JKKtConvertedFromForLoopSyntheticWhileStatement) =
-    override fun visitKtConvertedFromForLoopSyntheticWhileStatement(ktConvertedFromForLoopSyntheticWhileStatement: JKKtConvertedFromForLoopSyntheticWhileStatement, data: Nothing?) = visitKtConvertedFromForLoopSyntheticWhileStatement(ktConvertedFromForLoopSyntheticWhileStatement)
+        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)
+    fun visitKtAnnotationArrayInitializerExpression(ktAnnotationArrayInitializerExpression: JKKtAnnotationArrayInitializerExpression) =
-    override fun visitKtAnnotationArrayInitializerExpression(ktAnnotationArrayInitializerExpression: JKKtAnnotationArrayInitializerExpression, data: Nothing?) = visitKtAnnotationArrayInitializerExpression(ktAnnotationArrayInitializerExpression)
+        visitExpression(ktAnnotationArrayInitializerExpression, null)
+
+    override fun visitKtAnnotationArrayInitializerExpression(
+        ktAnnotationArrayInitializerExpression: JKKtAnnotationArrayInitializerExpression,
+        data: Nothing?
+    ) = visitKtAnnotationArrayInitializerExpression(ktAnnotationArrayInitializerExpression)
 }

nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitorWithCommentsPrinting.kt

@@ -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)
 }

nj2k/src/org/jetbrains/kotlin/nj2k/utils.kt

@@ -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()