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

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/evaluate/FirAnnotationValueConverter.kt

@@ -42,7 +42,7 @@ internal object FirAnnotationValueConverter {
         )
     }
 
-    private fun <T> FirConstExpression<T>.convertConstantExpression(): KtConstantAnnotationValue? {
+    private fun <T> FirLiteralExpression<T>.convertConstantExpression(): KtConstantAnnotationValue? {
         val expression = psi as? KtElement
 
         @OptIn(UnresolvedExpressionTypeAccess::class)
@@ -98,7 +98,7 @@ internal object FirAnnotationValueConverter {
     private fun FirExpression.convertConstantExpression(builder: KtSymbolByFirBuilder): KtAnnotationValue? {
         val sourcePsi = psi as? KtElement
         return when (this) {
-            is FirConstExpression<*> -> convertConstantExpression()
+            is FirLiteralExpression<*> -> convertConstantExpression()
             is FirNamedArgumentExpression -> {
                 expression.convertConstantExpression(builder)
             }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/evaluate/FirCompileTimeConstantEvaluator.kt

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.declarations.utils.isConst
 import org.jetbrains.kotlin.fir.declarations.utils.isFinal
 import org.jetbrains.kotlin.fir.declarations.utils.isStatic
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression
+import org.jetbrains.kotlin.fir.expressions.builder.buildLiteralExpression
 import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.references.FirNamedReference
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
@@ -45,7 +45,7 @@ internal object FirCompileTimeConstantEvaluator {
     fun evaluate(
         fir: FirElement?,
         mode: KtConstantEvaluationMode,
-    ): FirConstExpression<*>? =
+    ): FirLiteralExpression<*>? =
         when (fir) {
             is FirPropertyAccessExpression -> {
                 when (val referredVariable = fir.calleeReference.toResolvedVariableSymbol()) {
@@ -53,14 +53,14 @@ internal object FirCompileTimeConstantEvaluator {
                         if (referredVariable.callableId.isStringLength) {
                             evaluate(fir.explicitReceiver, mode)?.evaluateStringLength()
                         } else {
-                            referredVariable.toConstExpression(mode)
+                            referredVariable.toLiteralExpression(mode)
                         }
                     }
-                    is FirFieldSymbol -> referredVariable.toConstExpression(mode)
+                    is FirFieldSymbol -> referredVariable.toLiteralExpression(mode)
                     else -> null
                 }
             }
-            is FirConstExpression<*> -> {
+            is FirLiteralExpression<*> -> {
                 fir.adaptToConstKind()
             }
             is FirFunctionCall -> {
@@ -70,7 +70,7 @@ internal object FirCompileTimeConstantEvaluator {
                 evaluateStringConcatenationCall(fir, mode)
             }
             is FirNamedReference -> {
-                fir.toResolvedPropertySymbol()?.toConstExpression(mode)
+                fir.toResolvedPropertySymbol()?.toLiteralExpression(mode)
             }
             else -> null
         }
@@ -78,9 +78,9 @@ internal object FirCompileTimeConstantEvaluator {
     private val CallableId.isStringLength: Boolean
         get() = classId == StandardClassIds.String && callableName.identifierOrNullIfSpecial == "length"
 
-    private fun FirPropertySymbol.toConstExpression(
+    private fun FirPropertySymbol.toLiteralExpression(
         mode: KtConstantEvaluationMode,
-    ): FirConstExpression<*>? {
+    ): FirLiteralExpression<*>? {
         return when {
             mode == KtConstantEvaluationMode.CONSTANT_EXPRESSION_EVALUATION && !isConst -> null
             isVal && hasInitializer -> {
@@ -92,9 +92,9 @@ internal object FirCompileTimeConstantEvaluator {
         }
     }
 
-    private fun FirFieldSymbol.toConstExpression(
+    private fun FirFieldSymbol.toLiteralExpression(
         mode: KtConstantEvaluationMode,
-    ): FirConstExpression<*>? {
+    ): FirLiteralExpression<*>? {
         return when {
             mode == KtConstantEvaluationMode.CONSTANT_EXPRESSION_EVALUATION && !(isStatic && isFinal) -> null
             isVal && hasInitializer -> {
@@ -148,8 +148,8 @@ internal object FirCompileTimeConstantEvaluator {
         }
     }
 
-    private fun FirConstExpression<*>.adaptToConstKind(): FirConstExpression<*> {
+    private fun FirLiteralExpression<*>.adaptToConstKind(): FirLiteralExpression<*> {
-        return kind.toConstExpression(
+        return kind.toLiteralExpression(
             source,
             kind.convertToNumber(value as? Number) ?: value
         )
@@ -158,7 +158,7 @@ internal object FirCompileTimeConstantEvaluator {
     private fun evaluateStringConcatenationCall(
         stringConcatenationCall: FirStringConcatenationCall,
         mode: KtConstantEvaluationMode,
-    ): FirConstExpression<String>? {
+    ): FirLiteralExpression<String>? {
         val concatenated = buildString {
             for (arg in stringConcatenationCall.arguments) {
                 val evaluated = evaluate(arg, mode) ?: return null
@@ -166,13 +166,13 @@ internal object FirCompileTimeConstantEvaluator {
             }
         }
 
-        return ConstantValueKind.String.toConstExpression(stringConcatenationCall.source, concatenated)
+        return ConstantValueKind.String.toLiteralExpression(stringConcatenationCall.source, concatenated)
     }
 
     private fun evaluateFunctionCall(
         functionCall: FirFunctionCall,
         mode: KtConstantEvaluationMode,
-    ): FirConstExpression<*>? {
+    ): FirLiteralExpression<*>? {
         val function = functionCall.getOriginalFunction() as? FirSimpleFunction ?: return null
 
         val opr1 = evaluate(functionCall.explicitReceiver, mode) ?: return null
@@ -188,7 +188,7 @@ internal object FirCompileTimeConstantEvaluator {
         return null
     }
 
-    private fun FirConstExpression<*>.adjustType(expectedType: ConeKotlinType): FirConstExpression<*> {
+    private fun FirLiteralExpression<*>.adjustType(expectedType: ConeKotlinType): FirLiteralExpression<*> {
         val expectedKind = expectedType.toConstantValueKind()
         // Note that the resolved type for the const expression is not always matched with the const kind. For example,
         //   fun foo(x: Int) {
@@ -200,7 +200,7 @@ internal object FirCompileTimeConstantEvaluator {
         val expression =
             if (expectedKind != null && expectedKind != kind && value is Number) {
                 val typeAdjustedValue = expectedKind.convertToNumber(value as Number)!!
-                expectedKind.toConstExpression(source, typeAdjustedValue)
+                expectedKind.toLiteralExpression(source, typeAdjustedValue)
             } else {
                 this
             }
@@ -227,7 +227,7 @@ internal object FirCompileTimeConstantEvaluator {
     }
 
     // Unary operators
-    private fun FirConstExpression<*>.evaluate(function: FirSimpleFunction): FirConstExpression<*>? {
+    private fun FirLiteralExpression<*>.evaluate(function: FirSimpleFunction): FirLiteralExpression<*>? {
         if (value == null) return null
         (value as? String)?.let { opr ->
             evalUnaryOp(
@@ -235,7 +235,7 @@ internal object FirCompileTimeConstantEvaluator {
                 kind.toCompileTimeType(),
                 opr
             )?.let {
-                return it.toConstantValueKind().toConstExpression(source, it)
+                return it.toConstantValueKind().toLiteralExpression(source, it)
             }
         }
         return kind.convertToNumber(value as? Number)?.let { opr ->
@@ -244,22 +244,22 @@ internal object FirCompileTimeConstantEvaluator {
                 kind.toCompileTimeType(),
                 opr
             )?.let {
-                it.toConstantValueKind().toConstExpression(source, it)
+                it.toConstantValueKind().toLiteralExpression(source, it)
             }
         }
     }
 
-    private fun FirConstExpression<*>.evaluateStringLength(): FirConstExpression<*>? {
+    private fun FirLiteralExpression<*>.evaluateStringLength(): FirLiteralExpression<*>? {
         return (value as? String)?.length?.let {
-            it.toConstantValueKind().toConstExpression(source, it)
+            it.toConstantValueKind().toLiteralExpression(source, it)
         }
     }
 
     // Binary operators
-    private fun FirConstExpression<*>.evaluate(
+    private fun FirLiteralExpression<*>.evaluate(
         function: FirSimpleFunction,
-        other: FirConstExpression<*>
+        other: FirLiteralExpression<*>
-    ): FirConstExpression<*>? {
+    ): FirLiteralExpression<*>? {
         if (value == null || other.value == null) return null
         // NB: some utils accept very general types, and due to the way operation map works, we should up-cast rhs type.
         val rightType = when {
@@ -276,7 +276,7 @@ internal object FirCompileTimeConstantEvaluator {
                     rightType,
                     opr2
                 )?.let {
-                    return it.toConstantValueKind().toConstExpression(source, it)
+                    return it.toConstantValueKind().toLiteralExpression(source, it)
                 }
             }
         }
@@ -289,7 +289,7 @@ internal object FirCompileTimeConstantEvaluator {
                     other.kind.toCompileTimeType(),
                     opr2
                 )?.let {
-                    it.toConstantValueKind().toConstExpression(source, it)
+                    it.toConstantValueKind().toLiteralExpression(source, it)
                 }
             }
         }
@@ -367,9 +367,9 @@ internal object FirCompileTimeConstantEvaluator {
         }
     }
 
-    private fun <T> ConstantValueKind<T>.toConstExpression(source: KtSourceElement?, value: Any?): FirConstExpression<T> =
+    private fun <T> ConstantValueKind<T>.toLiteralExpression(source: KtSourceElement?, value: Any?): FirLiteralExpression<T> =
         @Suppress("UNCHECKED_CAST")
-        buildConstExpression(source, this, value as T, setType = false)
+        buildLiteralExpression(source, this, value as T, setType = false)
 
     private fun FirFunctionCall.getOriginalFunction(): FirCallableDeclaration? {
         val symbol: FirBasedSymbol<*>? = when (val reference = calleeReference) {

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/file/structure/FirElementsRecorder.kt

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.builder.toFirOperationOrNull
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression
+import org.jetbrains.kotlin.fir.expressions.builder.buildLiteralExpression
 import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.references.*
 import org.jetbrains.kotlin.fir.types.*
@@ -77,16 +77,16 @@ internal open class FirElementsRecorder : FirVisitor<Unit, MutableMap<KtElement,
         visitElement(variableAssignment, data)
     }
 
-    override fun <T> visitConstExpression(constExpression: FirConstExpression<T>, data: MutableMap<KtElement, FirElement>) {
+    override fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>, data: MutableMap<KtElement, FirElement>) {
-        cacheElement(constExpression, data)
+        cacheElement(literalExpression, data)
-        constExpression.annotations.forEach {
+        literalExpression.annotations.forEach {
             it.accept(this, data)
         }
-        // KtPrefixExpression(-, KtConstExpression(n)) is represented as FirConstExpression(-n) with converted constant value.
+        // KtPrefixExpression(-, KtConstExpression(n)) is represented as FirLiteralExpression(-n) with converted constant value.
-        // If one queries FIR for KtConstExpression, we still return FirConstExpression(-n) even though its source is KtPrefixExpression.
+        // If one queries FIR for KtConstExpression, we still return FirLiteralExpression(-n) even though its source is KtPrefixExpression.
-        // Here, we cache FirConstExpression(n) for KtConstExpression(n) to make everything natural and intuitive!
+        // Here, we cache FirLiteralExpression(n) for KtConstExpression(n) to make everything natural and intuitive!
-        if (constExpression.isConverted) {
+        if (literalExpression.isConverted) {
-            constExpression.kind.reverseConverted(constExpression)?.let { cacheElement(it, data) }
+            literalExpression.kind.reverseConverted(literalExpression)?.let { cacheElement(it, data) }
         }
     }
 
@@ -192,19 +192,19 @@ internal open class FirElementsRecorder : FirVisitor<Unit, MutableMap<KtElement,
         return FirOperationNameConventions.ASSIGNMENTS[firOperation]
     }
 
-    private val FirConstExpression<*>.isConverted: Boolean
+    private val FirLiteralExpression<*>.isConverted: Boolean
         get() {
             val firSourcePsi = this.source?.psi ?: return false
             return firSourcePsi is KtPrefixExpression && firSourcePsi.operationToken == KtTokens.MINUS
         }
 
-    private val FirConstExpression<*>.ktConstantExpression: KtConstantExpression?
+    private val FirLiteralExpression<*>.ktConstantExpression: KtConstantExpression?
         get() {
             val firSourcePsi = this.source?.psi
             return firSourcePsi?.findDescendantOfType()
         }
 
-    private fun <T> ConstantValueKind<T>.reverseConverted(original: FirConstExpression<T>): FirConstExpression<T>? {
+    private fun <T> ConstantValueKind<T>.reverseConverted(original: FirLiteralExpression<T>): FirLiteralExpression<T>? {
         val value = original.value as? Number ?: return null
         val convertedValue = when (this) {
             ConstantValueKind.Byte -> value.toByte().unaryMinus()
@@ -216,7 +216,7 @@ internal open class FirElementsRecorder : FirVisitor<Unit, MutableMap<KtElement,
             else -> null
         } ?: return null
         @Suppress("UNCHECKED_CAST")
-        return buildConstExpression(
+        return buildLiteralExpression(
             original.ktConstantExpression?.toKtPsiSourceElement(),
             this,
             convertedValue as T,

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/FirLazyBodiesCalculator.kt

@@ -320,7 +320,7 @@ private fun rebindThisRef(
     oldTarget: FirPropertySymbol,
     canHavePropertySymbolAsThisReference: Boolean,
 ) {
-    if (expression is FirConstExpression<*>) return
+    if (expression is FirLiteralExpression<*>) return
 
     requireWithAttachment(
         expression is FirThisReceiverExpression,

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/stubBased/deserialization/StubBasedAnnotationDeserializer.kt

@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.collectEnumEntries
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
-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.buildUnaryArgumentList
 import org.jetbrains.kotlin.fir.expressions.builder.*
@@ -198,8 +198,8 @@ class StubBasedAnnotationDeserializer(
         value: T,
         typeRef: FirResolvedTypeRef,
         sourceElement: PsiElement
-    ): FirConstExpression<T> {
+    ): FirLiteralExpression<T> {
-        return buildConstExpression(
+        return buildLiteralExpression(
             KtRealPsiSourceElement(sourceElement),
             kind,
             value,

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/stubBased/deserialization/StubBasedFirTypeDeserializer.kt

@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
 import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotation
 import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotationArgumentMapping
-import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression
+import org.jetbrains.kotlin.fir.expressions.builder.buildLiteralExpression
 import org.jetbrains.kotlin.fir.symbols.*
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
@@ -121,7 +121,7 @@ internal class StubBasedFirTypeDeserializer(
                     }
                     this.argumentMapping = buildAnnotationArgumentMapping {
                         mapping[StandardNames.NAME] =
-                            buildConstExpression(null, ConstantValueKind.String, paramName, setType = true)
+                            buildLiteralExpression(null, ConstantValueKind.String, paramName, setType = true)
                     }
                 }
             }

analysis/low-level-api-fir/testData/getOrBuildFir/annotations/annotationApplicationArgument.txt

@@ -1,5 +1,5 @@
 KT element: KtValueArgument
-FIR element: FirConstExpressionImpl
+FIR element: FirLiteralExpressionImpl
 FIR source kind: KtRealSourceElementKind
 
 FIR element rendered:

analysis/low-level-api-fir/testData/getOrBuildFir/annotations/annotationApplicationArgumentOnStatement.txt

@@ -1,5 +1,5 @@
 KT element: KtValueArgument
-FIR element: FirConstExpressionImpl
+FIR element: FirLiteralExpressionImpl
 FIR source kind: KtRealSourceElementKind
 
 FIR element rendered:

analysis/low-level-api-fir/testData/getOrBuildFir/annotations/annotationApplicationArgumentScript.txt

@@ -1,5 +1,5 @@
 KT element: KtValueArgument
-FIR element: FirConstExpressionImpl
+FIR element: FirLiteralExpressionImpl
 FIR source kind: KtRealSourceElementKind
 
 FIR element rendered:

analysis/low-level-api-fir/testData/getOrBuildFir/annotations/annotationApplicationVarargArgument.txt

@@ -1,5 +1,5 @@
 KT element: KtValueArgument
-FIR element: FirConstExpressionImpl
+FIR element: FirLiteralExpressionImpl
 FIR source kind: KtRealSourceElementKind
 
 FIR element rendered:

analysis/low-level-api-fir/testData/getOrBuildFir/annotations/typeOnAnnotationOnConstructorParameterExpression.txt

@@ -1,5 +1,5 @@
 KT element: KtStringTemplateExpression
-FIR element: FirConstExpressionImpl
+FIR element: FirLiteralExpressionImpl
 FIR source kind: KtRealSourceElementKind
 
 FIR element rendered:

analysis/low-level-api-fir/testData/getOrBuildFir/annotations/typeOnAnnotationOnConstructorParameterExpressionScript.txt

@@ -1,5 +1,5 @@
 KT element: KtStringTemplateExpression
-FIR element: FirConstExpressionImpl
+FIR element: FirLiteralExpressionImpl
 FIR source kind: KtRealSourceElementKind
 
 FIR element rendered:

analysis/low-level-api-fir/testData/getOrBuildFir/calls/callArgument.txt

@@ -1,5 +1,5 @@
 KT element: KtValueArgument
-FIR element: FirConstExpressionImpl
+FIR element: FirLiteralExpressionImpl
 FIR source kind: KtRealSourceElementKind
 
 FIR element rendered:

analysis/low-level-api-fir/testData/getOrBuildFir/calls/callArgumentScript.txt

@@ -1,5 +1,5 @@
 KT element: KtValueArgument
-FIR element: FirConstExpressionImpl
+FIR element: FirLiteralExpressionImpl
 FIR source kind: KtRealSourceElementKind
 
 FIR element rendered:

analysis/low-level-api-fir/testData/getOrBuildFir/expressions/arrayIndexExpressionWithInc.out_of_src_roots.txt

@@ -1,5 +1,5 @@
 KT element: KtConstantExpression
-FIR element: FirConstExpressionImpl
+FIR element: FirLiteralExpressionImpl
 FIR source kind: KtRealSourceElementKind
 
 FIR element rendered:

analysis/low-level-api-fir/testData/getOrBuildFir/expressions/arrayIndexExpressionWithInc.txt

@@ -1,5 +1,5 @@
 KT element: KtConstantExpression
-FIR element: FirConstExpressionImpl
+FIR element: FirLiteralExpressionImpl
 FIR source kind: KtRealSourceElementKind
 
 FIR element rendered:

analysis/low-level-api-fir/testData/getOrBuildFir/expressions/arrayIndexExpressionWithIncScript.txt

@@ -1,5 +1,5 @@
 KT element: KtConstantExpression
-FIR element: FirConstExpressionImpl
+FIR element: FirLiteralExpressionImpl
 FIR source kind: KtRealSourceElementKind
 
 FIR element rendered:

analysis/low-level-api-fir/testData/getOrBuildFir/expressions/assignment.txt

@@ -1,5 +1,5 @@
 KT element: KtStringTemplateExpression
-FIR element: FirConstExpressionImpl
+FIR element: FirLiteralExpressionImpl
 FIR source kind: KtRealSourceElementKind
 
 FIR element rendered:

analysis/low-level-api-fir/testData/getOrBuildFir/expressions/boolLiteral.txt

@@ -1,5 +1,5 @@
 KT element: KtConstantExpression
-FIR element: FirConstExpressionImpl
+FIR element: FirLiteralExpressionImpl
 FIR source kind: KtRealSourceElementKind
 
 FIR element rendered:

analysis/low-level-api-fir/testData/getOrBuildFir/expressions/boolLiteralScript.txt

@@ -1,5 +1,5 @@
 KT element: KtConstantExpression
-FIR element: FirConstExpressionImpl
+FIR element: FirLiteralExpressionImpl
 FIR source kind: KtRealSourceElementKind
 
 FIR element rendered:

analysis/low-level-api-fir/testData/getOrBuildFir/expressions/intLiteral.txt

@@ -1,5 +1,5 @@
 KT element: KtConstantExpression
-FIR element: FirConstExpressionImpl
+FIR element: FirLiteralExpressionImpl
 FIR source kind: KtRealSourceElementKind
 
 FIR element rendered:

analysis/low-level-api-fir/testData/getOrBuildFir/expressions/intLiteralScript.txt

@@ -1,5 +1,5 @@
 KT element: KtConstantExpression
-FIR element: FirConstExpressionImpl
+FIR element: FirLiteralExpressionImpl
 FIR source kind: KtRealSourceElementKind
 
 FIR element rendered:

analysis/low-level-api-fir/testData/getOrBuildFir/expressions/intLiteral_minusOne_entire.txt

@@ -1,5 +1,5 @@
 KT element: KtPrefixExpression
-FIR element: FirConstExpressionImpl
+FIR element: FirLiteralExpressionImpl
 FIR source kind: KtRealSourceElementKind
 
 FIR element rendered:

analysis/low-level-api-fir/testData/getOrBuildFir/expressions/intLiteral_minusOne_justOne.txt

@@ -1,5 +1,5 @@
 KT element: KtConstantExpression
-FIR element: FirConstExpressionImpl
+FIR element: FirLiteralExpressionImpl
 FIR source kind: KtRealSourceElementKind
 
 FIR element rendered:

analysis/low-level-api-fir/testData/getOrBuildFir/expressions/intLiteral_plusOne_entire.txt

@@ -1,5 +1,5 @@
 KT element: KtPrefixExpression
-FIR element: FirConstExpressionImpl
+FIR element: FirLiteralExpressionImpl
 FIR source kind: KtRealSourceElementKind
 
 FIR element rendered:

analysis/low-level-api-fir/testData/getOrBuildFir/expressions/intLiteral_plusOne_justOne.txt

@@ -1,5 +1,5 @@
 KT element: KtConstantExpression
-FIR element: FirConstExpressionImpl
+FIR element: FirLiteralExpressionImpl
 FIR source kind: KtRealSourceElementKind
 
 FIR element rendered:

analysis/low-level-api-fir/testData/getOrBuildFir/expressions/stringLiteral.txt

@@ -1,5 +1,5 @@
 KT element: KtStringTemplateExpression
-FIR element: FirConstExpressionImpl
+FIR element: FirLiteralExpressionImpl
 FIR source kind: KtRealSourceElementKind
 
 FIR element rendered:

analysis/low-level-api-fir/testData/getOrBuildFir/expressions/stringLiteralScript.txt

@@ -1,5 +1,5 @@
 KT element: KtStringTemplateExpression
-FIR element: FirConstExpressionImpl
+FIR element: FirLiteralExpressionImpl
 FIR source kind: KtRealSourceElementKind
 
 FIR element rendered:

compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/Main.kt

@@ -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")

compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/declaration/FirJsExportDeclarationChecker.kt

@@ -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

compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/declaration/FirJvmNameChecker.kt

@@ -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)

compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeObjCNameChecker.kt

@@ -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) {

compiler/fir/checkers/checkers.web.common/src/org/jetbrains/kotlin/fir/analysis/web/common/checkers/expression/FirJsQualifierChecker.kt

@@ -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)

compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/ComposedExpressionCheckers.kt

@@ -65,8 +65,8 @@ class ComposedExpressionCheckers(val predicate: (FirCheckerWithMppKind) -> Boole
         get() = _typeOperatorCallCheckers
     override val resolvedQualifierCheckers: Set<FirResolvedQualifierChecker>
         get() = _resolvedQualifierCheckers
-    override val constExpressionCheckers: Set<FirConstExpressionChecker>
+    override val literalExpressionCheckers: Set<FirLiteralExpressionChecker>
-        get() = _constExpressionCheckers
+        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)

compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/ExpressionCheckers.kt

@@ -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 }

compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirExpressionCheckerAliases.kt

@@ -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>

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/cfa/FirReturnsImpliesAnalyzer.kt

@@ -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

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirConstChecks.kt

@@ -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
                     }

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirHelpers.kt

@@ -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
 }
 

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirSinceKotlinHelpers.kt

@@ -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

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInlineDeclarationChecker.kt

@@ -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

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirAnnotationExpressionChecker.kt

@@ -123,8 +123,8 @@ object FirAnnotationExpressionChecker : FirAnnotationCallChecker(MppCheckerKind.
         context: CheckerContext,
         reporter: DiagnosticReporter
     ): ApiVersion? {
-        val constantExpression = (expression as? FirConstExpression<*>)
+        val constantExpression = (expression as? FirLiteralExpression<*>)
-            ?: ((expression as? FirNamedArgumentExpression)?.expression as? FirConstExpression<*>) ?: return null
+            ?: ((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"

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirDivisionByZeroChecker.kt

@@ -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) {

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageBaseChecker.kt

@@ -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)
     }
 

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirWhenConditionChecker.kt

@@ -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 -> {

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/EmptyRangeChecker.kt

@@ -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
         }
 }

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantCallOfConversionMethod.kt

@@ -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 {

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/RedundantExplicitTypeChecker.kt

@@ -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

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/type/FirDuplicateParameterNameInFunctionTypeChecker.kt

@@ -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) {

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/AbstractDiagnosticCollector.kt

@@ -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()

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ExpressionCheckersDiagnosticComponent.kt

@@ -46,8 +46,8 @@ class ExpressionCheckersDiagnosticComponent(
         checkers.allTypeOperatorCallCheckers.check(typeOperatorCall, data)
     }
 
-    override fun <T> visitConstExpression(constExpression: FirConstExpression<T>, data: CheckerContext) {
+    override fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>, data: CheckerContext) {
-        checkers.allConstExpressionCheckers.check(constExpression, data)
+        checkers.allLiteralExpressionCheckers.check(literalExpression, data)
     }
 
     override fun visitAnnotation(annotation: FirAnnotation, data: CheckerContext) {

compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt

@@ -759,7 +759,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
         }
     }
 
-    private fun FlowContent.generate(expression: FirConstExpression<*>) {
+    private fun FlowContent.generate(expression: FirLiteralExpression<*>) {
         val value = expression.value
         if (value == null && expression.kind != ConstantValueKind.Null) {
             return error {
@@ -1545,7 +1545,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
                 is FirElseIfTrueCondition -> generate(expression)
                 is FirWhenExpression -> generate(expression, isStatement = false)
                 is FirTryExpression -> generate(expression, isStatement = false)
-                is FirConstExpression<*> -> generate(expression)
+                is FirLiteralExpression<*> -> generate(expression)
                 is FirReturnExpression -> {
                     span("return-label") {
                         symbolRef(expression.target.labeledElement.symbol) {

compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/AbstractAnnotationDeserializer.kt

@@ -298,7 +298,7 @@ abstract class AbstractAnnotationDeserializer(
         }
     }
 
-    private fun <T> const(kind: ConstantValueKind<T>, value: T, typeRef: FirResolvedTypeRef): FirConstExpression<T> {
+    private fun <T> const(kind: ConstantValueKind<T>, value: T, typeRef: FirResolvedTypeRef): FirLiteralExpression<T> {
-        return buildConstExpression(null, kind, value, setType = true).apply { this.replaceConeTypeOrNull(typeRef.coneType) }
+        return buildLiteralExpression(null, kind, value, setType = true).apply { this.replaceConeTypeOrNull(typeRef.coneType) }
     }
 }

compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/FirConstDeserializer.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.deserialization
 
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression
+import org.jetbrains.kotlin.fir.expressions.builder.buildLiteralExpression
 import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.metadata.deserialization.Flags
 import org.jetbrains.kotlin.metadata.deserialization.NameResolver
@@ -35,31 +35,31 @@ fun buildFirConstant(
     protoValue: ProtoBuf.Annotation.Argument.Value?, sourceValue: Any?, constKind: String, nameResolver: NameResolver
 ): FirExpression? {
     return when (constKind) {
-        "BYTE", "B" -> buildConstExpression(
+        "BYTE", "B" -> buildLiteralExpression(
             null, ConstantValueKind.Byte, ((protoValue?.intValue ?: sourceValue) as Number).toByte(), setType = true
         )
-        "CHAR", "C" -> buildConstExpression(
+        "CHAR", "C" -> buildLiteralExpression(
             null, ConstantValueKind.Char, ((protoValue?.intValue ?: sourceValue) as Number).toInt().toChar(), setType = true
         )
-        "SHORT", "S" -> buildConstExpression(
+        "SHORT", "S" -> buildLiteralExpression(
             null, ConstantValueKind.Short, ((protoValue?.intValue ?: sourceValue) as Number).toShort(), setType = true
         )
-        "INT", "I" -> buildConstExpression(
+        "INT", "I" -> buildLiteralExpression(
             null, ConstantValueKind.Int, protoValue?.intValue?.toInt() ?: sourceValue as Int, setType = true
         )
-        "LONG", "J" -> buildConstExpression(
+        "LONG", "J" -> buildLiteralExpression(
             null, ConstantValueKind.Long, protoValue?.intValue ?: sourceValue as Long, setType = true
         )
-        "FLOAT", "F" -> buildConstExpression(
+        "FLOAT", "F" -> buildLiteralExpression(
             null, ConstantValueKind.Float, protoValue?.floatValue ?: sourceValue as Float, setType = true
         )
-        "DOUBLE", "D" -> buildConstExpression(
+        "DOUBLE", "D" -> buildLiteralExpression(
             null, ConstantValueKind.Double, protoValue?.doubleValue ?: sourceValue as Double, setType = true
         )
-        "BOOLEAN", "Z" -> buildConstExpression(
+        "BOOLEAN", "Z" -> buildLiteralExpression(
             null, ConstantValueKind.Boolean, (protoValue?.intValue?.toInt() ?: sourceValue) != 0, setType = true
         )
-        "STRING", "Ljava/lang/String;" -> buildConstExpression(
+        "STRING", "Ljava/lang/String;" -> buildLiteralExpression(
             null, ConstantValueKind.String,
             protoValue?.stringValue?.let { nameResolver.getString(it) } ?: sourceValue as String, setType = true
         )

compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/FirElementSerializer.kt

@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.fir.deserialization.projection
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotation
 import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotationArgumentMapping
-import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression
+import org.jetbrains.kotlin.fir.expressions.builder.buildLiteralExpression
 import org.jetbrains.kotlin.fir.expressions.impl.FirEmptyAnnotationArgumentMapping
 import org.jetbrains.kotlin.fir.extensions.FirExtensionApiInternals
 import org.jetbrains.kotlin.fir.extensions.extensionService
@@ -938,7 +938,7 @@ class FirElementSerializer private constructor(
                             correspondingTypeRef?.annotations, CompilerConeAttributes.ContextFunctionTypeParams.ANNOTATION_CLASS_ID,
                             argumentMapping = buildAnnotationArgumentMapping {
                                 this.mapping[StandardNames.CONTEXT_FUNCTION_TYPE_PARAMETER_COUNT_NAME] =
-                                    buildConstExpression(
+                                    buildLiteralExpression(
                                         source = null, ConstantValueKind.Int, type.contextReceiversNumberForFunctionType, setType = false
                                     )
                             }

compiler/fir/fir-serialization/src/org/jetbrains/kotlin/fir/serialization/constant/FirToConstantValueTransformer.kt

@@ -60,12 +60,12 @@ internal object FirToConstantValueTransformer : FirDefaultVisitor<ConstantValue<
         error("Illegal element as annotation argument: ${element::class.qualifiedName} -> ${element.render()}")
     }
 
-    override fun <T> visitConstExpression(
+    override fun <T> visitLiteralExpression(
-        constExpression: FirConstExpression<T>,
+        literalExpression: FirLiteralExpression<T>,
         data: FirToConstantValueTransformerData
     ): ConstantValue<*>? {
-        val value = constExpression.value
+        val value = literalExpression.value
-        return when (constExpression.kind) {
+        return when (literalExpression.kind) {
             ConstantValueKind.Boolean -> BooleanValue(value as Boolean)
             ConstantValueKind.Char -> CharValue(value as Char)
             ConstantValueKind.Byte -> ByteValue((value as Number).toByte())
@@ -250,11 +250,11 @@ internal object FirToConstantValueChecker : FirDefaultVisitor<Boolean, FirSessio
         return false
     }
 
-    override fun <T> visitConstExpression(
+    override fun <T> visitLiteralExpression(
-        constExpression: FirConstExpression<T>,
+        literalExpression: FirLiteralExpression<T>,
         data: FirSession
     ): Boolean {
-        return constExpression.kind in supportedConstKinds
+        return literalExpression.kind in supportedConstKinds
     }
 
     override fun visitStringConcatenationCall(stringConcatenationCall: FirStringConcatenationCall, data: FirSession): Boolean {

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt

@@ -333,7 +333,7 @@ fun FirCallableSymbol<*>.toSymbolForCall(
     }
 }
 
-fun FirConstExpression<*>.getIrConstKind(): IrConstKind<*> = when (kind) {
+fun FirLiteralExpression<*>.getIrConstKind(): IrConstKind<*> = when (kind) {
     ConstantValueKind.IntegerLiteral, ConstantValueKind.UnsignedIntegerLiteral -> {
         val type = resolvedType as ConeIntegerLiteralType
         type.getApproximatedType().toConstKind()!!.toIrConstKind()
@@ -342,7 +342,7 @@ fun FirConstExpression<*>.getIrConstKind(): IrConstKind<*> = when (kind) {
     else -> kind.toIrConstKind()
 }
 
-fun <T> FirConstExpression<T>.toIrConst(irType: IrType): IrConst<T> {
+fun <T> FirLiteralExpression<T>.toIrConst(irType: IrType): IrConst<T> {
     return convertWithOffsets { startOffset, endOffset ->
         @Suppress("UNCHECKED_CAST")
         val kind = getIrConstKind() as IrConstKind<T>

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrImplicitCastInserter.kt

@@ -62,7 +62,7 @@ class Fir2IrImplicitCastInserter(
 
     override fun visitEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall, data: IrElement): IrElement = data
 
-    override fun <T> visitConstExpression(constExpression: FirConstExpression<T>, data: IrElement): IrElement = data
+    override fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>, data: IrElement): IrElement = data
 
     override fun visitThisReceiverExpression(thisReceiverExpression: FirThisReceiverExpression, data: IrElement): IrElement = data
 

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrIrGeneratedDeclarationsRegistrar.kt

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.declarations.utils.classId
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
 import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotation
 import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotationArgumentMapping
-import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression
+import org.jetbrains.kotlin.fir.expressions.builder.buildLiteralExpression
 import org.jetbrains.kotlin.fir.expressions.builder.buildExpressionStub
 import org.jetbrains.kotlin.fir.resolve.defaultType
 import org.jetbrains.kotlin.fir.resolve.providers.getContainingFile
@@ -280,61 +280,61 @@ class Fir2IrIrGeneratedDeclarationsRegistrar(private val components: Fir2IrCompo
                     val name = this@toFirAnnotation.symbol.owner.valueParameters[i].name
                     val argument = this@toFirAnnotation.getValueArgument(i) as IrConst<*>
                     this.mapping[name] = when (argument.kind) {
-                        IrConstKind.Boolean -> buildConstExpression(
+                        IrConstKind.Boolean -> buildLiteralExpression(
                             source = null,
                             ConstantValueKind.Boolean,
                             argument.value as Boolean,
                             setType = true
                         )
-                        IrConstKind.Byte -> buildConstExpression(
+                        IrConstKind.Byte -> buildLiteralExpression(
                             source = null,
                             ConstantValueKind.Byte,
                             argument.value as Byte,
                             setType = true
                         )
-                        IrConstKind.Char -> buildConstExpression(
+                        IrConstKind.Char -> buildLiteralExpression(
                             source = null,
                             ConstantValueKind.Char,
                             argument.value as Char,
                             setType = true
                         )
-                        IrConstKind.Double -> buildConstExpression(
+                        IrConstKind.Double -> buildLiteralExpression(
                             source = null,
                             ConstantValueKind.Double,
                             argument.value as Double,
                             setType = true
                         )
-                        IrConstKind.Float -> buildConstExpression(
+                        IrConstKind.Float -> buildLiteralExpression(
                             source = null,
                             ConstantValueKind.Float,
                             argument.value as Float,
                             setType = true
                         )
-                        IrConstKind.Int -> buildConstExpression(
+                        IrConstKind.Int -> buildLiteralExpression(
                             source = null,
                             ConstantValueKind.Int,
                             argument.value as Int,
                             setType = true
                         )
-                        IrConstKind.Long -> buildConstExpression(
+                        IrConstKind.Long -> buildLiteralExpression(
                             source = null,
                             ConstantValueKind.Long,
                             argument.value as Long,
                             setType = true
                         )
-                        IrConstKind.Null -> buildConstExpression(
+                        IrConstKind.Null -> buildLiteralExpression(
                             source = null,
                             ConstantValueKind.Null,
                             value = null,
                             setType = true
                         )
-                        IrConstKind.Short -> buildConstExpression(
+                        IrConstKind.Short -> buildLiteralExpression(
                             source = null,
                             ConstantValueKind.Short,
                             argument.value as Short,
                             setType = false
                         )
-                        IrConstKind.String -> buildConstExpression(
+                        IrConstKind.String -> buildLiteralExpression(
                             source = null,
                             ConstantValueKind.String,
                             argument.value as String,

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt

@@ -876,8 +876,8 @@ class Fir2IrVisitor(
         return desugaredAssignmentValueReferenceExpression.expressionRef.value.accept(this, null)
     }
 
-    override fun <T> visitConstExpression(constExpression: FirConstExpression<T>, data: Any?): IrElement {
+    override fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>, data: Any?): IrElement {
-        return constExpression.toIrConst(constExpression.resolvedType.toIrType())
+        return literalExpression.toIrConst(literalExpression.resolvedType.toIrType())
     }
 
     // ==================================================================================

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/Fir2IrCallableDeclarationsGenerator.kt

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertySetter
 import org.jetbrains.kotlin.fir.declarations.utils.*
 import org.jetbrains.kotlin.fir.descriptors.FirModuleDescriptor
 import org.jetbrains.kotlin.fir.descriptors.FirPackageFragmentDescriptor
-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.FirQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.expressions.impl.FirExpressionStub
@@ -312,7 +312,7 @@ class Fir2IrCallableDeclarationsGenerator(val components: Fir2IrComponents) : Fi
                                 initializer,
                                 typeToUse
                             ).also { field ->
-                                if (initializer is FirConstExpression<*>) {
+                                if (initializer is FirLiteralExpression<*>) {
                                     val constType = initializer.resolvedType.toIrType()
                                     field.initializer = factory.createExpressionBody(initializer.toIrConst(constType))
                                 }
@@ -368,7 +368,7 @@ class Fir2IrCallableDeclarationsGenerator(val components: Fir2IrComponents) : Fi
     private fun getEffectivePropertyInitializer(property: FirProperty, resolveIfNeeded: Boolean): FirExpression? {
         val initializer = property.backingField?.initializer ?: property.initializer
 
-        if (resolveIfNeeded && initializer is FirConstExpression<*>) {
+        if (resolveIfNeeded && initializer is FirLiteralExpression<*>) {
             property.lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
             return getEffectivePropertyInitializer(property, resolveIfNeeded = false)
         }
@@ -558,7 +558,7 @@ class Fir2IrCallableDeclarationsGenerator(val components: Fir2IrComponents) : Fi
             ).apply {
                 metadata = FirMetadataSource.Field(field)
                 val initializer = field.unwrapFakeOverrides().initializer
-                if (initializer is FirConstExpression<*>) {
+                if (initializer is FirLiteralExpression<*>) {
                     this.initializer = factory.createExpressionBody(initializer.toIrConst(irType))
                 }
                 /*

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyField.kt

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.declarations.utils.isExternal
 import org.jetbrains.kotlin.fir.declarations.utils.isFinal
 import org.jetbrains.kotlin.fir.declarations.utils.isStatic
 import org.jetbrains.kotlin.fir.declarations.utils.visibility
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
+import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
 import org.jetbrains.kotlin.fir.unwrapFakeOverrides
 import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.declarations.*
@@ -72,7 +72,7 @@ class Fir2IrLazyField(
 
     override var initializer: IrExpressionBody? by lazyVar(lock) {
         when (val initializer = fir.unwrapFakeOverrides().initializer) {
-            is FirConstExpression<*> -> factory.createExpressionBody(initializer.toIrConst(type))
+            is FirLiteralExpression<*> -> factory.createExpressionBody(initializer.toIrConst(type))
             else -> null
         }
     }

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyProperty.kt

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyGetter
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertySetter
 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.expressions.FirExpression
 import org.jetbrains.kotlin.fir.types.coneType
 import org.jetbrains.kotlin.fir.types.resolvedType
@@ -100,7 +100,7 @@ class Fir2IrLazyProperty(
                 components, fir.returnTypeRef.coneType
             )
             // Setting initializers to every other class causes some cryptic errors in lowerings
-            initializer is FirConstExpression<*> -> {
+            initializer is FirLiteralExpression<*> -> {
                 val constType = with(typeConverter) { initializer.resolvedType.toIrType() }
                 factory.createExpressionBody(initializer.toIrConst(constType))
             }

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/FirJavaElementFinder.kt

@@ -34,7 +34,7 @@ import org.jetbrains.kotlin.fir.caches.getValue
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.*
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
+import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
 import org.jetbrains.kotlin.fir.moduleData
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
@@ -132,7 +132,7 @@ class FirJavaElementFinder(
     private fun FirFile.jvmName(): String {
         val jvmNameAnnotation = this.findJvmNameAnnotation()
         val jvmName = jvmNameAnnotation?.findArgumentByName(StandardNames.NAME)
-        val jvmNameValue = (jvmName as? FirConstExpression<*>)?.value as? String
+        val jvmNameValue = (jvmName as? FirLiteralExpression<*>)?.value as? String
         return jvmNameValue ?: (this.name.removeSuffix(".kt").capitalizeAsciiOnly() + "Kt")
     }
 

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt

@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.expressions.FirArrayLiteral
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.builder.buildArgumentList
 import org.jetbrains.kotlin.fir.expressions.builder.buildArrayLiteral
-import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression
+import org.jetbrains.kotlin.fir.expressions.builder.buildLiteralExpression
 import org.jetbrains.kotlin.fir.expressions.builder.buildErrorExpression
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.expectedConeType
 import org.jetbrains.kotlin.fir.types.*
@@ -77,31 +77,31 @@ internal fun Any?.createConstantOrError(session: FirSession, expectedTypeRef: Fi
 
 internal fun Any?.createConstantIfAny(session: FirSession, unsigned: Boolean = false): FirExpression? {
     return when (this) {
-        is Byte -> buildConstExpression(
+        is Byte -> buildLiteralExpression(
             null, if (unsigned) ConstantValueKind.UnsignedByte else ConstantValueKind.Byte, this, setType = true
         )
-        is Short -> buildConstExpression(
+        is Short -> buildLiteralExpression(
             null, if (unsigned) ConstantValueKind.UnsignedShort else ConstantValueKind.Short, this, setType = true
         )
-        is Int -> buildConstExpression(
+        is Int -> buildLiteralExpression(
             null, if (unsigned) ConstantValueKind.UnsignedInt else ConstantValueKind.Int, this, setType = true
         )
-        is Long -> buildConstExpression(
+        is Long -> buildLiteralExpression(
             null, if (unsigned) ConstantValueKind.UnsignedLong else ConstantValueKind.Long, this, setType = true
         )
-        is Char -> buildConstExpression(
+        is Char -> buildLiteralExpression(
             null, ConstantValueKind.Char, this, setType = true
         )
-        is Float -> buildConstExpression(
+        is Float -> buildLiteralExpression(
             null, ConstantValueKind.Float, this, setType = true
         )
-        is Double -> buildConstExpression(
+        is Double -> buildLiteralExpression(
             null, ConstantValueKind.Double, this, setType = true
         )
-        is Boolean -> buildConstExpression(
+        is Boolean -> buildLiteralExpression(
             null, ConstantValueKind.Boolean, this, setType = true
         )
-        is String -> buildConstExpression(
+        is String -> buildLiteralExpression(
             null, ConstantValueKind.String, this, setType = true
         )
         is ByteArray -> toList().createArrayLiteral(session, ConstantValueKind.Byte)
@@ -112,7 +112,7 @@ internal fun Any?.createConstantIfAny(session: FirSession, unsigned: Boolean = f
         is FloatArray -> toList().createArrayLiteral(session, ConstantValueKind.Float)
         is DoubleArray -> toList().createArrayLiteral(session, ConstantValueKind.Double)
         is BooleanArray -> toList().createArrayLiteral(session, ConstantValueKind.Boolean)
-        null -> buildConstExpression(
+        null -> buildLiteralExpression(
             null, ConstantValueKind.Null, null, setType = true
         )
 

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/JvmBinaryAnnotationDeserializer.kt

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.deserialization.AbstractAnnotationDeserializer
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
-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.builder.buildAnnotation
 import org.jetbrains.kotlin.fir.java.createConstantIfAny
@@ -216,7 +216,7 @@ class JvmBinaryAnnotationDeserializer(
     ): FirExpression? {
         val signature = getCallableSignature(propertyProto, nameResolver, typeTable, CallableKind.PROPERTY_GETTER) ?: return null
         val firExpr = annotationInfo.annotationMethodsDefaultValues[signature]
-        return if (firExpr is FirConstExpression<*> && expectedPropertyType.coneType.isUnsignedType && firExpr.kind.isSignedNumber)
+        return if (firExpr is FirLiteralExpression<*> && expectedPropertyType.coneType.isUnsignedType && firExpr.kind.isSignedNumber)
             firExpr.value.createConstantIfAny(session, unsigned = true)
         else
             firExpr

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty
 import org.jetbrains.kotlin.fir.declarations.synthetic.buildSyntheticProperty
 import org.jetbrains.kotlin.fir.declarations.utils.*
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
+import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
 import org.jetbrains.kotlin.fir.expressions.unexpandedClassId
 import org.jetbrains.kotlin.fir.java.FirJavaTypeConversionMode
 import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack
@@ -533,7 +533,7 @@ class FirSignatureEnhancement(
     private fun getPurelyImplementedSupertype(session: FirSession): ConeKotlinType? {
         val purelyImplementedClassIdFromAnnotation = owner.annotations
             .firstOrNull { it.unexpandedClassId?.asSingleFqName() == JvmAnnotationNames.PURELY_IMPLEMENTS_ANNOTATION }
-            ?.let { (it.argumentMapping.mapping.values.firstOrNull() as? FirConstExpression<*>) }
+            ?.let { (it.argumentMapping.mapping.values.firstOrNull() as? FirLiteralExpression<*>) }
             ?.let { it.value as? String }
             ?.takeIf { it.isNotBlank() && isValidJavaFqName(it) }
             ?.let { ClassId.topLevel(FqName(it)) }

compiler/fir/native/src/org/jetbrains/kotlin/fir/backend/native/interop/FirObjCInterop.kt

@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.containingClassLookupTag
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
+import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
 import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.scopes.getDirectOverriddenFunctions
 import org.jetbrains.kotlin.fir.scopes.impl.declaredMemberScope
@@ -88,7 +88,7 @@ private fun FirAnnotation.constBooleanArgumentOrNull(argumentName: String): Bool
         constArgument(argumentName) as Boolean?
 
 private fun FirAnnotation.constArgument(argumentName: String) =
-        (argumentMapping.mapping[Name.identifier(argumentName)] as? FirConstExpression<*>)?.value
+        (argumentMapping.mapping[Name.identifier(argumentName)] as? FirLiteralExpression<*>)?.value
 
 internal fun FirFunction.hasObjCFactoryAnnotation(session: FirSession) = this.annotations.hasAnnotation(NativeStandardInteropNames.objCFactoryClassId, session)
 

compiler/fir/providers/src/org/jetbrains/kotlin/fir/CopyUtils.kt

@@ -127,4 +127,4 @@ private fun FirAnnotation.tryExpandClassId(session: FirSession): ClassId? {
 }
 
 private fun FirAnnotation.extractContextReceiversCount() =
-    (argumentMapping.mapping[StandardNames.CONTEXT_FUNCTION_TYPE_PARAMETER_COUNT_NAME] as? FirConstExpression<*>)?.value as? Int
+    (argumentMapping.mapping[StandardNames.CONTEXT_FUNCTION_TYPE_PARAMETER_COUNT_NAME] as? FirLiteralExpression<*>)?.value as? Int

compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/FirAnnotationUtils.kt

@@ -141,12 +141,12 @@ fun FirAnnotation.getBooleanArgument(name: Name): Boolean? = getPrimitiveArgumen
 fun FirAnnotation.getStringArgument(name: Name): String? = getPrimitiveArgumentValue(name)
 fun FirAnnotation.getStringArrayArgument(name: Name): List<String>? {
     val argument = findArgumentByName(name) as? FirArrayLiteral ?: return null
-    return argument.arguments.mapNotNull { (it as? FirConstExpression<*>)?.value as? String }
+    return argument.arguments.mapNotNull { (it as? FirLiteralExpression<*>)?.value as? String }
 }
 
 private inline fun <reified T> FirAnnotation.getPrimitiveArgumentValue(name: Name): T? {
     return findArgumentByName(name)?.let { expression ->
-        (expression as? FirConstExpression<*>)?.value as? T
+        (expression as? FirLiteralExpression<*>)?.value as? T
     }
 }
 

compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/deprecationUtils.kt

@@ -273,7 +273,7 @@ private fun List<FirAnnotation>.extractDeprecationAnnotationInfoPerUseSite(
         for ((deprecated, shouldPropagateToOverrides) in annotations) {
             if (deprecated.unexpandedClassId == StandardClassIds.Annotations.SinceKotlin) {
                 val sinceKotlinSingleArgument = deprecated.findArgumentByName(ParameterNames.sinceKotlinVersion)
-                val apiVersion = ((sinceKotlinSingleArgument as? FirConstExpression<*>)?.value as? String)
+                val apiVersion = ((sinceKotlinSingleArgument as? FirLiteralExpression<*>)?.value as? String)
                     ?.let(ApiVersion.Companion::parse) ?: continue
                 val wasExperimental = this@extractDeprecationAnnotationInfoPerUseSite.any {
                     it.unexpandedClassId == StandardClassIds.Annotations.WasExperimental
@@ -315,7 +315,7 @@ private fun List<FirAnnotation>.extractDeprecationAnnotationInfoPerUseSite(
 private fun FirAnnotation.getFirstArgumentStringIfNotNamed(): String? {
     if (this !is FirAnnotationCall) return null
     val firstArgument = argumentList.arguments.firstOrNull() ?: return null
-    return (firstArgument as? FirConstExpression<*>)?.value?.toString()
+    return (firstArgument as? FirLiteralExpression<*>)?.value?.toString()
 }
 
 

compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/LookupTagUtils.kt

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.declarations.utils.isInner
 import org.jetbrains.kotlin.fir.declarations.utils.isLocal
 import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotation
 import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotationArgumentMapping
-import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression
+import org.jetbrains.kotlin.fir.expressions.builder.buildLiteralExpression
 import org.jetbrains.kotlin.fir.getContainingClassLookupTag
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
@@ -109,7 +109,7 @@ fun ConeKotlinType.withParameterNameAnnotation(parameter: FirFunctionTypeParamet
             }
         argumentMapping = buildAnnotationArgumentMapping {
             mapping[StandardClassIds.Annotations.ParameterNames.parameterNameName] =
-                buildConstExpression(fakeSource, ConstantValueKind.String, name.asString(), setType = true)
+                buildLiteralExpression(fakeSource, ConstantValueKind.String, name.asString(), setType = true)
         }
     }
     val attributesWithParameterNameAnnotation =

compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt

@@ -569,7 +569,7 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty
             is FirNamedArgumentExpression -> argument.expression
             else -> argument
         } ?: return null
-        return (argument as? FirConstExpression<*>)?.value
+        return (argument as? FirLiteralExpression<*>)?.value
     }
 
     override fun TypeConstructorMarker.getTypeParameterClassifier(): TypeParameterMarker? {

compiler/fir/raw-fir/raw-fir.common/src/org/jetbrains/kotlin/fir/builder/AbstractRawFirBuilder.kt

@@ -470,14 +470,14 @@ abstract class AbstractRawFirBuilder<T>(val baseSession: FirSession, val context
                 )
             }
             BOOLEAN_CONSTANT ->
-                buildConstExpression(
+                buildLiteralExpression(
                     sourceElement,
                     ConstantValueKind.Boolean,
                     convertedText as Boolean,
                     setType = false
                 )
             NULL ->
-                buildConstExpression(
+                buildLiteralExpression(
                     sourceElement,
                     ConstantValueKind.Null,
                     null,
@@ -503,7 +503,7 @@ abstract class AbstractRawFirBuilder<T>(val baseSession: FirSession, val context
         receiver: FirExpression,
         operationToken: IElementType,
     ): FirExpression? {
-        if (receiver !is FirConstExpression<*>) return null
+        if (receiver !is FirLiteralExpression<*>) return null
         if (receiver.kind != ConstantValueKind.IntegerLiteral) return null
         if (operationToken != PLUS && operationToken != MINUS) return null
 
@@ -514,7 +514,7 @@ abstract class AbstractRawFirBuilder<T>(val baseSession: FirSession, val context
             else -> error("Should not be here")
         }
 
-        return buildConstExpression(
+        return buildLiteralExpression(
             source.toFirSourceElement(),
             ConstantValueKind.IntegerLiteral,
             convertedValue,
@@ -537,7 +537,7 @@ abstract class AbstractRawFirBuilder<T>(val baseSession: FirSession, val context
                         OPEN_QUOTE, CLOSING_QUOTE -> continue@L
                         LITERAL_STRING_TEMPLATE_ENTRY -> {
                             sb.append(entry.asText)
-                            buildConstExpression(
+                            buildLiteralExpression(
                                 entry.toFirSourceElement(), ConstantValueKind.String, entry.asText, setType = false
                             )
                         }
@@ -571,7 +571,7 @@ abstract class AbstractRawFirBuilder<T>(val baseSession: FirSession, val context
             source = base?.toFirSourceElement()
             // Fast-pass if there is no errors and non-const string expressions
             if (!hasExpressions && !argumentList.arguments.any { it is FirErrorExpression })
-                return buildConstExpression(source, ConstantValueKind.String, sb.toString(), setType = false)
+                return buildLiteralExpression(source, ConstantValueKind.String, sb.toString(), setType = false)
         }
     }
 

compiler/fir/raw-fir/raw-fir.common/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt

@@ -363,7 +363,7 @@ fun <T> FirPropertyBuilder.generateAccessorsByDelegate(
                 }
                 coneTypeOrNull = context.dispatchReceiverTypesStack.last()
             }
-            else -> buildConstExpression(null, ConstantValueKind.Null, null, setType = false)
+            else -> buildLiteralExpression(null, ConstantValueKind.Null, null, setType = false)
         }
 
     fun delegateAccess() = buildPropertyAccessExpression {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt

@@ -815,7 +815,7 @@ class FirCallResolver(
 
             candidates.isEmpty() -> {
                 when {
-                    name.asString() == "invoke" && explicitReceiver is FirConstExpression<*> ->
+                    name.asString() == "invoke" && explicitReceiver is FirLiteralExpression<*> ->
                         ConeFunctionExpectedError(
                             explicitReceiver.value?.toString() ?: "",
                             explicitReceiver.resolvedType,

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt

@@ -563,7 +563,7 @@ fun FirExpression?.isIntegerLiteralOrOperatorCall(): Boolean {
         returns(true) implies (this@isIntegerLiteralOrOperatorCall != null)
     }
     return when (this) {
-        is FirConstExpression<*> -> kind == ConstantValueKind.Int
+        is FirLiteralExpression<*> -> kind == ConstantValueKind.Int
                 || kind == ConstantValueKind.IntegerLiteral
                 || kind == ConstantValueKind.UnsignedInt
                 || kind == ConstantValueKind.UnsignedIntegerLiteral

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirDataFlowAnalyzer.kt

@@ -435,8 +435,8 @@ abstract class FirDataFlowAnalyzer(
         val leftConst = when (leftOperand) {
             is FirWhenSubjectExpression -> leftOperand.whenRef.value.subject
             else -> leftOperand
-        } as? FirConstExpression<*>
+        } as? FirLiteralExpression<*>
-        val rightConst = rightOperand as? FirConstExpression<*>
+        val rightConst = rightOperand as? FirLiteralExpression<*>
         val leftIsNullConst = leftConst?.kind == ConstantValueKind.Null
         val rightIsNullConst = rightConst?.kind == ConstantValueKind.Null
         val leftIsNull = leftIsNullConst || leftOperand.resolvedType.isNullableNothing && !rightIsNullConst
@@ -460,7 +460,7 @@ abstract class FirDataFlowAnalyzer(
         flow: MutableFlow,
         expression: FirEqualityOperatorCall,
         operand: FirExpression,
-        const: FirConstExpression<*>,
+        const: FirLiteralExpression<*>,
         isEq: Boolean
     ) {
         if (const.kind == ConstantValueKind.Null) {
@@ -1020,7 +1020,7 @@ abstract class FirDataFlowAnalyzer(
         }
     }
 
-    fun exitConstExpression(constExpression: FirConstExpression<*>) {
+    fun exitConstExpression(constExpression: FirLiteralExpression<*>) {
         if (constExpression.isResolved) return
         graphBuilder.exitConstExpression(constExpression).mergeIncomingFlow()
     }
@@ -1265,7 +1265,7 @@ abstract class FirDataFlowAnalyzer(
 
             // For any predicate P(x), if P(v) != P(u ?: v) then u != null. In general this requires two levels of
             // implications, but for constant v the logic system can handle some basic cases of P(x).
-            val rhs = (elvisExpression.rhs as? FirConstExpression<*>)?.value as? Boolean
+            val rhs = (elvisExpression.rhs as? FirLiteralExpression<*>)?.value as? Boolean
             if (rhs != null) {
                 flow.addAllConditionally(elvisVariable eq !rhs, node.firstPreviousNode.getFlow(path))
             }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphBuilder.kt

@@ -966,7 +966,7 @@ class ControlFlowGraphBuilder {
 
     fun exitWhileLoopCondition(loop: FirLoop): Pair<LoopConditionExitNode, LoopBlockEnterNode> {
         val conditionExitNode = createLoopConditionExitNode(loop.condition).also { addNewSimpleNode(it) }
-        val conditionConstBooleanValue = loop.condition.booleanConstValue
+        val conditionConstBooleanValue = loop.condition.booleanLiteralValue
         addEdge(conditionExitNode, loopExitNodes.getValue(loop), propagateDeadness = false, isDead = conditionConstBooleanValue == true)
         val loopBlockEnterNode = createLoopBlockEnterNode(loop)
         addNewSimpleNode(loopBlockEnterNode, conditionConstBooleanValue == false)
@@ -1008,7 +1008,7 @@ class ControlFlowGraphBuilder {
     fun exitDoWhileLoop(loop: FirLoop): Pair<LoopConditionExitNode, LoopExitNode> {
         loopConditionEnterNodes.remove(loop)
         val conditionExitNode = createLoopConditionExitNode(loop.condition)
-        val conditionBooleanValue = loop.condition.booleanConstValue
+        val conditionBooleanValue = loop.condition.booleanLiteralValue
         popAndAddEdge(conditionExitNode)
         val blockEnterNode = lastNodes.pop()
         require(blockEnterNode is LoopBlockEnterNode)
@@ -1041,7 +1041,7 @@ class ControlFlowGraphBuilder {
         addNewSimpleNode(leftExitNode)
         lastNodes.push(leftExitNode) // to create an exit edge later
         val rhsNeverExecuted =
-            binaryLogicExpression.leftOperand.booleanConstValue == (binaryLogicExpression.kind != LogicOperationKind.AND)
+            binaryLogicExpression.leftOperand.booleanLiteralValue == (binaryLogicExpression.kind != LogicOperationKind.AND)
         addNewSimpleNode(rightEnterNode, isDead = rhsNeverExecuted)
         return leftExitNode to rightEnterNode
     }
@@ -1054,14 +1054,14 @@ class ControlFlowGraphBuilder {
         val rightNode = lastNodes.pop()
         val leftNode = lastNodes.pop()
         val rhsAlwaysExecuted =
-            binaryLogicExpression.leftOperand.booleanConstValue == (binaryLogicExpression.kind == LogicOperationKind.AND)
+            binaryLogicExpression.leftOperand.booleanLiteralValue == (binaryLogicExpression.kind == LogicOperationKind.AND)
         addEdge(leftNode, exitNode, propagateDeadness = !rhsAlwaysExecuted, isDead = rhsAlwaysExecuted)
         addEdge(rightNode, exitNode, propagateDeadness = rhsAlwaysExecuted)
         lastNodes.push(exitNode)
         return exitNode
     }
 
-    private val FirExpression.booleanConstValue: Boolean? get() = (this as? FirConstExpression<*>)?.value as? Boolean?
+    private val FirExpression.booleanLiteralValue: Boolean? get() = (this as? FirLiteralExpression<*>)?.value as? Boolean?
 
     // ----------------------------------- Try-catch-finally -----------------------------------
 
@@ -1330,7 +1330,7 @@ class ControlFlowGraphBuilder {
         return node
     }
 
-    fun exitConstExpression(constExpression: FirConstExpression<*>): ConstExpressionNode {
+    fun exitLiteralExpression(constExpression: FirLiteralExpression<*>): ConstExpressionNode {
         return createConstExpressionNode(constExpression).also { addNewSimpleNode(it) }
     }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphNodeBuilder.kt

@@ -163,7 +163,7 @@ fun ControlFlowGraphBuilder.createElvisExitNode(fir: FirElvisExpression): ElvisE
 fun ControlFlowGraphBuilder.createVariableDeclarationNode(fir: FirProperty): VariableDeclarationNode =
     VariableDeclarationNode(currentGraph, fir, levelCounter)
 
-fun ControlFlowGraphBuilder.createConstExpressionNode(fir: FirConstExpression<*>): ConstExpressionNode =
+fun ControlFlowGraphBuilder.createConstExpressionNode(fir: FirLiteralExpression<*>): ConstExpressionNode =
     ConstExpressionNode(currentGraph, fir, levelCounter)
 
 fun ControlFlowGraphBuilder.createThrowExceptionNode(fir: FirThrowExpression): ThrowExceptionNode =

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt

@@ -938,16 +938,16 @@ class FirCallCompletionResultsWriterTransformer(
         )
     }
 
-    override fun <T> transformConstExpression(
+    override fun <T> transformLiteralExpression(
-        constExpression: FirConstExpression<T>,
+        literalExpression: FirLiteralExpression<T>,
         data: ExpectedArgumentType?,
     ): FirStatement {
-        if (data == ExpectedArgumentType.NoApproximation) return constExpression
+        if (data == ExpectedArgumentType.NoApproximation) return literalExpression
-        val expectedType = data?.getExpectedType(constExpression)
+        val expectedType = data?.getExpectedType(literalExpression)
         if (expectedType is ConeIntegerConstantOperatorType) {
-            return constExpression
+            return literalExpression
         }
-        return constExpression.transformSingle(integerOperatorApproximator, expectedType)
+        return literalExpression.transformSingle(integerOperatorApproximator, expectedType)
     }
 
     override fun transformIntegerLiteralOperatorCall(

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirWhenExhaustivenessTransformer.kt

@@ -271,7 +271,7 @@ private object WhenOnBooleanExhaustivenessChecker : WhenExhaustivenessChecker()
         override fun visitEqualityOperatorCall(equalityOperatorCall: FirEqualityOperatorCall, data: Flags) {
             if (equalityOperatorCall.operation.let { it == FirOperation.EQ || it == FirOperation.IDENTITY }) {
                 val argument = equalityOperatorCall.arguments[1]
-                if (argument is FirConstExpression<*>) {
+                if (argument is FirLiteralExpression<*>) {
                     when (argument.value) {
                         true -> data.containsTrue = true
                         false -> data.containsFalse = true

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/IntegerLiteralAndOperatorApproximationTransformer.kt

@@ -10,10 +10,9 @@ import org.jetbrains.kotlin.fakeElement
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
+import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
 import org.jetbrains.kotlin.fir.expressions.FirIntegerLiteralOperatorCall
 import org.jetbrains.kotlin.fir.expressions.FirStatement
-import org.jetbrains.kotlin.fir.expressions.UnresolvedExpressionTypeAccess
 import org.jetbrains.kotlin.fir.expressions.builder.buildFunctionCall
 import org.jetbrains.kotlin.fir.references.FirResolvedErrorReference
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
@@ -58,17 +57,17 @@ class IntegerLiteralAndOperatorApproximationTransformer(
         return element
     }
 
-    override fun <T> transformConstExpression(
+    override fun <T> transformLiteralExpression(
-        constExpression: FirConstExpression<T>,
+        literalExpression: FirLiteralExpression<T>,
         data: ConeKotlinType?,
     ): FirStatement {
-        val type = constExpression.resolvedType as? ConeIntegerLiteralType ?: return constExpression
+        val type = literalExpression.resolvedType as? ConeIntegerLiteralType ?: return literalExpression
         val approximatedType = type.getApproximatedType(data?.fullyExpandedType(session))
-        constExpression.resultType = approximatedType
+        literalExpression.resultType = approximatedType
         @Suppress("UNCHECKED_CAST")
         val kind = approximatedType.toConstKind() as ConstantValueKind<T>
-        constExpression.replaceKind(kind)
+        literalExpression.replaceKind(kind)
-        return constExpression
+        return literalExpression
     }
 
     override fun transformIntegerLiteralOperatorCall(

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformerDispatcher.kt

@@ -299,13 +299,13 @@ abstract class FirAbstractBodyResolveTransformerDispatcher(
         FirDeclarationsResolveTransformer::transformWrappedDelegateExpression,
     )
 
-    override fun <T> transformConstExpression(
+    override fun <T> transformLiteralExpression(
-        constExpression: FirConstExpression<T>,
+        literalExpression: FirLiteralExpression<T>,
         data: ResolutionMode,
     ): FirStatement = expressionTransformation(
-        constExpression,
+        literalExpression,
         data,
-        FirExpressionsResolveTransformer::transformConstExpression,
+        FirExpressionsResolveTransformer::transformLiteralExpression,
     )
 
     override fun transformAnnotation(

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt

@@ -1089,7 +1089,7 @@ open class FirExpressionsResolveTransformer(transformer: FirAbstractBodyResolveT
     ): FirStatement = whileAnalysing(session, getClassCall) {
         getClassCall.transformAnnotations(transformer, ResolutionMode.ContextIndependent)
         val arg = getClassCall.argument
-        val dataForLhs = if (arg is FirConstExpression<*>) {
+        val dataForLhs = if (arg is FirLiteralExpression<*>) {
             withExpectedType(arg.kind.expectedConeType(session).toFirResolvedTypeRef())
         } else {
             ResolutionMode.ContextIndependent
@@ -1163,16 +1163,16 @@ open class FirExpressionsResolveTransformer(transformer: FirAbstractBodyResolveT
         return true
     }
 
-    override fun <T> transformConstExpression(
+    override fun <T> transformLiteralExpression(
-        constExpression: FirConstExpression<T>,
+        literalExpression: FirLiteralExpression<T>,
         data: ResolutionMode,
     ): FirStatement {
-        constExpression.transformAnnotations(transformer, ResolutionMode.ContextIndependent)
+        literalExpression.transformAnnotations(transformer, ResolutionMode.ContextIndependent)
 
-        val type = when (val kind = constExpression.kind) {
+        val type = when (val kind = literalExpression.kind) {
             ConstantValueKind.IntegerLiteral, ConstantValueKind.UnsignedIntegerLiteral -> {
                 val expressionType = ConeIntegerLiteralConstantTypeImpl.create(
-                    constExpression.value as Long,
+                    literalExpression.value as Long,
                     isTypePresent = { it.lookupTag.toSymbol(session) != null },
                     isUnsigned = kind == ConstantValueKind.UnsignedIntegerLiteral
                 )
@@ -1183,7 +1183,7 @@ open class FirExpressionsResolveTransformer(transformer: FirAbstractBodyResolveT
                         expressionType
                     }
                     expressionType is ConeClassLikeType -> {
-                        constExpression.replaceKind(expressionType.toConstKind() as ConstantValueKind<T>)
+                        literalExpression.replaceKind(expressionType.toConstKind() as ConstantValueKind<T>)
                         expressionType
                     }
                     data is ResolutionMode.ReceiverResolution && !data.forCallableReference -> {
@@ -1194,7 +1194,7 @@ open class FirExpressionsResolveTransformer(transformer: FirAbstractBodyResolveT
                         require(expressionType is ConeIntegerLiteralConstantTypeImpl)
                         val coneType = expectedTypeRef.coneTypeSafe<ConeKotlinType>()?.fullyExpandedType(session)
                         val approximatedType = expressionType.getApproximatedType(coneType)
-                        constExpression.replaceKind(approximatedType.toConstKind() as ConstantValueKind<T>)
+                        literalExpression.replaceKind(approximatedType.toConstKind() as ConstantValueKind<T>)
                         approximatedType
                     }
                     else -> {
@@ -1205,17 +1205,17 @@ open class FirExpressionsResolveTransformer(transformer: FirAbstractBodyResolveT
             else -> kind.expectedConeType(session)
         }
 
-        dataFlowAnalyzer.exitConstExpression(constExpression as FirConstExpression<*>)
+        dataFlowAnalyzer.exitConstExpression(literalExpression as FirLiteralExpression<*>)
-        constExpression.resultType = type
+        literalExpression.resultType = type
 
-        return when (val resolvedType = constExpression.resolvedType) {
+        return when (val resolvedType = literalExpression.resolvedType) {
             is ConeErrorType -> buildErrorExpression {
-                expression = constExpression
+                expression = literalExpression
                 diagnostic = resolvedType.diagnostic
-                source = constExpression.source
+                source = literalExpression.source
             }
 
-            else -> constExpression
+            else -> literalExpression
         }
     }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/ConeEffectExtractor.kt

@@ -130,7 +130,7 @@ class ConeEffectExtractor(
         }
 
         val argument = equalityOperatorCall.arguments[1]
-        val const = argument as? FirConstExpression<*> ?: return ConeContractDescriptionError.NotAConstant(argument).asElement()
+        val const = argument as? FirLiteralExpression<*> ?: return ConeContractDescriptionError.NotAConstant(argument).asElement()
         if (const.kind != ConstantValueKind.Null) return ConeContractDescriptionError.IllegalConst(const, onlyNullAllowed = true).asElement()
 
         val arg = equalityOperatorCall.arguments[0].asContractValueExpression()
@@ -203,14 +203,14 @@ class ConeEffectExtractor(
         }
     }
 
-    override fun <T> visitConstExpression(constExpression: FirConstExpression<T>, data: Nothing?): ConeContractDescriptionElement {
+    override fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>, data: Nothing?): ConeContractDescriptionElement {
-        return when (constExpression.kind) {
+        return when (literalExpression.kind) {
             ConstantValueKind.Null -> ConeContractConstantValues.NULL
-            ConstantValueKind.Boolean -> when (constExpression.value as Boolean) {
+            ConstantValueKind.Boolean -> when (literalExpression.value as Boolean) {
                 true -> ConeContractConstantValues.TRUE
                 false -> ConeContractConstantValues.FALSE
             }
-            else -> ConeContractDescriptionError.IllegalConst(constExpression, onlyNullAllowed = false).asElement()
+            else -> ConeContractDescriptionError.IllegalConst(literalExpression, onlyNullAllowed = false).asElement()
         }
     }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/mpp/FirExpectActualMatchingContextImpl.kt

@@ -483,7 +483,7 @@ class FirExpectActualMatchingContextImpl private constructor(
         // Because of that, we have "honest" checker at backend IR stage
         // and "only simplest case" checker in frontend, so that we have at least some reporting in the IDE.
         return when {
-            expression1 is FirConstExpression<*> && expression2 is FirConstExpression<*> -> {
+            expression1 is FirLiteralExpression<*> && expression2 is FirLiteralExpression<*> -> {
                 expression1.value == expression2.value
             }
             else -> true

compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/CFGNode.kt

@@ -668,7 +668,7 @@ class JumpNode(owner: ControlFlowGraph, override val fir: FirJump<*>, level: Int
         return visitor.visitJumpNode(this, data)
     }
 }
-class ConstExpressionNode(owner: ControlFlowGraph, override val fir: FirConstExpression<*>, level: Int) : CFGNode<FirConstExpression<*>>(owner, level) {
+class ConstExpressionNode(owner: ControlFlowGraph, override val fir: FirLiteralExpression<*>, level: Int) : CFGNode<FirLiteralExpression<*>>(owner, level) {
     override fun <R, D> accept(visitor: ControlFlowGraphVisitor<R, D>, data: D): R {
         return visitor.visitConstExpressionNode(this, data)
     }

compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/diagnostics/ConeDiagnostics.kt

@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.declarations.FirVariable
 import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnosticWithNullability
 import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnosticWithSource
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
+import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
 import org.jetbrains.kotlin.fir.expressions.FirOperation
 import org.jetbrains.kotlin.fir.expressions.FirThisReceiverExpression
 import org.jetbrains.kotlin.fir.render
@@ -199,7 +199,7 @@ sealed class ConeContractDescriptionError : ConeDiagnostic {
     }
 
     class IllegalConst(
-        val element: FirConstExpression<*>,
+        val element: FirLiteralExpression<*>,
         val onlyNullAllowed: Boolean
     ) : ConeContractDescriptionError() {
         override val reason: String

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirLiteralExpression.kt

@@ -16,9 +16,9 @@ import org.jetbrains.kotlin.fir.visitors.FirVisitor
 import org.jetbrains.kotlin.types.ConstantValueKind
 
 /**
- * Generated from: [org.jetbrains.kotlin.fir.tree.generator.FirTreeBuilder.constExpression]
+ * Generated from: [org.jetbrains.kotlin.fir.tree.generator.FirTreeBuilder.literalExpression]
  */
-abstract class FirConstExpression<T> : FirExpression() {
+abstract class FirLiteralExpression<T> : FirExpression() {
     abstract override val source: KtSourceElement?
     @UnresolvedExpressionTypeAccess
     abstract override val coneTypeOrNull: ConeKotlinType?
@@ -27,11 +27,11 @@ abstract class FirConstExpression<T> : FirExpression() {
     abstract val value: T
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
-        visitor.visitConstExpression(this, data)
+        visitor.visitLiteralExpression(this, data)
 
     @Suppress("UNCHECKED_CAST")
     override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
-        transformer.transformConstExpression(this, data) as E
+        transformer.transformLiteralExpression(this, data) as E
 
     abstract override fun replaceConeTypeOrNull(newConeTypeOrNull: ConeKotlinType?)
 
@@ -39,5 +39,5 @@ abstract class FirConstExpression<T> : FirExpression() {
 
     abstract fun replaceKind(newKind: ConstantValueKind<T>)
 
-    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirConstExpression<T>
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirLiteralExpression<T>
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirLiteralExpressionImpl.kt

@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.fir.MutableOrEmptyList
 import org.jetbrains.kotlin.fir.builder.toMutableOrEmpty
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
+import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
 import org.jetbrains.kotlin.fir.expressions.UnresolvedExpressionTypeAccess
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
@@ -23,25 +23,25 @@ import org.jetbrains.kotlin.fir.visitors.transformInplace
 import org.jetbrains.kotlin.types.ConstantValueKind
 
 @OptIn(UnresolvedExpressionTypeAccess::class)
-internal class FirConstExpressionImpl<T> (
+internal class FirLiteralExpressionImpl<T> (
     override val source: KtSourceElement?,
     @property:UnresolvedExpressionTypeAccess
     override var coneTypeOrNull: ConeKotlinType?,
     override var annotations: MutableOrEmptyList<FirAnnotation>,
     override var kind: ConstantValueKind<T>,
     override val value: T,
-) : FirConstExpression<T>() {
+) : FirLiteralExpression<T>() {
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         annotations.forEach { it.accept(visitor, data) }
     }
 
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirConstExpressionImpl<T> {
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirLiteralExpressionImpl<T> {
         transformAnnotations(transformer, data)
         return this
     }
 
-    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirConstExpressionImpl<T> {
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirLiteralExpressionImpl<T> {
         annotations.transformInplace(transformer, data)
         return this
     }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt

@@ -101,8 +101,8 @@ abstract class FirDefaultVisitor<out R, in D> : FirVisitor<R, D>() {
     override fun visitContinueExpression(continueExpression: FirContinueExpression, data: D): R =
         visitLoopJump(continueExpression, data)
 
-    override fun <T> visitConstExpression(constExpression: FirConstExpression<T>, data: D): R =
+    override fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>, data: D): R =
-        visitExpression(constExpression, data)
+        visitExpression(literalExpression, data)
 
     override fun visitStarProjection(starProjection: FirStarProjection, data: D): R =
         visitTypeProjection(starProjection, data)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt

@@ -74,7 +74,7 @@ abstract class FirDefaultVisitorVoid : FirVisitorVoid() {
 
     override fun visitContinueExpression(continueExpression: FirContinueExpression) = visitLoopJump(continueExpression)
 
-    override fun <T> visitConstExpression(constExpression: FirConstExpression<T>) = visitExpression(constExpression)
+    override fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>) = visitExpression(literalExpression)
 
     override fun visitStarProjection(starProjection: FirStarProjection) = visitTypeProjection(starProjection)
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt

@@ -555,12 +555,12 @@ abstract class FirTransformer<in D> : FirVisitor<FirElement, D>() {
         return transformTryExpression(tryExpression, data)
     }
 
-    open fun <T> transformConstExpression(constExpression: FirConstExpression<T>, data: D): FirStatement {
+    open fun <T> transformLiteralExpression(literalExpression: FirLiteralExpression<T>, data: D): FirStatement {
-        return transformElement(constExpression, data)
+        return transformElement(literalExpression, data)
     }
 
-    final override fun <T> visitConstExpression(constExpression: FirConstExpression<T>, data: D): FirStatement {
+    final override fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>, data: D): FirStatement {
-        return transformConstExpression(constExpression, data)
+        return transformLiteralExpression(literalExpression, data)
     }
 
     open fun transformTypeProjection(typeProjection: FirTypeProjection, data: D): FirTypeProjection {

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt

@@ -221,8 +221,8 @@ abstract class FirVisitor<out R, in D> {
     open fun visitTryExpression(tryExpression: FirTryExpression, data: D): R =
         visitElement(tryExpression, data)
 
-    open fun <T> visitConstExpression(constExpression: FirConstExpression<T>, data: D): R =
+    open fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>, data: D): R =
-        visitElement(constExpression, data)
+        visitElement(literalExpression, data)
 
     open fun visitTypeProjection(typeProjection: FirTypeProjection, data: D): R =
         visitElement(typeProjection, data)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt

@@ -555,12 +555,12 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitElement(tryExpression)
     }
 
-    final override fun <T> visitConstExpression(constExpression: FirConstExpression<T>, data: Nothing?) {
+    final override fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>, data: Nothing?) {
-        visitConstExpression(constExpression)
+        visitLiteralExpression(literalExpression)
     }
 
-    open fun <T> visitConstExpression(constExpression: FirConstExpression<T>) {
+    open fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>) {
-        visitElement(constExpression)
+        visitElement(literalExpression)
     }
 
     final override fun visitTypeProjection(typeProjection: FirTypeProjection, data: Nothing?) {

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpressionUtil.kt

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.declarations.utils.isStatic
 import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
-import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression
+import org.jetbrains.kotlin.fir.expressions.builder.buildLiteralExpression
 import org.jetbrains.kotlin.fir.expressions.builder.buildErrorExpression
 import org.jetbrains.kotlin.fir.expressions.builder.buildErrorLoop
 import org.jetbrains.kotlin.fir.expressions.impl.FirBlockImpl
@@ -34,7 +34,7 @@ inline val FirAnnotation.unexpandedClassId: ClassId?
 
 fun <T> buildConstOrErrorExpression(source: KtSourceElement?, kind: ConstantValueKind<T>, value: T?, diagnostic: ConeDiagnostic): FirExpression =
     value?.let {
-        buildConstExpression(source, kind, it, setType = false)
+        buildLiteralExpression(source, kind, it, setType = false)
     } ?: buildErrorExpression {
         this.source = source
         this.diagnostic = diagnostic

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/builder/FirConstExpressionBuilder.kt

@@ -8,22 +8,22 @@ package org.jetbrains.kotlin.fir.expressions.builder
 import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.fir.builder.toMutableOrEmpty
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
-import org.jetbrains.kotlin.fir.expressions.FirConstExpression
+import org.jetbrains.kotlin.fir.expressions.FirLiteralExpression
 import org.jetbrains.kotlin.fir.expressions.UnresolvedExpressionTypeAccess
-import org.jetbrains.kotlin.fir.expressions.impl.FirConstExpressionImpl
+import org.jetbrains.kotlin.fir.expressions.impl.FirLiteralExpressionImpl
 import org.jetbrains.kotlin.fir.types.constructClassLikeType
 import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.types.ConstantValueKind
 
 @OptIn(UnresolvedExpressionTypeAccess::class)
-fun <T> buildConstExpression(
+fun <T> buildLiteralExpression(
     source: KtSourceElement?,
     kind: ConstantValueKind<T>,
     value: T,
     annotations: MutableList<FirAnnotation> = mutableListOf(),
     setType: Boolean
-): FirConstExpression<T> {
+): FirLiteralExpression<T> {
-    return FirConstExpressionImpl(source, null, annotations.toMutableOrEmpty(), kind, value).also {
+    return FirLiteralExpressionImpl(source, null, annotations.toMutableOrEmpty(), kind, value).also {
         if (setType) {
             when (kind) {
                 ConstantValueKind.Boolean -> it.coneTypeOrNull = StandardClassIds.Boolean.constructClassLikeType()

compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirRenderer.kt

@@ -699,10 +699,10 @@ class FirRenderer(
             print("LAZY_EXPRESSION")
         }
 
-        override fun <T> visitConstExpression(constExpression: FirConstExpression<T>) {
+        override fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>) {
-            annotationRenderer?.render(constExpression)
+            annotationRenderer?.render(literalExpression)
-            val kind = constExpression.kind
+            val kind = literalExpression.kind
-            val value = constExpression.value
+            val value = literalExpression.value
             print("$kind(")
             if (value !is Char) {
                 print(value.toString())

compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirTypeUtils.kt

@@ -85,7 +85,7 @@ val FirTypeRef.isArrayType: Boolean
                 || StandardClassIds.unsignedArrayTypeByElementType.values.any { isBuiltinType(it, false) }
 
 val FirExpression.isNullLiteral: Boolean
-    get() = this is FirConstExpression<*> &&
+    get() = this is FirLiteralExpression<*> &&
             this.kind == ConstantValueKind.Null &&
             this.value == null &&
             this.source != null