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

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 =
-        visitExpression(constExpression, data)
+    override fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>, data: D): R =
+        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 {
-        return transformElement(constExpression, data)
+    open fun <T> transformLiteralExpression(literalExpression: FirLiteralExpression<T>, data: D): FirStatement {
+        return transformElement(literalExpression, data)
     }
 
-    final override fun <T> visitConstExpression(constExpression: FirConstExpression<T>, data: D): FirStatement {
-        return transformConstExpression(constExpression, data)
+    final override fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>, data: D): FirStatement {
+        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 =
-        visitElement(constExpression, data)
+    open fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>, data: D): R =
+        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?) {
-        visitConstExpression(constExpression)
+    final override fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>, data: Nothing?) {
+        visitLiteralExpression(literalExpression)
     }
 
-    open fun <T> visitConstExpression(constExpression: FirConstExpression<T>) {
-        visitElement(constExpression)
+    open fun <T> visitLiteralExpression(literalExpression: FirLiteralExpression<T>) {
+        visitElement(literalExpression)
     }
 
     final override fun visitTypeProjection(typeProjection: FirTypeProjection, data: Nothing?) {