[IR] Introduce DumpIrTreeOptions for customizing IR dump

We plan to add more options => using a data class is better
than multiple function parameters

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/Deprecated.kt

@@ -0,0 +1,65 @@
+/*
+ * 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.ir.util
+
+import org.jetbrains.kotlin.ir.IrElement
+import org.jetbrains.kotlin.ir.IrFileEntry
+import org.jetbrains.kotlin.ir.declarations.IrFile
+
+@Deprecated(
+    "Use the overload with DumpIrTreeOptions instead.",
+    ReplaceWith(
+        "dump(DumpIrTreeOptions(normalizeNames = normalizeNames, stableOrder = stableOrder))",
+        "org.jetbrains.kotlin.ir.util.DumpIrTreeOptions",
+    ),
+    DeprecationLevel.ERROR,
+)
+fun IrElement.dump(normalizeNames: Boolean = false, stableOrder: Boolean = false) =
+    dump(DumpIrTreeOptions(normalizeNames = normalizeNames, stableOrder = stableOrder))
+
+@Deprecated(
+    "Use the overload with DumpIrTreeOptions instead.",
+    ReplaceWith(
+        "dumpTreesFromLineNumber(lineNumber, DumpIrTreeOptions(normalizeNames = normalizeNames))",
+        "org.jetbrains.kotlin.ir.util.DumpIrTreeOptions",
+    ),
+    DeprecationLevel.ERROR,
+)
+fun IrFile.dumpTreesFromLineNumber(lineNumber: Int, normalizeNames: Boolean = false) =
+    dumpTreesFromLineNumber(lineNumber, DumpIrTreeOptions(normalizeNames = normalizeNames))
+
+@Deprecated(
+    "Use the overload with DumpIrTreeOptions instead.",
+    ReplaceWith(
+        "DumpTreeFromSourceLineVisitor(fileEntry, lineNumber, out, DumpIrTreeOptions(normalizeNames = normalizeNames))",
+        "org.jetbrains.kotlin.ir.util.DumpIrTreeOptions",
+    ),
+    DeprecationLevel.ERROR,
+)
+fun DumpTreeFromSourceLineVisitor(fileEntry: IrFileEntry, lineNumber: Int, out: Appendable, normalizeNames: Boolean = false) =
+    DumpTreeFromSourceLineVisitor(fileEntry, lineNumber, out, DumpIrTreeOptions(normalizeNames = normalizeNames))
+
+@Deprecated(
+    "Use the overload with DumpIrTreeOptions instead.",
+    ReplaceWith(
+        "DumpIrTreeVisitor(out, DumpIrTreeOptions(normalizeNames = normalizeNames, stableOrder = stableOrder))",
+        "org.jetbrains.kotlin.ir.util.DumpIrTreeOptions",
+    ),
+    DeprecationLevel.ERROR,
+)
+fun DumpIrTreeVisitor(out: Appendable, normalizeNames: Boolean = false, stableOrder: Boolean = false) =
+    DumpIrTreeVisitor(out, DumpIrTreeOptions(normalizeNames = normalizeNames, stableOrder = stableOrder))
+
+@Deprecated(
+    "Use the overload with DumpIrTreeOptions instead.",
+    ReplaceWith(
+        "RenderIrElementVisitor(DumpIrTreeOptions(normalizeNames = normalizeNames, stableOrder = !verboseErrorTypes))",
+        "org.jetbrains.kotlin.ir.util.DumpIrTreeOptions",
+    ),
+    DeprecationLevel.ERROR,
+)
+fun RenderIrElementVisitor(normalizeNames: Boolean = false, verboseErrorTypes: Boolean = true) =
+    RenderIrElementVisitor(DumpIrTreeOptions(normalizeNames = normalizeNames, verboseErrorTypes = verboseErrorTypes))

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DumpIrTree.kt

@@ -21,28 +21,40 @@ import org.jetbrains.kotlin.ir.IrFileEntry
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
+import org.jetbrains.kotlin.ir.types.IrErrorType
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid
 import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid
 import org.jetbrains.kotlin.utils.Printer
 
-fun IrElement.dump(normalizeNames: Boolean = false, stableOrder: Boolean = false): String =
+fun IrElement.dump(options: DumpIrTreeOptions = DumpIrTreeOptions()): String =
     try {
         StringBuilder().also { sb ->
-            accept(DumpIrTreeVisitor(sb, normalizeNames, stableOrder), "")
+            accept(DumpIrTreeVisitor(sb, options), "")
         }.toString()
     } catch (e: Exception) {
-        "(Full dump is not available: ${e.message})\n" + render()
+        "(Full dump is not available: ${e.message})\n" + render(options)
     }
 
-fun IrFile.dumpTreesFromLineNumber(lineNumber: Int, normalizeNames: Boolean = false): String {
+fun IrFile.dumpTreesFromLineNumber(lineNumber: Int, options: DumpIrTreeOptions = DumpIrTreeOptions()): String {
     if (shouldSkipDump()) return ""
     val sb = StringBuilder()
-    accept(DumpTreeFromSourceLineVisitor(fileEntry, lineNumber, sb, normalizeNames), null)
+    accept(DumpTreeFromSourceLineVisitor(fileEntry, lineNumber, sb, options), null)
     return sb.toString()
 }
 
+/**
+ * @property normalizeNames Rename temporary local variables using a stable naming scheme
+ * @property stableOrder Print declarations in a sorted order
+ * @property verboseErrorTypes Whether to dump the value of [IrErrorType.kotlinType] for [IrErrorType] nodes
+ */
+data class DumpIrTreeOptions(
+    val normalizeNames: Boolean = false,
+    val stableOrder: Boolean = false,
+    val verboseErrorTypes: Boolean = true,
+)
+
 private fun IrFile.shouldSkipDump(): Boolean {
     val entry = fileEntry as? NaiveSourceBasedFileEntryImpl ?: return false
     return entry.lineStartOffsetsAreEmpty
@@ -81,15 +93,14 @@ internal fun List<IrDeclaration>.stableOrdered(): List<IrDeclaration> {
 
 class DumpIrTreeVisitor(
     out: Appendable,
-    normalizeNames: Boolean = false,
-    private val stableOrder: Boolean = false
+    private val options: DumpIrTreeOptions = DumpIrTreeOptions(),
 ) : IrElementVisitor<Unit, String> {
 
     private val printer = Printer(out, "  ")
-    private val elementRenderer = RenderIrElementVisitor(normalizeNames, !stableOrder)
+    private val elementRenderer = RenderIrElementVisitor(options)
     private fun IrType.render() = elementRenderer.renderType(this)
 
-    private fun List<IrDeclaration>.ordered(): List<IrDeclaration> = if (stableOrder) stableOrdered() else this
+    private fun List<IrDeclaration>.ordered(): List<IrDeclaration> = if (options.stableOrder) stableOrdered() else this
 
     override fun visitElement(element: IrElement, data: String) {
         element.dumpLabeledElementWith(data) {
@@ -434,9 +445,9 @@ class DumpTreeFromSourceLineVisitor(
     val fileEntry: IrFileEntry,
     private val lineNumber: Int,
     out: Appendable,
-    normalizeNames: Boolean = false
+    options: DumpIrTreeOptions,
 ) : IrElementVisitorVoid {
-    private val dumper = DumpIrTreeVisitor(out, normalizeNames)
+    private val dumper = DumpIrTreeVisitor(out, options)
 
     override fun visitElement(element: IrElement) {
         if (fileEntry.getLineNumber(element.startOffset) == lineNumber) {

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/RenderIrElement.kt

@@ -23,33 +23,33 @@ import org.jetbrains.kotlin.util.capitalizeDecapitalize.toLowerCaseAsciiOnly
 import org.jetbrains.kotlin.utils.addIfNotNull
 import org.jetbrains.kotlin.utils.addToStdlib.ifTrue
 
-fun IrElement.render() =
-    accept(RenderIrElementVisitor(), null)
+fun IrElement.render(options: DumpIrTreeOptions = DumpIrTreeOptions()) =
+    accept(RenderIrElementVisitor(options), null)
 
-class RenderIrElementVisitor(normalizeNames: Boolean = false, private val verboseErrorTypes: Boolean = true) :
+class RenderIrElementVisitor(private val options: DumpIrTreeOptions = DumpIrTreeOptions()) :
     IrElementVisitor<String, Nothing?> {
 
-    private val variableNameData = VariableNameData(normalizeNames)
+    private val variableNameData = VariableNameData(options.normalizeNames)
 
-    fun renderType(type: IrType) = type.renderTypeWithRenderer(this@RenderIrElementVisitor, verboseErrorTypes)
+    fun renderType(type: IrType) = type.renderTypeWithRenderer(this@RenderIrElementVisitor, options)
 
     fun renderSymbolReference(symbol: IrSymbol) = symbol.renderReference()
 
     fun renderAsAnnotation(irAnnotation: IrConstructorCall): String =
-        StringBuilder().also { it.renderAsAnnotation(irAnnotation, this, verboseErrorTypes) }.toString()
+        StringBuilder().also { it.renderAsAnnotation(irAnnotation, this, options) }.toString()
 
     private fun IrType.render(): String =
-        this.renderTypeWithRenderer(this@RenderIrElementVisitor, verboseErrorTypes)
+        this.renderTypeWithRenderer(this@RenderIrElementVisitor, options)
 
     private fun IrSymbol.renderReference() =
         if (isBound)
-            owner.accept(BoundSymbolReferenceRenderer(variableNameData, verboseErrorTypes), null)
+            owner.accept(BoundSymbolReferenceRenderer(variableNameData, options), null)
         else
             "UNBOUND ${javaClass.simpleName}"
 
     private class BoundSymbolReferenceRenderer(
         private val variableNameData: VariableNameData,
-        private val verboseErrorTypes: Boolean,
+        private val options: DumpIrTreeOptions,
     ) : IrElementVisitor<String, Nothing?> {
 
         override fun visitElement(element: IrElement, data: Nothing?) = buildTrimEnd {
@@ -66,16 +66,16 @@ class RenderIrElementVisitor(normalizeNames: Boolean = false, private val verbos
         }
 
         override fun visitTypeParameter(declaration: IrTypeParameter, data: Nothing?): String =
-            renderTypeParameter(declaration, null, verboseErrorTypes)
+            renderTypeParameter(declaration, null, options)
 
         override fun visitClass(declaration: IrClass, data: Nothing?) =
-            renderClassWithRenderer(declaration, null, verboseErrorTypes)
+            renderClassWithRenderer(declaration, null, options)
 
         override fun visitEnumEntry(declaration: IrEnumEntry, data: Nothing?) =
             renderEnumEntry(declaration)
 
         override fun visitField(declaration: IrField, data: Nothing?) =
-            renderField(declaration, null, verboseErrorTypes)
+            renderField(declaration, null, options)
 
         override fun visitVariable(declaration: IrVariable, data: Nothing?) =
             buildTrimEnd {
@@ -83,7 +83,7 @@ class RenderIrElementVisitor(normalizeNames: Boolean = false, private val verbos
 
                 append(declaration.normalizedName(variableNameData))
                 append(": ")
-                append(declaration.type.renderTypeWithRenderer(null, verboseErrorTypes))
+                append(declaration.type.renderTypeWithRenderer(null, options))
                 append(' ')
 
                 append(declaration.renderVariableFlags())
@@ -95,7 +95,7 @@ class RenderIrElementVisitor(normalizeNames: Boolean = false, private val verbos
             buildTrimEnd {
                 append(declaration.name.asString())
                 append(": ")
-                append(declaration.type.renderTypeWithRenderer(null, verboseErrorTypes))
+                append(declaration.type.renderTypeWithRenderer(null, options))
                 append(' ')
 
                 append(declaration.renderValueParameterFlags())
@@ -130,17 +130,17 @@ class RenderIrElementVisitor(normalizeNames: Boolean = false, private val verbos
                         append("vararg ")
                         append(valueParameter.name.asString())
                         append(": ")
-                        append(varargElementType.renderTypeWithRenderer(null, verboseErrorTypes))
+                        append(varargElementType.renderTypeWithRenderer(null, options))
                     } else {
                         append(valueParameter.name.asString())
                         append(": ")
-                        append(valueParameter.type.renderTypeWithRenderer(null, verboseErrorTypes))
+                        append(valueParameter.type.renderTypeWithRenderer(null, options))
                     }
                 }
 
                 if (declaration is IrSimpleFunction) {
                     append(": ")
-                    append(declaration.renderReturnType(null, verboseErrorTypes))
+                    append(declaration.renderReturnType(null, options))
                 }
                 append(' ')
 
@@ -173,10 +173,10 @@ class RenderIrElementVisitor(normalizeNames: Boolean = false, private val verbos
                 val getter = declaration.getter
                 if (getter != null) {
                     append(": ")
-                    append(getter.renderReturnType(null, verboseErrorTypes))
+                    append(getter.renderReturnType(null, options))
                 } else declaration.backingField?.type?.let { type ->
                     append(": ")
-                    append(type.renderTypeWithRenderer(null, verboseErrorTypes))
+                    append(type.renderTypeWithRenderer(null, options))
                 }
 
                 append(' ')
@@ -188,7 +188,7 @@ class RenderIrElementVisitor(normalizeNames: Boolean = false, private val verbos
                 if (declaration.isVar) append("var ") else append("val ")
                 append(declaration.name.asString())
                 append(": ")
-                append(declaration.type.renderTypeWithRenderer(null, verboseErrorTypes))
+                append(declaration.type.renderTypeWithRenderer(null, options))
                 append(" by (...)")
             }
 
@@ -258,7 +258,7 @@ class RenderIrElementVisitor(normalizeNames: Boolean = false, private val verbos
                     "name:$name visibility:$visibility modality:$modality " +
                     renderTypeParameters() + " " +
                     renderValueParameterTypes() + " " +
-                    "returnType:${renderReturnType(this@RenderIrElementVisitor, verboseErrorTypes)} " +
+                    "returnType:${renderReturnType(this@RenderIrElementVisitor, options)} " +
                     renderSimpleFunctionFlags()
         }
 
@@ -275,7 +275,7 @@ class RenderIrElementVisitor(normalizeNames: Boolean = false, private val verbos
                     "visibility:$visibility " +
                     renderTypeParameters() + " " +
                     renderValueParameterTypes() + " " +
-                    "returnType:${renderReturnType(this@RenderIrElementVisitor, verboseErrorTypes)} " +
+                    "returnType:${renderReturnType(this@RenderIrElementVisitor, options)} " +
                     renderConstructorFlags()
         }
 
@@ -287,10 +287,10 @@ class RenderIrElementVisitor(normalizeNames: Boolean = false, private val verbos
         }
 
     override fun visitField(declaration: IrField, data: Nothing?): String =
-        renderField(declaration, this, verboseErrorTypes)
+        renderField(declaration, this, options)
 
     override fun visitClass(declaration: IrClass, data: Nothing?): String =
-        renderClassWithRenderer(declaration, this, verboseErrorTypes)
+        renderClassWithRenderer(declaration, this, options)
 
     override fun visitVariable(declaration: IrVariable, data: Nothing?): String =
         declaration.runTrimEnd {
@@ -304,7 +304,7 @@ class RenderIrElementVisitor(normalizeNames: Boolean = false, private val verbos
         "ANONYMOUS_INITIALIZER isStatic=${declaration.isStatic}"
 
     override fun visitTypeParameter(declaration: IrTypeParameter, data: Nothing?): String =
-        renderTypeParameter(declaration, this, verboseErrorTypes)
+        renderTypeParameter(declaration, this, options)
 
     override fun visitValueParameter(declaration: IrValueParameter, data: Nothing?): String =
         declaration.runTrimEnd {
@@ -591,14 +591,15 @@ private fun IrDeclaration.renderDeclarationParentFqn(sb: StringBuilder) {
     }
 }
 
-fun IrType.render() = renderTypeWithRenderer(RenderIrElementVisitor(), true)
+fun IrType.render(options: DumpIrTreeOptions = DumpIrTreeOptions()) =
+    renderTypeWithRenderer(RenderIrElementVisitor(options), options)
 
-fun IrSimpleType.render() = (this as IrType).render()
+fun IrSimpleType.render(options: DumpIrTreeOptions = DumpIrTreeOptions()) = (this as IrType).render(options)
 
-fun IrTypeArgument.render() =
+fun IrTypeArgument.render(options: DumpIrTreeOptions = DumpIrTreeOptions()) =
     when (this) {
         is IrStarProjection -> "*"
-        is IrTypeProjection -> "$variance ${type.render()}"
+        is IrTypeProjection -> "$variance ${type.render(options)}"
     }
 
 internal inline fun <T, Buffer : Appendable> Buffer.appendIterableWith(
@@ -726,17 +727,17 @@ private fun IrVariable.normalizedName(data: VariableNameData): String {
     return name.asString()
 }
 
-private fun IrFunction.renderReturnType(renderer: RenderIrElementVisitor?, verboseErrorTypes: Boolean): String =
-    safeReturnType?.renderTypeWithRenderer(renderer, verboseErrorTypes) ?: "<Uninitialized>"
+private fun IrFunction.renderReturnType(renderer: RenderIrElementVisitor?, options: DumpIrTreeOptions): String =
+    safeReturnType?.renderTypeWithRenderer(renderer, options) ?: "<Uninitialized>"
 
-private fun IrType.renderTypeWithRenderer(renderer: RenderIrElementVisitor?, verboseErrorTypes: Boolean): String =
-    "${renderTypeAnnotations(annotations, renderer, verboseErrorTypes)}${renderTypeInner(renderer, verboseErrorTypes)}"
+private fun IrType.renderTypeWithRenderer(renderer: RenderIrElementVisitor?, options: DumpIrTreeOptions): String =
+    "${renderTypeAnnotations(annotations, renderer, options)}${renderTypeInner(renderer, options)}"
 
-private fun IrType.renderTypeInner(renderer: RenderIrElementVisitor?, verboseErrorTypes: Boolean) =
+private fun IrType.renderTypeInner(renderer: RenderIrElementVisitor?, options: DumpIrTreeOptions) =
     when (this) {
         is IrDynamicType -> "dynamic"
 
-        is IrErrorType -> "IrErrorType(${verboseErrorTypes.ifTrue { originalKotlinType }})"
+        is IrErrorType -> "IrErrorType(${options.verboseErrorTypes.ifTrue { originalKotlinType }})"
 
         is IrSimpleType -> buildTrimEnd {
             val isDefinitelyNotNullType =
@@ -746,7 +747,7 @@ private fun IrType.renderTypeInner(renderer: RenderIrElementVisitor?, verboseErr
             if (arguments.isNotEmpty()) {
                 append(
                     arguments.joinToString(prefix = "<", postfix = ">", separator = ", ") {
-                        it.renderTypeArgument(renderer, verboseErrorTypes)
+                        it.renderTypeArgument(renderer, options)
                     }
                 )
             }
@@ -756,22 +757,22 @@ private fun IrType.renderTypeInner(renderer: RenderIrElementVisitor?, verboseErr
                 append('?')
             }
             abbreviation?.let {
-                append(it.renderTypeAbbreviation(renderer, verboseErrorTypes))
+                append(it.renderTypeAbbreviation(renderer, options))
             }
         }
 
         else -> "{${javaClass.simpleName} $this}"
     }
 
-private fun IrTypeAbbreviation.renderTypeAbbreviation(renderer: RenderIrElementVisitor?, verboseErrorTypes: Boolean): String =
+private fun IrTypeAbbreviation.renderTypeAbbreviation(renderer: RenderIrElementVisitor?, options: DumpIrTreeOptions): String =
     buildString {
         append("{ ")
-        append(renderTypeAnnotations(annotations, renderer, verboseErrorTypes))
+        append(renderTypeAnnotations(annotations, renderer, options))
         append(typeAlias.renderTypeAliasFqn())
         if (arguments.isNotEmpty()) {
             append(
                 arguments.joinToString(prefix = "<", postfix = ">", separator = ", ") {
-                    it.renderTypeArgument(renderer, verboseErrorTypes)
+                    it.renderTypeArgument(renderer, options)
                 }
             )
         }
@@ -781,25 +782,25 @@ private fun IrTypeAbbreviation.renderTypeAbbreviation(renderer: RenderIrElementV
         append(" }")
     }
 
-private fun IrTypeArgument.renderTypeArgument(renderer: RenderIrElementVisitor?, verboseErrorTypes: Boolean): String =
+private fun IrTypeArgument.renderTypeArgument(renderer: RenderIrElementVisitor?, options: DumpIrTreeOptions): String =
     when (this) {
         is IrStarProjection -> "*"
 
         is IrTypeProjection -> buildTrimEnd {
             append(variance.label)
             if (variance != Variance.INVARIANT) append(' ')
-            append(type.renderTypeWithRenderer(renderer, verboseErrorTypes))
+            append(type.renderTypeWithRenderer(renderer, options))
         }
     }
 
-private fun renderTypeAnnotations(annotations: List<IrConstructorCall>, renderer: RenderIrElementVisitor?, verboseErrorTypes: Boolean) =
+private fun renderTypeAnnotations(annotations: List<IrConstructorCall>, renderer: RenderIrElementVisitor?, options: DumpIrTreeOptions) =
     if (annotations.isEmpty())
         ""
     else
         buildString {
             appendIterableWith(annotations, prefix = "", postfix = " ", separator = " ") {
                 append("@[")
-                renderAsAnnotation(it, renderer, verboseErrorTypes)
+                renderAsAnnotation(it, renderer, options)
                 append("]")
             }
         }
@@ -807,14 +808,14 @@ private fun renderTypeAnnotations(annotations: List<IrConstructorCall>, renderer
 private fun StringBuilder.renderAsAnnotation(
     irAnnotation: IrConstructorCall,
     renderer: RenderIrElementVisitor?,
-    verboseErrorTypes: Boolean,
+    options: DumpIrTreeOptions,
 ) {
     val annotationClassName = irAnnotation.symbol.takeIf { it.isBound }?.owner?.parentAsClass?.name?.asString() ?: "<unbound>"
     append(annotationClassName)
 
     if (irAnnotation.typeArgumentsCount != 0) {
         (0 until irAnnotation.typeArgumentsCount).joinTo(this, ", ", "<", ">") { i ->
-            irAnnotation.getTypeArgument(i)?.renderTypeWithRenderer(renderer, verboseErrorTypes) ?: "null"
+            irAnnotation.getTypeArgument(i)?.renderTypeWithRenderer(renderer, options) ?: "null"
         }
     }
 
@@ -825,14 +826,14 @@ private fun StringBuilder.renderAsAnnotation(
     appendIterableWith(0 until irAnnotation.valueArgumentsCount, separator = ", ", prefix = "(", postfix = ")") {
         append(valueParameterNames[it])
         append(" = ")
-        renderAsAnnotationArgument(irAnnotation.getValueArgument(it), renderer, verboseErrorTypes)
+        renderAsAnnotationArgument(irAnnotation.getValueArgument(it), renderer, options)
     }
 }
 
-private fun StringBuilder.renderAsAnnotationArgument(irElement: IrElement?, renderer: RenderIrElementVisitor?, verboseErrorTypes: Boolean) {
+private fun StringBuilder.renderAsAnnotationArgument(irElement: IrElement?, renderer: RenderIrElementVisitor?, options: DumpIrTreeOptions) {
     when (irElement) {
         null -> append("<null>")
-        is IrConstructorCall -> renderAsAnnotation(irElement, renderer, verboseErrorTypes)
+        is IrConstructorCall -> renderAsAnnotation(irElement, renderer, options)
         is IrConst<*> -> {
             append('\'')
             append(irElement.value.toString())
@@ -840,7 +841,7 @@ private fun StringBuilder.renderAsAnnotationArgument(irElement: IrElement?, rend
         }
         is IrVararg -> {
             appendIterableWith(irElement.elements, prefix = "[", postfix = "]", separator = ", ") {
-                renderAsAnnotationArgument(it, renderer, verboseErrorTypes)
+                renderAsAnnotationArgument(it, renderer, options)
             }
         }
         else -> if (renderer != null) {
@@ -851,35 +852,35 @@ private fun StringBuilder.renderAsAnnotationArgument(irElement: IrElement?, rend
     }
 }
 
-private fun renderClassWithRenderer(declaration: IrClass, renderer: RenderIrElementVisitor?, verboseErrorTypes: Boolean) =
+private fun renderClassWithRenderer(declaration: IrClass, renderer: RenderIrElementVisitor?, options: DumpIrTreeOptions) =
     declaration.runTrimEnd {
         "CLASS ${renderOriginIfNonTrivial()}" +
                 "$kind name:$name modality:$modality visibility:$visibility " +
                 renderClassFlags() +
-                "superTypes:[${superTypes.joinToString(separator = "; ") { it.renderTypeWithRenderer(renderer, verboseErrorTypes) }}]"
+                "superTypes:[${superTypes.joinToString(separator = "; ") { it.renderTypeWithRenderer(renderer, options) }}]"
     }
 
 private fun renderEnumEntry(declaration: IrEnumEntry) = declaration.runTrimEnd {
     "ENUM_ENTRY ${renderOriginIfNonTrivial()}name:$name"
 }
 
-private fun renderField(declaration: IrField, renderer: RenderIrElementVisitor?, verboseErrorTypes: Boolean) = declaration.runTrimEnd {
+private fun renderField(declaration: IrField, renderer: RenderIrElementVisitor?, options: DumpIrTreeOptions) = declaration.runTrimEnd {
     "FIELD ${renderOriginIfNonTrivial()}name:$name type:${
         type.renderTypeWithRenderer(
             renderer,
-            verboseErrorTypes
+            options
         )
     } visibility:$visibility ${renderFieldFlags()}"
 }
 
-private fun renderTypeParameter(declaration: IrTypeParameter, renderer: RenderIrElementVisitor?, verboseErrorTypes: Boolean) =
+private fun renderTypeParameter(declaration: IrTypeParameter, renderer: RenderIrElementVisitor?, options: DumpIrTreeOptions) =
     declaration.runTrimEnd {
         "TYPE_PARAMETER ${renderOriginIfNonTrivial()}" +
                 "name:$name index:$index variance:$variance " +
                 "superTypes:[${
                     superTypes.joinToString(separator = "; ") {
                         it.renderTypeWithRenderer(
-                            renderer, verboseErrorTypes
+                            renderer, options
                         )
                     }
                 }] " +

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrTextDumpHandler.kt

@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.backend.common.extensions.IrPluginContext
 import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
 import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrFile
+import org.jetbrains.kotlin.ir.util.DumpIrTreeOptions
 import org.jetbrains.kotlin.ir.util.dump
 import org.jetbrains.kotlin.ir.util.dumpTreesFromLineNumber
 import org.jetbrains.kotlin.name.ClassId
@@ -67,9 +68,9 @@ class IrTextDumpHandler(testServices: TestServices) : AbstractIrHandler(testServ
 
             for ((testFile, irFile) in testFileToIrFile) {
                 if (testFile?.directives?.contains(EXTERNAL_FILE) == true) continue
-                var actualDump = irFile.dumpTreesFromLineNumber(lineNumber = 0, normalizeNames = true)
+                var actualDump = irFile.dumpTreesFromLineNumber(lineNumber = 0, DumpIrTreeOptions(normalizeNames = true))
                 if (actualDump.isEmpty()) {
-                    actualDump = irFile.dumpTreesFromLineNumber(lineNumber = UNDEFINED_OFFSET, normalizeNames = true)
+                    actualDump = irFile.dumpTreesFromLineNumber(lineNumber = UNDEFINED_OFFSET, DumpIrTreeOptions(normalizeNames = true))
                 }
                 builder.append(actualDump)
             }

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrTreeVerifierHandler.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.test.backend.handlers
 
 import org.jetbrains.kotlin.ir.IrVerifier
+import org.jetbrains.kotlin.ir.util.DumpIrTreeOptions
 import org.jetbrains.kotlin.ir.util.deepCopyWithSymbols
 import org.jetbrains.kotlin.ir.util.dumpTreesFromLineNumber
 import org.jetbrains.kotlin.test.backend.handlers.IrTextDumpHandler.Companion.groupWithTestFiles
@@ -32,10 +33,10 @@ class IrTreeVerifierHandler(testServices: TestServices) : AbstractIrHandler(test
 
                 IrVerifier(assertions, module.frontendKind == FrontendKinds.FIR).verifyWithAssert(irFile)
 
-                val actualDump = irFile.dumpTreesFromLineNumber(lineNumber = 0, normalizeNames = true)
+                val actualDump = irFile.dumpTreesFromLineNumber(lineNumber = 0, DumpIrTreeOptions(normalizeNames = true))
 
                 val irFileCopy = irFile.deepCopyWithSymbols()
-                val dumpOfCopy = irFileCopy.dumpTreesFromLineNumber(lineNumber = 0, normalizeNames = true)
+                val dumpOfCopy = irFileCopy.dumpTreesFromLineNumber(lineNumber = 0, DumpIrTreeOptions(normalizeNames = true))
                 assertions.assertEquals(actualDump, dumpOfCopy) { "IR dump mismatch after deep copy with symbols" }
             }
         }

compiler/tests-common/tests/org/jetbrains/kotlin/klib/AbstractKlibIrTextTestCase.kt

@@ -96,14 +96,14 @@ abstract class AbstractKlibIrTextTestCase : CodegenTestCase() {
         val ignoreErrors = AbstractIrGeneratorTestCase.shouldIgnoreErrors(wholeFile)
         val stdlib = loadKlibFromPath(listOf(runtimeKlibPath)).single()
         val (irModule, bindingContext) = buildFragmentAndLinkIt(stdlib, ignoreErrors, expectActualSymbols)
-        val expected = irModule.dump(stableOrder = true)
+        val expected = irModule.dump(DumpIrTreeOptions(stableOrder = true, verboseErrorTypes = false))
         val mppProject =
             myEnvironment.configuration.languageVersionSettings.getFeatureSupport(LanguageFeature.MultiPlatformProjects) == LanguageFeature.State.ENABLED
         val klibPath = serializeModule(irModule, bindingContext, stdlib, ignoreErrors, expectActualSymbols, !mppProject)
         val libs = loadKlibFromPath(listOf(runtimeKlibPath, klibPath))
         val (stdlib2, klib) = libs
         val deserializedIrModule = deserializeModule(stdlib2, klib)
-        val actual = deserializedIrModule.dump(stableOrder = true)
+        val actual = deserializedIrModule.dump(DumpIrTreeOptions(stableOrder = true, verboseErrorTypes = false))
 
         try {
             TestCase.assertEquals(wholeFile.name, expected, actual)