Use declaration properties in RenderIrElementVisitor

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

@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.ir.util
 
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
 import org.jetbrains.kotlin.ir.IrElement
@@ -28,6 +27,7 @@ import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.renderer.DescriptorRendererModifier
 import org.jetbrains.kotlin.renderer.OverrideRenderingPolicy
 import org.jetbrains.kotlin.types.KotlinType
+import org.jetbrains.kotlin.utils.addIfNotNull
 
 fun IrElement.render() = accept(RenderIrElementVisitor(), null)
 
@@ -39,49 +39,135 @@ class RenderIrElementVisitor : IrElementVisitor<String, Nothing?> {
         "? ${declaration::class.java.simpleName} ${declaration.descriptor.ref()}"
 
     override fun visitModuleFragment(declaration: IrModuleFragment, data: Nothing?): String =
-            "MODULE_FRAGMENT ${declaration.descriptor.ref()}"
+        "MODULE_FRAGMENT name:${declaration.name}"
 
     override fun visitExternalPackageFragment(declaration: IrExternalPackageFragment, data: Nothing?): String =
-            "EXTERNAL_PACKAGE_FRAGMENT ${declaration.packageFragmentDescriptor.fqName}"
+        "EXTERNAL_PACKAGE_FRAGMENT fqName:${declaration.fqName}"
 
     override fun visitFile(declaration: IrFile, data: Nothing?): String =
-            "FILE ${declaration.name}"
+        "FILE fqName:${declaration.fqName} fileName:${declaration.name}"
 
     override fun visitFunction(declaration: IrFunction, data: Nothing?): String =
-            "FUN ${declaration.renderOrigin()}${declaration.renderDeclared()}"
+        "FUN ${declaration.renderOriginIfNonTrivial()}${declaration.renderDeclared()}"
+
+    override fun visitSimpleFunction(declaration: IrSimpleFunction, data: Nothing?): String =
+        declaration.run {
+            "FUN ${renderOriginIfNonTrivial()}" +
+                    "name:$name visibility:$visibility modality:$modality " +
+                    renderTypeParameters() + " " +
+                    renderValueParameterTypes() + " " +
+                    "returnType:$returnType " +
+                    "flags:${renderSimpleFunctionFlags()}"
+        }
+
+    private fun IrSimpleFunction.renderSimpleFunctionFlags(): String =
+        listOfNotNull(
+            "tailrec".takeIf { isTailrec },
+            "inline".takeIf { isInline },
+            "suspend".takeIf { isSuspend }
+        ).joinToString(separator = ",")
+
+    private fun IrFunction.renderTypeParameters(): String =
+        typeParameters.joinToString(separator = ", ", prefix = "<", postfix = ">") { it.name.toString() }
+
+    private fun IrFunction.renderValueParameterTypes(): String =
+        ArrayList<String>().apply {
+            addIfNotNull(dispatchReceiverParameter?.run { "\$this:${type.render()}" })
+            addIfNotNull(extensionReceiverParameter?.run { "\$receiver:${type.render()}" })
+            valueParameters.mapTo(this) { "${it.name}:${it.type.render()}" }
+        }.joinToString(separator = ", ", prefix = "(", postfix = ")")
 
     override fun visitConstructor(declaration: IrConstructor, data: Nothing?): String =
-            "CONSTRUCTOR ${declaration.renderOrigin()}${declaration.renderDeclared()}"
+        declaration.run {
+            "CONSTRUCTOR ${renderOriginIfNonTrivial()}" +
+                    "visibility:$visibility " +
+                    renderTypeParameters() + " " +
+                    renderValueParameterTypes() + " " +
+                    "returnType:${returnType.render()} " +
+                    "flags:${if (isInline) "inline" else ""}"
+        }
 
     override fun visitProperty(declaration: IrProperty, data: Nothing?): String =
-            "PROPERTY ${declaration.renderOrigin()}${declaration.renderDeclared()}"
+        declaration.run {
+            "PROPERTY ${renderOriginIfNonTrivial()}" +
+                    "name:$name type:${type.render()} visibility:$visibility modality:$modality " +
+                    "flags:${renderPropertyFlags()}"
+        }
+
+    private fun IrProperty.renderPropertyFlags() =
+        listOfNotNull(
+            "const".takeIf { isConst },
+            "lateinit".takeIf { isLateinit },
+            "delegated".takeIf { isDelegated },
+            if (isVar) "var" else "val"
+        ).joinToString(separator = "m")
 
     override fun visitField(declaration: IrField, data: Nothing?): String =
-            "FIELD ${declaration.renderOrigin()}${declaration.renderDeclared()}"
+        "FIELD ${declaration.renderOriginIfNonTrivial()}" +
+                "name:${declaration.name} type:${declaration.type.render()} visibility:${declaration.visibility}"
 
     override fun visitClass(declaration: IrClass, data: Nothing?): String =
-            "CLASS ${declaration.renderOrigin()}${declaration.descriptor.kind} ${declaration.descriptor.ref()}"
+        declaration.run {
+            "CLASS ${renderOriginIfNonTrivial()}" +
+                    "$kind name:$name modality:$modality visibility:$visibility " +
+                    "flags:${renderClassFlags()}"
+        }
+
+    private fun IrClass.renderClassFlags() =
+        listOfNotNull("companion".takeIf { isCompanion }, "data".takeIf { isData }).joinToString(separator = ",")
 
     override fun visitTypeAlias(declaration: IrTypeAlias, data: Nothing?): String =
-            "TYPEALIAS ${declaration.renderOrigin()}${declaration.descriptor.ref()} type=${declaration.descriptor.underlyingType.render()}"
+        "TYPEALIAS ${declaration.renderOriginIfNonTrivial()}${declaration.descriptor.ref()} type=${declaration.descriptor.underlyingType.render()}"
 
     override fun visitVariable(declaration: IrVariable, data: Nothing?): String =
-            "VAR ${declaration.renderOrigin()}${declaration.renderDeclared()}"
+        "VAR ${declaration.renderOriginIfNonTrivial()}" +
+                "name:${declaration.name} type:${declaration.type.render()} flags:${declaration.renderVariableFlags()}"
+
+    private fun IrVariable.renderVariableFlags(): String =
+        listOfNotNull(
+            "const".takeIf { isConst },
+            "lateinit".takeIf { isLateinit },
+            if (isVar) "var" else "val"
+        ).joinToString(separator = " ")
 
     override fun visitEnumEntry(declaration: IrEnumEntry, data: Nothing?): String =
-            "ENUM_ENTRY ${declaration.renderOrigin()}${declaration.renderDeclared()}"
+        "ENUM_ENTRY ${declaration.renderOriginIfNonTrivial()}name:${declaration.name}"
 
     override fun visitAnonymousInitializer(declaration: IrAnonymousInitializer, data: Nothing?): String =
         "ANONYMOUS_INITIALIZER ${declaration.descriptor.ref()}"
 
     override fun visitTypeParameter(declaration: IrTypeParameter, data: Nothing?): String =
-            "TYPE_PARAMETER ${declaration.renderDeclared()}"
+        declaration.run {
+            "TYPE_PARAMETER ${renderOriginIfNonTrivial()}" +
+                    "name:$name index:$index variance:$variance " +
+                    "upperBounds:[${upperBounds.joinToString(separator = "; ") { it.render() }}]"
+        }
 
     override fun visitValueParameter(declaration: IrValueParameter, data: Nothing?): String =
-            "VALUE_PARAMETER ${declaration.renderDeclared()}"
+        declaration.run {
+            "VALUE_PARAMETER ${renderOriginIfNonTrivial()}" +
+                    "name:$name " +
+                    (if (index >= 0) "index:$index " else "") +
+                    "type:${type.render()} " +
+                    (varargElementType?.let { "varargElementType:${it.render()} " } ?: "") +
+                    "flags:${renderValueParameterFlags()}"
+        }
+
+    private fun IrValueParameter.renderValueParameterFlags(): String =
+        listOfNotNull(
+            "vararg".takeIf { varargElementType != null },
+            "crossinline".takeIf { isCrossinline },
+            "noinline".takeIf { isNoinline }
+        ).joinToString(separator = ",")
 
     override fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty, data: Nothing?): String =
