[FIR/IR generator] Commonize visitor printing logic

This is a step towards commonizing the code generator between
FIR and IR: KT-61970

Also, don't use kotlinpoet for generating IR visitors (KT-61703)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt

@@ -19,6 +19,7 @@ import org.jetbrains.kotlin.fir.references.*
 import org.jetbrains.kotlin.fir.types.*
 
 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)
@@ -188,5 +189,4 @@ abstract class FirDefaultVisitor<out R, in D> : FirVisitor<R, D>() {
     override fun visitRawContractDescription(rawContractDescription: FirRawContractDescription, data: D): R = visitContractDescription(rawContractDescription, data)
 
     override fun visitResolvedContractDescription(resolvedContractDescription: FirResolvedContractDescription, data: D): R = visitContractDescription(resolvedContractDescription, data)
-
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt

@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.fir.references.*
 import org.jetbrains.kotlin.fir.types.*
 
 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)
@@ -328,5 +329,4 @@ abstract class FirVisitor<out R, in D> {
     open fun visitRawContractDescription(rawContractDescription: FirRawContractDescription, data: D): R = visitElement(rawContractDescription, data)
 
     open fun visitResolvedContractDescription(resolvedContractDescription: FirResolvedContractDescription, data: D): R = visitElement(resolvedContractDescription, data)
-
 }

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt

@@ -734,6 +734,10 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
             +field("partiallyResolvedTypeRef", typeRef, nullable = true).withTransform()
         }
 
