[FIR/IR generator] Commonize visitor printing logic
diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt
index 3c1f787..82a5927 100644
--- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt
+++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt
@@ -5,162 +5,13 @@
 
 package org.jetbrains.kotlin.fir.visitors
 
-import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirAnnotationContainer
-import org.jetbrains.kotlin.fir.types.FirTypeRef
-import org.jetbrains.kotlin.fir.references.FirReference
-import org.jetbrains.kotlin.fir.FirLabel
-import org.jetbrains.kotlin.fir.expressions.FirResolvable
-import org.jetbrains.kotlin.fir.FirTargetElement
-import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
-import org.jetbrains.kotlin.fir.declarations.FirResolvedDeclarationStatus
-import org.jetbrains.kotlin.fir.declarations.FirControlFlowGraphOwner
-import org.jetbrains.kotlin.fir.expressions.FirStatement
-import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.expressions.FirLazyExpression
-import org.jetbrains.kotlin.fir.declarations.FirContextReceiver
-import org.jetbrains.kotlin.fir.FirElementWithResolveState
-import org.jetbrains.kotlin.fir.FirFileAnnotationsContainer
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRefsOwner
-import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner
-import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirAnonymousInitializer
-import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRef
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
-import org.jetbrains.kotlin.fir.declarations.FirConstructedClassTypeParameterRef
-import org.jetbrains.kotlin.fir.declarations.FirOuterClassTypeParameterRef
-import org.jetbrains.kotlin.fir.declarations.FirVariable
-import org.jetbrains.kotlin.fir.declarations.FirValueParameter
-import org.jetbrains.kotlin.fir.declarations.FirReceiverParameter
-import org.jetbrains.kotlin.fir.declarations.FirProperty
-import org.jetbrains.kotlin.fir.declarations.FirField
-import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
-import org.jetbrains.kotlin.fir.FirFunctionTypeParameter
-import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirClass
-import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
-import org.jetbrains.kotlin.fir.declarations.FirFunction
-import org.jetbrains.kotlin.fir.declarations.FirContractDescriptionOwner
-import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
-import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
-import org.jetbrains.kotlin.fir.declarations.FirBackingField
-import org.jetbrains.kotlin.fir.declarations.FirConstructor
-import org.jetbrains.kotlin.fir.declarations.FirFile
-import org.jetbrains.kotlin.fir.declarations.FirScript
-import org.jetbrains.kotlin.fir.declarations.FirCodeFragment
-import org.jetbrains.kotlin.fir.FirPackageDirective
-import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
-import org.jetbrains.kotlin.fir.expressions.FirAnonymousFunctionExpression
-import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject
-import org.jetbrains.kotlin.fir.expressions.FirAnonymousObjectExpression
-import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder
-import org.jetbrains.kotlin.fir.declarations.FirImport
-import org.jetbrains.kotlin.fir.declarations.FirResolvedImport
-import org.jetbrains.kotlin.fir.declarations.FirErrorImport
-import org.jetbrains.kotlin.fir.expressions.FirLoop
-import org.jetbrains.kotlin.fir.expressions.FirErrorLoop
-import org.jetbrains.kotlin.fir.expressions.FirDoWhileLoop
-import org.jetbrains.kotlin.fir.expressions.FirWhileLoop
-import org.jetbrains.kotlin.fir.expressions.FirBlock
-import org.jetbrains.kotlin.fir.expressions.FirLazyBlock
-import org.jetbrains.kotlin.fir.expressions.FirBinaryLogicExpression
-import org.jetbrains.kotlin.fir.expressions.FirJump
-import org.jetbrains.kotlin.fir.expressions.FirLoopJump
-import org.jetbrains.kotlin.fir.expressions.FirBreakExpression
-import org.jetbrains.kotlin.fir.expressions.FirContinueExpression
-import org.jetbrains.kotlin.fir.expressions.FirCatch
-import org.jetbrains.kotlin.fir.expressions.FirTryExpression
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
-import org.jetbrains.kotlin.fir.types.FirTypeProjection
-import org.jetbrains.kotlin.fir.types.FirStarProjection
-import org.jetbrains.kotlin.fir.types.FirPlaceholderProjection
-import org.jetbrains.kotlin.fir.types.FirTypeProjectionWithVariance
-import org.jetbrains.kotlin.fir.expressions.FirArgumentList
-import org.jetbrains.kotlin.fir.expressions.FirCall
-import org.jetbrains.kotlin.fir.expressions.FirAnnotation
-import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.expressions.FirAnnotationArgumentMapping
-import org.jetbrains.kotlin.fir.expressions.FirErrorAnnotationCall
-import org.jetbrains.kotlin.fir.expressions.FirComparisonExpression
-import org.jetbrains.kotlin.fir.expressions.FirTypeOperatorCall
-import org.jetbrains.kotlin.fir.expressions.FirAssignmentOperatorStatement
-import org.jetbrains.kotlin.fir.expressions.FirIncrementDecrementExpression
-import org.jetbrains.kotlin.fir.expressions.FirEqualityOperatorCall
-import org.jetbrains.kotlin.fir.expressions.FirWhenExpression
-import org.jetbrains.kotlin.fir.expressions.FirWhenBranch
-import org.jetbrains.kotlin.fir.expressions.FirContextReceiverArgumentListOwner
-import org.jetbrains.kotlin.fir.expressions.FirCheckNotNullCall
-import org.jetbrains.kotlin.fir.expressions.FirElvisExpression
-import org.jetbrains.kotlin.fir.expressions.FirArrayLiteral
-import org.jetbrains.kotlin.fir.expressions.FirAugmentedArraySetCall
-import org.jetbrains.kotlin.fir.expressions.FirClassReferenceExpression
-import org.jetbrains.kotlin.fir.expressions.FirErrorExpression
-import org.jetbrains.kotlin.fir.declarations.FirErrorFunction
-import org.jetbrains.kotlin.fir.declarations.FirErrorProperty
-import org.jetbrains.kotlin.fir.declarations.FirErrorPrimaryConstructor
-import org.jetbrains.kotlin.fir.declarations.FirDanglingModifierList
-import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
-import org.jetbrains.kotlin.fir.expressions.FirQualifiedErrorAccessExpression
-import org.jetbrains.kotlin.fir.expressions.FirPropertyAccessExpression
-import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
-import org.jetbrains.kotlin.fir.expressions.FirIntegerLiteralOperatorCall
-import org.jetbrains.kotlin.fir.expressions.FirImplicitInvokeCall
-import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
-import org.jetbrains.kotlin.fir.expressions.FirMultiDelegatedConstructorCall
-import org.jetbrains.kotlin.fir.expressions.FirComponentCall
-import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess
-import org.jetbrains.kotlin.fir.expressions.FirThisReceiverExpression
-import org.jetbrains.kotlin.fir.expressions.FirInaccessibleReceiverExpression
-import org.jetbrains.kotlin.fir.expressions.FirSmartCastExpression
-import org.jetbrains.kotlin.fir.expressions.FirSafeCallExpression
-import org.jetbrains.kotlin.fir.expressions.FirCheckedSafeCallSubject
-import org.jetbrains.kotlin.fir.expressions.FirGetClassCall
-import org.jetbrains.kotlin.fir.expressions.FirWrappedExpression
-import org.jetbrains.kotlin.fir.expressions.FirWrappedArgumentExpression
-import org.jetbrains.kotlin.fir.expressions.FirLambdaArgumentExpression
-import org.jetbrains.kotlin.fir.expressions.FirSpreadArgumentExpression
-import org.jetbrains.kotlin.fir.expressions.FirNamedArgumentExpression
-import org.jetbrains.kotlin.fir.expressions.FirVarargArgumentsExpression
-import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier
-import org.jetbrains.kotlin.fir.expressions.FirErrorResolvedQualifier
-import org.jetbrains.kotlin.fir.expressions.FirResolvedReifiedParameterReference
-import org.jetbrains.kotlin.fir.expressions.FirReturnExpression
-import org.jetbrains.kotlin.fir.expressions.FirStringConcatenationCall
-import org.jetbrains.kotlin.fir.expressions.FirThrowExpression
-import org.jetbrains.kotlin.fir.expressions.FirVariableAssignment
-import org.jetbrains.kotlin.fir.expressions.FirWhenSubjectExpression
-import org.jetbrains.kotlin.fir.expressions.FirDesugaredAssignmentValueReferenceExpression
-import org.jetbrains.kotlin.fir.expressions.FirWrappedDelegateExpression
-import org.jetbrains.kotlin.fir.expressions.FirEnumEntryDeserializedAccessExpression
-import org.jetbrains.kotlin.fir.references.FirNamedReference
-import org.jetbrains.kotlin.fir.references.FirNamedReferenceWithCandidateBase
-import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
-import org.jetbrains.kotlin.fir.references.FirFromMissingDependenciesNamedReference
-import org.jetbrains.kotlin.fir.references.FirSuperReference
-import org.jetbrains.kotlin.fir.references.FirThisReference
-import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
-import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
-import org.jetbrains.kotlin.fir.references.FirResolvedErrorReference
-import org.jetbrains.kotlin.fir.references.FirDelegateFieldReference
-import org.jetbrains.kotlin.fir.references.FirBackingFieldReference
-import org.jetbrains.kotlin.fir.references.FirResolvedCallableReference
-import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
-import org.jetbrains.kotlin.fir.types.FirErrorTypeRef
-import org.jetbrains.kotlin.fir.types.FirTypeRefWithNullability
-import org.jetbrains.kotlin.fir.types.FirUserTypeRef
-import org.jetbrains.kotlin.fir.types.FirDynamicTypeRef
-import org.jetbrains.kotlin.fir.types.FirFunctionTypeRef
-import org.jetbrains.kotlin.fir.types.FirIntersectionTypeRef
-import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
-import org.jetbrains.kotlin.fir.contracts.FirContractElementDeclaration
-import org.jetbrains.kotlin.fir.contracts.FirEffectDeclaration
-import org.jetbrains.kotlin.fir.contracts.FirContractDescription
-import org.jetbrains.kotlin.fir.contracts.FirLegacyRawContractDescription
-import org.jetbrains.kotlin.fir.contracts.FirRawContractDescription
-import org.jetbrains.kotlin.fir.contracts.FirResolvedContractDescription
+import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.contracts.*
+import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.diagnostics.*
+import org.jetbrains.kotlin.fir.expressions.*
+import org.jetbrains.kotlin.fir.references.*
+import org.jetbrains.kotlin.fir.types.*
 
 /*
  * This file was generated automatically
@@ -168,6 +19,7 @@
  */
 
 abstract class FirDefaultVisitor<out R, in D> : FirVisitor<R, D>() {
+
     override fun visitTypeRef(typeRef: FirTypeRef, data: D): R = visitAnnotationContainer(typeRef, data)
 
     override fun visitResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus, data: D): R = visitDeclarationStatus(resolvedDeclarationStatus, data)
@@ -337,5 +189,4 @@
     override fun visitRawContractDescription(rawContractDescription: FirRawContractDescription, data: D): R = visitContractDescription(rawContractDescription, data)
 
     override fun visitResolvedContractDescription(resolvedContractDescription: FirResolvedContractDescription, data: D): R = visitContractDescription(resolvedContractDescription, data)
-
 }
diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt
index 19a00be..f13fc9d 100644
--- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt
+++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt
@@ -5,162 +5,13 @@
 
 package org.jetbrains.kotlin.fir.visitors
 
-import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirAnnotationContainer
-import org.jetbrains.kotlin.fir.types.FirTypeRef
-import org.jetbrains.kotlin.fir.references.FirReference
-import org.jetbrains.kotlin.fir.FirLabel
-import org.jetbrains.kotlin.fir.expressions.FirResolvable
-import org.jetbrains.kotlin.fir.FirTargetElement
-import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
-import org.jetbrains.kotlin.fir.declarations.FirResolvedDeclarationStatus
-import org.jetbrains.kotlin.fir.declarations.FirControlFlowGraphOwner
-import org.jetbrains.kotlin.fir.expressions.FirStatement
-import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.expressions.FirLazyExpression
-import org.jetbrains.kotlin.fir.declarations.FirContextReceiver
-import org.jetbrains.kotlin.fir.FirElementWithResolveState
-import org.jetbrains.kotlin.fir.FirFileAnnotationsContainer
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRefsOwner
-import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner
-import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirAnonymousInitializer
-import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRef
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
-import org.jetbrains.kotlin.fir.declarations.FirConstructedClassTypeParameterRef
-import org.jetbrains.kotlin.fir.declarations.FirOuterClassTypeParameterRef
-import org.jetbrains.kotlin.fir.declarations.FirVariable
-import org.jetbrains.kotlin.fir.declarations.FirValueParameter
-import org.jetbrains.kotlin.fir.declarations.FirReceiverParameter
-import org.jetbrains.kotlin.fir.declarations.FirProperty
-import org.jetbrains.kotlin.fir.declarations.FirField
-import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
-import org.jetbrains.kotlin.fir.FirFunctionTypeParameter
-import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirClass
-import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
-import org.jetbrains.kotlin.fir.declarations.FirFunction
-import org.jetbrains.kotlin.fir.declarations.FirContractDescriptionOwner
-import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
-import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
-import org.jetbrains.kotlin.fir.declarations.FirBackingField
-import org.jetbrains.kotlin.fir.declarations.FirConstructor
-import org.jetbrains.kotlin.fir.declarations.FirFile
-import org.jetbrains.kotlin.fir.declarations.FirScript
-import org.jetbrains.kotlin.fir.declarations.FirCodeFragment
-import org.jetbrains.kotlin.fir.FirPackageDirective
-import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
-import org.jetbrains.kotlin.fir.expressions.FirAnonymousFunctionExpression
-import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject
-import org.jetbrains.kotlin.fir.expressions.FirAnonymousObjectExpression
-import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder
-import org.jetbrains.kotlin.fir.declarations.FirImport
-import org.jetbrains.kotlin.fir.declarations.FirResolvedImport
-import org.jetbrains.kotlin.fir.declarations.FirErrorImport
-import org.jetbrains.kotlin.fir.expressions.FirLoop
-import org.jetbrains.kotlin.fir.expressions.FirErrorLoop
-import org.jetbrains.kotlin.fir.expressions.FirDoWhileLoop
-import org.jetbrains.kotlin.fir.expressions.FirWhileLoop
-import org.jetbrains.kotlin.fir.expressions.FirBlock
-import org.jetbrains.kotlin.fir.expressions.FirLazyBlock
-import org.jetbrains.kotlin.fir.expressions.FirBinaryLogicExpression
-import org.jetbrains.kotlin.fir.expressions.FirJump
-import org.jetbrains.kotlin.fir.expressions.FirLoopJump
-import org.jetbrains.kotlin.fir.expressions.FirBreakExpression
-import org.jetbrains.kotlin.fir.expressions.FirContinueExpression
-import org.jetbrains.kotlin.fir.expressions.FirCatch
-import org.jetbrains.kotlin.fir.expressions.FirTryExpression
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
-import org.jetbrains.kotlin.fir.types.FirTypeProjection
-import org.jetbrains.kotlin.fir.types.FirStarProjection
-import org.jetbrains.kotlin.fir.types.FirPlaceholderProjection
-import org.jetbrains.kotlin.fir.types.FirTypeProjectionWithVariance
-import org.jetbrains.kotlin.fir.expressions.FirArgumentList
-import org.jetbrains.kotlin.fir.expressions.FirCall
-import org.jetbrains.kotlin.fir.expressions.FirAnnotation
-import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.expressions.FirAnnotationArgumentMapping
-import org.jetbrains.kotlin.fir.expressions.FirErrorAnnotationCall
-import org.jetbrains.kotlin.fir.expressions.FirComparisonExpression
-import org.jetbrains.kotlin.fir.expressions.FirTypeOperatorCall
-import org.jetbrains.kotlin.fir.expressions.FirAssignmentOperatorStatement
-import org.jetbrains.kotlin.fir.expressions.FirIncrementDecrementExpression
-import org.jetbrains.kotlin.fir.expressions.FirEqualityOperatorCall
-import org.jetbrains.kotlin.fir.expressions.FirWhenExpression
-import org.jetbrains.kotlin.fir.expressions.FirWhenBranch
-import org.jetbrains.kotlin.fir.expressions.FirContextReceiverArgumentListOwner
-import org.jetbrains.kotlin.fir.expressions.FirCheckNotNullCall
-import org.jetbrains.kotlin.fir.expressions.FirElvisExpression
-import org.jetbrains.kotlin.fir.expressions.FirArrayLiteral
-import org.jetbrains.kotlin.fir.expressions.FirAugmentedArraySetCall
-import org.jetbrains.kotlin.fir.expressions.FirClassReferenceExpression
-import org.jetbrains.kotlin.fir.expressions.FirErrorExpression
-import org.jetbrains.kotlin.fir.declarations.FirErrorFunction
-import org.jetbrains.kotlin.fir.declarations.FirErrorProperty
-import org.jetbrains.kotlin.fir.declarations.FirErrorPrimaryConstructor
-import org.jetbrains.kotlin.fir.declarations.FirDanglingModifierList
-import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
-import org.jetbrains.kotlin.fir.expressions.FirQualifiedErrorAccessExpression
-import org.jetbrains.kotlin.fir.expressions.FirPropertyAccessExpression
-import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
-import org.jetbrains.kotlin.fir.expressions.FirIntegerLiteralOperatorCall
-import org.jetbrains.kotlin.fir.expressions.FirImplicitInvokeCall
-import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
-import org.jetbrains.kotlin.fir.expressions.FirMultiDelegatedConstructorCall
-import org.jetbrains.kotlin.fir.expressions.FirComponentCall
-import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess
-import org.jetbrains.kotlin.fir.expressions.FirThisReceiverExpression
-import org.jetbrains.kotlin.fir.expressions.FirInaccessibleReceiverExpression
-import org.jetbrains.kotlin.fir.expressions.FirSmartCastExpression
-import org.jetbrains.kotlin.fir.expressions.FirSafeCallExpression
-import org.jetbrains.kotlin.fir.expressions.FirCheckedSafeCallSubject
-import org.jetbrains.kotlin.fir.expressions.FirGetClassCall
-import org.jetbrains.kotlin.fir.expressions.FirWrappedExpression
-import org.jetbrains.kotlin.fir.expressions.FirWrappedArgumentExpression
-import org.jetbrains.kotlin.fir.expressions.FirLambdaArgumentExpression
-import org.jetbrains.kotlin.fir.expressions.FirSpreadArgumentExpression
-import org.jetbrains.kotlin.fir.expressions.FirNamedArgumentExpression
-import org.jetbrains.kotlin.fir.expressions.FirVarargArgumentsExpression
-import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier
-import org.jetbrains.kotlin.fir.expressions.FirErrorResolvedQualifier
-import org.jetbrains.kotlin.fir.expressions.FirResolvedReifiedParameterReference
-import org.jetbrains.kotlin.fir.expressions.FirReturnExpression
-import org.jetbrains.kotlin.fir.expressions.FirStringConcatenationCall
-import org.jetbrains.kotlin.fir.expressions.FirThrowExpression
-import org.jetbrains.kotlin.fir.expressions.FirVariableAssignment
-import org.jetbrains.kotlin.fir.expressions.FirWhenSubjectExpression
-import org.jetbrains.kotlin.fir.expressions.FirDesugaredAssignmentValueReferenceExpression
-import org.jetbrains.kotlin.fir.expressions.FirWrappedDelegateExpression
-import org.jetbrains.kotlin.fir.expressions.FirEnumEntryDeserializedAccessExpression
-import org.jetbrains.kotlin.fir.references.FirNamedReference
-import org.jetbrains.kotlin.fir.references.FirNamedReferenceWithCandidateBase
-import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
-import org.jetbrains.kotlin.fir.references.FirFromMissingDependenciesNamedReference
-import org.jetbrains.kotlin.fir.references.FirSuperReference
-import org.jetbrains.kotlin.fir.references.FirThisReference
-import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
-import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
-import org.jetbrains.kotlin.fir.references.FirResolvedErrorReference
-import org.jetbrains.kotlin.fir.references.FirDelegateFieldReference
-import org.jetbrains.kotlin.fir.references.FirBackingFieldReference
-import org.jetbrains.kotlin.fir.references.FirResolvedCallableReference
-import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
-import org.jetbrains.kotlin.fir.types.FirErrorTypeRef
-import org.jetbrains.kotlin.fir.types.FirTypeRefWithNullability
-import org.jetbrains.kotlin.fir.types.FirUserTypeRef
-import org.jetbrains.kotlin.fir.types.FirDynamicTypeRef
-import org.jetbrains.kotlin.fir.types.FirFunctionTypeRef
-import org.jetbrains.kotlin.fir.types.FirIntersectionTypeRef
-import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
-import org.jetbrains.kotlin.fir.contracts.FirContractElementDeclaration
-import org.jetbrains.kotlin.fir.contracts.FirEffectDeclaration
-import org.jetbrains.kotlin.fir.contracts.FirContractDescription
-import org.jetbrains.kotlin.fir.contracts.FirLegacyRawContractDescription
-import org.jetbrains.kotlin.fir.contracts.FirRawContractDescription
-import org.jetbrains.kotlin.fir.contracts.FirResolvedContractDescription
+import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.contracts.*
+import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.diagnostics.*
+import org.jetbrains.kotlin.fir.expressions.*
+import org.jetbrains.kotlin.fir.references.*
+import org.jetbrains.kotlin.fir.types.*
 
 /*
  * This file was generated automatically
diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt
index 53058d6..93e0589 100644
--- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt
+++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt
@@ -5,162 +5,13 @@
 
 package org.jetbrains.kotlin.fir.visitors
 
-import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirAnnotationContainer
-import org.jetbrains.kotlin.fir.types.FirTypeRef
-import org.jetbrains.kotlin.fir.references.FirReference
-import org.jetbrains.kotlin.fir.FirLabel
-import org.jetbrains.kotlin.fir.expressions.FirResolvable
-import org.jetbrains.kotlin.fir.FirTargetElement
-import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
-import org.jetbrains.kotlin.fir.declarations.FirResolvedDeclarationStatus
-import org.jetbrains.kotlin.fir.declarations.FirControlFlowGraphOwner
-import org.jetbrains.kotlin.fir.expressions.FirStatement
-import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.expressions.FirLazyExpression
-import org.jetbrains.kotlin.fir.declarations.FirContextReceiver
-import org.jetbrains.kotlin.fir.FirElementWithResolveState
-import org.jetbrains.kotlin.fir.FirFileAnnotationsContainer
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRefsOwner
-import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner
-import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirAnonymousInitializer
-import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRef
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
-import org.jetbrains.kotlin.fir.declarations.FirConstructedClassTypeParameterRef
-import org.jetbrains.kotlin.fir.declarations.FirOuterClassTypeParameterRef
-import org.jetbrains.kotlin.fir.declarations.FirVariable
-import org.jetbrains.kotlin.fir.declarations.FirValueParameter
-import org.jetbrains.kotlin.fir.declarations.FirReceiverParameter
-import org.jetbrains.kotlin.fir.declarations.FirProperty
-import org.jetbrains.kotlin.fir.declarations.FirField
-import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
-import org.jetbrains.kotlin.fir.FirFunctionTypeParameter
-import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirClass
-import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
-import org.jetbrains.kotlin.fir.declarations.FirFunction
-import org.jetbrains.kotlin.fir.declarations.FirContractDescriptionOwner
-import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
-import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
-import org.jetbrains.kotlin.fir.declarations.FirBackingField
-import org.jetbrains.kotlin.fir.declarations.FirConstructor
-import org.jetbrains.kotlin.fir.declarations.FirFile
-import org.jetbrains.kotlin.fir.declarations.FirScript
-import org.jetbrains.kotlin.fir.declarations.FirCodeFragment
-import org.jetbrains.kotlin.fir.FirPackageDirective
-import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
-import org.jetbrains.kotlin.fir.expressions.FirAnonymousFunctionExpression
-import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject
-import org.jetbrains.kotlin.fir.expressions.FirAnonymousObjectExpression
-import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder
-import org.jetbrains.kotlin.fir.declarations.FirImport
-import org.jetbrains.kotlin.fir.declarations.FirResolvedImport
-import org.jetbrains.kotlin.fir.declarations.FirErrorImport
-import org.jetbrains.kotlin.fir.expressions.FirLoop
-import org.jetbrains.kotlin.fir.expressions.FirErrorLoop
-import org.jetbrains.kotlin.fir.expressions.FirDoWhileLoop
-import org.jetbrains.kotlin.fir.expressions.FirWhileLoop
-import org.jetbrains.kotlin.fir.expressions.FirBlock
-import org.jetbrains.kotlin.fir.expressions.FirLazyBlock
-import org.jetbrains.kotlin.fir.expressions.FirBinaryLogicExpression
-import org.jetbrains.kotlin.fir.expressions.FirJump
-import org.jetbrains.kotlin.fir.expressions.FirLoopJump
-import org.jetbrains.kotlin.fir.expressions.FirBreakExpression
-import org.jetbrains.kotlin.fir.expressions.FirContinueExpression
-import org.jetbrains.kotlin.fir.expressions.FirCatch
-import org.jetbrains.kotlin.fir.expressions.FirTryExpression
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
-import org.jetbrains.kotlin.fir.types.FirTypeProjection
-import org.jetbrains.kotlin.fir.types.FirStarProjection
-import org.jetbrains.kotlin.fir.types.FirPlaceholderProjection
-import org.jetbrains.kotlin.fir.types.FirTypeProjectionWithVariance
-import org.jetbrains.kotlin.fir.expressions.FirArgumentList
-import org.jetbrains.kotlin.fir.expressions.FirCall
-import org.jetbrains.kotlin.fir.expressions.FirAnnotation
-import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.expressions.FirAnnotationArgumentMapping
-import org.jetbrains.kotlin.fir.expressions.FirErrorAnnotationCall
-import org.jetbrains.kotlin.fir.expressions.FirComparisonExpression
-import org.jetbrains.kotlin.fir.expressions.FirTypeOperatorCall
-import org.jetbrains.kotlin.fir.expressions.FirAssignmentOperatorStatement
-import org.jetbrains.kotlin.fir.expressions.FirIncrementDecrementExpression
-import org.jetbrains.kotlin.fir.expressions.FirEqualityOperatorCall
-import org.jetbrains.kotlin.fir.expressions.FirWhenExpression
-import org.jetbrains.kotlin.fir.expressions.FirWhenBranch
-import org.jetbrains.kotlin.fir.expressions.FirContextReceiverArgumentListOwner
-import org.jetbrains.kotlin.fir.expressions.FirCheckNotNullCall
-import org.jetbrains.kotlin.fir.expressions.FirElvisExpression
-import org.jetbrains.kotlin.fir.expressions.FirArrayLiteral
-import org.jetbrains.kotlin.fir.expressions.FirAugmentedArraySetCall
-import org.jetbrains.kotlin.fir.expressions.FirClassReferenceExpression
-import org.jetbrains.kotlin.fir.expressions.FirErrorExpression
-import org.jetbrains.kotlin.fir.declarations.FirErrorFunction
-import org.jetbrains.kotlin.fir.declarations.FirErrorProperty
-import org.jetbrains.kotlin.fir.declarations.FirErrorPrimaryConstructor
-import org.jetbrains.kotlin.fir.declarations.FirDanglingModifierList
-import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
-import org.jetbrains.kotlin.fir.expressions.FirQualifiedErrorAccessExpression
-import org.jetbrains.kotlin.fir.expressions.FirPropertyAccessExpression
-import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
-import org.jetbrains.kotlin.fir.expressions.FirIntegerLiteralOperatorCall
-import org.jetbrains.kotlin.fir.expressions.FirImplicitInvokeCall
-import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
-import org.jetbrains.kotlin.fir.expressions.FirMultiDelegatedConstructorCall
-import org.jetbrains.kotlin.fir.expressions.FirComponentCall
-import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess
-import org.jetbrains.kotlin.fir.expressions.FirThisReceiverExpression
-import org.jetbrains.kotlin.fir.expressions.FirInaccessibleReceiverExpression
-import org.jetbrains.kotlin.fir.expressions.FirSmartCastExpression
-import org.jetbrains.kotlin.fir.expressions.FirSafeCallExpression
-import org.jetbrains.kotlin.fir.expressions.FirCheckedSafeCallSubject
-import org.jetbrains.kotlin.fir.expressions.FirGetClassCall
-import org.jetbrains.kotlin.fir.expressions.FirWrappedExpression
-import org.jetbrains.kotlin.fir.expressions.FirWrappedArgumentExpression
-import org.jetbrains.kotlin.fir.expressions.FirLambdaArgumentExpression
-import org.jetbrains.kotlin.fir.expressions.FirSpreadArgumentExpression
-import org.jetbrains.kotlin.fir.expressions.FirNamedArgumentExpression
-import org.jetbrains.kotlin.fir.expressions.FirVarargArgumentsExpression
-import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier
-import org.jetbrains.kotlin.fir.expressions.FirErrorResolvedQualifier
-import org.jetbrains.kotlin.fir.expressions.FirResolvedReifiedParameterReference
-import org.jetbrains.kotlin.fir.expressions.FirReturnExpression
-import org.jetbrains.kotlin.fir.expressions.FirStringConcatenationCall
-import org.jetbrains.kotlin.fir.expressions.FirThrowExpression
-import org.jetbrains.kotlin.fir.expressions.FirVariableAssignment
-import org.jetbrains.kotlin.fir.expressions.FirWhenSubjectExpression
-import org.jetbrains.kotlin.fir.expressions.FirDesugaredAssignmentValueReferenceExpression
-import org.jetbrains.kotlin.fir.expressions.FirWrappedDelegateExpression
-import org.jetbrains.kotlin.fir.expressions.FirEnumEntryDeserializedAccessExpression
-import org.jetbrains.kotlin.fir.references.FirNamedReference
-import org.jetbrains.kotlin.fir.references.FirNamedReferenceWithCandidateBase
-import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
-import org.jetbrains.kotlin.fir.references.FirFromMissingDependenciesNamedReference
-import org.jetbrains.kotlin.fir.references.FirSuperReference
-import org.jetbrains.kotlin.fir.references.FirThisReference
-import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
-import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
-import org.jetbrains.kotlin.fir.references.FirResolvedErrorReference
-import org.jetbrains.kotlin.fir.references.FirDelegateFieldReference
-import org.jetbrains.kotlin.fir.references.FirBackingFieldReference
-import org.jetbrains.kotlin.fir.references.FirResolvedCallableReference
-import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
-import org.jetbrains.kotlin.fir.types.FirErrorTypeRef
-import org.jetbrains.kotlin.fir.types.FirTypeRefWithNullability
-import org.jetbrains.kotlin.fir.types.FirUserTypeRef
-import org.jetbrains.kotlin.fir.types.FirDynamicTypeRef
-import org.jetbrains.kotlin.fir.types.FirFunctionTypeRef
-import org.jetbrains.kotlin.fir.types.FirIntersectionTypeRef
-import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
-import org.jetbrains.kotlin.fir.contracts.FirContractElementDeclaration
-import org.jetbrains.kotlin.fir.contracts.FirEffectDeclaration
-import org.jetbrains.kotlin.fir.contracts.FirContractDescription
-import org.jetbrains.kotlin.fir.contracts.FirLegacyRawContractDescription
-import org.jetbrains.kotlin.fir.contracts.FirRawContractDescription
-import org.jetbrains.kotlin.fir.contracts.FirResolvedContractDescription
+import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.contracts.*
+import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.diagnostics.*
+import org.jetbrains.kotlin.fir.expressions.*
+import org.jetbrains.kotlin.fir.references.*
+import org.jetbrains.kotlin.fir.types.*
 
 /*
  * This file was generated automatically
@@ -168,6 +19,7 @@
  */
 
 abstract class FirVisitor<out R, in D> {
+
     abstract fun visitElement(element: FirElement, data: D): R
 
     open fun visitAnnotationContainer(annotationContainer: FirAnnotationContainer, data: D): R = visitElement(annotationContainer, data)
@@ -479,5 +331,4 @@
     open fun visitRawContractDescription(rawContractDescription: FirRawContractDescription, data: D): R = visitElement(rawContractDescription, data)
 
     open fun visitResolvedContractDescription(resolvedContractDescription: FirResolvedContractDescription, data: D): R = visitElement(resolvedContractDescription, data)
-
 }
diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt
index b3aa0d5..e0148f6 100644
--- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt
+++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt
@@ -5,162 +5,13 @@
 
 package org.jetbrains.kotlin.fir.visitors
 
-import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirAnnotationContainer
-import org.jetbrains.kotlin.fir.types.FirTypeRef
-import org.jetbrains.kotlin.fir.references.FirReference
-import org.jetbrains.kotlin.fir.FirLabel
-import org.jetbrains.kotlin.fir.expressions.FirResolvable
-import org.jetbrains.kotlin.fir.FirTargetElement
-import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
-import org.jetbrains.kotlin.fir.declarations.FirResolvedDeclarationStatus
-import org.jetbrains.kotlin.fir.declarations.FirControlFlowGraphOwner
-import org.jetbrains.kotlin.fir.expressions.FirStatement
-import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.expressions.FirLazyExpression
-import org.jetbrains.kotlin.fir.declarations.FirContextReceiver
-import org.jetbrains.kotlin.fir.FirElementWithResolveState
-import org.jetbrains.kotlin.fir.FirFileAnnotationsContainer
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRefsOwner
-import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner
-import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirAnonymousInitializer
-import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRef
-import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
-import org.jetbrains.kotlin.fir.declarations.FirConstructedClassTypeParameterRef
-import org.jetbrains.kotlin.fir.declarations.FirOuterClassTypeParameterRef
-import org.jetbrains.kotlin.fir.declarations.FirVariable
-import org.jetbrains.kotlin.fir.declarations.FirValueParameter
-import org.jetbrains.kotlin.fir.declarations.FirReceiverParameter
-import org.jetbrains.kotlin.fir.declarations.FirProperty
-import org.jetbrains.kotlin.fir.declarations.FirField
-import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
-import org.jetbrains.kotlin.fir.FirFunctionTypeParameter
-import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirClass
-import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
-import org.jetbrains.kotlin.fir.declarations.FirFunction
-import org.jetbrains.kotlin.fir.declarations.FirContractDescriptionOwner
-import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
-import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
-import org.jetbrains.kotlin.fir.declarations.FirBackingField
-import org.jetbrains.kotlin.fir.declarations.FirConstructor
-import org.jetbrains.kotlin.fir.declarations.FirFile
-import org.jetbrains.kotlin.fir.declarations.FirScript
-import org.jetbrains.kotlin.fir.declarations.FirCodeFragment
-import org.jetbrains.kotlin.fir.FirPackageDirective
-import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
-import org.jetbrains.kotlin.fir.expressions.FirAnonymousFunctionExpression
-import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject
-import org.jetbrains.kotlin.fir.expressions.FirAnonymousObjectExpression
-import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder
-import org.jetbrains.kotlin.fir.declarations.FirImport
-import org.jetbrains.kotlin.fir.declarations.FirResolvedImport
-import org.jetbrains.kotlin.fir.declarations.FirErrorImport
-import org.jetbrains.kotlin.fir.expressions.FirLoop
-import org.jetbrains.kotlin.fir.expressions.FirErrorLoop
-import org.jetbrains.kotlin.fir.expressions.FirDoWhileLoop
-import org.jetbrains.kotlin.fir.expressions.FirWhileLoop
-import org.jetbrains.kotlin.fir.expressions.FirBlock
-import org.jetbrains.kotlin.fir.expressions.FirLazyBlock
-import org.jetbrains.kotlin.fir.expressions.FirBinaryLogicExpression
-import org.jetbrains.kotlin.fir.expressions.FirJump
-import org.jetbrains.kotlin.fir.expressions.FirLoopJump
-import org.jetbrains.kotlin.fir.expressions.FirBreakExpression
-import org.jetbrains.kotlin.fir.expressions.FirContinueExpression
-import org.jetbrains.kotlin.fir.expressions.FirCatch
-import org.jetbrains.kotlin.fir.expressions.FirTryExpression
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
-import org.jetbrains.kotlin.fir.types.FirTypeProjection
-import org.jetbrains.kotlin.fir.types.FirStarProjection
-import org.jetbrains.kotlin.fir.types.FirPlaceholderProjection
-import org.jetbrains.kotlin.fir.types.FirTypeProjectionWithVariance
-import org.jetbrains.kotlin.fir.expressions.FirArgumentList
-import org.jetbrains.kotlin.fir.expressions.FirCall
-import org.jetbrains.kotlin.fir.expressions.FirAnnotation
-import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.expressions.FirAnnotationArgumentMapping
-import org.jetbrains.kotlin.fir.expressions.FirErrorAnnotationCall
-import org.jetbrains.kotlin.fir.expressions.FirComparisonExpression
-import org.jetbrains.kotlin.fir.expressions.FirTypeOperatorCall
-import org.jetbrains.kotlin.fir.expressions.FirAssignmentOperatorStatement
-import org.jetbrains.kotlin.fir.expressions.FirIncrementDecrementExpression
-import org.jetbrains.kotlin.fir.expressions.FirEqualityOperatorCall
-import org.jetbrains.kotlin.fir.expressions.FirWhenExpression
-import org.jetbrains.kotlin.fir.expressions.FirWhenBranch
-import org.jetbrains.kotlin.fir.expressions.FirContextReceiverArgumentListOwner
-import org.jetbrains.kotlin.fir.expressions.FirCheckNotNullCall
-import org.jetbrains.kotlin.fir.expressions.FirElvisExpression
-import org.jetbrains.kotlin.fir.expressions.FirArrayLiteral
-import org.jetbrains.kotlin.fir.expressions.FirAugmentedArraySetCall
-import org.jetbrains.kotlin.fir.expressions.FirClassReferenceExpression
-import org.jetbrains.kotlin.fir.expressions.FirErrorExpression
-import org.jetbrains.kotlin.fir.declarations.FirErrorFunction
-import org.jetbrains.kotlin.fir.declarations.FirErrorProperty
-import org.jetbrains.kotlin.fir.declarations.FirErrorPrimaryConstructor
-import org.jetbrains.kotlin.fir.declarations.FirDanglingModifierList
-import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
-import org.jetbrains.kotlin.fir.expressions.FirQualifiedErrorAccessExpression
-import org.jetbrains.kotlin.fir.expressions.FirPropertyAccessExpression
-import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
-import org.jetbrains.kotlin.fir.expressions.FirIntegerLiteralOperatorCall
-import org.jetbrains.kotlin.fir.expressions.FirImplicitInvokeCall
-import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
-import org.jetbrains.kotlin.fir.expressions.FirMultiDelegatedConstructorCall
-import org.jetbrains.kotlin.fir.expressions.FirComponentCall
-import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess
-import org.jetbrains.kotlin.fir.expressions.FirThisReceiverExpression
-import org.jetbrains.kotlin.fir.expressions.FirInaccessibleReceiverExpression
-import org.jetbrains.kotlin.fir.expressions.FirSmartCastExpression
-import org.jetbrains.kotlin.fir.expressions.FirSafeCallExpression
-import org.jetbrains.kotlin.fir.expressions.FirCheckedSafeCallSubject
-import org.jetbrains.kotlin.fir.expressions.FirGetClassCall
-import org.jetbrains.kotlin.fir.expressions.FirWrappedExpression
-import org.jetbrains.kotlin.fir.expressions.FirWrappedArgumentExpression
-import org.jetbrains.kotlin.fir.expressions.FirLambdaArgumentExpression
-import org.jetbrains.kotlin.fir.expressions.FirSpreadArgumentExpression
-import org.jetbrains.kotlin.fir.expressions.FirNamedArgumentExpression
-import org.jetbrains.kotlin.fir.expressions.FirVarargArgumentsExpression
-import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier
-import org.jetbrains.kotlin.fir.expressions.FirErrorResolvedQualifier
-import org.jetbrains.kotlin.fir.expressions.FirResolvedReifiedParameterReference
-import org.jetbrains.kotlin.fir.expressions.FirReturnExpression
-import org.jetbrains.kotlin.fir.expressions.FirStringConcatenationCall
-import org.jetbrains.kotlin.fir.expressions.FirThrowExpression
-import org.jetbrains.kotlin.fir.expressions.FirVariableAssignment
-import org.jetbrains.kotlin.fir.expressions.FirWhenSubjectExpression
-import org.jetbrains.kotlin.fir.expressions.FirDesugaredAssignmentValueReferenceExpression
-import org.jetbrains.kotlin.fir.expressions.FirWrappedDelegateExpression
-import org.jetbrains.kotlin.fir.expressions.FirEnumEntryDeserializedAccessExpression
-import org.jetbrains.kotlin.fir.references.FirNamedReference
-import org.jetbrains.kotlin.fir.references.FirNamedReferenceWithCandidateBase
-import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
-import org.jetbrains.kotlin.fir.references.FirFromMissingDependenciesNamedReference
-import org.jetbrains.kotlin.fir.references.FirSuperReference
-import org.jetbrains.kotlin.fir.references.FirThisReference
-import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
-import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
-import org.jetbrains.kotlin.fir.references.FirResolvedErrorReference
-import org.jetbrains.kotlin.fir.references.FirDelegateFieldReference
-import org.jetbrains.kotlin.fir.references.FirBackingFieldReference
-import org.jetbrains.kotlin.fir.references.FirResolvedCallableReference
-import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
-import org.jetbrains.kotlin.fir.types.FirErrorTypeRef
-import org.jetbrains.kotlin.fir.types.FirTypeRefWithNullability
-import org.jetbrains.kotlin.fir.types.FirUserTypeRef
-import org.jetbrains.kotlin.fir.types.FirDynamicTypeRef
-import org.jetbrains.kotlin.fir.types.FirFunctionTypeRef
-import org.jetbrains.kotlin.fir.types.FirIntersectionTypeRef
-import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
-import org.jetbrains.kotlin.fir.contracts.FirContractElementDeclaration
-import org.jetbrains.kotlin.fir.contracts.FirEffectDeclaration
-import org.jetbrains.kotlin.fir.contracts.FirContractDescription
-import org.jetbrains.kotlin.fir.contracts.FirLegacyRawContractDescription
-import org.jetbrains.kotlin.fir.contracts.FirRawContractDescription
-import org.jetbrains.kotlin.fir.contracts.FirResolvedContractDescription
+import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.contracts.*
+import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.diagnostics.*
+import org.jetbrains.kotlin.fir.expressions.*
+import org.jetbrains.kotlin.fir.references.*
+import org.jetbrains.kotlin.fir.types.*
 
 /*
  * This file was generated automatically
@@ -168,1250 +19,1246 @@
  */
 
 abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
+
     abstract fun visitElement(element: FirElement)
 
-    open fun visitAnnotationContainer(annotationContainer: FirAnnotationContainer) {
-        visitElement(annotationContainer)
-    }
-
-    open fun visitTypeRef(typeRef: FirTypeRef) {
-        visitElement(typeRef)
-    }
-
-    open fun visitReference(reference: FirReference) {
-        visitElement(reference)
-    }
-
-    open fun visitLabel(label: FirLabel) {
-        visitElement(label)
-    }
-
-    open fun visitResolvable(resolvable: FirResolvable) {
-        visitElement(resolvable)
-    }
-
-    open fun visitTargetElement(targetElement: FirTargetElement) {
-        visitElement(targetElement)
-    }
-
-    open fun visitDeclarationStatus(declarationStatus: FirDeclarationStatus) {
-        visitElement(declarationStatus)
-    }
-
-    open fun visitResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus) {
-        visitElement(resolvedDeclarationStatus)
-    }
-
-    open fun visitControlFlowGraphOwner(controlFlowGraphOwner: FirControlFlowGraphOwner) {
-        visitElement(controlFlowGraphOwner)
-    }
-
-    open fun visitStatement(statement: FirStatement) {
-        visitElement(statement)
-    }
-
-    open fun visitExpression(expression: FirExpression) {
-        visitElement(expression)
-    }
-
-    open fun visitLazyExpression(lazyExpression: FirLazyExpression) {
-        visitElement(lazyExpression)
-    }
-
-    open fun visitContextReceiver(contextReceiver: FirContextReceiver) {
-        visitElement(contextReceiver)
-    }
-
-    open fun visitElementWithResolveState(elementWithResolveState: FirElementWithResolveState) {
-        visitElement(elementWithResolveState)
-    }
-
-    open fun visitFileAnnotationsContainer(fileAnnotationsContainer: FirFileAnnotationsContainer) {
-        visitElement(fileAnnotationsContainer)
-    }
-
-    open fun visitDeclaration(declaration: FirDeclaration) {
-        visitElement(declaration)
-    }
-
-    open fun visitTypeParameterRefsOwner(typeParameterRefsOwner: FirTypeParameterRefsOwner) {
-        visitElement(typeParameterRefsOwner)
-    }
-
-    open fun visitTypeParametersOwner(typeParametersOwner: FirTypeParametersOwner) {
-        visitElement(typeParametersOwner)
-    }
-
-    open fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration) {
-        visitElement(memberDeclaration)
-    }
-
-    open fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer) {
-        visitElement(anonymousInitializer)
-    }
-
-    open fun visitCallableDeclaration(callableDeclaration: FirCallableDeclaration) {
-        visitElement(callableDeclaration)
-    }
-
-    open fun visitTypeParameterRef(typeParameterRef: FirTypeParameterRef) {
-        visitElement(typeParameterRef)
-    }
-
-    open fun visitTypeParameter(typeParameter: FirTypeParameter) {
-        visitElement(typeParameter)
-    }
-
-    open fun visitConstructedClassTypeParameterRef(constructedClassTypeParameterRef: FirConstructedClassTypeParameterRef) {
-        visitElement(constructedClassTypeParameterRef)
-    }
-
-    open fun visitOuterClassTypeParameterRef(outerClassTypeParameterRef: FirOuterClassTypeParameterRef) {
-        visitElement(outerClassTypeParameterRef)
-    }
-
-    open fun visitVariable(variable: FirVariable) {
-        visitElement(variable)
-    }
-
-    open fun visitValueParameter(valueParameter: FirValueParameter) {
-        visitElement(valueParameter)
-    }
-
-    open fun visitReceiverParameter(receiverParameter: FirReceiverParameter) {
-        visitElement(receiverParameter)
-    }
-
-    open fun visitProperty(property: FirProperty) {
-        visitElement(property)
-    }
-
-    open fun visitField(field: FirField) {
-        visitElement(field)
-    }
-
-    open fun visitEnumEntry(enumEntry: FirEnumEntry) {
-        visitElement(enumEntry)
-    }
-
-    open fun visitFunctionTypeParameter(functionTypeParameter: FirFunctionTypeParameter) {
-        visitElement(functionTypeParameter)
-    }
-
-    open fun visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration) {
-        visitElement(classLikeDeclaration)
-    }
-
-    open fun visitClass(klass: FirClass) {
-        visitElement(klass)
-    }
-
-    open fun visitRegularClass(regularClass: FirRegularClass) {
-        visitElement(regularClass)
-    }
-
-    open fun visitTypeAlias(typeAlias: FirTypeAlias) {
-        visitElement(typeAlias)
-    }
-
-    open fun visitFunction(function: FirFunction) {
-        visitElement(function)
-    }
-
-    open fun visitContractDescriptionOwner(contractDescriptionOwner: FirContractDescriptionOwner) {
-        visitElement(contractDescriptionOwner)
-    }
-
-    open fun visitSimpleFunction(simpleFunction: FirSimpleFunction) {
-        visitElement(simpleFunction)
-    }
-
-    open fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor) {
-        visitElement(propertyAccessor)
-    }
-
-    open fun visitBackingField(backingField: FirBackingField) {
-        visitElement(backingField)
-    }
-
-    open fun visitConstructor(constructor: FirConstructor) {
-        visitElement(constructor)
-    }
-
-    open fun visitFile(file: FirFile) {
-        visitElement(file)
-    }
-
-    open fun visitScript(script: FirScript) {
-        visitElement(script)
-    }
-
-    open fun visitCodeFragment(codeFragment: FirCodeFragment) {
-        visitElement(codeFragment)
-    }
-
-    open fun visitPackageDirective(packageDirective: FirPackageDirective) {
-        visitElement(packageDirective)
-    }
-
-    open fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction) {
-        visitElement(anonymousFunction)
-    }
-
-    open fun visitAnonymousFunctionExpression(anonymousFunctionExpression: FirAnonymousFunctionExpression) {
-        visitElement(anonymousFunctionExpression)
-    }
-
-    open fun visitAnonymousObject(anonymousObject: FirAnonymousObject) {
-        visitElement(anonymousObject)
-    }
-
-    open fun visitAnonymousObjectExpression(anonymousObjectExpression: FirAnonymousObjectExpression) {
-        visitElement(anonymousObjectExpression)
-    }
-
-    open fun visitDiagnosticHolder(diagnosticHolder: FirDiagnosticHolder) {
-        visitElement(diagnosticHolder)
-    }
-
-    open fun visitImport(import: FirImport) {
-        visitElement(import)
-    }
-
-    open fun visitResolvedImport(resolvedImport: FirResolvedImport) {
-        visitElement(resolvedImport)
-    }
-
-    open fun visitErrorImport(errorImport: FirErrorImport) {
-        visitElement(errorImport)
-    }
-
-    open fun visitLoop(loop: FirLoop) {
-        visitElement(loop)
-    }
-
-    open fun visitErrorLoop(errorLoop: FirErrorLoop) {
-        visitElement(errorLoop)
-    }
-
-    open fun visitDoWhileLoop(doWhileLoop: FirDoWhileLoop) {
-        visitElement(doWhileLoop)
-    }
-
-    open fun visitWhileLoop(whileLoop: FirWhileLoop) {
-        visitElement(whileLoop)
-    }
-
-    open fun visitBlock(block: FirBlock) {
-        visitElement(block)
-    }
-
-    open fun visitLazyBlock(lazyBlock: FirLazyBlock) {
-        visitElement(lazyBlock)
-    }
-
-    open fun visitBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression) {
-        visitElement(binaryLogicExpression)
-    }
-
-    open fun <E : FirTargetElement> visitJump(jump: FirJump<E>) {
-        visitElement(jump)
-    }
-
-    open fun visitLoopJump(loopJump: FirLoopJump) {
-        visitElement(loopJump)
-    }
-
-    open fun visitBreakExpression(breakExpression: FirBreakExpression) {
-        visitElement(breakExpression)
-    }
-
-    open fun visitContinueExpression(continueExpression: FirContinueExpression) {
-        visitElement(continueExpression)
-    }
-
-    open fun visitCatch(catch: FirCatch) {
-        visitElement(catch)
-    }
-
-    open fun visitTryExpression(tryExpression: FirTryExpression) {
-        visitElement(tryExpression)
-    }
-
-    open fun <T> visitConstExpression(constExpression: FirConstExpression<T>) {
-        visitElement(constExpression)
-    }
-
-    open fun visitTypeProjection(typeProjection: FirTypeProjection) {
-        visitElement(typeProjection)
-    }
-
-    open fun visitStarProjection(starProjection: FirStarProjection) {
-        visitElement(starProjection)
-    }
-
-    open fun visitPlaceholderProjection(placeholderProjection: FirPlaceholderProjection) {
-        visitElement(placeholderProjection)
-    }
-
-    open fun visitTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance) {
-        visitElement(typeProjectionWithVariance)
-    }
-
-    open fun visitArgumentList(argumentList: FirArgumentList) {
-        visitElement(argumentList)
-    }
-
-    open fun visitCall(call: FirCall) {
-        visitElement(call)
-    }
-
-    open fun visitAnnotation(annotation: FirAnnotation) {
-        visitElement(annotation)
-    }
-
-    open fun visitAnnotationCall(annotationCall: FirAnnotationCall) {
-        visitElement(annotationCall)
-    }
-
-    open fun visitAnnotationArgumentMapping(annotationArgumentMapping: FirAnnotationArgumentMapping) {
-        visitElement(annotationArgumentMapping)
-    }
-
-    open fun visitErrorAnnotationCall(errorAnnotationCall: FirErrorAnnotationCall) {
-        visitElement(errorAnnotationCall)
-    }
-
-    open fun visitComparisonExpression(comparisonExpression: FirComparisonExpression) {
-        visitElement(comparisonExpression)
-    }
-
-    open fun visitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall) {
-        visitElement(typeOperatorCall)
-    }
-
-    open fun visitAssignmentOperatorStatement(assignmentOperatorStatement: FirAssignmentOperatorStatement) {
-        visitElement(assignmentOperatorStatement)
-    }
-
-    open fun visitIncrementDecrementExpression(incrementDecrementExpression: FirIncrementDecrementExpression) {
-        visitElement(incrementDecrementExpression)
-    }
-
-    open fun visitEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall) {
-        visitElement(equalityOperatorCall)
-    }
-
-    open fun visitWhenExpression(whenExpression: FirWhenExpression) {
-        visitElement(whenExpression)
-    }
-
-    open fun visitWhenBranch(whenBranch: FirWhenBranch) {
-        visitElement(whenBranch)
-    }
-
-    open fun visitContextReceiverArgumentListOwner(contextReceiverArgumentListOwner: FirContextReceiverArgumentListOwner) {
-        visitElement(contextReceiverArgumentListOwner)
-    }
-
-    open fun visitCheckNotNullCall(checkNotNullCall: FirCheckNotNullCall) {
-        visitElement(checkNotNullCall)
-    }
-
-    open fun visitElvisExpression(elvisExpression: FirElvisExpression) {
-        visitElement(elvisExpression)
-    }
-
-    open fun visitArrayLiteral(arrayLiteral: FirArrayLiteral) {
-        visitElement(arrayLiteral)
-    }
-
-    open fun visitAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall) {
-        visitElement(augmentedArraySetCall)
-    }
-
-    open fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression) {
-        visitElement(classReferenceExpression)
-    }
-
-    open fun visitErrorExpression(errorExpression: FirErrorExpression) {
-        visitElement(errorExpression)
-    }
-
-    open fun visitErrorFunction(errorFunction: FirErrorFunction) {
-        visitElement(errorFunction)
-    }
-
-    open fun visitErrorProperty(errorProperty: FirErrorProperty) {
-        visitElement(errorProperty)
-    }
-
-    open fun visitErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor) {
-        visitElement(errorPrimaryConstructor)
-    }
-
-    open fun visitDanglingModifierList(danglingModifierList: FirDanglingModifierList) {
-        visitElement(danglingModifierList)
-    }
-
-    open fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression) {
-        visitElement(qualifiedAccessExpression)
-    }
-
-    open fun visitQualifiedErrorAccessExpression(qualifiedErrorAccessExpression: FirQualifiedErrorAccessExpression) {
-        visitElement(qualifiedErrorAccessExpression)
-    }
-
-    open fun visitPropertyAccessExpression(propertyAccessExpression: FirPropertyAccessExpression) {
-        visitElement(propertyAccessExpression)
-    }
-
-    open fun visitFunctionCall(functionCall: FirFunctionCall) {
-        visitElement(functionCall)
-    }
-
-    open fun visitIntegerLiteralOperatorCall(integerLiteralOperatorCall: FirIntegerLiteralOperatorCall) {
-        visitElement(integerLiteralOperatorCall)
-    }
-
-    open fun visitImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall) {
-        visitElement(implicitInvokeCall)
-    }
-
-    open fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall) {
-        visitElement(delegatedConstructorCall)
-    }
-
-    open fun visitMultiDelegatedConstructorCall(multiDelegatedConstructorCall: FirMultiDelegatedConstructorCall) {
-        visitElement(multiDelegatedConstructorCall)
-    }
-
-    open fun visitComponentCall(componentCall: FirComponentCall) {
-        visitElement(componentCall)
-    }
-
-    open fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess) {
-        visitElement(callableReferenceAccess)
-    }
-
-    open fun visitThisReceiverExpression(thisReceiverExpression: FirThisReceiverExpression) {
-        visitElement(thisReceiverExpression)
-    }
-
-    open fun visitInaccessibleReceiverExpression(inaccessibleReceiverExpression: FirInaccessibleReceiverExpression) {
-        visitElement(inaccessibleReceiverExpression)
-    }
-
-    open fun visitSmartCastExpression(smartCastExpression: FirSmartCastExpression) {
-        visitElement(smartCastExpression)
-    }
-
-    open fun visitSafeCallExpression(safeCallExpression: FirSafeCallExpression) {
-        visitElement(safeCallExpression)
-    }
-
-    open fun visitCheckedSafeCallSubject(checkedSafeCallSubject: FirCheckedSafeCallSubject) {
-        visitElement(checkedSafeCallSubject)
-    }
-
-    open fun visitGetClassCall(getClassCall: FirGetClassCall) {
-        visitElement(getClassCall)
-    }
-
-    open fun visitWrappedExpression(wrappedExpression: FirWrappedExpression) {
-        visitElement(wrappedExpression)
-    }
-
-    open fun visitWrappedArgumentExpression(wrappedArgumentExpression: FirWrappedArgumentExpression) {
-        visitElement(wrappedArgumentExpression)
-    }
-
-    open fun visitLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression) {
-        visitElement(lambdaArgumentExpression)
-    }
-
-    open fun visitSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression) {
-        visitElement(spreadArgumentExpression)
-    }
-
-    open fun visitNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression) {
-        visitElement(namedArgumentExpression)
-    }
-
-    open fun visitVarargArgumentsExpression(varargArgumentsExpression: FirVarargArgumentsExpression) {
-        visitElement(varargArgumentsExpression)
-    }
-
-    open fun visitResolvedQualifier(resolvedQualifier: FirResolvedQualifier) {
-        visitElement(resolvedQualifier)
-    }
-
-    open fun visitErrorResolvedQualifier(errorResolvedQualifier: FirErrorResolvedQualifier) {
-        visitElement(errorResolvedQualifier)
-    }
-
-    open fun visitResolvedReifiedParameterReference(resolvedReifiedParameterReference: FirResolvedReifiedParameterReference) {
-        visitElement(resolvedReifiedParameterReference)
-    }
-
-    open fun visitReturnExpression(returnExpression: FirReturnExpression) {
-        visitElement(returnExpression)
-    }
-
-    open fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall) {
-        visitElement(stringConcatenationCall)
-    }
-
-    open fun visitThrowExpression(throwExpression: FirThrowExpression) {
-        visitElement(throwExpression)
-    }
-
-    open fun visitVariableAssignment(variableAssignment: FirVariableAssignment) {
-        visitElement(variableAssignment)
-    }
-
-    open fun visitWhenSubjectExpression(whenSubjectExpression: FirWhenSubjectExpression) {
-        visitElement(whenSubjectExpression)
-    }
-
-    open fun visitDesugaredAssignmentValueReferenceExpression(desugaredAssignmentValueReferenceExpression: FirDesugaredAssignmentValueReferenceExpression) {
-        visitElement(desugaredAssignmentValueReferenceExpression)
-    }
-
-    open fun visitWrappedDelegateExpression(wrappedDelegateExpression: FirWrappedDelegateExpression) {
-        visitElement(wrappedDelegateExpression)
-    }
-
-    open fun visitEnumEntryDeserializedAccessExpression(enumEntryDeserializedAccessExpression: FirEnumEntryDeserializedAccessExpression) {
-        visitElement(enumEntryDeserializedAccessExpression)
-    }
-
-    open fun visitNamedReference(namedReference: FirNamedReference) {
-        visitElement(namedReference)
-    }
-
-    open fun visitNamedReferenceWithCandidateBase(namedReferenceWithCandidateBase: FirNamedReferenceWithCandidateBase) {
-        visitElement(namedReferenceWithCandidateBase)
-    }
-
-    open fun visitErrorNamedReference(errorNamedReference: FirErrorNamedReference) {
-        visitElement(errorNamedReference)
-    }
-
-    open fun visitFromMissingDependenciesNamedReference(fromMissingDependenciesNamedReference: FirFromMissingDependenciesNamedReference) {
-        visitElement(fromMissingDependenciesNamedReference)
-    }
-
-    open fun visitSuperReference(superReference: FirSuperReference) {
-        visitElement(superReference)
-    }
-
-    open fun visitThisReference(thisReference: FirThisReference) {
-        visitElement(thisReference)
-    }
-
-    open fun visitControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference) {
-        visitElement(controlFlowGraphReference)
-    }
-
-    open fun visitResolvedNamedReference(resolvedNamedReference: FirResolvedNamedReference) {
-        visitElement(resolvedNamedReference)
-    }
-
-    open fun visitResolvedErrorReference(resolvedErrorReference: FirResolvedErrorReference) {
-        visitElement(resolvedErrorReference)
-    }
-
-    open fun visitDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference) {
-        visitElement(delegateFieldReference)
-    }
-
-    open fun visitBackingFieldReference(backingFieldReference: FirBackingFieldReference) {
-        visitElement(backingFieldReference)
-    }
-
-    open fun visitResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference) {
-        visitElement(resolvedCallableReference)
-    }
-
-    open fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef) {
-        visitElement(resolvedTypeRef)
-    }
-
-    open fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef) {
-        visitElement(errorTypeRef)
-    }
-
-    open fun visitTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability) {
-        visitElement(typeRefWithNullability)
-    }
-
-    open fun visitUserTypeRef(userTypeRef: FirUserTypeRef) {
-        visitElement(userTypeRef)
-    }
-
-    open fun visitDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef) {
-        visitElement(dynamicTypeRef)
-    }
-
-    open fun visitFunctionTypeRef(functionTypeRef: FirFunctionTypeRef) {
-        visitElement(functionTypeRef)
-    }
-
-    open fun visitIntersectionTypeRef(intersectionTypeRef: FirIntersectionTypeRef) {
-        visitElement(intersectionTypeRef)
-    }
-
-    open fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef) {
-        visitElement(implicitTypeRef)
-    }
-
-    open fun visitContractElementDeclaration(contractElementDeclaration: FirContractElementDeclaration) {
-        visitElement(contractElementDeclaration)
-    }
-
-    open fun visitEffectDeclaration(effectDeclaration: FirEffectDeclaration) {
-        visitElement(effectDeclaration)
-    }
-
-    open fun visitContractDescription(contractDescription: FirContractDescription) {
-        visitElement(contractDescription)
-    }
-
-    open fun visitLegacyRawContractDescription(legacyRawContractDescription: FirLegacyRawContractDescription) {
-        visitElement(legacyRawContractDescription)
-    }
-
-    open fun visitRawContractDescription(rawContractDescription: FirRawContractDescription) {
-        visitElement(rawContractDescription)
-    }
-
-    open fun visitResolvedContractDescription(resolvedContractDescription: FirResolvedContractDescription) {
-        visitElement(resolvedContractDescription)
-    }
-
-    final override fun visitElement(element: FirElement, data: Nothing?) {
-        visitElement(element)
-    }
-
     final override fun visitAnnotationContainer(annotationContainer: FirAnnotationContainer, data: Nothing?) {
         visitAnnotationContainer(annotationContainer)
     }
 
