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.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
}
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.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
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.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()
+">"
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.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 <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
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
}
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.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<ConstantValue<
): ConstantValue<*>? {
val value = constExpression.value
return when (constExpression.kind) {
FirConstKind.Boolean -> BooleanValue(value as Boolean)
FirConstKind.Char -> CharValue(value as Char)
FirConstKind.Byte -> ByteValue(value as Byte)
FirConstKind.UnsignedByte -> UByteValue(value as Byte)
FirConstKind.Short -> ShortValue(value as Short)
FirConstKind.UnsignedShort -> UShortValue(value as Short)
FirConstKind.Int -> IntValue(value as Int)
FirConstKind.UnsignedInt -> UIntValue(value as Int)
FirConstKind.Long -> LongValue(value as Long)
FirConstKind.UnsignedLong -> ULongValue(value as Long)
FirConstKind.String -> StringValue(value as String)
FirConstKind.Float -> FloatValue(value as Float)
FirConstKind.Double -> DoubleValue(value as Double)
FirConstKind.Null -> NullValue
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
}
}
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.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<ConeIntegerLiteralType>()
type.getApproximatedType().toConstKind()!!.toIrConstKind()
}
@@ -194,25 +194,25 @@ fun <T> FirConstExpression<T>.toIrConst(irType: IrType): IrConst<T> {
}
}
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()
}
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.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 <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 {
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
}
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.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
}
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.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
}
}
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.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<FirExpression>(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 {
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.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 {
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.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<T>(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<T>(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<T>(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<T>(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<T>(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())
}
}
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.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 {
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.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<FLOW : Flow>(
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<FLOW : Flow>(
}
// 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<FLOW : Flow>(
}
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)
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.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<FirExpression?, Map<Int, FirExpression>>() {
@@ -21,8 +22,8 @@ private object ConeConditionalEffectToFirVisitor : ConeContractDescriptionVisito
override fun visitConstantDescriptor(constantReference: ConeConstantReference, data: Map<Int, FirExpression>): 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<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.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<ConeK
val approximatedType = type.getApproximatedType(data)
constExpression.resultType = constExpression.resultType.resolvedTypeFromPrototype(approximatedType)
@Suppress("UNCHECKED_CAST")
val kind = approximatedType.toConstKind() as FirConstKind<T>
val kind = approximatedType.toConstKind() as ConstantValueKind<T>
constExpression.replaceKind(kind)
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.buildResolvedTypeRef
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.types.ConstantValueKind
inline fun <reified T : FirElement> 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)
}
}
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.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<T>)
constExpression.replaceKind(newConstKind as ConstantValueKind<T>)
approximatedType
} else {
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.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 <T> visitConstExpression(constExpression: FirConstExpression<T>, 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
}
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.types.FirTypeRef
import org.jetbrains.kotlin.types.ConstantValueKind
import org.jetbrains.kotlin.fir.visitors.*
/*
@@ -18,14 +19,14 @@ abstract class FirConstExpression<T> : FirExpression() {
abstract override val source: FirSourceElement?
abstract override val typeRef: FirTypeRef
abstract override val annotations: List<FirAnnotationCall>
abstract val kind: FirConstKind<T>
abstract val kind: ConstantValueKind<T>
abstract val value: T
override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitConstExpression(this, data)
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>
}
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.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<T> (
override val source: FirSourceElement?,
override val annotations: MutableList<FirAnnotationCall>,
override var kind: FirConstKind<T>,
override var kind: ConstantValueKind<T>,
override val value: T,
) : FirConstExpression<T>() {
override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(null)
@@ -46,7 +46,7 @@ internal class FirConstExpressionImpl<T> (
typeRef = newTypeRef
}
override fun replaceKind(newKind: FirConstKind<T>) {
override fun replaceKind(newKind: ConstantValueKind<T>) {
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.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 <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 {
buildConstExpression(source, kind, it)
} ?: 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.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 <T> buildConstExpression(
source: FirSourceElement?,
kind: FirConstKind<T>,
kind: ConstantValueKind<T>,
value: T,
annotations: MutableList<FirAnnotationCall> = mutableListOf(),
): 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
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<FirAnnotationCall>.dropExtensionFunctionAnnotation(): List<FirAnnotatio
return filterNot { it.isExtensionFunctionAnnotationCall }
}
fun ConeClassLikeType.toConstKind(): FirConstKind<*>? = 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
}
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 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)
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.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<Pair<String, MutableList<String>>>
@@ -444,7 +445,7 @@ class FirVisualizer(private val firFile: FirFile) : BaseRenderer() {
}
override fun <T> visitConstExpression(constExpression: FirConstExpression<T>, data: StringBuilder) {
if (constExpression.kind != FirConstKind.String) {
if (constExpression.kind != ConstantValueKind.String) {
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
}