+        resolvedErrorReference.configure {
+            element.customParentInVisitor = resolvedNamedReference
+        }
+
         intersectionTypeRef.configure {
             +field("leftType", typeRef)
             +field("rightType", typeRef)

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt

@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.descriptors.Visibility
 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
@@ -116,11 +117,11 @@ val annotationResolvePhaseType = generatedType("expressions", "FirAnnotationReso
 
 val typeRefMarkerType = type("mpp", "TypeRefMarker")
 
-val firVisitorType = type("fir.visitors", "FirVisitor", kind = TypeKind.Class)
+val firVisitorType = generatedType("visitors", "FirVisitor")
-val firVisitorVoidType = type("fir.visitors", "FirVisitorVoid", kind = TypeKind.Class)
+val firVisitorVoidType = generatedType("visitors", "FirVisitorVoid")
-val firDefaultVisitorType = type("fir.visitors", "FirDefaultVisitor", kind = TypeKind.Class)
+val firDefaultVisitorType = generatedType("visitors", "FirDefaultVisitor")
-val firDefaultVisitorVoidType = type("fir.visitors", "FirDefaultVisitorVoid", kind = TypeKind.Class)
+val firDefaultVisitorVoidType = generatedType("visitors", "FirDefaultVisitorVoid")
-val firTransformerType = type("fir.visitors", "FirTransformer", kind = TypeKind.Class)
+val firTransformerType = generatedType("visitors", "FirTransformer")
 
 val resolveStateAccessAnnotation = type("fir.declarations", "ResolveStateAccess", kind = TypeKind.Class)
 val unresolvedExpressionTypeAccessAnnotation = type("fir.expressions", "UnresolvedExpressionTypeAccess", kind = TypeKind.Class)

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
@@ -78,6 +79,17 @@ class Element(override val name: String, override val propertyName: String, kind
     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 }

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/element.kt

@@ -40,7 +40,7 @@ fun SmartPrinter.printElement(element: Element) {
 
         printKDoc(element.extendedKDoc())
         print("${kind!!.title} $typeName")
-        print(typeParameters())
+        print(params.typeParameters())
         val parentRefs = element.parentRefs
         if (parentRefs.isNotEmpty()) {
             print(
@@ -49,7 +49,7 @@ fun SmartPrinter.printElement(element: Element) {
                 }
             )
         }
-        print(multipleUpperBoundsList())
+        print(params.multipleUpperBoundsList())
         println(" {")
         withIndent {
             allFields.forEach { field ->

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/implementation.kt

@@ -67,7 +67,7 @@ fun SmartPrinter.printImplementation(implementation: Implementation) {
             print("internal ")
         }
         print("${kind!!.title} ${this.typeName}")
-        print(element.typeParameters(end = " "))
+        print(element.params.typeParameters(end = " "))
 
         val isInterface = kind == ImplementationKind.Interface || kind == ImplementationKind.SealedInterface
         val isAbstract = kind == ImplementationKind.AbstractClass || kind == ImplementationKind.SealedClass

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/transformer.kt

@@ -5,71 +5,107 @@
 
 package org.jetbrains.kotlin.fir.tree.generator.printer
 
+import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.fir.tree.generator.context.AbstractFirTreeBuilder
+import org.jetbrains.kotlin.fir.tree.generator.firTransformerType
+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.generators.tree.*
+import org.jetbrains.kotlin.generators.tree.printer.FunctionParameter
 import org.jetbrains.kotlin.generators.tree.printer.GeneratedFile
-import org.jetbrains.kotlin.generators.tree.printer.multipleUpperBoundsList
+import org.jetbrains.kotlin.generators.tree.printer.printFunctionDeclaration
 import org.jetbrains.kotlin.generators.tree.printer.printGeneratedType
-import org.jetbrains.kotlin.generators.tree.printer.typeParameters
+import org.jetbrains.kotlin.types.Variance
-import org.jetbrains.kotlin.generators.tree.render
+import org.jetbrains.kotlin.utils.SmartPrinter
 import org.jetbrains.kotlin.utils.withIndent
 import java.io.File
 
-fun printTransformer(elements: List<Element>, generationPath: File): GeneratedFile =
+private class TransformerPrinter(
-    printGeneratedType(generationPath, TREE_GENERATOR_README, VISITOR_PACKAGE, "FirTransformer") {
+    printer: SmartPrinter,
-        println()
+) : AbstractVisitorPrinter<Element, Field>(printer, visitSuperTypeByDefault = false) {
-        println("abstract class FirTransformer<in D> : FirVisitor<FirElement, D>() {")
+
-        println()
+    override val visitorType: ClassRef<*>
-        withIndent {
+        get() = firTransformerType
-            println("abstract fun <E : FirElement> transformElement(element: E, data: D): E")
+
+    override val visitorSuperType: ClassRef<PositionTypeParameterRef>
+        get() = firVisitorType.withArgs(AbstractFirTreeBuilder.baseFirElement, visitorDataType)
+
+    override val visitorTypeParameters: List<TypeVariable>
+        get() = listOf(dataTypeVariable)
+
+    override val visitorDataType: TypeRef
+        get() = dataTypeVariable
+
+    override fun visitMethodReturnType(element: Element) = element.transformerType
+
+    override val allowTypeParametersInVisitorMethods: Boolean
+        get() = true
+
+    context(ImportCollector)
+    override fun printMethodsForElement(element: Element) {
+        printer.run {
             println()
-            for (element in elements) {
+            val elementParameterName = element.safeDecapitalizedName
-                if (element == AbstractFirTreeBuilder.baseFirElement) continue
+            if (element.isRootElement) {
-                val varName = element.safeDecapitalizedName
+                val elementTP = TypeVariable("E", listOf(element), variance = Variance.INVARIANT)
-                print("open fun ")
+                printFunctionDeclaration(
-                element.typeParameters(end = " ").takeIf { it.isNotBlank() }?.let { print(it) }
+                    name = "transformElement",
-                println(
+                    parameters = listOf(
-                    "transform",
+                        FunctionParameter(elementParameterName, elementTP),
-                    element.name,
+                        FunctionParameter("data", dataTypeVariable)
-                    "(",
+                    ),
-                    varName,
+                    returnType = elementTP,
-                    ": ",
+                    typeParameters = listOf(elementTP),
-                    element.render(),
+                    modality = Modality.ABSTRACT,
-                    ", data: D): ",
-                    element.transformerType.render(),
-                    element.multipleUpperBoundsList(),
-                    " {",
                 )
+                println()
+            } else {
+                printFunctionDeclaration(
+                    name = "transform" + element.name,
+                    parameters = listOf(
+                        FunctionParameter(elementParameterName, element),
+                        FunctionParameter("data", dataTypeVariable)
+                    ),
+                    returnType = visitMethodReturnType(element),
+                    typeParameters = element.params,
+                    modality = Modality.OPEN,
+                )
+                println(" {")
                 withIndent {
-                    println("return transformElement($varName, data)")
+                    println("return transformElement(", elementParameterName, ", data)")
                 }
                 println("}")
-                println()
             }
-
+            println()
-            for (element in elements) {
+            printVisitMethodDeclaration(
-                val varName = element.safeDecapitalizedName
+                element = element,
-                print("final override fun ")
+                modality = Modality.FINAL,
-                element.typeParameters(end = " ").takeIf { it.isNotBlank() }?.let { print(it) }
+                override = true,
-
+            )
+            println(" {")
+            withIndent {
                 println(
-                    "visit",
+                    "return transform",
                     element.name,
                     "(",
-                    varName,
+                    element.safeDecapitalizedName,
-                    ": ",
+                    ", ",
-                    element.render(),
+                    "data)"
-                    ", data: D): ",
-                    element.transformerType.render(),
-                    element.multipleUpperBoundsList(),
-                    " {"
                 )
-                withIndent {
-                    println("return transform${element.name}($varName, data)")
-                }
-                println("}")
-                println()
             }
+            println("}")
         }
-        println("}")
+    }
+}
+
+fun printTransformer(elements: List<Element>, generationPath: File): GeneratedFile =
+    printGeneratedType(
+        generationPath,
+        TREE_GENERATOR_README,
+        firTransformerType.packageName,
+        firTransformerType.simpleName,
+    ) {
+        println()
+        TransformerPrinter(this).printVisitor(elements)
     }

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/printer/visitor.kt

@@ -5,176 +5,121 @@
 
 package org.jetbrains.kotlin.fir.tree.generator.printer
 
-import org.jetbrains.kotlin.fir.tree.generator.FirTreeBuilder
 import org.jetbrains.kotlin.fir.tree.generator.context.AbstractFirTreeBuilder
+import org.jetbrains.kotlin.fir.tree.generator.firDefaultVisitorType
+import org.jetbrains.kotlin.fir.tree.generator.firDefaultVisitorVoidType
+import org.jetbrains.kotlin.fir.tree.generator.firVisitorType
+import org.jetbrains.kotlin.fir.tree.generator.firVisitorVoidType
 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.generators.tree.printer.GeneratedFile
-import org.jetbrains.kotlin.generators.tree.printer.multipleUpperBoundsList
 import org.jetbrains.kotlin.generators.tree.printer.printGeneratedType
-import org.jetbrains.kotlin.generators.tree.printer.typeParameters
+import org.jetbrains.kotlin.utils.SmartPrinter
-import org.jetbrains.kotlin.generators.tree.render
-import org.jetbrains.kotlin.utils.withIndent
 import java.io.File
 
-private val elementsWithMultipleSupertypesForDefaultVisitor = mapOf(
+private class VisitorPrinter(
-    FirTreeBuilder.resolvedErrorReference to FirTreeBuilder.resolvedNamedReference
+    printer: SmartPrinter,
-)
+    override val visitorType: ClassRef<*>,
+    visitSuperTypeByDefault: Boolean,
+) : AbstractVisitorPrinter<Element, Field>(printer, visitSuperTypeByDefault) {
 
-private fun Element.isAcceptableForDefaultVisiting(): Boolean {
+    override val visitorTypeParameters: List<TypeVariable>
-    if (this == AbstractFirTreeBuilder.baseFirElement) return false
+        get() = listOf(resultTypeVariable, dataTypeVariable)
-    val hasSingleSupertype = elementParents.size == 1 && !elementParents[0].element.isRootElement
-    return hasSingleSupertype || this in elementsWithMultipleSupertypesForDefaultVisitor
-}
 
-private fun Element.getNameOfSupertypeForDefaultVisiting(): String {
+    override val visitorSuperType: ClassRef<PositionTypeParameterRef>? =
-    val parentForDefaultVisiting =
+        firVisitorType.takeIf { visitSuperTypeByDefault }?.withArgs(resultTypeVariable, dataTypeVariable)
-        elementParents.singleOrNull()?.element ?: elementsWithMultipleSupertypesForDefaultVisitor.getValue(this)
-    return parentForDefaultVisiting.name
-}
 
-fun printVisitor(elements: List<Element>, generationPath: File, visitSuperTypeByDefault: Boolean): GeneratedFile {
+    override val visitorDataType: TypeRef
-    val className = if (visitSuperTypeByDefault) "FirDefaultVisitor" else "FirVisitor"
+        get() = dataTypeVariable
-    return printGeneratedType(generationPath, TREE_GENERATOR_README, VISITOR_PACKAGE, className) {
-        println()
 
-        print("abstract class $className<out R, in D> ")
+    override fun visitMethodReturnType(element: Element) = resultTypeVariable
-        if (visitSuperTypeByDefault) {
-            print(": FirVisitor<R, D>() ")
-        }
-        println("{")
 
-        pushIndent()
+    override val allowTypeParametersInVisitorMethods: Boolean
-        if (!visitSuperTypeByDefault) {
+        get() = true
-            println("abstract fun visitElement(element: FirElement, data: D): R\n")
+
-        }
+    override fun parentInVisitor(element: Element): Element? = when {
-        for (element in elements) {
+        element.isRootElement -> null
-            if (element == AbstractFirTreeBuilder.baseFirElement) continue
+        visitSuperTypeByDefault -> element.parentInVisitor
-            if (visitSuperTypeByDefault && !element.isAcceptableForDefaultVisiting()) continue
+        else -> AbstractFirTreeBuilder.baseFirElement
-            with(element) {
-                val varName = safeDecapitalizedName
-                if (visitSuperTypeByDefault) {
-                    print("override")
-                } else {
-                    print("open")
-                }
-                print(
-                    " fun ",
-                    typeParameters(end = " "),
-                    "visit",
-                    name,
-                    "(",
-                    varName,
-                    ": ",
-                    render(),
-                    ", data: D): R",
-                    multipleUpperBoundsList(),
-                    " = visit"
-                )
-                if (visitSuperTypeByDefault) {
-                    print(element.getNameOfSupertypeForDefaultVisiting())
-                } else {
-                    print("Element")
-                }
-                println("($varName, data)")
-                println()
-            }
-        }
-        popIndent()
-        println("}")
     }
 }
 
+fun printVisitor(elements: List<Element>, generationPath: File, visitSuperTypeByDefault: Boolean) =
+    printVisitorCommon(
+        elements,
+        generationPath,
+        if (visitSuperTypeByDefault) firDefaultVisitorType else firVisitorType,
+    ) { printer, visitorType ->
+        VisitorPrinter(printer, visitorType, visitSuperTypeByDefault)
+    }
 
-fun printVisitorVoid(elements: List<Element>, generationPath: File): GeneratedFile =
+private class VisitorVoidPrinter(
-    printGeneratedType(generationPath, TREE_GENERATOR_README, VISITOR_PACKAGE, "FirVisitorVoid") {
+    printer: SmartPrinter,
-        println()
+    override val visitorType: ClassRef<*>,
-        println("abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {")
+) : AbstractVisitorVoidPrinter<Element, Field>(printer, visitSuperTypeByDefault = false) {
 
-        withIndent {
+    override val visitorSuperClass: ClassRef<PositionTypeParameterRef>
-            println("abstract fun visitElement(element: FirElement)")
+        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, firVisitorVoidType, ::VisitorVoidPrinter)
+
+private class DefaultVisitorVoidPrinter(
+    printer: SmartPrinter,
+    override val visitorType: ClassRef<*>,
+) : AbstractVisitorPrinter<Element, Field>(printer, visitSuperTypeByDefault = true) {
+
+    override val visitorTypeParameters: List<TypeVariable>
+        get() = emptyList()
+
+    override val visitorDataType: TypeRef
+        get() = StandardTypes.nothing.copy(nullable = true)
+
+    override fun visitMethodReturnType(element: Element) = StandardTypes.unit
+
+    override val visitorSuperType: ClassRef<PositionTypeParameterRef>
+        get() = firVisitorVoidType
+
+    override val allowTypeParametersInVisitorMethods: Boolean
+        get() = true
+
+    context(ImportCollector)
+    override fun printMethodsForElement(element: Element) {
+        printer.run {
+            printVisitMethodDeclaration(
+                element,
+                hasDataParameter = false,
+                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,
-                        ": ",
-                        render(),
-                        ")",
-                        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,
-                        ": ",
-                        render(),
-                        ", data: Nothing?)",
-                        multipleUpperBoundsList(),
-                        " {"
-                    )
-                    withIndent {
-                        println("visit$name($varName)")
-                    }
-                    println("}")
-                    println()
-                }
-            }
         }
-        println("}")
     }
+}
 
-fun printDefaultVisitorVoid(elements: List<Element>, generationPath: File): GeneratedFile =
+fun printDefaultVisitorVoid(elements: List<Element>, generationPath: File) =
-    printGeneratedType(generationPath, TREE_GENERATOR_README, VISITOR_PACKAGE, "FirDefaultVisitorVoid") {
+    printVisitorCommon(elements, generationPath, firDefaultVisitorVoidType, ::DefaultVisitorVoidPrinter)
+
+private fun printVisitorCommon(
+    elements: List<Element>,
+    generationPath: File,
+    visitorType: ClassRef<*>,
+    makePrinter: (SmartPrinter, ClassRef<*>) -> AbstractVisitorPrinter<Element, Field>,
+): GeneratedFile =
+    printGeneratedType(generationPath, TREE_GENERATOR_README, visitorType.packageName, visitorType.simpleName) {
         println()
-        println("abstract class FirDefaultVisitorVoid : FirVisitorVoid() {")
+        makePrinter(this, visitorType).printVisitor(elements)
-
+    }
-        pushIndent()
-        for (element in elements) {
-            if (!element.isAcceptableForDefaultVisiting()) continue
-            with(element) {
-                val varName = safeDecapitalizedName
-                println(
-                    "override fun ",
-                    typeParameters(end = " "),
-                    "visit",
-                    name,
-                    "(",
-                    varName,
-                    ": ",
-                    render(),
-                    ")",
-                    multipleUpperBoundsList(),
-                    " = visit",
-                    getNameOfSupertypeForDefaultVisiting(),
-                    "(",
-                    varName,
-                    ")"
-                )
-                println()
-            }
-        }
-        popIndent()
-        println("}")
-    }

compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrElementTransformer.kt

@@ -10,90 +10,11 @@ package org.jetbrains.kotlin.ir.visitors
 
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrStatement
-import org.jetbrains.kotlin.ir.declarations.IrAnonymousInitializer
+import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.declarations.IrClass
+import org.jetbrains.kotlin.ir.expressions.*
-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
 
 interface IrElementTransformer<in D> : IrElementVisitor<IrElement, D> {
+
     override fun visitElement(element: IrElement, data: D): IrElement {
         element.transformChildren(this, data)
         return element
@@ -105,61 +26,59 @@ interface IrElementTransformer<in D> : IrElementVisitor<IrElement, D> {
     }
 
     override fun visitValueParameter(declaration: IrValueParameter, data: D): IrStatement =
-            visitDeclaration(declaration, data)
+        visitDeclaration(declaration, data)
 
     override fun visitClass(declaration: IrClass, data: D): IrStatement =
-            visitDeclaration(declaration, data)
+        visitDeclaration(declaration, data)
 
-    override fun visitAnonymousInitializer(declaration: IrAnonymousInitializer, data: D):
+    override fun visitAnonymousInitializer(declaration: IrAnonymousInitializer, data: D): IrStatement =
-            IrStatement = visitDeclaration(declaration, data)
+        visitDeclaration(declaration, data)
 
     override fun visitTypeParameter(declaration: IrTypeParameter, data: D): IrStatement =
-            visitDeclaration(declaration, data)
+        visitDeclaration(declaration, data)
 
     override fun visitFunction(declaration: IrFunction, data: D): IrStatement =
-            visitDeclaration(declaration, data)
+        visitDeclaration(declaration, data)
 
     override fun visitConstructor(declaration: IrConstructor, data: D): IrStatement =
-            visitFunction(declaration, data)
+        visitFunction(declaration, data)
 
     override fun visitEnumEntry(declaration: IrEnumEntry, data: D): IrStatement =
-            visitDeclaration(declaration, data)
+        visitDeclaration(declaration, data)
 
-    override fun visitErrorDeclaration(declaration: IrErrorDeclaration, data: D):
+    override fun visitErrorDeclaration(declaration: IrErrorDeclaration, data: D): IrStatement =
-            IrStatement = visitDeclaration(declaration, data)
+        visitDeclaration(declaration, data)
 
     override fun visitField(declaration: IrField, data: D): IrStatement =
-            visitDeclaration(declaration, data)
+        visitDeclaration(declaration, data)
 
-    override fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty,
+    override fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty, data: D): IrStatement =
-            data: D): IrStatement = visitDeclaration(declaration, data)
+        visitDeclaration(declaration, data)
 
-    override fun visitModuleFragment(declaration: IrModuleFragment, data: D):
+    override fun visitModuleFragment(declaration: IrModuleFragment, data: D): IrModuleFragment {
-            IrModuleFragment {
         declaration.transformChildren(this, data)
         return declaration
     }
 
     override fun visitProperty(declaration: IrProperty, data: D): IrStatement =
-            visitDeclaration(declaration, data)
+        visitDeclaration(declaration, data)
 
     override fun visitScript(declaration: IrScript, data: D): IrStatement =
-            visitDeclaration(declaration, data)
+        visitDeclaration(declaration, data)
 
     override fun visitSimpleFunction(declaration: IrSimpleFunction, data: D): IrStatement =
-            visitFunction(declaration, data)
+        visitFunction(declaration, data)
 
     override fun visitTypeAlias(declaration: IrTypeAlias, data: D): IrStatement =
-            visitDeclaration(declaration, data)
+        visitDeclaration(declaration, data)
 
     override fun visitVariable(declaration: IrVariable, data: D): IrStatement =
-            visitDeclaration(declaration, data)
+        visitDeclaration(declaration, data)
 
     override fun visitPackageFragment(declaration: IrPackageFragment, data: D): IrElement =
-            visitElement(declaration, data)
+        visitElement(declaration, data)
 
-    override fun visitExternalPackageFragment(declaration: IrExternalPackageFragment,
+    override fun visitExternalPackageFragment(declaration: IrExternalPackageFragment, data: D): IrExternalPackageFragment {
-            data: D): IrExternalPackageFragment {
         declaration.transformChildren(this, data)
         return declaration
     }
@@ -180,156 +99,156 @@ interface IrElementTransformer<in D> : IrElementVisitor<IrElement, D> {
     }
 
     override fun visitExpressionBody(body: IrExpressionBody, data: D): IrBody =
-            visitBody(body, data)
+        visitBody(body, data)
 
-    override fun visitBlockBody(body: IrBlockBody, data: D): IrBody = visitBody(body, data)
+    override fun visitBlockBody(body: IrBlockBody, data: D): IrBody =
+        visitBody(body, data)
 
-    override fun visitDeclarationReference(expression: IrDeclarationReference, data: D):
+    override fun visitDeclarationReference(expression: IrDeclarationReference, data: D): IrExpression =
-            IrExpression = visitExpression(expression, data)
+        visitExpression(expression, data)
 
-    override fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: D):
+    override fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: D): IrElement =
-            IrElement = visitDeclarationReference(expression, data)
+        visitDeclarationReference(expression, data)
 
-    override fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: D):
+    override fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: D): IrElement =
-            IrElement = visitMemberAccess(expression, data)
+        visitMemberAccess(expression, data)
 
     override fun visitConstructorCall(expression: IrConstructorCall, data: D): IrElement =
-            visitFunctionAccess(expression, data)
+        visitFunctionAccess(expression, data)
 
-    override fun visitSingletonReference(expression: IrGetSingletonValue, data: D):
+    override fun visitSingletonReference(expression: IrGetSingletonValue, data: D): IrExpression =
-            IrExpression = visitDeclarationReference(expression, data)
+        visitDeclarationReference(expression, data)
 
     override fun visitGetObjectValue(expression: IrGetObjectValue, data: D): IrExpression =
-            visitSingletonReference(expression, data)
+        visitSingletonReference(expression, data)
 
     override fun visitGetEnumValue(expression: IrGetEnumValue, data: D): IrExpression =
-            visitSingletonReference(expression, data)
+        visitSingletonReference(expression, data)
 
-    override fun visitRawFunctionReference(expression: IrRawFunctionReference, data: D):
+    override fun visitRawFunctionReference(expression: IrRawFunctionReference, data: D): IrExpression =
-            IrExpression = visitDeclarationReference(expression, data)
+        visitDeclarationReference(expression, data)
 
-    override fun visitContainerExpression(expression: IrContainerExpression, data: D):
+    override fun visitContainerExpression(expression: IrContainerExpression, data: D): IrExpression =
-            IrExpression = visitExpression(expression, data)
+        visitExpression(expression, data)
 
     override fun visitBlock(expression: IrBlock, data: D): IrExpression =
-            visitContainerExpression(expression, data)
+        visitContainerExpression(expression, data)
 
     override fun visitComposite(expression: IrComposite, data: D): IrExpression =
-            visitContainerExpression(expression, data)
+        visitContainerExpression(expression, data)
 
     override fun visitSyntheticBody(body: IrSyntheticBody, data: D): IrBody =
-            visitBody(body, data)
+        visitBody(body, data)
 
     override fun visitBreakContinue(jump: IrBreakContinue, data: D): IrExpression =
-            visitExpression(jump, data)
+        visitExpression(jump, data)
 
     override fun visitBreak(jump: IrBreak, data: D): IrExpression =
-            visitBreakContinue(jump, data)
+        visitBreakContinue(jump, data)
 
     override fun visitContinue(jump: IrContinue, data: D): IrExpression =
-            visitBreakContinue(jump, data)
+        visitBreakContinue(jump, data)
 
     override fun visitCall(expression: IrCall, data: D): IrElement =
-            visitFunctionAccess(expression, data)
+        visitFunctionAccess(expression, data)
 
-    override fun visitCallableReference(expression: IrCallableReference<*>, data: D):
+    override fun visitCallableReference(expression: IrCallableReference<*>, data: D): IrElement =
-            IrElement = visitMemberAccess(expression, data)
+        visitMemberAccess(expression, data)
 
-    override fun visitFunctionReference(expression: IrFunctionReference, data: D):
+    override fun visitFunctionReference(expression: IrFunctionReference, data: D): IrElement =
-            IrElement = visitCallableReference(expression, data)
+        visitCallableReference(expression, data)
 
-    override fun visitPropertyReference(expression: IrPropertyReference, data: D):
+    override fun visitPropertyReference(expression: IrPropertyReference, data: D): IrElement =
-            IrElement = visitCallableReference(expression, data)
+        visitCallableReference(expression, data)
 
-    override
+    override fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference, data: D): IrElement =
-            fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference,
+        visitCallableReference(expression, data)
-            data: D): IrElement = visitCallableReference(expression, data)
 
     override fun visitClassReference(expression: IrClassReference, data: D): IrExpression =
-            visitDeclarationReference(expression, data)
+        visitDeclarationReference(expression, data)
 
     override fun visitConst(expression: IrConst<*>, data: D): IrExpression =
-            visitExpression(expression, data)
+        visitExpression(expression, data)
 
-    override fun visitConstantValue(expression: IrConstantValue, data: D):
+    override fun visitConstantValue(expression: IrConstantValue, data: D): IrConstantValue {
-            IrConstantValue {
         expression.transformChildren(this, data)
         return expression
     }
 
-    override fun visitConstantPrimitive(expression: IrConstantPrimitive, data: D):
+    override fun visitConstantPrimitive(expression: IrConstantPrimitive, data: D): IrConstantValue =
-            IrConstantValue = visitConstantValue(expression, data)
+        visitConstantValue(expression, data)
 
-    override fun visitConstantObject(expression: IrConstantObject, data: D):
+    override fun visitConstantObject(expression: IrConstantObject, data: D): IrConstantValue =
-            IrConstantValue = visitConstantValue(expression, data)
+        visitConstantValue(expression, data)
 
-    override fun visitConstantArray(expression: IrConstantArray, data: D): IrConstantValue
+    override fun visitConstantArray(expression: IrConstantArray, data: D): IrConstantValue =
-            = visitConstantValue(expression, data)
+        visitConstantValue(expression, data)
 
-    override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall,
+    override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall, data: D): IrElement =
-            data: D): IrElement = visitFunctionAccess(expression, data)
+        visitFunctionAccess(expression, data)
 
-    override fun visitDynamicExpression(expression: IrDynamicExpression, data: D):
+    override fun visitDynamicExpression(expression: IrDynamicExpression, data: D): IrExpression =
-            IrExpression = visitExpression(expression, data)
+        visitExpression(expression, data)
 
-    override fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression,
+    override fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression, data: D): IrExpression =
-            data: D): IrExpression = visitDynamicExpression(expression, data)
+        visitDynamicExpression(expression, data)
 
-    override fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression,
+    override fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression, data: D): IrExpression =
-            data: D): IrExpression = visitDynamicExpression(expression, data)
+        visitDynamicExpression(expression, data)
 
-    override fun visitEnumConstructorCall(expression: IrEnumConstructorCall, data: D):
+    override fun visitEnumConstructorCall(expression: IrEnumConstructorCall, data: D): IrElement =
-            IrElement = visitFunctionAccess(expression, data)
+        visitFunctionAccess(expression, data)
 
-    override fun visitErrorExpression(expression: IrErrorExpression, data: D): IrExpression
+    override fun visitErrorExpression(expression: IrErrorExpression, data: D): IrExpression =
-            = visitExpression(expression, data)
+        visitExpression(expression, data)
 
-    override fun visitErrorCallExpression(expression: IrErrorCallExpression, data: D):
+    override fun visitErrorCallExpression(expression: IrErrorCallExpression, data: D): IrExpression =
-            IrExpression = visitErrorExpression(expression, data)
+        visitErrorExpression(expression, data)
 
-    override fun visitFieldAccess(expression: IrFieldAccessExpression, data: D):
+    override fun visitFieldAccess(expression: IrFieldAccessExpression, data: D): IrExpression =
-            IrExpression = visitDeclarationReference(expression, data)
+        visitDeclarationReference(expression, data)
 
     override fun visitGetField(expression: IrGetField, data: D): IrExpression =
-            visitFieldAccess(expression, data)
+        visitFieldAccess(expression, data)
 
     override fun visitSetField(expression: IrSetField, data: D): IrExpression =
-            visitFieldAccess(expression, data)
+        visitFieldAccess(expression, data)
 
-    override fun visitFunctionExpression(expression: IrFunctionExpression, data: D):
+    override fun visitFunctionExpression(expression: IrFunctionExpression, data: D): IrElement =
-            IrElement = visitExpression(expression, data)
+        visitExpression(expression, data)
 
     override fun visitGetClass(expression: IrGetClass, data: D): IrExpression =
-            visitExpression(expression, data)
+        visitExpression(expression, data)
 
-    override fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall,
+    override fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall, data: D): IrExpression =
-            data: D): IrExpression = visitExpression(expression, data)
+        visitExpression(expression, data)
 
-    override fun visitLoop(loop: IrLoop, data: D): IrExpression = visitExpression(loop,
+    override fun visitLoop(loop: IrLoop, data: D): IrExpression =
-            data)
+        visitExpression(loop, data)
 
-    override fun visitWhileLoop(loop: IrWhileLoop, data: D): IrExpression = visitLoop(loop,
+    override fun visitWhileLoop(loop: IrWhileLoop, data: D): IrExpression =
-            data)
+        visitLoop(loop, data)
 
     override fun visitDoWhileLoop(loop: IrDoWhileLoop, data: D): IrExpression =
-            visitLoop(loop, data)
+        visitLoop(loop, data)
 
     override fun visitReturn(expression: IrReturn, data: D): IrExpression =
-            visitExpression(expression, data)
+        visitExpression(expression, data)
 
-    override fun visitStringConcatenation(expression: IrStringConcatenation, data: D):
+    override fun visitStringConcatenation(expression: IrStringConcatenation, data: D): IrExpression =
-            IrExpression = visitExpression(expression, data)
+        visitExpression(expression, data)
 
-    override fun visitSuspensionPoint(expression: IrSuspensionPoint, data: D): IrExpression
+    override fun visitSuspensionPoint(expression: IrSuspensionPoint, data: D): IrExpression =
-            = visitExpression(expression, data)
+        visitExpression(expression, data)
 
-    override fun visitSuspendableExpression(expression: IrSuspendableExpression, data: D):
+    override fun visitSuspendableExpression(expression: IrSuspendableExpression, data: D): IrExpression =
-            IrExpression = visitExpression(expression, data)
+        visitExpression(expression, data)
 
     override fun visitThrow(expression: IrThrow, data: D): IrExpression =
-            visitExpression(expression, data)
+        visitExpression(expression, data)
 
-    override fun visitTry(aTry: IrTry, data: D): IrExpression = visitExpression(aTry, data)
+    override fun visitTry(aTry: IrTry, data: D): IrExpression =
+        visitExpression(aTry, data)
 
     override fun visitCatch(aCatch: IrCatch, data: D): IrCatch {
         aCatch.transformChildren(this, data)
@@ -337,19 +256,19 @@ interface IrElementTransformer<in D> : IrElementVisitor<IrElement, D> {
     }
 
     override fun visitTypeOperator(expression: IrTypeOperatorCall, data: D): IrExpression =
-            visitExpression(expression, data)
+        visitExpression(expression, data)
 
-    override fun visitValueAccess(expression: IrValueAccessExpression, data: D):
+    override fun visitValueAccess(expression: IrValueAccessExpression, data: D): IrExpression =
-            IrExpression = visitDeclarationReference(expression, data)
+        visitDeclarationReference(expression, data)
 
     override fun visitGetValue(expression: IrGetValue, data: D): IrExpression =
-            visitValueAccess(expression, data)
+        visitValueAccess(expression, data)
 
     override fun visitSetValue(expression: IrSetValue, data: D): IrExpression =
-            visitValueAccess(expression, data)
+        visitValueAccess(expression, data)
 
     override fun visitVararg(expression: IrVararg, data: D): IrExpression =
-            visitExpression(expression, data)
+        visitExpression(expression, data)
 
     override fun visitSpreadElement(spread: IrSpreadElement, data: D): IrSpreadElement {
         spread.transformChildren(this, data)
@@ -357,7 +276,7 @@ interface IrElementTransformer<in D> : IrElementVisitor<IrElement, D> {
     }
 
     override fun visitWhen(expression: IrWhen, data: D): IrExpression =
-            visitExpression(expression, data)
+        visitExpression(expression, data)
 
     override fun visitBranch(branch: IrBranch, data: D): IrBranch {
         branch.transformChildren(this, data)

compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrElementVisitor.kt

@@ -9,152 +9,54 @@
 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.*
-import org.jetbrains.kotlin.ir.declarations.IrClass
+import org.jetbrains.kotlin.ir.expressions.*
-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
 
 interface IrElementVisitor<out R, in D> {
+
     fun visitElement(element: IrElement, data: D): R
 
-    fun visitDeclaration(declaration: IrDeclarationBase, data: D): R =
+    fun visitDeclaration(declaration: IrDeclarationBase, data: D): R = visitElement(declaration, data)
-            visitElement(declaration, data)
 
-    fun visitValueParameter(declaration: IrValueParameter, data: D): R =
+    fun visitValueParameter(declaration: IrValueParameter, data: D): R = visitDeclaration(declaration, data)
-            visitDeclaration(declaration, data)
 
     fun visitClass(declaration: IrClass, data: D): R = visitDeclaration(declaration, data)
 
-    fun visitAnonymousInitializer(declaration: IrAnonymousInitializer, data: D): R =
+    fun visitAnonymousInitializer(declaration: IrAnonymousInitializer, data: D): R = visitDeclaration(declaration, data)
-            visitDeclaration(declaration, data)
 
-    fun visitTypeParameter(declaration: IrTypeParameter, data: D): R =
+    fun visitTypeParameter(declaration: IrTypeParameter, data: D): R = visitDeclaration(declaration, data)
-            visitDeclaration(declaration, data)
 
-    fun visitFunction(declaration: IrFunction, data: D): R = visitDeclaration(declaration,
+    fun visitFunction(declaration: IrFunction, data: D): R = visitDeclaration(declaration, data)
-            data)
 
-    fun visitConstructor(declaration: IrConstructor, data: D): R =
+    fun visitConstructor(declaration: IrConstructor, data: D): R = visitFunction(declaration, data)
-            visitFunction(declaration, data)
 
-    fun visitEnumEntry(declaration: IrEnumEntry, data: D): R =
+    fun visitEnumEntry(declaration: IrEnumEntry, data: D): R = visitDeclaration(declaration, data)
-            visitDeclaration(declaration, data)
 
-    fun visitErrorDeclaration(declaration: IrErrorDeclaration, data: D): R =
+    fun visitErrorDeclaration(declaration: IrErrorDeclaration, data: D): R = visitDeclaration(declaration, data)
-            visitDeclaration(declaration, data)
 
     fun visitField(declaration: IrField, data: D): R = visitDeclaration(declaration, data)
 
-    fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty, data: D): R =
+    fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty, data: D): R = visitDeclaration(declaration, data)
-            visitDeclaration(declaration, data)
 
-    fun visitModuleFragment(declaration: IrModuleFragment, data: D): R =
+    fun visitModuleFragment(declaration: IrModuleFragment, data: D): R = visitElement(declaration, data)
-            visitElement(declaration, data)
 
-    fun visitProperty(declaration: IrProperty, data: D): R = visitDeclaration(declaration,
+    fun visitProperty(declaration: IrProperty, data: D): R = visitDeclaration(declaration, data)
-            data)
 
-    fun visitScript(declaration: IrScript, data: D): R = visitDeclaration(declaration,
+    fun visitScript(declaration: IrScript, data: D): R = visitDeclaration(declaration, data)
-            data)
 
-    fun visitSimpleFunction(declaration: IrSimpleFunction, data: D): R =
+    fun visitSimpleFunction(declaration: IrSimpleFunction, data: D): R = visitFunction(declaration, data)
-            visitFunction(declaration, data)
 
-    fun visitTypeAlias(declaration: IrTypeAlias, data: D): R =
+    fun visitTypeAlias(declaration: IrTypeAlias, data: D): R = visitDeclaration(declaration, data)
-            visitDeclaration(declaration, data)
 
-    fun visitVariable(declaration: IrVariable, data: D): R = visitDeclaration(declaration,
+    fun visitVariable(declaration: IrVariable, data: D): R = visitDeclaration(declaration, data)
-            data)
 
-    fun visitPackageFragment(declaration: IrPackageFragment, data: D): R =
+    fun visitPackageFragment(declaration: IrPackageFragment, data: D): R = visitElement(declaration, data)
-            visitElement(declaration, data)
 
-    fun visitExternalPackageFragment(declaration: IrExternalPackageFragment, data: D): R =
+    fun visitExternalPackageFragment(declaration: IrExternalPackageFragment, data: D): R = visitPackageFragment(declaration, data)
-            visitPackageFragment(declaration, data)
 
-    fun visitFile(declaration: IrFile, data: D): R = visitPackageFragment(declaration,
+    fun visitFile(declaration: IrFile, data: D): R = visitPackageFragment(declaration, data)
-            data)
 
-    fun visitExpression(expression: IrExpression, data: D): R = visitElement(expression,
+    fun visitExpression(expression: IrExpression, data: D): R = visitElement(expression, data)
-            data)
 
     fun visitBody(body: IrBody, data: D): R = visitElement(body, data)
 
@@ -162,38 +64,27 @@ interface IrElementVisitor<out R, in D> {
 
     fun visitBlockBody(body: IrBlockBody, data: D): R = visitBody(body, data)
 
-    fun visitDeclarationReference(expression: IrDeclarationReference, data: D): R =
+    fun visitDeclarationReference(expression: IrDeclarationReference, data: D): R = visitExpression(expression, data)
-            visitExpression(expression, data)
 
-    fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: D): R =
+    fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: D): R = visitDeclarationReference(expression, data)
-            visitDeclarationReference(expression, data)
 
-    fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: D): R =
+    fun visitFunctionAccess(expression: IrFunctionAccessExpression, data: D): R = visitMemberAccess(expression, data)
-            visitMemberAccess(expression, data)
 
-    fun visitConstructorCall(expression: IrConstructorCall, data: D): R =
+    fun visitConstructorCall(expression: IrConstructorCall, data: D): R = visitFunctionAccess(expression, data)
-            visitFunctionAccess(expression, data)
 
-    fun visitSingletonReference(expression: IrGetSingletonValue, data: D): R =
+    fun visitSingletonReference(expression: IrGetSingletonValue, data: D): R = visitDeclarationReference(expression, data)
-            visitDeclarationReference(expression, data)
 
-    fun visitGetObjectValue(expression: IrGetObjectValue, data: D): R =
+    fun visitGetObjectValue(expression: IrGetObjectValue, data: D): R = visitSingletonReference(expression, data)
-            visitSingletonReference(expression, data)
 
-    fun visitGetEnumValue(expression: IrGetEnumValue, data: D): R =
+    fun visitGetEnumValue(expression: IrGetEnumValue, data: D): R = visitSingletonReference(expression, data)
-            visitSingletonReference(expression, data)
 
-    fun visitRawFunctionReference(expression: IrRawFunctionReference, data: D): R =
+    fun visitRawFunctionReference(expression: IrRawFunctionReference, data: D): R = visitDeclarationReference(expression, data)
-            visitDeclarationReference(expression, data)
 
-    fun visitContainerExpression(expression: IrContainerExpression, data: D): R =
+    fun visitContainerExpression(expression: IrContainerExpression, data: D): R = visitExpression(expression, data)
-            visitExpression(expression, data)
 
-    fun visitBlock(expression: IrBlock, data: D): R = visitContainerExpression(expression,
+    fun visitBlock(expression: IrBlock, data: D): R = visitContainerExpression(expression, data)
-            data)
 
-    fun visitComposite(expression: IrComposite, data: D): R =
+    fun visitComposite(expression: IrComposite, data: D): R = visitContainerExpression(expression, data)
-            visitContainerExpression(expression, data)
 
     fun visitSyntheticBody(body: IrSyntheticBody, data: D): R = visitBody(body, data)
 
@@ -205,73 +96,51 @@ interface IrElementVisitor<out R, in D> {
 
     fun visitCall(expression: IrCall, data: D): R = visitFunctionAccess(expression, data)
 
-    fun visitCallableReference(expression: IrCallableReference<*>, data: D): R =
+    fun visitCallableReference(expression: IrCallableReference<*>, data: D): R = visitMemberAccess(expression, data)
-            visitMemberAccess(expression, data)
 
-    fun visitFunctionReference(expression: IrFunctionReference, data: D): R =
+    fun visitFunctionReference(expression: IrFunctionReference, data: D): R = visitCallableReference(expression, data)
-            visitCallableReference(expression, data)
 
-    fun visitPropertyReference(expression: IrPropertyReference, data: D): R =
+    fun visitPropertyReference(expression: IrPropertyReference, data: D): R = visitCallableReference(expression, data)
-            visitCallableReference(expression, data)
 
-    fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference,
+    fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference, data: D): R = visitCallableReference(expression, data)
-            data: D): R = visitCallableReference(expression, data)
 