+    open fun visitAnnotationContainer(annotationContainer: FirAnnotationContainer) {
+        visitElement(annotationContainer)
+    }
+
     final override fun visitTypeRef(typeRef: FirTypeRef, data: Nothing?) {
         visitTypeRef(typeRef)
     }
 
+    open fun visitTypeRef(typeRef: FirTypeRef) {
+        visitElement(typeRef)
+    }
+
     final override fun visitReference(reference: FirReference, data: Nothing?) {
         visitReference(reference)
     }
 
+    open fun visitReference(reference: FirReference) {
+        visitElement(reference)
+    }
+
     final override fun visitLabel(label: FirLabel, data: Nothing?) {
         visitLabel(label)
     }
 
+    open fun visitLabel(label: FirLabel) {
+        visitElement(label)
+    }
+
     final override fun visitResolvable(resolvable: FirResolvable, data: Nothing?) {
         visitResolvable(resolvable)
     }
 
+    open fun visitResolvable(resolvable: FirResolvable) {
+        visitElement(resolvable)
+    }
+
     final override fun visitTargetElement(targetElement: FirTargetElement, data: Nothing?) {
         visitTargetElement(targetElement)
     }
 
+    open fun visitTargetElement(targetElement: FirTargetElement) {
+        visitElement(targetElement)
+    }
+
     final override fun visitDeclarationStatus(declarationStatus: FirDeclarationStatus, data: Nothing?) {
         visitDeclarationStatus(declarationStatus)
     }
 
+    open fun visitDeclarationStatus(declarationStatus: FirDeclarationStatus) {
+        visitElement(declarationStatus)
+    }
+
     final override fun visitResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus, data: Nothing?) {
         visitResolvedDeclarationStatus(resolvedDeclarationStatus)
     }
 
+    open fun visitResolvedDeclarationStatus(resolvedDeclarationStatus: FirResolvedDeclarationStatus) {
+        visitElement(resolvedDeclarationStatus)
+    }
+
     final override fun visitControlFlowGraphOwner(controlFlowGraphOwner: FirControlFlowGraphOwner, data: Nothing?) {
         visitControlFlowGraphOwner(controlFlowGraphOwner)
     }
 
+    open fun visitControlFlowGraphOwner(controlFlowGraphOwner: FirControlFlowGraphOwner) {
+        visitElement(controlFlowGraphOwner)
+    }
+
     final override fun visitStatement(statement: FirStatement, data: Nothing?) {
         visitStatement(statement)
     }
 
+    open fun visitStatement(statement: FirStatement) {
+        visitElement(statement)
+    }
+
     final override fun visitExpression(expression: FirExpression, data: Nothing?) {
         visitExpression(expression)
     }
 
+    open fun visitExpression(expression: FirExpression) {
+        visitElement(expression)
+    }
+
     final override fun visitLazyExpression(lazyExpression: FirLazyExpression, data: Nothing?) {
         visitLazyExpression(lazyExpression)
     }
 
+    open fun visitLazyExpression(lazyExpression: FirLazyExpression) {
+        visitElement(lazyExpression)
+    }
+
     final override fun visitContextReceiver(contextReceiver: FirContextReceiver, data: Nothing?) {
         visitContextReceiver(contextReceiver)
     }
 
+    open fun visitContextReceiver(contextReceiver: FirContextReceiver) {
+        visitElement(contextReceiver)
+    }
+
     final override fun visitElementWithResolveState(elementWithResolveState: FirElementWithResolveState, data: Nothing?) {
         visitElementWithResolveState(elementWithResolveState)
     }
 
+    open fun visitElementWithResolveState(elementWithResolveState: FirElementWithResolveState) {
+        visitElement(elementWithResolveState)
+    }
+
     final override fun visitFileAnnotationsContainer(fileAnnotationsContainer: FirFileAnnotationsContainer, data: Nothing?) {
         visitFileAnnotationsContainer(fileAnnotationsContainer)
     }
 
+    open fun visitFileAnnotationsContainer(fileAnnotationsContainer: FirFileAnnotationsContainer) {
+        visitElement(fileAnnotationsContainer)
+    }
+
     final override fun visitDeclaration(declaration: FirDeclaration, data: Nothing?) {
         visitDeclaration(declaration)
     }
 
+    open fun visitDeclaration(declaration: FirDeclaration) {
+        visitElement(declaration)
+    }
+
     final override fun visitTypeParameterRefsOwner(typeParameterRefsOwner: FirTypeParameterRefsOwner, data: Nothing?) {
         visitTypeParameterRefsOwner(typeParameterRefsOwner)
     }
 
+    open fun visitTypeParameterRefsOwner(typeParameterRefsOwner: FirTypeParameterRefsOwner) {
+        visitElement(typeParameterRefsOwner)
+    }
+
     final override fun visitTypeParametersOwner(typeParametersOwner: FirTypeParametersOwner, data: Nothing?) {
         visitTypeParametersOwner(typeParametersOwner)
     }
 
+    open fun visitTypeParametersOwner(typeParametersOwner: FirTypeParametersOwner) {
+        visitElement(typeParametersOwner)
+    }
+
     final override fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: Nothing?) {
         visitMemberDeclaration(memberDeclaration)
     }
 
+    open fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration) {
+        visitElement(memberDeclaration)
+    }
+
     final override fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: Nothing?) {
         visitAnonymousInitializer(anonymousInitializer)
     }
 
+    open fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer) {
+        visitElement(anonymousInitializer)
+    }
+
     final override fun visitCallableDeclaration(callableDeclaration: FirCallableDeclaration, data: Nothing?) {
         visitCallableDeclaration(callableDeclaration)
     }
 
+    open fun visitCallableDeclaration(callableDeclaration: FirCallableDeclaration) {
+        visitElement(callableDeclaration)
+    }
+
     final override fun visitTypeParameterRef(typeParameterRef: FirTypeParameterRef, data: Nothing?) {
         visitTypeParameterRef(typeParameterRef)
     }
 
+    open fun visitTypeParameterRef(typeParameterRef: FirTypeParameterRef) {
+        visitElement(typeParameterRef)
+    }
+
     final override fun visitTypeParameter(typeParameter: FirTypeParameter, data: Nothing?) {
         visitTypeParameter(typeParameter)
     }
 
+    open fun visitTypeParameter(typeParameter: FirTypeParameter) {
+        visitElement(typeParameter)
+    }
+
     final override fun visitConstructedClassTypeParameterRef(constructedClassTypeParameterRef: FirConstructedClassTypeParameterRef, data: Nothing?) {
         visitConstructedClassTypeParameterRef(constructedClassTypeParameterRef)
     }
 
+    open fun visitConstructedClassTypeParameterRef(constructedClassTypeParameterRef: FirConstructedClassTypeParameterRef) {
+        visitElement(constructedClassTypeParameterRef)
+    }
+
     final override fun visitOuterClassTypeParameterRef(outerClassTypeParameterRef: FirOuterClassTypeParameterRef, data: Nothing?) {
         visitOuterClassTypeParameterRef(outerClassTypeParameterRef)
     }
 
+    open fun visitOuterClassTypeParameterRef(outerClassTypeParameterRef: FirOuterClassTypeParameterRef) {
+        visitElement(outerClassTypeParameterRef)
+    }
+
     final override fun visitVariable(variable: FirVariable, data: Nothing?) {
         visitVariable(variable)
     }
 
+    open fun visitVariable(variable: FirVariable) {
+        visitElement(variable)
+    }
+
     final override fun visitValueParameter(valueParameter: FirValueParameter, data: Nothing?) {
         visitValueParameter(valueParameter)
     }
 
+    open fun visitValueParameter(valueParameter: FirValueParameter) {
+        visitElement(valueParameter)
+    }
+
     final override fun visitReceiverParameter(receiverParameter: FirReceiverParameter, data: Nothing?) {
         visitReceiverParameter(receiverParameter)
     }
 
+    open fun visitReceiverParameter(receiverParameter: FirReceiverParameter) {
+        visitElement(receiverParameter)
+    }
+
     final override fun visitProperty(property: FirProperty, data: Nothing?) {
         visitProperty(property)
     }
 
+    open fun visitProperty(property: FirProperty) {
+        visitElement(property)
+    }
+
     final override fun visitField(field: FirField, data: Nothing?) {
         visitField(field)
     }
 
+    open fun visitField(field: FirField) {
+        visitElement(field)
+    }
+
     final override fun visitEnumEntry(enumEntry: FirEnumEntry, data: Nothing?) {
         visitEnumEntry(enumEntry)
     }
 
+    open fun visitEnumEntry(enumEntry: FirEnumEntry) {
+        visitElement(enumEntry)
+    }
+
     final override fun visitFunctionTypeParameter(functionTypeParameter: FirFunctionTypeParameter, data: Nothing?) {
         visitFunctionTypeParameter(functionTypeParameter)
     }
 
+    open fun visitFunctionTypeParameter(functionTypeParameter: FirFunctionTypeParameter) {
+        visitElement(functionTypeParameter)
+    }
+
     final override fun visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration, data: Nothing?) {
         visitClassLikeDeclaration(classLikeDeclaration)
     }
 
+    open fun visitClassLikeDeclaration(classLikeDeclaration: FirClassLikeDeclaration) {
+        visitElement(classLikeDeclaration)
+    }
+
     final override fun visitClass(klass: FirClass, data: Nothing?) {
         visitClass(klass)
     }
 
+    open fun visitClass(klass: FirClass) {
+        visitElement(klass)
+    }
+
     final override fun visitRegularClass(regularClass: FirRegularClass, data: Nothing?) {
         visitRegularClass(regularClass)
     }
 
+    open fun visitRegularClass(regularClass: FirRegularClass) {
+        visitElement(regularClass)
+    }
+
     final override fun visitTypeAlias(typeAlias: FirTypeAlias, data: Nothing?) {
         visitTypeAlias(typeAlias)
     }
 
+    open fun visitTypeAlias(typeAlias: FirTypeAlias) {
+        visitElement(typeAlias)
+    }
+
     final override fun visitFunction(function: FirFunction, data: Nothing?) {
         visitFunction(function)
     }
 
+    open fun visitFunction(function: FirFunction) {
+        visitElement(function)
+    }
+
     final override fun visitContractDescriptionOwner(contractDescriptionOwner: FirContractDescriptionOwner, data: Nothing?) {
         visitContractDescriptionOwner(contractDescriptionOwner)
     }
 
+    open fun visitContractDescriptionOwner(contractDescriptionOwner: FirContractDescriptionOwner) {
+        visitElement(contractDescriptionOwner)
+    }
+
     final override fun visitSimpleFunction(simpleFunction: FirSimpleFunction, data: Nothing?) {
         visitSimpleFunction(simpleFunction)
     }
 
+    open fun visitSimpleFunction(simpleFunction: FirSimpleFunction) {
+        visitElement(simpleFunction)
+    }
+
     final override fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: Nothing?) {
         visitPropertyAccessor(propertyAccessor)
     }
 
+    open fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor) {
+        visitElement(propertyAccessor)
+    }
+
     final override fun visitBackingField(backingField: FirBackingField, data: Nothing?) {
         visitBackingField(backingField)
     }
 
+    open fun visitBackingField(backingField: FirBackingField) {
+        visitElement(backingField)
+    }
+
     final override fun visitConstructor(constructor: FirConstructor, data: Nothing?) {
         visitConstructor(constructor)
     }
 
+    open fun visitConstructor(constructor: FirConstructor) {
+        visitElement(constructor)
+    }
+
     final override fun visitFile(file: FirFile, data: Nothing?) {
         visitFile(file)
     }
 
+    open fun visitFile(file: FirFile) {
+        visitElement(file)
+    }
+
     final override fun visitScript(script: FirScript, data: Nothing?) {
         visitScript(script)
     }
 
+    open fun visitScript(script: FirScript) {
+        visitElement(script)
+    }
+
     final override fun visitCodeFragment(codeFragment: FirCodeFragment, data: Nothing?) {
         visitCodeFragment(codeFragment)
     }
 
+    open fun visitCodeFragment(codeFragment: FirCodeFragment) {
+        visitElement(codeFragment)
+    }
+
     final override fun visitPackageDirective(packageDirective: FirPackageDirective, data: Nothing?) {
         visitPackageDirective(packageDirective)
     }
 
+    open fun visitPackageDirective(packageDirective: FirPackageDirective) {
+        visitElement(packageDirective)
+    }
+
     final override fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: Nothing?) {
         visitAnonymousFunction(anonymousFunction)
     }
 
+    open fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction) {
+        visitElement(anonymousFunction)
+    }
+
     final override fun visitAnonymousFunctionExpression(anonymousFunctionExpression: FirAnonymousFunctionExpression, data: Nothing?) {
         visitAnonymousFunctionExpression(anonymousFunctionExpression)
     }
 
+    open fun visitAnonymousFunctionExpression(anonymousFunctionExpression: FirAnonymousFunctionExpression) {
+        visitElement(anonymousFunctionExpression)
+    }
+
     final override fun visitAnonymousObject(anonymousObject: FirAnonymousObject, data: Nothing?) {
         visitAnonymousObject(anonymousObject)
     }
 
+    open fun visitAnonymousObject(anonymousObject: FirAnonymousObject) {
+        visitElement(anonymousObject)
+    }
+
     final override fun visitAnonymousObjectExpression(anonymousObjectExpression: FirAnonymousObjectExpression, data: Nothing?) {
         visitAnonymousObjectExpression(anonymousObjectExpression)
     }
 
+    open fun visitAnonymousObjectExpression(anonymousObjectExpression: FirAnonymousObjectExpression) {
+        visitElement(anonymousObjectExpression)
+    }
+
     final override fun visitDiagnosticHolder(diagnosticHolder: FirDiagnosticHolder, data: Nothing?) {
         visitDiagnosticHolder(diagnosticHolder)
     }
 
+    open fun visitDiagnosticHolder(diagnosticHolder: FirDiagnosticHolder) {
+        visitElement(diagnosticHolder)
+    }
+
     final override fun visitImport(import: FirImport, data: Nothing?) {
         visitImport(import)
     }
 
+    open fun visitImport(import: FirImport) {
+        visitElement(import)
+    }
+
     final override fun visitResolvedImport(resolvedImport: FirResolvedImport, data: Nothing?) {
         visitResolvedImport(resolvedImport)
     }
 
+    open fun visitResolvedImport(resolvedImport: FirResolvedImport) {
+        visitElement(resolvedImport)
+    }
+
     final override fun visitErrorImport(errorImport: FirErrorImport, data: Nothing?) {
         visitErrorImport(errorImport)
     }
 
+    open fun visitErrorImport(errorImport: FirErrorImport) {
+        visitElement(errorImport)
+    }
+
     final override fun visitLoop(loop: FirLoop, data: Nothing?) {
         visitLoop(loop)
     }
 
+    open fun visitLoop(loop: FirLoop) {
+        visitElement(loop)
+    }
+
     final override fun visitErrorLoop(errorLoop: FirErrorLoop, data: Nothing?) {
         visitErrorLoop(errorLoop)
     }
 
+    open fun visitErrorLoop(errorLoop: FirErrorLoop) {
+        visitElement(errorLoop)
+    }
+
     final override fun visitDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: Nothing?) {
         visitDoWhileLoop(doWhileLoop)
     }
 
+    open fun visitDoWhileLoop(doWhileLoop: FirDoWhileLoop) {
+        visitElement(doWhileLoop)
+    }
+
     final override fun visitWhileLoop(whileLoop: FirWhileLoop, data: Nothing?) {
         visitWhileLoop(whileLoop)
     }
 
+    open fun visitWhileLoop(whileLoop: FirWhileLoop) {
+        visitElement(whileLoop)
+    }
+
     final override fun visitBlock(block: FirBlock, data: Nothing?) {
         visitBlock(block)
     }
 
+    open fun visitBlock(block: FirBlock) {
+        visitElement(block)
+    }
+
     final override fun visitLazyBlock(lazyBlock: FirLazyBlock, data: Nothing?) {
         visitLazyBlock(lazyBlock)
     }
 
+    open fun visitLazyBlock(lazyBlock: FirLazyBlock) {
+        visitElement(lazyBlock)
+    }
+
     final override fun visitBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression, data: Nothing?) {
         visitBinaryLogicExpression(binaryLogicExpression)
     }
 
+    open fun visitBinaryLogicExpression(binaryLogicExpression: FirBinaryLogicExpression) {
+        visitElement(binaryLogicExpression)
+    }
+
     final override fun <E : FirTargetElement> visitJump(jump: FirJump<E>, data: Nothing?) {
         visitJump(jump)
     }
 
+    open fun <E : FirTargetElement> visitJump(jump: FirJump<E>) {
+        visitElement(jump)
+    }
+
     final override fun visitLoopJump(loopJump: FirLoopJump, data: Nothing?) {
         visitLoopJump(loopJump)
     }
 
+    open fun visitLoopJump(loopJump: FirLoopJump) {
+        visitElement(loopJump)
+    }
+
     final override fun visitBreakExpression(breakExpression: FirBreakExpression, data: Nothing?) {
         visitBreakExpression(breakExpression)
     }
 
+    open fun visitBreakExpression(breakExpression: FirBreakExpression) {
+        visitElement(breakExpression)
+    }
+
     final override fun visitContinueExpression(continueExpression: FirContinueExpression, data: Nothing?) {
         visitContinueExpression(continueExpression)
     }
 
