FirRenderer: partially get rid of RenderMode

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticRenderers.kt

@@ -14,7 +14,11 @@ import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirModuleData
 import org.jetbrains.kotlin.fir.declarations.utils.*
 import org.jetbrains.kotlin.fir.render
+import org.jetbrains.kotlin.fir.renderer.ConeTypeRenderer
+import org.jetbrains.kotlin.fir.renderer.FirAnnotationRenderer
+import org.jetbrains.kotlin.fir.renderer.FirNoClassMemberRenderer
 import org.jetbrains.kotlin.fir.renderer.FirRenderer
+import org.jetbrains.kotlin.fir.renderer.FirRenderer.RenderMode.Companion.WithFqNames
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.SymbolInternals
 import org.jetbrains.kotlin.fir.symbols.impl.*
@@ -27,7 +31,14 @@ object FirDiagnosticRenderers {
     val SYMBOL = Renderer { symbol: FirBasedSymbol<*> ->
         when (symbol) {
             is FirClassLikeSymbol<*>,
-            is FirCallableSymbol<*> -> symbol.fir.render(FirRenderer.RenderMode.DeclarationHeader)
+            is FirCallableSymbol<*> -> FirRenderer(
+                mode = FirRenderer.RenderMode.DeclarationHeader
+            ).with(
+                typeRenderer = ConeTypeRenderer(),
+                classMemberRenderer = FirNoClassMemberRenderer(),
+                annotationRenderer = FirAnnotationRenderer(),
+                bodyRenderer = null,
+            ).renderElementAsString(symbol.fir)
             is FirTypeParameterSymbol -> symbol.name.asString()
             else -> "???"
         }
@@ -94,7 +105,9 @@ object FirDiagnosticRenderers {
 
     val FQ_NAMES_IN_TYPES = Renderer { symbol: FirBasedSymbol<*> ->
         @OptIn(SymbolInternals::class)
-        symbol.fir.render(mode = FirRenderer.RenderMode.WithFqNamesExceptAnnotationAndBody)
+        FirRenderer(mode = WithFqNames).with(
+            annotationRenderer = null, bodyRenderer = null
+        ).renderElementAsString(symbol.fir)
     }
 
     val AMBIGUOUS_CALLS = Renderer { candidates: Collection<FirBasedSymbol<*>> ->

compiler/fir/cones/src/org/jetbrains/kotlin/fir/renderer/ConeTypeRenderer.kt

@@ -11,7 +11,13 @@ import org.jetbrains.kotlin.name.ClassId
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.contract
 
-open class ConeTypeRenderer(protected val builder: StringBuilder) {
+open class ConeTypeRenderer() {
+
+    lateinit var builder: StringBuilder
+
+    constructor(builder: StringBuilder) : this() {
+        this.builder = builder
+    }
 
     open fun renderAsPossibleFunctionType(
         type: ConeKotlinType, renderType: ConeTypeProjection.() -> Unit = { render() }

compiler/fir/cones/src/org/jetbrains/kotlin/fir/renderer/ConeTypeRendererForDebugging.kt

@@ -8,7 +8,12 @@ package org.jetbrains.kotlin.fir.renderer
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.ConeTypeProjection
 
-class ConeTypeRendererForDebugging(builder: StringBuilder) : ConeTypeRendererWithFqNames(builder) {
+class ConeTypeRendererForDebugging() : ConeTypeRendererWithFqNames() {
+
+    constructor(builder: StringBuilder) : this() {
+        this.builder = builder
+    }
+
     override fun renderAsPossibleFunctionType(type: ConeKotlinType, renderType: ConeTypeProjection.() -> Unit) {
         builder.append("R|")
         super.renderAsPossibleFunctionType(type, renderType)

compiler/fir/cones/src/org/jetbrains/kotlin/fir/renderer/ConeTypeRendererWithFqNames.kt

@@ -7,7 +7,12 @@ package org.jetbrains.kotlin.fir.renderer
 
 import org.jetbrains.kotlin.name.ClassId
 
-open class ConeTypeRendererWithFqNames(builder: StringBuilder) : ConeTypeRenderer(builder) {
+open class ConeTypeRendererWithFqNames() : ConeTypeRenderer() {
+
+    constructor(builder: StringBuilder) : this() {
+        this.builder = builder
+    }
+
     override fun ClassId.render() {
         builder.append(asString())
     }

compiler/fir/raw-fir/light-tree2fir/tests/org/jetbrains/kotlin/fir/lightTree/AbstractLightTree2FirConverterTestCase.kt

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.lightTree
 import org.jetbrains.kotlin.fir.builder.AbstractRawFirBuilderTestCase
 import org.jetbrains.kotlin.fir.builder.StubFirScopeProvider
 import org.jetbrains.kotlin.fir.render
+import org.jetbrains.kotlin.fir.renderer.FirDeclarationRendererWithAttributes
 import org.jetbrains.kotlin.fir.renderer.FirRenderer
 import org.jetbrains.kotlin.fir.session.FirSessionFactory
 import org.jetbrains.kotlin.test.KotlinTestUtils
@@ -23,7 +24,7 @@ abstract class AbstractLightTree2FirConverterTestCase : AbstractRawFirBuilderTes
             scopeProvider = StubFirScopeProvider,
             diagnosticsReporter = null
         ).buildFirFile(Paths.get(filePath))
-        val firDump = firFile.render(mode = FirRenderer.RenderMode.WithDeclarationAttributes)
+        val firDump = FirRenderer().with(declarationRenderer = FirDeclarationRendererWithAttributes()).renderElementAsString(firFile)
 
         val expectedFile = File(filePath.replace(".kt", ".txt"))
         KotlinTestUtils.assertEqualsToFile(expectedFile, firDump)

compiler/fir/raw-fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/AbstractRawFirBuilderTestCase.kt

@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.expressions.impl.FirStubStatement
 import org.jetbrains.kotlin.fir.references.impl.FirStubReference
+import org.jetbrains.kotlin.fir.renderer.FirDeclarationRendererWithAttributes
 import org.jetbrains.kotlin.fir.renderer.FirRenderer
 import org.jetbrains.kotlin.fir.session.FirSessionFactory
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
@@ -65,7 +66,7 @@ abstract class AbstractRawFirBuilderTestCase : KtParsingTestCase(
     protected open fun doRawFirTest(filePath: String) {
         val file = createKtFile(filePath)
         val firFile = file.toFirFile(BodyBuildingMode.NORMAL)
-        val firFileDump = FirRenderer(mode = FirRenderer.RenderMode.WithDeclarationAttributes).renderElementAsString(firFile)
+        val firFileDump = FirRenderer().with(declarationRenderer = FirDeclarationRendererWithAttributes()).renderElementAsString(firFile)
         val expectedPath = filePath.replace(".kt", ".txt")
         KotlinTestUtils.assertEqualsToFile(File(expectedPath), firFileDump)
     }

compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/CFGNodeRenderer.kt

@@ -39,26 +39,26 @@ fun CFGNode<*>.render(): String =
                 is LoopConditionExitNode -> "Exit loop condition"
                 is LoopExitNode -> "Exit ${fir.type()}loop"
 
-                is QualifiedAccessNode -> "Access variable ${fir.calleeReference.render(CfgRenderMode)}"
+                is QualifiedAccessNode -> "Access variable ${CfgRenderer.renderElementAsString(fir.calleeReference)}"
                 is ResolvedQualifierNode -> "Access qualifier ${fir.classId}"
                 is ComparisonExpressionNode -> "Comparison ${fir.operation.operator}"
-                is TypeOperatorCallNode -> "Type operator: \"${fir.render(CfgRenderMode)}\""
+                is TypeOperatorCallNode -> "Type operator: \"${CfgRenderer.renderElementAsString(fir)}\""
                 is EqualityOperatorCallNode -> "Equality operator ${fir.operation.operator}"
                 is JumpNode -> "Jump: ${fir.render()}"
                 is StubNode -> "Stub"
-                is CheckNotNullCallNode -> "Check not null: ${fir.render(CfgRenderMode)}"
+                is CheckNotNullCallNode -> "Check not null: ${CfgRenderer.renderElementAsString(fir)}"
 
                 is ConstExpressionNode -> "Const: ${fir.render()}"
                 is VariableDeclarationNode ->
                     "Variable declaration: ${
-                        FirRenderer(mode = CfgRenderMode).renderAsCallableDeclarationString(fir)
+                        CfgRenderer.renderAsCallableDeclarationString(fir)
                     }"
 
-                is VariableAssignmentNode -> "Assignment: ${fir.lValue.render(CfgRenderMode)}"
-                is FunctionCallNode -> "Function call: ${fir.render(CfgRenderMode)}"
-                is DelegatedConstructorCallNode -> "Delegated constructor call: ${fir.render(CfgRenderMode)}"
-                is StringConcatenationCallNode -> "String concatenation call: ${fir.render(CfgRenderMode)}"
-                is ThrowExceptionNode -> "Throw: ${fir.render(CfgRenderMode)}"
+                is VariableAssignmentNode -> "Assignment: ${CfgRenderer.renderElementAsString(fir.lValue)}"
+                is FunctionCallNode -> "Function call: ${CfgRenderer.renderElementAsString(fir)}"
+                is DelegatedConstructorCallNode -> "Delegated constructor call: ${CfgRenderer.renderElementAsString(fir)}"
+                is StringConcatenationCallNode -> "String concatenation call: ${CfgRenderer.renderElementAsString(fir)}"
+                is ThrowExceptionNode -> "Throw: ${CfgRenderer.renderElementAsString(fir)}"
 
                 is TryExpressionEnterNode -> "Try expression enter"
                 is TryMainBlockEnterNode -> "Try main block enter"
@@ -123,7 +123,7 @@ fun CFGNode<*>.render(): String =
                 is ElvisRhsEnterNode -> "Enter rhs of ?:"
                 is ElvisExitNode -> "Exit ?:"
 
-                is CallableReferenceNode -> "Callable reference: ${fir.render(CfgRenderMode)}"
+                is CallableReferenceNode -> "Callable reference: ${CfgRenderer.renderElementAsString(fir)}"
                 is GetClassCallNode -> "::class call"
 
                 is AbstractBinaryExitNode -> throw IllegalStateException()
@@ -131,12 +131,14 @@ fun CFGNode<*>.render(): String =
         )
     }
 
-private val CfgRenderMode = FirRenderer.RenderMode(
-    renderCallArguments = false,
-    renderCallableFqNames = false,
-    renderDeclarationResolvePhase = false,
-    renderAnnotation = false,
-)
+// NB: renderer has a state, so we have to create it each time
+private val CfgRenderer
+    get() = FirRenderer(
+        mode = FirRenderer.RenderMode(
+            renderCallArguments = false,
+            renderCallableFqNames = false,
+        )
+    ).with(annotationRenderer = null)
 
 private fun FirFunction.name(): String = when (this) {
     is FirSimpleFunction -> name.asString()

compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirAnnotationRenderer.kt

@@ -12,7 +12,12 @@ import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 
-open class FirAnnotationRenderer internal constructor(components: FirRendererComponents) : FirRendererComponents by components {
+open class FirAnnotationRenderer {
+
+    internal lateinit var components: FirRendererComponents
+    protected val visitor get() = components.visitor
+    protected val printer get() = components.printer
+
     fun render(annotationContainer: FirAnnotationContainer) {
         renderAnnotations(annotationContainer.annotations)
     }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirAnnotationWithArgumentsRenderer.kt

@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
 import org.jetbrains.kotlin.name.Name
 
-class FirAnnotationWithArgumentsRenderer internal constructor(components: FirRendererComponents) : FirAnnotationRenderer(components) {
+class FirAnnotationWithArgumentsRenderer() : FirAnnotationRenderer() {
     override fun FirAnnotation.renderArgumentMapping() {
         printer.print("(")
         argumentMapping.mapping.renderSeparated()

compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirBodyRenderer.kt

@@ -7,10 +7,17 @@ package org.jetbrains.kotlin.fir.renderer
 
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.expressions.FirBlock
+import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
 import org.jetbrains.kotlin.fir.expressions.FirStatement
 import org.jetbrains.kotlin.fir.expressions.impl.FirLazyBlock
 
-class FirBodyRenderer internal constructor(components: FirRendererComponents) : FirRendererComponents by components {
+class FirBodyRenderer {
+
+    internal lateinit var components: FirRendererComponents
+
+    private val annotationRenderer get() = components.annotationRenderer
+    private val visitor get() = components.visitor
+    private val printer get() = components.printer
 
     fun render(function: FirFunction) {
         renderBody(function.body)
@@ -33,4 +40,15 @@ class FirBodyRenderer internal constructor(components: FirRendererComponents) :
             }
         }
     }
+
+    fun renderDelegatedConstructor(delegatedConstructor: FirDelegatedConstructorCall?) {
+        if (delegatedConstructor != null) {
+            printer.renderInBraces {
+                delegatedConstructor.accept(visitor)
+                printer.println()
+            }
+        } else {
+            printer.println()
+        }
+    }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirClassMemberRenderer.kt

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2010-2022 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.fir.renderer
+
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
+
+open class FirClassMemberRenderer {
+    internal lateinit var components: FirRendererComponents
+    protected val visitor get() = components.visitor
+    protected val printer get() = components.printer
+
+    open fun render(regularClass: FirRegularClass) {
+        render(regularClass.declarations)
+    }
+
+    open fun render(declarations: List<FirDeclaration>) {
+        printer.renderInBraces {
+            for (declaration in declarations) {
+                declaration.accept(visitor)
+                printer.println()
+            }
+        }
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirDeclarationRenderer.kt

@@ -7,7 +7,11 @@ package org.jetbrains.kotlin.fir.renderer
 
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 
-open class FirDeclarationRenderer internal constructor(components: FirRendererComponents) : FirRendererComponents by components {
+open class FirDeclarationRenderer {
+
+    internal lateinit var components: FirRendererComponents
+    protected val printer get() = components.printer
+
     fun render(declaration: FirDeclaration) {
         with(declaration) {
             renderDeclarationResolvePhase()

compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirDeclarationRendererWithAttributes.kt

@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import kotlin.reflect.KClass
 
-open class FirDeclarationRendererWithAttributes internal constructor(components: FirRendererComponents) : FirDeclarationRenderer(components) {
+open class FirDeclarationRendererWithAttributes : FirDeclarationRenderer() {
     override fun FirDeclaration.renderDeclarationAttributes() {
         if (attributes.isNotEmpty()) {
             val attributes = getAttributesWithValues().mapNotNull { (klass, value) ->

compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirDeclarationRendererWithAttributesAndResolvePhase.kt

@@ -7,9 +7,7 @@ package org.jetbrains.kotlin.fir.renderer
 
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 
-class FirDeclarationRendererWithAttributesAndResolvePhase internal constructor(
-    components: FirRendererComponents
-) : FirDeclarationRendererWithAttributes(components) {
+class FirDeclarationRendererWithAttributesAndResolvePhase : FirDeclarationRendererWithAttributes() {
     override fun FirDeclaration.renderDeclarationResolvePhase() {
         printer.print("[${resolvePhase}] ")
     }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirDeclarationRendererWithResolvePhase.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.renderer
 
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 
-class FirDeclarationRendererWithResolvePhase internal constructor(components: FirRendererComponents) : FirDeclarationRenderer(components) {
+class FirDeclarationRendererWithResolvePhase : FirDeclarationRenderer() {
     override fun FirDeclaration.renderDeclarationResolvePhase() {
         printer.print("[${resolvePhase}] ")
     }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirNoClassMemberRenderer.kt

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2010-2022 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.fir.renderer
+
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
+
+class FirNoClassMemberRenderer : FirClassMemberRenderer() {
+    override fun render(regularClass: FirRegularClass) {
+    }
+
+    override fun render(declarations: List<FirDeclaration>) {
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirPackageDirectiveRenderer.kt

@@ -7,7 +7,12 @@ package org.jetbrains.kotlin.fir.renderer
 
 import org.jetbrains.kotlin.fir.FirPackageDirective
 
-class FirPackageDirectiveRenderer internal constructor(components: FirRendererComponents) : FirRendererComponents by components {
+class FirPackageDirectiveRenderer {
+
+    internal lateinit var components: FirRendererComponents
+    private val printer get() = components.printer
+
+
     fun render(packageDirective: FirPackageDirective) {
         if (!packageDirective.packageFqName.isRoot) {
             printer.println("package ${packageDirective.packageFqName.asString()}")

compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirRenderer.kt

@@ -34,9 +34,15 @@ import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 import java.util.*
 
 open class FirRenderer private constructor(
-    builder: StringBuilder,
+    private val builder: StringBuilder,
     protected val mode: RenderMode,
-    components: FirComponentsImpl
+    components: FirComponentsImpl,
+    private val annotationRenderer: FirAnnotationRenderer?,
+    private val bodyRenderer: FirBodyRenderer?,
+    private val classMemberRenderer: FirClassMemberRenderer,
+    private val declarationRenderer: FirDeclarationRenderer,
+    private val packageDirectiveRenderer: FirPackageDirectiveRenderer?,
+    private val typeRenderer: ConeTypeRenderer
 ) : FirPrinter(builder) {
 
     companion object {
@@ -46,8 +52,57 @@ open class FirRenderer private constructor(
         )
     }
 
+    private val visitor = Visitor()
+
+    init {
+        components.visitor = visitor
+        components.annotationRenderer = annotationRenderer
+        components.bodyRenderer = bodyRenderer
+        components.classMemberRenderer = classMemberRenderer
+        components.declarationRenderer = declarationRenderer
+        components.packageDirectiveRenderer = packageDirectiveRenderer
+        components.typeRenderer = typeRenderer
+        @Suppress("LeakingThis")
+        components.printer = this
+        annotationRenderer?.components = components
+        bodyRenderer?.components = components
+        classMemberRenderer.components = components
+        declarationRenderer.components = components
+        packageDirectiveRenderer?.components = components
+        typeRenderer.builder = builder
+    }
+
+    private constructor(
+        builder: StringBuilder,
+        mode: RenderMode,
+        components: FirComponentsImpl,
+    ) : this(
+        builder,
+        mode,
+        components,
+        FirAnnotationWithArgumentsRenderer(),
+        FirBodyRenderer(),
+        FirClassMemberRenderer(),
+        FirDeclarationRenderer(),
+        packageDirectiveRenderer = null,
+        ConeTypeRendererForDebugging(),
+    )
+
     constructor(builder: StringBuilder = StringBuilder(), mode: RenderMode = RenderMode.Normal) : this(builder, mode, FirComponentsImpl())
 
+    fun with(
+        annotationRenderer: FirAnnotationRenderer? = this.annotationRenderer,
+        bodyRenderer: FirBodyRenderer? = this.bodyRenderer,
+        classMemberRenderer: FirClassMemberRenderer = this.classMemberRenderer,
+        declarationRenderer: FirDeclarationRenderer = this.declarationRenderer,
+        packageDirectiveRenderer: FirPackageDirectiveRenderer? = this.packageDirectiveRenderer,
+        typeRenderer: ConeTypeRenderer = this.typeRenderer
+    ): FirRenderer = FirRenderer(
+        builder, mode, FirComponentsImpl(),
+        annotationRenderer, bodyRenderer, classMemberRenderer,
+        declarationRenderer, packageDirectiveRenderer, typeRenderer
+    )
+
     fun renderElementAsString(element: FirElement): String {
         element.accept(visitor)
         return toString()
@@ -69,6 +124,8 @@ open class FirRenderer private constructor(
 
         override var packageDirectiveRenderer: FirPackageDirectiveRenderer? = null
 
+        override lateinit var classMemberRenderer: FirClassMemberRenderer
+
         override lateinit var declarationRenderer: FirDeclarationRenderer
 
         override lateinit var typeRenderer: ConeTypeRenderer
@@ -81,118 +138,37 @@ open class FirRenderer private constructor(
     data class RenderMode(
         val renderCallArguments: Boolean,
         val renderCallableFqNames: Boolean,
-        val renderDeclarationResolvePhase: Boolean,
-        val renderAnnotation: Boolean,
-        val renderBodies: Boolean = true,
         val renderPropertyAccessors: Boolean = true,
-        val renderDeclarationAttributes: Boolean = false,
-        val renderPackageDirective: Boolean = false,
-        val renderNestedDeclarations: Boolean = true,
         val renderDefaultParameterValues: Boolean = true,
-        val renderDetailedTypeReferences: Boolean = true,
         val renderAllModifiers: Boolean = true,
     ) {
         companion object {
             val Normal = RenderMode(
                 renderCallArguments = true,
                 renderCallableFqNames = false,
-                renderDeclarationResolvePhase = false,
-                renderAnnotation = true,
             )
 
             val WithFqNames = RenderMode(
                 renderCallArguments = true,
                 renderCallableFqNames = true,
-                renderDeclarationResolvePhase = false,
-                renderAnnotation = true,
-            )
-
-            val WithFqNamesExceptAnnotationAndBody = RenderMode(
-                renderCallArguments = true,
-                renderCallableFqNames = true,
-                renderDeclarationResolvePhase = false,
-                renderAnnotation = false,
-                renderBodies = false,
-            )
-
-            val WithResolvePhases = RenderMode(
-                renderCallArguments = true,
-                renderCallableFqNames = false,
-                renderDeclarationResolvePhase = true,
-                renderAnnotation = true,
             )
 
             val NoBodies = RenderMode(
                 renderCallArguments = false,
                 renderCallableFqNames = false,
-                renderDeclarationResolvePhase = false,
-                renderAnnotation = false,
-                renderBodies = false,
                 renderPropertyAccessors = false,
             )
 
             val DeclarationHeader = RenderMode(
                 renderCallArguments = false,
                 renderCallableFqNames = false,
-                renderDeclarationResolvePhase = false,
-                renderAnnotation = true,
-                renderBodies = false,
                 renderPropertyAccessors = false,
-                renderDeclarationAttributes = false,
-                renderPackageDirective = false,
-                renderNestedDeclarations = false,
                 renderDefaultParameterValues = false,
-                renderDetailedTypeReferences = false,
                 renderAllModifiers = false,
             )
-
-            val WithDeclarationAttributes = RenderMode(
-                renderCallArguments = true,
-                renderCallableFqNames = false,
-                renderDeclarationResolvePhase = false,
-                renderAnnotation = true,
-                renderDeclarationAttributes = true,
-            )
         }
     }
 
-    private val visitor = Visitor()
-    private val annotationRenderer = when {
-        mode.renderAnnotation ->
-            if (mode.renderCallArguments) FirAnnotationWithArgumentsRenderer(components) else FirAnnotationRenderer(components)
-        else ->
-            null
-    }
-    private val bodyRenderer =
-        if (mode.renderBodies) FirBodyRenderer(components) else null
-
-    private val declarationRenderer = when {
-        mode.renderDeclarationAttributes && mode.renderDeclarationResolvePhase ->
-            FirDeclarationRendererWithAttributesAndResolvePhase(components)
-        mode.renderDeclarationAttributes ->
-            FirDeclarationRendererWithAttributes(components)
-        mode.renderDeclarationResolvePhase ->
-            FirDeclarationRendererWithResolvePhase(components)
-        else -> FirDeclarationRenderer(components)
-    }
-
-    private val packageDirectiveRenderer = if (mode.renderPackageDirective) FirPackageDirectiveRenderer(components) else null
-
-    @Suppress("LeakingThis")
-    private val typeRenderer =
-        if (mode.renderDetailedTypeReferences) ConeTypeRendererForDebugging(builder) else ConeTypeRenderer(builder)
-
-    init {
-        components.visitor = visitor
-        components.annotationRenderer = annotationRenderer
-        components.bodyRenderer = bodyRenderer
-        components.declarationRenderer = declarationRenderer
-        components.packageDirectiveRenderer = packageDirectiveRenderer
-        components.typeRenderer = typeRenderer
-        @Suppress("LeakingThis")
-        components.printer = this
-    }
-
     private fun List<FirElement>.renderSeparated() {
         for ((index, element) in this.withIndex()) {
             if (index > 0) {
@@ -291,15 +267,6 @@ open class FirRenderer private constructor(
         }
     }
 
-    protected fun List<FirDeclaration>.renderDeclarations() {
-        renderInBraces {
-            for (declaration in this) {
-                declaration.accept(visitor)
-                println()
-            }
-        }
-    }
-
     fun renderSupertypes(regularClass: FirRegularClass) {
         if (regularClass.superTypeRefs.isNotEmpty()) {
             print(" : ")
@@ -312,9 +279,7 @@ open class FirRenderer private constructor(
     }
 
     protected open fun renderClassDeclarations(regularClass: FirRegularClass) {
-        if (mode.renderNestedDeclarations) {
-            regularClass.declarations.renderDeclarations()
-        }
+        classMemberRenderer.render(regularClass)
     }
 
     private fun visitAssignment(operation: FirOperation, rValue: FirExpression) {
@@ -526,7 +491,7 @@ open class FirRenderer private constructor(
             annotationRenderer?.render(anonymousObject)
             print("object : ")
             anonymousObject.superTypeRefs.renderSeparated()
-            anonymousObject.declarations.renderDeclarations()
+            classMemberRenderer.render(anonymousObject.declarations)
         }
 
         override fun visitVariable(variable: FirVariable) {
@@ -614,15 +579,8 @@ open class FirRenderer private constructor(
             constructor.returnTypeRef.accept(this)
             val body = constructor.body
             val delegatedConstructor = constructor.delegatedConstructor
-            if (body == null && mode.renderBodies) {
-                if (delegatedConstructor != null) {
-                    renderInBraces {
-                        delegatedConstructor.accept(this)
-                        println()
-                    }
-                } else {
-                    println()
-                }
+            if (body == null) {
+                bodyRenderer?.renderDelegatedConstructor(delegatedConstructor)
             }
             bodyRenderer?.renderBody(body, listOfNotNull<FirStatement>(delegatedConstructor))
         }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirRendererComponents.kt

@@ -11,6 +11,7 @@ internal interface FirRendererComponents {
     val declarationRenderer: FirDeclarationRenderer
     val annotationRenderer: FirAnnotationRenderer?
     val bodyRenderer: FirBodyRenderer?
+    val classMemberRenderer: FirClassMemberRenderer
     val packageDirectiveRenderer: FirPackageDirectiveRenderer?
     val typeRenderer: ConeTypeRenderer
 }