From a2f937e282b736aaab345a8d51aaf049090cd59c Mon Sep 17 00:00:00 2001 From: Dmitry Gridin Date: Fri, 26 Jul 2019 15:16:30 +0300 Subject: [PATCH] DescriptorRender: cleanup code --- .../kotlin/renderer/DescriptorRenderer.kt | 103 +++++--- .../kotlin/renderer/DescriptorRendererImpl.kt | 230 +++++++++--------- .../idea/util/IdeDescriptorRenderers.kt | 21 +- 3 files changed, 197 insertions(+), 157 deletions(-) diff --git a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt index 87036b89723..ee78e44e10f 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt @@ -44,8 +44,8 @@ abstract class DescriptorRenderer { abstract fun renderValueParameters(parameters: Collection, 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() } } diff --git a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt index 48af47bc6b5..22832306721 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt @@ -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 "$keyword" - } + private fun renderKeyword(keyword: String): String = when (textFormat) { + RenderingFormat.PLAIN -> keyword + RenderingFormat.HTML -> if (boldOnlyForNamesInHtml) keyword else "$keyword" } - private fun renderError(keyword: String): String { - when (textFormat) { - RenderingFormat.PLAIN -> return keyword - RenderingFormat.HTML -> return "$keyword" - } + private fun renderError(keyword: String): String = when (textFormat) { + RenderingFormat.PLAIN -> keyword + RenderingFormat.HTML -> "$keyword" } 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 -> "→" - } + private fun arrow(): String = when (textFormat) { + RenderingFormat.PLAIN -> escape("->") + RenderingFormat.HTML -> "→" } - override fun renderMessage(message: String): String { - return when (textFormat) { - RenderingFormat.PLAIN -> message - RenderingFormat.HTML -> "$message" - } + override fun renderMessage(message: String): String = when (textFormat) { + RenderingFormat.PLAIN -> message + RenderingFormat.HTML -> "$message" } /* NAMES RENDERING */ override fun renderName(name: Name, rootRenderedElement: Boolean): String { val escaped = escape(name.render()) - if (boldOnlyForNamesInHtml && textFormat == RenderingFormat.HTML && rootRenderedElement) { - return "$escaped" - } - return escaped + return if (boldOnlyForNamesInHtml && textFormat == RenderingFormat.HTML && rootRenderedElement) { + "$escaped" + } else + escaped } private fun renderName(descriptor: DeclarationDescriptor, builder: StringBuilder, rootRenderedElement: Boolean) { @@ -113,12 +106,10 @@ internal class DescriptorRendererImpl( private fun renderFqName(pathSegments: List) = 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("") 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 -> (Mutable)List! - 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 -> (Mutable)Map.(Mutable)Entry! - 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): String { - if (typeArguments.isEmpty()) return "" - return buildString { - append(lt()) - this.appendTypeProjections(typeArguments) - append(gt()) - } + override fun renderTypeArguments(typeArguments: List): 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, 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, synthesizedParameterNames: Boolean): String { - return buildString { renderValueParameters(parameters, synthesizedParameterNames, this) } + override fun renderValueParameters(parameters: Collection, synthesizedParameterNames: Boolean) = buildString { + renderValueParameters(parameters, synthesizedParameterNames, this) } - private fun renderValueParameters(parameters: Collection, synthesizedParameterNames: Boolean, builder: StringBuilder) { + private fun renderValueParameters( + parameters: Collection, + 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() } diff --git a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/IdeDescriptorRenderers.kt b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/IdeDescriptorRenderers.kt index 59b65262a4d..5b7b524608b 100644 --- a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/IdeDescriptorRenderers.kt +++ b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/IdeDescriptorRenderers.kt @@ -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