From d24331955e9bc90811a76448ee77831e2a10c4e3 Mon Sep 17 00:00:00 2001 From: Stanislav Erokhin Date: Mon, 11 Jan 2021 13:53:23 +0100 Subject: [PATCH] Rename FirConstKind to ConstantValueKind and move it to compiler.common --- .../analysis/cfa/FirReturnsImpliesAnalyzer.kt | 7 ++-- .../extended/RedundantExplicitTypeChecker.kt | 5 ++- .../jetbrains/kotlin/fir/dump/HtmlFirDump.kt | 33 +++++++-------- .../AbstractAnnotationDeserializer.kt | 21 +++++----- .../deserialization/FirConstDeserializer.kt | 20 ++++----- .../constant/FirToConstantValueTransformer.kt | 29 ++++++------- .../kotlin/fir/backend/ConversionUtils.kt | 36 ++++++++-------- .../jetbrains/kotlin/fir/java/JavaUtils.kt | 41 ++++++++++--------- .../java/enhancement/SignatureEnhancement.kt | 4 +- .../fir/java/enhancement/javaTypeUtils.kt | 19 +++++---- .../converter/ExpressionsConverter.kt | 5 ++- .../kotlin/fir/builder/RawFirBuilder.kt | 9 +++- .../kotlin/fir/builder/BaseFirBuilder.kt | 25 +++++------ .../kotlin/fir/builder/ConversionUtils.kt | 3 +- .../fir/resolve/dfa/FirDataFlowAnalyzer.kt | 9 ++-- .../ConeConditionalEffectToFirVisitor.kt | 7 ++-- ...egerLiteralTypeApproximationTransformer.kt | 4 +- .../body/resolve/BodyResolveUtils.kt | 35 ++++++++-------- .../FirExpressionsResolveTransformer.kt | 7 ++-- .../contracts/ConeEffectExtractor.kt | 7 ++-- .../fir/expressions/FirConstExpression.kt | 5 ++- .../impl/FirConstExpressionImpl.kt | 6 +-- .../kotlin/fir/expressions/FirConstKind.kt | 31 -------------- .../fir/expressions/FirExpressionUtil.kt | 3 +- .../builder/FirConstExpressionBuilder.kt | 4 +- .../kotlin/fir/types/FirTypeUtils.kt | 20 ++++----- .../kotlin/fir/tree/generator/Types.kt | 2 +- .../compiler/visualizer/FirVisualizer.kt | 3 +- .../kotlin/types/ConstantValueKind.kt | 31 ++++++++++++++ 29 files changed, 227 insertions(+), 204 deletions(-) delete mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirConstKind.kt create mode 100644 core/compiler.common/src/org/jetbrains/kotlin/types/ConstantValueKind.kt diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirReturnsImpliesAnalyzer.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirReturnsImpliesAnalyzer.kt index 88911c8f35c..02b2df564e2 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirReturnsImpliesAnalyzer.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirReturnsImpliesAnalyzer.kt @@ -29,6 +29,7 @@ import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.fir.types.intersectTypesOrNull import org.jetbrains.kotlin.fir.types.isNullable import org.jetbrains.kotlin.types.AbstractTypeChecker +import org.jetbrains.kotlin.types.ConstantValueKind import org.jetbrains.kotlin.types.model.KotlinTypeMarker import org.jetbrains.kotlin.types.model.TypeCheckerProviderContext import org.jetbrains.kotlin.utils.addIfNotNull @@ -183,9 +184,9 @@ object FirReturnsImpliesAnalyzer : FirControlFlowChecker() { } private fun FirConstExpression<*>.isApplicableWith(operation: Operation): Boolean = when { - kind == FirConstKind.Null -> operation == Operation.EqNull - kind == FirConstKind.Boolean && operation == Operation.EqTrue -> (value as Boolean) - kind == FirConstKind.Boolean && operation == Operation.EqFalse -> !(value as Boolean) + kind == ConstantValueKind.Null -> operation == Operation.EqNull + kind == ConstantValueKind.Boolean && operation == Operation.EqTrue -> (value as Boolean) + kind == ConstantValueKind.Boolean && operation == Operation.EqFalse -> !(value as Boolean) else -> true } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantExplicitTypeChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantExplicitTypeChecker.kt index cdc4e17f832..924e5e7095c 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantExplicitTypeChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantExplicitTypeChecker.kt @@ -20,6 +20,7 @@ import org.jetbrains.kotlin.fir.symbols.StandardClassIds import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.types.ConstantValueKind object RedundantExplicitTypeChecker : FirMemberDeclarationChecker() { override fun check(declaration: FirMemberDeclaration, context: CheckerContext, reporter: DiagnosticReporter) { @@ -43,14 +44,14 @@ object RedundantExplicitTypeChecker : FirMemberDeclarationChecker() { if (!type.isSame(StandardClassIds.Boolean)) return } KtNodeTypes.INTEGER_CONSTANT -> { - if (initializer.kind == FirConstKind.Long) { + if (initializer.kind == ConstantValueKind.Long) { if (!type.isSame(StandardClassIds.Long)) return } else { if (!type.isSame(StandardClassIds.Int)) return } } KtNodeTypes.FLOAT_CONSTANT -> { - if (initializer.kind == FirConstKind.Float) { + if (initializer.kind == ConstantValueKind.Float) { if (!type.isSame(StandardClassIds.Float)) return } else { if (!type.isSame(StandardClassIds.Double)) return diff --git a/compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt b/compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt index 21bf65bb7cc..afaaf000399 100644 --- a/compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt +++ b/compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt @@ -42,6 +42,7 @@ import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.calls.inference.model.NewConstraintError import org.jetbrains.kotlin.types.AbstractStrictEqualityTypeChecker +import org.jetbrains.kotlin.types.ConstantValueKind import org.jetbrains.kotlin.types.Variance import java.io.File import java.io.Writer @@ -761,7 +762,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver private fun FlowContent.generate(expression: FirConstExpression<*>) { val value = expression.value - if (value == null && expression.kind != FirConstKind.Null) { + if (value == null && expression.kind != ConstantValueKind.Null) { return error { +"null value" } @@ -769,56 +770,56 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver @OptIn(ExperimentalUnsignedTypes::class) when (expression.kind) { - FirConstKind.Null -> keyword("null") - FirConstKind.Boolean -> keyword(value.toString()) - FirConstKind.String, FirConstKind.Char -> + ConstantValueKind.Null -> keyword("null") + ConstantValueKind.Boolean -> keyword(value.toString()) + ConstantValueKind.String, ConstantValueKind.Char -> stringLiteral(value) - FirConstKind.Byte -> { + ConstantValueKind.Byte -> { +value.toString() keyword("B") } - FirConstKind.Short -> { + ConstantValueKind.Short -> { +value.toString() keyword("S") } - FirConstKind.Int -> { + ConstantValueKind.Int -> { +value.toString() keyword("I") } - FirConstKind.Long -> { + ConstantValueKind.Long -> { +value.toString() keyword("L") } - FirConstKind.UnsignedByte -> { + ConstantValueKind.UnsignedByte -> { +(value as Long).toUByte().toString() keyword("uB") } - FirConstKind.UnsignedShort -> { + ConstantValueKind.UnsignedShort -> { +(value as Long).toUShort().toString() keyword("uS") } - FirConstKind.UnsignedInt -> { + ConstantValueKind.UnsignedInt -> { +(value as Long).toUInt().toString() keyword("uI") } - FirConstKind.UnsignedLong -> { + ConstantValueKind.UnsignedLong -> { +(value as Long).toULong().toString() keyword("uL") } - FirConstKind.Float -> { + ConstantValueKind.Float -> { +value.toString() keyword("F") } - FirConstKind.Double -> { + ConstantValueKind.Double -> { +value.toString() keyword("D") } - FirConstKind.IntegerLiteral -> { + ConstantValueKind.IntegerLiteral -> { +"IL<" +value.toString() +">" } - FirConstKind.UnsignedIntegerLiteral -> { + ConstantValueKind.UnsignedIntegerLiteral -> { +"UIL<" +value.toString() +">" diff --git a/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/AbstractAnnotationDeserializer.kt b/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/AbstractAnnotationDeserializer.kt index 8f82799bac8..4ba6d4d960b 100644 --- a/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/AbstractAnnotationDeserializer.kt +++ b/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/AbstractAnnotationDeserializer.kt @@ -36,6 +36,7 @@ import org.jetbrains.kotlin.serialization.deserialization.builtins.BuiltInSerial import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource import org.jetbrains.kotlin.serialization.deserialization.getClassId import org.jetbrains.kotlin.serialization.deserialization.getName +import org.jetbrains.kotlin.types.ConstantValueKind abstract class AbstractAnnotationDeserializer( private val session: FirSession @@ -222,30 +223,30 @@ abstract class AbstractAnnotationDeserializer( return when (value.type) { BYTE -> { - val kind = if (isUnsigned) FirConstKind.UnsignedByte else FirConstKind.Byte + val kind = if (isUnsigned) ConstantValueKind.UnsignedByte else ConstantValueKind.Byte const(kind, value.intValue.toByte()) } SHORT -> { - val kind = if (isUnsigned) FirConstKind.UnsignedShort else FirConstKind.Short + val kind = if (isUnsigned) ConstantValueKind.UnsignedShort else ConstantValueKind.Short const(kind, value.intValue.toShort()) } INT -> { - val kind = if (isUnsigned) FirConstKind.UnsignedInt else FirConstKind.Int + val kind = if (isUnsigned) ConstantValueKind.UnsignedInt else ConstantValueKind.Int const(kind, value.intValue.toInt()) } LONG -> { - val kind = if (isUnsigned) FirConstKind.UnsignedLong else FirConstKind.Long + val kind = if (isUnsigned) ConstantValueKind.UnsignedLong else ConstantValueKind.Long const(kind, value.intValue) } - CHAR -> const(FirConstKind.Char, value.intValue.toChar()) - FLOAT -> const(FirConstKind.Float, value.floatValue) - DOUBLE -> const(FirConstKind.Double, value.doubleValue) - BOOLEAN -> const(FirConstKind.Boolean, (value.intValue != 0L)) - STRING -> const(FirConstKind.String, nameResolver.getString(value.stringValue)) + CHAR -> const(ConstantValueKind.Char, value.intValue.toChar()) + FLOAT -> const(ConstantValueKind.Float, value.floatValue) + DOUBLE -> const(ConstantValueKind.Double, value.doubleValue) + BOOLEAN -> const(ConstantValueKind.Boolean, (value.intValue != 0L)) + STRING -> const(ConstantValueKind.String, nameResolver.getString(value.stringValue)) ANNOTATION -> deserializeAnnotation(value.annotation, nameResolver) CLASS -> buildGetClassCall { val classId = nameResolver.getClassId(value.classId) @@ -294,5 +295,5 @@ abstract class AbstractAnnotationDeserializer( } } - private fun const(kind: FirConstKind, value: T) = buildConstExpression(null, kind, value) + private fun const(kind: ConstantValueKind, value: T) = buildConstExpression(null, kind, value) } diff --git a/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/FirConstDeserializer.kt b/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/FirConstDeserializer.kt index 1e67995070e..c2028dfb67d 100644 --- a/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/FirConstDeserializer.kt +++ b/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/FirConstDeserializer.kt @@ -6,7 +6,6 @@ package org.jetbrains.kotlin.fir.deserialization import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.expressions.FirConstKind import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression import org.jetbrains.kotlin.fir.symbols.CallableId @@ -17,6 +16,7 @@ import org.jetbrains.kotlin.metadata.deserialization.NameResolver import org.jetbrains.kotlin.metadata.deserialization.getExtensionOrNull import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.serialization.deserialization.builtins.BuiltInSerializerProtocol +import org.jetbrains.kotlin.types.ConstantValueKind class FirConstDeserializer( val session: FirSession, @@ -53,16 +53,16 @@ class FirConstDeserializer( protoValue: ProtoBuf.Annotation.Argument.Value?, sourceValue: Any?, constKind: String, nameResolver: NameResolver ): FirExpression? { return when (constKind) { - "BYTE", "B" -> buildConstExpression(null, FirConstKind.Byte, ((protoValue?.intValue ?: sourceValue) as Number).toByte()) - "CHAR", "C" -> buildConstExpression(null, FirConstKind.Char, ((protoValue?.intValue ?: sourceValue) as Number).toChar()) - "SHORT", "S" -> buildConstExpression(null, FirConstKind.Short, ((protoValue?.intValue ?: sourceValue) as Number).toShort()) - "INT", "I" -> buildConstExpression(null, FirConstKind.Int, protoValue?.intValue?.toInt() ?: sourceValue as Int) - "LONG", "J" -> buildConstExpression(null, FirConstKind.Long, protoValue?.intValue ?: sourceValue as Long) - "FLOAT", "F" -> buildConstExpression(null, FirConstKind.Float, protoValue?.floatValue ?: sourceValue as Float) - "DOUBLE", "D" -> buildConstExpression(null, FirConstKind.Double, protoValue?.doubleValue ?: sourceValue as Double) - "BOOLEAN", "Z" -> buildConstExpression(null, FirConstKind.Boolean, (protoValue?.intValue?.toInt() ?: sourceValue) != 0) + "BYTE", "B" -> buildConstExpression(null, ConstantValueKind.Byte, ((protoValue?.intValue ?: sourceValue) as Number).toByte()) + "CHAR", "C" -> buildConstExpression(null, ConstantValueKind.Char, ((protoValue?.intValue ?: sourceValue) as Number).toChar()) + "SHORT", "S" -> buildConstExpression(null, ConstantValueKind.Short, ((protoValue?.intValue ?: sourceValue) as Number).toShort()) + "INT", "I" -> buildConstExpression(null, ConstantValueKind.Int, protoValue?.intValue?.toInt() ?: sourceValue as Int) + "LONG", "J" -> buildConstExpression(null, ConstantValueKind.Long, protoValue?.intValue ?: sourceValue as Long) + "FLOAT", "F" -> buildConstExpression(null, ConstantValueKind.Float, protoValue?.floatValue ?: sourceValue as Float) + "DOUBLE", "D" -> buildConstExpression(null, ConstantValueKind.Double, protoValue?.doubleValue ?: sourceValue as Double) + "BOOLEAN", "Z" -> buildConstExpression(null, ConstantValueKind.Boolean, (protoValue?.intValue?.toInt() ?: sourceValue) != 0) "STRING", "Ljava/lang/String;" -> buildConstExpression( - null, FirConstKind.String, protoValue?.stringValue?.let { nameResolver.getString(it) } ?: sourceValue as String + null, ConstantValueKind.String, protoValue?.stringValue?.let { nameResolver.getString(it) } ?: sourceValue as String ) else -> null } 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 index 06e716f57df..149c0efaf48 100644 --- 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 @@ -12,6 +12,7 @@ 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 +import org.jetbrains.kotlin.types.ConstantValueKind internal fun FirExpression.toConstantValue(): ConstantValue<*>? = accept(FirToConstantValueTransformer, null) @@ -30,20 +31,20 @@ internal object FirToConstantValueTransformer : FirDefaultVisitor? { 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 + ConstantValueKind.Boolean -> BooleanValue(value as Boolean) + ConstantValueKind.Char -> CharValue(value as Char) + ConstantValueKind.Byte -> ByteValue(value as Byte) + ConstantValueKind.UnsignedByte -> UByteValue(value as Byte) + ConstantValueKind.Short -> ShortValue(value as Short) + ConstantValueKind.UnsignedShort -> UShortValue(value as Short) + ConstantValueKind.Int -> IntValue(value as Int) + ConstantValueKind.UnsignedInt -> UIntValue(value as Int) + ConstantValueKind.Long -> LongValue(value as Long) + ConstantValueKind.UnsignedLong -> ULongValue(value as Long) + ConstantValueKind.String -> StringValue(value as String) + ConstantValueKind.Float -> FloatValue(value as Float) + ConstantValueKind.Double -> DoubleValue(value as Double) + ConstantValueKind.Null -> NullValue else -> null } } diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt index 6e8e5916690..ed271c778d4 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt @@ -14,7 +14,6 @@ import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty import org.jetbrains.kotlin.fir.expressions.FirConstExpression -import org.jetbrains.kotlin.fir.expressions.FirConstKind import org.jetbrains.kotlin.fir.references.FirReference import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.references.FirThisReference @@ -49,6 +48,7 @@ import org.jetbrains.kotlin.ir.util.functions import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.psiUtil.endOffset import org.jetbrains.kotlin.psi.psiUtil.startOffsetSkippingComments +import org.jetbrains.kotlin.types.ConstantValueKind import org.jetbrains.kotlin.types.Variance import org.jetbrains.kotlin.util.OperatorNameConventions @@ -163,7 +163,7 @@ private fun FirCallableSymbol<*>.toSymbolForCall(declarationStorage: Fir2IrDecla } fun FirConstExpression<*>.getIrConstKind(): IrConstKind<*> = when (kind) { - FirConstKind.IntegerLiteral -> { + ConstantValueKind.IntegerLiteral -> { val type = typeRef.coneTypeUnsafe() type.getApproximatedType().toConstKind()!!.toIrConstKind() } @@ -194,25 +194,25 @@ fun FirConstExpression.toIrConst(irType: IrType): IrConst { } } -private fun FirConstKind<*>.toIrConstKind(): IrConstKind<*> = when (this) { - FirConstKind.Null -> IrConstKind.Null - FirConstKind.Boolean -> IrConstKind.Boolean - FirConstKind.Char -> IrConstKind.Char +private fun ConstantValueKind<*>.toIrConstKind(): IrConstKind<*> = when (this) { + ConstantValueKind.Null -> IrConstKind.Null + ConstantValueKind.Boolean -> IrConstKind.Boolean + ConstantValueKind.Char -> IrConstKind.Char - FirConstKind.Byte -> IrConstKind.Byte - FirConstKind.Short -> IrConstKind.Short - FirConstKind.Int -> IrConstKind.Int - FirConstKind.Long -> IrConstKind.Long + ConstantValueKind.Byte -> IrConstKind.Byte + ConstantValueKind.Short -> IrConstKind.Short + ConstantValueKind.Int -> IrConstKind.Int + ConstantValueKind.Long -> IrConstKind.Long - FirConstKind.UnsignedByte -> IrConstKind.Byte - FirConstKind.UnsignedShort -> IrConstKind.Short - FirConstKind.UnsignedInt -> IrConstKind.Int - FirConstKind.UnsignedLong -> IrConstKind.Long + ConstantValueKind.UnsignedByte -> IrConstKind.Byte + ConstantValueKind.UnsignedShort -> IrConstKind.Short + ConstantValueKind.UnsignedInt -> IrConstKind.Int + ConstantValueKind.UnsignedLong -> IrConstKind.Long - FirConstKind.String -> IrConstKind.String - FirConstKind.Float -> IrConstKind.Float - FirConstKind.Double -> IrConstKind.Double - FirConstKind.IntegerLiteral, FirConstKind.UnsignedIntegerLiteral -> throw IllegalArgumentException() + ConstantValueKind.String -> IrConstKind.String + ConstantValueKind.Float -> IrConstKind.Float + ConstantValueKind.Double -> IrConstKind.Double + ConstantValueKind.IntegerLiteral, ConstantValueKind.UnsignedIntegerLiteral -> throw IllegalArgumentException() } diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt index 6233ffd1959..f61df5dda07 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt @@ -46,6 +46,7 @@ import org.jetbrains.kotlin.load.java.typeEnhancement.TypeComponentPosition import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.types.ConstantValueKind import org.jetbrains.kotlin.types.Variance.* import org.jetbrains.kotlin.util.capitalizeDecapitalize.capitalizeAsciiOnly import org.jetbrains.kotlin.utils.addToStdlib.runIf @@ -542,7 +543,7 @@ internal fun JavaAnnotation.toFirAnnotationCall( } JAVA_RETENTION_CLASS_ID -> arguments.singleOrNull()?.mapJavaRetentionArgument(session)?.let(::buildUnaryArgumentList) JAVA_DEPRECATED_CLASS_ID -> - buildUnaryArgumentList(buildConstExpression(null, FirConstKind.String, "Deprecated in Java").setProperType(session)) + buildUnaryArgumentList(buildConstExpression(null, ConstantValueKind.String, "Deprecated in Java").setProperType(session)) null -> null else -> buildArgumentMapping(session, javaTypeParameterStack, lookupTag!!, arguments) } ?: buildArgumentList { @@ -641,7 +642,7 @@ private fun JavaAnnotationArgument.toFirExpression( } // TODO: use kind here -private fun List.createArrayOfCall(session: FirSession, @Suppress("UNUSED_PARAMETER") kind: FirConstKind): FirArrayOfCall { +private fun List.createArrayOfCall(session: FirSession, @Suppress("UNUSED_PARAMETER") kind: ConstantValueKind): FirArrayOfCall { return buildArrayOfCall { argumentList = buildArgumentList { for (element in this@createArrayOfCall) { @@ -662,24 +663,24 @@ internal fun Any?.createConstantOrError(session: FirSession): FirExpression { internal fun Any?.createConstantIfAny(session: FirSession): FirExpression? { return when (this) { - is Byte -> buildConstExpression(null, FirConstKind.Byte, this).setProperType(session) - is Short -> buildConstExpression(null, FirConstKind.Short, this).setProperType(session) - is Int -> buildConstExpression(null, FirConstKind.Int, this).setProperType(session) - is Long -> buildConstExpression(null, FirConstKind.Long, this).setProperType(session) - is Char -> buildConstExpression(null, FirConstKind.Char, this).setProperType(session) - is Float -> buildConstExpression(null, FirConstKind.Float, this).setProperType(session) - is Double -> buildConstExpression(null, FirConstKind.Double, this).setProperType(session) - is Boolean -> buildConstExpression(null, FirConstKind.Boolean, this).setProperType(session) - is String -> buildConstExpression(null, FirConstKind.String, this).setProperType(session) - is ByteArray -> toList().createArrayOfCall(session, FirConstKind.Byte) - is ShortArray -> toList().createArrayOfCall(session, FirConstKind.Short) - is IntArray -> toList().createArrayOfCall(session, FirConstKind.Int) - is LongArray -> toList().createArrayOfCall(session, FirConstKind.Long) - is CharArray -> toList().createArrayOfCall(session, FirConstKind.Char) - is FloatArray -> toList().createArrayOfCall(session, FirConstKind.Float) - is DoubleArray -> toList().createArrayOfCall(session, FirConstKind.Double) - is BooleanArray -> toList().createArrayOfCall(session, FirConstKind.Boolean) - null -> buildConstExpression(null, FirConstKind.Null, null).setProperType(session) + is Byte -> buildConstExpression(null, ConstantValueKind.Byte, this).setProperType(session) + is Short -> buildConstExpression(null, ConstantValueKind.Short, this).setProperType(session) + is Int -> buildConstExpression(null, ConstantValueKind.Int, this).setProperType(session) + is Long -> buildConstExpression(null, ConstantValueKind.Long, this).setProperType(session) + is Char -> buildConstExpression(null, ConstantValueKind.Char, this).setProperType(session) + is Float -> buildConstExpression(null, ConstantValueKind.Float, this).setProperType(session) + is Double -> buildConstExpression(null, ConstantValueKind.Double, this).setProperType(session) + is Boolean -> buildConstExpression(null, ConstantValueKind.Boolean, this).setProperType(session) + is String -> buildConstExpression(null, ConstantValueKind.String, this).setProperType(session) + is ByteArray -> toList().createArrayOfCall(session, ConstantValueKind.Byte) + is ShortArray -> toList().createArrayOfCall(session, ConstantValueKind.Short) + is IntArray -> toList().createArrayOfCall(session, ConstantValueKind.Int) + is LongArray -> toList().createArrayOfCall(session, ConstantValueKind.Long) + is CharArray -> toList().createArrayOfCall(session, ConstantValueKind.Char) + is FloatArray -> toList().createArrayOfCall(session, ConstantValueKind.Float) + is DoubleArray -> toList().createArrayOfCall(session, ConstantValueKind.Double) + is BooleanArray -> toList().createArrayOfCall(session, ConstantValueKind.Boolean) + null -> buildConstExpression(null, ConstantValueKind.Null, null).setProperType(session) else -> null } diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt index 0961d5c0585..492cdf6937c 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt @@ -18,7 +18,6 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty import org.jetbrains.kotlin.fir.declarations.synthetic.buildSyntheticProperty -import org.jetbrains.kotlin.fir.expressions.FirConstKind import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack @@ -36,6 +35,7 @@ import org.jetbrains.kotlin.load.java.descriptors.StringDefaultValue import org.jetbrains.kotlin.load.java.typeEnhancement.* import org.jetbrains.kotlin.load.kotlin.SignatureBuildingComponents import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.types.ConstantValueKind import org.jetbrains.kotlin.utils.JavaTypeEnhancementState import org.jetbrains.kotlin.utils.addToStdlib.safeAs @@ -323,7 +323,7 @@ class FirSignatureEnhancement( ) val firResolvedTypeRef = signatureParts.type val defaultValueExpression = when (val defaultValue = ownerParameter.getDefaultValueFromAnnotation()) { - NullDefaultValue -> buildConstExpression(null, FirConstKind.Null, null) + NullDefaultValue -> buildConstExpression(null, ConstantValueKind.Null, null) is StringDefaultValue -> firResolvedTypeRef.type.lexicalCastFrom(session, defaultValue.value) null -> null } diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt index c744a6f7dc7..e6cb0f6b97a 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/javaTypeUtils.kt @@ -43,6 +43,7 @@ import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.types.AbstractStrictEqualityTypeChecker +import org.jetbrains.kotlin.types.ConstantValueKind import org.jetbrains.kotlin.types.RawType import org.jetbrains.kotlin.utils.addToStdlib.safeAs import org.jetbrains.kotlin.utils.extractRadix @@ -303,15 +304,15 @@ internal fun ConeKotlinType.lexicalCastFrom(session: FirSession, value: String): val (number, radix) = extractRadix(value) return when (classId.relativeClassName.asString()) { - "Boolean" -> buildConstExpression(null, FirConstKind.Boolean, value.toBoolean()) - "Char" -> buildConstExpression(null, FirConstKind.Char, value.singleOrNull() ?: return null) - "Byte" -> buildConstExpression(null, FirConstKind.Byte, number.toByteOrNull(radix) ?: return null) - "Short" -> buildConstExpression(null, FirConstKind.Short, number.toShortOrNull(radix) ?: return null) - "Int" -> buildConstExpression(null, FirConstKind.Int, number.toIntOrNull(radix) ?: return null) - "Long" -> buildConstExpression(null, FirConstKind.Long, number.toLongOrNull(radix) ?: return null) - "Float" -> buildConstExpression(null, FirConstKind.Float, value.toFloatOrNull() ?: return null) - "Double" -> buildConstExpression(null, FirConstKind.Double, value.toDoubleOrNull() ?: return null) - "String" -> buildConstExpression(null, FirConstKind.String, value) + "Boolean" -> buildConstExpression(null, ConstantValueKind.Boolean, value.toBoolean()) + "Char" -> buildConstExpression(null, ConstantValueKind.Char, value.singleOrNull() ?: return null) + "Byte" -> buildConstExpression(null, ConstantValueKind.Byte, number.toByteOrNull(radix) ?: return null) + "Short" -> buildConstExpression(null, ConstantValueKind.Short, number.toShortOrNull(radix) ?: return null) + "Int" -> buildConstExpression(null, ConstantValueKind.Int, number.toIntOrNull(radix) ?: return null) + "Long" -> buildConstExpression(null, ConstantValueKind.Long, number.toLongOrNull(radix) ?: return null) + "Float" -> buildConstExpression(null, ConstantValueKind.Float, value.toFloatOrNull() ?: return null) + "Double" -> buildConstExpression(null, ConstantValueKind.Double, value.toDoubleOrNull() ?: return null) + "String" -> buildConstExpression(null, ConstantValueKind.String, value) else -> null } } diff --git a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/ExpressionsConverter.kt b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/ExpressionsConverter.kt index affd7d14d44..670c637fe09 100644 --- a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/ExpressionsConverter.kt +++ b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/ExpressionsConverter.kt @@ -42,6 +42,7 @@ import org.jetbrains.kotlin.fir.types.builder.buildImplicitTypeRef import org.jetbrains.kotlin.lexer.KtTokens.* import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.stubs.elements.KtConstantExpressionElementType +import org.jetbrains.kotlin.types.ConstantValueKind import org.jetbrains.kotlin.types.expressions.OperatorConventions import org.jetbrains.kotlin.util.OperatorNameConventions @@ -375,14 +376,14 @@ class ExpressionsConverter( } val receiver = getAsFirExpression(argument, "No operand") if (operationToken == PLUS || operationToken == MINUS) { - if (receiver is FirConstExpression<*> && receiver.kind == FirConstKind.IntegerLiteral) { + if (receiver is FirConstExpression<*> && receiver.kind == ConstantValueKind.IntegerLiteral) { val value = receiver.value as Long val convertedValue = when (operationToken) { MINUS -> -value PLUS -> value else -> error("Should not be here") } - return buildConstExpression(unaryExpression.toFirSourceElement(), FirConstKind.IntegerLiteral, convertedValue) + return buildConstExpression(unaryExpression.toFirSourceElement(), ConstantValueKind.IntegerLiteral, convertedValue) } } buildFunctionCall { diff --git a/compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt b/compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt index 9011a12d235..7d4d2cfc5e2 100644 --- a/compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt +++ b/compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt @@ -43,6 +43,7 @@ import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.* +import org.jetbrains.kotlin.types.ConstantValueKind import org.jetbrains.kotlin.types.Variance import org.jetbrains.kotlin.types.expressions.OperatorConventions import org.jetbrains.kotlin.util.OperatorNameConventions @@ -1839,14 +1840,18 @@ class RawFirBuilder( val receiver = argument.toFirExpression("No operand") if (operationToken == PLUS || operationToken == MINUS) { - if (receiver is FirConstExpression<*> && receiver.kind == FirConstKind.IntegerLiteral) { + if (receiver is FirConstExpression<*> && receiver.kind == ConstantValueKind.IntegerLiteral) { val value = receiver.value as Long val convertedValue = when (operationToken) { MINUS -> -value PLUS -> value else -> error("Should not be here") } - return buildConstExpression(expression.toFirPsiSourceElement(), FirConstKind.IntegerLiteral, convertedValue) + return buildConstExpression( + expression.toFirPsiSourceElement(), + ConstantValueKind.IntegerLiteral, + convertedValue + ) } } buildFunctionCall { diff --git a/compiler/fir/raw-fir/raw-fir.common/src/org/jetbrains/kotlin/fir/builder/BaseFirBuilder.kt b/compiler/fir/raw-fir/raw-fir.common/src/org/jetbrains/kotlin/fir/builder/BaseFirBuilder.kt index cf228facb8e..0608e5c70c6 100644 --- a/compiler/fir/raw-fir/raw-fir.common/src/org/jetbrains/kotlin/fir/builder/BaseFirBuilder.kt +++ b/compiler/fir/raw-fir/raw-fir.common/src/org/jetbrains/kotlin/fir/builder/BaseFirBuilder.kt @@ -34,6 +34,7 @@ import org.jetbrains.kotlin.lexer.KtTokens.OPEN_QUOTE import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.parsing.* +import org.jetbrains.kotlin.types.ConstantValueKind import org.jetbrains.kotlin.util.OperatorNameConventions //T can be either PsiElement, or LighterASTNode @@ -285,17 +286,17 @@ abstract class BaseFirBuilder(val baseSession: FirSession, val context: Conte convertedText !is Long -> return reportIncorrectConstant(DiagnosticKind.IllegalConstExpression) hasUnsignedLongSuffix(text) -> { - FirConstKind.UnsignedLong + ConstantValueKind.UnsignedLong } hasLongSuffix(text) -> { - FirConstKind.Long + ConstantValueKind.Long } hasUnsignedSuffix(text) -> { - FirConstKind.UnsignedIntegerLiteral + ConstantValueKind.UnsignedIntegerLiteral } else -> { - FirConstKind.IntegerLiteral + ConstantValueKind.IntegerLiteral } } @@ -310,14 +311,14 @@ abstract class BaseFirBuilder(val baseSession: FirSession, val context: Conte if (convertedText is Float) { buildConstOrErrorExpression( sourceElement, - FirConstKind.Float, + ConstantValueKind.Float, convertedText, ConeSimpleDiagnostic("Incorrect float: $text", DiagnosticKind.IllegalConstExpression) ) } else { buildConstOrErrorExpression( sourceElement, - FirConstKind.Double, + ConstantValueKind.Double, convertedText as? Double, ConeSimpleDiagnostic("Incorrect double: $text", DiagnosticKind.IllegalConstExpression) ) @@ -325,20 +326,20 @@ abstract class BaseFirBuilder(val baseSession: FirSession, val context: Conte CHARACTER_CONSTANT -> buildConstOrErrorExpression( sourceElement, - FirConstKind.Char, + ConstantValueKind.Char, text.parseCharacter(), ConeSimpleDiagnostic("Incorrect character: $text", DiagnosticKind.IllegalConstExpression) ) BOOLEAN_CONSTANT -> buildConstExpression( sourceElement, - FirConstKind.Boolean, + ConstantValueKind.Boolean, convertedText as Boolean ) NULL -> buildConstExpression( sourceElement, - FirConstKind.Null, + ConstantValueKind.Null, null ) else -> @@ -361,11 +362,11 @@ abstract class BaseFirBuilder(val baseSession: FirSession, val context: Conte OPEN_QUOTE, CLOSING_QUOTE -> continue@L LITERAL_STRING_TEMPLATE_ENTRY -> { sb.append(entry.asText) - buildConstExpression(entry.toFirSourceElement(), FirConstKind.String, entry.asText) + buildConstExpression(entry.toFirSourceElement(), ConstantValueKind.String, entry.asText) } ESCAPE_STRING_TEMPLATE_ENTRY -> { sb.append(entry.unescapedValue) - buildConstExpression(entry.toFirSourceElement(), FirConstKind.String, entry.unescapedValue) + buildConstExpression(entry.toFirSourceElement(), ConstantValueKind.String, entry.unescapedValue) } SHORT_STRING_TEMPLATE_ENTRY, LONG_STRING_TEMPLATE_ENTRY -> { hasExpressions = true @@ -392,7 +393,7 @@ abstract class BaseFirBuilder(val baseSession: FirSession, val context: Conte } source = base?.toFirSourceElement() // Fast-pass if there is no non-const string expressions - if (!hasExpressions) return buildConstExpression(source, FirConstKind.String, sb.toString()) + if (!hasExpressions) return buildConstExpression(source, ConstantValueKind.String, sb.toString()) } } diff --git a/compiler/fir/raw-fir/raw-fir.common/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt b/compiler/fir/raw-fir/raw-fir.common/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt index e99b1c79f28..cc5311b4a43 100644 --- a/compiler/fir/raw-fir/raw-fir.common/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt +++ b/compiler/fir/raw-fir/raw-fir.common/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt @@ -36,6 +36,7 @@ import org.jetbrains.kotlin.fir.types.builder.* import org.jetbrains.kotlin.fir.types.impl.* import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.types.ConstantValueKind import org.jetbrains.kotlin.types.expressions.OperatorConventions import org.jetbrains.kotlin.util.OperatorNameConventions @@ -326,7 +327,7 @@ fun FirPropertyBuilder.generateAccessorsByDelegate( boundSymbol = this@generateAccessorsByDelegate.symbol } } - else -> buildConstExpression(null, FirConstKind.Null, null) + else -> buildConstExpression(null, ConstantValueKind.Null, null) } fun delegateAccess() = buildQualifiedAccessExpression { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirDataFlowAnalyzer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirDataFlowAnalyzer.kt index d0734c68154..7c3acdd6da6 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirDataFlowAnalyzer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirDataFlowAnalyzer.kt @@ -30,6 +30,7 @@ import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.visitors.transformSingle import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.types.ConstantValueKind import org.jetbrains.kotlin.utils.addIfNotNull import org.jetbrains.kotlin.utils.addToStdlib.runIf @@ -366,8 +367,8 @@ abstract class FirDataFlowAnalyzer( when { leftConst != null && rightConst != null -> return - leftConst?.kind == FirConstKind.Null -> processEqNull(node, rightOperand, operation) - rightConst?.kind == FirConstKind.Null -> processEqNull(node, leftOperand, operation) + leftConst?.kind == ConstantValueKind.Null -> processEqNull(node, rightOperand, operation) + rightConst?.kind == ConstantValueKind.Null -> processEqNull(node, leftOperand, operation) leftConst != null -> processEqWithConst(node, rightOperand, leftConst, operation) rightConst != null -> processEqWithConst(node, leftOperand, rightConst, operation) else -> processEq(node, leftOperand, rightOperand, operation) @@ -389,7 +390,7 @@ abstract class FirDataFlowAnalyzer( } // propagating facts for (... == true) and (... == false) - if (const.kind == FirConstKind.Boolean) { + if (const.kind == ConstantValueKind.Boolean) { val constValue = const.value as Boolean val shouldInvert = isEq xor constValue @@ -899,7 +900,7 @@ abstract class FirDataFlowAnalyzer( } if (isAssignment) { - if (initializer is FirConstExpression<*> && initializer.kind == FirConstKind.Null) { + if (initializer is FirConstExpression<*> && initializer.kind == ConstantValueKind.Null) { flow.addTypeStatement(propertyVariable typeEq property.returnTypeRef.coneType.withNullability(ConeNullability.NULLABLE)) } else { flow.addTypeStatement(propertyVariable typeEq initializer.typeRef.coneType) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/contracts/ConeConditionalEffectToFirVisitor.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/contracts/ConeConditionalEffectToFirVisitor.kt index cbfd115b60a..57441d2661f 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/contracts/ConeConditionalEffectToFirVisitor.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/contracts/ConeConditionalEffectToFirVisitor.kt @@ -12,6 +12,7 @@ import org.jetbrains.kotlin.fir.expressions.builder.* import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression import org.jetbrains.kotlin.fir.references.builder.buildSimpleNamedReference import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef +import org.jetbrains.kotlin.types.ConstantValueKind import org.jetbrains.kotlin.util.OperatorNameConventions private object ConeConditionalEffectToFirVisitor : ConeContractDescriptionVisitor>() { @@ -21,8 +22,8 @@ private object ConeConditionalEffectToFirVisitor : ConeContractDescriptionVisito override fun visitConstantDescriptor(constantReference: ConeConstantReference, data: Map): FirExpression? { return when (constantReference) { - ConeBooleanConstantReference.TRUE -> buildConstExpression(null, FirConstKind.Boolean, true) - ConeBooleanConstantReference.FALSE -> buildConstExpression(null, FirConstKind.Boolean, false) + ConeBooleanConstantReference.TRUE -> buildConstExpression(null, ConstantValueKind.Boolean, true) + ConeBooleanConstantReference.FALSE -> buildConstExpression(null, ConstantValueKind.Boolean, false) ConeConstantReference.NULL -> createConstNull() else -> null } @@ -78,7 +79,7 @@ private object ConeConditionalEffectToFirVisitor : ConeContractDescriptionVisito return data[valueParameterReference.parameterIndex] } - private fun createConstNull(): FirConstExpression<*> = buildConstExpression(null, FirConstKind.Null, null) + private fun createConstNull(): FirConstExpression<*> = buildConstExpression(null, ConstantValueKind.Null, null) } fun ConeConditionalEffectDeclaration.buildContractFir(argumentMapping: Map): FirExpression? { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/IntegerLiteralTypeApproximationTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/IntegerLiteralTypeApproximationTransformer.kt index f93156db43a..bb2424c0f81 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/IntegerLiteralTypeApproximationTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/IntegerLiteralTypeApproximationTransformer.kt @@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.resolve.transformers import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.expressions.FirConstExpression -import org.jetbrains.kotlin.fir.expressions.FirConstKind import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.resultType @@ -20,6 +19,7 @@ import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.compose import org.jetbrains.kotlin.fir.visitors.transformSingle +import org.jetbrains.kotlin.types.ConstantValueKind fun FirExpression.approximateIfIsIntegerConst(expectedType: ConeKotlinType? = null): FirExpression { return transformSingle(IntegerLiteralTypeApproximationTransformer, expectedType) @@ -38,7 +38,7 @@ private object IntegerLiteralTypeApproximationTransformer : FirTransformer + val kind = approximatedType.toConstKind() as ConstantValueKind constExpression.replaceKind(kind) return constExpression.compose() } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveUtils.kt index 3d1c7d0aff2..e4b3acf1a51 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveUtils.kt @@ -18,6 +18,7 @@ import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.types.ConstantValueKind inline fun FirBasedSymbol<*>.firUnsafe(): T { val fir = this.fir @@ -104,30 +105,30 @@ fun FirBlock.writeResultType(session: FirSession) { } } -fun FirConstKind<*>.expectedConeType(session: FirSession): ConeKotlinType { +fun ConstantValueKind<*>.expectedConeType(session: FirSession): ConeKotlinType { fun constructLiteralType(classId: ClassId, isNullable: Boolean = false): ConeKotlinType { val symbol = session.firSymbolProvider.getClassLikeSymbolByFqName(classId) ?: return ConeClassErrorType(ConeSimpleDiagnostic("Missing stdlib class: $classId", DiagnosticKind.MissingStdlibClass)) return symbol.toLookupTag().constructClassType(emptyArray(), isNullable) } return when (this) { - FirConstKind.Null -> session.builtinTypes.nullableNothingType.type - FirConstKind.Boolean -> session.builtinTypes.booleanType.type - FirConstKind.Char -> constructLiteralType(StandardClassIds.Char) - FirConstKind.Byte -> constructLiteralType(StandardClassIds.Byte) - FirConstKind.Short -> constructLiteralType(StandardClassIds.Short) - FirConstKind.Int -> constructLiteralType(StandardClassIds.Int) - FirConstKind.Long -> constructLiteralType(StandardClassIds.Long) - FirConstKind.String -> constructLiteralType(StandardClassIds.String) - FirConstKind.Float -> constructLiteralType(StandardClassIds.Float) - FirConstKind.Double -> constructLiteralType(StandardClassIds.Double) + ConstantValueKind.Null -> session.builtinTypes.nullableNothingType.type + ConstantValueKind.Boolean -> session.builtinTypes.booleanType.type + ConstantValueKind.Char -> constructLiteralType(StandardClassIds.Char) + ConstantValueKind.Byte -> constructLiteralType(StandardClassIds.Byte) + ConstantValueKind.Short -> constructLiteralType(StandardClassIds.Short) + ConstantValueKind.Int -> constructLiteralType(StandardClassIds.Int) + ConstantValueKind.Long -> constructLiteralType(StandardClassIds.Long) + ConstantValueKind.String -> constructLiteralType(StandardClassIds.String) + ConstantValueKind.Float -> constructLiteralType(StandardClassIds.Float) + ConstantValueKind.Double -> constructLiteralType(StandardClassIds.Double) - FirConstKind.UnsignedByte -> constructLiteralType(StandardClassIds.UByte) - FirConstKind.UnsignedShort -> constructLiteralType(StandardClassIds.UShort) - FirConstKind.UnsignedInt -> constructLiteralType(StandardClassIds.UInt) - FirConstKind.UnsignedLong -> constructLiteralType(StandardClassIds.ULong) + ConstantValueKind.UnsignedByte -> constructLiteralType(StandardClassIds.UByte) + ConstantValueKind.UnsignedShort -> constructLiteralType(StandardClassIds.UShort) + ConstantValueKind.UnsignedInt -> constructLiteralType(StandardClassIds.UInt) + ConstantValueKind.UnsignedLong -> constructLiteralType(StandardClassIds.ULong) - FirConstKind.IntegerLiteral -> constructLiteralType(StandardClassIds.Int) - FirConstKind.UnsignedIntegerLiteral -> constructLiteralType(StandardClassIds.UInt) + ConstantValueKind.IntegerLiteral -> constructLiteralType(StandardClassIds.Int) + ConstantValueKind.UnsignedIntegerLiteral -> constructLiteralType(StandardClassIds.UInt) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt index 1241edbed7e..a73e495a382 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt @@ -35,6 +35,7 @@ import org.jetbrains.kotlin.fir.types.builder.* import org.jetbrains.kotlin.fir.visitors.* import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.calls.tower.CandidateApplicability +import org.jetbrains.kotlin.types.ConstantValueKind import org.jetbrains.kotlin.types.TypeApproximatorConfiguration open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) : FirPartialBodyResolveTransformer(transformer) { @@ -682,14 +683,14 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform constExpression.transformAnnotations(transformer, ResolutionMode.ContextIndependent) val type = when (val kind = constExpression.kind) { - FirConstKind.IntegerLiteral, FirConstKind.UnsignedIntegerLiteral -> { + ConstantValueKind.IntegerLiteral, ConstantValueKind.UnsignedIntegerLiteral -> { val integerLiteralType = - ConeIntegerLiteralTypeImpl(constExpression.value as Long, isUnsigned = kind == FirConstKind.UnsignedIntegerLiteral) + ConeIntegerLiteralTypeImpl(constExpression.value as Long, isUnsigned = kind == ConstantValueKind.UnsignedIntegerLiteral) if (data.expectedType != null) { val approximatedType = integerLiteralType.getApproximatedType(data.expectedType?.coneTypeSafe()) val newConstKind = approximatedType.toConstKind() @Suppress("UNCHECKED_CAST") - constExpression.replaceKind(newConstKind as FirConstKind) + constExpression.replaceKind(newConstKind as ConstantValueKind) approximatedType } else { integerLiteralType diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/ConeEffectExtractor.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/ConeEffectExtractor.kt index f8a387e0f0e..9ba71745f86 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/ConeEffectExtractor.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/ConeEffectExtractor.kt @@ -15,6 +15,7 @@ import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitor +import org.jetbrains.kotlin.types.ConstantValueKind class ConeEffectExtractor( private val session: FirSession, @@ -103,7 +104,7 @@ class ConeEffectExtractor( else -> return null } val const = equalityOperatorCall.arguments[1] as? FirConstExpression<*> ?: return null - if (const.kind != FirConstKind.Null) return null + if (const.kind != ConstantValueKind.Null) return null val arg = equalityOperatorCall.arguments[0].accept(this, null) as? ConeValueParameterReference ?: return null return ConeIsNullPredicate(arg, isNegated) } @@ -148,8 +149,8 @@ class ConeEffectExtractor( override fun visitConstExpression(constExpression: FirConstExpression, data: Nothing?): ConeContractDescriptionElement? { return when (constExpression.kind) { - FirConstKind.Null -> ConeConstantReference.NULL - FirConstKind.Boolean -> when (constExpression.value as Boolean) { + ConstantValueKind.Null -> ConeConstantReference.NULL + ConstantValueKind.Boolean -> when (constExpression.value as Boolean) { true -> ConeBooleanConstantReference.TRUE false -> ConeBooleanConstantReference.FALSE } diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirConstExpression.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirConstExpression.kt index e6079ee0978..4a610d163e9 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirConstExpression.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirConstExpression.kt @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.expressions import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.types.FirTypeRef +import org.jetbrains.kotlin.types.ConstantValueKind import org.jetbrains.kotlin.fir.visitors.* /* @@ -18,14 +19,14 @@ abstract class FirConstExpression : FirExpression() { abstract override val source: FirSourceElement? abstract override val typeRef: FirTypeRef abstract override val annotations: List - abstract val kind: FirConstKind + abstract val kind: ConstantValueKind abstract val value: T override fun accept(visitor: FirVisitor, data: D): R = visitor.visitConstExpression(this, data) abstract override fun replaceTypeRef(newTypeRef: FirTypeRef) - abstract fun replaceKind(newKind: FirConstKind) + abstract fun replaceKind(newKind: ConstantValueKind) abstract override fun transformAnnotations(transformer: FirTransformer, data: D): FirConstExpression } diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirConstExpressionImpl.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirConstExpressionImpl.kt index 98b11155bcb..2a9ca0b762b 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirConstExpressionImpl.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirConstExpressionImpl.kt @@ -8,9 +8,9 @@ package org.jetbrains.kotlin.fir.expressions.impl import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirConstExpression -import org.jetbrains.kotlin.fir.expressions.FirConstKind import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl +import org.jetbrains.kotlin.types.ConstantValueKind import org.jetbrains.kotlin.fir.visitors.* /* @@ -21,7 +21,7 @@ import org.jetbrains.kotlin.fir.visitors.* internal class FirConstExpressionImpl ( override val source: FirSourceElement?, override val annotations: MutableList, - override var kind: FirConstKind, + override var kind: ConstantValueKind, override val value: T, ) : FirConstExpression() { override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(null) @@ -46,7 +46,7 @@ internal class FirConstExpressionImpl ( typeRef = newTypeRef } - override fun replaceKind(newKind: FirConstKind) { + override fun replaceKind(newKind: ConstantValueKind) { kind = newKind } } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirConstKind.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirConstKind.kt deleted file mode 100644 index 02a5d8ce6bd..00000000000 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirConstKind.kt +++ /dev/null @@ -1,31 +0,0 @@ -/* - * Copyright 2010-2019 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.expressions - -sealed class FirConstKind(val asString: kotlin.String) { - object Null : FirConstKind("Null") - object Boolean : FirConstKind("Boolean") - object Char : FirConstKind("Char") - - object Byte : FirConstKind("Byte") - object UnsignedByte : FirConstKind("UByte") - object Short : FirConstKind("Short") - object UnsignedShort : FirConstKind("UShort") - object Int : FirConstKind("Int") - object UnsignedInt : FirConstKind("UInt") - object Long : FirConstKind("Long") - object UnsignedLong : FirConstKind("ULong") - - object String : FirConstKind("String") - - object Float : FirConstKind("Float") - object Double : FirConstKind("Double") - - object IntegerLiteral : FirConstKind("IntegerLiteral") - object UnsignedIntegerLiteral : FirConstKind("UnsignedIntegerLiteral") - - override fun toString() = asString -} diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpressionUtil.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpressionUtil.kt index 15cd05afed7..1092bd434b2 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpressionUtil.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpressionUtil.kt @@ -21,6 +21,7 @@ import org.jetbrains.kotlin.fir.visitors.FirTransformer import org.jetbrains.kotlin.fir.visitors.TransformData import org.jetbrains.kotlin.fir.visitors.transformInplace import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.types.ConstantValueKind inline val FirAnnotationCall.coneClassLikeType: ConeClassLikeType? get() = ((annotationTypeRef as? FirResolvedTypeRef)?.type as? ConeClassLikeType) @@ -28,7 +29,7 @@ inline val FirAnnotationCall.coneClassLikeType: ConeClassLikeType? inline val FirAnnotationCall.classId: ClassId? get() = coneClassLikeType?.lookupTag?.classId -fun buildConstOrErrorExpression(source: FirSourceElement?, kind: FirConstKind, value: T?, diagnostic: ConeDiagnostic): FirExpression = +fun buildConstOrErrorExpression(source: FirSourceElement?, kind: ConstantValueKind, value: T?, diagnostic: ConeDiagnostic): FirExpression = value?.let { buildConstExpression(source, kind, it) } ?: buildErrorExpression { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/builder/FirConstExpressionBuilder.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/builder/FirConstExpressionBuilder.kt index b3356fd0732..b2315b13b3e 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/builder/FirConstExpressionBuilder.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/builder/FirConstExpressionBuilder.kt @@ -8,12 +8,12 @@ package org.jetbrains.kotlin.fir.expressions.builder import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirConstExpression -import org.jetbrains.kotlin.fir.expressions.FirConstKind import org.jetbrains.kotlin.fir.expressions.impl.FirConstExpressionImpl +import org.jetbrains.kotlin.types.ConstantValueKind fun buildConstExpression( source: FirSourceElement?, - kind: FirConstKind, + kind: ConstantValueKind, value: T, annotations: MutableList = mutableListOf(), ): FirConstExpression { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirTypeUtils.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirTypeUtils.kt index d0f4e6af615..778e0845323 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirTypeUtils.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirTypeUtils.kt @@ -6,11 +6,11 @@ package org.jetbrains.kotlin.fir.types import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall -import org.jetbrains.kotlin.fir.expressions.FirConstKind import org.jetbrains.kotlin.fir.render import org.jetbrains.kotlin.fir.symbols.StandardClassIds import org.jetbrains.kotlin.fir.types.impl.FirImplicitBuiltinTypeRef import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.types.ConstantValueKind import kotlin.contracts.ExperimentalContracts import kotlin.contracts.contract @@ -77,16 +77,16 @@ fun List.dropExtensionFunctionAnnotation(): List? = when (lookupTag.classId) { - StandardClassIds.Byte -> FirConstKind.Byte - StandardClassIds.Short -> FirConstKind.Short - StandardClassIds.Int -> FirConstKind.Int - StandardClassIds.Long -> FirConstKind.Long +fun ConeClassLikeType.toConstKind(): ConstantValueKind<*>? = when (lookupTag.classId) { + StandardClassIds.Byte -> ConstantValueKind.Byte + StandardClassIds.Short -> ConstantValueKind.Short + StandardClassIds.Int -> ConstantValueKind.Int + StandardClassIds.Long -> ConstantValueKind.Long - StandardClassIds.UInt -> FirConstKind.UnsignedInt - StandardClassIds.ULong -> FirConstKind.UnsignedLong - StandardClassIds.UShort -> FirConstKind.UnsignedShort - StandardClassIds.UByte -> FirConstKind.UnsignedByte + StandardClassIds.UInt -> ConstantValueKind.UnsignedInt + StandardClassIds.ULong -> ConstantValueKind.UnsignedLong + StandardClassIds.UShort -> ConstantValueKind.UnsignedShort + StandardClassIds.UByte -> ConstantValueKind.UnsignedByte else -> null } diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt index 2f194a18da2..2be2eeb4e63 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt @@ -22,7 +22,7 @@ import org.jetbrains.kotlin.types.Variance val sourceElementType = type("fir", "FirSourceElement") val jumpTargetType = type("fir", "FirTarget") -val constKindType = generatedType("expressions", "FirConstKind") +val constKindType = type("types", "ConstantValueKind") val operationType = type("fir.expressions", "FirOperation") val classKindType = type(ClassKind::class) val eventOccurrencesRangeType = type(EventOccurrencesRange::class) diff --git a/compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt b/compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt index f2e5e700d34..fd066bea142 100644 --- a/compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt +++ b/compiler/visualizer/render-fir/src/org/jetbrains/kotlin/compiler/visualizer/FirVisualizer.kt @@ -26,6 +26,7 @@ import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.getChildrenOfType +import org.jetbrains.kotlin.types.ConstantValueKind import org.jetbrains.kotlin.util.capitalizeDecapitalize.toLowerCaseAsciiOnly private typealias Stack = MutableList>> @@ -444,7 +445,7 @@ class FirVisualizer(private val firFile: FirFile) : BaseRenderer() { } override fun visitConstExpression(constExpression: FirConstExpression, data: StringBuilder) { - if (constExpression.kind != FirConstKind.String) { + if (constExpression.kind != ConstantValueKind.String) { data.append(constExpression.kind) } } diff --git a/core/compiler.common/src/org/jetbrains/kotlin/types/ConstantValueKind.kt b/core/compiler.common/src/org/jetbrains/kotlin/types/ConstantValueKind.kt new file mode 100644 index 00000000000..e40f081dc83 --- /dev/null +++ b/core/compiler.common/src/org/jetbrains/kotlin/types/ConstantValueKind.kt @@ -0,0 +1,31 @@ +/* + * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.types + +sealed class ConstantValueKind(val asString: kotlin.String) { + object Null : ConstantValueKind("Null") + object Boolean : ConstantValueKind("Boolean") + object Char : ConstantValueKind("Char") + + object Byte : ConstantValueKind("Byte") + object UnsignedByte : ConstantValueKind("UByte") + object Short : ConstantValueKind("Short") + object UnsignedShort : ConstantValueKind("UShort") + object Int : ConstantValueKind("Int") + object UnsignedInt : ConstantValueKind("UInt") + object Long : ConstantValueKind("Long") + object UnsignedLong : ConstantValueKind("ULong") + + object String : ConstantValueKind("String") + + object Float : ConstantValueKind("Float") + object Double : ConstantValueKind("Double") + + object IntegerLiteral : ConstantValueKind("IntegerLiteral") + object UnsignedIntegerLiteral : ConstantValueKind("UnsignedIntegerLiteral") + + override fun toString() = asString +}