diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10Renderer.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10Renderer.kt index e195232c4eb..b5a3feb01b4 100644 --- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10Renderer.kt +++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10Renderer.kt @@ -8,10 +8,12 @@ package org.jetbrains.kotlin.analysis.api.descriptors.utils import org.jetbrains.kotlin.analysis.api.components.KtDeclarationRendererOptions import org.jetbrains.kotlin.analysis.api.components.RendererModifier import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext +import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.* import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.classId 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.api.symbols.markers.KtConstantValueRenderer import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.builtins.StandardNames import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor @@ -103,11 +105,6 @@ internal class KtFe10Renderer( return } - renderAnnotations(type.annotations) { classId -> - !options.typeRendererOptions.renderFunctionType - || classId != StandardClassIds.Annotations.ExtensionFunctionType - } - typeRenderer.render(type, this) } @@ -510,35 +507,7 @@ internal class KtFe10Renderer( return } - for (annotation in annotations) { - val annotationClass = annotation.annotationClass ?: continue - - val classId = annotationClass.classId - if (classId != null && !predicate(classId)) { - continue - } - - if (annotationClass.fqNameSafe != StandardNames.FqNames.parameterName) { - append('@') - renderType(annotation.type) - - val valueArguments = annotation.allValueArguments.entries.sortedBy { it.key.asString() } - renderList(valueArguments, separator = ", ", prefix = "(", postfix = ")", renderWhenEmpty = false) { (name, value) -> - append(name.render()) - append(" = ") - when (value) { - is UByteValue -> append(value.value.toUByte().toString()) - is UShortValue -> append(value.value.toUShort().toString()) - is UIntValue -> append(value.value.toUInt().toString()) - is ULongValue -> append(value.value.toULong().toString()) - is EnumValue, is AnnotationValue, is KClassValue, is ArrayValue, is ErrorValue -> append("NOT_CONST_EXPRESSION") - else -> append(value.value) - } - } - - append(' ') - } - } + renderFe10Annotations(annotations, predicate) } private fun KtFe10RendererConsumer.renderModifiers(descriptor: DeclarationDescriptor) { diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10TypeRenderer.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10TypeRenderer.kt index 65130b63cb1..44c8fe48803 100644 --- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10TypeRenderer.kt +++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10TypeRenderer.kt @@ -44,6 +44,10 @@ internal class KtFe10TypeRenderer(private val options: KtTypeRendererOptions, pr private fun KtFe10RendererConsumer.renderType(type: KotlinType) { if (isDebugText) { renderTypeAnnotationsDebug(type) + } else { + renderFe10Annotations(type.annotations) { classId -> + classId != StandardClassIds.Annotations.ExtensionFunctionType + } } when (val unwrappedType = type.unwrap()) { is FlexibleType -> renderFlexibleType(unwrappedType) diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/renderAnnotations.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/renderAnnotations.kt new file mode 100644 index 00000000000..d3317b31511 --- /dev/null +++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/renderAnnotations.kt @@ -0,0 +1,40 @@ +/* + * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.analysis.api.descriptors.utils + +import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.classId +import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtConstantValue +import org.jetbrains.kotlin.analysis.api.symbols.markers.KtConstantValueRenderer +import org.jetbrains.kotlin.builtins.StandardNames +import org.jetbrains.kotlin.descriptors.annotations.Annotations +import org.jetbrains.kotlin.name.ClassId +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 }) { + for (annotation in annotations) { + val annotationClass = annotation.annotationClass ?: continue + val classId = annotationClass.classId + if (classId != null && !predicate(classId)) { + continue + } + + if (annotationClass.fqNameSafe != StandardNames.FqNames.parameterName) { + append('@') + append(annotation.fqName?.shortName()?.asString() ?: "ERROR") + + val valueArguments = annotation.allValueArguments.entries.sortedBy { it.key.asString() } + renderList(valueArguments, separator = ", ", prefix = "(", postfix = ")", renderWhenEmpty = false) { (name, value) -> + append(name.render()) + append(" = ") + append(KtConstantValueRenderer.render(value.toKtConstantValue())) + } + + append(' ') + } + } +} \ No newline at end of file diff --git a/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/symbolDeclarationRenderer/KtFe10RendererTestGenerated.java b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/symbolDeclarationRenderer/KtFe10RendererTestGenerated.java index cde8d178256..0c23e15b990 100644 --- a/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/symbolDeclarationRenderer/KtFe10RendererTestGenerated.java +++ b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/descriptors/test/components/symbolDeclarationRenderer/KtFe10RendererTestGenerated.java @@ -185,4 +185,26 @@ public class KtFe10RendererTestGenerated extends AbstractKtFe10RendererTest { public void testWhere() throws Exception { runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/where.kt"); } + + @Nested + @TestMetadata("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/types") + @TestDataPath("$PROJECT_ROOT") + public class Types { + @Test + public void testAllFilesPresentInTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/types"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("annotaionOnTypes.kt") + public void testAnnotaionOnTypes() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/types/annotaionOnTypes.kt"); + } + + @Test + @TestMetadata("annotaionOnTypesWithComplexExpression.kt") + public void testAnnotaionOnTypesWithComplexExpression() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/types/annotaionOnTypesWithComplexExpression.kt"); + } + } } diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/renderer/ConeTypeIdeRenderer.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/renderer/ConeTypeIdeRenderer.kt index 2a456ff1d17..5bed7d2cada 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/renderer/ConeTypeIdeRenderer.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/renderer/ConeTypeIdeRenderer.kt @@ -39,19 +39,13 @@ internal class ConeTypeIdeRenderer( if (message != null) append(" <$message>") } - private var filterExtensionFunctionType: Boolean = false - - private fun StringBuilder.renderAnnotationList(annotations: List?) { - if (annotations != null) { - val filteredExtensionIfNeeded = annotations.applyIf(filterExtensionFunctionType) { - annotations.filterNot { it.toAnnotationClassId() == StandardClassIds.Annotations.ExtensionFunctionType } - } - renderAnnotations(this@ConeTypeIdeRenderer, filteredExtensionIfNeeded, session) + private fun StringBuilder.renderAnnotationList(type: ConeKotlinType) { + if (options.renderTypeAnnotations) { + renderAnnotations(this@ConeTypeIdeRenderer, type.customAnnotations, session) } } - fun renderType(type: ConeTypeProjection, annotations: List? = null): String = buildString { - + fun renderType(type: ConeTypeProjection): String = buildString { when (type) { is ConeKotlinErrorType -> { renderErrorType(type) @@ -59,39 +53,36 @@ internal class ConeTypeIdeRenderer( //is Dynamic??? -> append("dynamic") is ConeClassLikeType -> { if (options.renderFunctionType && shouldRenderAsPrettyFunctionType(type)) { - val oldFilterExtensionFunctionType = filterExtensionFunctionType - filterExtensionFunctionType = true - renderAnnotationList(annotations) + renderAnnotationList(type) renderFunctionType(type) - filterExtensionFunctionType = oldFilterExtensionFunctionType } else { - renderAnnotationList(annotations) + renderAnnotationList(type) renderTypeConstructorAndArguments(type) } } is ConeTypeParameterType -> { - renderAnnotationList(annotations) + renderAnnotationList(type) append(type.lookupTag.name.asString()) renderNullability(type.type) } is ConeIntersectionType -> { - renderAnnotationList(annotations) + renderAnnotationList(type) type.intersectedTypes.joinTo(this, "&", prefix = "(", postfix = ")") { renderType(it) } renderNullability(type.type) } is ConeFlexibleType -> { - renderAnnotationList(annotations) + renderAnnotationList(type) append(renderFlexibleType(renderType(type.lowerBound), renderType(type.upperBound))) } is ConeCapturedType -> { - renderAnnotationList(annotations) + renderAnnotationList(type) append(type.render()) renderNullability(type.type) } is ConeDefinitelyNotNullType -> { - renderAnnotationList(annotations) + renderAnnotationList(type) append(renderType(type.original)) append("!!") } @@ -214,7 +205,9 @@ internal class ConeTypeIdeRenderer( else -> error("Invalid declaration ${declaration.renderWithType()}") } ?: return listOf(declaration) - return if(containingClass.isLocal) { containingClass.collectForLocal().reversed() } else null + return if (containingClass.isLocal) { + containingClass.collectForLocal().reversed() + } else null } private fun StringBuilder.renderTypeConstructorAndArguments(type: ConeClassLikeType) { diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/renderer/FirAnnotationsIdeRenderer.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/renderer/FirAnnotationsIdeRenderer.kt index 72362e4f103..6e1c346c884 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/renderer/FirAnnotationsIdeRenderer.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/renderer/FirAnnotationsIdeRenderer.kt @@ -6,6 +6,10 @@ package org.jetbrains.kotlin.analysis.api.fir.renderer import org.jetbrains.kotlin.analysis.api.fir.annotations.mapAnnotationParameters +import org.jetbrains.kotlin.analysis.api.fir.evaluate.FirCompileTimeConstantEvaluator +import org.jetbrains.kotlin.analysis.api.fir.evaluate.KtFirConstantValueConverter +import org.jetbrains.kotlin.analysis.api.symbols.markers.KtConstantValueRenderer +import org.jetbrains.kotlin.analysis.api.symbols.markers.KtUnsupportedConstantValue import org.jetbrains.kotlin.builtins.StandardNames import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.toAnnotationClassId @@ -47,14 +51,15 @@ private fun renderAnnotation(annotation: FirAnnotation, coneTypeIdeRenderer: Con private fun renderAndSortAnnotationArguments(descriptor: FirAnnotation, session: FirSession): List { val argumentList = mapAnnotationParameters(descriptor, session).entries.map { (name, value) -> - "$name = ${renderConstant(value)}" + "$name = ${renderConstant(value, session)}" } return argumentList.sorted() } -private fun renderConstant(value: FirExpression): String { - return when (value) { - is FirConstExpression<*> -> value.toString() - else -> "NOT_CONST_EXPRESSION" - } +private fun renderConstant(value: FirExpression, useSiteSession: FirSession): String { + val evaluated = FirCompileTimeConstantEvaluator.evaluate(value) + val constantValue = KtFirConstantValueConverter.toConstantValue(evaluated ?: value, useSiteSession) + ?: KtUnsupportedConstantValue + + return KtConstantValueRenderer.render(constantValue) } diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/renderer/FirIdeRenderer.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/renderer/FirIdeRenderer.kt index 8b968812e6f..e3d6acd055b 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/renderer/FirIdeRenderer.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/renderer/FirIdeRenderer.kt @@ -43,8 +43,8 @@ internal class FirIdeRenderer private constructor( } } - private fun renderType(type: ConeTypeProjection, annotations: List? = null): String = - typeIdeRenderer.renderType(type, annotations) + private fun renderType(type: ConeTypeProjection): String = + typeIdeRenderer.renderType(type) private fun renderType(firRef: FirTypeRef, approximate: Boolean = false): String { require(firRef is FirResolvedTypeRef) @@ -52,12 +52,7 @@ internal class FirIdeRenderer private constructor( val approximatedIfNeeded = approximate.ifTrue { PublicTypeApproximator.approximateTypeToPublicDenotable(firRef.coneType, session, approximateLocalTypes = true) } ?: firRef.coneType - val annotations = if (RendererModifier.ANNOTATIONS in options.modifiers) { - firRef.annotations - } else { - null - } - return renderType(approximatedIfNeeded, annotations) + return renderType(approximatedIfNeeded) } private fun StringBuilder.renderName(declaration: FirDeclaration) { @@ -653,7 +648,7 @@ internal class FirIdeRenderer private constructor( append(": ") val parameterType = typeToRender.coneType if (isVarArg) { - append(renderType(parameterType.arrayElementType() ?: parameterType, typeToRender.annotations)) + append(renderType(parameterType.arrayElementType() ?: parameterType)) } else { append(renderType(typeToRender)) } diff --git a/analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/components/symbolDeclarationRenderer/FirRendererTestGenerated.java b/analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/components/symbolDeclarationRenderer/FirRendererTestGenerated.java index 99c2f589a24..735d8aff7a7 100644 --- a/analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/components/symbolDeclarationRenderer/FirRendererTestGenerated.java +++ b/analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/components/symbolDeclarationRenderer/FirRendererTestGenerated.java @@ -185,4 +185,26 @@ public class FirRendererTestGenerated extends AbstractFirRendererTest { public void testWhere() throws Exception { runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/where.kt"); } + + @Nested + @TestMetadata("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/types") + @TestDataPath("$PROJECT_ROOT") + public class Types { + @Test + public void testAllFilesPresentInTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/types"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("annotaionOnTypes.kt") + public void testAnnotaionOnTypes() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/types/annotaionOnTypes.kt"); + } + + @Test + @TestMetadata("annotaionOnTypesWithComplexExpression.kt") + public void testAnnotaionOnTypesWithComplexExpression() throws Exception { + runTest("analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/types/annotaionOnTypesWithComplexExpression.kt"); + } + } } diff --git a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtSymbolDeclarationRendererProvider.kt b/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtSymbolDeclarationRendererProvider.kt index cbaaeae4591..ef33d82ab96 100644 --- a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtSymbolDeclarationRendererProvider.kt +++ b/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtSymbolDeclarationRendererProvider.kt @@ -35,7 +35,12 @@ public data class KtTypeRendererOptions( /** * Whether to render type arguments. */ - public val renderTypeArguments: Boolean = true + public val renderTypeArguments: Boolean = true, + + /** + * Should annotations on types be rendered. + */ + public val renderTypeAnnotations: Boolean = true ) { public companion object { public val DEFAULT: KtTypeRendererOptions = KtTypeRendererOptions() diff --git a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/symbols/markers/KtConstantValueRenderer.kt b/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/symbols/markers/KtConstantValueRenderer.kt new file mode 100644 index 00000000000..64e311298d7 --- /dev/null +++ b/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/symbols/markers/KtConstantValueRenderer.kt @@ -0,0 +1,103 @@ +/* + * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.analysis.api.symbols.markers + +import org.jetbrains.kotlin.analysis.api.annotations.KtNamedConstantValue +import org.jetbrains.kotlin.types.ConstantValueKind + +public object KtConstantValueRenderer { + public fun render(value: KtConstantValue): String = buildString { + renderConstantValue(value) + } + + private fun StringBuilder.renderConstantValue(value: KtConstantValue) { + when (value) { + is KtAnnotationConstantValue -> { + renderAnnotationConstantValue(value) + } + is KtArrayConstantValue -> { + renderArrayConstantValue(value) + } + is KtEnumEntryConstantValue -> { + renderEnumEntryConstantValue(value) + } + is KtErrorValue -> { + append("ERROR") + } + is KtLiteralConstantValue<*> -> { + renderLiteralConstantValue(value) + } + KtUnsupportedConstantValue -> { + append("KtUnsupportedConstantValue") + } + } + } + + private fun StringBuilder.renderLiteralConstantValue(value: KtLiteralConstantValue<*>) { + when (value.constantValueKind) { + ConstantValueKind.String -> { + append('"') + append(value.value) + append('"') + } + ConstantValueKind.Char -> { + append("'") + append(value.value) + append("'") + } + else -> { + append(value.value) + } + } + } + + private fun StringBuilder.renderEnumEntryConstantValue(value: KtEnumEntryConstantValue) { + append(value.callableId?.asSingleFqName()?.asString()) + } + + private fun StringBuilder.renderAnnotationConstantValue(value: KtAnnotationConstantValue) { + append(value.classId) + if (value.arguments.isNotEmpty()) { + append("(") + renderNamedConstantValueList(value.arguments) + append(")") + } + } + + private fun StringBuilder.renderArrayConstantValue(value: KtArrayConstantValue) { + append("[") + renderConstantValueList(value.values) + append("]") + } + + private fun StringBuilder.renderConstantValueList(list: Collection) { + renderWithSeparator(list, ", ") { constantValue -> + renderConstantValue(constantValue) + } + } + + private fun StringBuilder.renderNamedConstantValueList(list: Collection) { + renderWithSeparator(list, ", ") { namedValue -> + append(namedValue.name) + append(" = ") + renderConstantValue(namedValue.expression) + append(", ") + } + } + + private inline fun StringBuilder.renderWithSeparator( + collection: Collection, + separator: String, + render: StringBuilder.(E) -> Unit + ) { + collection.forEachIndexed { index, element -> + render(element) + if (index != collection.size - 1) { + append(separator) + } + } + } +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/annotation.descriptors.rendered b/analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/annotation.descriptors.rendered index 1ac04be0f91..86c9f02d2f5 100644 --- a/analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/annotation.descriptors.rendered +++ b/analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/annotation.descriptors.rendered @@ -1,4 +1,4 @@ -@Target(allowedTargets = NOT_CONST_EXPRESSION) annotation class base +@Target(allowedTargets = [kotlin.annotation.AnnotationTarget.ANNOTATION_CLASS]) annotation class base @base annotation class derived @base class correct { constructor(x: Int) diff --git a/analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/annotation.rendered b/analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/annotation.rendered index 3b5cd27146f..8ce14d5482c 100644 --- a/analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/annotation.rendered +++ b/analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/annotation.rendered @@ -1,4 +1,4 @@ -@Target(allowedTargets = NOT_CONST_EXPRESSION) annotation class base +@Target(allowedTargets = [kotlin.annotation.AnnotationTarget.ANNOTATION_CLASS]) annotation class base @base annotation class derived @base class correct { constructor(@base x: Int) diff --git a/analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/types/annotaionOnTypes.kt b/analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/types/annotaionOnTypes.kt new file mode 100644 index 00000000000..094ad8c290e --- /dev/null +++ b/analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/types/annotaionOnTypes.kt @@ -0,0 +1,9 @@ +@Target(AnnotationTarget.TYPE) +annotation class A1 + +@Target(AnnotationTarget.TYPE) +annotation class A2(val value: String) + +fun x(): @A1 @A2("LIST") List<@A2("INT") Int> { + TODO() +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/types/annotaionOnTypes.rendered b/analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/types/annotaionOnTypes.rendered new file mode 100644 index 00000000000..f34823dd47d --- /dev/null +++ b/analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/types/annotaionOnTypes.rendered @@ -0,0 +1,6 @@ +@Target(allowedTargets = [kotlin.annotation.AnnotationTarget.TYPE]) annotation class A1 +@Target(allowedTargets = [kotlin.annotation.AnnotationTarget.TYPE]) annotation class A2 { + constructor(value: String) + val value: String +} +fun x(): @A1 @A2(value = "LIST") List<@A2(value = "INT") Int> diff --git a/analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/types/annotaionOnTypesWithComplexExpression.kt b/analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/types/annotaionOnTypesWithComplexExpression.kt new file mode 100644 index 00000000000..755a3b2c1ed --- /dev/null +++ b/analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/types/annotaionOnTypesWithComplexExpression.kt @@ -0,0 +1,6 @@ +@Target(AnnotationTarget.TYPE) +annotation class A(val value: Int) + +fun x(): @A(1 + 2) Int { + TODO() +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/types/annotaionOnTypesWithComplexExpression.rendered b/analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/types/annotaionOnTypesWithComplexExpression.rendered new file mode 100644 index 00000000000..7e4580fbc14 --- /dev/null +++ b/analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/types/annotaionOnTypesWithComplexExpression.rendered @@ -0,0 +1,5 @@ +@Target(allowedTargets = [kotlin.annotation.AnnotationTarget.TYPE]) annotation class A { + constructor(value: Int) + val value: Int +} +fun x(): @A(value = 3) Int diff --git a/analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/vararg.descriptors.rendered b/analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/vararg.descriptors.rendered new file mode 100644 index 00000000000..2cac76e417c --- /dev/null +++ b/analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/vararg.descriptors.rendered @@ -0,0 +1,3 @@ +@Target(allowedTargets = [kotlin.annotation.AnnotationTarget.ANNOTATION_CLASS, kotlin.annotation.AnnotationTarget.VALUE_PARAMETER, kotlin.annotation.AnnotationTarget.TYPE]) annotation class base +fun foo1(vararg ints: Int) +fun foo2(@base vararg ints: @base Int) diff --git a/analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/vararg.rendered b/analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/vararg.rendered index 47c9203032b..34c4aaf00a0 100644 --- a/analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/vararg.rendered +++ b/analysis/analysis-api/testData/components/symbolDeclarationRenderer/renderDeclaration/vararg.rendered @@ -1,3 +1,3 @@ -@Target(allowedTargets = NOT_CONST_EXPRESSION) annotation class base +@Target(allowedTargets = [kotlin.annotation.AnnotationTarget.ANNOTATION_CLASS, kotlin.annotation.AnnotationTarget.VALUE_PARAMETER, kotlin.annotation.AnnotationTarget.TYPE]) annotation class base fun foo1(vararg ints: Int) -fun foo2(@base vararg ints: @base Int) +fun foo2(@base vararg ints: Int)