[FIR/IR generator] Factor out walkableChildren and transformableChildren

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

@@ -112,7 +112,6 @@ class FieldWithDefault(val origin: Field) : Field() {
     override var withGetter: Boolean = false
     override var customSetter: String? = null
     override var fromDelegate: Boolean = false
-    var needAcceptAndTransform: Boolean = true
     override val overridenTypes: MutableSet<TypeRefWithNullability>
         get() = origin.overridenTypes
 

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

@@ -64,12 +64,6 @@ class Implementation(val element: Element, val name: String?) : FieldContainer,
     override val hasTransformChildrenMethod: Boolean
         get() = true
 
-    override val walkableChildren: List<FieldWithDefault>
-        get() = allFields.filter { it.containsElement && !it.withGetter && it.needAcceptAndTransform }
-
-    override val transformableChildren: List<FieldWithDefault>
-        get() = walkableChildren.filter { it.isMutable }
-
     override fun get(fieldName: String): FieldWithDefault? {
         return allFields.firstOrNull { it.name == fieldName }
     }

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

@@ -159,6 +159,7 @@ fun SmartPrinter.printImplementation(implementation: Implementation) {
                     println()
                     withIndent {
                         for (field in walkableFields) {
+                            check(field is FieldWithDefault)
                             when (field.name) {
                                 "explicitReceiver" -> {
                                     val explicitReceiver = implementation["explicitReceiver"]!!
@@ -225,6 +226,7 @@ fun SmartPrinter.printImplementation(implementation: Implementation) {
                 if (!isInterface && !isAbstract) {
                     printBlock {
                         for (field in transformableChildren) {
+                            check(field is FieldWithDefault)
                             when {
                                 field.name == "explicitReceiver" -> {
                                     val explicitReceiver = implementation["explicitReceiver"]!!

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

@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.ir.generator.model.Element
 import org.jetbrains.kotlin.ir.generator.model.Element.Category.*
 import org.jetbrains.kotlin.ir.generator.model.ListField.Mutability.*
 import org.jetbrains.kotlin.ir.generator.model.ListField.Mutability.Array
-import org.jetbrains.kotlin.ir.generator.model.ListField.Mutability.List
+import org.jetbrains.kotlin.ir.generator.model.ListField.Mutability.MutableList
 import org.jetbrains.kotlin.ir.generator.model.SingleField
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -338,7 +338,7 @@ object IrTree : AbstractTreeBuilder() {
 
         parent(declarationParent)
 
-        +listField("declarations", declaration, mutability = List, isChild = true) {
+        +listField("declarations", declaration, mutability = MutableList, isChild = true) {
             kDoc = """
                  Accessing list of declaration may trigger lazy declaration list computation for lazy class,
                    which requires computation of fake-overrides for this class. So it's unsafe to access it
@@ -482,7 +482,7 @@ object IrTree : AbstractTreeBuilder() {
         }
         +field("name", type<Name>(), mutable = false)
         +field("irBuiltins", type(Packages.tree, "IrBuiltIns"), mutable = false)
-        +listField("files", file, mutability = List, isChild = true)
+        +listField("files", file, mutability = MutableList, isChild = true)
         usedTypes += ArbitraryImportable(Packages.tree, "UNDEFINED_OFFSET")
         +field("startOffset", int, mutable = false) {
             baseGetter = "UNDEFINED_OFFSET"
@@ -661,7 +661,7 @@ object IrTree : AbstractTreeBuilder() {
     val statementContainer: Element by element(Expression) {
         ownsChildren = false
 
-        +listField("statements", statement, mutability = List, isChild = true)
+        +listField("statements", statement, mutability = MutableList, isChild = true)
     }
     val body: Element by element(Expression) {
         needTransformMethod()
@@ -831,7 +831,7 @@ object IrTree : AbstractTreeBuilder() {
         parent(statementContainer)
 
         +field("origin", statementOriginType, nullable = true)
-        +listField("statements", statement, mutability = List, isChild = true) {
+        +listField("statements", statement, mutability = MutableList, isChild = true) {
             baseDefaultValue = "ArrayList(2)"
         }
     }
@@ -965,13 +965,13 @@ object IrTree : AbstractTreeBuilder() {
         parent(constantValue)
 
         +field("constructor", constructorSymbolType)
-        +listField("valueArguments", constantValue, mutability = List, isChild = true)
+        +listField("valueArguments", constantValue, mutability = MutableList, isChild = true)
-        +listField("typeArguments", irTypeType, mutability = List)
+        +listField("typeArguments", irTypeType, mutability = MutableList)
     }
     val constantArray: Element by element(Expression) {
         parent(constantValue)
 
-        +listField("elements", constantValue, mutability = List, isChild = true)
+        +listField("elements", constantValue, mutability = MutableList, isChild = true)
     }
     val delegatingConstructorCall: Element by element(Expression) {
         parent(functionAccessExpression)
@@ -986,7 +986,7 @@ object IrTree : AbstractTreeBuilder() {
 
         +field("operator", type(Packages.exprs, "IrDynamicOperator"))
         +field("receiver", expression, isChild = true)
-        +listField("arguments", expression, mutability = List, isChild = true)
+        +listField("arguments", expression, mutability = MutableList, isChild = true)
     }
     val dynamicMemberExpression: Element by element(Expression) {
         parent(dynamicExpression)
@@ -1010,7 +1010,7 @@ object IrTree : AbstractTreeBuilder() {
         parent(errorExpression)
 
         +field("explicitReceiver", expression, nullable = true, isChild = true)
-        +listField("arguments", expression, mutability = List, isChild = true)
+        +listField("arguments", expression, mutability = MutableList, isChild = true)
     }
     val fieldAccessExpression: Element by element(Expression) {
         nameInVisitorMethod = "FieldAccess"
@@ -1086,7 +1086,7 @@ object IrTree : AbstractTreeBuilder() {
     val stringConcatenation: Element by element(Expression) {
         parent(expression)
 
-        +listField("arguments", expression, mutability = List, isChild = true)
+        +listField("arguments", expression, mutability = MutableList, isChild = true)
     }
     val suspensionPoint: Element by element(Expression) {
         parent(expression)
@@ -1112,7 +1112,7 @@ object IrTree : AbstractTreeBuilder() {
         parent(expression)
 
         +field("tryResult", expression, isChild = true)
-        +listField("catches", catch, mutability = List, isChild = true)
+        +listField("catches", catch, mutability = MutableList, isChild = true)
         +field("finallyExpression", expression, nullable = true, isChild = true)
     }
     val catch: Element by element(Expression) {
@@ -1153,7 +1153,7 @@ object IrTree : AbstractTreeBuilder() {
         parent(expression)
 
         +field("varargElementType", irTypeType)
-        +listField("elements", varargElement, mutability = List, isChild = true)
+        +listField("elements", varargElement, mutability = MutableList, isChild = true)
     }
     val spreadElement: Element by element(Expression) {
         visitorParameterName = "spread"
@@ -1168,7 +1168,7 @@ object IrTree : AbstractTreeBuilder() {
         parent(expression)
 
         +field("origin", statementOriginType, nullable = true)
-        +listField("branches", branch, mutability = List, isChild = true)
+        +listField("branches", branch, mutability = MutableList, isChild = true)
     }
     val branch: Element by element(Expression) {
         visitorParameterName = "branch"

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

@@ -86,13 +86,13 @@ abstract class AbstractTreeBuilder {
         name: String,
         elementType: TypeRef?,
         nullable: Boolean = false,
-        mutability: ListField.Mutability = ListField.Mutability.Immutable,
+        mutability: ListField.Mutability,
         isChild: Boolean = false,
         initializer: ListField.() -> Unit = {}
     ): ListField {
         checkChildType(isChild, elementType, name)
         val listType = when (mutability) {
-            ListField.Mutability.List -> StandardTypes.mutableList
+            ListField.Mutability.MutableList -> StandardTypes.mutableList
             ListField.Mutability.Array -> StandardTypes.array
             else -> StandardTypes.list
         }
@@ -103,7 +103,6 @@ abstract class AbstractTreeBuilder {
             isNullable = nullable,
             mutable = mutability == ListField.Mutability.Var,
             isChild = isChild,
-            transformable = mutability != ListField.Mutability.Immutable,
         ).apply(initializer)
     }
 

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

@@ -96,7 +96,6 @@ class Element(
 
     var childrenOrderOverride: List<String>? = null
     override var walkableChildren: List<Field> = emptyList()
-    override val transformableChildren get() = walkableChildren.filter { it.transformable }
 
     override var visitorParameterName = category.defaultVisitorParam
 
@@ -168,8 +167,6 @@ sealed class Field(
     var baseDefaultValue: String? = null
     var baseGetter: String? = null
 
-    abstract val transformable: Boolean
-
     sealed class UseFieldAsParameterInIrFactoryStrategy {
 
         data object No : UseFieldAsParameterInIrFactoryStrategy()
@@ -208,10 +205,7 @@ class SingleField(
     override var typeRef: TypeRefWithNullability,
     mutable: Boolean,
     isChild: Boolean,
-) : Field(name, mutable, isChild) {
+) : Field(name, mutable, isChild)
-    override val transformable: Boolean
-        get() = isMutable
-}
 
 class ListField(
     name: String,
@@ -220,16 +214,14 @@ class ListField(
     override val listType: ClassRef<PositionTypeParameterRef>,
     mutable: Boolean,
     isChild: Boolean,
-    override val transformable: Boolean,
 ) : Field(name, mutable, isChild), AbstractListField {
 
     override val typeRef: ClassRef<PositionTypeParameterRef>
         get() = listType.withArgs(baseType).copy(isNullable)
 
     enum class Mutability {
-        Immutable,
         Var,
-        List,
+        MutableList,
         Array
     }
 }

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

@@ -80,10 +80,6 @@ abstract class AbstractElement<Element, Field>(
 
     abstract override val allFields: List<Field>
 
-    abstract override val walkableChildren: List<Field>
-
-    abstract override val transformableChildren: List<Field>
-
     /**
      * A custom return type of the corresponding transformer method for this element.
      */

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

@@ -51,6 +51,13 @@ abstract class AbstractField {
      */
     var useInBaseTransformerDetection = true
 
+    /**
+     * Whether a visitor should be run on this field in the generated `acceptChildren` in `transformChildren` method.
+     *
+     * Only has effect if [containsElement] is `true`.
+     */
+    var needAcceptAndTransform: Boolean = true
+
     override fun toString(): String {
         return name
     }

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

@@ -21,9 +21,15 @@ interface FieldContainer {
     val hasTransformChildrenMethod: Boolean
         get() = false
 
+    /**
+     * The fields on which to run the visitor in generated `acceptChildren` methods.
+     */
     val walkableChildren: List<AbstractField>
-        get() = emptyList()
+        get() = allFields.filter { it.containsElement && !it.withGetter && it.needAcceptAndTransform }
 
+    /**
+     * The fields on which to run the transformer in generated `transformChildren` methods.
+     */
     val transformableChildren: List<AbstractField>
-        get() = emptyList()
+        get() = walkableChildren.filter { it.isMutable || it is ListField }
 }