+    open fun visitContinueExpression(continueExpression: FirContinueExpression) {
+        visitElement(continueExpression)
+    }
+
     final override fun visitCatch(catch: FirCatch, data: Nothing?) {
         visitCatch(catch)
     }
 
+    open fun visitCatch(catch: FirCatch) {
+        visitElement(catch)
+    }
+
     final override fun visitTryExpression(tryExpression: FirTryExpression, data: Nothing?) {
         visitTryExpression(tryExpression)
     }
 
+    open fun visitTryExpression(tryExpression: FirTryExpression) {
+        visitElement(tryExpression)
+    }
+
     final override fun <T> visitConstExpression(constExpression: FirConstExpression<T>, data: Nothing?) {
         visitConstExpression(constExpression)
     }
 
+    open fun <T> visitConstExpression(constExpression: FirConstExpression<T>) {
+        visitElement(constExpression)
+    }
+
     final override fun visitTypeProjection(typeProjection: FirTypeProjection, data: Nothing?) {
         visitTypeProjection(typeProjection)
     }
 
+    open fun visitTypeProjection(typeProjection: FirTypeProjection) {
+        visitElement(typeProjection)
+    }
+
     final override fun visitStarProjection(starProjection: FirStarProjection, data: Nothing?) {
         visitStarProjection(starProjection)
     }
 
+    open fun visitStarProjection(starProjection: FirStarProjection) {
+        visitElement(starProjection)
+    }
+
     final override fun visitPlaceholderProjection(placeholderProjection: FirPlaceholderProjection, data: Nothing?) {
         visitPlaceholderProjection(placeholderProjection)
     }
 
+    open fun visitPlaceholderProjection(placeholderProjection: FirPlaceholderProjection) {
+        visitElement(placeholderProjection)
+    }
+
     final override fun visitTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance, data: Nothing?) {
         visitTypeProjectionWithVariance(typeProjectionWithVariance)
     }
 
+    open fun visitTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance) {
+        visitElement(typeProjectionWithVariance)
+    }
+
     final override fun visitArgumentList(argumentList: FirArgumentList, data: Nothing?) {
         visitArgumentList(argumentList)
     }
 
+    open fun visitArgumentList(argumentList: FirArgumentList) {
+        visitElement(argumentList)
+    }
+
     final override fun visitCall(call: FirCall, data: Nothing?) {
         visitCall(call)
     }
 
+    open fun visitCall(call: FirCall) {
+        visitElement(call)
+    }
+
     final override fun visitAnnotation(annotation: FirAnnotation, data: Nothing?) {
         visitAnnotation(annotation)
     }
 
+    open fun visitAnnotation(annotation: FirAnnotation) {
+        visitElement(annotation)
+    }
+
     final override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: Nothing?) {
         visitAnnotationCall(annotationCall)
     }
 
+    open fun visitAnnotationCall(annotationCall: FirAnnotationCall) {
+        visitElement(annotationCall)
+    }
+
     final override fun visitAnnotationArgumentMapping(annotationArgumentMapping: FirAnnotationArgumentMapping, data: Nothing?) {
         visitAnnotationArgumentMapping(annotationArgumentMapping)
     }
 
+    open fun visitAnnotationArgumentMapping(annotationArgumentMapping: FirAnnotationArgumentMapping) {
+        visitElement(annotationArgumentMapping)
+    }
+
     final override fun visitErrorAnnotationCall(errorAnnotationCall: FirErrorAnnotationCall, data: Nothing?) {
         visitErrorAnnotationCall(errorAnnotationCall)
     }
 
+    open fun visitErrorAnnotationCall(errorAnnotationCall: FirErrorAnnotationCall) {
+        visitElement(errorAnnotationCall)
+    }
+
     final override fun visitComparisonExpression(comparisonExpression: FirComparisonExpression, data: Nothing?) {
         visitComparisonExpression(comparisonExpression)
     }
 
+    open fun visitComparisonExpression(comparisonExpression: FirComparisonExpression) {
+        visitElement(comparisonExpression)
+    }
+
     final override fun visitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: Nothing?) {
         visitTypeOperatorCall(typeOperatorCall)
     }
 
+    open fun visitTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall) {
+        visitElement(typeOperatorCall)
+    }
+
     final override fun visitAssignmentOperatorStatement(assignmentOperatorStatement: FirAssignmentOperatorStatement, data: Nothing?) {
         visitAssignmentOperatorStatement(assignmentOperatorStatement)
     }
 
+    open fun visitAssignmentOperatorStatement(assignmentOperatorStatement: FirAssignmentOperatorStatement) {
+        visitElement(assignmentOperatorStatement)
+    }
+
     final override fun visitIncrementDecrementExpression(incrementDecrementExpression: FirIncrementDecrementExpression, data: Nothing?) {
         visitIncrementDecrementExpression(incrementDecrementExpression)
     }
 
+    open fun visitIncrementDecrementExpression(incrementDecrementExpression: FirIncrementDecrementExpression) {
+        visitElement(incrementDecrementExpression)
+    }
+
     final override fun visitEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall, data: Nothing?) {
         visitEqualityOperatorCall(equalityOperatorCall)
     }
 
+    open fun visitEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall) {
+        visitElement(equalityOperatorCall)
+    }
+
     final override fun visitWhenExpression(whenExpression: FirWhenExpression, data: Nothing?) {
         visitWhenExpression(whenExpression)
     }
 
+    open fun visitWhenExpression(whenExpression: FirWhenExpression) {
+        visitElement(whenExpression)
+    }
+
     final override fun visitWhenBranch(whenBranch: FirWhenBranch, data: Nothing?) {
         visitWhenBranch(whenBranch)
     }
 
+    open fun visitWhenBranch(whenBranch: FirWhenBranch) {
+        visitElement(whenBranch)
+    }
+
     final override fun visitContextReceiverArgumentListOwner(contextReceiverArgumentListOwner: FirContextReceiverArgumentListOwner, data: Nothing?) {
         visitContextReceiverArgumentListOwner(contextReceiverArgumentListOwner)
     }
 
+    open fun visitContextReceiverArgumentListOwner(contextReceiverArgumentListOwner: FirContextReceiverArgumentListOwner) {
+        visitElement(contextReceiverArgumentListOwner)
+    }
+
     final override fun visitCheckNotNullCall(checkNotNullCall: FirCheckNotNullCall, data: Nothing?) {
         visitCheckNotNullCall(checkNotNullCall)
     }
 
+    open fun visitCheckNotNullCall(checkNotNullCall: FirCheckNotNullCall) {
+        visitElement(checkNotNullCall)
+    }
+
     final override fun visitElvisExpression(elvisExpression: FirElvisExpression, data: Nothing?) {
         visitElvisExpression(elvisExpression)
     }
 
+    open fun visitElvisExpression(elvisExpression: FirElvisExpression) {
+        visitElement(elvisExpression)
+    }
+
     final override fun visitArrayLiteral(arrayLiteral: FirArrayLiteral, data: Nothing?) {
         visitArrayLiteral(arrayLiteral)
     }
 
+    open fun visitArrayLiteral(arrayLiteral: FirArrayLiteral) {
+        visitElement(arrayLiteral)
+    }
+
     final override fun visitAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall, data: Nothing?) {
         visitAugmentedArraySetCall(augmentedArraySetCall)
     }
 
+    open fun visitAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall) {
+        visitElement(augmentedArraySetCall)
+    }
+
     final override fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression, data: Nothing?) {
         visitClassReferenceExpression(classReferenceExpression)
     }
 
+    open fun visitClassReferenceExpression(classReferenceExpression: FirClassReferenceExpression) {
+        visitElement(classReferenceExpression)
+    }
+
     final override fun visitErrorExpression(errorExpression: FirErrorExpression, data: Nothing?) {
         visitErrorExpression(errorExpression)
     }
 
+    open fun visitErrorExpression(errorExpression: FirErrorExpression) {
+        visitElement(errorExpression)
+    }
+
     final override fun visitErrorFunction(errorFunction: FirErrorFunction, data: Nothing?) {
         visitErrorFunction(errorFunction)
     }
 
+    open fun visitErrorFunction(errorFunction: FirErrorFunction) {
+        visitElement(errorFunction)
+    }
+
     final override fun visitErrorProperty(errorProperty: FirErrorProperty, data: Nothing?) {
         visitErrorProperty(errorProperty)
     }
 
+    open fun visitErrorProperty(errorProperty: FirErrorProperty) {
+        visitElement(errorProperty)
+    }
+
     final override fun visitErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor, data: Nothing?) {
         visitErrorPrimaryConstructor(errorPrimaryConstructor)
     }
 
+    open fun visitErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor) {
+        visitElement(errorPrimaryConstructor)
+    }
+
     final override fun visitDanglingModifierList(danglingModifierList: FirDanglingModifierList, data: Nothing?) {
         visitDanglingModifierList(danglingModifierList)
     }
 
+    open fun visitDanglingModifierList(danglingModifierList: FirDanglingModifierList) {
+        visitElement(danglingModifierList)
+    }
+
     final override fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: Nothing?) {
         visitQualifiedAccessExpression(qualifiedAccessExpression)
     }
 
+    open fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression) {
+        visitElement(qualifiedAccessExpression)
+    }
+
     final override fun visitQualifiedErrorAccessExpression(qualifiedErrorAccessExpression: FirQualifiedErrorAccessExpression, data: Nothing?) {
         visitQualifiedErrorAccessExpression(qualifiedErrorAccessExpression)
     }
 
+    open fun visitQualifiedErrorAccessExpression(qualifiedErrorAccessExpression: FirQualifiedErrorAccessExpression) {
+        visitElement(qualifiedErrorAccessExpression)
+    }
+
     final override fun visitPropertyAccessExpression(propertyAccessExpression: FirPropertyAccessExpression, data: Nothing?) {
         visitPropertyAccessExpression(propertyAccessExpression)
     }
 
+    open fun visitPropertyAccessExpression(propertyAccessExpression: FirPropertyAccessExpression) {
+        visitElement(propertyAccessExpression)
+    }
+
     final override fun visitFunctionCall(functionCall: FirFunctionCall, data: Nothing?) {
         visitFunctionCall(functionCall)
     }
 
+    open fun visitFunctionCall(functionCall: FirFunctionCall) {
+        visitElement(functionCall)
+    }
+
     final override fun visitIntegerLiteralOperatorCall(integerLiteralOperatorCall: FirIntegerLiteralOperatorCall, data: Nothing?) {
         visitIntegerLiteralOperatorCall(integerLiteralOperatorCall)
     }
 
+    open fun visitIntegerLiteralOperatorCall(integerLiteralOperatorCall: FirIntegerLiteralOperatorCall) {
+        visitElement(integerLiteralOperatorCall)
+    }
+
     final override fun visitImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall, data: Nothing?) {
         visitImplicitInvokeCall(implicitInvokeCall)
     }
 
+    open fun visitImplicitInvokeCall(implicitInvokeCall: FirImplicitInvokeCall) {
+        visitElement(implicitInvokeCall)
+    }
+
     final override fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: Nothing?) {
         visitDelegatedConstructorCall(delegatedConstructorCall)
     }
 
+    open fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall) {
+        visitElement(delegatedConstructorCall)
+    }
+
     final override fun visitMultiDelegatedConstructorCall(multiDelegatedConstructorCall: FirMultiDelegatedConstructorCall, data: Nothing?) {
         visitMultiDelegatedConstructorCall(multiDelegatedConstructorCall)
     }
 
+    open fun visitMultiDelegatedConstructorCall(multiDelegatedConstructorCall: FirMultiDelegatedConstructorCall) {
+        visitElement(multiDelegatedConstructorCall)
+    }
+
     final override fun visitComponentCall(componentCall: FirComponentCall, data: Nothing?) {
         visitComponentCall(componentCall)
     }
 
+    open fun visitComponentCall(componentCall: FirComponentCall) {
+        visitElement(componentCall)
+    }
+
     final override fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess, data: Nothing?) {
         visitCallableReferenceAccess(callableReferenceAccess)
     }
 
+    open fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess) {
+        visitElement(callableReferenceAccess)
+    }
+
     final override fun visitThisReceiverExpression(thisReceiverExpression: FirThisReceiverExpression, data: Nothing?) {
         visitThisReceiverExpression(thisReceiverExpression)
     }
 
+    open fun visitThisReceiverExpression(thisReceiverExpression: FirThisReceiverExpression) {
+        visitElement(thisReceiverExpression)
+    }
+
     final override fun visitInaccessibleReceiverExpression(inaccessibleReceiverExpression: FirInaccessibleReceiverExpression, data: Nothing?) {
         visitInaccessibleReceiverExpression(inaccessibleReceiverExpression)
     }
 
+    open fun visitInaccessibleReceiverExpression(inaccessibleReceiverExpression: FirInaccessibleReceiverExpression) {
+        visitElement(inaccessibleReceiverExpression)
+    }
+
     final override fun visitSmartCastExpression(smartCastExpression: FirSmartCastExpression, data: Nothing?) {
         visitSmartCastExpression(smartCastExpression)
     }
 
+    open fun visitSmartCastExpression(smartCastExpression: FirSmartCastExpression) {
+        visitElement(smartCastExpression)
+    }
+
     final override fun visitSafeCallExpression(safeCallExpression: FirSafeCallExpression, data: Nothing?) {
         visitSafeCallExpression(safeCallExpression)
     }
 
+    open fun visitSafeCallExpression(safeCallExpression: FirSafeCallExpression) {
+        visitElement(safeCallExpression)
+    }
+
     final override fun visitCheckedSafeCallSubject(checkedSafeCallSubject: FirCheckedSafeCallSubject, data: Nothing?) {
         visitCheckedSafeCallSubject(checkedSafeCallSubject)
     }
 
+    open fun visitCheckedSafeCallSubject(checkedSafeCallSubject: FirCheckedSafeCallSubject) {
+        visitElement(checkedSafeCallSubject)
+    }
+
     final override fun visitGetClassCall(getClassCall: FirGetClassCall, data: Nothing?) {
         visitGetClassCall(getClassCall)
     }
 
+    open fun visitGetClassCall(getClassCall: FirGetClassCall) {
+        visitElement(getClassCall)
+    }
+
     final override fun visitWrappedExpression(wrappedExpression: FirWrappedExpression, data: Nothing?) {
         visitWrappedExpression(wrappedExpression)
     }
 
+    open fun visitWrappedExpression(wrappedExpression: FirWrappedExpression) {
+        visitElement(wrappedExpression)
+    }
+
     final override fun visitWrappedArgumentExpression(wrappedArgumentExpression: FirWrappedArgumentExpression, data: Nothing?) {
         visitWrappedArgumentExpression(wrappedArgumentExpression)
     }
 
+    open fun visitWrappedArgumentExpression(wrappedArgumentExpression: FirWrappedArgumentExpression) {
+        visitElement(wrappedArgumentExpression)
+    }
+
     final override fun visitLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression, data: Nothing?) {
         visitLambdaArgumentExpression(lambdaArgumentExpression)
     }
 
+    open fun visitLambdaArgumentExpression(lambdaArgumentExpression: FirLambdaArgumentExpression) {
+        visitElement(lambdaArgumentExpression)
+    }
+
     final override fun visitSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression, data: Nothing?) {
         visitSpreadArgumentExpression(spreadArgumentExpression)
     }
 
+    open fun visitSpreadArgumentExpression(spreadArgumentExpression: FirSpreadArgumentExpression) {
+        visitElement(spreadArgumentExpression)
+    }
+
     final override fun visitNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: Nothing?) {
         visitNamedArgumentExpression(namedArgumentExpression)
     }
 
+    open fun visitNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression) {
+        visitElement(namedArgumentExpression)
+    }
+
     final override fun visitVarargArgumentsExpression(varargArgumentsExpression: FirVarargArgumentsExpression, data: Nothing?) {
         visitVarargArgumentsExpression(varargArgumentsExpression)
     }
 
+    open fun visitVarargArgumentsExpression(varargArgumentsExpression: FirVarargArgumentsExpression) {
+        visitElement(varargArgumentsExpression)
+    }
+
     final override fun visitResolvedQualifier(resolvedQualifier: FirResolvedQualifier, data: Nothing?) {
         visitResolvedQualifier(resolvedQualifier)
     }
 
+    open fun visitResolvedQualifier(resolvedQualifier: FirResolvedQualifier) {
+        visitElement(resolvedQualifier)
+    }
+
     final override fun visitErrorResolvedQualifier(errorResolvedQualifier: FirErrorResolvedQualifier, data: Nothing?) {
         visitErrorResolvedQualifier(errorResolvedQualifier)
     }
 
+    open fun visitErrorResolvedQualifier(errorResolvedQualifier: FirErrorResolvedQualifier) {
+        visitElement(errorResolvedQualifier)
+    }
+
     final override fun visitResolvedReifiedParameterReference(resolvedReifiedParameterReference: FirResolvedReifiedParameterReference, data: Nothing?) {
         visitResolvedReifiedParameterReference(resolvedReifiedParameterReference)
     }
 
+    open fun visitResolvedReifiedParameterReference(resolvedReifiedParameterReference: FirResolvedReifiedParameterReference) {
+        visitElement(resolvedReifiedParameterReference)
+    }
+
     final override fun visitReturnExpression(returnExpression: FirReturnExpression, data: Nothing?) {
         visitReturnExpression(returnExpression)
     }
 
+    open fun visitReturnExpression(returnExpression: FirReturnExpression) {
+        visitElement(returnExpression)
+    }
+
     final override fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: Nothing?) {
         visitStringConcatenationCall(stringConcatenationCall)
     }
 
+    open fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall) {
+        visitElement(stringConcatenationCall)
+    }
+
     final override fun visitThrowExpression(throwExpression: FirThrowExpression, data: Nothing?) {
         visitThrowExpression(throwExpression)
     }
 
+    open fun visitThrowExpression(throwExpression: FirThrowExpression) {
+        visitElement(throwExpression)
+    }
+
     final override fun visitVariableAssignment(variableAssignment: FirVariableAssignment, data: Nothing?) {
         visitVariableAssignment(variableAssignment)
     }
 
+    open fun visitVariableAssignment(variableAssignment: FirVariableAssignment) {
+        visitElement(variableAssignment)
+    }
+
     final override fun visitWhenSubjectExpression(whenSubjectExpression: FirWhenSubjectExpression, data: Nothing?) {
         visitWhenSubjectExpression(whenSubjectExpression)
     }
 
+    open fun visitWhenSubjectExpression(whenSubjectExpression: FirWhenSubjectExpression) {
+        visitElement(whenSubjectExpression)
+    }
+
     final override fun visitDesugaredAssignmentValueReferenceExpression(desugaredAssignmentValueReferenceExpression: FirDesugaredAssignmentValueReferenceExpression, data: Nothing?) {
         visitDesugaredAssignmentValueReferenceExpression(desugaredAssignmentValueReferenceExpression)
     }
 
+    open fun visitDesugaredAssignmentValueReferenceExpression(desugaredAssignmentValueReferenceExpression: FirDesugaredAssignmentValueReferenceExpression) {
+        visitElement(desugaredAssignmentValueReferenceExpression)
+    }
+
     final override fun visitWrappedDelegateExpression(wrappedDelegateExpression: FirWrappedDelegateExpression, data: Nothing?) {
         visitWrappedDelegateExpression(wrappedDelegateExpression)
     }
 
+    open fun visitWrappedDelegateExpression(wrappedDelegateExpression: FirWrappedDelegateExpression) {
+        visitElement(wrappedDelegateExpression)
+    }
+
     final override fun visitEnumEntryDeserializedAccessExpression(enumEntryDeserializedAccessExpression: FirEnumEntryDeserializedAccessExpression, data: Nothing?) {
         visitEnumEntryDeserializedAccessExpression(enumEntryDeserializedAccessExpression)
     }
 
+    open fun visitEnumEntryDeserializedAccessExpression(enumEntryDeserializedAccessExpression: FirEnumEntryDeserializedAccessExpression) {
+        visitElement(enumEntryDeserializedAccessExpression)
+    }
+
     final override fun visitNamedReference(namedReference: FirNamedReference, data: Nothing?) {
         visitNamedReference(namedReference)
     }
 
+    open fun visitNamedReference(namedReference: FirNamedReference) {
+        visitElement(namedReference)
+    }
+
     final override fun visitNamedReferenceWithCandidateBase(namedReferenceWithCandidateBase: FirNamedReferenceWithCandidateBase, data: Nothing?) {
         visitNamedReferenceWithCandidateBase(namedReferenceWithCandidateBase)
     }
 
+    open fun visitNamedReferenceWithCandidateBase(namedReferenceWithCandidateBase: FirNamedReferenceWithCandidateBase) {
+        visitElement(namedReferenceWithCandidateBase)
+    }
+
     final override fun visitErrorNamedReference(errorNamedReference: FirErrorNamedReference, data: Nothing?) {
         visitErrorNamedReference(errorNamedReference)
     }
 
+    open fun visitErrorNamedReference(errorNamedReference: FirErrorNamedReference) {
+        visitElement(errorNamedReference)
+    }
+
     final override fun visitFromMissingDependenciesNamedReference(fromMissingDependenciesNamedReference: FirFromMissingDependenciesNamedReference, data: Nothing?) {
         visitFromMissingDependenciesNamedReference(fromMissingDependenciesNamedReference)
     }
 
+    open fun visitFromMissingDependenciesNamedReference(fromMissingDependenciesNamedReference: FirFromMissingDependenciesNamedReference) {
+        visitElement(fromMissingDependenciesNamedReference)
+    }
+
     final override fun visitSuperReference(superReference: FirSuperReference, data: Nothing?) {
         visitSuperReference(superReference)
     }
 
+    open fun visitSuperReference(superReference: FirSuperReference) {
+        visitElement(superReference)
+    }
+
     final override fun visitThisReference(thisReference: FirThisReference, data: Nothing?) {
         visitThisReference(thisReference)
     }
 
+    open fun visitThisReference(thisReference: FirThisReference) {
+        visitElement(thisReference)
+    }
+
     final override fun visitControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference, data: Nothing?) {
         visitControlFlowGraphReference(controlFlowGraphReference)
     }
 
+    open fun visitControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference) {
+        visitElement(controlFlowGraphReference)
+    }
+
     final override fun visitResolvedNamedReference(resolvedNamedReference: FirResolvedNamedReference, data: Nothing?) {
         visitResolvedNamedReference(resolvedNamedReference)
     }
 
+    open fun visitResolvedNamedReference(resolvedNamedReference: FirResolvedNamedReference) {
+        visitElement(resolvedNamedReference)
+    }
+
     final override fun visitResolvedErrorReference(resolvedErrorReference: FirResolvedErrorReference, data: Nothing?) {
         visitResolvedErrorReference(resolvedErrorReference)
     }
 
+    open fun visitResolvedErrorReference(resolvedErrorReference: FirResolvedErrorReference) {
+        visitElement(resolvedErrorReference)
+    }
+
     final override fun visitDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference, data: Nothing?) {
         visitDelegateFieldReference(delegateFieldReference)
     }
 
+    open fun visitDelegateFieldReference(delegateFieldReference: FirDelegateFieldReference) {
+        visitElement(delegateFieldReference)
+    }
+
     final override fun visitBackingFieldReference(backingFieldReference: FirBackingFieldReference, data: Nothing?) {
         visitBackingFieldReference(backingFieldReference)
     }
 
+    open fun visitBackingFieldReference(backingFieldReference: FirBackingFieldReference) {
+        visitElement(backingFieldReference)
+    }
+
     final override fun visitResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference, data: Nothing?) {
         visitResolvedCallableReference(resolvedCallableReference)
     }
 
+    open fun visitResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference) {
+        visitElement(resolvedCallableReference)
+    }
+
     final override fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef, data: Nothing?) {
         visitResolvedTypeRef(resolvedTypeRef)
     }
 
+    open fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef) {
+        visitElement(resolvedTypeRef)
+    }
+
     final override fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: Nothing?) {
         visitErrorTypeRef(errorTypeRef)
     }
 
+    open fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef) {
+        visitElement(errorTypeRef)
+    }
+
     final override fun visitTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability, data: Nothing?) {
         visitTypeRefWithNullability(typeRefWithNullability)
     }
 
+    open fun visitTypeRefWithNullability(typeRefWithNullability: FirTypeRefWithNullability) {
+        visitElement(typeRefWithNullability)
+    }
+
     final override fun visitUserTypeRef(userTypeRef: FirUserTypeRef, data: Nothing?) {
         visitUserTypeRef(userTypeRef)
     }
 
+    open fun visitUserTypeRef(userTypeRef: FirUserTypeRef) {
+        visitElement(userTypeRef)
+    }
+
     final override fun visitDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef, data: Nothing?) {
         visitDynamicTypeRef(dynamicTypeRef)
     }
 
+    open fun visitDynamicTypeRef(dynamicTypeRef: FirDynamicTypeRef) {
+        visitElement(dynamicTypeRef)
+    }
+
     final override fun visitFunctionTypeRef(functionTypeRef: FirFunctionTypeRef, data: Nothing?) {
         visitFunctionTypeRef(functionTypeRef)
     }
 
+    open fun visitFunctionTypeRef(functionTypeRef: FirFunctionTypeRef) {
+        visitElement(functionTypeRef)
+    }
+
     final override fun visitIntersectionTypeRef(intersectionTypeRef: FirIntersectionTypeRef, data: Nothing?) {
         visitIntersectionTypeRef(intersectionTypeRef)
     }
 
+    open fun visitIntersectionTypeRef(intersectionTypeRef: FirIntersectionTypeRef) {
+        visitElement(intersectionTypeRef)
+    }
+
     final override fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: Nothing?) {
         visitImplicitTypeRef(implicitTypeRef)
     }
 
+    open fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef) {
+        visitElement(implicitTypeRef)
+    }
+
     final override fun visitContractElementDeclaration(contractElementDeclaration: FirContractElementDeclaration, data: Nothing?) {
         visitContractElementDeclaration(contractElementDeclaration)
     }
 
+    open fun visitContractElementDeclaration(contractElementDeclaration: FirContractElementDeclaration) {
+        visitElement(contractElementDeclaration)
+    }
+
     final override fun visitEffectDeclaration(effectDeclaration: FirEffectDeclaration, data: Nothing?) {
         visitEffectDeclaration(effectDeclaration)
     }
 
+    open fun visitEffectDeclaration(effectDeclaration: FirEffectDeclaration) {
+        visitElement(effectDeclaration)
+    }
+
     final override fun visitContractDescription(contractDescription: FirContractDescription, data: Nothing?) {
         visitContractDescription(contractDescription)
     }
 
