K2. Minor. Rename FirConstExpression to FirLiteralExpression

FirConstExpression is usually confused with "constant" calculations, while in fact, it just denotes a simple literal expression and `1 + 1` isn't represented by a FirConstExpression. ^KT-64314 Fixed
2024-01-12 18:44:13 +01:00
parent 213967e25c
commit 53e89a9722
105 changed files with 300 additions and 295 deletions
@@ -56,7 +56,7 @@ fun main(args: Array<String>) {
        alias<FirStringConcatenationCall>("StringConcatenationCallChecker")
        alias<FirTypeOperatorCall>("TypeOperatorCallChecker")
        alias<FirResolvedQualifier>("ResolvedQualifierChecker")
-        alias<FirConstExpression<*>>("ConstExpressionChecker")
+        alias<FirLiteralExpression<*>>("LiteralExpressionChecker")
        alias<FirCallableReferenceAccess>("CallableReferenceAccessChecker")
        alias<FirThisReceiverExpression>("ThisReceiverExpressionChecker")
        alias<FirWhileLoop>("WhileLoopChecker")
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.fir.analysis.js.checkers.isExportedObject
 import org.jetbrains.kotlin.fir.analysis.js.checkers.sanitizeName
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.*
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
+import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
 import org.jetbrains.kotlin.fir.isEnumEntries
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
@@ -242,7 +242,7 @@ object FirJsExportDeclarationChecker : FirBasicDeclarationChecker(MppCheckerKind

        val jsNameArgument = declaration.symbol.getAnnotationFirstArgument(JsStandardClassIds.Annotations.JsName, context.session)
        val reportTarget = jsNameArgument?.source ?: declaration.source
-        val name = (jsNameArgument as? FirConstExpression<*>)?.value as? String ?: declaration.nameOrSpecialName.asString()
+        val name = (jsNameArgument as? FirLiteralExpression<*>)?.value as? String ?: declaration.nameOrSpecialName.asString()

        if (name in SPECIAL_KEYWORDS || (name !in RESERVED_KEYWORDS && sanitizeName(name) == name)) {
            return
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.isInline
 import org.jetbrains.kotlin.fir.declarations.utils.isOverridable
 import org.jetbrains.kotlin.fir.declarations.utils.isOverride
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
+import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
 import org.jetbrains.kotlin.fir.java.findJvmNameAnnotation
 import org.jetbrains.kotlin.fir.resolve.getContainingClass
 import org.jetbrains.kotlin.fir.types.resolvedType
@@ -34,7 +34,7 @@ object FirJvmNameChecker : FirBasicDeclarationChecker(MppCheckerKind.Common) {
            return
        }

-        val value = (name as? FirConstExpression<*>)?.value as? String ?: return
+        val value = (name as? FirLiteralExpression<*>)?.value as? String ?: return

        if (!Name.isValidIdentifier(value)) {
            reporter.reportOn(jvmName.source, FirJvmErrors.ILLEGAL_JVM_NAME, context)
@@ -26,7 +26,13 @@ import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.declarations.utils.isOverride
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
+import org.jetbrains.kotlin.fir.expressions.FirAnnotation
+import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.Name

 object FirNativeObjCNameChecker : FirBasicDeclarationChecker(MppCheckerKind.Common) {
    override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
@@ -48,7 +54,7 @@ object FirNativeObjCNameChecker : FirBasicDeclarationChecker(MppCheckerKind.Comm
    private fun checkObjCName(objCName: ObjCName, declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
        val annotationSource = objCName.annotation.source
        for ((_, argument) in objCName.annotation.argumentMapping.mapping) {
-            if (argument is FirConstExpression<*>) continue
+            if (argument is FirLiteralExpression<*>) continue
            reporter.reportOn(argument.source, NON_LITERAL_OBJC_NAME_ARG, context)
        }
        if (objCName.name == null && objCName.swiftName == null) {
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirAnnotationCallCh
 import org.jetbrains.kotlin.fir.analysis.diagnostics.web.common.FirWebCommonErrors
 import org.jetbrains.kotlin.fir.declarations.toAnnotationClassId
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
+import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
 import org.jetbrains.kotlin.js.validateQualifier
 import org.jetbrains.kotlin.name.WebCommonStandardClassIds.Annotations.JsQualifier

@@ -23,7 +23,7 @@ object FirJsQualifierChecker : FirAnnotationCallChecker(MppCheckerKind.Common) {
            return
        }

-        val string = (expression.argumentMapping.mapping.values.firstOrNull() as? FirConstExpression<*>)?.value as? String ?: return
+        val string = (expression.argumentMapping.mapping.values.firstOrNull() as? FirLiteralExpression<*>)?.value as? String ?: return

        if (!validateQualifier(string)) {
            reporter.reportOn(expression.argumentList.arguments.first().source, FirWebCommonErrors.WRONG_JS_QUALIFIER, context)
@@ -65,8 +65,8 @@ class ComposedExpressionCheckers(val predicate: (FirCheckerWithMppKind) -> Boole
        get() = _typeOperatorCallCheckers
    override val resolvedQualifierCheckers: Set<FirResolvedQualifierChecker>
        get() = _resolvedQualifierCheckers
-    override val constExpressionCheckers: Set<FirConstExpressionChecker>
-        get() = _constExpressionCheckers
+    override val literalExpressionCheckers: Set<FirLiteralExpressionChecker>
+        get() = _literalExpressionCheckers
    override val callableReferenceAccessCheckers: Set<FirCallableReferenceAccessChecker>
        get() = _callableReferenceAccessCheckers
    override val thisReceiverExpressionCheckers: Set<FirThisReceiverExpressionChecker>
@@ -108,7 +108,7 @@ class ComposedExpressionCheckers(val predicate: (FirCheckerWithMppKind) -> Boole
    private val _stringConcatenationCallCheckers: MutableSet<FirStringConcatenationCallChecker> = mutableSetOf()
    private val _typeOperatorCallCheckers: MutableSet<FirTypeOperatorCallChecker> = mutableSetOf()
    private val _resolvedQualifierCheckers: MutableSet<FirResolvedQualifierChecker> = mutableSetOf()
-    private val _constExpressionCheckers: MutableSet<FirConstExpressionChecker> = mutableSetOf()
+    private val _literalExpressionCheckers: MutableSet<FirLiteralExpressionChecker> = mutableSetOf()
    private val _callableReferenceAccessCheckers: MutableSet<FirCallableReferenceAccessChecker> = mutableSetOf()
    private val _thisReceiverExpressionCheckers: MutableSet<FirThisReceiverExpressionChecker> = mutableSetOf()
    private val _whileLoopCheckers: MutableSet<FirWhileLoopChecker> = mutableSetOf()
@@ -144,7 +144,7 @@ class ComposedExpressionCheckers(val predicate: (FirCheckerWithMppKind) -> Boole
        checkers.stringConcatenationCallCheckers.filterTo(_stringConcatenationCallCheckers, predicate)
        checkers.typeOperatorCallCheckers.filterTo(_typeOperatorCallCheckers, predicate)
        checkers.resolvedQualifierCheckers.filterTo(_resolvedQualifierCheckers, predicate)
-        checkers.constExpressionCheckers.filterTo(_constExpressionCheckers, predicate)
+        checkers.literalExpressionCheckers.filterTo(_literalExpressionCheckers, predicate)
        checkers.callableReferenceAccessCheckers.filterTo(_callableReferenceAccessCheckers, predicate)
        checkers.thisReceiverExpressionCheckers.filterTo(_thisReceiverExpressionCheckers, predicate)
        checkers.whileLoopCheckers.filterTo(_whileLoopCheckers, predicate)
@@ -41,7 +41,7 @@ abstract class ExpressionCheckers {
    open val stringConcatenationCallCheckers: Set<FirStringConcatenationCallChecker> = emptySet()
    open val typeOperatorCallCheckers: Set<FirTypeOperatorCallChecker> = emptySet()
    open val resolvedQualifierCheckers: Set<FirResolvedQualifierChecker> = emptySet()
-    open val constExpressionCheckers: Set<FirConstExpressionChecker> = emptySet()
+    open val literalExpressionCheckers: Set<FirLiteralExpressionChecker> = emptySet()
    open val callableReferenceAccessCheckers: Set<FirCallableReferenceAccessChecker> = emptySet()
    open val thisReceiverExpressionCheckers: Set<FirThisReceiverExpressionChecker> = emptySet()
    open val whileLoopCheckers: Set<FirWhileLoopChecker> = emptySet()
@@ -75,7 +75,7 @@ abstract class ExpressionCheckers {
    @CheckersComponentInternal internal val allStringConcatenationCallCheckers: Set<FirStringConcatenationCallChecker> by lazy { stringConcatenationCallCheckers + basicExpressionCheckers + callCheckers }
    @CheckersComponentInternal internal val allTypeOperatorCallCheckers: Set<FirTypeOperatorCallChecker> by lazy { typeOperatorCallCheckers + basicExpressionCheckers + callCheckers }
    @CheckersComponentInternal internal val allResolvedQualifierCheckers: Set<FirResolvedQualifierChecker> by lazy { resolvedQualifierCheckers + basicExpressionCheckers }
-    @CheckersComponentInternal internal val allConstExpressionCheckers: Set<FirConstExpressionChecker> by lazy { constExpressionCheckers + basicExpressionCheckers }
+    @CheckersComponentInternal internal val allLiteralExpressionCheckers: Set<FirLiteralExpressionChecker> by lazy { literalExpressionCheckers + basicExpressionCheckers }
    @CheckersComponentInternal internal val allCallableReferenceAccessCheckers: Set<FirCallableReferenceAccessChecker> by lazy { callableReferenceAccessCheckers + qualifiedAccessExpressionCheckers + basicExpressionCheckers }
    @CheckersComponentInternal internal val allThisReceiverExpressionCheckers: Set<FirThisReceiverExpressionChecker> by lazy { thisReceiverExpressionCheckers + qualifiedAccessExpressionCheckers + basicExpressionCheckers }
    @CheckersComponentInternal internal val allWhileLoopCheckers: Set<FirWhileLoopChecker> by lazy { whileLoopCheckers + loopExpressionCheckers + basicExpressionCheckers }
@@ -19,7 +19,6 @@ import org.jetbrains.kotlin.fir.expressions.FirCall
 import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess
 import org.jetbrains.kotlin.fir.expressions.FirCheckNotNullCall
 import org.jetbrains.kotlin.fir.expressions.FirClassReferenceExpression
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
 import org.jetbrains.kotlin.fir.expressions.FirDoWhileLoop
 import org.jetbrains.kotlin.fir.expressions.FirElvisExpression
 import org.jetbrains.kotlin.fir.expressions.FirEqualityOperatorCall
@@ -27,6 +26,7 @@ import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
 import org.jetbrains.kotlin.fir.expressions.FirGetClassCall
 import org.jetbrains.kotlin.fir.expressions.FirInaccessibleReceiverExpression
 import org.jetbrains.kotlin.fir.expressions.FirIntegerLiteralOperatorCall
+import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
 import org.jetbrains.kotlin.fir.expressions.FirLoop
 import org.jetbrains.kotlin.fir.expressions.FirLoopJump
 import org.jetbrains.kotlin.fir.expressions.FirPropertyAccessExpression
@@ -68,7 +68,7 @@ typealias FirEqualityOperatorCallChecker = FirExpressionChecker<FirEqualityOpera
 typealias FirStringConcatenationCallChecker = FirExpressionChecker<FirStringConcatenationCall>
 typealias FirTypeOperatorCallChecker = FirExpressionChecker<FirTypeOperatorCall>
 typealias FirResolvedQualifierChecker = FirExpressionChecker<FirResolvedQualifier>
-typealias FirConstExpressionChecker = FirExpressionChecker<FirConstExpression<*>>
+typealias FirLiteralExpressionChecker = FirExpressionChecker<FirLiteralExpression<*>>
 typealias FirCallableReferenceAccessChecker = FirExpressionChecker<FirCallableReferenceAccess>
 typealias FirThisReceiverExpressionChecker = FirExpressionChecker<FirThisReceiverExpression>
 typealias FirWhileLoopChecker = FirExpressionChecker<FirWhileLoop>
@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.contracts.effects
 import org.jetbrains.kotlin.fir.declarations.FirContractDescriptionOwner
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirProperty
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
+import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirReturnExpression
 import org.jetbrains.kotlin.fir.expressions.FirWhenExpression
@@ -111,7 +111,7 @@ object FirReturnsImpliesAnalyzer : FirControlFlowChecker(MppCheckerKind.Common)
        var flow = node.flow
        val operation = effect.value.toOperation()
        if (operation != null) {
-            if (resultExpression is FirConstExpression<*>) {
+            if (resultExpression is FirLiteralExpression<*>) {
                if (!operation.isTrueFor(resultExpression.value)) return false
            } else {
                if (expressionType != null && !operation.canBeTrueFor(context.session, expressionType)) return false
@@ -119,7 +119,7 @@ private class FirConstCheckVisitor(private val session: FirSession) : FirVisitor
        return if (intrinsicConstEvaluation) ConstantArgumentKind.VALID_CONST else ConstantArgumentKind.NOT_CONST
    }

-    override fun <T> visitConstExpression(constExpression: FirConstExpression<T>, data: Nothing?): ConstantArgumentKind {
+    override fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>, data: Nothing?): ConstantArgumentKind {
        return ConstantArgumentKind.VALID_CONST
    }

@@ -143,7 +143,7 @@ private class FirConstCheckVisitor(private val session: FirSession) : FirVisitor
        }

        for (exp in equalityOperatorCall.arguments) {
-            if (exp is FirConstExpression<*> && exp.value == null) {
+            if (exp is FirLiteralExpression<*> && exp.value == null) {
                return ConstantArgumentKind.NOT_CONST
            }

@@ -219,7 +219,7 @@ private class FirConstCheckVisitor(private val session: FirSession) : FirVisitor
                // Ok, because we only look at the structure, not resolution-dependent properties.
                @OptIn(SymbolInternals::class)
                return when (propertySymbol.fir.initializer) {
-                    is FirConstExpression<*> -> when {
+                    is FirLiteralExpression<*> -> when {
                        propertySymbol.isVal -> ConstantArgumentKind.NOT_CONST_VAL_IN_CONST_EXPRESSION
                        else -> ConstantArgumentKind.NOT_CONST
                    }
@@ -792,7 +792,7 @@ fun FirBasedSymbol<*>.getAnnotationFirstArgument(classId: ClassId, session: FirS
 }

 fun FirBasedSymbol<*>.getAnnotationStringParameter(classId: ClassId, session: FirSession): String? {
-    val expression = getAnnotationFirstArgument(classId, session) as? FirConstExpression<*>
+    val expression = getAnnotationFirstArgument(classId, session) as? FirLiteralExpression<*>
    return expression?.value as? String
 }

@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.config.ApiVersion
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
+import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
 import org.jetbrains.kotlin.fir.languageVersionSettings
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.name.StandardClassIds
@@ -56,7 +56,7 @@ private fun FirDeclaration.getOwnSinceKotlinVersion(session: FirSession): FirSin
    val sinceKotlinSingleArgument = getAnnotationByClassId(StandardClassIds.Annotations.SinceKotlin, session)?.findArgumentByName(
        StandardClassIds.Annotations.ParameterNames.sinceKotlinVersion
    )
-    val apiVersion = ((sinceKotlinSingleArgument as? FirConstExpression<*>)?.value as? String)?.let(ApiVersion.Companion::parse)
+    val apiVersion = ((sinceKotlinSingleArgument as? FirLiteralExpression<*>)?.value as? String)?.let(ApiVersion.Companion::parse)
    return if (apiVersion != null) {
        FirSinceKotlinValue(apiVersion, loadWasExperimentalMarkerClasses(session))
    } else null
@@ -456,7 +456,7 @@ object FirInlineDeclarationChecker : FirFunctionChecker(MppCheckerKind.Common) {
                expression is FirFunctionCall ||
                expression is FirLambdaArgumentExpression ||
                expression is FirAnonymousFunctionExpression ||
-                (expression is FirConstExpression<*> && expression.value == null) //this will be reported separately
+                (expression is FirLiteralExpression<*> && expression.value == null) //this will be reported separately

    fun checkCallableDeclaration(declaration: FirCallableDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
        if (declaration is FirPropertyAccessor) return
@@ -123,8 +123,8 @@ object FirAnnotationExpressionChecker : FirAnnotationCallChecker(MppCheckerKind.
        context: CheckerContext,
        reporter: DiagnosticReporter
    ): ApiVersion? {
-        val constantExpression = (expression as? FirConstExpression<*>)
-            ?: ((expression as? FirNamedArgumentExpression)?.expression as? FirConstExpression<*>) ?: return null
+        val constantExpression = (expression as? FirLiteralExpression<*>)
+            ?: ((expression as? FirNamedArgumentExpression)?.expression as? FirLiteralExpression<*>) ?: return null
        val stringValue = constantExpression.value as? String ?: return null
        if (!stringValue.matches(RequireKotlinConstants.VERSION_REGEX)) {
            reporter.reportOn(expression.source, FirErrors.ILLEGAL_KOTLIN_VERSION_STRING_VALUE, context)
@@ -242,7 +242,7 @@ object FirAnnotationExpressionChecker : FirAnnotationCallChecker(MppCheckerKind.
        if (annotationClassId != StandardClassIds.Annotations.Suppress) return
        val nameExpressions = argumentMapping[StandardClassIds.Annotations.ParameterNames.suppressNames]?.unwrapVarargValue() ?: return
        for (nameExpression in nameExpressions) {
-            val name = (nameExpression as? FirConstExpression<*>)?.value as? String ?: continue
+            val name = (nameExpression as? FirLiteralExpression<*>)?.value as? String ?: continue
            val parameter = when (name) {
                in FIR_NON_SUPPRESSIBLE_ERROR_NAMES -> name
                AbstractDiagnosticCollector.SUPPRESS_ALL_ERRORS -> "all errors"
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.analysis.checkers.MppCheckerKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
+import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
 import org.jetbrains.kotlin.fir.expressions.arguments
 import org.jetbrains.kotlin.fir.references.toResolvedNamedFunctionSymbol
@@ -22,7 +22,7 @@ object FirDivisionByZeroChecker : FirFunctionCallChecker(MppCheckerKind.Common)
    private val defaultDivName = Name.identifier("div")

    override fun check(expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter) {
-        val firstValue = (expression.arguments.singleOrNull() as? FirConstExpression<*>)?.value
+        val firstValue = (expression.arguments.singleOrNull() as? FirLiteralExpression<*>)?.value
        if (firstValue != null && (firstValue == 0L || firstValue == 0.0f || firstValue == 0.0)) {
            val callableId = (expression.calleeReference.toResolvedNamedFunctionSymbol())?.callableId
            if (callableId != null && callableId.packageName == defaultPackageName && callableId.callableName == defaultDivName) {
@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.correspondingValueParameterFromPrimaryConstructor
 import org.jetbrains.kotlin.fir.declarations.utils.isData
 import org.jetbrains.kotlin.fir.declarations.utils.nameOrSpecialName
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
+import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
 import org.jetbrains.kotlin.fir.expressions.toReference
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.references.FirNamedReference
@@ -281,7 +281,7 @@ object FirOptInUsageBaseChecker {
        val levelName = levelArgument?.extractEnumValueArgumentInfo()?.enumEntryName?.asString()

        val severity = Experimentality.Severity.entries.firstOrNull { it.name == levelName } ?: Experimentality.DEFAULT_SEVERITY
-        val message = (experimental.findArgumentByName(MESSAGE) as? FirConstExpression<*>)?.value as? String
+        val message = (experimental.findArgumentByName(MESSAGE) as? FirLiteralExpression<*>)?.value as? String
        return Experimentality(symbol.classId, severity, message, annotatedOwnerClassName)
    }

@@ -42,7 +42,7 @@ object FirWhenConditionChecker : FirWhenExpressionChecker(MppCheckerKind.Common)
                    val arguments = condition.arguments
                    if (arguments.size == 2 && arguments[0].unwrapSmartcastExpression() is FirWhenSubjectExpression) {
                        val value = when (val targetExpression = arguments[1]) {
-                            is FirConstExpression<*> -> targetExpression.value
+                            is FirLiteralExpression<*> -> targetExpression.value
                            is FirQualifiedAccessExpression -> targetExpression.calleeReference.toResolvedCallableSymbol() as? FirEnumEntrySymbol
                                ?: continue
                            is FirResolvedQualifier -> {
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.MppCheckerKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirFunctionCallChecker
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
+import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCall

 object EmptyRangeChecker : FirFunctionCallChecker(MppCheckerKind.Common) {
@@ -41,12 +41,12 @@ object EmptyRangeChecker : FirFunctionCallChecker(MppCheckerKind.Common) {

    private val FirFunctionCall.rangeLeft: Long?
        get() {
-            return (explicitReceiver as? FirConstExpression<*>)?.value as? Long
+            return (explicitReceiver as? FirLiteralExpression<*>)?.value as? Long
        }

    private val FirFunctionCall.rangeRight: Long?
        get() {
-            val arg = argumentList.arguments.getOrNull(0) as? FirConstExpression<*>
+            val arg = argumentList.arguments.getOrNull(0) as? FirLiteralExpression<*>
            return arg?.value as? Long
        }
 }
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.MppCheckerKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirQualifiedAccessExpressionChecker
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
+import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
@@ -38,7 +38,7 @@ object RedundantCallOfConversionMethod : FirQualifiedAccessExpressionChecker(Mpp
    }

    private fun FirExpression.isRedundant(qualifiedClassId: ClassId, session: FirSession): Boolean {
-        val thisType = if (this is FirConstExpression<*>) {
+        val thisType = if (this is FirLiteralExpression<*>) {
            this.resolvedType.classId
        } else {
            when {
@@ -38,7 +38,7 @@ object RedundantExplicitTypeChecker : FirPropertyChecker(MppCheckerKind.Common)
        if (typeReference.annotations.isNotEmpty()) return

        when (initializer) {
-            is FirConstExpression<*> -> {
+            is FirLiteralExpression<*> -> {
                when (initializer.source?.elementType) {
                    KtNodeTypes.BOOLEAN_CONSTANT -> {
                        if (!type.isSame(StandardClassIds.Boolean)) return
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.MppCheckerKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.declarations.getAnnotationByClassId
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
+import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.customAnnotations
@@ -26,7 +26,7 @@ object FirDuplicateParameterNameInFunctionTypeChecker : FirTypeRefChecker(MppChe
            val type = it.type ?: return@groupBy null
            val annotation = type.customAnnotations.getAnnotationByClassId(StandardNames.FqNames.parameterNameClassId, context.session)
            val nameEntry = annotation?.argumentMapping?.mapping?.get(StandardNames.NAME)
-            (nameEntry as? FirConstExpression<*>)?.value as? String
+            (nameEntry as? FirLiteralExpression<*>)?.value as? String
        }

        for ((name, projections) in nameToArgumentProjection) {
@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.findArgumentByName
 import org.jetbrains.kotlin.fir.declarations.unwrapVarargValue
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
+import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.SessionHolder
 import org.jetbrains.kotlin.fir.symbols.lazyDeclarationResolver
@@ -60,7 +60,7 @@ abstract class AbstractDiagnosticCollector(
                        ?: continue

                for (argumentValue in argumentValues) {
-                    val value = (argumentValue as? FirConstExpression<*>)?.value as? String ?: continue
+                    val value = (argumentValue as? FirLiteralExpression<*>)?.value as? String ?: continue

                    if (result == null) {
                        result = mutableListOf()
@@ -46,8 +46,8 @@ class ExpressionCheckersDiagnosticComponent(
        checkers.allTypeOperatorCallCheckers.check(typeOperatorCall, data)
    }

-    override fun <T> visitConstExpression(constExpression: FirConstExpression<T>, data: CheckerContext) {
-        checkers.allConstExpressionCheckers.check(constExpression, data)
+    override fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>, data: CheckerContext) {
+        checkers.allLiteralExpressionCheckers.check(literalExpression, data)
    }

    override fun visitAnnotation(annotation: FirAnnotation, data: CheckerContext) {