[FIR] Rename FirElvisCall to FirElvisExpression

FirElvisCall is not a FirCall, so FirElvisExpression is more
  convenient name

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

@@ -1359,10 +1359,10 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
         +"!!"
     }
 
-    private fun FlowContent.generate(elvisCall: FirElvisCall) {
+    private fun FlowContent.generate(elvisExpression: FirElvisExpression) {
-        generate(elvisCall.lhs)
+        generate(elvisExpression.lhs)
         +" ?: "
-        generate(elvisCall.rhs)
+        generate(elvisExpression.rhs)
     }
 
     @Suppress("UNUSED_PARAMETER")
@@ -1569,7 +1569,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
                 is FirOperatorCall -> generate(expression)
                 is FirBinaryLogicExpression -> generate(expression)
                 is FirCheckNotNullCall -> generate(expression)
-                is FirElvisCall -> generate(expression)
+                is FirElvisExpression -> generate(expression)
                 is FirVarargArgumentsExpression -> generate(expression)
                 is FirResolvedReifiedParameterReference -> generate(expression)
                 is FirComparisonExpression -> generate(expression)

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

@@ -562,21 +562,21 @@ class Fir2IrVisitor(
         }
     }
 
-    override fun visitElvisCall(elvisCall: FirElvisCall, data: Any?): IrElement {
+    override fun visitElvisExpression(elvisExpression: FirElvisExpression, data: Any?): IrElement {
         val firLhsVariable = buildProperty {
-            source = elvisCall.source
+            source = elvisExpression.source
             session = this@Fir2IrVisitor.session
             origin = FirDeclarationOrigin.Source
-            returnTypeRef = elvisCall.lhs.typeRef
+            returnTypeRef = elvisExpression.lhs.typeRef
             name = Name.special("<elvis>")
-            initializer = elvisCall.lhs
+            initializer = elvisExpression.lhs
             symbol = FirPropertySymbol(name)
             isVar = false
             isLocal = true
             status = FirDeclarationStatusImpl(Visibilities.LOCAL, Modality.FINAL)
         }
         val irLhsVariable = firLhsVariable.accept(this, null) as IrVariable
-        return elvisCall.convertWithOffsets { startOffset, endOffset ->
+        return elvisExpression.convertWithOffsets { startOffset, endOffset ->
             fun irGetLhsValue(): IrGetValue =
                 IrGetValueImpl(startOffset, endOffset, irLhsVariable.type, irLhsVariable.symbol)
 
@@ -591,7 +591,7 @@ class Fir2IrVisitor(
                         irGetLhsValue(),
                         IrConstImpl.constNull(startOffset, endOffset, irBuiltIns.nothingNType)
                     ),
-                    convertToIrExpression(elvisCall.rhs)
+                    convertToIrExpression(elvisExpression.rhs)
                 ),
                 IrElseBranchImpl(
                     IrConstImpl.boolean(startOffset, endOffset, irBuiltIns.booleanType, true),
@@ -609,7 +609,7 @@ class Fir2IrVisitor(
             generateWhen(
                 startOffset, endOffset, IrStatementOrigin.ELVIS,
                 irLhsVariable, irBranches,
-                elvisCall.typeRef.toIrType()
+                elvisExpression.typeRef.toIrType()
             )
         }
     }

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

@@ -22,7 +22,6 @@ import org.jetbrains.kotlin.fir.expressions.builder.*
 import org.jetbrains.kotlin.fir.expressions.impl.FirModifiableQualifiedAccess
 import org.jetbrains.kotlin.fir.expressions.impl.FirSingleExpressionBlock
 import org.jetbrains.kotlin.fir.expressions.impl.FirStubStatement
-import org.jetbrains.kotlin.fir.expressions.impl.buildSingleExpressionBlock
 import org.jetbrains.kotlin.fir.references.FirNamedReference
 import org.jetbrains.kotlin.fir.references.builder.buildDelegateFieldReference
 import org.jetbrains.kotlin.fir.references.builder.buildImplicitThisReference
@@ -142,8 +141,8 @@ fun IElementType.toFirOperation(): FirOperation =
 
 fun FirExpression.generateNotNullOrOther(
     other: FirExpression, baseSource: FirSourceElement?,
-): FirElvisCall {
+): FirElvisExpression {
-    return buildElvisCall {
+    return buildElvisExpression {
         source = baseSource
         lhs = this@generateNotNullOrOther
         rhs = other

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt

@@ -42,7 +42,7 @@ fun Candidate.resolveArgumentExpression(
     isDispatch: Boolean
 ) {
     when (argument) {
-        is FirFunctionCall, is FirWhenExpression, is FirTryExpression, is FirCheckNotNullCall, is FirElvisCall -> resolveSubCallArgument(
+        is FirFunctionCall, is FirWhenExpression, is FirTryExpression, is FirCheckNotNullCall, is FirElvisExpression -> resolveSubCallArgument(
             csBuilder,
             argument as FirResolvable,
             expectedType,

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateFactory.kt

@@ -117,7 +117,7 @@ fun PostponedArgumentsAnalyzer.Context.addSubsystemFromExpression(statement: Fir
         is FirTryExpression,
         is FirCheckNotNullCall,
         is FirCallableReferenceAccess,
-        is FirElvisCall
+        is FirElvisExpression
         -> (statement as FirResolvable).candidate()?.let { addOtherSystem(it.system.asReadOnlyStorage()) }
 
         is FirSafeCallExpression -> addSubsystemFromExpression(statement.regularQualifiedAccess)

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

@@ -1016,11 +1016,11 @@ abstract class FirDataFlowAnalyzer<FLOW : Flow>(
 
     // ----------------------------------- Elvis -----------------------------------
 
-    fun exitElvisLhs(elvisCall: FirElvisCall) {
+    fun exitElvisLhs(elvisExpression: FirElvisExpression) {
-        val (lhsExitNode, lhsIsNotNullNode, rhsEnterNode) = graphBuilder.exitElvisLhs(elvisCall)
+        val (lhsExitNode, lhsIsNotNullNode, rhsEnterNode) = graphBuilder.exitElvisLhs(elvisExpression)
         lhsExitNode.mergeIncomingFlow()
         val flow = lhsExitNode.flow
-        val lhsVariable = variableStorage.getOrCreateVariable(flow, elvisCall.lhs)
+        val lhsVariable = variableStorage.getOrCreateVariable(flow, elvisExpression.lhs)
         rhsEnterNode.flow = logicSystem.approveStatementsInsideFlow(
             flow,
             lhsVariable eq null,

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

@@ -603,25 +603,25 @@ class ExitSafeCallNode(owner: ControlFlowGraph, override val fir: FirSafeCallExp
 
 // ----------------------------------- Elvis -----------------------------------
 
-class ElvisLhsExitNode(owner: ControlFlowGraph, override val fir: FirElvisCall, level: Int, id: Int) : CFGNode<FirElvisCall>(owner, level, id) {
+class ElvisLhsExitNode(owner: ControlFlowGraph, override val fir: FirElvisExpression, level: Int, id: Int) : CFGNode<FirElvisExpression>(owner, level, id) {
     override fun <R, D> accept(visitor: ControlFlowGraphVisitor<R, D>, data: D): R {
         return visitor.visitElvisLhsExitNode(this, data)
     }
 }
 
-class ElvisLhsIsNotNullNode(owner: ControlFlowGraph, override val fir: FirElvisCall, level: Int, id: Int) : CFGNode<FirElvisCall>(owner, level, id) {
+class ElvisLhsIsNotNullNode(owner: ControlFlowGraph, override val fir: FirElvisExpression, level: Int, id: Int) : CFGNode<FirElvisExpression>(owner, level, id) {
     override fun <R, D> accept(visitor: ControlFlowGraphVisitor<R, D>, data: D): R {
         return visitor.visitElvisLhsIsNotNullNode(this, data)
     }
 }
 
-class ElvisRhsEnterNode(owner: ControlFlowGraph, override val fir: FirElvisCall, level: Int, id: Int) : CFGNode<FirElvisCall>(owner, level, id) {
+class ElvisRhsEnterNode(owner: ControlFlowGraph, override val fir: FirElvisExpression, level: Int, id: Int) : CFGNode<FirElvisExpression>(owner, level, id) {
     override fun <R, D> accept(visitor: ControlFlowGraphVisitor<R, D>, data: D): R {
         return visitor.visitElvisRhsEnterNode(this, data)
     }
 }
 
-class ElvisExitNode(owner: ControlFlowGraph, override val fir: FirElvisCall, level: Int, id: Int) : AbstractBinaryExitNode<FirElvisCall>(owner, level, id) {
+class ElvisExitNode(owner: ControlFlowGraph, override val fir: FirElvisExpression, level: Int, id: Int) : AbstractBinaryExitNode<FirElvisExpression>(owner, level, id) {
     override fun <R, D> accept(visitor: ControlFlowGraphVisitor<R, D>, data: D): R {
         return visitor.visitElvisExitNode(this, data)
     }

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

@@ -91,7 +91,7 @@ class ControlFlowGraphBuilder {
     private val initBlockExitNodes: Stack<InitBlockExitNode> = stackOf()
 
     private val exitSafeCallNodes: Stack<ExitSafeCallNode> = stackOf()
-    private val exitElvisCallNodes: Stack<ElvisExitNode> = stackOf()
+    private val exitElvisExpressionNodes: Stack<ElvisExitNode> = stackOf()
 
     // ----------------------------------- API for node builders -----------------------------------
 
@@ -996,21 +996,21 @@ class ControlFlowGraphBuilder {
 
     // ----------------------------------- Elvis -----------------------------------
 
-    fun exitElvisLhs(elvisCall: FirElvisCall): Triple<ElvisLhsExitNode, ElvisLhsIsNotNullNode, ElvisRhsEnterNode> {
+    fun exitElvisLhs(elvisExpression: FirElvisExpression): Triple<ElvisLhsExitNode, ElvisLhsIsNotNullNode, ElvisRhsEnterNode> {
-        val exitNode = createElvisExitNode(elvisCall).also {
+        val exitNode = createElvisExitNode(elvisExpression).also {
-            exitElvisCallNodes.push(it)
+            exitElvisExpressionNodes.push(it)
         }
 
-        val lhsExitNode = createElvisLhsExitNode(elvisCall).also {
+        val lhsExitNode = createElvisLhsExitNode(elvisExpression).also {
             popAndAddEdge(it)
         }
 
-        val lhsIsNotNullNode = createElvisLhsIsNotNullNode(elvisCall).also {
+        val lhsIsNotNullNode = createElvisLhsIsNotNullNode(elvisExpression).also {
             addEdge(lhsExitNode, it)
             addEdge(it, exitNode)
         }
 
-        val rhsEnterNode = createElvisRhsEnterNode(elvisCall).also {
+        val rhsEnterNode = createElvisRhsEnterNode(elvisExpression).also {
             addEdge(lhsExitNode, it)
         }
         lastNodes.push(rhsEnterNode)
@@ -1018,7 +1018,7 @@ class ControlFlowGraphBuilder {
     }
 
     fun exitElvis(): ElvisExitNode {
-        val exitNode = exitElvisCallNodes.pop()
+        val exitNode = exitElvisExpressionNodes.pop()
         addNewSimpleNode(exitNode)
         exitNode.updateDeadStatus()
         dropPostponedLambdasForNonDeterministicCalls()

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

@@ -125,16 +125,16 @@ fun ControlFlowGraphBuilder.createAnnotationExitNode(fir: FirAnnotationCall): An
 fun ControlFlowGraphBuilder.createAnnotationEnterNode(fir: FirAnnotationCall): AnnotationEnterNode =
     AnnotationEnterNode(currentGraph, fir, levelCounter, createId())
 
-fun ControlFlowGraphBuilder.createElvisLhsIsNotNullNode(fir: FirElvisCall): ElvisLhsIsNotNullNode =
+fun ControlFlowGraphBuilder.createElvisLhsIsNotNullNode(fir: FirElvisExpression): ElvisLhsIsNotNullNode =
     ElvisLhsIsNotNullNode(currentGraph, fir, levelCounter, createId())
 
-fun ControlFlowGraphBuilder.createElvisRhsEnterNode(fir: FirElvisCall): ElvisRhsEnterNode =
+fun ControlFlowGraphBuilder.createElvisRhsEnterNode(fir: FirElvisExpression): ElvisRhsEnterNode =
     ElvisRhsEnterNode(currentGraph, fir, levelCounter, createId())
 
-fun ControlFlowGraphBuilder.createElvisLhsExitNode(fir: FirElvisCall): ElvisLhsExitNode =
+fun ControlFlowGraphBuilder.createElvisLhsExitNode(fir: FirElvisExpression): ElvisLhsExitNode =
     ElvisLhsExitNode(currentGraph, fir, levelCounter, createId())
 
-fun ControlFlowGraphBuilder.createElvisExitNode(fir: FirElvisCall): ElvisExitNode =
+fun ControlFlowGraphBuilder.createElvisExitNode(fir: FirElvisExpression): ElvisExitNode =
     ElvisExitNode(currentGraph, fir, levelCounter, createId())
 
 fun ControlFlowGraphBuilder.createVariableDeclarationNode(fir: FirProperty): VariableDeclarationNode =

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/ConstraintSystemCompleter.kt

@@ -294,7 +294,7 @@ fun FirStatement.processAllContainingCallCandidates(processBlocks: Boolean, proc
             this.arguments.forEach { it.processAllContainingCallCandidates(processBlocks, processor) }
         }
 
-        is FirElvisCall -> {
+        is FirElvisExpression -> {
             processCandidateIfApplicable(processor, processBlocks)
             lhs.processAllContainingCallCandidates(processBlocks, processor)
             rhs.processAllContainingCallCandidates(processBlocks, processor)

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

@@ -435,8 +435,8 @@ class FirCallCompletionResultsWriterTransformer(
         return transformSyntheticCall(checkNotNullCall, data)
     }
 
-    override fun transformElvisCall(elvisCall: FirElvisCall, data: ExpectedArgumentType?): CompositeTransformResult<FirStatement> {
+    override fun transformElvisExpression(elvisExpression: FirElvisExpression, data: ExpectedArgumentType?): CompositeTransformResult<FirStatement> {
-        return transformSyntheticCall(elvisCall, data)
+        return transformSyntheticCall(elvisExpression, data)
     }
 
     private inline fun <reified D> transformSyntheticCall(

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

@@ -103,12 +103,12 @@ class FirSyntheticCallGenerator(
         return checkNotNullCall.transformCalleeReference(UpdateReference, reference)
     }
 
-    fun generateCalleeForElvisCall(elvisCall: FirElvisCall): FirElvisCall? {
+    fun generateCalleeForElvisExpression(elvisExpression: FirElvisExpression): FirElvisExpression? {
-        if (elvisCall.calleeReference !is FirStubReference) return null
+        if (elvisExpression.calleeReference !is FirStubReference) return null
 
         val argumentList = buildArgumentList {
-            arguments += elvisCall.lhs
+            arguments += elvisExpression.lhs
-            arguments += elvisCall.rhs
+            arguments += elvisExpression.rhs
         }
         val reference = generateCalleeReferenceWithCandidate(
             elvisFunction,
@@ -116,7 +116,7 @@ class FirSyntheticCallGenerator(
             SyntheticCallableId.ELVIS_NOT_NULL.callableName
         ) ?: return null
 
-        return elvisCall.transformCalleeReference(UpdateReference, reference)
+        return elvisExpression.transformCalleeReference(UpdateReference, reference)
     }
 
     fun resolveCallableReferenceWithSyntheticOuterCall(

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

@@ -304,8 +304,8 @@ open class FirBodyResolveTransformer(
         return controlFlowStatementsTransformer.transformThrowExpression(throwExpression, data)
     }
 
-    override fun transformElvisCall(elvisCall: FirElvisCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
+    override fun transformElvisExpression(elvisExpression: FirElvisExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> {
-        return controlFlowStatementsTransformer.transformElvisCall(elvisCall, data)
+        return controlFlowStatementsTransformer.transformElvisExpression(elvisExpression, data)
     }
 
     // --------------------------------------------------------------------------

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

@@ -209,16 +209,16 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
 
     // ------------------------------- Elvis -------------------------------
 
-    override fun transformElvisCall(elvisCall: FirElvisCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
+    override fun transformElvisExpression(elvisExpression: FirElvisExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> {
-        if (elvisCall.calleeReference is FirResolvedNamedReference) return elvisCall.compose()
+        if (elvisExpression.calleeReference is FirResolvedNamedReference) return elvisExpression.compose()
-        elvisCall.transformAnnotations(transformer, data)
+        elvisExpression.transformAnnotations(transformer, data)
-        elvisCall.transformLhs(transformer, ResolutionMode.ContextDependent)
+        elvisExpression.transformLhs(transformer, ResolutionMode.ContextDependent)
-        dataFlowAnalyzer.exitElvisLhs(elvisCall)
+        dataFlowAnalyzer.exitElvisLhs(elvisExpression)
-        elvisCall.transformRhs(transformer, ResolutionMode.ContextDependent)
+        elvisExpression.transformRhs(transformer, ResolutionMode.ContextDependent)
 
-        val result = syntheticCallGenerator.generateCalleeForElvisCall(elvisCall)?.let {
+        val result = syntheticCallGenerator.generateCalleeForElvisExpression(elvisExpression)?.let {
             callCompleter.completeCall(it, data.expectedType).result
-        } ?: elvisCall.also {
+        } ?: elvisExpression.also {
             it.resultType = buildErrorTypeRef {
                 diagnostic = ConeSimpleDiagnostic("Can't resolve ?: operator call", DiagnosticKind.InferenceError)
             }

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

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-abstract class FirElvisCall : FirExpression(), FirResolvable {
+abstract class FirElvisExpression : FirExpression(), FirResolvable {
     abstract override val source: FirSourceElement?
     abstract override val typeRef: FirTypeRef
     abstract override val annotations: List<FirAnnotationCall>
@@ -23,17 +23,17 @@ abstract class FirElvisCall : FirExpression(), FirResolvable {
     abstract val lhs: FirExpression
     abstract val rhs: FirExpression
 
-    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitElvisCall(this, data)
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitElvisExpression(this, data)
 
     abstract override fun replaceTypeRef(newTypeRef: FirTypeRef)
 
     abstract override fun replaceCalleeReference(newCalleeReference: FirReference)
 
-    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirElvisCall
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirElvisExpression
 
-    abstract override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirElvisCall
+    abstract override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirElvisExpression
 
-    abstract fun <D> transformLhs(transformer: FirTransformer<D>, data: D): FirElvisCall
+    abstract fun <D> transformLhs(transformer: FirTransformer<D>, data: D): FirElvisExpression
 
-    abstract fun <D> transformRhs(transformer: FirTransformer<D>, data: D): FirElvisCall
+    abstract fun <D> transformRhs(transformer: FirTransformer<D>, data: D): FirElvisExpression
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirElvisExpressionBuilder.kt

@@ -10,10 +10,10 @@ import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
 import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.expressions.FirElvisCall
+import org.jetbrains.kotlin.fir.expressions.FirElvisExpression
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.builder.FirExpressionBuilder
-import org.jetbrains.kotlin.fir.expressions.impl.FirElvisCallImpl
+import org.jetbrains.kotlin.fir.expressions.impl.FirElvisExpressionImpl
 import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.references.impl.FirStubReference
 import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -26,15 +26,15 @@ import org.jetbrains.kotlin.fir.visitors.*
  */
 
 @FirBuilderDsl
-class FirElvisCallBuilder : FirAnnotationContainerBuilder, FirExpressionBuilder {
+class FirElvisExpressionBuilder : FirAnnotationContainerBuilder, FirExpressionBuilder {
     override var source: FirSourceElement? = null
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
     var calleeReference: FirReference = FirStubReference
     lateinit var lhs: FirExpression
     lateinit var rhs: FirExpression
 
-    override fun build(): FirElvisCall {
+    override fun build(): FirElvisExpression {
-        return FirElvisCallImpl(
+        return FirElvisExpressionImpl(
             source,
             annotations,
             calleeReference,
@@ -44,7 +44,7 @@ class FirElvisCallBuilder : FirAnnotationContainerBuilder, FirExpressionBuilder
     }
 
 
-    @Deprecated("Modification of 'typeRef' has no impact for FirElvisCallBuilder", level = DeprecationLevel.HIDDEN)
+    @Deprecated("Modification of 'typeRef' has no impact for FirElvisExpressionBuilder", level = DeprecationLevel.HIDDEN)
     override var typeRef: FirTypeRef
         get() = throw IllegalStateException()
         set(value) {
@@ -53,9 +53,9 @@ class FirElvisCallBuilder : FirAnnotationContainerBuilder, FirExpressionBuilder
 }
 
 @OptIn(ExperimentalContracts::class)
-inline fun buildElvisCall(init: FirElvisCallBuilder.() -> Unit): FirElvisCall {
+inline fun buildElvisExpression(init: FirElvisExpressionBuilder.() -> Unit): FirElvisExpression {
     contract {
         callsInPlace(init, kotlin.contracts.InvocationKind.EXACTLY_ONCE)
     }
-    return FirElvisCallBuilder().apply(init).build()
+    return FirElvisExpressionBuilder().apply(init).build()
 }

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

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.expressions.impl
 
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.expressions.FirElvisCall
+import org.jetbrains.kotlin.fir.expressions.FirElvisExpression
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -19,13 +19,13 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-internal class FirElvisCallImpl(
+internal class FirElvisExpressionImpl(
     override val source: FirSourceElement?,
     override val annotations: MutableList<FirAnnotationCall>,
     override var calleeReference: FirReference,
     override var lhs: FirExpression,
     override var rhs: FirExpression,
-) : FirElvisCall() {
+) : FirElvisExpression() {
     override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(null)
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
@@ -36,7 +36,7 @@ internal class FirElvisCallImpl(
         rhs.accept(visitor, data)
     }
 
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElvisCallImpl {
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElvisExpressionImpl {
         typeRef = typeRef.transformSingle(transformer, data)
         transformAnnotations(transformer, data)
         transformCalleeReference(transformer, data)
@@ -45,22 +45,22 @@ internal class FirElvisCallImpl(
         return this
     }
 
-    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirElvisCallImpl {
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirElvisExpressionImpl {
         annotations.transformInplace(transformer, data)
         return this
     }
 
-    override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirElvisCallImpl {
+    override fun <D> transformCalleeReference(transformer: FirTransformer<D>, data: D): FirElvisExpressionImpl {
         calleeReference = calleeReference.transformSingle(transformer, data)
         return this
     }
 
-    override fun <D> transformLhs(transformer: FirTransformer<D>, data: D): FirElvisCallImpl {
+    override fun <D> transformLhs(transformer: FirTransformer<D>, data: D): FirElvisExpressionImpl {
         lhs = lhs.transformSingle(transformer, data)
         return this
     }
 
-    override fun <D> transformRhs(transformer: FirTransformer<D>, data: D): FirElvisCallImpl {
+    override fun <D> transformRhs(transformer: FirTransformer<D>, data: D): FirElvisExpressionImpl {
         rhs = rhs.transformSingle(transformer, data)
         return this
     }

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

@@ -76,7 +76,7 @@ import org.jetbrains.kotlin.fir.expressions.FirWhenBranch
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessWithoutCallee
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess
 import org.jetbrains.kotlin.fir.expressions.FirCheckNotNullCall
-import org.jetbrains.kotlin.fir.expressions.FirElvisCall
+import org.jetbrains.kotlin.fir.expressions.FirElvisExpression
 import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall
 import org.jetbrains.kotlin.fir.expressions.FirAugmentedArraySetCall
 import org.jetbrains.kotlin.fir.expressions.FirClassReferenceExpression
@@ -420,8 +420,8 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformElement(checkNotNullCall, data)
     }
 
-    open fun transformElvisCall(elvisCall: FirElvisCall, data: D): CompositeTransformResult<FirStatement> {
+    open fun transformElvisExpression(elvisExpression: FirElvisExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformElement(elvisCall, data)
+        return transformElement(elvisExpression, data)
     }
 
     open fun transformArrayOfCall(arrayOfCall: FirArrayOfCall, data: D): CompositeTransformResult<FirStatement> {
@@ -916,8 +916,8 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformCheckNotNullCall(checkNotNullCall, data)
     }
 
-    final override fun visitElvisCall(elvisCall: FirElvisCall, data: D): CompositeTransformResult<FirStatement> {
+    final override fun visitElvisExpression(elvisExpression: FirElvisExpression, data: D): CompositeTransformResult<FirStatement> {
-        return transformElvisCall(elvisCall, data)
+        return transformElvisExpression(elvisExpression, data)
     }
 
     final override fun visitArrayOfCall(arrayOfCall: FirArrayOfCall, data: D): CompositeTransformResult<FirStatement> {

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

@@ -76,7 +76,7 @@ import org.jetbrains.kotlin.fir.expressions.FirWhenBranch
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessWithoutCallee
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess
 import org.jetbrains.kotlin.fir.expressions.FirCheckNotNullCall
-import org.jetbrains.kotlin.fir.expressions.FirElvisCall
+import org.jetbrains.kotlin.fir.expressions.FirElvisExpression
 import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall
 import org.jetbrains.kotlin.fir.expressions.FirAugmentedArraySetCall
 import org.jetbrains.kotlin.fir.expressions.FirClassReferenceExpression
@@ -278,7 +278,7 @@ abstract class FirVisitor<out R, in D> {
 
     open fun visitCheckNotNullCall(checkNotNullCall: FirCheckNotNullCall, data: D): R  = visitElement(checkNotNullCall, data)
 
-    open fun visitElvisCall(elvisCall: FirElvisCall, data: D): R  = visitElement(elvisCall, data)
+    open fun visitElvisExpression(elvisExpression: FirElvisExpression, data: D): R  = visitElement(elvisExpression, data)
 
     open fun visitArrayOfCall(arrayOfCall: FirArrayOfCall, data: D): R  = visitElement(arrayOfCall, data)
 

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

@@ -76,7 +76,7 @@ import org.jetbrains.kotlin.fir.expressions.FirWhenBranch
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessWithoutCallee
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess
 import org.jetbrains.kotlin.fir.expressions.FirCheckNotNullCall
-import org.jetbrains.kotlin.fir.expressions.FirElvisCall
+import org.jetbrains.kotlin.fir.expressions.FirElvisExpression
 import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall
 import org.jetbrains.kotlin.fir.expressions.FirAugmentedArraySetCall
 import org.jetbrains.kotlin.fir.expressions.FirClassReferenceExpression
@@ -418,8 +418,8 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitElement(checkNotNullCall)
     }
 
-    open fun visitElvisCall(elvisCall: FirElvisCall) {
+    open fun visitElvisExpression(elvisExpression: FirElvisExpression) {
-        visitElement(elvisCall)
+        visitElement(elvisExpression)
     }
 
     open fun visitArrayOfCall(arrayOfCall: FirArrayOfCall) {
@@ -914,8 +914,8 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitCheckNotNullCall(checkNotNullCall)
     }
 
-    final override fun visitElvisCall(elvisCall: FirElvisCall, data: Nothing?) {
+    final override fun visitElvisExpression(elvisExpression: FirElvisExpression, data: Nothing?) {
-        visitElvisCall(elvisCall)
+        visitElvisExpression(elvisExpression)
     }
 
     final override fun visitArrayOfCall(arrayOfCall: FirArrayOfCall, data: Nothing?) {

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

@@ -1022,10 +1022,10 @@ class FirRenderer(builder: StringBuilder, private val mode: RenderMode = RenderM
         print("!!")
     }
 
-    override fun visitElvisCall(elvisCall: FirElvisCall) {
+    override fun visitElvisExpression(elvisExpression: FirElvisExpression) {
-        elvisCall.lhs.accept(this)
+        elvisExpression.lhs.accept(this)
         print(" ?: ")
-        elvisCall.rhs.accept(this)
+        elvisExpression.rhs.accept(this)
     }
 
     override fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess) {

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/BuilderConfigurator.kt

@@ -287,7 +287,7 @@ object BuilderConfigurator : AbstractBuilderConfigurator<FirTreeBuilder>(FirTree
             useTypes(stubReferenceType)
         }
 
-        builder(elvisCall) {
+        builder(elvisExpression) {
             default("calleeReference", "FirStubReference")
             useTypes(stubReferenceType)
         }

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FirTreeBuilder.kt

@@ -91,7 +91,7 @@ object FirTreeBuilder : AbstractFirTreeBuilder() {
     val qualifiedAccessWithoutCallee = element("QualifiedAccessWithoutCallee", Expression, statement)
     val qualifiedAccess = element("QualifiedAccess", Expression, qualifiedAccessWithoutCallee, resolvable)
     val checkNotNullCall = element("CheckNotNullCall", Expression, expression, call, resolvable)
-    val elvisCall = element("ElvisCall", Expression, expression, resolvable)
+    val elvisExpression = element("ElvisExpression", Expression, expression, resolvable)
 
     val arrayOfCall = element("ArrayOfCall", Expression, expression, call)
     val arraySetCall = element("AugmentedArraySetCall", Expression, statement)

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt

@@ -187,7 +187,7 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
             needTransformOtherChildren()
         }
 
-        elvisCall.configure {
+        elvisExpression.configure {
             +field("lhs", expression).withTransform()
             +field("rhs", expression).withTransform()
         }