[FIR] Implement fir-specific contract values and fix annotations serialization

compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/ConeTypeUtils.kt

@@ -49,3 +49,9 @@ fun ConeKotlinType.toTypeProjection(variance: Variance): ConeTypeProjection =
         Variance.IN_VARIANCE -> ConeKotlinTypeProjectionIn(this)
         Variance.OUT_VARIANCE -> ConeKotlinTypeProjectionOut(this)
     }
+
+fun ConeClassLikeType.replaceArgumentsWithStarProjections(): ConeClassLikeType {
+    if (typeArguments.isEmpty()) return this
+    val newArguments = Array(typeArguments.size) { ConeStarProjection }
+    return withArguments(newArguments)
+}

compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirAnnotationArgumentVisitor.kt

@@ -5,13 +5,12 @@
 
 package org.jetbrains.kotlin.fir.serialization
 
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationArgumentVisitor
+import org.jetbrains.kotlin.fir.serialization.constant.*
+import org.jetbrains.kotlin.fir.types.arrayElementType
 import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.metadata.deserialization.Flags
-import org.jetbrains.kotlin.resolve.constants.*
 
-object FirAnnotationArgumentVisitor : AnnotationArgumentVisitor<Unit, FirAnnotationArgumentVisitorData> {
+object FirAnnotationArgumentVisitor : AnnotationArgumentVisitor<Unit, FirAnnotationArgumentVisitorData>() {
     override fun visitAnnotationValue(value: AnnotationValue, data: FirAnnotationArgumentVisitorData) {
         data.builder.type = ProtoBuf.Annotation.Argument.Value.Type.ANNOTATION
         // TODO: annotation = serializeAnnotation(value.value)
@@ -78,9 +77,9 @@ object FirAnnotationArgumentVisitor : AnnotationArgumentVisitor<Unit, FirAnnotat
             is KClassValue.Value.LocalClass -> {
                 var arrayDimensions = 0
                 var type = classValue.type
-                while (KotlinBuiltIns.isArray(type)) {
+                while (true) {
+                    type = type.arrayElementType() ?: break
                     arrayDimensions++
-                    type = type.arguments.single().type
                 }
 
                 //val descriptor = type.constructor.declarationDescriptor as? ClassDescriptor
@@ -136,5 +135,4 @@ object FirAnnotationArgumentVisitor : AnnotationArgumentVisitor<Unit, FirAnnotat
         data.builder.intValue = value.value
         data.builder.flags = Flags.IS_UNSIGNED.toFlags(true)
     }
-
-}
+}

compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirAnnotationSerializer.kt

@@ -6,14 +6,12 @@
 package org.jetbrains.kotlin.fir.serialization
 
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
-import org.jetbrains.kotlin.fir.expressions.FirNamedArgumentExpression
+import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.resolve.toSymbol
-import org.jetbrains.kotlin.fir.types.ConeClassLikeType
-import org.jetbrains.kotlin.fir.types.coneTypeSafe
+import org.jetbrains.kotlin.fir.serialization.constant.ConstantValue
+import org.jetbrains.kotlin.fir.serialization.constant.toConstantValue
+import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.metadata.ProtoBuf
-import org.jetbrains.kotlin.resolve.constants.*
 
 class FirAnnotationSerializer(private val session: FirSession, internal val stringTable: FirElementAwareStringTable) {
     fun serializeAnnotation(annotation: FirAnnotationCall): ProtoBuf.Annotation = ProtoBuf.Annotation.newBuilder().apply {
@@ -26,8 +24,7 @@ class FirAnnotationSerializer(private val session: FirSession, internal val stri
             if (argumentExpression !is FirNamedArgumentExpression) continue
             val argument = ProtoBuf.Annotation.Argument.newBuilder()
             argument.nameId = stringTable.getStringIndex(argumentExpression.name.asString())
-            val constant = argumentExpression.expression as? FirConstExpression<*> ?: continue
-            argument.setValue(valueProto(constant.value as? ConstantValue<*> ?: continue))
+            argument.setValue(valueProto(argumentExpression.toConstantValue() ?: continue))
             addArgument(argument)
         }
     }.build()

compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt

@@ -11,21 +11,27 @@ import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.FirAnnotationContainer
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
 import org.jetbrains.kotlin.fir.deserialization.CONTINUATION_INTERFACE_CLASS_ID
 import org.jetbrains.kotlin.fir.deserialization.projection
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirArgumentList
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
+import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirNamedArgumentExpression
+import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.calls.varargElementType
 import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
 import org.jetbrains.kotlin.fir.resolve.inference.isSuspendFunctionType
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.resolve.transformers.sealedInheritors
+import org.jetbrains.kotlin.fir.serialization.constant.EnumValue
+import org.jetbrains.kotlin.fir.serialization.constant.IntValue
+import org.jetbrains.kotlin.fir.serialization.constant.StringValue
+import org.jetbrains.kotlin.fir.serialization.constant.toConstantValue
 import org.jetbrains.kotlin.fir.symbols.StandardClassIds
 import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.types.*
@@ -41,10 +47,6 @@ import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.RequireKotlinConstants
-import org.jetbrains.kotlin.resolve.constants.ConstantValue
-import org.jetbrains.kotlin.resolve.constants.EnumValue
-import org.jetbrains.kotlin.resolve.constants.IntValue
-import org.jetbrains.kotlin.resolve.constants.StringValue
 import org.jetbrains.kotlin.serialization.deserialization.ProtoEnumFlags
 
 class FirElementSerializer private constructor(
@@ -736,21 +738,10 @@ class FirElementSerializer private constructor(
     private fun MutableVersionRequirementTable.writeVersionRequirementDependingOnCoroutinesVersion(): Int =
         writeVersionRequirement(LanguageFeature.ReleaseCoroutines)
 
-    private operator fun FirArgumentList.get(name: Name): ConstantValue<*>? {
-        // TODO: constant evaluation
-        val expression = arguments.filterIsInstance<FirNamedArgumentExpression>().find {
-            it.name == name
-        }?.expression
-        if (expression !is FirConstExpression<*>) {
-            return null
-        }
-        return expression.value as? ConstantValue<*>
-    }
-
     private fun serializeVersionRequirementFromRequireKotlin(annotation: FirAnnotationCall): ProtoBuf.VersionRequirement.Builder? {
         val args = annotation.argumentList
 
-        val versionString = (args[RequireKotlinConstants.VERSION] as? StringValue)?.value ?: return null
+        val versionString = (args[RequireKotlinConstants.VERSION]?.toConstantValue() as? StringValue)?.value ?: return null
         val matchResult = RequireKotlinConstants.VERSION_REGEX.matchEntire(versionString) ?: return null
 
         val major = matchResult.groupValues.getOrNull(1)?.toIntOrNull() ?: return null
@@ -763,12 +754,12 @@ class FirElementSerializer private constructor(
             writeVersionFull = { proto.versionFull = it }
         )
 
-        val message = (args[RequireKotlinConstants.MESSAGE] as? StringValue)?.value
+        val message = (args[RequireKotlinConstants.MESSAGE]?.toConstantValue() as? StringValue)?.value
         if (message != null) {
             proto.message = stringTable.getStringIndex(message)
         }
 
-        when ((args[RequireKotlinConstants.LEVEL] as? EnumValue)?.enumEntryName?.asString()) {
+        when ((args[RequireKotlinConstants.LEVEL]?.toConstantValue() as? EnumValue)?.enumEntryName?.asString()) {
             DeprecationLevel.ERROR.name -> {
                 // ERROR is the default level
             }
@@ -776,7 +767,7 @@ class FirElementSerializer private constructor(
             DeprecationLevel.HIDDEN.name -> proto.level = ProtoBuf.VersionRequirement.Level.HIDDEN
         }
 
-        when ((args[RequireKotlinConstants.VERSION_KIND] as? EnumValue)?.enumEntryName?.asString()) {
+        when ((args[RequireKotlinConstants.VERSION_KIND]?.toConstantValue() as? EnumValue)?.enumEntryName?.asString()) {
             ProtoBuf.VersionRequirement.VersionKind.LANGUAGE_VERSION.name -> {
                 // LANGUAGE_VERSION is the default kind
             }
@@ -786,7 +777,7 @@ class FirElementSerializer private constructor(
                 proto.versionKind = ProtoBuf.VersionRequirement.VersionKind.API_VERSION
         }
 
-        val errorCode = (args[RequireKotlinConstants.ERROR_CODE] as? IntValue)?.value
+        val errorCode = (args[RequireKotlinConstants.ERROR_CODE]?.toConstantValue() as? IntValue)?.value
         if (errorCode != null && errorCode != -1) {
             proto.errorCode = errorCode
         }
@@ -794,6 +785,13 @@ class FirElementSerializer private constructor(
         return proto
     }
 
+    private operator fun FirArgumentList.get(name: Name): FirExpression? {
+        // TODO: constant evaluation
+        return arguments.filterIsInstance<FirNamedArgumentExpression>().find {
+            it.name == name
+        }?.expression
+    }
+
 
     private fun normalizeVisibility(declaration: FirMemberDeclaration): Visibility {
         // It can be necessary for Java classes serialization having package-private visibility

compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/AnnotationArgumentVisitor.kt

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2010-2020 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.fir.serialization.constant
+
+abstract class AnnotationArgumentVisitor<R, D> {
+    abstract fun visitLongValue(value: LongValue, data: D): R
+    abstract fun visitIntValue(value: IntValue, data: D): R
+    abstract fun visitErrorValue(value: ErrorValue, data: D): R
+    abstract fun visitShortValue(value: ShortValue, data: D): R
+    abstract fun visitByteValue(value: ByteValue, data: D): R
+    abstract fun visitDoubleValue(value: DoubleValue, data: D): R
+    abstract fun visitFloatValue(value: FloatValue, data: D): R
+    abstract fun visitBooleanValue(value: BooleanValue, data: D): R
+    abstract fun visitCharValue(value: CharValue, data: D): R
+    abstract fun visitStringValue(value: StringValue, data: D): R
+    abstract fun visitNullValue(value: NullValue, data: D): R
+    abstract fun visitEnumValue(value: EnumValue, data: D): R
+    abstract fun visitArrayValue(value: ArrayValue, data: D): R
+    abstract fun visitAnnotationValue(value: AnnotationValue, data: D): R
+    abstract fun visitKClassValue(value: KClassValue, data: D): R
+    abstract fun visitUByteValue(value: UByteValue, data: D): R
+    abstract fun visitUShortValue(value: UShortValue, data: D): R
+    abstract fun visitUIntValue(value: UIntValue, data: D): R
+    abstract fun visitULongValue(value: ULongValue, data: D): R
+}

compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/ConstantValue.kt

@@ -0,0 +1,226 @@
+/*
+ * Copyright 2010-2020 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.fir.serialization.constant
+
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.resolve.defaultType
+import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
+import org.jetbrains.kotlin.fir.types.*
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.constants.ClassLiteralValue
+
+sealed class ConstantValue<out T>(open val value: T) {
+    abstract fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D): R
+
+    override fun equals(other: Any?): Boolean = this === other || value == (other as? ConstantValue<*>)?.value
+
+    override fun hashCode(): Int = value?.hashCode() ?: 0
+
+    override fun toString(): String = value.toString()
+
+    open fun stringTemplateValue(): String = value.toString()
+}
+
+abstract class IntegerValueConstant<out T> protected constructor(value: T) : ConstantValue<T>(value)
+abstract class UnsignedValueConstant<out T> protected constructor(value: T) : ConstantValue<T>(value)
+
+class AnnotationValue(value: FirAnnotationCall) : ConstantValue<FirAnnotationCall>(value) {
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D): R = visitor.visitAnnotationValue(this, data)
+}
+
+class ArrayValue(
+    value: List<ConstantValue<*>>,
+) : ConstantValue<List<ConstantValue<*>>>(value) {
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D): R = visitor.visitArrayValue(this, data)
+}
+
+class BooleanValue(value: Boolean) : ConstantValue<Boolean>(value) {
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D): R = visitor.visitBooleanValue(this, data)
+}
+
+class ByteValue(value: Byte) : IntegerValueConstant<Byte>(value) {
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D): R = visitor.visitByteValue(this, data)
+
+    override fun toString(): String = "$value.toByte()"
+}
+
+class CharValue(value: Char) : IntegerValueConstant<Char>(value) {
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D): R = visitor.visitCharValue(this, data)
+
+    override fun toString(): String = "\\u%04X ('%s')".format(value.toInt(), getPrintablePart(value))
+
+    private fun getPrintablePart(c: Char): String = when (c) {
+        '\b' -> "\\b"
+        '\t' -> "\\t"
+        '\n' -> "\\n"
+        //TODO: KT-8507
+        12.toChar() -> "\\f"
+        '\r' -> "\\r"
+        else -> if (isPrintableUnicode(c)) c.toString() else "?"
+    }
+
+    private fun isPrintableUnicode(c: Char): Boolean {
+        val t = Character.getType(c).toByte()
+        return t != Character.UNASSIGNED &&
+                t != Character.LINE_SEPARATOR &&
+                t != Character.PARAGRAPH_SEPARATOR &&
+                t != Character.CONTROL &&
+                t != Character.FORMAT &&
+                t != Character.PRIVATE_USE &&
+                t != Character.SURROGATE
+    }
+}
+
+class DoubleValue(value: Double) : ConstantValue<Double>(value) {
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D): R = visitor.visitDoubleValue(this, data)
+
+    override fun toString(): String = "$value.toDouble()"
+}
+
+class EnumValue(val enumClassId: ClassId, val enumEntryName: Name) : ConstantValue<Pair<ClassId, Name>>(enumClassId to enumEntryName) {
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D): R = visitor.visitEnumValue(this, data)
+
+    override fun toString(): String = "${enumClassId.shortClassName}.$enumEntryName"
+}
+
+abstract class ErrorValue : ConstantValue<Unit>(Unit) {
+    @Deprecated("Should not be called, for this is not a real value, but a indication of an error", level = DeprecationLevel.HIDDEN)
+    override val value: Unit
+        get() = throw UnsupportedOperationException()
+
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D): R = visitor.visitErrorValue(this, data)
+
+    class ErrorValueWithMessage(val message: String) : ErrorValue() {
+        override fun toString(): String = message
+    }
+
+    companion object {
+        fun create(message: String): ErrorValue {
+            return ErrorValueWithMessage(message)
+        }
+    }
+}
+
+class FloatValue(value: Float) : ConstantValue<Float>(value) {
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D): R = visitor.visitFloatValue(this, data)
+
+    override fun toString(): String = "$value.toFloat()"
+}
+
+class IntValue(value: Int) : IntegerValueConstant<Int>(value) {
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D): R = visitor.visitIntValue(this, data)
+}
+
+class KClassValue(value: Value) : ConstantValue<KClassValue.Value>(value) {
+    sealed class Value {
+        data class NormalClass(val value: ClassLiteralValue) : Value() {
+            val classId: ClassId get() = value.classId
+            val arrayDimensions: Int get() = value.arrayNestedness
+        }
+
+        data class LocalClass(val type: ConeKotlinType) : Value()
+    }
+
+    constructor(value: ClassLiteralValue) : this(Value.NormalClass(value))
+
+    constructor(classId: ClassId, arrayDimensions: Int) : this(ClassLiteralValue(classId, arrayDimensions))
+
+    fun getArgumentType(session: FirSession): ConeKotlinType? {
+        when (value) {
+            is Value.LocalClass -> return value.type
+            is Value.NormalClass -> {
+                val (classId, arrayDimensions) = value.value
+                val klass = session.firSymbolProvider.getClassLikeSymbolByFqName(classId)?.fir as? FirRegularClass ?: return null
+                var type: ConeKotlinType = klass.defaultType().replaceArgumentsWithStarProjections()
+                repeat(arrayDimensions) {
+                    type = type.createArrayOf()
+                }
+                return type
+            }
+        }
+    }
+
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D): R = visitor.visitKClassValue(this, data)
+
+    companion object {
+        fun create(argumentType: ConeKotlinType): ConstantValue<*>? {
+            if (argumentType is ConeKotlinErrorType) return null
+            if (argumentType !is ConeClassLikeType) return null
+            var type = argumentType
+            var arrayDimensions = 0
+            while (true) {
+                type = type.arrayElementType() ?: break
+                arrayDimensions++
+            }
+            val classId = type.classId ?: return null
+            return KClassValue(classId, arrayDimensions)
+        }
+    }
+}
+
+class LongValue(value: Long) : IntegerValueConstant<Long>(value) {
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D): R = visitor.visitLongValue(this, data)
+
+    override fun toString(): String = "$value.toLong()"
+}
+
+object NullValue : ConstantValue<Nothing?>(null) {
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D): R = visitor.visitNullValue(this, data)
+}
+
+class ShortValue(value: Short) : IntegerValueConstant<Short>(value) {
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D): R = visitor.visitShortValue(this, data)
+
+    override fun toString(): String = "$value.toShort()"
+}
+
+class StringValue(value: String) : ConstantValue<String>(value) {
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D): R = visitor.visitStringValue(this, data)
+
+    override fun toString(): String = "\"$value\""
+}
+
+class UByteValue(byteValue: Byte) : UnsignedValueConstant<Byte>(byteValue) {
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D): R = visitor.visitUByteValue(this, data)
+
+    override fun toString(): String = "$value.toUByte()"
+
+    override fun stringTemplateValue(): String = (value.toInt() and 0xFF).toString()
+}
+
+class UShortValue(shortValue: Short) : UnsignedValueConstant<Short>(shortValue) {
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D): R = visitor.visitUShortValue(this, data)
+
+    override fun toString(): String = "$value.toUShort()"
+
+    override fun stringTemplateValue(): String = (value.toInt() and 0xFFFF).toString()
+}
+
+class UIntValue(intValue: Int) : UnsignedValueConstant<Int>(intValue) {
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D): R = visitor.visitUIntValue(this, data)
+
+    override fun toString(): String = "$value.toUInt()"
+
+    override fun stringTemplateValue(): String = (value.toLong() and 0xFFFFFFFFL).toString()
+}
+
+class ULongValue(longValue: Long) : UnsignedValueConstant<Long>(longValue) {
+    override fun <R, D> accept(visitor: AnnotationArgumentVisitor<R, D>, data: D): R = visitor.visitULongValue(this, data)
+
+    override fun toString(): String = "$value.toULong()"
+
+    override fun stringTemplateValue(): String {
+        if (value >= 0) return value.toString()
+
+        val div10 = (value ushr 1) / 5
+        val mod10 = value - 10 * div10
+
+        return "$div10$mod10"
+    }
+}

compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/FirToConstantValueTransformer.kt

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2010-2020 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.fir.serialization.constant
+
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
+import org.jetbrains.kotlin.fir.expressions.*
+import org.jetbrains.kotlin.fir.types.classId
+import org.jetbrains.kotlin.fir.types.coneType
+import org.jetbrains.kotlin.fir.types.coneTypeUnsafe
+import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitor
+
+fun FirExpression.toConstantValue(): ConstantValue<*>? = accept(FirToConstantValueTransformer, null)
+
+object FirToConstantValueTransformer : FirDefaultVisitor<ConstantValue<*>?, Nothing?>() {
+    override fun visitElement(
+        element: FirElement,
+        data: Nothing?
+    ): ConstantValue<*>? {
+        error("Illegal element as annotation argument: ${element::class.qualifiedName}")
+    }
+
+    @OptIn(ExperimentalUnsignedTypes::class)
+    override fun <T> visitConstExpression(
+        constExpression: FirConstExpression<T>,
+        data: Nothing?
+    ): ConstantValue<*>? {
+        val value = constExpression.value
+        return when (constExpression.kind) {
+            FirConstKind.Boolean -> BooleanValue(value as Boolean)
+            FirConstKind.Char -> CharValue(value as Char)
+            FirConstKind.Byte -> ByteValue(value as Byte)
+            FirConstKind.UnsignedByte -> UByteValue(value as Byte)
+            FirConstKind.Short -> ShortValue(value as Short)
+            FirConstKind.UnsignedShort -> UShortValue(value as Short)
+            FirConstKind.Int -> IntValue(value as Int)
+            FirConstKind.UnsignedInt -> UIntValue(value as Int)
+            FirConstKind.Long -> LongValue(value as Long)
+            FirConstKind.UnsignedLong -> ULongValue(value as Long)
+            FirConstKind.String -> StringValue(value as String)
+            FirConstKind.Float -> FloatValue(value as Float)
+            FirConstKind.Double -> DoubleValue(value as Double)
+            FirConstKind.Null -> NullValue
+            else -> null
+        }
+    }
+
+    override fun visitArrayOfCall(
+        arrayOfCall: FirArrayOfCall,
+        data: Nothing?
+    ): ConstantValue<*>? {
+        return ArrayValue(arrayOfCall.argumentList.arguments.mapNotNull { it.accept(this, null) })
+    }
+
+    override fun visitAnnotationCall(
+        annotationCall: FirAnnotationCall,
+        data: Nothing?
+    ): ConstantValue<*>? {
+        return AnnotationValue(annotationCall)
+    }
+
+    override fun visitGetClassCall(
+        getClassCall: FirGetClassCall,
+        data: Nothing?
+    ): ConstantValue<*>? {
+        return KClassValue.create(getClassCall.typeRef.coneTypeUnsafe())
+    }
+
+    override fun visitQualifiedAccessExpression(
+        qualifiedAccessExpression: FirQualifiedAccessExpression,
+        data: Nothing?
+    ): ConstantValue<*>? {
+        val symbol = qualifiedAccessExpression.toResolvedCallableSymbol() ?: return null
+        val enumEntry = symbol.fir as? FirEnumEntry ?: return null
+        val classId = enumEntry.returnTypeRef.coneType.classId ?: return null
+        val outerClassId = classId.outerClassId ?: return null
+        return EnumValue(outerClassId, enumEntry.name)
+    }
+}