+    open fun visitContractDescription(contractDescription: FirContractDescription) {
+        visitElement(contractDescription)
+    }
+
     final override fun visitLegacyRawContractDescription(legacyRawContractDescription: FirLegacyRawContractDescription, data: Nothing?) {
         visitLegacyRawContractDescription(legacyRawContractDescription)
     }
 
+    open fun visitLegacyRawContractDescription(legacyRawContractDescription: FirLegacyRawContractDescription) {
+        visitElement(legacyRawContractDescription)
+    }
+
     final override fun visitRawContractDescription(rawContractDescription: FirRawContractDescription, data: Nothing?) {
         visitRawContractDescription(rawContractDescription)
     }
 
+    open fun visitRawContractDescription(rawContractDescription: FirRawContractDescription) {
+        visitElement(rawContractDescription)
+    }
+
     final override fun visitResolvedContractDescription(resolvedContractDescription: FirResolvedContractDescription, data: Nothing?) {
         visitResolvedContractDescription(resolvedContractDescription)
     }
 
+    open fun visitResolvedContractDescription(resolvedContractDescription: FirResolvedContractDescription) {
+        visitElement(resolvedContractDescription)
+    }
 }
diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt
index a8fcab6..c553b69 100644
--- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt
+++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt
@@ -731,6 +731,10 @@
             +field("partiallyResolvedTypeRef", typeRef, nullable = true).withTransform()
         }
 
+        resolvedErrorReference.configure {
+            element.customParentInVisitor = resolvedNamedReference
+        }
+
         intersectionTypeRef.configure {
             +field("leftType", typeRef)
             +field("rightType", typeRef)
diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt
index 1e6c616..dff731b 100644
--- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt
+++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt
@@ -15,6 +15,7 @@
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.fir.tree.generator.context.generatedType
 import org.jetbrains.kotlin.fir.tree.generator.context.type
+import org.jetbrains.kotlin.fir.tree.generator.printer.VISITOR_PACKAGE
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.ConeErrorType
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
@@ -108,3 +109,9 @@
 val errorTypeRefImplType = type("fir.types.impl", "FirErrorTypeRefImpl")
 
 val annotationResolvePhaseType = generatedType("expressions", "FirAnnotationResolvePhase")
+
+val firVisitorType = generatedType("visitors", "FirVisitor")
+val firVisitorVoidType = generatedType("visitors", "FirVisitorVoid")
+val firDefaultVisitorType = generatedType("visitors", "FirDefaultVisitor")
+val firDefaultVisitorVoidType = generatedType("visitors", "FirDefaultVisitorVoid")
+val firTransformerType = generatedType("visitors", "FirTransformer")
diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/model/Element.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/model/Element.kt
index 656d93a..95ee000 100644
--- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/model/Element.kt
+++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/model/Element.kt
@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.fir.tree.generator.model
 
 import org.jetbrains.kotlin.fir.tree.generator.printer.BASE_PACKAGE
+import org.jetbrains.kotlin.fir.tree.generator.printer.safeDecapitalizedName
 import org.jetbrains.kotlin.fir.tree.generator.util.set
 import org.jetbrains.kotlin.generators.tree.*
 import org.jetbrains.kotlin.generators.tree.ElementOrRef as GenericElementOrRef
@@ -38,7 +39,7 @@
 
     override val fields = mutableSetOf<Field>()
     override val type: String = "Fir$name"
-    override val packageName: String = BASE_PACKAGE + kind.packageName.let { if (it.isBlank()) it else "." + it }
+    override val packageName: String = kind.fullPackageName
     override val fullQualifiedName: String get() = super.fullQualifiedName!!
 
     override val elementParents = mutableListOf<ElementRef>()
@@ -82,6 +83,17 @@
     var baseTransformerType: Element? = null
     val transformerType: Element get() = baseTransformerType ?: this
 
+    override val visitFunctionName: String
+        get() = "visit$name"
+
+    override val visitorParameterName: String
+        get() = safeDecapitalizedName
+
+    var customParentInVisitor: Element? = null
+
+    override val parentInVisitor: Element?
+        get() = customParentInVisitor ?: elementParents.singleOrNull()?.element?.takeIf { !it.isRootElement }
+
     var doesNotNeedImplementation: Boolean = false
 
     val needTransformOtherChildren: Boolean get() = _needTransformOtherChildren || elementParents.any { it.element.needTransformOtherChildren }
@@ -178,7 +190,16 @@
         TypeRef("types"),
         Contracts("contracts"),
         Diagnostics("diagnostics"),
-        Other("")
+        Other("");
+
+        val fullPackageName: String
+            get() = buildString {
+                append(BASE_PACKAGE)
+                if (packageName.isNotBlank()) {
+                    append(".")
+                    append(packageName)
+                }
+            }
     }
 }
 
diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/element.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/element.kt
index 5c04c9f..b9157f3 100644
--- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/element.kt
+++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/element.kt
@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.fir.tree.generator.printer
 
 import org.jetbrains.kotlin.fir.tree.generator.context.AbstractFirTreeBuilder
+import org.jetbrains.kotlin.fir.tree.generator.firVisitorType
 import org.jetbrains.kotlin.fir.tree.generator.model.Element
 import org.jetbrains.kotlin.fir.tree.generator.model.Field
 import org.jetbrains.kotlin.fir.tree.generator.util.get
@@ -19,7 +20,7 @@
     override val fieldPrinter = FieldPrinter(printer)
 
     override val visitorType: ClassRef<*>
-        get() = type(VISITOR_PACKAGE, "FirVisitor", TypeKind.Class)
+        get() = firVisitorType
 
     override val transformerType: ClassRef<*>
         get() = type(VISITOR_PACKAGE, "FirTransformer", TypeKind.Class)
diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/visitor.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/visitor.kt
index d356d7f..e4eef0b 100644
--- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/visitor.kt
+++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/visitor.kt
@@ -5,153 +5,120 @@
 
 package org.jetbrains.kotlin.fir.tree.generator.printer
 
-import org.jetbrains.kotlin.fir.tree.generator.FirTreeBuilder
+import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.fir.tree.generator.*
 import org.jetbrains.kotlin.fir.tree.generator.context.AbstractFirTreeBuilder
 import org.jetbrains.kotlin.fir.tree.generator.model.Element
+import org.jetbrains.kotlin.fir.tree.generator.model.Field
 import org.jetbrains.kotlin.generators.tree.*
 import org.jetbrains.kotlin.utils.SmartPrinter
-import org.jetbrains.kotlin.utils.withIndent
 import java.io.File
 
-private val elementsWithMultipleSupertypesForDefaultVisitor = mapOf(
-    FirTreeBuilder.resolvedErrorReference to FirTreeBuilder.resolvedNamedReference
-)
+private class VisitorPrinter(
+    printer: SmartPrinter,
+    visitSuperTypeByDefault: Boolean,
+) : AbstractVisitorPrinter<Element, Field>(printer, visitSuperTypeByDefault) {
 
-private fun Element.isAcceptableForDefaultVisiting(): Boolean {
-    if (this == AbstractFirTreeBuilder.baseFirElement) return false
-    val hasSingleSupertype = elementParents.size == 1 && !elementParents[0].element.isRootElement
-    return hasSingleSupertype || this in elementsWithMultipleSupertypesForDefaultVisitor
-}
+    override val visitorType: ClassRef<*> = if (visitSuperTypeByDefault) firDefaultVisitorType else firVisitorType
 
-private fun Element.getNameOfSupertypeForDefaultVisiting(): String {
-    val parentForDefaultVisiting =
-        elementParents.singleOrNull()?.element ?: elementsWithMultipleSupertypesForDefaultVisitor.getValue(this)
-    return parentForDefaultVisiting.name
-}
+    override val visitorTypeParameters: List<TypeVariable>
+        get() = listOf(resultTypeVariable, dataTypeVariable)
 
-fun printVisitor(elements: List<Element>, generationPath: File, visitSuperTypeByDefault: Boolean): GeneratedFile {
-    val className = if (visitSuperTypeByDefault) "FirDefaultVisitor" else "FirVisitor"
-    val dir = File(generationPath, VISITOR_PACKAGE.replace(".", "/"))
-    val file = File(dir, "$className.kt")
-    val stringBuilder = StringBuilder()
-    SmartPrinter(stringBuilder).apply {
-        printCopyright()
-        println("package $VISITOR_PACKAGE")
-        println()
-        elements.forEach { println("import ${it.fullQualifiedName}") }
-        println()
-        printGeneratedMessage()
+    override val visitorSuperType: ClassRef<PositionTypeParameterRef>? =
+        firVisitorType.takeIf { visitSuperTypeByDefault }?.withArgs(resultTypeVariable, dataTypeVariable)
 
-        print("abstract class $className<out R, in D> ")
-        if (visitSuperTypeByDefault) {
-            print(": FirVisitor<R, D>() ")
-        }
-        println("{")
+    override val allowTypeParametersInVisitorMethods: Boolean
+        get() = true
 
-        pushIndent()
-        if (!visitSuperTypeByDefault) {
-            println("abstract fun visitElement(element: FirElement, data: D): R\n")
-        }
-        for (element in elements) {
-            if (element == AbstractFirTreeBuilder.baseFirElement) continue
-            if (visitSuperTypeByDefault && !element.isAcceptableForDefaultVisiting()) continue
-            with(element) {
-                val varName = safeDecapitalizedName
-                if (visitSuperTypeByDefault) {
-                    print("override")
-                } else {
-                    print("open")
-                }
-                print(" fun ${typeParameters(end = " ")}visit$name($varName: $typeWithArguments, data: D): R${multipleUpperBoundsList()} = visit")
-                if (visitSuperTypeByDefault) {
-                    print(element.getNameOfSupertypeForDefaultVisiting())
-                } else {
-                    print("Element")
-                }
-                println("($varName, data)")
-                println()
-            }
-        }
-        popIndent()
-        println("}")
+    override fun parentInVisitor(element: Element): Element? = when {
+        element.isRootElement -> null
+        visitSuperTypeByDefault -> element.parentInVisitor
+        else -> AbstractFirTreeBuilder.baseFirElement
     }
-    return GeneratedFile(file, stringBuilder.toString())
 }
 
+fun printVisitor(elements: List<Element>, generationPath: File, visitSuperTypeByDefault: Boolean) =
+    printVisitorCommon(elements, generationPath) { VisitorPrinter(it, visitSuperTypeByDefault) }
 
-fun printVisitorVoid(elements: List<Element>, generationPath: File): GeneratedFile {
-    val dir = File(generationPath, VISITOR_PACKAGE.replace(".", "/"))
-    val file = File(dir, "FirVisitorVoid.kt")
-    val stringBuilder = StringBuilder()
-    SmartPrinter(stringBuilder).apply {
-        printCopyright()
-        println("package $VISITOR_PACKAGE")
-        println()
-        elements.forEach { println("import ${it.fullQualifiedName}") }
-        println()
-        printGeneratedMessage()
+private class VisitorVoidPrinter(
+    printer: SmartPrinter,
+) : AbstractVisitorVoidPrinter<Element, Field>(printer, visitSuperTypeByDefault = false) {
 
-        println("abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {")
+    override val visitorType: ClassRef<*>
+        get() = firVisitorVoidType
 
-        withIndent {
-            println("abstract fun visitElement(element: FirElement)")
+    override val visitorSuperClass: ClassRef<PositionTypeParameterRef>
+        get() = firVisitorType
+
+    override val allowTypeParametersInVisitorMethods: Boolean
+        get() = true
+
+    override val useAbstractMethodForRootElement: Boolean
+        get() = true
+
+    override val overriddenVisitMethodsAreFinal: Boolean
+        get() = true
+
+    override fun parentInVisitor(element: Element): Element = AbstractFirTreeBuilder.baseFirElement
+}
+
+fun printVisitorVoid(elements: List<Element>, generationPath: File) =
+    printVisitorCommon(elements, generationPath, ::VisitorVoidPrinter)
+
+private class DefaultVisitorVoidPrinter(
+    printer: SmartPrinter,
+) : AbstractVisitorPrinter<Element, Field>(printer, visitSuperTypeByDefault = true) {
+
+    override val visitorType: ClassRef<*>
+        get() = firDefaultVisitorVoidType
+
+    override val visitorTypeParameters: List<TypeVariable>
+        get() = emptyList()
+
+    override val visitorSuperType: ClassRef<PositionTypeParameterRef>
+        get() = firVisitorVoidType
+
+    override val allowTypeParametersInVisitorMethods: Boolean
+        get() = true
+
+    override fun printMethodsForElement(element: Element) {
+        printer.run {
+            printVisitMethodDeclaration(
+                element,
+                additionalParameters = emptyList(),
+                returnType = StandardTypes.unit,
+                modality = Modality.OPEN,
+                override = true,
+            )
+            println(" = ", element.parentInVisitor!!.visitFunctionName, "(", element.visitorParameterName, ")")
             println()
-            for (element in elements) {
-                if (element == AbstractFirTreeBuilder.baseFirElement) continue
-                with(element) {
-                    val varName = safeDecapitalizedName
-                    println("open fun ${typeParameters(end = " ")}visit$name($varName: $typeWithArguments)${multipleUpperBoundsList()} {")
-                    withIndent {
-                        println("visitElement($varName)")
-                    }
-                    println("}")
-                    println()
-                }
-            }
-
-            for (element in elements) {
-                with(element) {
-                    val varName = safeDecapitalizedName
-                    println("final override fun ${typeParameters(end = " ")}visit$name($varName: $typeWithArguments, data: Nothing?)${multipleUpperBoundsList()} {")
-                    withIndent {
-                        println("visit$name($varName)")
-                    }
-                    println("}")
-                    println()
-                }
-            }
         }
-        println("}")
     }
-    return GeneratedFile(file, stringBuilder.toString())
 }
 
-fun printDefaultVisitorVoid(elements: List<Element>, generationPath: File): GeneratedFile {
-    val className = "FirDefaultVisitorVoid"
-    val dir = File(generationPath, VISITOR_PACKAGE.replace(".", "/"))
-    val file = File(dir, "$className.kt")
+fun printDefaultVisitorVoid(elements: List<Element>, generationPath: File) =
+    printVisitorCommon(elements, generationPath, ::DefaultVisitorVoidPrinter)
+
+private fun printVisitorCommon(
+    elements: List<Element>,
+    generationPath: File,
+    makePrinter: (SmartPrinter) -> AbstractVisitorPrinter<Element, Field>,
+): GeneratedFile {
     val stringBuilder = StringBuilder()
-    SmartPrinter(stringBuilder).apply {
+    val smartPrinter = SmartPrinter(stringBuilder)
+    val printer = makePrinter(smartPrinter)
+    val dir = File(generationPath, printer.visitorType.packageName.replace(".", "/"))
+    val file = File(dir, "${printer.visitorType.simpleName}.kt")
+    smartPrinter.run {
         printCopyright()
         println("package $VISITOR_PACKAGE")
         println()
-        elements.forEach { println("import ${it.fullQualifiedName}") }
+        Element.Kind.entries.map { it.fullPackageName }.sorted().forEach {
+            println("import ", it, ".*")
+        }
         println()
         printGeneratedMessage()
-
-        println("abstract class $className : FirVisitorVoid() {")
-
-        pushIndent()
-        for (element in elements) {
-            if (!element.isAcceptableForDefaultVisiting()) continue
-            with(element) {
-                val varName = safeDecapitalizedName
-                println("override fun ${typeParameters(end = " ")}visit$name($varName: $typeWithArguments)${multipleUpperBoundsList()} = visit${element.getNameOfSupertypeForDefaultVisiting()}($varName)")
-                println()
-            }
-        }
-        popIndent()
-        println("}")
+        printer.printVisitor(elements)
     }
     return GeneratedFile(file, stringBuilder.toString())
-}
+}
\ No newline at end of file
diff --git a/compiler/ir/ir.tree/build.gradle.kts b/compiler/ir/ir.tree/build.gradle.kts
index 0ebd35c..51d0cde 100644
--- a/compiler/ir/ir.tree/build.gradle.kts
+++ b/compiler/ir/ir.tree/build.gradle.kts
@@ -36,7 +36,7 @@
 
 val generationRoot = projectDir.resolve("gen")
 
-val generateTree by tasks.registering(NoDebugJavaExec::class) {
+val generateTree by tasks.registering(JavaExec::class) {
 
     val generatorRoot = "$projectDir/tree-generator/src/"
 
diff --git a/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrElementVisitor.kt b/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrElementVisitor.kt
index ee4804a..2905b15 100644
--- a/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrElementVisitor.kt
+++ b/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrElementVisitor.kt
@@ -8,153 +8,55 @@
 
 package org.jetbrains.kotlin.ir.visitors
 
-import org.jetbrains.kotlin.ir.IrElement
-import org.jetbrains.kotlin.ir.declarations.IrAnonymousInitializer
-import org.jetbrains.kotlin.ir.declarations.IrClass
-import org.jetbrains.kotlin.ir.declarations.IrConstructor
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationBase
-import org.jetbrains.kotlin.ir.declarations.IrEnumEntry
-import org.jetbrains.kotlin.ir.declarations.IrErrorDeclaration
-import org.jetbrains.kotlin.ir.declarations.IrExternalPackageFragment
-import org.jetbrains.kotlin.ir.declarations.IrField
-import org.jetbrains.kotlin.ir.declarations.IrFile
-import org.jetbrains.kotlin.ir.declarations.IrFunction
-import org.jetbrains.kotlin.ir.declarations.IrLocalDelegatedProperty
-import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
-import org.jetbrains.kotlin.ir.declarations.IrPackageFragment
-import org.jetbrains.kotlin.ir.declarations.IrProperty
-import org.jetbrains.kotlin.ir.declarations.IrScript
-import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
-import org.jetbrains.kotlin.ir.declarations.IrTypeAlias
-import org.jetbrains.kotlin.ir.declarations.IrTypeParameter
-import org.jetbrains.kotlin.ir.declarations.IrValueParameter
-import org.jetbrains.kotlin.ir.declarations.IrVariable
-import org.jetbrains.kotlin.ir.expressions.IrBlock
-import org.jetbrains.kotlin.ir.expressions.IrBlockBody
-import org.jetbrains.kotlin.ir.expressions.IrBody
-import org.jetbrains.kotlin.ir.expressions.IrBranch
-import org.jetbrains.kotlin.ir.expressions.IrBreak
-import org.jetbrains.kotlin.ir.expressions.IrBreakContinue
-import org.jetbrains.kotlin.ir.expressions.IrCall
-import org.jetbrains.kotlin.ir.expressions.IrCallableReference
-import org.jetbrains.kotlin.ir.expressions.IrCatch
-import org.jetbrains.kotlin.ir.expressions.IrClassReference
-import org.jetbrains.kotlin.ir.expressions.IrComposite
-import org.jetbrains.kotlin.ir.expressions.IrConst
-import org.jetbrains.kotlin.ir.expressions.IrConstantArray
-import org.jetbrains.kotlin.ir.expressions.IrConstantObject
-import org.jetbrains.kotlin.ir.expressions.IrConstantPrimitive
-import org.jetbrains.kotlin.ir.expressions.IrConstantValue
-import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
-import org.jetbrains.kotlin.ir.expressions.IrContainerExpression
-import org.jetbrains.kotlin.ir.expressions.IrContinue
-import org.jetbrains.kotlin.ir.expressions.IrDeclarationReference
-import org.jetbrains.kotlin.ir.expressions.IrDelegatingConstructorCall
-import org.jetbrains.kotlin.ir.expressions.IrDoWhileLoop
-import org.jetbrains.kotlin.ir.expressions.IrDynamicExpression
-import org.jetbrains.kotlin.ir.expressions.IrDynamicMemberExpression
-import org.jetbrains.kotlin.ir.expressions.IrDynamicOperatorExpression
-import org.jetbrains.kotlin.ir.expressions.IrElseBranch
-import org.jetbrains.kotlin.ir.expressions.IrEnumConstructorCall
-import org.jetbrains.kotlin.ir.expressions.IrErrorCallExpression
-import org.jetbrains.kotlin.ir.expressions.IrErrorExpression
-import org.jetbrains.kotlin.ir.expressions.IrExpression
-import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
-import org.jetbrains.kotlin.ir.expressions.IrFieldAccessExpression
-import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression
-import org.jetbrains.kotlin.ir.expressions.IrFunctionExpression
-import org.jetbrains.kotlin.ir.expressions.IrFunctionReference
-import org.jetbrains.kotlin.ir.expressions.IrGetClass
-import org.jetbrains.kotlin.ir.expressions.IrGetEnumValue
-import org.jetbrains.kotlin.ir.expressions.IrGetField
-import org.jetbrains.kotlin.ir.expressions.IrGetObjectValue
-import org.jetbrains.kotlin.ir.expressions.IrGetSingletonValue
-import org.jetbrains.kotlin.ir.expressions.IrGetValue
-import org.jetbrains.kotlin.ir.expressions.IrInstanceInitializerCall
-import org.jetbrains.kotlin.ir.expressions.IrLocalDelegatedPropertyReference
-import org.jetbrains.kotlin.ir.expressions.IrLoop
-import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression
-import org.jetbrains.kotlin.ir.expressions.IrPropertyReference
-import org.jetbrains.kotlin.ir.expressions.IrRawFunctionReference
-import org.jetbrains.kotlin.ir.expressions.IrReturn
-import org.jetbrains.kotlin.ir.expressions.IrSetField
-import org.jetbrains.kotlin.ir.expressions.IrSetValue
-import org.jetbrains.kotlin.ir.expressions.IrSpreadElement
-import org.jetbrains.kotlin.ir.expressions.IrStringConcatenation
-import org.jetbrains.kotlin.ir.expressions.IrSuspendableExpression
-import org.jetbrains.kotlin.ir.expressions.IrSuspensionPoint
-import org.jetbrains.kotlin.ir.expressions.IrSyntheticBody
-import org.jetbrains.kotlin.ir.expressions.IrThrow
-import org.jetbrains.kotlin.ir.expressions.IrTry
-import org.jetbrains.kotlin.ir.expressions.IrTypeOperatorCall
-import org.jetbrains.kotlin.ir.expressions.IrValueAccessExpression
-import org.jetbrains.kotlin.ir.expressions.IrVararg
-import org.jetbrains.kotlin.ir.expressions.IrWhen
-import org.jetbrains.kotlin.ir.expressions.IrWhileLoop
+import org.jetbrains.kotlin.ir.*
+import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.expressions.*
 
 interface IrElementVisitor<out R, in D> {
+
     fun visitElement(element: IrElement, data: D): R
 
-    fun visitDeclaration(declaration: IrDeclarationBase, data: D): R =
-            visitElement(declaration, data)
+    fun visitDeclaration(declaration: IrDeclarationBase, data: D): R = visitElement(declaration, data)
 
-    fun visitValueParameter(declaration: IrValueParameter, data: D): R =
-            visitDeclaration(declaration, data)
+    fun visitValueParameter(declaration: IrValueParameter, data: D): R = visitDeclaration(declaration, data)
 
     fun visitClass(declaration: IrClass, data: D): R = visitDeclaration(declaration, data)
 
-    fun visitAnonymousInitializer(declaration: IrAnonymousInitializer, data: D): R =
-            visitDeclaration(declaration, data)
+    fun visitAnonymousInitializer(declaration: IrAnonymousInitializer, data: D): R = visitDeclaration(declaration, data)
 
-    fun visitTypeParameter(declaration: IrTypeParameter, data: D): R =
-            visitDeclaration(declaration, data)
+    fun visitTypeParameter(declaration: IrTypeParameter, data: D): R = visitDeclaration(declaration, data)
 
-    fun visitFunction(declaration: IrFunction, data: D): R = visitDeclaration(declaration,
-            data)
+    fun visitFunction(declaration: IrFunction, data: D): R = visitDeclaration(declaration, data)
 
-    fun visitConstructor(declaration: IrConstructor, data: D): R =
-            visitFunction(declaration, data)
+    fun visitConstructor(declaration: IrConstructor, data: D): R = visitFunction(declaration, data)
 
-    fun visitEnumEntry(declaration: IrEnumEntry, data: D): R =
-            visitDeclaration(declaration, data)
+    fun visitEnumEntry(declaration: IrEnumEntry, data: D): R = visitDeclaration(declaration, data)
 
-    fun visitErrorDeclaration(declaration: IrErrorDeclaration, data: D): R =
-            visitDeclaration(declaration, data)
+    fun visitErrorDeclaration(declaration: IrErrorDeclaration, data: D): R = visitDeclaration(declaration, data)
 
     fun visitField(declaration: IrField, data: D): R = visitDeclaration(declaration, data)
 
-    fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty, data: D): R =
-            visitDeclaration(declaration, data)
+    fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty, data: D): R = visitDeclaration(declaration, data)
 
-    fun visitModuleFragment(declaration: IrModuleFragment, data: D): R =
-            visitElement(declaration, data)
+    fun visitModuleFragment(declaration: IrModuleFragment, data: D): R = visitElement(declaration, data)
 
-    fun visitProperty(declaration: IrProperty, data: D): R = visitDeclaration(declaration,
-            data)
+    fun visitProperty(declaration: IrProperty, data: D): R = visitDeclaration(declaration, data)
 
-    fun visitScript(declaration: IrScript, data: D): R = visitDeclaration(declaration,
-            data)
+    fun visitScript(declaration: IrScript, data: D): R = visitDeclaration(declaration, data)
 
-    fun visitSimpleFunction(declaration: IrSimpleFunction, data: D): R =
-            visitFunction(declaration, data)
+    fun visitSimpleFunction(declaration: IrSimpleFunction, data: D): R = visitFunction(declaration, data)
 
-    fun visitTypeAlias(declaration: IrTypeAlias, data: D): R =
-            visitDeclaration(declaration, data)
+    fun visitTypeAlias(declaration: IrTypeAlias, data: D): R = visitDeclaration(declaration, data)
 
-    fun visitVariable(declaration: IrVariable, data: D): R = visitDeclaration(declaration,
-            data)
+    fun visitVariable(declaration: IrVariable, data: D): R = visitDeclaration(declaration, data)
 
-    fun visitPackageFragment(declaration: IrPackageFragment, data: D): R =
-            visitElement(declaration, data)
+    fun visitPackageFragment(declaration: IrPackageFragment, data: D): R = visitElement(declaration, data)
 
-    fun visitExternalPackageFragment(declaration: IrExternalPackageFragment, data: D): R =
-            visitPackageFragment(declaration, data)
+    fun visitExternalPackageFragment(declaration: IrExternalPackageFragment, data: D): R = visitPackageFragment(declaration, data)
 
-    fun visitFile(declaration: IrFile, data: D): R = visitPackageFragment(declaration,
-            data)
+    fun visitFile(declaration: IrFile, data: D): R = visitPackageFragment(declaration, data)
 
-    fun visitExpression(expression: IrExpression, data: D): R = visitElement(expression,
-            data)
+    fun visitExpression(expression: IrExpression, data: D): R = visitElement(expression, data)
 
     fun visitBody(body: IrBody, data: D): R = visitElement(body, data)
 
@@ -162,38 +64,27 @@
 
     fun visitBlockBody(body: IrBlockBody, data: D): R = visitBody(body, data)
 
-    fun visitDeclarationReference(expression: IrDeclarationReference, data: D): R =
-            visitExpression(expression, data)
+    fun visitDeclarationReference(expression: IrDeclarationReference, data: D): R = visitExpression(expression, data)
 
-    fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: D): R =
-            visitDeclarationReference(expression, data)
+    fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: D): R = visitDeclarationReference(expression, data)
 
-    fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: D): R =
-            visitMemberAccess(expression, data)
+    fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: D): R = visitMemberAccess(expression, data)
 
-    fun visitConstructorCall(expression: IrConstructorCall, data: D): R =
-            visitFunctionAccess(expression, data)
+    fun visitConstructorCall(expression: IrConstructorCall, data: D): R = visitFunctionAccess(expression, data)
 
-    fun visitSingletonReference(expression: IrGetSingletonValue, data: D): R =
-            visitDeclarationReference(expression, data)
+    fun visitSingletonReference(expression: IrGetSingletonValue, data: D): R = visitDeclarationReference(expression, data)
 
-    fun visitGetObjectValue(expression: IrGetObjectValue, data: D): R =
-            visitSingletonReference(expression, data)
+    fun visitGetObjectValue(expression: IrGetObjectValue, data: D): R = visitSingletonReference(expression, data)
 
-    fun visitGetEnumValue(expression: IrGetEnumValue, data: D): R =
-            visitSingletonReference(expression, data)
+    fun visitGetEnumValue(expression: IrGetEnumValue, data: D): R = visitSingletonReference(expression, data)
 
-    fun visitRawFunctionReference(expression: IrRawFunctionReference, data: D): R =
-            visitDeclarationReference(expression, data)
+    fun visitRawFunctionReference(expression: IrRawFunctionReference, data: D): R = visitDeclarationReference(expression, data)
 
-    fun visitContainerExpression(expression: IrContainerExpression, data: D): R =
-            visitExpression(expression, data)
+    fun visitContainerExpression(expression: IrContainerExpression, data: D): R = visitExpression(expression, data)
 
-    fun visitBlock(expression: IrBlock, data: D): R = visitContainerExpression(expression,
-            data)
+    fun visitBlock(expression: IrBlock, data: D): R = visitContainerExpression(expression, data)
 
-    fun visitComposite(expression: IrComposite, data: D): R =
-            visitContainerExpression(expression, data)
+    fun visitComposite(expression: IrComposite, data: D): R = visitContainerExpression(expression, data)
 
     fun visitSyntheticBody(body: IrSyntheticBody, data: D): R = visitBody(body, data)
 
@@ -205,73 +96,51 @@
 
     fun visitCall(expression: IrCall, data: D): R = visitFunctionAccess(expression, data)
 
-    fun visitCallableReference(expression: IrCallableReference<*>, data: D): R =
-            visitMemberAccess(expression, data)
+    fun visitCallableReference(expression: IrCallableReference<*>, data: D): R = visitMemberAccess(expression, data)
 
-    fun visitFunctionReference(expression: IrFunctionReference, data: D): R =
-            visitCallableReference(expression, data)
+    fun visitFunctionReference(expression: IrFunctionReference, data: D): R = visitCallableReference(expression, data)
 
-    fun visitPropertyReference(expression: IrPropertyReference, data: D): R =
-            visitCallableReference(expression, data)
+    fun visitPropertyReference(expression: IrPropertyReference, data: D): R = visitCallableReference(expression, data)
 
-    fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference,
-            data: D): R = visitCallableReference(expression, data)
+    fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference, data: D): R = visitCallableReference(expression, data)
 
-    fun visitClassReference(expression: IrClassReference, data: D): R =
-            visitDeclarationReference(expression, data)
+    fun visitClassReference(expression: IrClassReference, data: D): R = visitDeclarationReference(expression, data)
 
     fun visitConst(expression: IrConst<*>, data: D): R = visitExpression(expression, data)
 
-    fun visitConstantValue(expression: IrConstantValue, data: D): R =
-            visitExpression(expression, data)
+    fun visitConstantValue(expression: IrConstantValue, data: D): R = visitExpression(expression, data)
 
-    fun visitConstantPrimitive(expression: IrConstantPrimitive, data: D): R =
-            visitConstantValue(expression, data)
+    fun visitConstantPrimitive(expression: IrConstantPrimitive, data: D): R = visitConstantValue(expression, data)
 
-    fun visitConstantObject(expression: IrConstantObject, data: D): R =
-            visitConstantValue(expression, data)
+    fun visitConstantObject(expression: IrConstantObject, data: D): R = visitConstantValue(expression, data)
 
-    fun visitConstantArray(expression: IrConstantArray, data: D): R =
-            visitConstantValue(expression, data)
+    fun visitConstantArray(expression: IrConstantArray, data: D): R = visitConstantValue(expression, data)
 
-    fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall, data: D): R
-            = visitFunctionAccess(expression, data)
+    fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall, data: D): R = visitFunctionAccess(expression, data)
 
