azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Analysis API: rework declaration renderer

Browse Source 
- refactor code to use PrettyPrinter instead of ad-hoc one
- do not print nested local declarations as this does not seem to have use-cases
This commit is contained in:
Ilya Kirillov
2021-11-29 15:10:40 +01:00
parent 908a47810b
commit 19dec92247
18 changed files with 533 additions and 815 deletions
Download Patch File Download Diff File Expand all files Collapse all files
analysis/analysis-api-fe10/build.gradle.kts
+1
View File
@@ -8,6 +8,7 @@ dependencies {
implementation(project(":compiler:frontend"))
implementation(project(":compiler:frontend.java"))
implementation(project(":analysis:analysis-api-impl-base"))
implementation(project(":analysis:analysis-internal-utils"))
implementation(project(":compiler:backend"))
implementation(project(":compiler:backend.jvm"))
analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolDeclarationRendererProvider.kt
+4 -4
View File
@@ -15,8 +15,10 @@ import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.bas
import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10Type
import org.jetbrains.kotlin.analysis.api.descriptors.utils.KtFe10TypeRenderer
import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
import org.jetbrains.kotlin.analysis.api.symbols.markers.KtPossibleMemberSymbol
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.api.types.KtType
import org.jetbrains.kotlin.analysis.utils.printer.prettyPrint
internal class KtFe10SymbolDeclarationRendererProvider(
override val analysisSession: KtFe10AnalysisSession
@@ -24,7 +26,7 @@ internal class KtFe10SymbolDeclarationRendererProvider(
override val token: ValidityToken
get() = analysisSession.token
override fun render(symbol: KtSymbol, options: KtDeclarationRendererOptions): String {
override fun renderMember(symbol: KtPossibleMemberSymbol, options: KtDeclarationRendererOptions): String {
val descriptor = getSymbolDescriptor(symbol)
if (descriptor != null) {
return descriptor.render(analysisContext, options)
@@ -36,8 +38,6 @@ internal class KtFe10SymbolDeclarationRendererProvider(
override fun render(type: KtType, options: KtTypeRendererOptions): String {
require(type is KtFe10Type)
val consumer = StringBuilder()
KtFe10TypeRenderer(options).render(type.type, consumer)
return consumer.toString()
return prettyPrint { KtFe10TypeRenderer(options).render(type.type, this) }
}
}
analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/base/Kt1DescUtils.kt
+4 -4
View File
@@ -15,10 +15,12 @@ import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.*
import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
import org.jetbrains.kotlin.analysis.api.descriptors.types.*
import org.jetbrains.kotlin.analysis.api.descriptors.utils.KtFe10Renderer
import org.jetbrains.kotlin.analysis.api.descriptors.utils.KtFe10TypeRenderer
import org.jetbrains.kotlin.analysis.api.symbols.*
import org.jetbrains.kotlin.analysis.api.symbols.markers.*
import org.jetbrains.kotlin.analysis.api.types.KtType
import org.jetbrains.kotlin.analysis.api.types.KtTypeNullability
import org.jetbrains.kotlin.analysis.utils.printer.prettyPrint
import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor
import org.jetbrains.kotlin.descriptors.*
import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
@@ -308,7 +310,7 @@ internal fun ConstantValue<*>.toKtAnnotationValue(): KtAnnotationValue {
value.annotationClass?.classId,
psi = null,
useSiteTarget = null,
arguments = arguments,
arguments = value.getKtNamedAnnotationArguments(),
)
)
}
@@ -413,9 +415,7 @@ internal fun ClassDescriptor.getSupertypesWithAny(): Collection<KotlinType> {
internal fun DeclarationDescriptor.render(analysisContext: Fe10AnalysisContext, options: KtDeclarationRendererOptions): String {
val renderer = KtFe10Renderer(analysisContext, options)
val consumer = StringBuilder()
renderer.render(this, consumer)
return consumer.toString().trim()
return prettyPrint { renderer.render(this@render, this) }.trim()
}
internal fun CallableMemberDescriptor.getSymbolPointerSignature(analysisContext: Fe10AnalysisContext): String {
analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/base/KtFe10Type.kt
+3 -3
View File
@@ -11,9 +11,11 @@ import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationsList
import org.jetbrains.kotlin.analysis.api.components.KtTypeRendererOptions
import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
import org.jetbrains.kotlin.analysis.api.descriptors.annotations.KtFe10AnnotationsList
import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.render
import org.jetbrains.kotlin.analysis.api.descriptors.utils.KtFe10TypeRenderer
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.api.withValidityAssertion
import org.jetbrains.kotlin.analysis.utils.printer.prettyPrint
import org.jetbrains.kotlin.types.KotlinType
import org.jetbrains.kotlin.types.UnwrappedType
@@ -32,8 +34,6 @@ interface KtFe10Type : ValidityTokenOwner, KtAnnotated {
}
internal fun KotlinType.asStringForDebugging(): String {
val builder = StringBuilder()
val renderer = KtFe10TypeRenderer(KtTypeRendererOptions.DEFAULT, isDebugText = true)
renderer.render(this, builder)
return builder.toString()
return prettyPrint { renderer.render(this@asStringForDebugging, this) }
}
analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10Renderer.kt
+63 -156
View File
@@ -12,32 +12,31 @@ import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.bas
import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.isExplicitOverride
import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktModality
import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktVisibility
import org.jetbrains.kotlin.analysis.utils.printer.PrettyPrinter
import org.jetbrains.kotlin.analysis.utils.printer.prettyPrint
import org.jetbrains.kotlin.builtins.KotlinBuiltIns
import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor
import org.jetbrains.kotlin.builtins.isFunctionType
import org.jetbrains.kotlin.descriptors.*
import org.jetbrains.kotlin.descriptors.annotations.Annotations
import org.jetbrains.kotlin.descriptors.annotations.Annotated
import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.name.SpecialNames
import org.jetbrains.kotlin.name.StandardClassIds
import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.renderer.render
import org.jetbrains.kotlin.resolve.BindingContext
import org.jetbrains.kotlin.resolve.DescriptorUtils
import org.jetbrains.kotlin.resolve.calls.components.hasDefaultValue
import org.jetbrains.kotlin.resolve.calls.components.isVararg
import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperClassNotAny
import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperInterfaces
import org.jetbrains.kotlin.resolve.source.getPsi
import org.jetbrains.kotlin.types.KotlinType
import org.jetbrains.kotlin.types.TypeApproximator
import org.jetbrains.kotlin.types.typeUtil.isNullableAny
import org.jetbrains.kotlin.types.typeUtil.isUnit
import org.jetbrains.kotlin.util.capitalizeDecapitalize.toLowerCaseAsciiOnly
internal typealias KtFe10RendererConsumer = StringBuilder
internal typealias KtFe10RendererConsumer = PrettyPrinter
internal class KtFe10Renderer(
private val analysisContext: Fe10AnalysisContext,
@@ -45,8 +44,6 @@ internal class KtFe10Renderer(
isDebugText: Boolean = false
) {
private companion object {
private val INDENTATION = " ".repeat(4)
val IGNORED_VISIBILITIES: Set<Visibility> = setOf(
Visibilities.Local,
Visibilities.PrivateToThis,
@@ -69,22 +66,6 @@ internal class KtFe10Renderer(
analysisContext.resolveSession.languageVersionSettings
)
private var indentation = 0
private fun KtFe10RendererConsumer.curlyBlock(body: KtFe10RendererConsumer.() -> Unit) {
append(" {")
indentedBlock(body)
appendLine()
renderIndentation()
append('}')
}
private fun KtFe10RendererConsumer.indentedBlock(body: KtFe10RendererConsumer.() -> Unit) {
indentation += 1
body()
indentation -= 1
}
fun render(descriptor: DeclarationDescriptor, consumer: KtFe10RendererConsumer) {
consumer.renderDeclaration(descriptor)
}
@@ -138,7 +119,7 @@ internal class KtFe10Renderer(
private fun KtFe10RendererConsumer.renderTypeAlias(descriptor: TypeAliasDescriptor) {
if (options.renderDeclarationHeader) {
renderAnnotations(descriptor.annotations)
renderAnnotations(descriptor)
renderModifiers(descriptor)
append("typealias ")
}
@@ -149,7 +130,9 @@ internal class KtFe10Renderer(
}
private fun KtFe10RendererConsumer.renderTypeParameters(typeParameters: List<TypeParameterDescriptor>) {
renderList(typeParameters, separator = ", ", prefix = "<", postfix = ">", renderWhenEmpty = false) { renderTypeParameter(it) }
if (typeParameters.isNotEmpty()) append('<')
printCollection(typeParameters, separator = ", ") { renderTypeParameter(it) }
if (typeParameters.isNotEmpty()) append('>')
}
private fun KtFe10RendererConsumer.renderTypeParameter(descriptor: TypeParameterDescriptor) {
@@ -158,19 +141,16 @@ internal class KtFe10Renderer(
val variance = descriptor.variance.label
renderModifier(variance, variance.isNotEmpty())
renderAnnotations(descriptor.annotations)
renderAnnotations(descriptor)
renderName(descriptor)
val upperBounds = descriptor.upperBounds.filterNot { it.isNullableAny() }
renderList(upperBounds, separator = " & ", prefix = " : ", postfix = "", renderWhenEmpty = false) { renderType(it) }
printCollectionIfNotEmpty(upperBounds, separator = " & ", prefix = " : ") { renderType(it) }
}
private fun KtFe10RendererConsumer.renderClass(descriptor: ClassDescriptor) {
appendLine()
renderIndentation()
if (options.renderDeclarationHeader) {
renderAnnotations(descriptor.annotations)
renderAnnotations(descriptor)
renderModifiers(descriptor)
@@ -200,7 +180,7 @@ internal class KtFe10Renderer(
renderTypeParameters(descriptor.declaredTypeParameters)
renderSupertypes(descriptor)
if (options.renderContainingDeclarations) {
if (options.renderClassMembers) {
val (enumEntries, otherDeclarations) = descriptor.unsubstitutedMemberScope.getContributedDescriptors()
.filter { shouldRenderNestedDeclaration(descriptor, it) }
.partition { it is ClassDescriptor && it.kind == ClassKind.ENUM_ENTRY }
@@ -209,10 +189,19 @@ internal class KtFe10Renderer(
.filter { shouldRenderNestedDeclaration(descriptor, it) }
if (enumEntries.isNotEmpty() || otherDeclarations.isNotEmpty() || constructors.isNotEmpty()) {
curlyBlock {
enumEntries.forEach { renderEnumEntry(it as ClassDescriptor) }
sortDeclarations(constructors).forEach { renderConstructor(it) }
sortDeclarations(otherDeclarations).forEach { renderDeclaration(it) }
append(' ')
withIndentInBraces {
printCollection(sortDeclarations(enumEntries), separator = ",\n") {
renderEnumEntry(it as ClassDescriptor)
}
if (enumEntries.isNotEmpty() && (constructors.isNotEmpty() || otherDeclarations.isNotEmpty())) {
appendLine(";\n")
}
printCollection(sortDeclarations(constructors + otherDeclarations), separator = "\n\n") {
renderDeclaration(it)
}
}
}
}
@@ -268,8 +257,8 @@ internal class KtFe10Renderer(
return@Comparator nameResult
}
val leftString = buildString { renderDeclaration(left) }
val rightString = buildString { renderDeclaration(right) }
val leftString = prettyPrint { renderDeclaration(left) }
val rightString = prettyPrint { renderDeclaration(right) }
return@Comparator leftString.compareTo(rightString)
})
}
@@ -279,7 +268,7 @@ internal class KtFe10Renderer(
.filterTo(HashSet()) { it.classId !in IGNORED_SUPERTYPES }
val supertypes = descriptor.typeConstructor.supertypes.filter { it.constructor.declarationDescriptor in allowedSuperClasses }
renderList(supertypes, separator = ", ", prefix = " : ", postfix = "", renderWhenEmpty = false) { renderType(it) }
printCollectionIfNotEmpty(supertypes, separator = ", ", prefix = " : ") { renderType(it) }
}
private fun KtFe10RendererConsumer.renderCallable(descriptor: CallableDescriptor) {
@@ -296,47 +285,35 @@ internal class KtFe10Renderer(
}
private fun KtFe10RendererConsumer.renderPropertyAccessor(descriptor: PropertyAccessorDescriptor) {
appendLine()
indentedBlock {
renderIndentation()
if (options.renderDeclarationHeader) {
renderAnnotations(descriptor.annotations)
renderModifiers(descriptor)
}
if (options.renderDeclarationHeader) {
renderAnnotations(descriptor)
renderModifiers(descriptor)
}
when (descriptor) {
is PropertyGetterDescriptor -> {
append("get()")
}
is PropertySetterDescriptor -> {
append("set(")
val valueParameter = descriptor.valueParameters.singleOrNull()
if (valueParameter != null) {
val name = valueParameter.name.takeIf { !it.isSpecial } ?: Name.identifier("value")
renderValueParameter(valueParameter, name)
}
append(")")
when (descriptor) {
is PropertyGetterDescriptor -> {
append("get()")
}
is PropertySetterDescriptor -> {
append("set(")
val valueParameter = descriptor.valueParameters.singleOrNull()
if (valueParameter != null) {
val name = valueParameter.name.takeIf { !it.isSpecial } ?: Name.identifier("value")
renderValueParameter(valueParameter, name)
}
append(")")
}
}
}
private fun KtFe10RendererConsumer.renderEnumEntry(descriptor: ClassDescriptor) {
assert(descriptor.kind == ClassKind.ENUM_ENTRY)
appendLine()
renderIndentation()
renderName(descriptor)
append(',')
}
private fun KtFe10RendererConsumer.renderLocalVariable(descriptor: LocalVariableDescriptor) {
appendLine()
renderIndentation()
if (options.renderDeclarationHeader) {
renderAnnotations(descriptor.annotations)
renderAnnotations(descriptor)
append(if (descriptor.isVar) "var" else "val").append(' ')
}
@@ -346,11 +323,8 @@ internal class KtFe10Renderer(
}
private fun KtFe10RendererConsumer.renderProperty(descriptor: PropertyDescriptor) {
appendLine()
renderIndentation()
if (options.renderDeclarationHeader) {
renderAnnotations(descriptor.annotations)
renderAnnotations(descriptor)
renderModifiers(descriptor)
append(if (descriptor.isVar) "var" else "val").append(' ')
renderTypeParameters(descriptor.typeParameters)
@@ -364,11 +338,9 @@ internal class KtFe10Renderer(
append(": ")
renderType(descriptor.type, shouldApproximate = options.approximateTypes)
if (options.renderContainingDeclarations) {
if (options.renderClassMembers) {
fun shouldRenderAccessor(accessor: PropertyAccessorDescriptor): Boolean {
return descriptor.isDelegated
|| accessor.hasBody()
|| !accessor.annotations.isEmpty()
return !accessor.annotations.isEmpty()
|| accessor.visibility != descriptor.visibility
}
@@ -377,11 +349,15 @@ internal class KtFe10Renderer(
val shouldRenderAccessors = (getter != null && shouldRenderAccessor(getter)) || (setter != null && shouldRenderAccessor(setter))
if (shouldRenderAccessors) {
if (getter != null) {
renderPropertyAccessor(getter)
}
if (setter != null) {
renderPropertyAccessor(setter)
withIndent {
if (getter != null) {
appendLine()
renderPropertyAccessor(getter)
}
if (setter != null) {
appendLine()
renderPropertyAccessor(setter)
}
}
}
}
@@ -401,23 +377,16 @@ internal class KtFe10Renderer(
}
private fun KtFe10RendererConsumer.renderConstructor(descriptor: ConstructorDescriptor) {
appendLine()
renderIndentation()
if (options.renderDeclarationHeader) {
renderAnnotations(descriptor.annotations)
renderAnnotations(descriptor)
}
append("constructor")
renderValueParameters(descriptor.valueParameters)
renderLocalDeclarations(descriptor)
}
private fun KtFe10RendererConsumer.renderFunction(descriptor: FunctionDescriptor) {
appendLine()
renderIndentation()
if (options.renderDeclarationHeader) {
renderAnnotations(descriptor.annotations)
renderAnnotations(descriptor)
renderModifiers(descriptor)
append("fun ")
renderTypeParameters(descriptor.typeParameters)
@@ -435,17 +404,15 @@ internal class KtFe10Renderer(
append(": ")
renderType(returnType, shouldApproximate = options.approximateTypes)
}
renderLocalDeclarations(descriptor)
}
private fun KtFe10RendererConsumer.renderValueParameters(valueParameters: List<ValueParameterDescriptor>) {
renderList(valueParameters, separator = ", ", prefix = "(", postfix = ")", renderWhenEmpty = true) { renderValueParameter(it) }
printCollection(valueParameters, separator = ", ", prefix = "(", postfix = ")") { renderValueParameter(it) }
}
private fun KtFe10RendererConsumer.renderValueParameter(descriptor: ValueParameterDescriptor, name: Name = descriptor.name) {
if (options.renderDeclarationHeader) {
renderAnnotations(descriptor.annotations)
renderAnnotations(descriptor)
}
renderModifiers(descriptor)
@@ -458,50 +425,16 @@ internal class KtFe10Renderer(
}
}
private fun KtFe10RendererConsumer.renderLocalDeclarations(descriptor: CallableMemberDescriptor) {
if (!options.renderContainingDeclarations) {
return
}
val body = when (val declaration = descriptor.source.getPsi()) {
is KtFunction -> declaration.bodyExpression
is KtPropertyAccessor -> declaration.bodyExpression
else -> null
}
val collectedChildren = mutableListOf<DeclarationDescriptor>()
body?.accept(object : KtTreeVisitorVoid() {
override fun visitDeclaration(declaration: KtDeclaration) {
if (declaration is KtFunction || declaration is KtVariableDeclaration || declaration is KtClassOrObject) {
val bindingContext = analysisContext.analyze(declaration)
val childDescriptor = bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, declaration]
if (childDescriptor != null) {
collectedChildren += childDescriptor
}
} else {
super.visitDeclaration(declaration)
}
}
})
if (collectedChildren.isNotEmpty()) {
curlyBlock {
collectedChildren.forEach { renderDeclaration(it) }
}
}
}
private fun KtFe10RendererConsumer.renderName(descriptor: DeclarationDescriptor) {
append(descriptor.name.render())
}
private fun KtFe10RendererConsumer.renderAnnotations(annotations: Annotations, predicate: (ClassId) -> Boolean = { true }) {
private fun KtFe10RendererConsumer.renderAnnotations(declaration: Annotated, predicate: (ClassId) -> Boolean = { true }) {
if (RendererModifier.ANNOTATIONS !in options.modifiers) {
return
}
renderFe10Annotations(annotations, predicate)
val isSingleLineAnnotations = declaration is ValueParameterDescriptor || declaration is TypeParameterDescriptor
renderFe10Annotations(declaration.annotations, isSingleLineAnnotations, predicate)
}
private fun KtFe10RendererConsumer.renderModifiers(descriptor: DeclarationDescriptor) {
@@ -595,30 +528,4 @@ internal class KtFe10Renderer(
append(text).append(' ')
}
}
private fun KtFe10RendererConsumer.renderIndentation() {
append(INDENTATION.repeat(indentation))
}
}
internal fun <T> KtFe10RendererConsumer.renderList(
list: Collection<T>,
separator: String,
prefix: String = "",
postfix: String = "",
renderWhenEmpty: Boolean = true,
renderItem: KtFe10RendererConsumer.(T) -> Unit
) {
if (!renderWhenEmpty && list.isEmpty()) {
return
}
append(prefix)
list.forEachIndexed { index, item ->
if (index > 0) {
append(separator)
}
renderItem(item)
}
append(postfix)
}
analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10TypeRenderer.kt
+13 -12
View File
@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.bas
import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.getKtNamedAnnotationArguments
import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.maybeLocalClassId
import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtConstantValue
import org.jetbrains.kotlin.analysis.utils.printer.PrettyPrinter
import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor
import org.jetbrains.kotlin.builtins.getReceiverTypeFromFunctionType
import org.jetbrains.kotlin.builtins.getReturnTypeFromFunctionType
@@ -38,7 +39,7 @@ internal class KtFe10TypeRenderer(private val options: KtTypeRendererOptions, pr
const val ERROR_TYPE_TEXT = "ERROR_TYPE"
}
fun render(type: KotlinType, consumer: KtFe10RendererConsumer) {
fun render(type: KotlinType, consumer: PrettyPrinter) {
consumer.renderType(type)
}
@@ -46,7 +47,7 @@ internal class KtFe10TypeRenderer(private val options: KtTypeRendererOptions, pr
if (isDebugText) {
renderTypeAnnotationsDebug(type)
} else {
renderFe10Annotations(type.annotations) { classId ->
renderFe10Annotations(type.annotations, isSingleLineAnnotations = true) { classId ->
classId != StandardClassIds.Annotations.ExtensionFunctionType
}
}
@@ -86,7 +87,7 @@ internal class KtFe10TypeRenderer(private val options: KtTypeRendererOptions, pr
val annotations = type.annotations
.filter { it.annotationClass?.classId != StandardClassIds.Annotations.ExtensionFunctionType }
renderList(annotations, separator = " ", postfix = " ", renderWhenEmpty = false) { renderTypeAnnotationDebug(it) }
printCollectionIfNotEmpty(annotations, separator = " ", postfix = " ") { renderTypeAnnotationDebug(it) }
}
private fun KtFe10RendererConsumer.renderTypeAnnotationDebug(annotation: AnnotationDescriptor) {
@@ -105,7 +106,7 @@ internal class KtFe10TypeRenderer(private val options: KtTypeRendererOptions, pr
print("<ERROR TYPE REF>")
}
renderList(namedValues, separator = ", ", prefix = "(", postfix = ")") { (name, value) ->
printCollection(namedValues, separator = ", ", prefix = "(", postfix = ")") { (name, value) ->
append(name).append(" = ")
renderConstantValueDebug(value)
}
@@ -115,9 +116,9 @@ internal class KtFe10TypeRenderer(private val options: KtTypeRendererOptions, pr
when (value) {
is KtAnnotationApplicationValue -> renderAnnotationDebug(value.annotationValue.classId, value.annotationValue.arguments)
is KtArrayAnnotationValue ->
renderList(value.values, separator = ", ", prefix = "[", postfix = "]") { renderConstantValueDebug(it) }
is KtEnumEntryAnnotationValue -> append(value.callableId)
is KtConstantAnnotationValue -> append(value.constantValue.constantValueKind.asString).append("(").append(value.constantValue.value).append(")")
printCollection(value.values, separator = ", ", prefix = "[", postfix = "]") { renderConstantValueDebug(it) }
is KtEnumEntryAnnotationValue -> append(value.callableId?.asSingleFqName()?.render())
is KtConstantAnnotationValue -> append(value.constantValue.constantValueKind.asString).append("(").append(value.constantValue.value.toString()).append(")")
KtUnsupportedAnnotationValue -> append(KtUnsupportedAnnotationValue::class.java.simpleName)
is KtKClassAnnotationValue -> append(value.render())
}
@@ -168,7 +169,7 @@ internal class KtFe10TypeRenderer(private val options: KtTypeRendererOptions, pr
if (isDebugText) {
append("it")
}
renderList(typeConstructor.supertypes, separator = " & ", prefix = "(", postfix = ")") { renderType(it) }
printCollection(typeConstructor.supertypes, separator = " & ", prefix = "(", postfix = ")") { renderType(it) }
}
private fun KtFe10RendererConsumer.renderFunctionType(type: SimpleType) {
@@ -180,7 +181,7 @@ internal class KtFe10TypeRenderer(private val options: KtTypeRendererOptions, pr
renderType(receiverType)
append(".")
}
renderList(valueParameters, separator = ", ", prefix = "(", postfix = ")") { renderTypeProjection(it) }
printCollection(valueParameters, separator = ", ", prefix = "(", postfix = ")") { renderTypeProjection(it) }
append(" -> ")
renderType(returnType)
}
@@ -192,7 +193,7 @@ internal class KtFe10TypeRenderer(private val options: KtTypeRendererOptions, pr
private fun KtFe10RendererConsumer.renderOrdinaryType(type: SimpleType) {
val nestedType = KtFe10JvmTypeMapperContext.getNestedType(type)
renderTypeSegment(nestedType.root, isRoot = true)
renderList(nestedType.nested, separator = ".", prefix = ".", postfix = "", renderWhenEmpty = false) { renderTypeSegment(it) }
printCollectionIfNotEmpty(nestedType.nested, separator = ".", prefix = ".", postfix = "") { renderTypeSegment(it) }
}
private fun KtFe10RendererConsumer.renderTypeSegment(typeSegment: PossiblyInnerType, isRoot: Boolean = false) {
@@ -212,11 +213,11 @@ internal class KtFe10TypeRenderer(private val options: KtTypeRendererOptions, pr
}
val arguments = typeSegment.arguments
renderList(arguments, separator = ", ", prefix = "<", postfix = ">", renderWhenEmpty = false) { renderTypeProjection(it) }
printCollectionIfNotEmpty(arguments, separator = ", ", prefix = "<", postfix = ">") { renderTypeProjection(it) }
}
private fun KtFe10RendererConsumer.renderFqName(fqName: FqName) {
renderList(fqName.pathSegments(), separator = ".") { append(it.render()) }
printCollection(fqName.pathSegments(), separator = ".") { append(it.render()) }
}
private fun KtFe10RendererConsumer.renderTypeProjection(projection: TypeProjection) {
analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/renderAnnotations.kt
+9 -3
View File
@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.bas
import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtConstantValue
import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationValueRenderer
import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtAnnotationValue
import org.jetbrains.kotlin.analysis.utils.printer.PrettyPrinter
import org.jetbrains.kotlin.builtins.StandardNames
import org.jetbrains.kotlin.descriptors.annotations.Annotations
import org.jetbrains.kotlin.name.ClassId
@@ -16,7 +17,12 @@ import org.jetbrains.kotlin.renderer.render
import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass
import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
internal fun KtFe10RendererConsumer.renderFe10Annotations(annotations: Annotations, predicate: (ClassId) -> Boolean = { true }) {
internal fun PrettyPrinter.renderFe10Annotations(
annotations: Annotations,
isSingleLineAnnotations: Boolean,
predicate: (ClassId) -> Boolean = { true }
) {
val separator = if (isSingleLineAnnotations) " " else "\n"
for (annotation in annotations) {
val annotationClass = annotation.annotationClass ?: continue
val classId = annotationClass.classId
@@ -29,13 +35,13 @@ internal fun KtFe10RendererConsumer.renderFe10Annotations(annotations: Annotatio
append(annotation.fqName?.shortName()?.asString() ?: "ERROR")
val valueArguments = annotation.allValueArguments.entries.sortedBy { it.key.asString() }
renderList(valueArguments, separator = ", ", prefix = "(", postfix = ")", renderWhenEmpty = false) { (name, value) ->
printCollectionIfNotEmpty(valueArguments, separator = ", ", prefix = "(", postfix = ")") { (name, value) ->
append(name.render())
append(" = ")
append(KtAnnotationValueRenderer.render(value.toKtAnnotationValue()))
}
append(' ')
append(separator)
}
}
}