Rename FirConstKind to ConstantValueKind and move it to compiler.common

2021-01-11 13:53:23 +01:00
parent eed27906e3
commit d24331955e
29 changed files with 227 additions and 204 deletions
@@ -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)
@@ -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? {
@@ -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()
    }
@@ -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)
    }
 }
@@ -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
@@ -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
            }