[FIR] Don't generate replace and transform in implementations with kind = Interface

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaClass.kt

@@ -67,6 +67,10 @@ class FirJavaClass internal constructor(
         supertypesComputationStatus = newSupertypesComputationStatus
     }
 
+    override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
+        resolvePhase = newResolvePhase
+    }
+
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         declarations.forEach { it.accept(visitor, data) }
         annotations.forEach { it.accept(visitor, data) }

compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/Modifier.kt

@@ -20,6 +20,8 @@ import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.PARAMETER_MO
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.PLATFORM_MODIFIER
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.PROPERTY_MODIFIER
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.VISIBILITY_MODIFIER
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 class Modifier(
     override val psi: PsiElement? = null,
@@ -155,4 +157,10 @@ class Modifier(
     fun hasActual(): Boolean {
         return platformModifiers.contains(PlatformModifier.ACTUAL) || platformModifiers.contains(PlatformModifier.IMPL)
     }
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {}
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAbstractAnnotatedElement {
+        return this
+    }
 }

compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/TypeModifier.kt

@@ -9,6 +9,8 @@ import com.intellij.lang.LighterASTNode
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
 import org.jetbrains.kotlin.lexer.KtTokens
 
 class TypeModifier(
@@ -26,4 +28,10 @@ class TypeModifier(
     fun hasNoAnnotations(): Boolean {
         return annotations.isEmpty()
     }
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {}
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAbstractAnnotatedElement {
+        return this
+    }
 }

compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/TypeParameterModifier.kt

@@ -11,6 +11,8 @@ import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.REIFICATION_MODIFIER
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.VARIANCE_MODIFIER
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
 import org.jetbrains.kotlin.types.Variance
 
 class TypeParameterModifier(
@@ -40,4 +42,10 @@ class TypeParameterModifier(
     fun hasReified(): Boolean {
         return reificationModifier == ReificationModifier.REIFIED
     }
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {}
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAbstractAnnotatedElement {
+        return this
+    }
 }

compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/fir/modifier/TypeProjectionModifier.kt

@@ -10,6 +10,8 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.ModifierSets.VARIANCE_MODIFIER
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
 import org.jetbrains.kotlin.types.Variance
 
 class TypeProjectionModifier(
@@ -32,4 +34,10 @@ class TypeProjectionModifier(
             else -> Variance.INVARIANT
         }
     }
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {}
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAbstractAnnotatedElement {
+        return this
+    }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableClass.kt

@@ -29,25 +29,9 @@ interface FirModifiableClass : FirClass, FirAbstractAnnotatedElement {
     override val superTypeRefs: MutableList<FirTypeRef>
     override val declarations: MutableList<FirDeclaration>
     override val annotations: MutableList<FirAnnotationCall>
-    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableClass
-        superTypeRefs.forEach { it.accept(visitor, data) }
-        declarations.forEach { it.accept(visitor, data) }
-        annotations.forEach { it.accept(visitor, data) }
-    }
 
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableClass {
+    override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
-        superTypeRefs.transformInplace(transformer, data)
-        declarations.transformInplace(transformer, data)
-        annotations.transformInplace(transformer, data)
-        return this
-    }
 
-    override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
+    override fun replaceSuperTypeRefs(newSuperTypeRefs: List<FirTypeRef>)
-        resolvePhase = newResolvePhase
-    }
-
-    override fun replaceSuperTypeRefs(newSuperTypeRefs: List<FirTypeRef>) {
-        superTypeRefs.clear()
-        superTypeRefs.addAll(newSuperTypeRefs)
-    }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableConstructor.kt

@@ -46,47 +46,13 @@ interface FirModifiableConstructor : FirConstructor, FirModifiableTypeParameters
     override val symbol: FirConstructorSymbol
     override var delegatedConstructor: FirDelegatedConstructorCall?
     override val isPrimary: Boolean
-    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableConstructor
-        returnTypeRef.accept(visitor, data)
-        receiverTypeRef?.accept(visitor, data)
-        controlFlowGraphReference.accept(visitor, data)
-        typeParameters.forEach { it.accept(visitor, data) }
-        valueParameters.forEach { it.accept(visitor, data) }
-        body?.accept(visitor, data)
-        status.accept(visitor, data)
-        annotations.forEach { it.accept(visitor, data) }
-        delegatedConstructor?.accept(visitor, data)
-    }
 
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableConstructor {
+    override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirModifiableConstructor
-        transformReturnTypeRef(transformer, data)
-        receiverTypeRef = receiverTypeRef?.transformSingle(transformer, data)
-        transformControlFlowGraphReference(transformer, data)
-        typeParameters.transformInplace(transformer, data)
-        transformValueParameters(transformer, data)
-        body = body?.transformSingle(transformer, data)
-        status = status.transformSingle(transformer, data)
-        annotations.transformInplace(transformer, data)
-        delegatedConstructor = delegatedConstructor?.transformSingle(transformer, data)
-        return this
-    }
 
-    override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirModifiableConstructor {
+    override fun <D> transformControlFlowGraphReference(transformer: FirTransformer<D>, data: D): FirModifiableConstructor
-        returnTypeRef = returnTypeRef.transformSingle(transformer, data)
-        return this
-    }
 
-    override fun <D> transformControlFlowGraphReference(transformer: FirTransformer<D>, data: D): FirModifiableConstructor {
+    override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirModifiableConstructor
-        controlFlowGraphReference = controlFlowGraphReference.transformSingle(transformer, data)
-        return this
-    }
 
-    override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirModifiableConstructor {
+    override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
-        valueParameters.transformInplace(transformer, data)
-        return this
-    }
-
-    override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
-        resolvePhase = newResolvePhase
-    }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableFunction.kt

