[FIR] Refactor: extract resolved named reference rendering out of FirRenderer

^KT-62585

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

@@ -46,6 +46,7 @@ class FirRenderer(
     override val valueParameterRenderer: FirValueParameterRenderer? = FirValueParameterRenderer(),
     override val errorExpressionRenderer: FirErrorExpressionRenderer? = FirErrorExpressionOnlyErrorRenderer(),
     override val fileAnnotationsContainerRenderer: FirFileAnnotationsContainerRenderer? = null,
+    override val resolvedNamedReferenceRenderer: FirResolvedNamedReferenceRenderer = FirResolvedNamedReferenceRendererWithLabel()
 ) : FirRendererComponents {
 
     override val visitor = Visitor()
@@ -98,6 +99,7 @@ class FirRenderer(
         valueParameterRenderer?.components = this
         errorExpressionRenderer?.components = this
         fileAnnotationsContainerRenderer?.components = this
+        resolvedNamedReferenceRenderer.components = this
     }
 
     fun renderElementAsString(element: FirElement, trim: Boolean = false): String {
@@ -924,57 +926,13 @@ class FirRenderer(
         }
 
         override fun visitResolvedNamedReference(resolvedNamedReference: FirResolvedNamedReference) {
-            print("R|")
-            val symbol = resolvedNamedReference.resolvedSymbol
-            val isSubstitutionOverride = (symbol.fir as? FirCallableDeclaration)?.isSubstitutionOverride == true
-
-            if (isSubstitutionOverride) {
-                print("SubstitutionOverride<")
-            }
-
-            referencedSymbolRenderer.printReference(symbol.unwrapIntersectionOverrides())
-
-            if (resolvedNamedReference is FirResolvedCallableReference) {
-                if (resolvedNamedReference.inferredTypeArguments.isNotEmpty()) {
-                    print("<")
-                    for ((index, element) in resolvedNamedReference.inferredTypeArguments.withIndex()) {
-                        if (index > 0) {
-                            print(", ")
-                        }
-                        typeRenderer.render(element)
-                    }
-                    print(">")
-                }
-            }
-
-            if (isSubstitutionOverride) {
-                when (symbol) {
-                    is FirNamedFunctionSymbol -> {
-                        print(": ")
-                        symbol.fir.returnTypeRef.accept(this)
-                    }
-                    is FirPropertySymbol -> {
-                        print(": ")
-                        symbol.fir.returnTypeRef.accept(this)
-                    }
-                }
-                print(">")
-            }
-            if (resolvedNamedReference is FirResolvedErrorReference) {
-                print("<${resolvedNamedReference.diagnostic.reason}>#")
-            }
-            print("|")
+            resolvedNamedReferenceRenderer.render(resolvedNamedReference)
         }
 
         override fun visitResolvedErrorReference(resolvedErrorReference: FirResolvedErrorReference) {
             visitResolvedNamedReference(resolvedErrorReference)
         }
 
-        private fun FirBasedSymbol<*>.unwrapIntersectionOverrides(): FirBasedSymbol<*> {
-            (this as? FirCallableSymbol<*>)?.baseForIntersectionOverride?.let { return it.unwrapIntersectionOverrides() }
-            return this
-        }
-
         override fun visitResolvedCallableReference(resolvedCallableReference: FirResolvedCallableReference) {
             visitResolvedNamedReference(resolvedCallableReference)
         }

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

@@ -26,4 +26,5 @@ internal interface FirRendererComponents {
     val valueParameterRenderer: FirValueParameterRenderer?
     val errorExpressionRenderer: FirErrorExpressionRenderer?
     val fileAnnotationsContainerRenderer: FirFileAnnotationsContainerRenderer?
+    val resolvedNamedReferenceRenderer: FirResolvedNamedReferenceRenderer
 }

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

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.renderer
+
+import org.jetbrains.kotlin.fir.baseForIntersectionOverride
+import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
+import org.jetbrains.kotlin.fir.isSubstitutionOverride
+import org.jetbrains.kotlin.fir.references.FirResolvedCallableReference
+import org.jetbrains.kotlin.fir.references.FirResolvedErrorReference
+import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
+
+open class FirResolvedNamedReferenceRenderer {
+
+    internal lateinit var components: FirRendererComponents
+
+    protected val printer: FirPrinter get() = components.printer
+    private val visitor: FirRenderer.Visitor get() = components.visitor
+
+    internal open fun render(resolvedNamedReference: FirResolvedNamedReference) {
+        val symbol = resolvedNamedReference.resolvedSymbol
+        val isSubstitutionOverride = (symbol.fir as? FirCallableDeclaration)?.isSubstitutionOverride == true
+
+        if (isSubstitutionOverride) {
+            printer.print("SubstitutionOverride<")
+        }
+
+        components.referencedSymbolRenderer.printReference(symbol.unwrapIntersectionOverrides())
+
+        if (resolvedNamedReference is FirResolvedCallableReference) {
+            if (resolvedNamedReference.inferredTypeArguments.isNotEmpty()) {
+                printer.print("<")
+                for ((index, element) in resolvedNamedReference.inferredTypeArguments.withIndex()) {
+                    if (index > 0) {
+                        printer.print(", ")
+                    }
+                    components.typeRenderer.render(element)
+                }
+                printer.print(">")
+            }
+        }
+
+        if (isSubstitutionOverride) {
+            when (symbol) {
+                is FirNamedFunctionSymbol -> {
+                    printer.print(": ")
+                    symbol.fir.returnTypeRef.accept(visitor)
+                }
+                is FirPropertySymbol -> {
+                    printer.print(": ")
+                    symbol.fir.returnTypeRef.accept(visitor)
+                }
+            }
+            printer.print(">")
+        }
+        if (resolvedNamedReference is FirResolvedErrorReference) {
+            printer.print("<${resolvedNamedReference.diagnostic.reason}>#")
+        }
+    }
+
+    private fun FirBasedSymbol<*>.unwrapIntersectionOverrides(): FirBasedSymbol<*> {
+        (this as? FirCallableSymbol<*>)?.baseForIntersectionOverride?.let { return it.unwrapIntersectionOverrides() }
+        return this
+    }
+}
+
+class FirResolvedNamedReferenceRendererWithLabel : FirResolvedNamedReferenceRenderer() {
+    override fun render(resolvedNamedReference: FirResolvedNamedReference) {
+        printer.print("R|")
+        super.render(resolvedNamedReference)
+        printer.print("|")
+    }
+}