FirRenderer: add renderAllModifiers and renderDetailedTypeReferences

Related to KT-52020

compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/TypeRenderer.kt

@@ -9,20 +9,24 @@ import org.jetbrains.kotlin.builtins.functions.FunctionClassKind
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.contract
 
-fun ConeKotlinType.render(): String {
+fun ConeKotlinType.render(renderFqNames: Boolean = true): String {
     val nullabilitySuffix = if (this !is ConeFlexibleType && this !is ConeErrorType) nullability.suffix else ""
     return when (this) {
         is ConeTypeVariableType -> "${renderAttributes()}TypeVariable(${this.lookupTag.name})"
-        is ConeDefinitelyNotNullType -> "${original.render()} & Any"
+        is ConeDefinitelyNotNullType -> "${original.render(renderFqNames)} & Any"
         is ConeErrorType -> "${renderAttributes()}ERROR CLASS: ${diagnostic.reason}"
-        is ConeCapturedType -> "${renderAttributes()}CapturedType(${constructor.projection.render()})"
+        is ConeCapturedType -> "${renderAttributes()}CapturedType(${constructor.projection.render(renderFqNames)})"
         is ConeClassLikeType -> {
             buildString {
                 append(renderAttributes())
-                append(lookupTag.classId.asString())
+                if (renderFqNames) {
+                    append(lookupTag.classId.asString())
+                } else {
+                    append(lookupTag.classId.relativeClassName.asString())
+                }
                 if (typeArguments.isNotEmpty()) {
                     append(typeArguments.joinToString(prefix = "<", postfix = ">") {
-                        it.render()
+                        it.render(renderFqNames)
                     })
                 }
             }
@@ -31,13 +35,15 @@ fun ConeKotlinType.render(): String {
             "${renderAttributes()}${lookupTag.name.asString()}"
         }
         is ConeDynamicType -> "dynamic"
-        is ConeFlexibleType -> this.render()
+        is ConeFlexibleType -> this.render(renderFqNames)
         is ConeIntersectionType -> {
             intersectedTypes.joinToString(
                 separator = " & ",
                 prefix = "${renderAttributes()}it(",
                 postfix = ")"
-            )
+            ) {
+                it.render(renderFqNames)
+            }
         }
         is ConeStubTypeForSyntheticFixation -> "${renderAttributes()}Stub (fixation): ${constructor.variable}"
         is ConeStubTypeForChainInference -> "${renderAttributes()}Stub (chain inference): ${constructor.variable}"
@@ -47,12 +53,12 @@ fun ConeKotlinType.render(): String {
     } + nullabilitySuffix
 }
 
-private fun ConeFlexibleType.render(): String =
+private fun ConeFlexibleType.render(renderFqNames: Boolean): String =
     buildString {
         append("ft<")
-        append(lowerBound.render())
+        append(lowerBound.render(renderFqNames))
         append(", ")
-        append(upperBound.render())
+        append(upperBound.render(renderFqNames))
         append(">")
     }
 
@@ -61,18 +67,18 @@ private fun ConeKotlinType.renderAttributes(): String {
     return attributes.joinToString(" ", postfix = " ") { it.toString() }
 }
 
-fun ConeTypeProjection.render(): String {
+fun ConeTypeProjection.render(renderFqNames: Boolean): String {
     return when (this) {
         ConeStarProjection -> "*"
-        is ConeKotlinTypeConflictingProjection -> "CONFLICTING-PROJECTION ${type.render()}"
-        is ConeKotlinTypeProjectionIn -> "in ${type.render()}"
-        is ConeKotlinTypeProjectionOut -> "out ${type.render()}"
-        is ConeKotlinType -> render()
+        is ConeKotlinTypeConflictingProjection -> "CONFLICTING-PROJECTION ${type.render(renderFqNames)}"
+        is ConeKotlinTypeProjectionIn -> "in ${type.render(renderFqNames)}"
+        is ConeKotlinTypeProjectionOut -> "out ${type.render(renderFqNames)}"
+        is ConeKotlinType -> render(renderFqNames)
     }
 }
 
 fun ConeKotlinType.renderFunctionType(
-    kind: FunctionClassKind?, renderType: ConeTypeProjection.() -> String = { render() }
+    kind: FunctionClassKind?, renderFqNames: Boolean, renderType: ConeTypeProjection.() -> String = { render(renderFqNames) }
 ): String {
     if (!kind.withPrettyRender()) return renderType()
 

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

@@ -66,6 +66,8 @@ open class FirRenderer(builder: StringBuilder, protected val mode: RenderMode =
         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(
@@ -124,6 +126,8 @@ open class FirRenderer(builder: StringBuilder, protected val mode: RenderMode =
                 renderPackageDirective = false,
                 renderNestedDeclarations = false,
                 renderDefaultParameterValues = false,
+                renderDetailedTypeReferences = false,
+                renderAllModifiers = false,
             )
 
             val WithDeclarationAttributes = RenderMode(
@@ -236,7 +240,6 @@ open class FirRenderer(builder: StringBuilder, protected val mode: RenderMode =
 
     override fun visitCallableDeclaration(callableDeclaration: FirCallableDeclaration) {
         renderContexts(callableDeclaration.contextReceivers)
-        callableDeclaration.contextReceivers
         callableDeclaration.annotations.renderAnnotations()
         visitMemberDeclaration(callableDeclaration)
         val receiverType = callableDeclaration.receiverTypeRef
@@ -338,7 +341,7 @@ open class FirRenderer(builder: StringBuilder, protected val mode: RenderMode =
     }
 
     override fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration) {
-        if (memberDeclaration !is FirProperty || !memberDeclaration.isLocal) {
+        if (mode.renderAllModifiers && (memberDeclaration !is FirProperty || !memberDeclaration.isLocal)) {
             // we can't access session.effectiveVisibilityResolver from here!
             // print(memberDeclaration.visibility.asString(memberDeclaration.getEffectiveVisibility(...)) + " ")
             print(memberDeclaration.visibility.asString() + " ")
@@ -350,11 +353,13 @@ open class FirRenderer(builder: StringBuilder, protected val mode: RenderMode =
         if (memberDeclaration.isActual) {
             print("actual ")
         }
-        if (memberDeclaration.isExternal) {
-            print("external ")
-        }
-        if (memberDeclaration.isOverride) {
-            print("override ")
+        if (mode.renderAllModifiers) {
+            if (memberDeclaration.isExternal) {
+                print("external ")
+            }
+            if (memberDeclaration.isOverride) {
+                print("override ")
+            }
         }
         if (memberDeclaration.isStatic) {
             print("static ")
@@ -379,26 +384,28 @@ open class FirRenderer(builder: StringBuilder, protected val mode: RenderMode =
             print("fun ")
         }
 
-        if (memberDeclaration.isInline) {
-            print("inline ")
-        }
-        if (memberDeclaration.isOperator) {
-            print("operator ")
-        }
-        if (memberDeclaration.isInfix) {
-            print("infix ")
-        }
-        if (memberDeclaration.isTailRec) {
-            print("tailrec ")
-        }
-        if (memberDeclaration.isSuspend) {
-            print("suspend ")
-        }
-        if (memberDeclaration.isConst) {
-            print("const ")
-        }
-        if (memberDeclaration.isLateInit) {
-            print("lateinit ")
+        if (mode.renderAllModifiers) {
+            if (memberDeclaration.isInline) {
+                print("inline ")
+            }
+            if (memberDeclaration.isOperator) {
+                print("operator ")
+            }
+            if (memberDeclaration.isInfix) {
+                print("infix ")
+            }
+            if (memberDeclaration.isTailRec) {
+                print("tailrec ")
+            }
+            if (memberDeclaration.isSuspend) {
+                print("suspend ")
+            }
+            if (memberDeclaration.isConst) {
+                print("const ")
+            }
+            if (memberDeclaration.isLateInit) {
+                print("lateinit ")
+            }
         }
 
         visitDeclaration(memberDeclaration as FirDeclaration)
@@ -1128,10 +1135,14 @@ open class FirRenderer(builder: StringBuilder, protected val mode: RenderMode =
 
     override fun visitResolvedTypeRef(resolvedTypeRef: FirResolvedTypeRef) {
         val kind = resolvedTypeRef.functionTypeKind
-        print("R|")
+        if (mode.renderDetailedTypeReferences) {
+            print("R|")
+        }
         val coneType = resolvedTypeRef.type
-        print(coneType.renderFunctionType(kind))
-        print("|")
+        print(coneType.renderFunctionType(kind, renderFqNames = mode.renderDetailedTypeReferences))
+        if (mode.renderDetailedTypeReferences) {
+            print("|")
+        }
     }
 
     override fun visitUserTypeRef(userTypeRef: FirUserTypeRef) {