azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rename FirConstKind to ConstantValueKind and move it to compiler.common

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