-    fun visitClassReference(expression: IrClassReference, data: D): R =
+    fun visitClassReference(expression: IrClassReference, data: D): R = visitDeclarationReference(expression, data)
-            visitDeclarationReference(expression, data)
 
     fun visitConst(expression: IrConst<*>, data: D): R = visitExpression(expression, data)
 
-    fun visitConstantValue(expression: IrConstantValue, data: D): R =
+    fun visitConstantValue(expression: IrConstantValue, data: D): R = visitExpression(expression, data)
-            visitExpression(expression, data)
 
-    fun visitConstantPrimitive(expression: IrConstantPrimitive, data: D): R =
+    fun visitConstantPrimitive(expression: IrConstantPrimitive, data: D): R = visitConstantValue(expression, data)
-            visitConstantValue(expression, data)
 
-    fun visitConstantObject(expression: IrConstantObject, data: D): R =
+    fun visitConstantObject(expression: IrConstantObject, data: D): R = visitConstantValue(expression, data)
-            visitConstantValue(expression, data)
 
-    fun visitConstantArray(expression: IrConstantArray, data: D): R =
+    fun visitConstantArray(expression: IrConstantArray, data: D): R = visitConstantValue(expression, data)
-            visitConstantValue(expression, data)
 
-    fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall, data: D): R
+    fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall, data: D): R = visitFunctionAccess(expression, data)
-            = visitFunctionAccess(expression, data)
 
