DescriptorRender: cleanup code

2019-07-26 15:16:30 +03:00
parent 80b09b9a08
commit a2f937e282
3 changed files with 197 additions and 157 deletions
@@ -44,8 +44,8 @@ abstract class DescriptorRenderer {

    abstract fun renderValueParameters(parameters: Collection<ValueParameterDescriptor>, synthesizedParameterNames: Boolean): String

-    fun renderFunctionParameters(functionDescriptor: FunctionDescriptor): String
-            = renderValueParameters(functionDescriptor.valueParameters, functionDescriptor.hasSynthesizedParameterNames())
+    fun renderFunctionParameters(functionDescriptor: FunctionDescriptor): String =
+        renderValueParameters(functionDescriptor.valueParameters, functionDescriptor.hasSynthesizedParameterNames())

    abstract fun renderName(name: Name, rootRenderedElement: Boolean): String

@@ -55,7 +55,13 @@ abstract class DescriptorRenderer {
        fun appendBeforeValueParameters(parameterCount: Int, builder: StringBuilder)
        fun appendAfterValueParameters(parameterCount: Int, builder: StringBuilder)

-        fun appendBeforeValueParameter(parameter: ValueParameterDescriptor, parameterIndex: Int, parameterCount: Int, builder: StringBuilder)
+        fun appendBeforeValueParameter(
+            parameter: ValueParameterDescriptor,
+            parameterIndex: Int,
+            parameterCount: Int,
+            builder: StringBuilder
+        )
+
        fun appendAfterValueParameter(parameter: ValueParameterDescriptor, parameterIndex: Int, parameterCount: Int, builder: StringBuilder)

        object DEFAULT : ValueParametersHandler {
@@ -67,10 +73,20 @@ abstract class DescriptorRenderer {
                builder.append(")")
            }

-            override fun appendBeforeValueParameter(parameter: ValueParameterDescriptor, parameterIndex: Int, parameterCount: Int, builder: StringBuilder) {
+            override fun appendBeforeValueParameter(
+                parameter: ValueParameterDescriptor,
+                parameterIndex: Int,
+                parameterCount: Int,
+                builder: StringBuilder
+            ) {
            }

-            override fun appendAfterValueParameter(parameter: ValueParameterDescriptor, parameterIndex: Int, parameterCount: Int, builder: StringBuilder) {
+            override fun appendAfterValueParameter(
+                parameter: ValueParameterDescriptor,
+                parameterIndex: Int,
+                parameterCount: Int,
+                builder: StringBuilder
+            ) {
                if (parameterIndex != parameterCount - 1) {
                    builder.append(", ")
                }
@@ -86,28 +102,33 @@ abstract class DescriptorRenderer {
            return DescriptorRendererImpl(options)
        }

-        @JvmField val COMPACT_WITH_MODIFIERS: DescriptorRenderer = withOptions {
+        @JvmField
+        val COMPACT_WITH_MODIFIERS: DescriptorRenderer = withOptions {
            withDefinedIn = false
        }

-        @JvmField val COMPACT: DescriptorRenderer = withOptions {
+        @JvmField
+        val COMPACT: DescriptorRenderer = withOptions {
            withDefinedIn = false
            modifiers = emptySet()
        }

-        @JvmField val COMPACT_WITHOUT_SUPERTYPES: DescriptorRenderer = withOptions {
+        @JvmField
+        val COMPACT_WITHOUT_SUPERTYPES: DescriptorRenderer = withOptions {
            withDefinedIn = false
            modifiers = emptySet()
            withoutSuperTypes = true
        }

-        @JvmField val COMPACT_WITH_SHORT_TYPES: DescriptorRenderer = withOptions {
+        @JvmField
+        val COMPACT_WITH_SHORT_TYPES: DescriptorRenderer = withOptions {
            modifiers = emptySet()
            classifierNamePolicy = ClassifierNamePolicy.SHORT
            parameterNameRenderingPolicy = ParameterNameRenderingPolicy.ONLY_NON_SYNTHESIZED
        }

-        @JvmField val ONLY_NAMES_WITH_SHORT_TYPES: DescriptorRenderer = withOptions {
+        @JvmField
+        val ONLY_NAMES_WITH_SHORT_TYPES: DescriptorRenderer = withOptions {
            withDefinedIn = false
            modifiers = emptySet()
            classifierNamePolicy = ClassifierNamePolicy.SHORT
@@ -119,55 +140,57 @@ abstract class DescriptorRenderer {
            startFromName = true
        }

-        @JvmField val FQ_NAMES_IN_TYPES: DescriptorRenderer = withOptions {
+        @JvmField
+        val FQ_NAMES_IN_TYPES: DescriptorRenderer = withOptions {
            modifiers = DescriptorRendererModifier.ALL
        }

-        @JvmField val SHORT_NAMES_IN_TYPES: DescriptorRenderer = withOptions {
+        @JvmField
+        val SHORT_NAMES_IN_TYPES: DescriptorRenderer = withOptions {
            classifierNamePolicy = ClassifierNamePolicy.SHORT
            parameterNameRenderingPolicy = ParameterNameRenderingPolicy.ONLY_NON_SYNTHESIZED
        }

-        @JvmField val DEBUG_TEXT: DescriptorRenderer = withOptions {
+        @JvmField
+        val DEBUG_TEXT: DescriptorRenderer = withOptions {
            debugMode = true
            classifierNamePolicy = ClassifierNamePolicy.FULLY_QUALIFIED
            modifiers = DescriptorRendererModifier.ALL
        }

-        @JvmField val HTML: DescriptorRenderer = withOptions {
+        @JvmField
+        val HTML: DescriptorRenderer = withOptions {
            textFormat = RenderingFormat.HTML
            modifiers = DescriptorRendererModifier.ALL
        }

-        fun getClassifierKindPrefix(classifier: ClassifierDescriptorWithTypeParameters): String =
-                when (classifier) {
-                    is TypeAliasDescriptor ->
-                        "typealias"
-                    is ClassDescriptor ->
-                        if (classifier.isCompanionObject) {
-                            "companion object"
-                        }
-                        else when (classifier.kind) {
-                            ClassKind.CLASS -> "class"
-                            ClassKind.INTERFACE -> "interface"
-                            ClassKind.ENUM_CLASS -> "enum class"
-                            ClassKind.OBJECT -> "object"
-                            ClassKind.ANNOTATION_CLASS -> "annotation class"
-                            ClassKind.ENUM_ENTRY -> "enum entry"
-                        }
-                    else ->
-                        throw AssertionError("Unexpected classifier: $classifier")
+        fun getClassifierKindPrefix(classifier: ClassifierDescriptorWithTypeParameters): String = when (classifier) {
+            is TypeAliasDescriptor ->
+                "typealias"
+            is ClassDescriptor ->
+                if (classifier.isCompanionObject) {
+                    "companion object"
+                } else when (classifier.kind) {
+                    ClassKind.CLASS -> "class"
+                    ClassKind.INTERFACE -> "interface"
+                    ClassKind.ENUM_CLASS -> "enum class"
+                    ClassKind.OBJECT -> "object"
+                    ClassKind.ANNOTATION_CLASS -> "annotation class"
+                    ClassKind.ENUM_ENTRY -> "enum entry"
                }
+            else ->
+                throw AssertionError("Unexpected classifier: $classifier")
+        }
    }
 }

 enum class AnnotationArgumentsRenderingPolicy(
-        val includeAnnotationArguments: Boolean = false,
-        val includeEmptyAnnotationArguments: Boolean = false
+    val includeAnnotationArguments: Boolean = false,
+    val includeEmptyAnnotationArguments: Boolean = false
 ) {
-    NO_ARGUMENTS(),
+    NO_ARGUMENTS,
    UNLESS_EMPTY(true),
-    ALWAYS_PARENTHESIZED(true, true)
+    ALWAYS_PARENTHESIZED(includeAnnotationArguments = true, includeEmptyAnnotationArguments = true)
 }

 interface DescriptorRendererOptions {
@@ -227,8 +250,8 @@ interface DescriptorRendererOptions {

 object ExcludedTypeAnnotations {
    val internalAnnotationsForResolve = setOf(
-            FqName("kotlin.internal.NoInfer"),
-            FqName("kotlin.internal.Exact")
+        FqName("kotlin.internal.NoInfer"),
+        FqName("kotlin.internal.Exact")
    )
 }

@@ -278,9 +301,9 @@ enum class DescriptorRendererModifier(val includeByDefault: Boolean) {

    companion object {
        @JvmField
-        val DEFAULTS = DescriptorRendererModifier.values().filter { it.includeByDefault }.toSet()
+        val DEFAULTS = values().filter { it.includeByDefault }.toSet()

        @JvmField
-        val ALL = DescriptorRendererModifier.values().toSet()
+        val ALL = values().toSet()
    }
 }
@@ -28,35 +28,32 @@ import org.jetbrains.kotlin.types.TypeUtils.CANT_INFER_FUNCTION_PARAM_TYPE
 import java.util.*

 internal class DescriptorRendererImpl(
-        val options: DescriptorRendererOptionsImpl
+    val options: DescriptorRendererOptionsImpl
 ) : DescriptorRenderer(), DescriptorRendererOptions by options/* this gives access to options without qualifier */ {
    init {
        assert(options.isLocked)
    }

    private val functionTypeAnnotationsRenderer: DescriptorRendererImpl by lazy {
-        this.withOptions {
+        withOptions {
            excludedTypeAnnotationClasses += listOf(KotlinBuiltIns.FQ_NAMES.extensionFunctionType)
            annotationArgumentsRenderingPolicy = AnnotationArgumentsRenderingPolicy.ALWAYS_PARENTHESIZED
        } as DescriptorRendererImpl
    }
+
    private val functionTypeParameterTypesRenderer: DescriptorRenderer by lazy {
-        this.withOptions { excludedTypeAnnotationClasses += listOf(KotlinBuiltIns.FQ_NAMES.parameterName) }
+        withOptions { excludedTypeAnnotationClasses += listOf(KotlinBuiltIns.FQ_NAMES.parameterName) }
    }

    /* FORMATTING */
-    private fun renderKeyword(keyword: String): String {
-        when (textFormat) {
-            RenderingFormat.PLAIN -> return keyword
-            RenderingFormat.HTML -> return if (boldOnlyForNamesInHtml) keyword else "<b>$keyword</b>"
-        }
+    private fun renderKeyword(keyword: String): String = when (textFormat) {
+        RenderingFormat.PLAIN -> keyword
+        RenderingFormat.HTML -> if (boldOnlyForNamesInHtml) keyword else "<b>$keyword</b>"
    }

-    private fun renderError(keyword: String): String {
-        when (textFormat) {
-            RenderingFormat.PLAIN -> return keyword
-            RenderingFormat.HTML -> return "<font color=red><b>$keyword</b></font>"
-        }
+    private fun renderError(keyword: String): String = when (textFormat) {
+        RenderingFormat.PLAIN -> keyword
+        RenderingFormat.HTML -> "<font color=red><b>$keyword</b></font>"
    }

    private fun escape(string: String) = textFormat.escape(string)
@@ -64,27 +61,23 @@ internal class DescriptorRendererImpl(
    private fun lt() = escape("<")
    private fun gt() = escape(">")

-    private fun arrow(): String {
-        return when (textFormat) {
-            RenderingFormat.PLAIN -> escape("->")
-            RenderingFormat.HTML -> "&rarr;"
-        }
+    private fun arrow(): String = when (textFormat) {
+        RenderingFormat.PLAIN -> escape("->")
+        RenderingFormat.HTML -> "&rarr;"
    }

-    override fun renderMessage(message: String): String {
-        return when (textFormat) {
-            RenderingFormat.PLAIN -> message
-            RenderingFormat.HTML -> "<i>$message</i>"
-        }
+    override fun renderMessage(message: String): String = when (textFormat) {
+        RenderingFormat.PLAIN -> message
+        RenderingFormat.HTML -> "<i>$message</i>"
    }

    /* NAMES RENDERING */
    override fun renderName(name: Name, rootRenderedElement: Boolean): String {
        val escaped = escape(name.render())
-        if (boldOnlyForNamesInHtml && textFormat == RenderingFormat.HTML && rootRenderedElement) {
-            return "<b>$escaped</b>"
-        }
-        return escaped
+        return if (boldOnlyForNamesInHtml && textFormat == RenderingFormat.HTML && rootRenderedElement) {
+            "<b>$escaped</b>"
+        } else
+            escaped
    }

    private fun renderName(descriptor: DeclarationDescriptor, builder: StringBuilder, rootRenderedElement: Boolean) {
@@ -113,12 +106,10 @@ internal class DescriptorRendererImpl(

    private fun renderFqName(pathSegments: List<Name>) = escape(org.jetbrains.kotlin.renderer.renderFqName(pathSegments))

-    override fun renderClassifierName(klass: ClassifierDescriptor): String {
-        if (ErrorUtils.isError(klass)) {
-            return klass.typeConstructor.toString()
-        }
-        return classifierNamePolicy.renderClassifier(klass, this)
-    }
+    override fun renderClassifierName(klass: ClassifierDescriptor): String = if (ErrorUtils.isError(klass)) {
+        klass.typeConstructor.toString()
+    } else
+        classifierNamePolicy.renderClassifier(klass, this)

    /* TYPES RENDERING */
    override fun renderType(type: KotlinType): String = buildString {
@@ -160,8 +151,7 @@ internal class DescriptorRendererImpl(
            append("<Not computed yet>")
            return
        }
-        val unwrappedType = type.unwrap()
-        when (unwrappedType) {
+        when (val unwrappedType = type.unwrap()) {
            is FlexibleType -> append(unwrappedType.render(this@DescriptorRendererImpl, this@DescriptorRendererImpl))
            is SimpleType -> renderSimpleType(unwrappedType)
        }
@@ -175,8 +165,7 @@ internal class DescriptorRendererImpl(
        if (ErrorUtils.isUninferredParameter(type)) {
            if (uninferredTypeParameterAsName) {
                append(renderError((type.constructor as UninferredParameterTypeConstructor).typeParameterDescriptor.name.toString()))
-            }
-            else {
+            } else {
                append("???")
            }
            return
@@ -188,8 +177,7 @@ internal class DescriptorRendererImpl(
        }
        if (shouldRenderAsPrettyFunctionType(type)) {
            renderFunctionType(type)
-        }
-        else {
+        } else {
            renderDefaultType(type)
        }
    }
@@ -204,33 +192,49 @@ internal class DescriptorRendererImpl(
                // the case of complex type, e.g. (() -> Unit)?
                return "($lowerRendered)!"
            }
-            return lowerRendered + "!"
+            return "$lowerRendered!"
        }

        val kotlinCollectionsPrefix = classifierNamePolicy.renderClassifier(builtIns.collection, this).substringBefore("Collection")
        val mutablePrefix = "Mutable"
        // java.util.List<Foo> -> (Mutable)List<Foo!>!
-        val simpleCollection = replacePrefixes(lowerRendered, kotlinCollectionsPrefix + mutablePrefix, upperRendered, kotlinCollectionsPrefix, "$kotlinCollectionsPrefix($mutablePrefix)")
+        val simpleCollection = replacePrefixes(
+            lowerRendered,
+            kotlinCollectionsPrefix + mutablePrefix,
+            upperRendered,
+            kotlinCollectionsPrefix,
+            "$kotlinCollectionsPrefix($mutablePrefix)"
+        )
        if (simpleCollection != null) return simpleCollection
        // java.util.Map.Entry<Foo, Bar> -> (Mutable)Map.(Mutable)Entry<Foo!, Bar!>!
-        val mutableEntry = replacePrefixes(lowerRendered, kotlinCollectionsPrefix + "MutableMap.MutableEntry", upperRendered, kotlinCollectionsPrefix + "Map.Entry", kotlinCollectionsPrefix + "(Mutable)Map.(Mutable)Entry")
+        val mutableEntry = replacePrefixes(
+            lowerRendered,
+            kotlinCollectionsPrefix + "MutableMap.MutableEntry",
+            upperRendered,
+            kotlinCollectionsPrefix + "Map.Entry",
+            "$kotlinCollectionsPrefix(Mutable)Map.(Mutable)Entry"
+        )
        if (mutableEntry != null) return mutableEntry

        val kotlinPrefix = classifierNamePolicy.renderClassifier(builtIns.array, this).substringBefore("Array")
        // Foo[] -> Array<(out) Foo!>!
-        val array = replacePrefixes(lowerRendered, kotlinPrefix + escape("Array<"), upperRendered, kotlinPrefix + escape("Array<out "), kotlinPrefix + escape("Array<(out) "))
+        val array = replacePrefixes(
+            lowerRendered,
+            kotlinPrefix + escape("Array<"),
+            upperRendered,
+            kotlinPrefix + escape("Array<out "),
+            kotlinPrefix + escape("Array<(out) ")
+        )
        if (array != null) return array

        return "($lowerRendered..$upperRendered)"
    }

-    override fun renderTypeArguments(typeArguments: List<TypeProjection>): String {
-        if (typeArguments.isEmpty()) return ""
-        return buildString {
-            append(lt())
-            this.appendTypeProjections(typeArguments)
-            append(gt())
-        }
+    override fun renderTypeArguments(typeArguments: List<TypeProjection>): String = if (typeArguments.isEmpty()) ""
+    else buildString {
+        append(lt())
+        this.appendTypeProjections(typeArguments)
+        append(gt())
    }

    private fun StringBuilder.renderDefaultType(type: KotlinType) {
@@ -243,8 +247,7 @@ internal class DescriptorRendererImpl(
                append(type.constructor.toString()) // Debug name of an error type is more informative
            }
            append(renderTypeArguments(type.arguments))
-        }
-        else {
+        } else {
            renderTypeConstructorAndArguments(type)
        }

@@ -258,8 +261,8 @@ internal class DescriptorRendererImpl(
    }

    private fun StringBuilder.renderTypeConstructorAndArguments(
-            type: KotlinType,
-            typeConstructor: TypeConstructor = type.constructor
+        type: KotlinType,
+        typeConstructor: TypeConstructor = type.constructor
    ) {
        val possiblyInnerType = type.buildPossiblyInnerType()
        if (possiblyInnerType == null) {
@@ -281,13 +284,10 @@ internal class DescriptorRendererImpl(
        append(renderTypeArguments(possiblyInnerType.arguments))
    }

-    override fun renderTypeConstructor(typeConstructor: TypeConstructor): String {
-        val cd = typeConstructor.declarationDescriptor
-        return when (cd) {
-            is TypeParameterDescriptor, is ClassDescriptor, is TypeAliasDescriptor -> renderClassifierName(cd)
-            null -> typeConstructor.toString()
-            else -> error("Unexpected classifier: " + cd::class.java)
-        }
+    override fun renderTypeConstructor(typeConstructor: TypeConstructor): String = when (val cd = typeConstructor.declarationDescriptor) {
+        is TypeParameterDescriptor, is ClassDescriptor, is TypeAliasDescriptor -> renderClassifierName(cd)
+        null -> typeConstructor.toString()
+        else -> error("Unexpected classifier: " + cd::class.java)
    }

    override fun renderTypeProjection(typeProjection: TypeProjection) = buildString {
@@ -298,8 +298,7 @@ internal class DescriptorRendererImpl(
        typeProjections.joinTo(this, ", ") {
            if (it.isStarProjection) {
                "*"
-            }
-            else {
+            } else {
                val type = renderType(it.type)
                if (it.projectionKind == Variance.INVARIANT) type else "${it.projectionKind} $type"
            }
@@ -322,8 +321,7 @@ internal class DescriptorRendererImpl(
        if (needParenthesis) {
            if (isSuspend) {
                insert(lengthBefore, '(')
-            }
-            else {
+            } else {
                if (hasAnnotations) {
                    assert(last() == ' ')
                    if (get(lastIndex - 1) != ')') {
@@ -340,7 +338,7 @@ internal class DescriptorRendererImpl(

        if (receiverType != null) {
            val surroundReceiver = shouldRenderAsPrettyFunctionType(receiverType) && !receiverType.isMarkedNullable ||
-                                   receiverType.hasModifiersOrAnnotations()
+                    receiverType.hasModifiersOrAnnotations()
            if (surroundReceiver) {
                append("(")
            }
@@ -375,7 +373,7 @@ internal class DescriptorRendererImpl(
    }

    private fun KotlinType.hasModifiersOrAnnotations() =
-            isSuspendFunctionType || !annotations.isEmpty()
+        isSuspendFunctionType || !annotations.isEmpty()

    /* METHODS FOR ALL KINDS OF DESCRIPTORS */
    private fun StringBuilder.appendDefinedIn(descriptor: DeclarationDescriptor) {
@@ -395,7 +393,8 @@ internal class DescriptorRendererImpl(

            if (withSourceFileForTopLevel &&
                containingDeclaration is PackageFragmentDescriptor &&
-                descriptor is DeclarationDescriptorWithSource) {
+                descriptor is DeclarationDescriptorWithSource
+            ) {
                descriptor.source.containingFile.name?.let { sourceFileName ->
                    append(" ").append(renderMessage("in file")).append(" ").append(sourceFileName)
                }
@@ -447,14 +446,14 @@ internal class DescriptorRendererImpl(
        val allValueArguments = descriptor.allValueArguments
        val classDescriptor = if (renderDefaultAnnotationArguments) descriptor.annotationClass else null
        val parameterDescriptorsWithDefaultValue = classDescriptor?.unsubstitutedPrimaryConstructor?.valueParameters
-                ?.filter { it.declaresDefaultValue() }
-                ?.map { it.name }
-                .orEmpty()
+            ?.filter { it.declaresDefaultValue() }
+            ?.map { it.name }
+            .orEmpty()
        val defaultList = parameterDescriptorsWithDefaultValue.filter { it !in allValueArguments }.map { "${it.asString()} = ..." }
        val argumentList = allValueArguments.entries
-                .map { (name, value) ->
-                    "${name.asString()} = ${if (name !in parameterDescriptorsWithDefaultValue) renderConstant(value) else "..."}"
-                }
+            .map { (name, value) ->
+                "${name.asString()} = ${if (name !in parameterDescriptorsWithDefaultValue) renderConstant(value) else "..."}"
+            }
        return (defaultList + argumentList).sorted()
    }

@@ -500,16 +499,17 @@ internal class DescriptorRendererImpl(
        if (this.overriddenDescriptors.isNotEmpty()) {
            if (containingClassDescriptor.modality != Modality.FINAL) return Modality.OPEN
        }
-        if (containingClassDescriptor.kind == ClassKind.INTERFACE && this.visibility != Visibilities.PRIVATE) {
-            return if (this.modality == Modality.ABSTRACT) Modality.ABSTRACT else Modality.OPEN
-        }
-        return Modality.FINAL
+        return if (containingClassDescriptor.kind == ClassKind.INTERFACE && this.visibility != Visibilities.PRIVATE) {
+            if (this.modality == Modality.ABSTRACT) Modality.ABSTRACT else Modality.OPEN
+        } else
+            Modality.FINAL
    }

    private fun renderModalityForCallable(callable: CallableMemberDescriptor, builder: StringBuilder) {
        if (!DescriptorUtils.isTopLevelDeclaration(callable) || callable.modality != Modality.FINAL) {
            if (overrideRenderingPolicy == OverrideRenderingPolicy.RENDER_OVERRIDE && callable.modality == Modality.OPEN &&
-                overridesSomething(callable)) {
+                overridesSomething(callable)
+            ) {
                return
            }
            renderModality(callable.modality, builder, callable.implicitModalityWithoutExtensions())
@@ -550,9 +550,9 @@ internal class DescriptorRendererImpl(

    private fun renderAdditionalModifiers(functionDescriptor: FunctionDescriptor, builder: StringBuilder) {
        val isOperator =
-                functionDescriptor.isOperator && (functionDescriptor.overriddenDescriptors.none { it.isOperator } || alwaysRenderModifiers)
+            functionDescriptor.isOperator && (functionDescriptor.overriddenDescriptors.none { it.isOperator } || alwaysRenderModifiers)
        val isInfix =
-                functionDescriptor.isInfix && (functionDescriptor.overriddenDescriptors.none { it.isInfix } || alwaysRenderModifiers)
+            functionDescriptor.isInfix && (functionDescriptor.overriddenDescriptors.none { it.isInfix } || alwaysRenderModifiers)

        renderModifier(builder, functionDescriptor.isTailrec, "tailrec")
        renderSuspendModifier(functionDescriptor, builder)
@@ -599,8 +599,7 @@ internal class DescriptorRendererImpl(
            if (!KotlinBuiltIns.isDefaultBound(upperBound)) {
                builder.append(" : ").append(renderType(upperBound))
            }
-        }
-        else if (topLevel) {
+        } else if (topLevel) {
            var first = true
            for (upperBound in typeParameter.upperBounds) {
                if (KotlinBuiltIns.isDefaultBound(upperBound)) {
@@ -608,15 +607,13 @@ internal class DescriptorRendererImpl(
                }
                if (first) {
                    builder.append(" : ")
-                }
-                else {
+                } else {
                    builder.append(" & ")
                }
                builder.append(renderType(upperBound))
                first = false
            }
-        }
-        else {
+        } else {
            // rendered with "where"
        }

@@ -628,7 +625,7 @@ internal class DescriptorRendererImpl(
    private fun renderTypeParameters(typeParameters: List<TypeParameterDescriptor>, builder: StringBuilder, withSpace: Boolean) {
        if (withoutTypeParameters) return

-        if (!typeParameters.isEmpty()) {
+        if (typeParameters.isNotEmpty()) {
            builder.append(lt())
            renderTypeParameterList(builder, typeParameters)
            builder.append(gt())
@@ -769,21 +766,25 @@ internal class DescriptorRendererImpl(

        for (typeParameter in typeParameters) {
            typeParameter.upperBounds
-                    .drop(1) // first parameter is rendered by renderTypeParameter
-                    .mapTo(upperBoundStrings) { renderName(typeParameter.name, false) + " : " + renderType(it) }
+                .drop(1) // first parameter is rendered by renderTypeParameter
+                .mapTo(upperBoundStrings) { renderName(typeParameter.name, false) + " : " + renderType(it) }
        }

-        if (!upperBoundStrings.isEmpty()) {
+        if (upperBoundStrings.isNotEmpty()) {
            builder.append(" ").append(renderKeyword("where")).append(" ")
            upperBoundStrings.joinTo(builder, ", ")
        }
    }

-    override fun renderValueParameters(parameters: Collection<ValueParameterDescriptor>, synthesizedParameterNames: Boolean): String {
-        return buildString { renderValueParameters(parameters, synthesizedParameterNames, this) }
+    override fun renderValueParameters(parameters: Collection<ValueParameterDescriptor>, synthesizedParameterNames: Boolean) = buildString {
+        renderValueParameters(parameters, synthesizedParameterNames, this)
    }

-    private fun renderValueParameters(parameters: Collection<ValueParameterDescriptor>, synthesizedParameterNames: Boolean, builder: StringBuilder) {
+    private fun renderValueParameters(
+        parameters: Collection<ValueParameterDescriptor>,
+        synthesizedParameterNames: Boolean,
+        builder: StringBuilder
+    ) {
        val includeNames = shouldRenderParameterNames(synthesizedParameterNames)
        val parameterCount = parameters.size
        valueParametersHandler.appendBeforeValueParameters(parameterCount, builder)
@@ -795,16 +796,19 @@ internal class DescriptorRendererImpl(
        valueParametersHandler.appendAfterValueParameters(parameterCount, builder)
    }

-    private fun shouldRenderParameterNames(synthesizedParameterNames: Boolean): Boolean {
-        when (parameterNameRenderingPolicy) {
-            ParameterNameRenderingPolicy.ALL -> return true
-            ParameterNameRenderingPolicy.ONLY_NON_SYNTHESIZED -> return !synthesizedParameterNames
-            ParameterNameRenderingPolicy.NONE -> return false
-        }
+    private fun shouldRenderParameterNames(synthesizedParameterNames: Boolean): Boolean = when (parameterNameRenderingPolicy) {
+        ParameterNameRenderingPolicy.ALL -> true
+        ParameterNameRenderingPolicy.ONLY_NON_SYNTHESIZED -> !synthesizedParameterNames
+        ParameterNameRenderingPolicy.NONE -> false
    }

    /* VARIABLES */
-    private fun renderValueParameter(valueParameter: ValueParameterDescriptor, includeName: Boolean, builder: StringBuilder, topLevel: Boolean) {
+    private fun renderValueParameter(
+        valueParameter: ValueParameterDescriptor,
+        includeName: Boolean,
+        builder: StringBuilder,
+        topLevel: Boolean
+    ) {
        if (topLevel) {
            builder.append(renderKeyword("value-parameter")).append(" ")
        }
@@ -828,7 +832,7 @@ internal class DescriptorRendererImpl(

        val withDefaultValue =
            defaultParameterValueRenderer != null &&
-            (if (debugMode) valueParameter.declaresDefaultValue() else valueParameter.declaresOrInheritsDefaultValue())
+                    (if (debugMode) valueParameter.declaresDefaultValue() else valueParameter.declaresOrInheritsDefaultValue())
        if (withDefaultValue) {
            builder.append(" = ${defaultParameterValueRenderer!!(valueParameter)}")
        }
@@ -957,7 +961,8 @@ internal class DescriptorRendererImpl(
                renderVisibility(klass.visibility, builder)
            }
            if (!(klass.kind == ClassKind.INTERFACE && klass.modality == Modality.ABSTRACT ||
-                  klass.kind.isSingleton && klass.modality == Modality.FINAL)) {
+                        klass.kind.isSingleton && klass.modality == Modality.FINAL)
+            ) {
                renderModality(klass.modality, builder, klass.implicitModalityWithoutExtensions())
            }
            renderMemberModifiers(klass, builder)
@@ -970,8 +975,7 @@ internal class DescriptorRendererImpl(
        if (!isCompanionObject(klass)) {
            if (!startFromName) renderSpaceIfNeeded(builder)
            renderName(klass, builder, true)
-        }
-        else {
+        } else {
            renderCompanionObjectName(klass, builder)
        }

@@ -1010,7 +1014,7 @@ internal class DescriptorRendererImpl(
    }

    private fun renderClassKindPrefix(klass: ClassDescriptor, builder: StringBuilder) {
-        builder.append(renderKeyword(DescriptorRenderer.getClassifierKindPrefix(klass)))
+        builder.append(renderKeyword(getClassifierKindPrefix(klass)))
    }


@@ -1129,7 +1133,13 @@ internal class DescriptorRendererImpl(
        }
    }

-    private fun replacePrefixes(lowerRendered: String, lowerPrefix: String, upperRendered: String, upperPrefix: String, foldedPrefix: String): String? {
+    private fun replacePrefixes(
+        lowerRendered: String,
+        lowerPrefix: String,
+        upperRendered: String,
+        upperPrefix: String,
+        foldedPrefix: String
+    ): String? {
        if (lowerRendered.startsWith(lowerPrefix) && upperRendered.startsWith(upperPrefix)) {
            val lowerWithoutPrefix = lowerRendered.substring(lowerPrefix.length)
            val upperWithoutPrefix = upperRendered.substring(upperPrefix.length)
@@ -1138,14 +1148,14 @@ internal class DescriptorRendererImpl(
            if (lowerWithoutPrefix == upperWithoutPrefix) return flexibleCollectionName

            if (differsOnlyInNullability(lowerWithoutPrefix, upperWithoutPrefix)) {
-                return flexibleCollectionName + "!"
+                return "$flexibleCollectionName!"
            }
        }
        return null
    }

-    private fun differsOnlyInNullability(lower: String, upper: String)
-            = lower == upper.replace("?", "") || upper.endsWith("?") && ("$lower?") == upper || "($lower)?" == upper
+    private fun differsOnlyInNullability(lower: String, upper: String) =
+        lower == upper.replace("?", "") || upper.endsWith("?") && ("$lower?") == upper || "($lower)?" == upper

    private fun overridesSomething(callable: CallableMemberDescriptor) = !callable.overriddenDescriptors.isEmpty()
 }
@@ -23,9 +23,11 @@ import org.jetbrains.kotlin.types.isDynamic
 import org.jetbrains.kotlin.types.typeUtil.builtIns

 object IdeDescriptorRenderers {
-    @JvmField val APPROXIMATE_FLEXIBLE_TYPES: (KotlinType) -> KotlinType = { it.approximateFlexibleTypes(preferNotNull = false) }
+    @JvmField
+    val APPROXIMATE_FLEXIBLE_TYPES: (KotlinType) -> KotlinType = { it.approximateFlexibleTypes(preferNotNull = false) }

-    @JvmField val APPROXIMATE_FLEXIBLE_TYPES_NOT_NULL: (KotlinType) -> KotlinType = { it.approximateFlexibleTypes(preferNotNull = true) }
+    @JvmField
+    val APPROXIMATE_FLEXIBLE_TYPES_NOT_NULL: (KotlinType) -> KotlinType = { it.approximateFlexibleTypes(preferNotNull = true) }

    private fun unwrapAnonymousType(type: KotlinType): KotlinType {
        if (type.isDynamic()) return type
@@ -54,31 +56,36 @@ object IdeDescriptorRenderers {
        annotationArgumentsRenderingPolicy = AnnotationArgumentsRenderingPolicy.UNLESS_EMPTY
    }

-    @JvmField val SOURCE_CODE: DescriptorRenderer = BASE.withOptions {
+    @JvmField
+    val SOURCE_CODE: DescriptorRenderer = BASE.withOptions {
        classifierNamePolicy = ClassifierNamePolicy.SOURCE_CODE_QUALIFIED
        typeNormalizer = { APPROXIMATE_FLEXIBLE_TYPES(unwrapAnonymousType(it)) }
    }

-    @JvmField val SOURCE_CODE_TYPES: DescriptorRenderer = BASE.withOptions {
+    @JvmField
+    val SOURCE_CODE_TYPES: DescriptorRenderer = BASE.withOptions {
        classifierNamePolicy = ClassifierNamePolicy.SOURCE_CODE_QUALIFIED
        typeNormalizer = { APPROXIMATE_FLEXIBLE_TYPES(unwrapAnonymousType(it)) }
        annotationFilter = { it !is BuiltInAnnotationDescriptor }
        parameterNamesInFunctionalTypes = false
    }

-    @JvmField val SOURCE_CODE_TYPES_WITH_SHORT_NAMES: DescriptorRenderer = BASE.withOptions {
+    @JvmField
+    val SOURCE_CODE_TYPES_WITH_SHORT_NAMES: DescriptorRenderer = BASE.withOptions {
        classifierNamePolicy = ClassifierNamePolicy.SHORT
        typeNormalizer = { APPROXIMATE_FLEXIBLE_TYPES(unwrapAnonymousType(it)) }
        modifiers -= DescriptorRendererModifier.ANNOTATIONS
        parameterNamesInFunctionalTypes = false
    }

-    @JvmField val SOURCE_CODE_NOT_NULL_TYPE_APPROXIMATION: DescriptorRenderer = BASE.withOptions {
+    @JvmField
+    val SOURCE_CODE_NOT_NULL_TYPE_APPROXIMATION: DescriptorRenderer = BASE.withOptions {
        classifierNamePolicy = ClassifierNamePolicy.SOURCE_CODE_QUALIFIED
        typeNormalizer = { APPROXIMATE_FLEXIBLE_TYPES_NOT_NULL(unwrapAnonymousType(it)) }
    }

-    @JvmField val SOURCE_CODE_SHORT_NAMES_NO_ANNOTATIONS: DescriptorRenderer = BASE.withOptions {
+    @JvmField
+    val SOURCE_CODE_SHORT_NAMES_NO_ANNOTATIONS: DescriptorRenderer = BASE.withOptions {
        classifierNamePolicy = ClassifierNamePolicy.SHORT
        typeNormalizer = { APPROXIMATE_FLEXIBLE_TYPES(unwrapAnonymousType(it)) }
        modifiers -= DescriptorRendererModifier.ANNOTATIONS