@@ -37,43 +37,13 @@ interface FirModifiableFunction<F : FirFunction<F>>  : FirFunction<F>, FirAbstra
     override val symbol: FirFunctionSymbol<F>
     override val valueParameters: MutableList<FirValueParameter>
     override var body: FirBlock?
-    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableFunction<F>
-        annotations.forEach { it.accept(visitor, data) }
-        returnTypeRef.accept(visitor, data)
-        receiverTypeRef?.accept(visitor, data)
-        controlFlowGraphReference.accept(visitor, data)
-        typeParameters.forEach { it.accept(visitor, data) }
-        valueParameters.forEach { it.accept(visitor, data) }
-        body?.accept(visitor, data)
-    }
 
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableFunction<F> {
+    override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirModifiableFunction<F>
-        annotations.transformInplace(transformer, data)
-        transformReturnTypeRef(transformer, data)
-        receiverTypeRef = receiverTypeRef?.transformSingle(transformer, data)
-        transformControlFlowGraphReference(transformer, data)
-        typeParameters.transformInplace(transformer, data)
-        transformValueParameters(transformer, data)
-        body = body?.transformSingle(transformer, data)
-        return this
-    }
 
-    override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirModifiableFunction<F> {
+    override fun <D> transformControlFlowGraphReference(transformer: FirTransformer<D>, data: D): FirModifiableFunction<F>
-        returnTypeRef = returnTypeRef.transformSingle(transformer, data)
-        return this
-    }
 
-    override fun <D> transformControlFlowGraphReference(transformer: FirTransformer<D>, data: D): FirModifiableFunction<F> {
+    override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirModifiableFunction<F>
-        controlFlowGraphReference = controlFlowGraphReference.transformSingle(transformer, data)
-        return this
-    }
 
-    override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirModifiableFunction<F> {
+    override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
-        valueParameters.transformInplace(transformer, data)
-        return this
-    }
-
-    override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
-        resolvePhase = newResolvePhase
-    }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableTypeParametersOwner.kt

@@ -18,12 +18,5 @@ import org.jetbrains.kotlin.fir.visitors.*
 interface FirModifiableTypeParametersOwner : FirTypeParametersOwner {
     override val psi: PsiElement?
     override val typeParameters: MutableList<FirTypeParameter>
-    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableTypeParametersOwner
-        typeParameters.forEach { it.accept(visitor, data) }
-    }
-
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableTypeParametersOwner {
-        typeParameters.transformInplace(transformer, data)
-        return this
-    }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableVariable.kt