-    fun visitDynamicExpression(expression: IrDynamicExpression, data: D): R =
+    fun visitDynamicExpression(expression: IrDynamicExpression, data: D): R = visitExpression(expression, data)
-            visitExpression(expression, data)
 
-    fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression, data: D): R
+    fun visitDynamicOperatorExpression(expression: IrDynamicOperatorExpression, data: D): R = visitDynamicExpression(expression, data)
-            = visitDynamicExpression(expression, data)
 
-    fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression, data: D): R =
+    fun visitDynamicMemberExpression(expression: IrDynamicMemberExpression, data: D): R = visitDynamicExpression(expression, data)
-            visitDynamicExpression(expression, data)
 
-    fun visitEnumConstructorCall(expression: IrEnumConstructorCall, data: D): R =
+    fun visitEnumConstructorCall(expression: IrEnumConstructorCall, data: D): R = visitFunctionAccess(expression, data)
-            visitFunctionAccess(expression, data)
 
-    fun visitErrorExpression(expression: IrErrorExpression, data: D): R =
+    fun visitErrorExpression(expression: IrErrorExpression, data: D): R = visitExpression(expression, data)
-            visitExpression(expression, data)
 
-    fun visitErrorCallExpression(expression: IrErrorCallExpression, data: D): R =
+    fun visitErrorCallExpression(expression: IrErrorCallExpression, data: D): R = visitErrorExpression(expression, data)
-            visitErrorExpression(expression, data)
 
