From 3deea96b5340a4e678b0c49a6812c669f2b741ac Mon Sep 17 00:00:00 2001 From: Sergej Jaskiewicz Date: Wed, 10 May 2023 16:52:18 +0200 Subject: [PATCH] [IR] Introduce DumpIrTreeOptions for customizing IR dump We plan to add more options => using a data class is better than multiple function parameters --- .../jetbrains/kotlin/ir/util/Deprecated.kt | 65 ++++++++++ .../jetbrains/kotlin/ir/util/DumpIrTree.kt | 33 +++-- .../kotlin/ir/util/RenderIrElement.kt | 113 +++++++++--------- .../backend/handlers/IrTextDumpHandler.kt | 5 +- .../backend/handlers/IrTreeVerifierHandler.kt | 5 +- .../kotlin/klib/AbstractKlibIrTextTestCase.kt | 4 +- 6 files changed, 152 insertions(+), 73 deletions(-) create mode 100644 compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/Deprecated.kt diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/Deprecated.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/Deprecated.kt new file mode 100644 index 00000000000..861fffe43d2 --- /dev/null +++ b/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)) \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DumpIrTree.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DumpIrTree.kt index a85e6e13c94..f9574afb831 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DumpIrTree.kt +++ b/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.stableOrdered(): List { class DumpIrTreeVisitor( out: Appendable, - normalizeNames: Boolean = false, - private val stableOrder: Boolean = false + private val options: DumpIrTreeOptions = DumpIrTreeOptions(), ) : IrElementVisitor { 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.ordered(): List = if (stableOrder) stableOrdered() else this + private fun List.ordered(): List = 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) { diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/RenderIrElement.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/RenderIrElement.kt index fdbf043edb9..20d15215a54 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/RenderIrElement.kt +++ b/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 { - 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 { 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 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) ?: "" +private fun IrFunction.renderReturnType(renderer: RenderIrElementVisitor?, options: DumpIrTreeOptions): String = + safeReturnType?.renderTypeWithRenderer(renderer, options) ?: "" -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, renderer: RenderIrElementVisitor?, verboseErrorTypes: Boolean) = +private fun renderTypeAnnotations(annotations: List, 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, renderer private fun StringBuilder.renderAsAnnotation( irAnnotation: IrConstructorCall, renderer: RenderIrElementVisitor?, - verboseErrorTypes: Boolean, + options: DumpIrTreeOptions, ) { val annotationClassName = irAnnotation.symbol.takeIf { it.isBound }?.owner?.parentAsClass?.name?.asString() ?: "" 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("") - 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 ) } }] " + diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrTextDumpHandler.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrTextDumpHandler.kt index 0316273effa..4c35d875bd7 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrTextDumpHandler.kt +++ b/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) } diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrTreeVerifierHandler.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrTreeVerifierHandler.kt index 19e4d1e78c1..5e558c2ba50 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrTreeVerifierHandler.kt +++ b/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" } } } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/klib/AbstractKlibIrTextTestCase.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/klib/AbstractKlibIrTextTestCase.kt index 749abca1460..24d27847eb1 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/klib/AbstractKlibIrTextTestCase.kt +++ b/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)