@@ -40,48 +40,15 @@ interface FirModifiableVariable<F : FirVariable<F>>  : FirVariable<F>, FirAbstra
     override var getter: FirPropertyAccessor?
     override var setter: FirPropertyAccessor?
     override val annotations: MutableList<FirAnnotationCall>
-    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableVariable<F>
-        returnTypeRef.accept(visitor, data)
-        receiverTypeRef?.accept(visitor, data)
-        initializer?.accept(visitor, data)
-        delegate?.accept(visitor, data)
-        getter?.accept(visitor, data)
-        setter?.accept(visitor, data)
-        annotations.forEach { it.accept(visitor, data) }
-    }
 
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableVariable<F> {
+    override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirModifiableVariable<F>
-        transformReturnTypeRef(transformer, data)
-        transformGetter(transformer, data)
-        transformSetter(transformer, data)
-        transformOtherChildren(transformer, data)
-        return this
-    }
 
-    override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirModifiableVariable<F> {
+    override fun <D> transformGetter(transformer: FirTransformer<D>, data: D): FirModifiableVariable<F>
-        returnTypeRef = returnTypeRef.transformSingle(transformer, data)
-        return this
-    }
 
-    override fun <D> transformGetter(transformer: FirTransformer<D>, data: D): FirModifiableVariable<F> {
+    override fun <D> transformSetter(transformer: FirTransformer<D>, data: D): FirModifiableVariable<F>
-        getter = getter?.transformSingle(transformer, data)
-        return this
-    }
 
-    override fun <D> transformSetter(transformer: FirTransformer<D>, data: D): FirModifiableVariable<F> {
+    override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirModifiableVariable<F>
-        setter = setter?.transformSingle(transformer, data)
-        return this
-    }
 
-    override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirModifiableVariable<F> {
+    override fun replaceResolvePhase(newResolvePhase: FirResolvePhase)
-        receiverTypeRef = receiverTypeRef?.transformSingle(transformer, data)
-        initializer = initializer?.transformSingle(transformer, data)
-        delegate = delegate?.transformSingle(transformer, data)
-        annotations.transformInplace(transformer, data)
-        return this
-    }
-
-    override fun replaceResolvePhase(newResolvePhase: FirResolvePhase) {
-        resolvePhase = newResolvePhase
-    }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractLoop.kt

@@ -25,33 +25,11 @@ interface FirAbstractLoop : FirLoop, FirAbstractAnnotatedElement {
     override var block: FirBlock
     override var condition: FirExpression
     override var label: FirLabel?
-    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAbstractLoop
-        annotations.forEach { it.accept(visitor, data) }
-        block.accept(visitor, data)
-        condition.accept(visitor, data)
-        label?.accept(visitor, data)
-    }
 
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAbstractLoop {
+    override fun <D> transformBlock(transformer: FirTransformer<D>, data: D): FirAbstractLoop
-        transformBlock(transformer, data)
-        transformCondition(transformer, data)
-        transformOtherChildren(transformer, data)
-        return this
-    }
 
-    override fun <D> transformBlock(transformer: FirTransformer<D>, data: D): FirAbstractLoop {
+    override fun <D> transformCondition(transformer: FirTransformer<D>, data: D): FirAbstractLoop
-        block = block.transformSingle(transformer, data)
-        return this
-    }
 
-    override fun <D> transformCondition(transformer: FirTransformer<D>, data: D): FirAbstractLoop {
+    override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirAbstractLoop
-        condition = condition.transformSingle(transformer, data)
-        return this
-    }
-
-    override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirAbstractLoop {
-        annotations.transformInplace(transformer, data)
-        label = label?.transformSingle(transformer, data)
-        return this
-    }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractLoopJump.kt