-    fun visitFieldAccess(expression: IrFieldAccessExpression, data: D): R =
+    fun visitFieldAccess(expression: IrFieldAccessExpression, data: D): R = visitDeclarationReference(expression, data)
-            visitDeclarationReference(expression, data)
 
-    fun visitGetField(expression: IrGetField, data: D): R = visitFieldAccess(expression,
+    fun visitGetField(expression: IrGetField, data: D): R = visitFieldAccess(expression, data)
-            data)
 
-    fun visitSetField(expression: IrSetField, data: D): R = visitFieldAccess(expression,
+    fun visitSetField(expression: IrSetField, data: D): R = visitFieldAccess(expression, data)
-            data)
 
-    fun visitFunctionExpression(expression: IrFunctionExpression, data: D): R =
+    fun visitFunctionExpression(expression: IrFunctionExpression, data: D): R = visitExpression(expression, data)
-            visitExpression(expression, data)
 
-    fun visitGetClass(expression: IrGetClass, data: D): R = visitExpression(expression,
+    fun visitGetClass(expression: IrGetClass, data: D): R = visitExpression(expression, data)
-            data)
 
-    fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall, data: D): R =
+    fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall, data: D): R = visitExpression(expression, data)
-            visitExpression(expression, data)
 
     fun visitLoop(loop: IrLoop, data: D): R = visitExpression(loop, data)
 
