From 9beeb51227361f70229827cc42b11e5b178e8ab7 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 2 Sep 2020 13:20:46 +0300 Subject: [PATCH] [FIR] Implement fir-specific contract values and fix annotations serialization --- .../kotlin/fir/types/ConeTypeUtils.kt | 6 + .../FirAnnotationArgumentVisitor.kt | 14 +- .../serialization/FirAnnotationSerializer.kt | 13 +- .../fir/serialization/FirElementSerializer.kt | 42 ++-- .../constant/AnnotationArgumentVisitor.kt | 28 +++ .../serialization/constant/ConstantValue.kt | 226 ++++++++++++++++++ .../constant/FirToConstantValueTransformer.kt | 82 +++++++ 7 files changed, 373 insertions(+), 38 deletions(-) create mode 100644 compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/AnnotationArgumentVisitor.kt create mode 100644 compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/ConstantValue.kt create mode 100644 compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/FirToConstantValueTransformer.kt diff --git a/compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/ConeTypeUtils.kt b/compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/ConeTypeUtils.kt index f823ed22662..e2683df9291 100644 --- a/compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/ConeTypeUtils.kt +++ b/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) +} diff --git a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirAnnotationArgumentVisitor.kt b/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirAnnotationArgumentVisitor.kt index 86b8b95203f..4bf27093692 100644 --- a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirAnnotationArgumentVisitor.kt +++ b/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 { +object FirAnnotationArgumentVisitor : AnnotationArgumentVisitor() { 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 { 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 ?: continue - argument.setValue(valueProto(constant.value as? ConstantValue<*> ?: continue)) + argument.setValue(valueProto(argumentExpression.toConstantValue() ?: continue)) addArgument(argument) } }.build() diff --git a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt b/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt index c0c14cd706d..2d7a0a5af0e 100644 --- a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt +++ b/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().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().find { + it.name == name + }?.expression + } + private fun normalizeVisibility(declaration: FirMemberDeclaration): Visibility { // It can be necessary for Java classes serialization having package-private visibility diff --git a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/AnnotationArgumentVisitor.kt b/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/AnnotationArgumentVisitor.kt new file mode 100644 index 00000000000..13ab5c323a1 --- /dev/null +++ b/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 { + 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 +} diff --git a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/ConstantValue.kt b/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/ConstantValue.kt new file mode 100644 index 00000000000..939e8652c0a --- /dev/null +++ b/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(open val value: T) { + abstract fun accept(visitor: AnnotationArgumentVisitor, 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 protected constructor(value: T) : ConstantValue(value) +abstract class UnsignedValueConstant protected constructor(value: T) : ConstantValue(value) + +class AnnotationValue(value: FirAnnotationCall) : ConstantValue(value) { + override fun accept(visitor: AnnotationArgumentVisitor, data: D): R = visitor.visitAnnotationValue(this, data) +} + +class ArrayValue( + value: List>, +) : ConstantValue>>(value) { + override fun accept(visitor: AnnotationArgumentVisitor, data: D): R = visitor.visitArrayValue(this, data) +} + +class BooleanValue(value: Boolean) : ConstantValue(value) { + override fun accept(visitor: AnnotationArgumentVisitor, data: D): R = visitor.visitBooleanValue(this, data) +} + +class ByteValue(value: Byte) : IntegerValueConstant(value) { + override fun accept(visitor: AnnotationArgumentVisitor, data: D): R = visitor.visitByteValue(this, data) + + override fun toString(): String = "$value.toByte()" +} + +class CharValue(value: Char) : IntegerValueConstant(value) { + override fun accept(visitor: AnnotationArgumentVisitor, 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(value) { + override fun accept(visitor: AnnotationArgumentVisitor, data: D): R = visitor.visitDoubleValue(this, data) + + override fun toString(): String = "$value.toDouble()" +} + +class EnumValue(val enumClassId: ClassId, val enumEntryName: Name) : ConstantValue>(enumClassId to enumEntryName) { + override fun accept(visitor: AnnotationArgumentVisitor, data: D): R = visitor.visitEnumValue(this, data) + + override fun toString(): String = "${enumClassId.shortClassName}.$enumEntryName" +} + +abstract class ErrorValue : ConstantValue(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 accept(visitor: AnnotationArgumentVisitor, 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(value) { + override fun accept(visitor: AnnotationArgumentVisitor, data: D): R = visitor.visitFloatValue(this, data) + + override fun toString(): String = "$value.toFloat()" +} + +class IntValue(value: Int) : IntegerValueConstant(value) { + override fun accept(visitor: AnnotationArgumentVisitor, data: D): R = visitor.visitIntValue(this, data) +} + +class KClassValue(value: Value) : ConstantValue(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 accept(visitor: AnnotationArgumentVisitor, 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(value) { + override fun accept(visitor: AnnotationArgumentVisitor, data: D): R = visitor.visitLongValue(this, data) + + override fun toString(): String = "$value.toLong()" +} + +object NullValue : ConstantValue(null) { + override fun accept(visitor: AnnotationArgumentVisitor, data: D): R = visitor.visitNullValue(this, data) +} + +class ShortValue(value: Short) : IntegerValueConstant(value) { + override fun accept(visitor: AnnotationArgumentVisitor, data: D): R = visitor.visitShortValue(this, data) + + override fun toString(): String = "$value.toShort()" +} + +class StringValue(value: String) : ConstantValue(value) { + override fun accept(visitor: AnnotationArgumentVisitor, data: D): R = visitor.visitStringValue(this, data) + + override fun toString(): String = "\"$value\"" +} + +class UByteValue(byteValue: Byte) : UnsignedValueConstant(byteValue) { + override fun accept(visitor: AnnotationArgumentVisitor, 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(shortValue) { + override fun accept(visitor: AnnotationArgumentVisitor, 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(intValue) { + override fun accept(visitor: AnnotationArgumentVisitor, 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(longValue) { + override fun accept(visitor: AnnotationArgumentVisitor, 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" + } +} diff --git a/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/FirToConstantValueTransformer.kt b/compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/FirToConstantValueTransformer.kt new file mode 100644 index 00000000000..69ae5d19669 --- /dev/null +++ b/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?, Nothing?>() { + override fun visitElement( + element: FirElement, + data: Nothing? + ): ConstantValue<*>? { + error("Illegal element as annotation argument: ${element::class.qualifiedName}") + } + + @OptIn(ExperimentalUnsignedTypes::class) + override fun visitConstExpression( + constExpression: FirConstExpression, + 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) + } +}