-    fun visitDynamicExpression(expression: IrDynamicExpression, data: D): R =
-            visitExpression(expression, data)
+    fun visitDynamicExpression(expression: IrDynamicExpression, data: D): R = visitExpression(expression, data)
 
-    fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression, data: D): R
-            = visitDynamicExpression(expression, data)
+    fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression, data: D): R = visitDynamicExpression(expression, data)
 
-    fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression, data: D): R =
-            visitDynamicExpression(expression, data)
+    fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression, data: D): R = visitDynamicExpression(expression, data)
 
-    fun visitEnumConstructorCall(expression: IrEnumConstructorCall, data: D): R =
-            visitFunctionAccess(expression, data)
+    fun visitEnumConstructorCall(expression: IrEnumConstructorCall, data: D): R = visitFunctionAccess(expression, data)
 
-    fun visitErrorExpression(expression: IrErrorExpression, data: D): R =
-            visitExpression(expression, data)
+    fun visitErrorExpression(expression: IrErrorExpression, data: D): R = visitExpression(expression, data)
 
-    fun visitErrorCallExpression(expression: IrErrorCallExpression, data: D): R =
-            visitErrorExpression(expression, data)
+    fun visitErrorCallExpression(expression: IrErrorCallExpression, data: D): R = visitErrorExpression(expression, data)
 
-    fun visitFieldAccess(expression: IrFieldAccessExpression, data: D): R =
-            visitDeclarationReference(expression, data)
+    fun visitFieldAccess(expression: IrFieldAccessExpression, data: D): R = visitDeclarationReference(expression, data)
 
-    fun visitGetField(expression: IrGetField, data: D): R = visitFieldAccess(expression,
-            data)
+    fun visitGetField(expression: IrGetField, data: D): R = visitFieldAccess(expression, data)
 
-    fun visitSetField(expression: IrSetField, data: D): R = visitFieldAccess(expression,
-            data)
+    fun visitSetField(expression: IrSetField, data: D): R = visitFieldAccess(expression, data)
 
-    fun visitFunctionExpression(expression: IrFunctionExpression, data: D): R =
-            visitExpression(expression, data)
+    fun visitFunctionExpression(expression: IrFunctionExpression, data: D): R = visitExpression(expression, data)
 
-    fun visitGetClass(expression: IrGetClass, data: D): R = visitExpression(expression,
-            data)
+    fun visitGetClass(expression: IrGetClass, data: D): R = visitExpression(expression, data)
 
-    fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall, data: D): R =
-            visitExpression(expression, data)
+    fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall, data: D): R = visitExpression(expression, data)
 
     fun visitLoop(loop: IrLoop, data: D): R = visitExpression(loop, data)
 
@@ -281,14 +150,11 @@
 
     fun visitReturn(expression: IrReturn, data: D): R = visitExpression(expression, data)
 
-    fun visitStringConcatenation(expression: IrStringConcatenation, data: D): R =
-            visitExpression(expression, data)
+    fun visitStringConcatenation(expression: IrStringConcatenation, data: D): R = visitExpression(expression, data)
 
-    fun visitSuspensionPoint(expression: IrSuspensionPoint, data: D): R =
-            visitExpression(expression, data)
+    fun visitSuspensionPoint(expression: IrSuspensionPoint, data: D): R = visitExpression(expression, data)
 
-    fun visitSuspendableExpression(expression: IrSuspendableExpression, data: D): R =
-            visitExpression(expression, data)
+    fun visitSuspendableExpression(expression: IrSuspendableExpression, data: D): R = visitExpression(expression, data)
 
     fun visitThrow(expression: IrThrow, data: D): R = visitExpression(expression, data)
 
@@ -296,22 +162,17 @@
 
     fun visitCatch(aCatch: IrCatch, data: D): R = visitElement(aCatch, data)
 
-    fun visitTypeOperator(expression: IrTypeOperatorCall, data: D): R =
-            visitExpression(expression, data)
+    fun visitTypeOperator(expression: IrTypeOperatorCall, data: D): R = visitExpression(expression, data)
 
-    fun visitValueAccess(expression: IrValueAccessExpression, data: D): R =
-            visitDeclarationReference(expression, data)
+    fun visitValueAccess(expression: IrValueAccessExpression, data: D): R = visitDeclarationReference(expression, data)
 
-    fun visitGetValue(expression: IrGetValue, data: D): R = visitValueAccess(expression,
-            data)
+    fun visitGetValue(expression: IrGetValue, data: D): R = visitValueAccess(expression, data)
 
-    fun visitSetValue(expression: IrSetValue, data: D): R = visitValueAccess(expression,
-            data)
+    fun visitSetValue(expression: IrSetValue, data: D): R = visitValueAccess(expression, data)
 
     fun visitVararg(expression: IrVararg, data: D): R = visitExpression(expression, data)
 
-    fun visitSpreadElement(spread: IrSpreadElement, data: D): R = visitElement(spread,
-            data)
+    fun visitSpreadElement(spread: IrSpreadElement, data: D): R = visitElement(spread, data)
 
     fun visitWhen(expression: IrWhen, data: D): R = visitExpression(expression, data)
 
diff --git a/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrElementVisitorVoid.kt b/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrElementVisitorVoid.kt
index 264f3a4..decd9e9 100644
--- a/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrElementVisitorVoid.kt
+++ b/compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrElementVisitorVoid.kt
@@ -8,516 +8,672 @@
 
 package org.jetbrains.kotlin.ir.visitors
 
-import org.jetbrains.kotlin.ir.IrElement
-import org.jetbrains.kotlin.ir.declarations.IrAnonymousInitializer
-import org.jetbrains.kotlin.ir.declarations.IrClass
-import org.jetbrains.kotlin.ir.declarations.IrConstructor
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationBase
-import org.jetbrains.kotlin.ir.declarations.IrEnumEntry
-import org.jetbrains.kotlin.ir.declarations.IrErrorDeclaration
-import org.jetbrains.kotlin.ir.declarations.IrExternalPackageFragment
-import org.jetbrains.kotlin.ir.declarations.IrField
-import org.jetbrains.kotlin.ir.declarations.IrFile
-import org.jetbrains.kotlin.ir.declarations.IrFunction
-import org.jetbrains.kotlin.ir.declarations.IrLocalDelegatedProperty
-import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
-import org.jetbrains.kotlin.ir.declarations.IrPackageFragment
-import org.jetbrains.kotlin.ir.declarations.IrProperty
-import org.jetbrains.kotlin.ir.declarations.IrScript
-import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
-import org.jetbrains.kotlin.ir.declarations.IrTypeAlias
-import org.jetbrains.kotlin.ir.declarations.IrTypeParameter
-import org.jetbrains.kotlin.ir.declarations.IrValueParameter
-import org.jetbrains.kotlin.ir.declarations.IrVariable
-import org.jetbrains.kotlin.ir.expressions.IrBlock
-import org.jetbrains.kotlin.ir.expressions.IrBlockBody
-import org.jetbrains.kotlin.ir.expressions.IrBody
-import org.jetbrains.kotlin.ir.expressions.IrBranch
-import org.jetbrains.kotlin.ir.expressions.IrBreak
-import org.jetbrains.kotlin.ir.expressions.IrBreakContinue
-import org.jetbrains.kotlin.ir.expressions.IrCall
-import org.jetbrains.kotlin.ir.expressions.IrCallableReference
-import org.jetbrains.kotlin.ir.expressions.IrCatch
-import org.jetbrains.kotlin.ir.expressions.IrClassReference
-import org.jetbrains.kotlin.ir.expressions.IrComposite
-import org.jetbrains.kotlin.ir.expressions.IrConst
-import org.jetbrains.kotlin.ir.expressions.IrConstantArray
-import org.jetbrains.kotlin.ir.expressions.IrConstantObject
-import org.jetbrains.kotlin.ir.expressions.IrConstantPrimitive
-import org.jetbrains.kotlin.ir.expressions.IrConstantValue
-import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
-import org.jetbrains.kotlin.ir.expressions.IrContainerExpression
-import org.jetbrains.kotlin.ir.expressions.IrContinue
-import org.jetbrains.kotlin.ir.expressions.IrDeclarationReference
-import org.jetbrains.kotlin.ir.expressions.IrDelegatingConstructorCall
-import org.jetbrains.kotlin.ir.expressions.IrDoWhileLoop
-import org.jetbrains.kotlin.ir.expressions.IrDynamicExpression
-import org.jetbrains.kotlin.ir.expressions.IrDynamicMemberExpression
-import org.jetbrains.kotlin.ir.expressions.IrDynamicOperatorExpression
-import org.jetbrains.kotlin.ir.expressions.IrElseBranch
-import org.jetbrains.kotlin.ir.expressions.IrEnumConstructorCall
-import org.jetbrains.kotlin.ir.expressions.IrErrorCallExpression
-import org.jetbrains.kotlin.ir.expressions.IrErrorExpression
-import org.jetbrains.kotlin.ir.expressions.IrExpression
-import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
-import org.jetbrains.kotlin.ir.expressions.IrFieldAccessExpression
-import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression
-import org.jetbrains.kotlin.ir.expressions.IrFunctionExpression
-import org.jetbrains.kotlin.ir.expressions.IrFunctionReference
-import org.jetbrains.kotlin.ir.expressions.IrGetClass
-import org.jetbrains.kotlin.ir.expressions.IrGetEnumValue
-import org.jetbrains.kotlin.ir.expressions.IrGetField
-import org.jetbrains.kotlin.ir.expressions.IrGetObjectValue
-import org.jetbrains.kotlin.ir.expressions.IrGetSingletonValue
-import org.jetbrains.kotlin.ir.expressions.IrGetValue
-import org.jetbrains.kotlin.ir.expressions.IrInstanceInitializerCall
-import org.jetbrains.kotlin.ir.expressions.IrLocalDelegatedPropertyReference
-import org.jetbrains.kotlin.ir.expressions.IrLoop
-import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression
-import org.jetbrains.kotlin.ir.expressions.IrPropertyReference
-import org.jetbrains.kotlin.ir.expressions.IrRawFunctionReference
-import org.jetbrains.kotlin.ir.expressions.IrReturn
-import org.jetbrains.kotlin.ir.expressions.IrSetField
-import org.jetbrains.kotlin.ir.expressions.IrSetValue
-import org.jetbrains.kotlin.ir.expressions.IrSpreadElement
-import org.jetbrains.kotlin.ir.expressions.IrStringConcatenation
-import org.jetbrains.kotlin.ir.expressions.IrSuspendableExpression
-import org.jetbrains.kotlin.ir.expressions.IrSuspensionPoint
-import org.jetbrains.kotlin.ir.expressions.IrSyntheticBody
-import org.jetbrains.kotlin.ir.expressions.IrThrow
-import org.jetbrains.kotlin.ir.expressions.IrTry
-import org.jetbrains.kotlin.ir.expressions.IrTypeOperatorCall
-import org.jetbrains.kotlin.ir.expressions.IrValueAccessExpression
-import org.jetbrains.kotlin.ir.expressions.IrVararg
-import org.jetbrains.kotlin.ir.expressions.IrWhen
-import org.jetbrains.kotlin.ir.expressions.IrWhileLoop
+import org.jetbrains.kotlin.ir.*
+import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.expressions.*
 
 interface IrElementVisitorVoid : IrElementVisitor<Unit, Nothing?> {
-    override fun visitElement(element: IrElement, data: Nothing?) = visitElement(element)
+
+    override fun visitElement(element: IrElement, data: Nothing?) {
+        visitElement(element)
+    }
 
     fun visitElement(element: IrElement) {
     }
 
-    override fun visitDeclaration(declaration: IrDeclarationBase, data: Nothing?) =
-            visitDeclaration(declaration)
+    override fun visitDeclaration(declaration: IrDeclarationBase, data: Nothing?) {
+        visitDeclaration(declaration)
+    }
 
-    fun visitDeclaration(declaration: IrDeclarationBase) = visitElement(declaration)
+    fun visitDeclaration(declaration: IrDeclarationBase) {
+        visitElement(declaration)
+    }
 
-    override fun visitValueParameter(declaration: IrValueParameter, data: Nothing?) =
-            visitValueParameter(declaration)
+    override fun visitValueParameter(declaration: IrValueParameter, data: Nothing?) {
+        visitValueParameter(declaration)
+    }
 
-    fun visitValueParameter(declaration: IrValueParameter) = visitDeclaration(declaration)
+    fun visitValueParameter(declaration: IrValueParameter) {
+        visitDeclaration(declaration)
+    }
 
-    override fun visitClass(declaration: IrClass, data: Nothing?) = visitClass(declaration)
+    override fun visitClass(declaration: IrClass, data: Nothing?) {
+        visitClass(declaration)
+    }
 
-    fun visitClass(declaration: IrClass) = visitDeclaration(declaration)
+    fun visitClass(declaration: IrClass) {
+        visitDeclaration(declaration)
+    }
 
-    override fun visitAnonymousInitializer(declaration: IrAnonymousInitializer,
-            data: Nothing?) = visitAnonymousInitializer(declaration)
+    override fun visitAnonymousInitializer(declaration: IrAnonymousInitializer, data: Nothing?) {
+        visitAnonymousInitializer(declaration)
+    }
 
-    fun visitAnonymousInitializer(declaration: IrAnonymousInitializer) =
-            visitDeclaration(declaration)
+    fun visitAnonymousInitializer(declaration: IrAnonymousInitializer) {
+        visitDeclaration(declaration)
+    }
 
-    override fun visitTypeParameter(declaration: IrTypeParameter, data: Nothing?) =
-            visitTypeParameter(declaration)
+    override fun visitTypeParameter(declaration: IrTypeParameter, data: Nothing?) {
+        visitTypeParameter(declaration)
+    }
 
-    fun visitTypeParameter(declaration: IrTypeParameter) = visitDeclaration(declaration)
+    fun visitTypeParameter(declaration: IrTypeParameter) {
+        visitDeclaration(declaration)
+    }
 
-    override fun visitFunction(declaration: IrFunction, data: Nothing?) =
-            visitFunction(declaration)
+    override fun visitFunction(declaration: IrFunction, data: Nothing?) {
+        visitFunction(declaration)
+    }
 
-    fun visitFunction(declaration: IrFunction) = visitDeclaration(declaration)
+    fun visitFunction(declaration: IrFunction) {
+        visitDeclaration(declaration)
+    }
 
-    override fun visitConstructor(declaration: IrConstructor, data: Nothing?) =
-            visitConstructor(declaration)
+    override fun visitConstructor(declaration: IrConstructor, data: Nothing?) {
+        visitConstructor(declaration)
+    }
 
-    fun visitConstructor(declaration: IrConstructor) = visitFunction(declaration)
+    fun visitConstructor(declaration: IrConstructor) {
+        visitFunction(declaration)
+    }
 
-    override fun visitEnumEntry(declaration: IrEnumEntry, data: Nothing?) =
-            visitEnumEntry(declaration)
+    override fun visitEnumEntry(declaration: IrEnumEntry, data: Nothing?) {
+        visitEnumEntry(declaration)
+    }
 
-    fun visitEnumEntry(declaration: IrEnumEntry) = visitDeclaration(declaration)
+    fun visitEnumEntry(declaration: IrEnumEntry) {
+        visitDeclaration(declaration)
+    }
 
-    override fun visitErrorDeclaration(declaration: IrErrorDeclaration, data: Nothing?) =
-            visitErrorDeclaration(declaration)
+    override fun visitErrorDeclaration(declaration: IrErrorDeclaration, data: Nothing?) {
+        visitErrorDeclaration(declaration)
+    }
 
-    fun visitErrorDeclaration(declaration: IrErrorDeclaration) =
-            visitDeclaration(declaration)
+    fun visitErrorDeclaration(declaration: IrErrorDeclaration) {
+        visitDeclaration(declaration)
+    }
 
-    override fun visitField(declaration: IrField, data: Nothing?) = visitField(declaration)
+    override fun visitField(declaration: IrField, data: Nothing?) {
+        visitField(declaration)
+    }
 
-    fun visitField(declaration: IrField) = visitDeclaration(declaration)
+    fun visitField(declaration: IrField) {
+        visitDeclaration(declaration)
+    }
 
-    override fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty,
-            data: Nothing?) = visitLocalDelegatedProperty(declaration)
+    override fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty, data: Nothing?) {
+        visitLocalDelegatedProperty(declaration)
+    }
 
-    fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty) =
-            visitDeclaration(declaration)
+    fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty) {
+        visitDeclaration(declaration)
+    }
 
-    override fun visitModuleFragment(declaration: IrModuleFragment, data: Nothing?) =
-            visitModuleFragment(declaration)
+    override fun visitModuleFragment(declaration: IrModuleFragment, data: Nothing?) {
+        visitModuleFragment(declaration)
+    }
 
-    fun visitModuleFragment(declaration: IrModuleFragment) = visitElement(declaration)
+    fun visitModuleFragment(declaration: IrModuleFragment) {
+        visitElement(declaration)
+    }
 
-    override fun visitProperty(declaration: IrProperty, data: Nothing?) =
-            visitProperty(declaration)
+    override fun visitProperty(declaration: IrProperty, data: Nothing?) {
+        visitProperty(declaration)
+    }
 
-    fun visitProperty(declaration: IrProperty) = visitDeclaration(declaration)
+    fun visitProperty(declaration: IrProperty) {
+        visitDeclaration(declaration)
+    }
 
-    override fun visitScript(declaration: IrScript, data: Nothing?) =
-            visitScript(declaration)
+    override fun visitScript(declaration: IrScript, data: Nothing?) {
+        visitScript(declaration)
+    }
 
-    fun visitScript(declaration: IrScript) = visitDeclaration(declaration)
+    fun visitScript(declaration: IrScript) {
+        visitDeclaration(declaration)
+    }
 
-    override fun visitSimpleFunction(declaration: IrSimpleFunction, data: Nothing?) =
-            visitSimpleFunction(declaration)
+    override fun visitSimpleFunction(declaration: IrSimpleFunction, data: Nothing?) {
+        visitSimpleFunction(declaration)
+    }
 
-    fun visitSimpleFunction(declaration: IrSimpleFunction) = visitFunction(declaration)
+    fun visitSimpleFunction(declaration: IrSimpleFunction) {
+        visitFunction(declaration)
+    }
 
-    override fun visitTypeAlias(declaration: IrTypeAlias, data: Nothing?) =
-            visitTypeAlias(declaration)
+    override fun visitTypeAlias(declaration: IrTypeAlias, data: Nothing?) {
+        visitTypeAlias(declaration)
+    }
 
-    fun visitTypeAlias(declaration: IrTypeAlias) = visitDeclaration(declaration)
+    fun visitTypeAlias(declaration: IrTypeAlias) {
+        visitDeclaration(declaration)
+    }
 
-    override fun visitVariable(declaration: IrVariable, data: Nothing?) =
-            visitVariable(declaration)
+    override fun visitVariable(declaration: IrVariable, data: Nothing?) {
+        visitVariable(declaration)
+    }
 
-    fun visitVariable(declaration: IrVariable) = visitDeclaration(declaration)
+    fun visitVariable(declaration: IrVariable) {
+        visitDeclaration(declaration)
+    }
 
-    override fun visitPackageFragment(declaration: IrPackageFragment, data: Nothing?) =
-            visitPackageFragment(declaration)
+    override fun visitPackageFragment(declaration: IrPackageFragment, data: Nothing?) {
+        visitPackageFragment(declaration)
+    }
 
-    fun visitPackageFragment(declaration: IrPackageFragment) = visitElement(declaration)
+    fun visitPackageFragment(declaration: IrPackageFragment) {
+        visitElement(declaration)
+    }
 
-    override fun visitExternalPackageFragment(declaration: IrExternalPackageFragment,
-            data: Nothing?) = visitExternalPackageFragment(declaration)
+    override fun visitExternalPackageFragment(declaration: IrExternalPackageFragment, data: Nothing?) {
+        visitExternalPackageFragment(declaration)
+    }
 
-    fun visitExternalPackageFragment(declaration: IrExternalPackageFragment) =
-            visitPackageFragment(declaration)
+    fun visitExternalPackageFragment(declaration: IrExternalPackageFragment) {
+        visitPackageFragment(declaration)
+    }
 
-    override fun visitFile(declaration: IrFile, data: Nothing?) = visitFile(declaration)
+    override fun visitFile(declaration: IrFile, data: Nothing?) {
+        visitFile(declaration)
+    }
 
-    fun visitFile(declaration: IrFile) = visitPackageFragment(declaration)
+    fun visitFile(declaration: IrFile) {
+        visitPackageFragment(declaration)
+    }
 
-    override fun visitExpression(expression: IrExpression, data: Nothing?) =
-            visitExpression(expression)
+    override fun visitExpression(expression: IrExpression, data: Nothing?) {
+        visitExpression(expression)
+    }
 
-    fun visitExpression(expression: IrExpression) = visitElement(expression)
+    fun visitExpression(expression: IrExpression) {
+        visitElement(expression)
+    }
 
-    override fun visitBody(body: IrBody, data: Nothing?) = visitBody(body)
+    override fun visitBody(body: IrBody, data: Nothing?) {
+        visitBody(body)
+    }
 
-    fun visitBody(body: IrBody) = visitElement(body)
+    fun visitBody(body: IrBody) {
+        visitElement(body)
+    }
 
-    override fun visitExpressionBody(body: IrExpressionBody, data: Nothing?) =
-            visitExpressionBody(body)
+    override fun visitExpressionBody(body: IrExpressionBody, data: Nothing?) {
+        visitExpressionBody(body)
+    }
 
-    fun visitExpressionBody(body: IrExpressionBody) = visitBody(body)
+    fun visitExpressionBody(body: IrExpressionBody) {
+        visitBody(body)
+    }
 