-            "LOCAL_DELEGATED_PROPERTY ${declaration.renderOrigin()}${declaration.renderDeclared()}"
+        declaration.run {
+            "LOCAL_DELEGATED_PROPERTY ${declaration.renderOriginIfNonTrivial()}" +
+                    "name:$name type:${type.render()} flags:${renderLocalDelegatedPropertyFlags()}"
+        }
+
+    private fun IrLocalDelegatedProperty.renderLocalDelegatedPropertyFlags() =
+        if (isVar) "var" else "val"
 
     override fun visitExpressionBody(body: IrExpressionBody, data: Nothing?): String =
         "EXPRESSION_BODY"
@@ -96,7 +182,7 @@ class RenderIrElementVisitor : IrElementVisitor<String, Nothing?> {
         "? ${expression::class.java.simpleName} type=${expression.type.render()}"
 
     override fun <T> visitConst(expression: IrConst<T>, data: Nothing?): String =
-            "CONST ${expression.kind} type=${expression.type.render()} value='${expression.value}'"
+        "CONST ${expression.kind} type=${expression.type.render()} value=${expression.value}"
 
     override fun visitVararg(expression: IrVararg, data: Nothing?): String =
         "VARARG type=${expression.type} varargElementType=${expression.varargElementType}"
@@ -111,7 +197,7 @@ class RenderIrElementVisitor : IrElementVisitor<String, Nothing?> {
         "COMPOSITE type=${expression.type.render()} origin=${expression.origin}"
 
     override fun visitReturn(expression: IrReturn, data: Nothing?): String =
-            "RETURN type=${expression.type.render()} from='${expression.returnTarget.ref()}'"
+        "RETURN type=${expression.type.render()} from=${expression.returnTarget.ref()}'"
 
     override fun visitCall(expression: IrCall, data: Nothing?): String =
         "CALL '${expression.descriptor.ref()}' ${expression.renderSuperQualifier()}" +
@@ -192,8 +278,7 @@ class RenderIrElementVisitor : IrElementVisitor<String, Nothing?> {
         append(prefix)
         if (value != null) {
             append(toString(value))
-        }
+        } else {
-        else {
             append("null")
         }
         append(" ")
@@ -205,7 +290,7 @@ class RenderIrElementVisitor : IrElementVisitor<String, Nothing?> {
             append("'${expression.descriptor.ref()}' ")
             append("delegate='${expression.delegate.descriptor.ref()}' ")
             append("getter='${expression.getter.descriptor.ref()}' ")
-                appendNullableAttribute("setter=", expression.setter) { "'${it.descriptor.ref()}'"}
+            appendNullableAttribute("setter=", expression.setter) { "'${it.descriptor.ref()}'" }
             append("type=${expression.type.render()} ")
             append("origin=${expression.origin}")
         }
@@ -261,7 +346,7 @@ class RenderIrElementVisitor : IrElementVisitor<String, Nothing?> {
         internal fun KotlinType.render(): String =
             DECLARATION_RENDERER.renderType(this)
 
-        internal fun IrDeclaration.renderOrigin(): String =
+        internal fun IrDeclaration.renderOriginIfNonTrivial(): String =
             if (origin != IrDeclarationOrigin.DEFINED) origin.toString() + " " else ""
     }
 }