Analysis API: rename KtConstantValue -> KtAnnotationValue as it is annotation specific

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10CompileTimeConstantProvider.kt

@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.analysis.api.components.KtCompileTimeConstantProvide
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtConstantValue
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtConstantValue
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationValue
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator
@@ -21,7 +21,7 @@ internal class KtFe10CompileTimeConstantProvider(
     override val token: ValidityToken
         get() = analysisSession.token
 
-    override fun evaluate(expression: KtExpression): KtConstantValue? {
+    override fun evaluate(expression: KtExpression): KtAnnotationValue? {
         val bindingContext = analysisContext.analyze(expression)
         val constant = ConstantExpressionEvaluator.getPossiblyErrorConstant(expression, bindingContext)
         return constant?.toConstantValue(TypeUtils.NO_EXPECTED_TYPE)?.toKtConstantValue()

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescKotlinPropertySymbol.kt

@@ -5,8 +5,6 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
 
-import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.analysis.api.KtConstantInitializerValue
 import org.jetbrains.kotlin.analysis.api.KtInitializerValue
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.*
@@ -15,7 +13,6 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtKotlinPropertySymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertyGetterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySetterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtConstantValue
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSyntheticJavaPropertySymbol.kt

@@ -10,7 +10,6 @@ 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.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.*
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtConstantValue
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.types.KtType

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSyntheticJavaPropertySymbolForOverride.kt

@@ -10,7 +10,6 @@ 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.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.*
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtConstantValue
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.types.KtType

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/base/Kt1DescUtils.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base
 
 import org.jetbrains.kotlin.analysis.api.*
-import org.jetbrains.kotlin.analysis.api.annotations.KtNamedConstantValue
+import org.jetbrains.kotlin.analysis.api.annotations.*
 import org.jetbrains.kotlin.analysis.api.components.KtDeclarationRendererOptions
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.*
@@ -30,7 +30,6 @@ import org.jetbrains.kotlin.load.kotlin.toSourceElement
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.KtProperty
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.calls.inference.CapturedType
@@ -263,30 +262,30 @@ internal val MemberDescriptor.ktModality: Modality
         return this.modality
     }
 
-internal fun ConstantValue<*>.toKtConstantValue(): KtConstantValue {
+internal fun ConstantValue<*>.toKtConstantValue(): KtAnnotationValue {
     return when (this) {
-        is BooleanValue -> KtLiteralConstantValue(ConstantValueKind.Boolean, value, null)
+        is BooleanValue -> KtLiteralAnnotationValue(ConstantValueKind.Boolean, value, null)
-        is CharValue -> KtLiteralConstantValue(ConstantValueKind.Char, value, null)
+        is CharValue -> KtLiteralAnnotationValue(ConstantValueKind.Char, value, null)
-        is ByteValue -> KtLiteralConstantValue(ConstantValueKind.Byte, value, null)
+        is ByteValue -> KtLiteralAnnotationValue(ConstantValueKind.Byte, value, null)
-        is UByteValue -> KtLiteralConstantValue(ConstantValueKind.UnsignedByte, value, null)
+        is UByteValue -> KtLiteralAnnotationValue(ConstantValueKind.UnsignedByte, value, null)
-        is ShortValue -> KtLiteralConstantValue(ConstantValueKind.Short, value, null)
+        is ShortValue -> KtLiteralAnnotationValue(ConstantValueKind.Short, value, null)
-        is UShortValue -> KtLiteralConstantValue(ConstantValueKind.UnsignedShort, value, null)
+        is UShortValue -> KtLiteralAnnotationValue(ConstantValueKind.UnsignedShort, value, null)
-        is IntValue -> KtLiteralConstantValue(ConstantValueKind.Int, value, null)
+        is IntValue -> KtLiteralAnnotationValue(ConstantValueKind.Int, value, null)
-        is UIntValue -> KtLiteralConstantValue(ConstantValueKind.UnsignedInt, value, null)
+        is UIntValue -> KtLiteralAnnotationValue(ConstantValueKind.UnsignedInt, value, null)
-        is LongValue -> KtLiteralConstantValue(ConstantValueKind.Long, value, null)
+        is LongValue -> KtLiteralAnnotationValue(ConstantValueKind.Long, value, null)
-        is ULongValue -> KtLiteralConstantValue(ConstantValueKind.UnsignedLong, value, null)
+        is ULongValue -> KtLiteralAnnotationValue(ConstantValueKind.UnsignedLong, value, null)
-        is FloatValue -> KtLiteralConstantValue(ConstantValueKind.Float, value, null)
+        is FloatValue -> KtLiteralAnnotationValue(ConstantValueKind.Float, value, null)
-        is DoubleValue -> KtLiteralConstantValue(ConstantValueKind.Double, value, null)
+        is DoubleValue -> KtLiteralAnnotationValue(ConstantValueKind.Double, value, null)
-        is NullValue -> KtLiteralConstantValue(ConstantValueKind.Null, null, null)
+        is NullValue -> KtLiteralAnnotationValue(ConstantValueKind.Null, null, null)
-        is StringValue -> KtLiteralConstantValue(ConstantValueKind.String, value, null)
+        is StringValue -> KtLiteralAnnotationValue(ConstantValueKind.String, value, null)
-        is ArrayValue -> KtArrayConstantValue(value.map { it.toKtConstantValue() }, null)
+        is ArrayValue -> KtArrayAnnotationValue(value.map { it.toKtConstantValue() }, null)
-        is EnumValue -> KtEnumEntryConstantValue(CallableId(enumClassId, enumEntryName), null)
+        is EnumValue -> KtEnumEntryAnnotationValue(CallableId(enumClassId, enumEntryName), null)
         is AnnotationValue -> {
             val arguments = value.allValueArguments.map { (name, v) -> KtNamedConstantValue(name.asString(), v.toKtConstantValue()) }
-            KtAnnotationConstantValue(value.annotationClass?.classId, arguments, null)
+            KtAnnotationAnnotationValue(value.annotationClass?.classId, arguments, null)
         }
         is ErrorValue -> KtErrorValue(this.toString())
-        else -> KtUnsupportedConstantValue
+        else -> KtUnsupportedAnnotationValue
     }
 }
 

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiKotlinPropertySymbol.kt

@@ -5,12 +5,9 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
 
-import org.jetbrains.kotlin.analysis.api.KtConstantInitializerValue
 import org.jetbrains.kotlin.analysis.api.KtInitializerValue
-import org.jetbrains.kotlin.analysis.api.KtNonConstantInitializerValue
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
-import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.*
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.createKtInitializerValue
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktModality
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktVisibility
@@ -25,9 +22,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtKotlinPropertySymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertyGetterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySetterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtConstantValue
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtUnsupportedConstantValue
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.types.KtType
@@ -42,8 +37,6 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtProperty
 import org.jetbrains.kotlin.psi.psiUtil.isExtensionDeclaration
 import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator
-import org.jetbrains.kotlin.types.TypeUtils
 
 internal class KtFe10PsiKotlinPropertySymbol(
     override val psi: KtProperty,

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10TypeRenderer.kt

@@ -5,12 +5,11 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.utils
 
-import org.jetbrains.kotlin.analysis.api.annotations.KtNamedConstantValue
+import org.jetbrains.kotlin.analysis.api.annotations.*
 import org.jetbrains.kotlin.analysis.api.components.KtTypeRendererOptions
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.classId
 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.api.symbols.markers.*
 import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor
 import org.jetbrains.kotlin.builtins.getReceiverTypeFromFunctionType
 import org.jetbrains.kotlin.builtins.getReturnTypeFromFunctionType
@@ -110,14 +109,14 @@ internal class KtFe10TypeRenderer(private val options: KtTypeRendererOptions, pr
         }
     }
 
-    private fun KtFe10RendererConsumer.renderConstantValueDebug(value: KtConstantValue) {
+    private fun KtFe10RendererConsumer.renderConstantValueDebug(value: KtAnnotationValue) {
         when (value) {
-            is KtAnnotationConstantValue -> renderAnnotationDebug(value.classId, value.arguments)
+            is KtAnnotationAnnotationValue -> renderAnnotationDebug(value.classId, value.arguments)
-            is KtArrayConstantValue ->
+            is KtArrayAnnotationValue ->
                 renderList(value.values, separator = ", ", prefix = "[", postfix = "]") { renderConstantValueDebug(it) }
-            is KtEnumEntryConstantValue -> append(value.callableId)
+            is KtEnumEntryAnnotationValue -> append(value.callableId)
-            is KtLiteralConstantValue<*> -> append(value.constantValueKind.asString).append("(").append(value.value).append(")")
+            is KtLiteralAnnotationValue<*> -> append(value.constantValueKind.asString).append("(").append(value.value).append(")")
-            KtUnsupportedConstantValue -> append(KtUnsupportedConstantValue::class.java.simpleName)
+            KtUnsupportedAnnotationValue -> append(KtUnsupportedAnnotationValue::class.java.simpleName)
             is KtErrorValue -> append("<ERROR>")
         }
     }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCompileTimeConstantProvider.kt

@@ -5,6 +5,8 @@
 
 package org.jetbrains.kotlin.analysis.api.fir.components
 
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationValue
+import org.jetbrains.kotlin.analysis.api.annotations.KtErrorValue
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.analysis.api.fir.evaluate.FirCompileTimeConstantEvaluator
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFir
@@ -12,7 +14,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.throwUnexpectedFirEle
 import org.jetbrains.kotlin.analysis.api.components.KtCompileTimeConstantProvider
 import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
 import org.jetbrains.kotlin.analysis.api.fir.evaluate.KtFirConstantValueConverter
-import org.jetbrains.kotlin.analysis.api.symbols.markers.*
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.fir.expressions.FirWhenBranch
@@ -23,7 +24,7 @@ internal class KtFirCompileTimeConstantProvider(
     override val token: ValidityToken,
 ) : KtCompileTimeConstantProvider(), KtFirAnalysisSessionComponent {
 
-    override fun evaluate(expression: KtExpression): KtConstantValue? = withValidityAssertion {
+    override fun evaluate(expression: KtExpression): KtAnnotationValue? = withValidityAssertion {
         when (val fir = expression.getOrBuildFir(firResolveState)) {
             is FirExpression -> {
                 try {

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/evaluate/FirCompileTimeConstantEvaluator.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.analysis.api.fir.evaluate
 
 import org.jetbrains.kotlin.KtSourceElement
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtConstantValue
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationValue
 import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
 import org.jetbrains.kotlin.fir.expressions.FirConstExpression
@@ -37,7 +37,7 @@ internal object FirCompileTimeConstantEvaluator {
             else -> null
         }
 
-    fun evaluateAsKtConstantExpression(expression: FirExpression): KtConstantValue? {
+    fun evaluateAsKtConstantExpression(expression: FirExpression): KtAnnotationValue? {
         val evaluated = evaluate(expression) ?: return null
         return KtFirConstantValueConverter.toConstantValue(evaluated)
     }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/evaluate/KtFirConstantValueConverter.kt

@@ -5,8 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.fir.evaluate
 
-import org.jetbrains.kotlin.analysis.api.annotations.KtNamedConstantValue
+import org.jetbrains.kotlin.analysis.api.annotations.*
-import org.jetbrains.kotlin.analysis.api.symbols.markers.*
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.analysis.checkers.getContainingClassSymbol
@@ -30,21 +29,21 @@ internal object KtFirConstantValueConverter {
         argumentMapping.map { (name, expression) ->
             KtNamedConstantValue(
                 name,
-                expression.convertConstantExpression(session) ?: KtUnsupportedConstantValue
+                expression.convertConstantExpression(session) ?: KtUnsupportedAnnotationValue
             )
         }
 
     fun <T> toConstantValue(
         firConstExpression: FirConstExpression<T>,
-    ): KtLiteralConstantValue<T> =
+    ): KtLiteralAnnotationValue<T> =
         firConstExpression.convertConstantExpression()
 
-    private fun <T> FirConstExpression<T>.convertConstantExpression(): KtLiteralConstantValue<T> =
+    private fun <T> FirConstExpression<T>.convertConstantExpression(): KtLiteralAnnotationValue<T> =
-        KtLiteralConstantValue(kind, value, psi as? KtElement)
+        KtLiteralAnnotationValue(kind, value, psi as? KtElement)
 
     private fun Collection<FirExpression>.convertConstantExpression(
         session: FirSession,
-    ): Collection<KtConstantValue> =
+    ): Collection<KtAnnotationValue> =
         mapNotNull { it.convertConstantExpression(session) }
 
     // Refer to KtLightAnnotationParameterList#checkIfToArrayConversionExpected
@@ -62,12 +61,12 @@ internal object KtFirConstantValueConverter {
         }
     }
 
-    private fun Collection<KtConstantValue>.toArrayConstantValueIfNecessary(sourcePsi: KtElement?): KtConstantValue? {
+    private fun Collection<KtAnnotationValue>.toArrayConstantValueIfNecessary(sourcePsi: KtElement?): KtAnnotationValue? {
         val valueArgument = if (sourcePsi is ValueArgument) sourcePsi else
             (sourcePsi?.parents?.firstOrNull { it is ValueArgument } as? ValueArgument)
         val wrap = valueArgument?.arrayConversionExpected() ?: false
         return if (wrap) {
-            KtArrayConstantValue(this, sourcePsi)
+            KtArrayAnnotationValue(this, sourcePsi)
         } else {
             singleOrNull()
         }
@@ -76,12 +75,12 @@ internal object KtFirConstantValueConverter {
     fun toConstantValue(
         firExpression: FirExpression,
         session: FirSession,
-    ): KtConstantValue? =
+    ): KtAnnotationValue? =
         firExpression.convertConstantExpression(session)
 
     private fun FirExpression.convertConstantExpression(
         session: FirSession,
-    ): KtConstantValue? {
+    ): KtAnnotationValue? {
         return when (this) {
             is FirConstExpression<*> -> convertConstantExpression()
             is FirNamedArgumentExpression -> {
@@ -95,7 +94,7 @@ internal object KtFirConstantValueConverter {
             }
             is FirArrayOfCall -> {
                 // Desugared collection literals.
-                KtArrayConstantValue(argumentList.arguments.convertConstantExpression(session), psi as? KtElement)
+                KtArrayAnnotationValue(argumentList.arguments.convertConstantExpression(session), psi as? KtElement)
             }
             is FirFunctionCall -> {
                 val reference = calleeReference as? FirResolvedNamedReference ?: return null
@@ -107,7 +106,7 @@ internal object KtFirConstantValueConverter {
                             argumentMapping?.entries?.forEach { (arg, param) ->
                                 resultMap[param.name.asString()] = arg
                             }
-                            KtAnnotationConstantValue(
+                            KtAnnotationAnnotationValue(
                                 resolvedSymbol.callableId.classId,
                                 toNamedConstantValue(resultMap, session),
                                 psi as? KtCallElement
@@ -127,7 +126,7 @@ internal object KtFirConstantValueConverter {
                 val reference = calleeReference as? FirResolvedNamedReference ?: return null
                 when (val resolvedSymbol = reference.resolvedSymbol) {
                     is FirEnumEntrySymbol -> {
-                        KtEnumEntryConstantValue(resolvedSymbol.callableId, psi as? KtElement)
+                        KtEnumEntryAnnotationValue(resolvedSymbol.callableId, psi as? KtElement)
                     }
                     else -> null
                 }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/renderer/FirAnnotationsIdeRenderer.kt

@@ -9,12 +9,11 @@ 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.analysis.api.annotations.KtUnsupportedAnnotationValue
 import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.toAnnotationClassId
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 
@@ -59,7 +58,7 @@ private fun renderAndSortAnnotationArguments(descriptor: FirAnnotation, session:
 private fun renderConstant(value: FirExpression, useSiteSession: FirSession): String {
     val evaluated = FirCompileTimeConstantEvaluator.evaluate(value)
     val constantValue = KtFirConstantValueConverter.toConstantValue(evaluated ?: value, useSiteSession)
-        ?: KtUnsupportedConstantValue
+        ?: KtUnsupportedAnnotationValue
 
     return KtConstantValueRenderer.render(constantValue)
 }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirKotlinPropertySymbol.kt

@@ -9,7 +9,6 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.analysis.api.fir.annotations.KtFirAnnotationListForDeclaration
-import org.jetbrains.kotlin.analysis.api.fir.evaluate.KtFirConstantValueConverter
 import org.jetbrains.kotlin.analysis.api.fir.findPsi
 import org.jetbrains.kotlin.analysis.api.fir.symbols.pointers.KtFirMemberPropertySymbolPointer
 import org.jetbrains.kotlin.analysis.api.fir.symbols.pointers.createSignature
@@ -20,7 +19,6 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtKotlinPropertySymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertyGetterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySetterSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtConstantValue
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.CanNotCreateSymbolPointerForLocalLibraryDeclarationException
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirSyntheticJavaPropertySymbol.kt

@@ -9,7 +9,6 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.analysis.api.KtInitializerValue
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.analysis.api.fir.annotations.KtFirAnnotationListForDeclaration
-import org.jetbrains.kotlin.analysis.api.fir.evaluate.KtFirConstantValueConverter
 import org.jetbrains.kotlin.analysis.api.fir.findPsi
 
 import org.jetbrains.kotlin.analysis.api.fir.symbols.pointers.KtFirJavaSyntheticPropertySymbolPointer
@@ -17,7 +16,6 @@ import org.jetbrains.kotlin.analysis.api.fir.utils.asKtInitializerValue
 import org.jetbrains.kotlin.analysis.api.fir.utils.cached
 import org.jetbrains.kotlin.analysis.api.fir.utils.firRef
 import org.jetbrains.kotlin.analysis.api.symbols.*
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtConstantValue
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/components/compileTimeConstantProvider/AbstractCompileTimeConstantEvaluatorTest.kt

@@ -5,10 +5,10 @@
 
 package org.jetbrains.kotlin.analysis.api.impl.base.test.components.compileTimeConstantProvider
 
+import org.jetbrains.kotlin.analysis.api.annotations.*
 import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService
 import org.jetbrains.kotlin.analysis.api.impl.barebone.test.expressionMarkerProvider
 import org.jetbrains.kotlin.analysis.api.impl.base.test.test.framework.AbstractHLApiSingleFileTest
-import org.jetbrains.kotlin.analysis.api.symbols.markers.*
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtValueArgument
@@ -32,19 +32,19 @@ abstract class AbstractCompileTimeConstantEvaluatorTest(
         val actual = buildString {
             appendLine("expression: ${expression.text}")
             appendLine("constant_value: ${analyseForTest(expression) { constantValue?.stringRepresentation() }}")
-            appendLine("constant: ${(constantValue as? KtLiteralConstantValue<*>)?.toConst()}")
+            appendLine("constant: ${(constantValue as? KtLiteralAnnotationValue<*>)?.toConst()}")
         }
         testServices.assertions.assertEqualsToTestDataFileSibling(actual)
     }
 
-    private fun KtConstantValue.stringRepresentation(): String {
+    private fun KtAnnotationValue.stringRepresentation(): String {
         return when (this) {
-            is KtArrayConstantValue -> buildString {
+            is KtArrayAnnotationValue -> buildString {
                 appendLine("KtArrayConstantValue [")
                 appendLine(INDENT, values.joinToString(separator = "\n") { it.stringRepresentation() })
                 append("]")
             }
-            is KtAnnotationConstantValue -> buildString {
+            is KtAnnotationAnnotationValue -> buildString {
                 append("KtAnnotationConstantValue(")
                 append(classId?.relativeClassName)
                 append(", ")
@@ -53,19 +53,19 @@ abstract class AbstractCompileTimeConstantEvaluatorTest(
                 }
                 append(")")
             }
-            is KtEnumEntryConstantValue -> buildString {
+            is KtEnumEntryAnnotationValue -> buildString {
                 append("KtEnumEntryConstantValue(")
                 append("$callableId")
                 append(")")
             }
-            is KtLiteralConstantValue<*> -> buildString {
+            is KtLiteralAnnotationValue<*> -> buildString {
                 append("KtLiteralConstantValue(")
                 append("constantValueKind=${constantValueKind}")
                 append(", ")
                 append("value=${value})")
             }
             is KtErrorValue -> "KtErrorValue($message)"
-            is KtUnsupportedConstantValue -> "KtUnsupportedConstantValue"
+            is KtUnsupportedAnnotationValue -> "KtUnsupportedConstantValue"
         }
     }
 

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/KtInitializerValue.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api
 
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtConstantValue
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationValue
 import org.jetbrains.kotlin.psi.KtExpression
 
 public sealed class KtInitializerValue {
@@ -13,7 +13,7 @@ public sealed class KtInitializerValue {
 }
 
 public class KtConstantInitializerValue(
-    public val constant: KtConstantValue,
+    public val constant: KtAnnotationValue,
     override val initializerPsi: KtExpression?
 ) : KtInitializerValue()
 

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/annotations/KtAnnotationValue.kt

@@ -3,9 +3,8 @@
  * 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
+package org.jetbrains.kotlin.analysis.api.annotations
 
-import org.jetbrains.kotlin.analysis.api.annotations.KtNamedConstantValue
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.psi.KtCallElement
@@ -22,12 +21,12 @@ import org.jetbrains.kotlin.types.ConstantValueKind
  *   * other annotation types, and
  *   * array of aforementioned types
  *
- *  [KtLiteralConstantValue] covers first two kinds;
+ *  [KtLiteralAnnotationValue]  covers first two kinds;
- *  [KtEnumEntryConstantValue] corresponds to enum types;
+ *  [KtEnumEntryAnnotationValue] corresponds to enum types;
- *  [KtAnnotationConstantValue] represents annotation types (with annotation fq name and arguments); and
+ *  [KtAnnotationAnnotationValue] represents annotation types (with annotation fq name and arguments); and
- *  [KtArrayConstantValue] abstracts an array of [KtConstantValue]s.
+ *  [KtArrayAnnotationValue] abstracts an array of [KtAnnotationValue]s.
  */
-public sealed class KtConstantValue(
+public sealed class KtAnnotationValue(
     public open val sourcePsi: KtElement? = null
 )
 
@@ -36,34 +35,34 @@ public sealed class KtConstantValue(
  */
 public class KtErrorValue(
     public val message: String
-) : KtConstantValue()
+) : KtAnnotationValue()
 
 /**
  * This represents an unsupported expression used as an annotation value.
  */
-public object KtUnsupportedConstantValue : KtConstantValue()
+public object KtUnsupportedAnnotationValue : KtAnnotationValue()
 
-public class KtArrayConstantValue(
+public class KtArrayAnnotationValue(
-    public val values: Collection<KtConstantValue>,
+    public val values: Collection<KtAnnotationValue>,
     override val sourcePsi: KtElement?,
-) : KtConstantValue()
+) : KtAnnotationValue()
 
-public class KtAnnotationConstantValue(
+public class KtAnnotationAnnotationValue(
     public val classId: ClassId?,
     public val arguments: List<KtNamedConstantValue>,
     override val sourcePsi: KtCallElement?,
-) : KtConstantValue()
+) : KtAnnotationValue()
 
-public class KtEnumEntryConstantValue(
+public class KtEnumEntryAnnotationValue(
     public val callableId: CallableId?,
     override val sourcePsi: KtElement?,
-) : KtConstantValue()
+) : KtAnnotationValue()
 
-public class KtLiteralConstantValue<T>(
+public class KtLiteralAnnotationValue<T>(
     public val constantValueKind: ConstantValueKind<T>,
     public val value: T,
     override val sourcePsi: KtElement?,
-) : KtConstantValue() {
+) : KtAnnotationValue() {
     public fun toConst(): Any? {
         return (value as? Long)?.let {
             when (constantValueKind) {

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/annotations/KtNamedConstantValue.kt

@@ -5,6 +5,4 @@
 
 package org.jetbrains.kotlin.analysis.api.annotations
 
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtConstantValue
+public data class KtNamedConstantValue(val name: String, val expression: KtAnnotationValue)
-
-public data class KtNamedConstantValue(val name: String, val expression: KtConstantValue)

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtCompileTimeConstantProvider.kt

@@ -5,14 +5,14 @@
 
 package org.jetbrains.kotlin.analysis.api.components
 
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtConstantValue
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationValue
 import org.jetbrains.kotlin.psi.KtExpression
 
 public abstract class KtCompileTimeConstantProvider : KtAnalysisSessionComponent() {
-    public abstract fun evaluate(expression: KtExpression): KtConstantValue?
+    public abstract fun evaluate(expression: KtExpression): KtAnnotationValue?
 }
 
 public interface KtCompileTimeConstantProviderMixIn : KtAnalysisSessionMixIn {
-    public fun KtExpression.evaluate(): KtConstantValue? =
+    public fun KtExpression.evaluate(): KtAnnotationValue? =
         analysisSession.compileTimeConstantProvider.evaluate(this)
 }

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/symbols/DebugSymbolRenderer.kt

@@ -11,10 +11,7 @@ import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.KtConstantInitializerValue
 import org.jetbrains.kotlin.analysis.api.KtInitializerValue
 import org.jetbrains.kotlin.analysis.api.KtNonConstantInitializerValue
-import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationApplication
+import org.jetbrains.kotlin.analysis.api.annotations.*
-import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationsList
-import org.jetbrains.kotlin.analysis.api.annotations.KtNamedConstantValue
-import org.jetbrains.kotlin.analysis.api.annotations.annotations
 import org.jetbrains.kotlin.analysis.api.components.KtSymbolInfoProviderMixIn
 import org.jetbrains.kotlin.analysis.api.symbols.markers.*
 import org.jetbrains.kotlin.analysis.api.types.KtClassErrorType
@@ -141,7 +138,7 @@ public object DebugSymbolRenderer {
         append(")")
     }
 
-    private fun Block.renderConstantValue(value: KtConstantValue) {
+    private fun Block.renderConstantValue(value: KtAnnotationValue) {
         append(KtConstantValueRenderer.render(value))
     }
 
@@ -191,7 +188,7 @@ public object DebugSymbolRenderer {
             // Symbol-related values
             is KtSymbol -> renderSymbolTag(value)
             is KtType -> renderType(value)
-            is KtConstantValue -> renderConstantValue(value)
+            is KtAnnotationValue -> renderConstantValue(value)
             is KtNamedConstantValue -> renderNamedConstantValue(value)
             is KtInitializerValue -> renderKtInitializerValue(value)
             is KtAnnotationApplication -> renderAnnotationApplication(value)

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/symbols/markers/KtConstantValueRenderer.kt

@@ -5,38 +5,38 @@
 
 package org.jetbrains.kotlin.analysis.api.symbols.markers
 
-import org.jetbrains.kotlin.analysis.api.annotations.KtNamedConstantValue
+import org.jetbrains.kotlin.analysis.api.annotations.*
 import org.jetbrains.kotlin.types.ConstantValueKind
 
 public object KtConstantValueRenderer {
-    public fun render(value: KtConstantValue): String = buildString {
+    public fun render(value: KtAnnotationValue): String = buildString {
         renderConstantValue(value)
     }
 
-    private fun StringBuilder.renderConstantValue(value: KtConstantValue) {
+    private fun StringBuilder.renderConstantValue(value: KtAnnotationValue) {
         when (value) {
-            is KtAnnotationConstantValue -> {
+            is KtAnnotationAnnotationValue -> {
                 renderAnnotationConstantValue(value)
             }
-            is KtArrayConstantValue -> {
+            is KtArrayAnnotationValue -> {
                 renderArrayConstantValue(value)
             }
-            is KtEnumEntryConstantValue -> {
+            is KtEnumEntryAnnotationValue -> {
                 renderEnumEntryConstantValue(value)
             }
             is KtErrorValue -> {
                 append("ERROR")
             }
-            is KtLiteralConstantValue<*> -> {
+            is KtLiteralAnnotationValue<*> -> {
                 renderLiteralConstantValue(value)
             }
-            KtUnsupportedConstantValue -> {
+            KtUnsupportedAnnotationValue -> {
                 append("KtUnsupportedConstantValue")
             }
         }
     }
 
-    private fun StringBuilder.renderLiteralConstantValue(value: KtLiteralConstantValue<*>) {
+    private fun StringBuilder.renderLiteralConstantValue(value: KtLiteralAnnotationValue<*>) {
         when (value.constantValueKind) {
             ConstantValueKind.String -> {
                 append('"')
@@ -54,11 +54,11 @@ public object KtConstantValueRenderer {
         }
     }
 
-    private fun StringBuilder.renderEnumEntryConstantValue(value: KtEnumEntryConstantValue) {
+    private fun StringBuilder.renderEnumEntryConstantValue(value: KtEnumEntryAnnotationValue) {
         append(value.callableId?.asSingleFqName()?.asString())
     }
 
-    private fun StringBuilder.renderAnnotationConstantValue(value: KtAnnotationConstantValue) {
+    private fun StringBuilder.renderAnnotationConstantValue(value: KtAnnotationAnnotationValue) {
         append(value.classId)
         if (value.arguments.isNotEmpty()) {
             append("(")
@@ -67,13 +67,13 @@ public object KtConstantValueRenderer {
         }
     }
 
-    private fun StringBuilder.renderArrayConstantValue(value: KtArrayConstantValue) {
+    private fun StringBuilder.renderArrayConstantValue(value: KtArrayAnnotationValue) {
         append("[")
         renderConstantValueList(value.values)
         append("]")
     }
 
-    private fun StringBuilder.renderConstantValueList(list: Collection<KtConstantValue>) {
+    private fun StringBuilder.renderConstantValueList(list: Collection<KtAnnotationValue>) {
         renderWithSeparator(list, ", ") { constantValue ->
             renderConstantValue(constantValue)
         }

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/annotations/annotationsUtils.kt

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.resolve.deprecation.DeprecationLevelValue
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.analysis.api.symbols.KtFileSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotatedSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtLiteralConstantValue
+import org.jetbrains.kotlin.analysis.api.annotations.KtLiteralAnnotationValue
 
 internal fun KtAnnotatedSymbol.hasJvmSyntheticAnnotation(annotationUseSiteTarget: AnnotationUseSiteTarget? = null): Boolean =
     hasAnnotation("kotlin/jvm/JvmSynthetic", annotationUseSiteTarget)
@@ -31,7 +31,7 @@ internal fun KtAnnotatedSymbol.getJvmNameFromAnnotation(annotationUseSiteTarget:
     }
 
     return annotation?.let {
-        (it.arguments.firstOrNull()?.expression as? KtLiteralConstantValue<*>)?.value as? String
+        (it.arguments.firstOrNull()?.expression as? KtLiteralAnnotationValue<*>)?.value as? String
     }
 }
 

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/fields/FirLightFieldForPropertySymbol.kt

@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.analysis.api.isValid
 import org.jetbrains.kotlin.analysis.api.symbols.KtKotlinPropertySymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySymbol
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtLiteralConstantValue
+import org.jetbrains.kotlin.analysis.api.annotations.KtLiteralAnnotationValue
 import org.jetbrains.kotlin.analysis.api.types.KtTypeMappingMode
 import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.KtProperty
@@ -113,7 +113,7 @@ internal class FirLightFieldForPropertySymbol(
         if (!propertySymbol.isConst) return@lazyPub null
         if (!propertySymbol.isVal) return@lazyPub null
         val constInitializer = propertySymbol.initializer as? KtConstantInitializerValue ?: return@lazyPub null
-        (constInitializer.constant as? KtLiteralConstantValue<*>)?.createPsiLiteral(this)
+        (constInitializer.constant as? KtLiteralAnnotationValue<*>)?.createPsiLiteral(this)
     }
 
     override fun getInitializer(): PsiExpression? = _initializer

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/firLightUtils.kt

@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.annotations.*
 import org.jetbrains.kotlin.analysis.api.components.DefaultTypeClassIds
 import org.jetbrains.kotlin.analysis.api.symbols.KtClassLikeSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol
@@ -170,13 +171,13 @@ private fun escapeString(str: String): String = buildString {
     }
 }
 
-internal fun KtConstantValue.toAnnotationMemberValue(parent: PsiElement): PsiAnnotationMemberValue? {
+internal fun KtAnnotationValue.toAnnotationMemberValue(parent: PsiElement): PsiAnnotationMemberValue? {
     return when (this) {
-        is KtArrayConstantValue ->
+        is KtArrayAnnotationValue ->
             FirPsiArrayInitializerMemberValue(sourcePsi, parent) { arrayLiteralParent ->
                 values.mapNotNull { element -> element.toAnnotationMemberValue(arrayLiteralParent) }
             }
-        is KtAnnotationConstantValue ->
+        is KtAnnotationAnnotationValue ->
             FirLightSimpleAnnotation(classId?.relativeClassName?.asString(), parent, arguments, sourcePsi)
         else ->
             createPsiLiteral(parent)?.let {
@@ -188,11 +189,11 @@ internal fun KtConstantValue.toAnnotationMemberValue(parent: PsiElement): PsiAnn
     }
 }
 
-private fun KtConstantValue.asStringForPsiLiteral(): String? =
+private fun KtAnnotationValue.asStringForPsiLiteral(): String? =
     when (this) {
-        is KtEnumEntryConstantValue ->
+        is KtEnumEntryAnnotationValue ->
             "${callableId?.classId?.asSingleFqName()?.asString() ?: ""}.${callableId?.callableName}"
-        is KtLiteralConstantValue<*> -> {
+        is KtLiteralAnnotationValue<*> -> {
             when (val value = this.value) {
                 is String -> "\"${escapeString(value)}\""
                 is Long -> "${value}L"
@@ -203,7 +204,7 @@ private fun KtConstantValue.asStringForPsiLiteral(): String? =
         else -> null
     }
 
-internal fun KtConstantValue.createPsiLiteral(parent: PsiElement): PsiExpression? {
+internal fun KtAnnotationValue.createPsiLiteral(parent: PsiElement): PsiExpression? {
     val asString = asStringForPsiLiteral() ?: return null
     val instance = PsiElementFactory.getInstance(parent.project)
     return try {