@@ -25,18 +25,7 @@ interface FirAbstractLoopJump : FirLoopJump, FirAbstractAnnotatedElement {
     override var typeRef: FirTypeRef
     override val annotations: MutableList<FirAnnotationCall>
     override var target: FirTarget<FirLoop>
-    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAbstractLoopJump
-        typeRef.accept(visitor, data)
-        annotations.forEach { it.accept(visitor, data) }
-    }
 
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAbstractLoopJump {
+    override fun replaceTypeRef(newTypeRef: FirTypeRef)
-        typeRef = typeRef.transformSingle(transformer, data)
-        annotations.transformInplace(transformer, data)
-        return this
-    }
-
-    override fun replaceTypeRef(newTypeRef: FirTypeRef) {
-        typeRef = newTypeRef
-    }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirCallWithArgumentList.kt

@@ -21,19 +21,7 @@ interface FirCallWithArgumentList : FirCall, FirAbstractAnnotatedElement {
     override val psi: PsiElement?
     override val annotations: MutableList<FirAnnotationCall>
     override val arguments: MutableList<FirExpression>
-    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirCallWithArgumentList
-        annotations.forEach { it.accept(visitor, data) }
-        arguments.forEach { it.accept(visitor, data) }
-    }
 
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirCallWithArgumentList {
+    override fun <D> transformArguments(transformer: FirTransformer<D>, data: D): FirCallWithArgumentList
-        annotations.transformInplace(transformer, data)
-        transformArguments(transformer, data)
-        return this
-    }
-
-    override fun <D> transformArguments(transformer: FirTransformer<D>, data: D): FirCallWithArgumentList {
-        arguments.transformInplace(transformer, data)
-        return this
-    }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirModifiableQualifiedAccess.kt

@@ -24,41 +24,11 @@ interface FirModifiableQualifiedAccess : FirQualifiedAccessWithoutCallee, FirAbs
     override var explicitReceiver: FirExpression?
     override var dispatchReceiver: FirExpression
     override var extensionReceiver: FirExpression
-    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableQualifiedAccess
-        annotations.forEach { it.accept(visitor, data) }
-        explicitReceiver?.accept(visitor, data)
-        if (dispatchReceiver !== explicitReceiver) {
-            dispatchReceiver.accept(visitor, data)
-        }
-        if (extensionReceiver !== explicitReceiver && extensionReceiver !== dispatchReceiver) {
-            extensionReceiver.accept(visitor, data)
-        }
-    }
 
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirModifiableQualifiedAccess {
+    override fun <D> transformExplicitReceiver(transformer: FirTransformer<D>, data: D): FirModifiableQualifiedAccess
-        annotations.transformInplace(transformer, data)
-        explicitReceiver = explicitReceiver?.transformSingle(transformer, data)
-        if (dispatchReceiver !== explicitReceiver) {
-            dispatchReceiver = dispatchReceiver.transformSingle(transformer, data)
-        }
-        if (extensionReceiver !== explicitReceiver && extensionReceiver !== dispatchReceiver) {
-            extensionReceiver = extensionReceiver.transformSingle(transformer, data)
-        }
-        return this
-    }
 
-    override fun <D> transformExplicitReceiver(transformer: FirTransformer<D>, data: D): FirModifiableQualifiedAccess {
+    override fun <D> transformDispatchReceiver(transformer: FirTransformer<D>, data: D): FirModifiableQualifiedAccess
-        explicitReceiver = explicitReceiver?.transformSingle(transformer, data)
-        return this
-    }
 
-    override fun <D> transformDispatchReceiver(transformer: FirTransformer<D>, data: D): FirModifiableQualifiedAccess {
+    override fun <D> transformExtensionReceiver(transformer: FirTransformer<D>, data: D): FirModifiableQualifiedAccess
-        dispatchReceiver = dispatchReceiver.transformSingle(transformer, data)
-        return this
-    }
-
-    override fun <D> transformExtensionReceiver(transformer: FirTransformer<D>, data: D): FirModifiableQualifiedAccess {
-        extensionReceiver = extensionReceiver.transformSingle(transformer, data)
-        return this
-    }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/impl/FirAbstractAnnotatedElement.kt

