ConstantValueKind.Short -> KaConstantValue.KaShortConstantValue(value as Short, psi)

            ConstantValueKind.UnsignedByte -> KaConstantValue.KaUnsignedByteConstantValue(value as UByte, psi)
            ConstantValueKind.UnsignedInt -> KaConstantValue.KaUnsignedIntConstantValue(value as UInt, psi)

    public class KaNullConstantValue(override val sourcePsi: KtElement?) : KaConstantValue(ConstantValueKind.Null) {
        override val value: Nothing? get() = null
        override fun renderAsKotlinConstant(): String = "null"
    }

    public class KaBooleanConstantValue(
        override val value: Boolean,
        override val sourcePsi: KtElement?
    ) : KaConstantValue(ConstantValueKind.Boolean) {

        null -> KaConstantValue.KaNullConstantValue(expression)
        is Boolean -> KaConstantValue.KaBooleanConstantValue(value, expression)
        is Char -> KaConstantValue.KaCharConstantValue(value, expression)
        is Byte -> KaConstantValue.KaByteConstantValue(value, expression)
        is UByte -> KaConstantValue.KaUnsignedByteConstantValue(value, expression)

        is StringValue -> KaConstantValue.KaStringConstantValue(value, sourcePsi = null)
        is ByteValue -> KaConstantValue.KaByteConstantValue(value, sourcePsi = null)
        is CharValue -> KaConstantValue.KaCharConstantValue(value, sourcePsi = null)
        is IntValue -> KaConstantValue.KaIntConstantValue(value, sourcePsi = null)

            type.isUByte -> KaConstantValue.KaUnsignedByteConstantValue((value as Number).toByte().toUByte(), expression)
            type.isShort -> KaConstantValue.KaShortConstantValue((value as Number).toShort(), expression)
            type.isUShort -> KaConstantValue.KaUnsignedShortConstantValue((value as Number).toShort().toUShort(), expression)

 * E.g: `@A(1 +2, "a" + "b")` -- both arguments here are [KaConstantAnnotationValue]
 * @see [KaConstantValue]
 */
public class KaConstantAnnotationValue @KaAnalysisApiInternals constructor(
    constantValue: KaConstantValue,
    token: KaLifetimeToken
) : KaAnnotationValue(token) {
    public val constantValue: KaConstantValue = constantValue
        get() = withValidityAssertion { field }

    /**
     * Tries to evaluate the provided expression.
     * Returns a [KaConstantValue] if the expression evaluates to a compile-time constant, otherwise returns null.
     */
    public fun KtExpression.evaluate(): KaConstantValue? =
        withValidityAssertion { analysisSession.compileTimeConstantProvider.evaluate(this) }

    /**

        sourcePsi: KtExpression,
    ): KaConstantValue? {
        return when {
            fir is FirPropertyAccessExpression || fir is FirExpression || fir is FirNamedReference -> {
                try {
                    FirCompileTimeConstantEvaluator.evaluateAsKtConstantValue(fir)
                } catch (e: ArithmeticException) {
                    KaConstantValue.KaErrorConstantValue(e.localizedMessage, sourcePsi)

 */

package org.jetbrains.kotlin.analysis.api

import org.jetbrains.kotlin.analysis.api.annotations.KaAnnotationValue
import org.jetbrains.kotlin.analysis.api.base.KaConstantValue
import org.jetbrains.kotlin.psi.KtExpression

/**
 * Value representing some property or variable initializer
 */
public sealed class KaInitializerValue {
    /**

 */

package org.jetbrains.kotlin.analysis.api.descriptors.components

import org.jetbrains.kotlin.analysis.api.annotations.KaAnnotationValue
import org.jetbrains.kotlin.analysis.api.base.KaConstantValue
import org.jetbrains.kotlin.analysis.api.components.KaCompileTimeConstantProvider
import org.jetbrains.kotlin.analysis.api.descriptors.KaFe10Session