@@ -281,14 +150,11 @@ interface IrElementVisitor<out R, in D> {
 
     fun visitReturn(expression: IrReturn, data: D): R = visitExpression(expression, data)
 
-    fun visitStringConcatenation(expression: IrStringConcatenation, data: D): R =
+    fun visitStringConcatenation(expression: IrStringConcatenation, data: D): R = visitExpression(expression, data)
-            visitExpression(expression, data)
 
-    fun visitSuspensionPoint(expression: IrSuspensionPoint, data: D): R =
+    fun visitSuspensionPoint(expression: IrSuspensionPoint, data: D): R = visitExpression(expression, data)
-            visitExpression(expression, data)
 
-    fun visitSuspendableExpression(expression: IrSuspendableExpression, data: D): R =
+    fun visitSuspendableExpression(expression: IrSuspendableExpression, data: D): R = visitExpression(expression, data)
-            visitExpression(expression, data)
 
     fun visitThrow(expression: IrThrow, data: D): R = visitExpression(expression, data)
 
@@ -296,22 +162,17 @@ interface IrElementVisitor<out R, in D> {
 
     fun visitCatch(aCatch: IrCatch, data: D): R = visitElement(aCatch, data)
 
-    fun visitTypeOperator(expression: IrTypeOperatorCall, data: D): R =
+    fun visitTypeOperator(expression: IrTypeOperatorCall, data: D): R = visitExpression(expression, data)
-            visitExpression(expression, data)
 
-    fun visitValueAccess(expression: IrValueAccessExpression, data: D): R =
+    fun visitValueAccess(expression: IrValueAccessExpression, data: D): R = visitDeclarationReference(expression, data)
-            visitDeclarationReference(expression, data)
 
-    fun visitGetValue(expression: IrGetValue, data: D): R = visitValueAccess(expression,
+    fun visitGetValue(expression: IrGetValue, data: D): R = visitValueAccess(expression, data)
-            data)
 
-    fun visitSetValue(expression: IrSetValue, data: D): R = visitValueAccess(expression,
+    fun visitSetValue(expression: IrSetValue, data: D): R = visitValueAccess(expression, data)
-            data)
 
     fun visitVararg(expression: IrVararg, data: D): R = visitExpression(expression, data)
 
-    fun visitSpreadElement(spread: IrSpreadElement, data: D): R = visitElement(spread,
+    fun visitSpreadElement(spread: IrSpreadElement, data: D): R = visitElement(spread, data)
-            data)
 
     fun visitWhen(expression: IrWhen, data: D): R = visitExpression(expression, data)
 

compiler/ir/ir.tree/gen/org/jetbrains/kotlin/ir/visitors/IrTypeTransformer.kt

@@ -10,34 +10,15 @@ package org.jetbrains.kotlin.ir.visitors
 
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrStatement
-import org.jetbrains.kotlin.ir.declarations.IrClass
+import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.declarations.IrField
+import org.jetbrains.kotlin.ir.expressions.*
-import org.jetbrains.kotlin.ir.declarations.IrFunction
-import org.jetbrains.kotlin.ir.declarations.IrLocalDelegatedProperty
-import org.jetbrains.kotlin.ir.declarations.IrScript
-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.IrClassReference
-import org.jetbrains.kotlin.ir.expressions.IrConstantObject
-import org.jetbrains.kotlin.ir.expressions.IrConstantValue
-import org.jetbrains.kotlin.ir.expressions.IrExpression
-import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression
-import org.jetbrains.kotlin.ir.expressions.IrTypeOperatorCall
-import org.jetbrains.kotlin.ir.expressions.IrVararg
 import org.jetbrains.kotlin.ir.types.IrType
 
 interface IrTypeTransformer<in D> : IrElementTransformer<D> {
-    fun <Type : IrType?> transformType(
+    fun <Type : IrType?> transformType(container: IrElement, type: Type, data: D): Type
-        container: IrElement,
-        type: Type,
-        data: D,
-    ): Type
 
     override fun visitValueParameter(declaration: IrValueParameter, data: D): IrStatement {
-        declaration.varargElementType = transformType(declaration, declaration.varargElementType,
+        declaration.varargElementType = transformType(declaration, declaration.varargElementType, data)
-                data)
         declaration.type = transformType(declaration, declaration.type, data)
         return super.visitValueParameter(declaration, data)
     }
@@ -65,8 +46,7 @@ interface IrTypeTransformer<in D> : IrElementTransformer<D> {
         return super.visitField(declaration, data)
     }
 
-    override fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty,
+    override fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty, data: D): IrStatement {
-            data: D): IrStatement {
         declaration.type = transformType(declaration, declaration.type, data)
         return super.visitLocalDelegatedProperty(declaration, data)
     }
@@ -91,8 +71,7 @@ interface IrTypeTransformer<in D> : IrElementTransformer<D> {
         return super.visitExpression(expression, data)
     }
 
-    override fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: D):
+    override fun visitMemberAccess(expression: IrMemberAccessExpression<*>, data: D): IrElement {
-            IrElement {
         (0 until expression.typeArgumentsCount).forEach {
             expression.getTypeArgument(it)?.let { type ->
                 expression.putTypeArgument(it, transformType(expression, type, data))
@@ -106,11 +85,9 @@ interface IrTypeTransformer<in D> : IrElementTransformer<D> {
         return super.visitClassReference(expression, data)
     }
 
-    override fun visitConstantObject(expression: IrConstantObject, data: D):
+    override fun visitConstantObject(expression: IrConstantObject, data: D): IrConstantValue {
-            IrConstantValue {
         for (i in 0 until expression.typeArguments.size) {
-            expression.typeArguments[i] = transformType(expression, expression.typeArguments[i],
+            expression.typeArguments[i] = transformType(expression, expression.typeArguments[i], data)
-                    data)
         }
         return super.visitConstantObject(expression, data)
     }

compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/CommonTypes.kt

@@ -27,7 +27,9 @@ object Packages {
 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 typeTransformerType = type(visitors, "IrTypeTransformer")
 val mutableAnnotationContainerType = type(declarations, "IrMutableAnnotationContainer")
 val irTypeType = type(types, "IrType")
 

compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/model/Model.kt

@@ -37,7 +37,7 @@ class Element(
     override val args: Map<NamedTypeParameterRef, TypeRef>
         get() = emptyMap()
 
-    var visitorParent: ElementRef? = null
+    override var parentInVisitor: Element? = null
     var transformerReturnType: Element? = null
 
     override var kind: ImplementationKind? = when (config.typeKind) {
@@ -54,8 +54,8 @@ class Element(
     override var walkableChildren: List<Field> = emptyList()
     override val transformableChildren get() = walkableChildren.filter { it.transformable }
 
-    val visitFunName = "visit" + (config.visitorName ?: name).replaceFirstChar(Char::uppercaseChar)
+    override val visitFunctionName = "visit" + (config.visitorName ?: name).replaceFirstChar(Char::uppercaseChar)
-    val visitorParam = config.visitorParam ?: config.category.defaultVisitorParam
+    override val visitorParameterName = config.visitorParam ?: config.category.defaultVisitorParam
 
     override var hasAcceptMethod = config.accept
 

compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/model/Transformations.kt

@@ -123,7 +123,7 @@ private fun replaceElementRefs(config: Config, mapping: Map<ElementConfig, Eleme
             .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) {
@@ -154,7 +154,7 @@ private fun markLeaves(elements: List<Element>) {
 
     for (el in leaves) {
         el.isLeaf = true
-        if (el.visitorParent != null) {
+        if (el.parentInVisitor != null) {
             el.hasAcceptMethod = true
         }
     }

compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/print/Elements.kt

@@ -97,7 +97,7 @@ fun printElements(generationPath: File, model: Model) = sequence {
                         .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(

compiler/ir/ir.tree/tree-generator/src/org/jetbrains/kotlin/ir/generator/print/VisitorsAndTransformers.kt

@@ -5,139 +5,144 @@
 
 package org.jetbrains.kotlin.ir.generator.print
 
-import com.squareup.kotlinpoet.*
+import org.jetbrains.kotlin.generators.tree.*
-import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
+import org.jetbrains.kotlin.generators.tree.printer.*
-import org.jetbrains.kotlin.generators.tree.printer.GeneratedFile
+import org.jetbrains.kotlin.ir.generator.*
-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.ir.generator.model.*
+import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.util.capitalizeDecapitalize.capitalizeAsciiOnly
+import org.jetbrains.kotlin.utils.SmartPrinter
+import org.jetbrains.kotlin.utils.withIndent
 import java.io.File
 
-private val visitorTypeName = ClassName(VISITOR_PACKAGE, "IrElementVisitor")
+private fun printVisitorCommon(
-private val visitorVoidTypeName = ClassName(VISITOR_PACKAGE, "IrElementVisitorVoid")
+    generationPath: File,
-private val transformerTypeName = ClassName(VISITOR_PACKAGE, "IrElementTransformer")
+    model: Model,
-private val typeTransformerTypeName = ClassName(VISITOR_PACKAGE, "IrTypeTransformer")
+    visitorType: ClassRef<*>,
+    makePrinter: (SmartPrinter, ClassRef<*>) -> AbstractVisitorPrinter<Element, Field>,
+): GeneratedFile =
+    printGeneratedType(generationPath, TREE_GENERATOR_README, visitorType.packageName, visitorType.simpleName) {
+        println()
+        makePrinter(this, visitorType).printVisitor(model.elements)
+    }
 
-fun printVisitor(generationPath: File, model: Model): GeneratedFile {
+private open class VisitorPrinter(printer: SmartPrinter, override val visitorType: ClassRef<*>) :
-    val visitorType = TypeSpec.interfaceBuilder(visitorTypeName).apply {
+    AbstractVisitorPrinter<Element, Field>(printer, visitSuperTypeByDefault = false) {
-        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 {
+    override val visitorTypeParameters: List<TypeVariable>
-            addParameter(element.visitorParam, element.toPoetStarParameterized())
+        get() = listOf(resultTypeVariable, dataTypeVariable)
-            addParameter("data", d)
-            returns(r)
-        }
 
-        addFunction(buildVisitFun(model.rootElement).addModifiers(KModifier.ABSTRACT).build())
+    override val visitorDataType: TypeRef
+        get() = dataTypeVariable
 
-        for (element in model.elements) {
+    override fun visitMethodReturnType(element: Element) = resultTypeVariable
-            element.visitorParent?.let { parent ->
-                addFunction(buildVisitFun(element).apply {
-                    addStatement("return ${parent.element.visitFunName}(${element.visitorParam}, data)")
-                }.build())
-            }
-        }
-    }.build()
 
-    return printTypeCommon(generationPath, visitorTypeName.packageName, visitorType)
+    override val visitorSuperType: ClassRef<PositionTypeParameterRef>?
+        get() = null
+
+    override val allowTypeParametersInVisitorMethods: Boolean
+        get() = false
 }
 
-fun printVisitorVoid(generationPath: File, model: Model): GeneratedFile {
+fun printVisitor(generationPath: File, model: Model) = printVisitorCommon(generationPath, model, elementVisitorType, ::VisitorPrinter)
-    val dataType = NOTHING.copy(nullable = true)
 
-    val visitorType = TypeSpec.interfaceBuilder(visitorVoidTypeName).apply {
+private class VisitorVoidPrinter(
-        addSuperinterface(visitorTypeName.parameterizedBy(UNIT, dataType))
+    printer: SmartPrinter,
+    override val visitorType: ClassRef<*>,
+) : AbstractVisitorVoidPrinter<Element, Field>(printer, visitSuperTypeByDefault = false) {
 
-        fun buildVisitFun(element: Element) = FunSpec.builder(element.visitFunName).apply {
+    override val visitorSuperClass: ClassRef<PositionTypeParameterRef>
-            addModifiers(KModifier.OVERRIDE)
+        get() = elementVisitorType
-            addParameter(element.visitorParam, element.toPoetStarParameterized())
-            addParameter("data", dataType)
-            addStatement("return ${element.visitFunName}(${element.visitorParam})")
-        }
 
-        fun buildVisitVoidFun(element: Element) = FunSpec.builder(element.visitFunName).apply {
+    override val allowTypeParametersInVisitorMethods: Boolean
-            addParameter(element.visitorParam, element.toPoetStarParameterized())
+        get() = false
-        }
 
-        addFunction(buildVisitFun(model.rootElement).build())
+    override val useAbstractMethodForRootElement: Boolean
-        addFunction(buildVisitVoidFun(model.rootElement).build())
+        get() = false
 
-        for (element in model.elements) {
+    override val overriddenVisitMethodsAreFinal: Boolean
-            element.visitorParent?.let { parent ->
+        get() = false
-                addFunction(buildVisitFun(element).build())
-                addFunction(buildVisitVoidFun(element).apply {
-                    addStatement("return ${parent.element.visitFunName}(${element.visitorParam})")
-                }.build())
-            }
-        }
-    }.build()
-
-    return printTypeCommon(generationPath, visitorVoidTypeName.packageName, visitorType)
 }
 
-fun printTransformer(generationPath: File, model: Model): GeneratedFile {
+fun printVisitorVoid(generationPath: File, model: Model) =
-    val visitorType = TypeSpec.interfaceBuilder(transformerTypeName).apply {
+    printVisitorCommon(generationPath, model, elementVisitorVoidType, ::VisitorVoidPrinter)
-        val d = TypeVariableName("D", KModifier.IN)
-        addTypeVariable(d)
 
-        addSuperinterface(visitorTypeName.parameterizedBy(model.rootElement.toPoetStarParameterized(), d))
+private class TransformerPrinter(
+    printer: SmartPrinter,
+    override val visitorType: ClassRef<*>,
+    val rootElement: Element,
+) : AbstractVisitorPrinter<Element, Field>(printer, visitSuperTypeByDefault = false) {
 
-        fun buildVisitFun(element: Element) = FunSpec.builder(element.visitFunName).apply {
+    override val visitorSuperType: ClassRef<PositionTypeParameterRef>
-            addModifiers(KModifier.OVERRIDE)
+        get() = elementVisitorType.withArgs(rootElement, dataTypeVariable)
-            addParameter(element.visitorParam, element.toPoetStarParameterized())
-            addParameter("data", d)
-        }
 
-        for (element in model.elements) {
+    override val visitorTypeParameters: List<TypeVariable>
-            val returnType = element.getTransformExplicitType()
+        get() = listOf(dataTypeVariable)
-            if (element.transformByChildren) {
-                addFunction(buildVisitFun(element).apply {
-                    addStatement("${element.visitorParam}.transformChildren(this, data)")
-                    addStatement("return ${element.visitorParam}")
-                    returns(returnType.toPoetStarParameterized())
-                }.build())
-            } else {
-                element.visitorParent?.let { parent ->
-                    addFunction(buildVisitFun(element).apply {
-                        addStatement("return ${parent.element.visitFunName}(${element.visitorParam}, data)")
-                        returns(returnType.toPoetStarParameterized())
-                    }.build())
-                }
-            }
-        }
-    }.build()
 
-    return printTypeCommon(generationPath, transformerTypeName.packageName, visitorType)
+    override val visitorDataType: TypeRef
-}
+        get() = dataTypeVariable
 
-fun printTypeVisitor(generationPath: File, model: Model): GeneratedFile {
+    override fun visitMethodReturnType(element: Element) = element.getTransformExplicitType()
-    val transformTypeFunName = "transformType"
 
-    fun FunSpec.Builder.addVisitTypeStatement(element: Element, field: Field) {
+    override val allowTypeParametersInVisitorMethods: Boolean
-        val visitorParam = element.visitorParam
+        get() = false
-        val access = "$visitorParam.${field.name}"
+
-        when (field) {
+    context(ImportCollector)
-            is SingleField -> addStatement("$access = $transformTypeFunName($visitorParam, $access, data)")
+    override fun printMethodsForElement(element: Element) {
-            is ListField -> {
+        printer.run {
-                if (field.isMutable) {
+            val parent = element.parentInVisitor
-                    addStatement("$access = $access.map { $transformTypeFunName($visitorParam, it, data) }")
+            if (element.transformByChildren || parent != null) {
+                println()
+                printVisitMethodDeclaration(
+                    element = element,
+                    override = true,
+                )
+                if (element.transformByChildren) {
+                    println(" {")
+                    withIndent {
+                        println(element.visitorParameterName, ".transformChildren(this, data)")
+                        println("return ", element.visitorParameterName)
+                    }
+                    println("}")
                 } else {
-                    beginControlFlow("for (i in 0 until $access.size)")
+                    println(" =")
-                    addStatement("$access[i] = $transformTypeFunName($visitorParam, $access[i], data)")
+                    withIndent {
-                    endControlFlow()
+                        println(parent!!.visitFunctionName, "(", element.visitorParameterName, ", data)")
+                    }
                 }
             }
         }
     }
+}
 
-    fun Element.getFieldsWithIrTypeType(insideParent: Boolean = false): List<Field> {
+fun printTransformer(generationPath: File, model: Model): GeneratedFile =
+    printVisitorCommon(generationPath, model, elementTransformerType) { printer, visitorType ->
+        TransformerPrinter(printer, visitorType, model.rootElement)
+    }
+
+private class TypeTransformerPrinter(
+    printer: SmartPrinter,
+    override val visitorType: ClassRef<*>,
+    val rootElement: Element,
+) : AbstractVisitorPrinter<Element, Field>(printer, visitSuperTypeByDefault = false) {
+
+    override val visitorSuperType: ClassRef<PositionTypeParameterRef>
+        get() = elementTransformerType.withArgs(dataTypeVariable)
+
+    override val visitorTypeParameters: List<TypeVariable>
+        get() = listOf(dataTypeVariable)
+
+    override val visitorDataType: TypeRef
+        get() = dataTypeVariable
+
+    override fun visitMethodReturnType(element: Element) = element.getTransformExplicitType()
+
+    override val allowTypeParametersInVisitorMethods: Boolean
+        get() = false
+
+    private 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
         }
 
@@ -153,71 +158,110 @@ fun printTypeVisitor(generationPath: File, model: Model): GeneratedFile {
         return irTypeFields + parentsFields
     }
 
-    val visitorType = TypeSpec.interfaceBuilder(typeTransformerTypeName).apply {
+    context(ImportCollector)
-        val d = TypeVariableName("D", KModifier.IN)
+    override fun SmartPrinter.printAdditionalMethods() {
-        addTypeVariable(d)
+        val typeTP = TypeVariable("Type", listOf(irTypeType.copy(nullable = true)), Variance.INVARIANT)
-        addSuperinterface(transformerTypeName.parameterizedBy(d))
+        printFunctionDeclaration(
+            name = "transformType",
+            parameters = listOf(
+                FunctionParameter("container", rootElement),
+                FunctionParameter("type", typeTP),
+                FunctionParameter("data", visitorDataType)
+            ),
+            returnType = typeTP,
+            typeParameters = listOf(typeTP),
+        )
+        println()
+    }
 
-        val abstractVisitFun = FunSpec.builder(transformTypeFunName).apply {
+    context(ImportCollector)
-            val poetNullableIrType = irTypeType.toPoet().copy(nullable = true)
+    override fun printMethodsForElement(element: Element) {
-            val typeVariable = TypeVariableName("Type", poetNullableIrType)
+        val irTypeFields = element.getFieldsWithIrTypeType()
-            addTypeVariable(typeVariable)
+        if (irTypeFields.isEmpty()) return
-            addParameter("container", model.rootElement.toPoet())
+        if (element.parentInVisitor == null) return
-            addParameter("type", typeVariable)
+        printer.run {
-            addParameter("data", d)
+            println()
-            returns(typeVariable)
+            val visitorParam = element.visitorParameterName
-        }
+            printVisitMethodDeclaration(
-        addFunction(abstractVisitFun.addModifiers(KModifier.ABSTRACT).build())
+                element = element,
+                override = true,
+            )
 
-        fun buildVisitFun(element: Element) = FunSpec.builder(element.visitFunName).apply {
+            fun addVisitTypeStatement(field: Field) {
-            addModifiers(KModifier.OVERRIDE)
+                val access = "$visitorParam.${field.name}"
-            addParameter(element.visitorParam, element.toPoetStarParameterized())
+                when (field) {
-            addParameter("data", d)
+                    is SingleField -> println(access, " = ", "transformType(", visitorParam, ", ", access, ", data)")
-        }
+                    is ListField -> {
+                        if (field.isMutable) {
+                            println(access, " = ", access, ".map { transformType(", visitorParam, ", it, data) }")
+                        } else {
+                            println("for (i in 0 until ", access, ".size) {")
+                            withIndent {
+                                println(access, "[i] = transformType(", visitorParam, ", ", access, "[i], data)")
+                            }
+                            println("}")
+                        }
+                    }
+                }
+            }
 
-        for (element in model.elements) {
+            println(" {")
-            val irTypeFields = element.getFieldsWithIrTypeType()
+            withIndent {
-            if (irTypeFields.isEmpty()) continue
+                when (element.name) {
-
+                    IrTree.memberAccessExpression.name -> {
-            val returnType = element.getTransformExplicitType()
+                        if (irTypeFields.singleOrNull()?.name != "typeArguments") {
-            element.visitorParent?.let { _ ->
+                            error(
-                addFunction(buildVisitFun(element).apply {
+                                """`Ir${IrTree.memberAccessExpression.name.capitalizeAsciiOnly()}` has unexpected fields with `IrType` type. 
-                    returns(returnType.toPoetStarParameterized())
+                                        |Please adjust logic of `${visitorType.simpleName}`'s generation.""".trimMargin()
-
+                            )
-                    val visitorParam = element.visitorParam
+                        }
-                    when (element.name) {
+                        println("(0 until ", visitorParam, ".typeArgumentsCount).forEach {")
-                        IrTree.memberAccessExpression.name -> {
+                        withIndent {
-                            if (irTypeFields.singleOrNull()?.name != "typeArguments") {
+                            println(visitorParam, ".getTypeArgument(it)?.let { type ->")
-                                error(
+                            withIndent {
-                                    """`Ir${IrTree.memberAccessExpression.name.capitalizeAsciiOnly()}` has unexpected fields with `IrType` type. 
+                                println(
-                                        |Please adjust logic of `${typeTransformerTypeName.simpleName}`'s generation.""".trimMargin()
+                                    visitorParam,
+                                    ".putTypeArgument(it, transformType(",
+                                    visitorParam,
+                                    ", type, data))"
                                 )
                             }
-                            beginControlFlow("(0 until $visitorParam.typeArgumentsCount).forEach {")
+                            println("}")
-                            beginControlFlow("$visitorParam.getTypeArgument(it)?.let { type ->")
-                            addStatement("expression.putTypeArgument(it, $transformTypeFunName($visitorParam, type, data))")
-                            endControlFlow()
-                            endControlFlow()
                         }
-                        IrTree.`class`.name -> {
+                        println("}")
-                            beginControlFlow("$visitorParam.valueClassRepresentation?.mapUnderlyingType {")
-                            addStatement("$transformTypeFunName($visitorParam, it, data)")
-                            endControlFlow()
-                            irTypeFields.forEach { addVisitTypeStatement(element, it) }
-                        }
-                        else -> irTypeFields.forEach { addVisitTypeStatement(element, it) }
                     }
-                    addStatement("return super.${element.visitFunName}($visitorParam, data)")
+                    IrTree.`class`.name -> {
-                }.build())
+                        println(visitorParam, ".valueClassRepresentation?.mapUnderlyingType {")
+                        withIndent {
+                            println("transformType(", visitorParam, ", it, data)")
+                        }
+                        println("}")
+                        irTypeFields.forEach(::addVisitTypeStatement)
+                    }
+                    else -> {
+                        irTypeFields.forEach(::addVisitTypeStatement)
+                    }
+                }
+                println(
+                    "return super.",
+                    element.visitFunctionName,
+                    "(",
+                    visitorParam,
+                    ", data)"
+                )
             }
+            println("}")
         }
-    }.build()
+    }
-
-    return printTypeCommon(generationPath, typeTransformerTypeName.packageName, visitorType)
 }
 
+fun printTypeVisitor(generationPath: File, model: Model): GeneratedFile =
+    printVisitorCommon(generationPath, model, typeTransformerType) { printer, visitorType ->
+        TypeTransformerPrinter(printer, visitorType, model.rootElement)
+    }
+
 private fun Element.getTransformExplicitType(): Element {
-    return generateSequence(this) { it.visitorParent?.element }
+    return generateSequence(this) { it.parentInVisitor?.element }
         .firstNotNullOfOrNull {
             when {
                 it.transformByChildren -> it.transformerReturnType ?: it

core/util.runtime/src/org/jetbrains/kotlin/utils/addToStdlib.kt

@@ -349,3 +349,33 @@ fun <T, R> Iterable<T>.zipWithNulls(other: Iterable<R>): List<Pair<T?, R?>> {
 fun unreachableBranch(argument: Any?): Nothing {
     error("This argument should've been processed by previous when branches but it wasn't: $argument")
 }
+
+/**
+ * Calls [appendElement] on [buffer] for all the elements, also appending [separator] between them and using the given [prefix]
+ * and [postfix] if supplied.
+ *
+ * If the collection could be huge, you can specify a non-negative value of [limit], in which case only the first [limit]
+ * elements will be appended, followed by the [truncated] string (which defaults to "...").
+ */
+fun <T, A : Appendable> Iterable<T>.joinToWithBuffer(
+    buffer: A,
+    separator: CharSequence = ", ",
+    prefix: CharSequence = "",
+    postfix: CharSequence = "",
+    limit: Int = -1,
+    truncated: CharSequence = "...",
+    appendElement: A.(T) -> Unit,
+): A {
+    buffer.append(prefix)
+    var count = 0
+    for (element in this) {
+        if (++count > 1) buffer.append(separator)
+        if (limit < 0 || count <= limit) {
+            buffer.appendElement(element)
+        } else break
+    }
+    if (limit in 0..<count) buffer.append(truncated)
+    buffer.append(postfix)
+    return buffer
+}
+

generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractElement.kt

@@ -38,6 +38,21 @@ abstract class AbstractElement<Element, Field> : ElementOrRef<Element, Field>, F
     open val isSealed: Boolean
         get() = false
 
+    /**
+     * The name of the method in visitors used to visit this element.
+     */
+    abstract val visitFunctionName: String
+
+    /**
+     * The name of the parameter representing this element in the visitor method used to visit this element.
+     */
+    abstract val visitorParameterName: String
+
+    /**
+     * The default element to visit if the method for visiting this element is not overridden.
+     */
+    abstract val parentInVisitor: Element?
+
     override val allParents: List<Element>
         get() = elementParents.map { it.element }
 

generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractVisitorPrinter.kt

@@ -0,0 +1,159 @@
+/*
+ * 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.generators.tree.printer.FunctionParameter
+import org.jetbrains.kotlin.generators.tree.printer.multipleUpperBoundsList
+import org.jetbrains.kotlin.generators.tree.printer.printFunctionDeclaration
+import org.jetbrains.kotlin.generators.tree.printer.typeParameters
+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,
+) {
+
+    /**
+     * The visitor type to print.
+     */
+    abstract val visitorType: ClassRef<*>
+
+    /**
+     * The result type parameter of the visitor. All visitor methods return result of this type.
+     */
+    protected val resultTypeVariable = TypeVariable("R", emptyList(), Variance.OUT_VARIANCE)
+
+    /**
+     * The data type parameter of the visitor. ALl visitor methods accept a parameter of this type.
+     */
+    protected val dataTypeVariable = TypeVariable("D", emptyList(), Variance.IN_VARIANCE)
+
+    /**
+     * The type parameters of the visitor class. Void visitors have no type parameters,
+     * regular visitors usually have [resultTypeVariable] and [dataTypeVariable] here.
+     */
+    abstract val visitorTypeParameters: List<TypeVariable>
+
+    abstract val visitorDataType: TypeRef
+
+    abstract fun visitMethodReturnType(element: Element): TypeRef
+
+    /**
+     * The superclass for this visitor class.
+     */
+    abstract val visitorSuperType: ClassRef<PositionTypeParameterRef>?
+
+    /**
+     * If `true`, visitor methods for generic tree elements will be parameterized correspondingly.
+     * Otherwise, type arguments of generic tree elements will be replaced with `*`.
+     */
+    abstract val allowTypeParametersInVisitorMethods: Boolean
+
+    /**
+     * Allows to customize the default element to visit if the method for visiting this [element] is not overridden.
+     *
+     * If returns `null`, methods for this element will not be overridden in this visitor class (except the root element).
+     */
+    open fun parentInVisitor(element: Element): Element? = element.parentInVisitor
+
+    /**
+     * Prints a single visitor method declaration, without body.
+     */
+    context(ImportCollector)
+    protected fun SmartPrinter.printVisitMethodDeclaration(
+        element: Element,
+        hasDataParameter: Boolean = true,
+        modality: Modality? = null,
+        override: Boolean = false,
+    ) {
+        val visitorParameterType = ElementRef(
+            element,
+            element.params.associateWith { if (allowTypeParametersInVisitorMethods) it else TypeRef.Star }
+        )
+        val parameters = buildList {
+            add(FunctionParameter(element.visitorParameterName, visitorParameterType))
+            if (hasDataParameter) add(FunctionParameter("data", visitorDataType))
+        }
+        printFunctionDeclaration(
+            name = element.visitFunctionName,
+            parameters = parameters,
+            returnType = visitMethodReturnType(element),
+            typeParameters = if (allowTypeParametersInVisitorMethods) {
+                element.params
+            } else {
+                emptyList()
+            },
+            modality = modality,
+            override = override,
+        )
+    }
+
+    context(ImportCollector)
+    protected fun printMethodDeclarationForElement(element: Element, modality: Modality? = null, override: Boolean) {
+        printer.run {
+            println()
+            printVisitMethodDeclaration(
+                element,
+                modality = modality,
+                override = override
+            )
+        }
+    }
+
+    context(ImportCollector)
+    protected open fun printMethodsForElement(element: Element) {
+        printer.run {
+            val parentInVisitor = parentInVisitor(element)
+            if (parentInVisitor == null && !element.isRootElement) return
+            printMethodDeclarationForElement(
+                element,
+                modality = when {
+                    visitorSuperType == null && parentInVisitor == null && visitorType.kind == TypeKind.Class -> Modality.ABSTRACT
+                    visitorSuperType == null && parentInVisitor != null && visitorType.kind == TypeKind.Class -> Modality.OPEN
+                    else -> null
+                },
+                override = parentInVisitor != null && visitorSuperType != null,
+            )
+            if (parentInVisitor != null) {
+                print(" = ", parentInVisitor.visitFunctionName, "(", element.visitorParameterName, ", data)")
+            }
+            println()
+        }
+    }
+
+    context(ImportCollector)
+    protected open fun SmartPrinter.printAdditionalMethods() {
+    }
+
+    context(ImportCollector)
+    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.typeParameters())
+            visitorSuperType?.let {
+                print(" : ", it.render(), it.inheritanceClauseParenthesis())
+            }
+            print(visitorTypeParameters.multipleUpperBoundsList())
+            println(" {")
+            withIndent {
+                printAdditionalMethods()
+                for (element in elements) {
+                    if (element.isRootElement && visitSuperTypeByDefault) continue
+                    if (visitSuperTypeByDefault && parentInVisitor(element) == null) continue
+                    printMethodsForElement(element)
+                }
+            }
+            println("}")
+        }
+    }
+}

generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/AbstractVisitorVoidPrinter.kt

@@ -0,0 +1,81 @@
+/*
+ * 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()
+
+    final override val visitorDataType: TypeRef
+        get() = StandardTypes.nothing.copy(nullable = true)
+
+    override fun visitMethodReturnType(element: Element) = StandardTypes.unit
+
+    abstract val visitorSuperClass: ClassRef<PositionTypeParameterRef>
+
+    override val visitorSuperType: ClassRef<PositionTypeParameterRef>
+        get() = if (visitSuperTypeByDefault)
+            visitorSuperClass
+        else
+            visitorSuperClass.withArgs(StandardTypes.unit, visitorDataType)
+
+    abstract val useAbstractMethodForRootElement: Boolean
+
+    abstract val overriddenVisitMethodsAreFinal: Boolean
+
+    context(ImportCollector)
+    final override fun printMethodsForElement(element: Element) {
+        val parentInVisitor = parentInVisitor(element)
+        if (!element.isRootElement && parentInVisitor == null) return
+
+        val isAbstractVisitRootElementMethod = element.isRootElement && useAbstractMethodForRootElement
+
+        printMethodDeclarationForElement(
+            element,
+            modality = Modality.FINAL.takeIf { overriddenVisitMethodsAreFinal },
+            override = true,
+        )
+
+        fun SmartPrinter.printBody(parentInVisitor: Element?) {
+            println(" {")
+            if (parentInVisitor != null) {
+                withIndent {
+                    println(parentInVisitor.visitFunctionName, "(", element.visitorParameterName, ")")
+                }
+            }
+            println("}")
+        }
+
+        printer.run {
+            printBody(element)
+            println()
+            printVisitMethodDeclaration(
+                element,
+                hasDataParameter = false,
+                modality = when {
+                    element.isRootElement && visitorType.kind == TypeKind.Class -> Modality.ABSTRACT
+                    !element.isRootElement && visitorType.kind == TypeKind.Class -> Modality.OPEN
+                    else -> null
+                }
+            )
+            if (isAbstractVisitRootElementMethod) {
+                println()
+            } else {
+                printBody(parentInVisitor)
+            }
+        }
+    }
+}

generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/StandardTypes.kt

@@ -6,6 +6,8 @@
 package org.jetbrains.kotlin.generators.tree
 
 object StandardTypes {
+    val unit = type<Unit>()
+    val nothing = type("kotlin", "Nothing")
     val boolean = type<Boolean>()
     val string = type<String>()
     val int = type<Int>()

generators/tree-generator-common/src/org/jetbrains/kotlin/generators/tree/printer/printUtils.kt

@@ -5,14 +5,17 @@
 
 package org.jetbrains.kotlin.generators.tree.printer
 
-import org.jetbrains.kotlin.generators.tree.AbstractElement
+import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.generators.tree.ImplementationKind
+import org.jetbrains.kotlin.generators.tree.*
+import org.jetbrains.kotlin.utils.SmartPrinter
 import org.jetbrains.kotlin.generators.tree.ImportCollector
 import org.jetbrains.kotlin.generators.tree.render
-import org.jetbrains.kotlin.utils.SmartPrinter
+import org.jetbrains.kotlin.types.Variance
+import org.jetbrains.kotlin.utils.addToStdlib.joinToWithBuffer
+import org.jetbrains.kotlin.utils.withIndent
 
 /**
- * The angle bracket-delimited list of type parameters to print, or empty string if the element has no type parameters.
+ * The angle bracket-delimited list of type parameters to print, or empty string if the list is empty.
  *
  * For type parameters that have a single upper bound, also prints that upper bound. If at least one type parameter has multiple upper
  * bounds, doesn't print any upper bounds at all. They are expected to be printed in the `where` clause (see [multipleUpperBoundsList]).
@@ -20,10 +23,21 @@ import org.jetbrains.kotlin.utils.SmartPrinter
  * @param end The string to add after the closing angle bracket of the type parameter list
  */
 context(ImportCollector)
-fun AbstractElement<*, *>.typeParameters(end: String = ""): String = params.takeIf { it.isNotEmpty() }
+fun List<TypeVariable>.typeParameters(end: String = ""): String = buildString {
-    ?.joinToString(", ", "<", ">$end") { param ->
+    if (this@typeParameters.isEmpty()) return@buildString
-        param.name + (param.bounds.singleOrNull()?.let { " : ${it.render()}" } ?: "")
+    joinToWithBuffer(this, prefix = "<", postfix = ">") { param ->
-    } ?: ""
+        if (param.variance != Variance.INVARIANT) {
+            append(param.variance.label)
+            append(" ")
+        }
+        append(param.name)
+        param.bounds.singleOrNull()?.let {
+            append(" : ")
+            it.renderTo(this)
+        }
+    }
+    append(end)
+}
 
 /**
  * The `where` clause to print after the class or function declaration if at least one of the element's tye parameters has multiple upper
@@ -32,14 +46,17 @@ fun AbstractElement<*, *>.typeParameters(end: String = ""): String = params.take
  * Otherwise, an empty string.
  */
 context(ImportCollector)
-fun AbstractElement<*, *>.multipleUpperBoundsList(): String {
+fun List<TypeVariable>.multipleUpperBoundsList(): String {
-    val paramsWithMultipleUpperBounds = params.filter { it.bounds.size > 1 }.takeIf { it.isNotEmpty() } ?: return ""
+    val paramsWithMultipleUpperBounds = filter { it.bounds.size > 1 }.takeIf { it.isNotEmpty() } ?: return ""
     return buildString {
         append(" where ")
-        paramsWithMultipleUpperBounds.joinTo(this, separator = ", ") { param ->
+        paramsWithMultipleUpperBounds.joinToWithBuffer(this, separator = ", ") { param ->
-            param.bounds.joinToString(", ") { bound -> "$param : ${bound.render()}" }
+            param.bounds.joinToWithBuffer(this) { bound ->
+                append(param.name)
+                append(" : ")
+                bound.renderTo(this)
+            }
         }
-        append("")
     }
 }
 
@@ -75,3 +92,58 @@ fun AbstractElement<*, *>.extendedKDoc(defaultKDoc: String? = null): String = bu
     }
     append("Generated from: [${element.propertyName}]")
 }
+
+data class FunctionParameter(val name: String, val type: TypeRef, val defaultValue: String? = null) {
+
+    context(ImportCollector)
+    fun render(): String = buildString {
+        append(name, ": ", type.render())
+        defaultValue?.let {
+            append(" = ", it)
+        }
+    }
+}
+
+context(ImportCollector)
+fun SmartPrinter.printFunctionDeclaration(
+    name: String,
+    parameters: List<FunctionParameter>,
+    returnType: TypeRef,
+    typeParameters: List<TypeVariable> = emptyList(),
+    modality: Modality? = null,
+    override: Boolean = false,
+    allParametersOnSeparateLines: Boolean = false,
+) {
+    when (modality) {
+        null -> {}
+        Modality.FINAL -> print("final ")
+        Modality.OPEN -> print("open ")
+        Modality.ABSTRACT -> print("abstract ")
+        Modality.SEALED -> error("Function cannot be sealed")
+    }
+    if (override) {
+        print("override ")
+    }
+    print("fun ")
+    print(typeParameters.typeParameters(end = " "))
+    print(name, "(")
+
+    if (allParametersOnSeparateLines) {
+        if (parameters.isNotEmpty()) {
+            println()
+            withIndent {
+                for (parameter in parameters) {
+                    print(parameter.render())
+                    println(",")
+                }
+            }
+        }
+    } else {
+        print(parameters.joinToString { it.render() })
+    }
+    print(")")
+    if (returnType != StandardTypes.unit) {
+        print(": ", returnType.render())
+    }
+    print(typeParameters.multipleUpperBoundsList())
+}