@@ -18,12 +18,5 @@ import org.jetbrains.kotlin.fir.visitors.*
 interface FirAbstractAnnotatedElement : FirAnnotationContainer {
     override val psi: PsiElement?
     override val annotations: MutableList<FirAnnotationCall>
-    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAbstractAnnotatedElement
-        annotations.forEach { it.accept(visitor, data) }
-    }
-
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirAbstractAnnotatedElement {
-        annotations.transformInplace(transformer, data)
-        return this
-    }
 }

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

@@ -261,7 +261,9 @@ fun PrintWriter.printImplementation(implementation: Implementation) {
         val fieldsWithoutDefault = allFields.filter { it.defaultValue == null && !it.isLateinit }
         val fieldsWithDefault = allFields.filter { it.defaultValue != null || it.isLateinit }
 
-        if (kind != Implementation.Kind.Interface && fieldsWithoutDefault.isNotEmpty()) {
+        val isInterface = kind == Implementation.Kind.Interface
+
+        if (!isInterface && fieldsWithoutDefault.isNotEmpty()) {
             println("(")
             fieldsWithoutDefault.forEachIndexed { i, field ->
                 val end = if (i == fieldsWithoutDefault.size - 1) "" else ","
@@ -276,7 +278,7 @@ fun PrintWriter.printImplementation(implementation: Implementation) {
         }
         println(" {")
 
-        if (kind == Implementation.Kind.Interface) {
+        if (isInterface) {
             allFields.forEach { printField(it, isImplementation = true, override = true, end = "") }
         } else {
             fieldsWithDefault.forEach {
@@ -288,7 +290,7 @@ fun PrintWriter.printImplementation(implementation: Implementation) {
         }
 
         element.allFields.filter { it.type.contains("Symbol") }
-            .takeIf { it.isNotEmpty() && kind != Implementation.Kind.Interface && !element.type.contains("Reference")}
+            .takeIf { it.isNotEmpty() && !isInterface && !element.type.contains("Reference")}
             ?.let { symbolFields ->
                 indent(1)
                 println("init {")
@@ -301,21 +303,24 @@ fun PrintWriter.printImplementation(implementation: Implementation) {
                 println()
             }
 
-        indent(1)
-        print("override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {")
-
         fun Field.acceptString(): String = "${name}${call()}accept(visitor, data)"
+        if (!isInterface) {
 
-        if (element.allFirFields.isNotEmpty()) {
+            indent(1)
-            println()
+            print("override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {")
-            for (field in allFields.filter { it.isFirType }) {
+
-                if (field.withGetter || !field.needAcceptAndTransform) continue
+
-                when (field.name) {
+            if (element.allFirFields.isNotEmpty()) {
-                    "explicitReceiver" -> {
+                println()
-                        val explicitReceiver = implementation["explicitReceiver"]!!
+                for (field in allFields.filter { it.isFirType }) {
-                        val dispatchReceiver = implementation["dispatchReceiver"]!!
+                    if (field.withGetter || !field.needAcceptAndTransform) continue
-                        val extensionReceiver = implementation["extensionReceiver"]!!
+                    when (field.name) {
-                        println("""
+                        "explicitReceiver" -> {
+                            val explicitReceiver = implementation["explicitReceiver"]!!
+                            val dispatchReceiver = implementation["dispatchReceiver"]!!
+                            val extensionReceiver = implementation["extensionReceiver"]!!
+                            println(
+                                """
                 |        ${explicitReceiver.acceptString()}
                 |        if (dispatchReceiver !== explicitReceiver) {
                 |            ${dispatchReceiver.acceptString()}
@@ -323,115 +328,135 @@ fun PrintWriter.printImplementation(implementation: Implementation) {
                 |        if (extensionReceiver !== explicitReceiver && extensionReceiver !== dispatchReceiver) {
                 |            ${extensionReceiver.acceptString()}
                 |        }
-                    """.trimMargin())
+                    """.trimMargin()
-                    }
+                            )
-
-                    "dispatchReceiver", "extensionReceiver", "subjectVariable" -> {}
-                    "companionObject" -> {}
-
-                    else -> {
-                        if (type == "FirClassImpl" && field.name == "declarations") {
-                            indent(2)
-                            println("(declarations.firstOrNull { it is FirConstructorImpl } as? FirConstructorImpl)?.typeParameters?.forEach { it.accept(visitor, data) }")
                         }
-                        if (type == "FirWhenExpressionImpl" && field.name == "subject") {
+
-                            println(
+                        "dispatchReceiver", "extensionReceiver", "subjectVariable" -> {
-                                """
+                        }
+                        "companionObject" -> {
+                        }
+
+                        else -> {
+                            if (type == "FirClassImpl" && field.name == "declarations") {
+                                indent(2)
+                                println("(declarations.firstOrNull { it is FirConstructorImpl } as? FirConstructorImpl)?.typeParameters?.forEach { it.accept(visitor, data) }")
+                            }
+                            if (type == "FirWhenExpressionImpl" && field.name == "subject") {
+                                println(
+                                    """
             |        if (subjectVariable != null) {
             |            subjectVariable.accept(visitor, data)
             |        } else {
             |            subject?.accept(visitor, data)
             |        }
                 """.trimMargin()
-                            )
+                                )
-                        } else {
+                            } else {
-                            indent(2)
+                                indent(2)
-                            when (field.origin) {
+                                when (field.origin) {
-                                is FirField -> {
+                                    is FirField -> {
-                                    println(field.acceptString())
+                                        println(field.acceptString())
-                                }
+                                    }
 
-                                is FieldList -> {
+                                    is FieldList -> {
-                                    println("${field.name}.forEach { it.accept(visitor, data) }")
+                                        println("${field.name}.forEach { it.accept(visitor, data) }")
-                                }
+                                    }
 
-                                else -> throw IllegalStateException()
+                                    else -> throw IllegalStateException()
+                                }
                             }
                         }
-                    }
 
+                    }
                 }
+                indent()
             }
-            indent()
+            println("}")
+            println()
         }
-        println("}")
-        println()
 
         indent()
-        println("override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): $typeWithArguments {")
+        print("override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): $typeWithArguments")
-        for (field in allFields) {
+        if (!isInterface) {
-            when {
+            println(" {")
-                !field.isMutable || !field.isFirType || field.withGetter || !field.needAcceptAndTransform -> {}
+            for (field in allFields) {
-                field.name == "explicitReceiver" -> {
+                when {
-                    val explicitReceiver = implementation["explicitReceiver"]!!
+                    !field.isMutable || !field.isFirType || field.withGetter || !field.needAcceptAndTransform -> {
-                    val dispatchReceiver = implementation["dispatchReceiver"]!!
-                    val extensionReceiver = implementation["extensionReceiver"]!!
-                    if (explicitReceiver.isMutable) {
-                        indent(2)
-                        println("explicitReceiver = explicitReceiver${explicitReceiver.call()}transformSingle(transformer, data)")
                     }
-                    if (dispatchReceiver.isMutable) {
+                    field.name == "explicitReceiver" -> {
-                        println("""
+                        val explicitReceiver = implementation["explicitReceiver"]!!
+                        val dispatchReceiver = implementation["dispatchReceiver"]!!
+                        val extensionReceiver = implementation["extensionReceiver"]!!
+                        if (explicitReceiver.isMutable) {
+                            indent(2)
+                            println("explicitReceiver = explicitReceiver${explicitReceiver.call()}transformSingle(transformer, data)")
+                        }
+                        if (dispatchReceiver.isMutable) {
+                            println(
+                                """
                             |        if (dispatchReceiver !== explicitReceiver) {
                             |            dispatchReceiver = dispatchReceiver.transformSingle(transformer, data)
                             |        }
-                        """.trimMargin())
+                        """.trimMargin()
-                    }
+                            )
-                    if (extensionReceiver.isMutable) {
+                        }
-                        println("""
+                        if (extensionReceiver.isMutable) {
+                            println(
+                                """
                             |        if (extensionReceiver !== explicitReceiver && extensionReceiver !== dispatchReceiver) {
                             |            extensionReceiver = extensionReceiver.transformSingle(transformer, data)
                             |        }
-                        """.trimMargin())
+                        """.trimMargin()
+                            )
+                        }
+                    }
+                    field.name in setOf("dispatchReceiver", "extensionReceiver") -> {
+                    }
+                    type == "FirClassImpl" && field.name == "declarations" -> {
+                        indent(2)
+                        println("(declarations.firstOrNull { it is FirConstructorImpl } as? FirConstructorImpl)?.typeParameters?.transformInplace(transformer, data)")
+                        indent(2)
+                        println("declarations.transformInplace(transformer, data)")
+                    }
+                    field.name == "companionObject" -> {
+                        indent(2)
+                        println("companionObject = declarations.asSequence().filterIsInstance<FirRegularClass>().firstOrNull { it.status.isCompanion }")
+                    }
+                    field.needsSeparateTransform -> {
+                        indent(2)
+                        println("transform${field.name.capitalize()}(transformer, data)")
+                    }
+                    !element.needTransformOtherChildren -> {
+                        indent(2)
+                        field.transform()
+                    }
+                    else -> {
                     }
                 }
-                field.name in setOf("dispatchReceiver", "extensionReceiver") -> {}
-                type == "FirClassImpl" && field.name == "declarations" -> {
-                    indent(2)
-                    println("(declarations.firstOrNull { it is FirConstructorImpl } as? FirConstructorImpl)?.typeParameters?.transformInplace(transformer, data)")
-                    indent(2)
-                    println("declarations.transformInplace(transformer, data)")
-                }
-                field.name == "companionObject" -> {
-                    indent(2)
-                    println("companionObject = declarations.asSequence().filterIsInstance<FirRegularClass>().firstOrNull { it.status.isCompanion }")
-                }
-                field.needsSeparateTransform -> {
-                    indent(2)
-                    println("transform${field.name.capitalize()}(transformer, data)")
-                }
-                !element.needTransformOtherChildren -> {
-                    indent(2)
-                    field.transform()
-                }
-                else -> {}
             }
-        }
+            if (element.needTransformOtherChildren) {
-        if (element.needTransformOtherChildren) {
+                indent(2)
+                println("transformOtherChildren(transformer, data)")
+            }
             indent(2)
-            println("transformOtherChildren(transformer, data)")
+            println("return this")
+            indent()
+            println("}")
+        } else {
+            println()
         }
-        indent(2)
-        println("return this")
-        indent()
-        println("}")
 
         for (field in allFields) {
             if (!field.needsSeparateTransform) continue
             println()
             indent()
-            print("override ${field.transformFunctionDeclaration(typeWithArguments)} {")
+            print("override ${field.transformFunctionDeclaration(typeWithArguments)}")
-            println()
+            if (isInterface) {
+                println()
+                continue
+            }
+            println(" {")
             if (field.isMutable && field.isFirType) {
                 // TODO: replace with smth normal
                 if (type == "FirWhenExpressionImpl" && field.name == "subject") {
@@ -456,24 +481,34 @@ fun PrintWriter.printImplementation(implementation: Implementation) {
         if (element.needTransformOtherChildren) {
             println()
             indent()
-            println("override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): $typeWithArguments {")
+            print("override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): $typeWithArguments")
-            for (field in allFields) {
+            if (isInterface) {
-                if (!field.isMutable || !field.isFirType || field.name == "subjectVariable") continue
+                println()
-                if (!field.needsSeparateTransform) {
+            } else {
-                    indent(2)
+                println(" {")
-                    field.transform()
+                for (field in allFields) {
+                    if (!field.isMutable || !field.isFirType || field.name == "subjectVariable") continue
+                    if (!field.needsSeparateTransform) {
+                        indent(2)
+                        field.transform()
+                    }
                 }
+                indent(2)
+                println("return this")
+                indent()
+                println("}")
             }
-            indent(2)
-            println("return this")
-            indent()
-            println("}")
         }
 
         for (field in allFields.filter { it.withReplace }) {
             println()
             indent()
-            print("override ${field.replaceFunctionDeclaration()} {")
+            print("override ${field.replaceFunctionDeclaration()}")
+            if (isInterface) {
+                println()
+                continue
+            }
+            print(" {")
             if (!field.isMutable) {
                 println("}")
                 continue