-    override fun visitBlockBody(body: IrBlockBody, data: Nothing?) = visitBlockBody(body)
+    override fun visitBlockBody(body: IrBlockBody, data: Nothing?) {
+        visitBlockBody(body)
+    }
 
-    fun visitBlockBody(body: IrBlockBody) = visitBody(body)
+    fun visitBlockBody(body: IrBlockBody) {
+        visitBody(body)
+    }
 
-    override fun visitDeclarationReference(expression: IrDeclarationReference,
-            data: Nothing?) = visitDeclarationReference(expression)
+    override fun visitDeclarationReference(expression: IrDeclarationReference, data: Nothing?) {
+        visitDeclarationReference(expression)
+    }
 
-    fun visitDeclarationReference(expression: IrDeclarationReference) =
-            visitExpression(expression)
+    fun visitDeclarationReference(expression: IrDeclarationReference) {
+        visitExpression(expression)
+    }
 
-    override fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: Nothing?)
-            = visitMemberAccess(expression)
+    override fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: Nothing?) {
+        visitMemberAccess(expression)
+    }
 
-    fun visitMemberAccess(expression: IrMemberAccessExpression<*>) =
-            visitDeclarationReference(expression)
+    fun visitMemberAccess(expression: IrMemberAccessExpression<*>) {
+        visitDeclarationReference(expression)
+    }
 
-    override fun visitFunctionAccess(expression: IrFunctionAccessExpression,
-            data: Nothing?) = visitFunctionAccess(expression)
+    override fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: Nothing?) {
+        visitFunctionAccess(expression)
+    }
 
-    fun visitFunctionAccess(expression: IrFunctionAccessExpression) =
-            visitMemberAccess(expression)
+    fun visitFunctionAccess(expression: IrFunctionAccessExpression) {
+        visitMemberAccess(expression)
+    }
 
-    override fun visitConstructorCall(expression: IrConstructorCall, data: Nothing?) =
-            visitConstructorCall(expression)
+    override fun visitConstructorCall(expression: IrConstructorCall, data: Nothing?) {
+        visitConstructorCall(expression)
+    }
 
-    fun visitConstructorCall(expression: IrConstructorCall) = visitFunctionAccess(expression)
+    fun visitConstructorCall(expression: IrConstructorCall) {
+        visitFunctionAccess(expression)
+    }
 
-    override fun visitSingletonReference(expression: IrGetSingletonValue, data: Nothing?) =
-            visitSingletonReference(expression)
+    override fun visitSingletonReference(expression: IrGetSingletonValue, data: Nothing?) {
+        visitSingletonReference(expression)
+    }
 
-    fun visitSingletonReference(expression: IrGetSingletonValue) =
-            visitDeclarationReference(expression)
+    fun visitSingletonReference(expression: IrGetSingletonValue) {
+        visitDeclarationReference(expression)
+    }
 
-    override fun visitGetObjectValue(expression: IrGetObjectValue, data: Nothing?) =
-            visitGetObjectValue(expression)
+    override fun visitGetObjectValue(expression: IrGetObjectValue, data: Nothing?) {
+        visitGetObjectValue(expression)
+    }
 
-    fun visitGetObjectValue(expression: IrGetObjectValue) =
-            visitSingletonReference(expression)
+    fun visitGetObjectValue(expression: IrGetObjectValue) {
+        visitSingletonReference(expression)
+    }
 
-    override fun visitGetEnumValue(expression: IrGetEnumValue, data: Nothing?) =
-            visitGetEnumValue(expression)
+    override fun visitGetEnumValue(expression: IrGetEnumValue, data: Nothing?) {
+        visitGetEnumValue(expression)
+    }
 
-    fun visitGetEnumValue(expression: IrGetEnumValue) = visitSingletonReference(expression)
+    fun visitGetEnumValue(expression: IrGetEnumValue) {
+        visitSingletonReference(expression)
+    }
 
-    override fun visitRawFunctionReference(expression: IrRawFunctionReference,
-            data: Nothing?) = visitRawFunctionReference(expression)
+    override fun visitRawFunctionReference(expression: IrRawFunctionReference, data: Nothing?) {
+        visitRawFunctionReference(expression)
+    }
 
-    fun visitRawFunctionReference(expression: IrRawFunctionReference) =
-            visitDeclarationReference(expression)
+    fun visitRawFunctionReference(expression: IrRawFunctionReference) {
+        visitDeclarationReference(expression)
+    }
 
-    override fun visitContainerExpression(expression: IrContainerExpression,
-            data: Nothing?) = visitContainerExpression(expression)
+    override fun visitContainerExpression(expression: IrContainerExpression, data: Nothing?) {
+        visitContainerExpression(expression)
+    }
 
-    fun visitContainerExpression(expression: IrContainerExpression) =
-            visitExpression(expression)
+    fun visitContainerExpression(expression: IrContainerExpression) {
+        visitExpression(expression)
+    }
 
-    override fun visitBlock(expression: IrBlock, data: Nothing?) = visitBlock(expression)
+    override fun visitBlock(expression: IrBlock, data: Nothing?) {
+        visitBlock(expression)
+    }
 
-    fun visitBlock(expression: IrBlock) = visitContainerExpression(expression)
+    fun visitBlock(expression: IrBlock) {
+        visitContainerExpression(expression)
+    }
 
-    override fun visitComposite(expression: IrComposite, data: Nothing?) =
-            visitComposite(expression)
+    override fun visitComposite(expression: IrComposite, data: Nothing?) {
+        visitComposite(expression)
+    }
 
-    fun visitComposite(expression: IrComposite) = visitContainerExpression(expression)
+    fun visitComposite(expression: IrComposite) {
+        visitContainerExpression(expression)
+    }
 
-    override fun visitSyntheticBody(body: IrSyntheticBody, data: Nothing?) =
-            visitSyntheticBody(body)
+    override fun visitSyntheticBody(body: IrSyntheticBody, data: Nothing?) {
+        visitSyntheticBody(body)
+    }
 
-    fun visitSyntheticBody(body: IrSyntheticBody) = visitBody(body)
+    fun visitSyntheticBody(body: IrSyntheticBody) {
+        visitBody(body)
+    }
 
-    override fun visitBreakContinue(jump: IrBreakContinue, data: Nothing?) =
-            visitBreakContinue(jump)
+    override fun visitBreakContinue(jump: IrBreakContinue, data: Nothing?) {
+        visitBreakContinue(jump)
+    }
 
-    fun visitBreakContinue(jump: IrBreakContinue) = visitExpression(jump)
+    fun visitBreakContinue(jump: IrBreakContinue) {
+        visitExpression(jump)
+    }
 
-    override fun visitBreak(jump: IrBreak, data: Nothing?) = visitBreak(jump)
+    override fun visitBreak(jump: IrBreak, data: Nothing?) {
+        visitBreak(jump)
+    }
 
-    fun visitBreak(jump: IrBreak) = visitBreakContinue(jump)
+    fun visitBreak(jump: IrBreak) {
+        visitBreakContinue(jump)
+    }
 
-    override fun visitContinue(jump: IrContinue, data: Nothing?) = visitContinue(jump)
+    override fun visitContinue(jump: IrContinue, data: Nothing?) {
+        visitContinue(jump)
+    }
 
-    fun visitContinue(jump: IrContinue) = visitBreakContinue(jump)
+    fun visitContinue(jump: IrContinue) {
+        visitBreakContinue(jump)
+    }
 
-    override fun visitCall(expression: IrCall, data: Nothing?) = visitCall(expression)
+    override fun visitCall(expression: IrCall, data: Nothing?) {
+        visitCall(expression)
+    }
 
-    fun visitCall(expression: IrCall) = visitFunctionAccess(expression)
+    fun visitCall(expression: IrCall) {
+        visitFunctionAccess(expression)
+    }
 
-    override fun visitCallableReference(expression: IrCallableReference<*>, data: Nothing?)
-            = visitCallableReference(expression)
+    override fun visitCallableReference(expression: IrCallableReference<*>, data: Nothing?) {
+        visitCallableReference(expression)
+    }
 
-    fun visitCallableReference(expression: IrCallableReference<*>) =
-            visitMemberAccess(expression)
+    fun visitCallableReference(expression: IrCallableReference<*>) {
+        visitMemberAccess(expression)
+    }
 
-    override fun visitFunctionReference(expression: IrFunctionReference, data: Nothing?) =
-            visitFunctionReference(expression)
+    override fun visitFunctionReference(expression: IrFunctionReference, data: Nothing?) {
+        visitFunctionReference(expression)
+    }
 
-    fun visitFunctionReference(expression: IrFunctionReference) =
-            visitCallableReference(expression)
+    fun visitFunctionReference(expression: IrFunctionReference) {
+        visitCallableReference(expression)
+    }
 
-    override fun visitPropertyReference(expression: IrPropertyReference, data: Nothing?) =
-            visitPropertyReference(expression)
+    override fun visitPropertyReference(expression: IrPropertyReference, data: Nothing?) {
+        visitPropertyReference(expression)
+    }
 
-    fun visitPropertyReference(expression: IrPropertyReference) =
-            visitCallableReference(expression)
+    fun visitPropertyReference(expression: IrPropertyReference) {
+        visitCallableReference(expression)
+    }
 
-    override
-            fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference,
-            data: Nothing?) = visitLocalDelegatedPropertyReference(expression)
+    override fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference, data: Nothing?) {
+        visitLocalDelegatedPropertyReference(expression)
+    }
 
-    fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference) =
-            visitCallableReference(expression)
+    fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference) {
+        visitCallableReference(expression)
+    }
 
-    override fun visitClassReference(expression: IrClassReference, data: Nothing?) =
-            visitClassReference(expression)
+    override fun visitClassReference(expression: IrClassReference, data: Nothing?) {
+        visitClassReference(expression)
+    }
 
-    fun visitClassReference(expression: IrClassReference) =
-            visitDeclarationReference(expression)
+    fun visitClassReference(expression: IrClassReference) {
+        visitDeclarationReference(expression)
+    }
 
-    override fun visitConst(expression: IrConst<*>, data: Nothing?) =
-            visitConst(expression)
+    override fun visitConst(expression: IrConst<*>, data: Nothing?) {
+        visitConst(expression)
+    }
 
-    fun visitConst(expression: IrConst<*>) = visitExpression(expression)
+    fun visitConst(expression: IrConst<*>) {
+        visitExpression(expression)
+    }
 
-    override fun visitConstantValue(expression: IrConstantValue, data: Nothing?) =
-            visitConstantValue(expression)
+    override fun visitConstantValue(expression: IrConstantValue, data: Nothing?) {
+        visitConstantValue(expression)
+    }
 
-    fun visitConstantValue(expression: IrConstantValue) = visitExpression(expression)
+    fun visitConstantValue(expression: IrConstantValue) {
+        visitExpression(expression)
+    }
 
-    override fun visitConstantPrimitive(expression: IrConstantPrimitive, data: Nothing?) =
-            visitConstantPrimitive(expression)
+    override fun visitConstantPrimitive(expression: IrConstantPrimitive, data: Nothing?) {
+        visitConstantPrimitive(expression)
+    }
 
-    fun visitConstantPrimitive(expression: IrConstantPrimitive) =
-            visitConstantValue(expression)
+    fun visitConstantPrimitive(expression: IrConstantPrimitive) {
+        visitConstantValue(expression)
+    }
 
-    override fun visitConstantObject(expression: IrConstantObject, data: Nothing?) =
-            visitConstantObject(expression)
+    override fun visitConstantObject(expression: IrConstantObject, data: Nothing?) {
+        visitConstantObject(expression)
+    }
 
-    fun visitConstantObject(expression: IrConstantObject) = visitConstantValue(expression)
+    fun visitConstantObject(expression: IrConstantObject) {
+        visitConstantValue(expression)
+    }
 
-    override fun visitConstantArray(expression: IrConstantArray, data: Nothing?) =
-            visitConstantArray(expression)
+    override fun visitConstantArray(expression: IrConstantArray, data: Nothing?) {
+        visitConstantArray(expression)
+    }
 
-    fun visitConstantArray(expression: IrConstantArray) = visitConstantValue(expression)
+    fun visitConstantArray(expression: IrConstantArray) {
+        visitConstantValue(expression)
+    }
 
-    override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall,
-            data: Nothing?) = visitDelegatingConstructorCall(expression)
+    override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall, data: Nothing?) {
+        visitDelegatingConstructorCall(expression)
+    }
 
-    fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall) =
-            visitFunctionAccess(expression)
+    fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall) {
+        visitFunctionAccess(expression)
+    }
 
-    override fun visitDynamicExpression(expression: IrDynamicExpression, data: Nothing?) =
-            visitDynamicExpression(expression)
+    override fun visitDynamicExpression(expression: IrDynamicExpression, data: Nothing?) {
+        visitDynamicExpression(expression)
+    }
 
-    fun visitDynamicExpression(expression: IrDynamicExpression) = visitExpression(expression)
+    fun visitDynamicExpression(expression: IrDynamicExpression) {
+        visitExpression(expression)
+    }
 
-    override fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression,
-            data: Nothing?) = visitDynamicOperatorExpression(expression)
+    override fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression, data: Nothing?) {
+        visitDynamicOperatorExpression(expression)
+    }
 
-    fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression) =
-            visitDynamicExpression(expression)
+    fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression) {
+        visitDynamicExpression(expression)
+    }
 
-    override fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression,
-            data: Nothing?) = visitDynamicMemberExpression(expression)
+    override fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression, data: Nothing?) {
+        visitDynamicMemberExpression(expression)
+    }
 
-    fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression) =
-            visitDynamicExpression(expression)
+    fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression) {
+        visitDynamicExpression(expression)
+    }
 
-    override fun visitEnumConstructorCall(expression: IrEnumConstructorCall,
-            data: Nothing?) = visitEnumConstructorCall(expression)
+    override fun visitEnumConstructorCall(expression: IrEnumConstructorCall, data: Nothing?) {
+        visitEnumConstructorCall(expression)
+    }
 
-    fun visitEnumConstructorCall(expression: IrEnumConstructorCall) =
-            visitFunctionAccess(expression)
+    fun visitEnumConstructorCall(expression: IrEnumConstructorCall) {
+        visitFunctionAccess(expression)
+    }
 
-    override fun visitErrorExpression(expression: IrErrorExpression, data: Nothing?) =
-            visitErrorExpression(expression)
+    override fun visitErrorExpression(expression: IrErrorExpression, data: Nothing?) {
+        visitErrorExpression(expression)
+    }
 
-    fun visitErrorExpression(expression: IrErrorExpression) = visitExpression(expression)
+    fun visitErrorExpression(expression: IrErrorExpression) {
+        visitExpression(expression)
+    }
 
-    override fun visitErrorCallExpression(expression: IrErrorCallExpression,
-            data: Nothing?) = visitErrorCallExpression(expression)
+    override fun visitErrorCallExpression(expression: IrErrorCallExpression, data: Nothing?) {
+        visitErrorCallExpression(expression)
+    }
 
-    fun visitErrorCallExpression(expression: IrErrorCallExpression) =
-            visitErrorExpression(expression)
+    fun visitErrorCallExpression(expression: IrErrorCallExpression) {
+        visitErrorExpression(expression)
+    }
 
-    override fun visitFieldAccess(expression: IrFieldAccessExpression, data: Nothing?) =
-            visitFieldAccess(expression)
+    override fun visitFieldAccess(expression: IrFieldAccessExpression, data: Nothing?) {
+        visitFieldAccess(expression)
+    }
 
-    fun visitFieldAccess(expression: IrFieldAccessExpression) =
-            visitDeclarationReference(expression)
+    fun visitFieldAccess(expression: IrFieldAccessExpression) {
+        visitDeclarationReference(expression)
+    }
 
-    override fun visitGetField(expression: IrGetField, data: Nothing?) =
-            visitGetField(expression)
+    override fun visitGetField(expression: IrGetField, data: Nothing?) {
+        visitGetField(expression)
+    }
 
-    fun visitGetField(expression: IrGetField) = visitFieldAccess(expression)
+    fun visitGetField(expression: IrGetField) {
+        visitFieldAccess(expression)
+    }
 
-    override fun visitSetField(expression: IrSetField, data: Nothing?) =
-            visitSetField(expression)
+    override fun visitSetField(expression: IrSetField, data: Nothing?) {
+        visitSetField(expression)
+    }
 
-    fun visitSetField(expression: IrSetField) = visitFieldAccess(expression)
+    fun visitSetField(expression: IrSetField) {
+        visitFieldAccess(expression)
+    }
 
-    override fun visitFunctionExpression(expression: IrFunctionExpression, data: Nothing?)
-            = visitFunctionExpression(expression)
+    override fun visitFunctionExpression(expression: IrFunctionExpression, data: Nothing?) {
+        visitFunctionExpression(expression)
+    }
 
-    fun visitFunctionExpression(expression: IrFunctionExpression) =
-            visitExpression(expression)
+    fun visitFunctionExpression(expression: IrFunctionExpression) {
+        visitExpression(expression)
+    }
 
-    override fun visitGetClass(expression: IrGetClass, data: Nothing?) =
-            visitGetClass(expression)
+    override fun visitGetClass(expression: IrGetClass, data: Nothing?) {
+        visitGetClass(expression)
+    }
 
-    fun visitGetClass(expression: IrGetClass) = visitExpression(expression)
+    fun visitGetClass(expression: IrGetClass) {
+        visitExpression(expression)
+    }
 
-    override fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall,
-            data: Nothing?) = visitInstanceInitializerCall(expression)
+    override fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall, data: Nothing?) {
+        visitInstanceInitializerCall(expression)
+    }
 
-    fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall) =
-            visitExpression(expression)
+    fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall) {
+        visitExpression(expression)
+    }
 
-    override fun visitLoop(loop: IrLoop, data: Nothing?) = visitLoop(loop)
+    override fun visitLoop(loop: IrLoop, data: Nothing?) {
+        visitLoop(loop)
+    }
 
-    fun visitLoop(loop: IrLoop) = visitExpression(loop)
+    fun visitLoop(loop: IrLoop) {
+        visitExpression(loop)
+    }
 
-    override fun visitWhileLoop(loop: IrWhileLoop, data: Nothing?) = visitWhileLoop(loop)
+    override fun visitWhileLoop(loop: IrWhileLoop, data: Nothing?) {
+        visitWhileLoop(loop)
+    }
 
-    fun visitWhileLoop(loop: IrWhileLoop) = visitLoop(loop)
+    fun visitWhileLoop(loop: IrWhileLoop) {
+        visitLoop(loop)
+    }
 
-    override fun visitDoWhileLoop(loop: IrDoWhileLoop, data: Nothing?) =
-            visitDoWhileLoop(loop)
+    override fun visitDoWhileLoop(loop: IrDoWhileLoop, data: Nothing?) {
+        visitDoWhileLoop(loop)
+    }
 
-    fun visitDoWhileLoop(loop: IrDoWhileLoop) = visitLoop(loop)
+    fun visitDoWhileLoop(loop: IrDoWhileLoop) {
+        visitLoop(loop)
+    }
 
-    override fun visitReturn(expression: IrReturn, data: Nothing?) =
-            visitReturn(expression)
+    override fun visitReturn(expression: IrReturn, data: Nothing?) {
+        visitReturn(expression)
+    }
 
-    fun visitReturn(expression: IrReturn) = visitExpression(expression)
+    fun visitReturn(expression: IrReturn) {
+        visitExpression(expression)
+    }
 
-    override fun visitStringConcatenation(expression: IrStringConcatenation,
-            data: Nothing?) = visitStringConcatenation(expression)
+    override fun visitStringConcatenation(expression: IrStringConcatenation, data: Nothing?) {
+        visitStringConcatenation(expression)
+    }
 
-    fun visitStringConcatenation(expression: IrStringConcatenation) =
-            visitExpression(expression)
+    fun visitStringConcatenation(expression: IrStringConcatenation) {
+        visitExpression(expression)
+    }
 
-    override fun visitSuspensionPoint(expression: IrSuspensionPoint, data: Nothing?) =
-            visitSuspensionPoint(expression)
+    override fun visitSuspensionPoint(expression: IrSuspensionPoint, data: Nothing?) {
+        visitSuspensionPoint(expression)
+    }
 
-    fun visitSuspensionPoint(expression: IrSuspensionPoint) = visitExpression(expression)
+    fun visitSuspensionPoint(expression: IrSuspensionPoint) {
+        visitExpression(expression)
+    }
 
-    override fun visitSuspendableExpression(expression: IrSuspendableExpression,
-            data: Nothing?) = visitSuspendableExpression(expression)
+    override fun visitSuspendableExpression(expression: IrSuspendableExpression, data: Nothing?) {
+        visitSuspendableExpression(expression)
+    }
 
-    fun visitSuspendableExpression(expression: IrSuspendableExpression) =
-            visitExpression(expression)
+    fun visitSuspendableExpression(expression: IrSuspendableExpression) {
+        visitExpression(expression)
+    }
 
-    override fun visitThrow(expression: IrThrow, data: Nothing?) = visitThrow(expression)
+    override fun visitThrow(expression: IrThrow, data: Nothing?) {
+        visitThrow(expression)
+    }
 
-    fun visitThrow(expression: IrThrow) = visitExpression(expression)
+    fun visitThrow(expression: IrThrow) {
+        visitExpression(expression)
+    }
 
-    override fun visitTry(aTry: IrTry, data: Nothing?) = visitTry(aTry)
+    override fun visitTry(aTry: IrTry, data: Nothing?) {
+        visitTry(aTry)
+    }
 
-    fun visitTry(aTry: IrTry) = visitExpression(aTry)
+    fun visitTry(aTry: IrTry) {
+        visitExpression(aTry)
+    }
 
-    override fun visitCatch(aCatch: IrCatch, data: Nothing?) = visitCatch(aCatch)
+    override fun visitCatch(aCatch: IrCatch, data: Nothing?) {
+        visitCatch(aCatch)
+    }
 
-    fun visitCatch(aCatch: IrCatch) = visitElement(aCatch)
+    fun visitCatch(aCatch: IrCatch) {
+        visitElement(aCatch)
+    }
 
-    override fun visitTypeOperator(expression: IrTypeOperatorCall, data: Nothing?) =
-            visitTypeOperator(expression)
+    override fun visitTypeOperator(expression: IrTypeOperatorCall, data: Nothing?) {
+        visitTypeOperator(expression)
+    }
 
-    fun visitTypeOperator(expression: IrTypeOperatorCall) = visitExpression(expression)
+    fun visitTypeOperator(expression: IrTypeOperatorCall) {
+        visitExpression(expression)
+    }
 
-    override fun visitValueAccess(expression: IrValueAccessExpression, data: Nothing?) =
-            visitValueAccess(expression)
+    override fun visitValueAccess(expression: IrValueAccessExpression, data: Nothing?) {
+        visitValueAccess(expression)
+    }
 
-    fun visitValueAccess(expression: IrValueAccessExpression) =
-            visitDeclarationReference(expression)
+    fun visitValueAccess(expression: IrValueAccessExpression) {
+        visitDeclarationReference(expression)
+    }
 
-    override fun visitGetValue(expression: IrGetValue, data: Nothing?) =
-            visitGetValue(expression)
+    override fun visitGetValue(expression: IrGetValue, data: Nothing?) {
+        visitGetValue(expression)
+    }
 
-    fun visitGetValue(expression: IrGetValue) = visitValueAccess(expression)
+    fun visitGetValue(expression: IrGetValue) {
+        visitValueAccess(expression)
+    }
 
-    override fun visitSetValue(expression: IrSetValue, data: Nothing?) =
-            visitSetValue(expression)
+    override fun visitSetValue(expression: IrSetValue, data: Nothing?) {
+        visitSetValue(expression)
+    }
 
-    fun visitSetValue(expression: IrSetValue) = visitValueAccess(expression)
+    fun visitSetValue(expression: IrSetValue) {
+        visitValueAccess(expression)
+    }
 
-    override fun visitVararg(expression: IrVararg, data: Nothing?) =
-            visitVararg(expression)
+    override fun visitVararg(expression: IrVararg, data: Nothing?) {
+        visitVararg(expression)
+    }
 
-    fun visitVararg(expression: IrVararg) = visitExpression(expression)
+    fun visitVararg(expression: IrVararg) {
+        visitExpression(expression)
+    }
 
-    override fun visitSpreadElement(spread: IrSpreadElement, data: Nothing?) =
-            visitSpreadElement(spread)
+    override fun visitSpreadElement(spread: IrSpreadElement, data: Nothing?) {
+        visitSpreadElement(spread)
+    }
 
-    fun visitSpreadElement(spread: IrSpreadElement) = visitElement(spread)
+    fun visitSpreadElement(spread: IrSpreadElement) {
+        visitElement(spread)
+    }
 
-    override fun visitWhen(expression: IrWhen, data: Nothing?) = visitWhen(expression)
+    override fun visitWhen(expression: IrWhen, data: Nothing?) {
+        visitWhen(expression)
+    }
 
-    fun visitWhen(expression: IrWhen) = visitExpression(expression)
+    fun visitWhen(expression: IrWhen) {
+        visitExpression(expression)
+    }
 
-    override fun visitBranch(branch: IrBranch, data: Nothing?) = visitBranch(branch)
+    override fun visitBranch(branch: IrBranch, data: Nothing?) {
+        visitBranch(branch)
+    }
 
-    fun visitBranch(branch: IrBranch) = visitElement(branch)
+    fun visitBranch(branch: IrBranch) {
+        visitElement(branch)
+    }
 
-    override fun visitElseBranch(branch: IrElseBranch, data: Nothing?) =
-            visitElseBranch(branch)
+    override fun visitElseBranch(branch: IrElseBranch, data: Nothing?) {
+        visitElseBranch(branch)
+    }
 
-    fun visitElseBranch(branch: IrElseBranch) = visitBranch(branch)
+    fun visitElseBranch(branch: IrElseBranch) {
+        visitBranch(branch)
+    }
 }
diff --git a/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/CommonTypes.kt b/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/CommonTypes.kt
index 65949c4..0d1b28f 100644
--- a/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/CommonTypes.kt
+++ b/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/CommonTypes.kt
@@ -27,6 +27,7 @@
 val elementBaseType = type(tree, "IrElementBase", TypeKind.Class)
 val statementOriginType = type(exprs, "IrStatementOrigin")
 val elementVisitorType = type(visitors, "IrElementVisitor")
+val elementVisitorVoidType = type(visitors, "IrElementVisitorVoid")
 val elementTransformerType = type(visitors, "IrElementTransformer")
 val mutableAnnotationContainerType = type(declarations, "IrMutableAnnotationContainer")
 val irTypeType = type(types, "IrType")
diff --git a/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/model/Model.kt b/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/model/Model.kt
index 706da99..d389cec 100644
--- a/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/model/Model.kt
+++ b/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/model/Model.kt
@@ -43,7 +43,7 @@
 
     override fun copy(args: Map<NamedTypeParameterRef, TypeRef>): ElementOrRef = TODO("Not yet implemented")
 
-    var visitorParent: ElementRef? = null
+    override var parentInVisitor: Element? = null
     var transformerReturnType: Element? = null
 
     override var kind: ImplementationKind? = when (config.typeKind) {
@@ -63,8 +63,8 @@
     override var walkableChildren: List<Field> = emptyList()
     override val transformableChildren get() = walkableChildren.filter { it.transformable }
 
-    val visitFunName = "visit" + (config.visitorName ?: name).replaceFirstChar(Char::uppercaseChar)
-    val visitorParam = config.visitorParam ?: config.category.defaultVisitorParam
+    override val visitFunctionName = "visit" + (config.visitorName ?: name).replaceFirstChar(Char::uppercaseChar)
+    override val visitorParameterName = config.visitorParam ?: config.category.defaultVisitorParam
 
     override var hasAcceptMethod = config.accept
 
diff --git a/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/model/Transformations.kt b/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/model/Transformations.kt
index 3c5e4c1..492aefb 100644
--- a/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/model/Transformations.kt
+++ b/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/model/Transformations.kt
@@ -121,7 +121,7 @@
             .partitionIsInstance<TypeRef, ElementRef>()
         el.elementParents = elParents.takeIf { it.isNotEmpty() || el == rootEl.element } ?: listOf(rootEl)
         el.otherParents = otherParents.castAll<ClassRef<*>>().toMutableList()
-        el.visitorParent = ec.visitorParent?.let(::transform) as GenericElementRef<Element, Field>?
+        el.parentInVisitor = (ec.visitorParent?.let(::transform) as GenericElementRef<Element, Field>?)?.element
         el.transformerReturnType = (ec.transformerReturnType?.let(::transform) as GenericElementRef<Element, Field>?)?.element
 
         for (field in el.fields) {
@@ -152,7 +152,7 @@
 
     for (el in leaves) {
         el.isLeaf = true
-        if (el.visitorParent != null) {
+        if (el.parentInVisitor != null) {
             el.hasAcceptMethod = true
         }
     }
diff --git a/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/print/Common.kt b/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/print/Common.kt
index 75e982d..cf1155e 100644
--- a/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/print/Common.kt
+++ b/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/print/Common.kt
@@ -13,7 +13,7 @@
 import java.io.File
 
 private val COPYRIGHT by lazy { File("license/COPYRIGHT_HEADER.txt").readText() }
-private val GENERATED_MESSAGE = """
+internal val GENERATED_MESSAGE = """
      // This file was generated automatically. See compiler/ir/ir.tree/tree-generator/ReadMe.md.
      // DO NOT MODIFY IT MANUALLY.
      """.trimIndent()
diff --git a/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/print/Elements.kt b/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/print/Elements.kt
index 5bf6d46..39d1981 100644
--- a/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/print/Elements.kt
+++ b/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/print/Elements.kt
@@ -96,7 +96,7 @@
                         .also(::addParameter)
                     returns(r)
                     if (!isRootElement) {
-                        addStatement("return %N.%N(this, %N)", visitorParam, element.visitFunName, dataParam)
+                        addStatement("return %N.%N(this, %N)", visitorParam, element.visitFunctionName, dataParam)
                     }
                     if (isRootElement) {
                         addKdoc(
diff --git a/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/print/VisitorsAndTransformers.kt b/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/print/VisitorsAndTransformers.kt
index 0c916f2..9ee6ebb 100644
--- a/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/print/VisitorsAndTransformers.kt
+++ b/compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/print/VisitorsAndTransformers.kt
@@ -7,79 +7,82 @@
 
 import com.squareup.kotlinpoet.*
 import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
-import org.jetbrains.kotlin.generators.tree.GeneratedFile
-import org.jetbrains.kotlin.ir.generator.IrTree
-import org.jetbrains.kotlin.ir.generator.VISITOR_PACKAGE
-import org.jetbrains.kotlin.ir.generator.irTypeType
+import org.jetbrains.kotlin.generators.tree.*
+import org.jetbrains.kotlin.ir.generator.*
 import org.jetbrains.kotlin.ir.generator.model.*
 import org.jetbrains.kotlin.util.capitalizeDecapitalize.capitalizeAsciiOnly
+import org.jetbrains.kotlin.utils.SmartPrinter
 import java.io.File
 
 private val visitorTypeName = ClassName(VISITOR_PACKAGE, "IrElementVisitor")
-private val visitorVoidTypeName = ClassName(VISITOR_PACKAGE, "IrElementVisitorVoid")
 private val transformerTypeName = ClassName(VISITOR_PACKAGE, "IrElementTransformer")
 private val typeTransformerTypeName = ClassName(VISITOR_PACKAGE, "IrTypeTransformer")
 
-fun printVisitor(generationPath: File, model: Model): GeneratedFile {
-    val visitorType = TypeSpec.interfaceBuilder(visitorTypeName).apply {
-        val r = TypeVariableName("R", KModifier.OUT)
-        val d = TypeVariableName("D", KModifier.IN)
-        addTypeVariable(r)
-        addTypeVariable(d)
-
-        fun buildVisitFun(element: Element) = FunSpec.builder(element.visitFunName).apply {
-            addParameter(element.visitorParam, element.toPoetStarParameterized())
-            addParameter("data", d)
-            returns(r)
-        }
-
-        addFunction(buildVisitFun(model.rootElement).addModifiers(KModifier.ABSTRACT).build())
-
-        for (element in model.elements) {
-            element.visitorParent?.let { parent ->
-                addFunction(buildVisitFun(element).apply {
-                    addStatement("return ${parent.element.visitFunName}(${element.visitorParam}, data)")
-                }.build())
-            }
-        }
-    }.build()
-
-    return printTypeCommon(generationPath, visitorTypeName.packageName, visitorType)
+private fun printVisitorCommon(
+    generationPath: File,
+    model: Model,
+    printerCreator: (SmartPrinter) -> AbstractVisitorPrinter<Element, Field>,
+): GeneratedFile {
+    val elements = model.elements
+    val stringBuilder = StringBuilder()
+    val smartPrinter = SmartPrinter(stringBuilder)
+    val printer = printerCreator(smartPrinter)
+    val dir = File(generationPath, printer.visitorType.packageName.replace(".", "/"))
+    val file = File(dir, "${printer.visitorType.simpleName}.kt")
+    smartPrinter.run {
+        printCopyright()
+        println(GENERATED_MESSAGE)
+        println()
+        println("package $VISITOR_PACKAGE")
+        println()
+        println("import ", Packages.tree, ".*")
+        println("import ", Packages.declarations, ".*")
+        println("import ", Packages.exprs, ".*")
+        println()
+        printer.printVisitor(elements)
+    }
+    return GeneratedFile(file, stringBuilder.toString())
 }
 
-fun printVisitorVoid(generationPath: File, model: Model): GeneratedFile {
-    val dataType = NOTHING.copy(nullable = true)
+private open class VisitorPrinter(printer: SmartPrinter) :
+    AbstractVisitorPrinter<Element, Field>(printer, visitSuperTypeByDefault = false) {
 
-    val visitorType = TypeSpec.interfaceBuilder(visitorVoidTypeName).apply {
-        addSuperinterface(visitorTypeName.parameterizedBy(UNIT, dataType))
+    override val visitorType: ClassRef<*>
+        get() = elementVisitorType
 
-        fun buildVisitFun(element: Element) = FunSpec.builder(element.visitFunName).apply {
-            addModifiers(KModifier.OVERRIDE)
-            addParameter(element.visitorParam, element.toPoetStarParameterized())
-            addParameter("data", dataType)
-            addStatement("return ${element.visitFunName}(${element.visitorParam})")
-        }
+    override val visitorTypeParameters: List<TypeVariable>
+        get() = listOf(resultTypeVariable, dataTypeVariable)
 
-        fun buildVisitVoidFun(element: Element) = FunSpec.builder(element.visitFunName).apply {
-            addParameter(element.visitorParam, element.toPoetStarParameterized())
-        }
+    override val visitorSuperType: ClassRef<PositionTypeParameterRef>?
+        get() = null
 
-        addFunction(buildVisitFun(model.rootElement).build())
-        addFunction(buildVisitVoidFun(model.rootElement).build())
-
-        for (element in model.elements) {
-            element.visitorParent?.let { parent ->
-                addFunction(buildVisitFun(element).build())
-                addFunction(buildVisitVoidFun(element).apply {
-                    addStatement("return ${parent.element.visitFunName}(${element.visitorParam})")
-                }.build())
-            }
-        }
-    }.build()
-
-    return printTypeCommon(generationPath, visitorVoidTypeName.packageName, visitorType)
+    override val allowTypeParametersInVisitorMethods: Boolean
+        get() = false
 }
 
+fun printVisitor(generationPath: File, model: Model) = printVisitorCommon(generationPath, model, ::VisitorPrinter)
+
+private class VisitorVoidPrinter(
+    printer: SmartPrinter,
+) : AbstractVisitorVoidPrinter<Element, Field>(printer, visitSuperTypeByDefault = false) {
+    override val visitorType: ClassRef<*>
+        get() = elementVisitorVoidType
+
+    override val visitorSuperClass: ClassRef<PositionTypeParameterRef>
+        get() = elementVisitorType
+
+    override val allowTypeParametersInVisitorMethods: Boolean
+        get() = false
+
+    override val useAbstractMethodForRootElement: Boolean
+        get() = false
+
+    override val overriddenVisitMethodsAreFinal: Boolean
+        get() = false
+}
+
+fun printVisitorVoid(generationPath: File, model: Model) = printVisitorCommon(generationPath, model, ::VisitorVoidPrinter)
+
 fun printTransformer(generationPath: File, model: Model): GeneratedFile {
     val visitorType = TypeSpec.interfaceBuilder(transformerTypeName).apply {
         val d = TypeVariableName("D", KModifier.IN)
@@ -87,9 +90,9 @@
 
         addSuperinterface(visitorTypeName.parameterizedBy(model.rootElement.toPoetStarParameterized(), d))
 
-        fun buildVisitFun(element: Element) = FunSpec.builder(element.visitFunName).apply {
+        fun buildVisitFun(element: Element) = FunSpec.builder(element.visitFunctionName).apply {
             addModifiers(KModifier.OVERRIDE)
-            addParameter(element.visitorParam, element.toPoetStarParameterized())
+            addParameter(element.visitorParameterName, element.toPoetStarParameterized())
             addParameter("data", d)
         }
 
@@ -97,14 +100,14 @@
             val returnType = element.getTransformExplicitType()
             if (element.transformByChildren) {
                 addFunction(buildVisitFun(element).apply {
-                    addStatement("${element.visitorParam}.transformChildren(this, data)")
-                    addStatement("return ${element.visitorParam}")
+                    addStatement("${element.visitorParameterName}.transformChildren(this, data)")
+                    addStatement("return ${element.visitorParameterName}")
                     returns(returnType.toPoetStarParameterized())
                 }.build())
             } else {
-                element.visitorParent?.let { parent ->
+                element.parentInVisitor?.let { parent ->
                     addFunction(buildVisitFun(element).apply {
-                        addStatement("return ${parent.element.visitFunName}(${element.visitorParam}, data)")
+                        addStatement("return ${parent.element.visitFunctionName}(${element.visitorParameterName}, data)")
                         returns(returnType.toPoetStarParameterized())
                     }.build())
                 }
@@ -119,7 +122,7 @@
     val transformTypeFunName = "transformType"
 
     fun FunSpec.Builder.addVisitTypeStatement(element: Element, field: Field) {
-        val visitorParam = element.visitorParam
+        val visitorParam = element.visitorParameterName
         val access = "$visitorParam.${field.name}"
         when (field) {
             is SingleField -> addStatement("$access = $transformTypeFunName($visitorParam, $access, data)")
@@ -137,7 +140,7 @@
 
     fun Element.getFieldsWithIrTypeType(insideParent: Boolean = false): List<Field> {
         val parentsFields = elementParents.flatMap { it.element.getFieldsWithIrTypeType(insideParent = true) }
-        if (insideParent && this.visitorParent != null) {
+        if (insideParent && this.parentInVisitor != null) {
             return parentsFields
         }
 
@@ -169,9 +172,9 @@
         }
         addFunction(abstractVisitFun.addModifiers(KModifier.ABSTRACT).build())
 
-        fun buildVisitFun(element: Element) = FunSpec.builder(element.visitFunName).apply {
+        fun buildVisitFun(element: Element) = FunSpec.builder(element.visitFunctionName).apply {
             addModifiers(KModifier.OVERRIDE)
-            addParameter(element.visitorParam, element.toPoetStarParameterized())
+            addParameter(element.visitorParameterName, element.toPoetStarParameterized())
             addParameter("data", d)
         }
 
@@ -180,11 +183,11 @@
             if (irTypeFields.isEmpty()) continue
 
             val returnType = element.getTransformExplicitType()
-            element.visitorParent?.let { _ ->
+            element.parentInVisitor?.let { _ ->
                 addFunction(buildVisitFun(element).apply {
                     returns(returnType.toPoetStarParameterized())
 
-                    val visitorParam = element.visitorParam
+                    val visitorParam = element.visitorParameterName
                     when (element.name) {
                         IrTree.memberAccessExpression.name -> {
                             if (irTypeFields.singleOrNull()?.name != "typeArguments") {
@@ -207,7 +210,7 @@
                         }
                         else -> irTypeFields.forEach { addVisitTypeStatement(element, it) }
                     }
-                    addStatement("return super.${element.visitFunName}($visitorParam, data)")
+                    addStatement("return super.${element.visitFunctionName}($visitorParam, data)")
                 }.build())
             }
         }
@@ -217,7 +220,7 @@
 }
 
 private fun Element.getTransformExplicitType(): Element {
-    return generateSequence(this) { it.visitorParent?.element }
+    return generateSequence(this) { it.parentInVisitor?.element }
         .firstNotNullOfOrNull {
             when {
                 it.transformByChildren -> it.transformerReturnType ?: it
diff --git a/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractElement.kt b/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractElement.kt
index 73c0bab..e89b30b 100644
--- a/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractElement.kt
+++ b/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractElement.kt
@@ -33,6 +33,21 @@
     val isSealed: Boolean
         get() = false
 
+    /**
+     * The name of the method in visitors used to visit this element.
+     */
+    val visitFunctionName: String
+
+    /**
+     * The name of the parameter representing this element in the visitor method used to visit this element.
+     */
+    val visitorParameterName: String
+
+    /**
+     * The default element to visit if the method for visiting this element is not overridden.
+     */
+    val parentInVisitor: Element?
+
     override val allParents: List<Element>
         get() = elementParents.map { it.element }
 
diff --git a/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractElementPrinter.kt b/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractElementPrinter.kt
index f8f389e..a5a65b9 100644
--- a/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractElementPrinter.kt
+++ b/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractElementPrinter.kt
@@ -149,14 +149,6 @@
     }
 }
 
-private fun ClassOrElementRef.inheritanceClauseParenthesis(): String = when (this) {
-    is ElementOrRef<*, *> -> element.kind.braces()
-    is ClassRef<*> -> when (kind) {
-        TypeKind.Class -> "()"
-        TypeKind.Interface -> ""
-    }
-}
-
 fun AbstractElement<*, *>.multipleUpperBoundsList(): String {
     val paramsWithMultipleUpperBounds = params.filter { it.bounds.size > 1 }.takeIf { it.isNotEmpty() } ?: return ""
     return buildString {
diff --git a/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractVisitorPrinter.kt b/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractVisitorPrinter.kt
new file mode 100644
index 0000000..a10c8fd
--- /dev/null
+++ b/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractVisitorPrinter.kt
@@ -0,0 +1,118 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.generators.tree
+
+import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.types.Variance
+import org.jetbrains.kotlin.utils.SmartPrinter
+import org.jetbrains.kotlin.utils.withIndent
+
+abstract class AbstractVisitorPrinter<Element : AbstractElement<Element, Field>, Field : AbstractField>(
+    val printer: SmartPrinter,
+    val visitSuperTypeByDefault: Boolean,
+) {
+    abstract val visitorType: ClassRef<*>
+
+    protected val resultTypeVariable = TypeVariable("R", emptyList(), Variance.OUT_VARIANCE)
+
+    protected val dataTypeVariable = TypeVariable("D", emptyList(), Variance.IN_VARIANCE)
+
+    abstract val visitorTypeParameters: List<TypeVariable>
+
+    abstract val visitorSuperType: ClassRef<PositionTypeParameterRef>?
+
+    abstract val allowTypeParametersInVisitorMethods: Boolean
+
+    open fun parentInVisitor(element: Element): Element? = element.parentInVisitor
+
+    protected fun SmartPrinter.printVisitMethodDeclaration(
+        element: Element,
+        additionalParameters: List<Pair<String, TypeRef>>,
+        returnType: TypeRef,
+        modality: Modality = Modality.FINAL,
+        override: Boolean = false,
+    ) {
+        val visitorParameterType = ElementRef(
+            element,
+            element.params.associateWith { if (allowTypeParametersInVisitorMethods) it else TypeRef.Star }
+        )
+        printFunctionDeclaration(
+            name = element.visitFunctionName,
+            parameters = listOf(element.visitorParameterName to visitorParameterType) + additionalParameters,
+            returnType = returnType,
+            typeParameters = if (allowTypeParametersInVisitorMethods) {
+                element.params
+            } else {
+                emptyList()
+            },
+            modality = modality,
+            override = override,
+        )
+        print(
+            element.multipleUpperBoundsList(),
+        )
+    }
+
+    protected fun printMethodDeclarationForElement(element: Element, modality: Modality, override: Boolean) {
+        val parentVisitorType = this@AbstractVisitorPrinter.visitorSuperType
+        val resultType = parentVisitorType?.args?.get(PositionTypeParameterRef(0)) ?: visitorTypeParameters[0]
+        val dataType = parentVisitorType?.args?.get(PositionTypeParameterRef(1)) ?: visitorTypeParameters[1]
+        printer.run {
+            println()
+            printVisitMethodDeclaration(
+                element,
+                additionalParameters = listOf("data" to dataType),
+                returnType = resultType,
+                modality = modality,
+                override = override
+            )
+        }
+    }
+
+    protected open fun printMethodsForElement(element: Element) {
+        val isInterface = visitorType.kind == TypeKind.Interface
+        printer.run {
+            val parentInVisitor = parentInVisitor(element)
+            if (parentInVisitor == null && !element.isRootElement) return
+            printMethodDeclarationForElement(
+                element,
+                modality = when {
+                    parentInVisitor == null && !isInterface -> Modality.ABSTRACT
+                    parentInVisitor != null && !isInterface -> Modality.OPEN
+                    else -> Modality.FINAL
+                },
+                override = parentInVisitor != null && visitorSuperType != null,
+            )
+            if (parentInVisitor != null) {
+                print(" = ", parentInVisitor.visitFunctionName, "(", element.visitorParameterName, ", data)")
+            }
+            println()
+        }
+    }
+
+    fun printVisitor(elements: List<Element>) {
+        val visitorType = this.visitorType
+        printer.run {
+            when (visitorType.kind) {
+                TypeKind.Interface -> print("interface ")
+                TypeKind.Class -> print("abstract class ")
+            }
+            print(visitorType.simpleName, visitorTypeParameters.generics, " ")
+            visitorSuperType?.let {
+                print(": ", it.typeWithArguments, it.inheritanceClauseParenthesis(), " ")
+            }
+            println("{")
+            withIndent {
+                for (element in elements) {
+                    if (element.isRootElement && visitSuperTypeByDefault) continue
+                    if (visitSuperTypeByDefault && parentInVisitor(element) == null) continue
+                    printMethodsForElement(element)
+                }
+            }
+            println("}")
+        }
+    }
+}
\ No newline at end of file
diff --git a/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractVisitorVoidPrinter.kt b/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractVisitorVoidPrinter.kt
new file mode 100644
index 0000000..abbbb7e
--- /dev/null
+++ b/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractVisitorVoidPrinter.kt
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.generators.tree
+
+import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.utils.SmartPrinter
+import org.jetbrains.kotlin.utils.withIndent
+
+abstract class AbstractVisitorVoidPrinter<Element, Field>(
+    printer: SmartPrinter,
+    visitSuperTypeByDefault: Boolean,
+) : AbstractVisitorPrinter<Element, Field>(printer, visitSuperTypeByDefault)
+        where Element : AbstractElement<Element, Field>,
+              Field : AbstractField {
+
+    final override val visitorTypeParameters: List<TypeVariable>
+        get() = emptyList()
+
+    abstract val visitorSuperClass: ClassRef<PositionTypeParameterRef>
+
+    final override val visitorSuperType: ClassRef<PositionTypeParameterRef>
+        get() = if (visitSuperTypeByDefault)
+            visitorSuperClass
+        else
+            visitorSuperClass.withArgs(StandardTypes.unit, StandardTypes.nothing.copy(nullable = true))
+
+    abstract val useAbstractMethodForRootElement: Boolean
+
+    abstract val overriddenVisitMethodsAreFinal: Boolean
+
+    final override fun printMethodsForElement(element: Element) {
+        val parentInVisitor = parentInVisitor(element)
+        if (!element.isRootElement && parentInVisitor == null) return
+
+        val isAbstractVisitRootElementMethod = element.isRootElement && useAbstractMethodForRootElement
+
+        if (!isAbstractVisitRootElementMethod) {
+            printMethodDeclarationForElement(
+                element,
+                modality = if (overriddenVisitMethodsAreFinal) Modality.FINAL else Modality.OPEN,
+                override = true,
+            )
+        }
+
+        fun SmartPrinter.printBody(parentInVisitor: Element?) {
+            if (!isAbstractVisitRootElementMethod) {
+                println(" {")
+                if (parentInVisitor != null) {
+                    withIndent {
+                        println(parentInVisitor.visitFunctionName, "(", element.visitorParameterName, ")")
+                    }
+                }
+                println("}")
+            }
+        }
+
+        printer.run {
+            printBody(element)
+            println()
+            printVisitMethodDeclaration(
+                element,
+                additionalParameters = emptyList(),
+                returnType = StandardTypes.unit,
+                modality = when {
+                    element.isRootElement && visitorType.kind == TypeKind.Class -> Modality.ABSTRACT
+                    !element.isRootElement && visitorType.kind == TypeKind.Class -> Modality.OPEN
+                    else -> Modality.FINAL
+                }
+            )
+            if (isAbstractVisitRootElementMethod) {
+                println()
+            }
+            printBody(parentInVisitor)
+        }
+    }
+}
\ No newline at end of file
diff --git a/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/StandardTypes.kt b/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/StandardTypes.kt
index cbaffe6..7a3ba47 100644
--- a/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/StandardTypes.kt
+++ b/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/StandardTypes.kt
@@ -7,6 +7,7 @@
 
 object StandardTypes {
     val unit = type<Unit>()
+    val nothing = type("kotlin", "Nothing")
     val boolean = type<Boolean>()
     val string = type<String>()
     val int = type<Int>()
diff --git a/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/TypeRef.kt b/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/TypeRef.kt
index b89c42e..7480592 100644
--- a/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/TypeRef.kt
+++ b/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/TypeRef.kt
@@ -64,7 +64,7 @@
     override val fullQualifiedName: String
         get() = canonicalName
 
-    override fun getTypeWithArguments(notNull: Boolean): String = type + generics
+    override fun getTypeWithArguments(notNull: Boolean): String = type + generics + (if (nullable) "?" else "")
 
     /**
      * The enclosing classes, outermost first, followed by the simple name. This is `["Map", "Entry"]`
@@ -75,6 +75,13 @@
     override fun copy(args: Map<P, TypeRef>) = ClassRef(kind, names, args, nullable)
     override fun copy(nullable: Boolean) = ClassRef(kind, names, args, nullable)
 
+    override fun equals(other: Any?): Boolean {
+        if (other !is ClassRef<*>) return false
+        return names == other.names && args == other.args && nullable == other.nullable
+    }
+
+    override fun hashCode(): Int = Objects.hash(names, args, nullable)
+
     override fun toString() = canonicalName
 }
 
@@ -169,7 +176,23 @@
     name: String,
     val bounds: List<TypeRef>,
     val variance: Variance,
-) : NamedTypeParameterRef(name)
+) : NamedTypeParameterRef(name) {
+
+    override fun toString(): String = buildString {
+        if (variance != Variance.INVARIANT) {
+            append(variance)
+            append(" ")
+        }
+        append(name)
+        bounds.singleOrNull()?.let {
+            append(" : ")
+            append(it.typeWithArguments)
+        }
+    }
+}
+
+val List<TypeVariable>.generics: String
+    get() = if (isNotEmpty()) joinToString(prefix = "<", postfix = ">") else ""
 
 fun <P : TypeParameterRef> KClass<*>.asRef(): ClassRef<P> {
     val qualifiedName = this.qualifiedName ?: error("$this doesn't have qualified name and thus cannot be converted to ClassRef")
@@ -194,3 +217,11 @@
         is ElementOrRef<*, *> -> element.kind!!.typeKind
         is ClassRef<*> -> kind
     }
+
+internal fun ClassOrElementRef.inheritanceClauseParenthesis(): String = when (this) {
+    is ElementOrRef<*, *> -> element.kind.braces()
+    is ClassRef<*> -> when (kind) {
+        TypeKind.Class -> "()"
+        TypeKind.Interface -> ""
+    }
+}
diff --git a/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/printUtils.kt b/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/printUtils.kt
index ad03f2d..33c3245 100644
--- a/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/printUtils.kt
+++ b/generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/printUtils.kt
@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.generators.tree
 
+import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.utils.SmartPrinter
 import java.io.File
 
@@ -35,4 +36,41 @@
         }
     }
     println(" */")
+}
+
+fun SmartPrinter.printFunctionDeclaration(
+    name: String,
+    parameters: List<Pair<String, TypeRef>>,
+    returnType: TypeRef,
+    typeParameters: List<TypeVariable> = emptyList(),
+    modality: Modality = Modality.FINAL,
+    override: Boolean = false,
+) {
+    when (modality) {
+        Modality.FINAL -> if (override) {
+            print("final ")
+        }
+        Modality.OPEN -> if (!override) {
+            print("open ")
+        }
+        Modality.ABSTRACT -> print("abstract ")
+        Modality.SEALED -> error("Function cannot be sealed")
+    }
+    if (override) {
+        print("override ")
+    }
+    print("fun ")
+    if (typeParameters.isNotEmpty()) {
+        print(typeParameters.generics)
+        print(" ")
+    }
+    print(name)
+    print(
+        parameters.joinToString(prefix = "(", postfix = ")") { (name, type) ->
+            "$name: ${type.typeWithArguments}"
+        }
+    )
+    if (returnType != StandardTypes.unit) {
+        print(": ", returnType.typeWithArguments)
+    }
 }
\ No newline at end of file