From 59bedaaa55db0a645b8f38c1ce21b1dc9be53716 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Thu, 2 Jul 2020 16:33:22 +0300 Subject: [PATCH] [FIR] Rename FirElvisCall to FirElvisExpression FirElvisCall is not a FirCall, so FirElvisExpression is more convenient name --- .../org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt | 8 ++++---- .../kotlin/fir/backend/Fir2IrVisitor.kt | 14 +++++++------- .../kotlin/fir/builder/ConversionUtils.kt | 5 ++--- .../kotlin/fir/resolve/calls/Arguments.kt | 2 +- .../kotlin/fir/resolve/calls/CandidateFactory.kt | 2 +- .../fir/resolve/dfa/FirDataFlowAnalyzer.kt | 6 +++--- .../kotlin/fir/resolve/dfa/cfg/CFGNode.kt | 8 ++++---- .../resolve/dfa/cfg/ControlFlowGraphBuilder.kt | 16 ++++++++-------- .../dfa/cfg/ControlFlowGraphNodeBuilder.kt | 8 ++++---- .../inference/ConstraintSystemCompleter.kt | 2 +- .../FirCallCompletionResultsWriterTransformer.kt | 4 ++-- .../transformers/FirSyntheticCallGenerator.kt | 10 +++++----- .../body/resolve/FirBodyResolveTransformer.kt | 4 ++-- ...FirControlFlowStatementsResolveTransformer.kt | 16 ++++++++-------- .../{FirElvisCall.kt => FirElvisExpression.kt} | 12 ++++++------ ...llBuilder.kt => FirElvisExpressionBuilder.kt} | 16 ++++++++-------- ...lvisCallImpl.kt => FirElvisExpressionImpl.kt} | 16 ++++++++-------- .../kotlin/fir/visitors/FirTransformer.kt | 10 +++++----- .../jetbrains/kotlin/fir/visitors/FirVisitor.kt | 4 ++-- .../kotlin/fir/visitors/FirVisitorVoid.kt | 10 +++++----- .../src/org/jetbrains/kotlin/fir/FirRenderer.kt | 6 +++--- .../fir/tree/generator/BuilderConfigurator.kt | 2 +- .../kotlin/fir/tree/generator/FirTreeBuilder.kt | 2 +- .../fir/tree/generator/NodeConfigurator.kt | 2 +- 24 files changed, 92 insertions(+), 93 deletions(-) rename compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/{FirElvisCall.kt => FirElvisExpression.kt} (82%) rename compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/{FirElvisCallBuilder.kt => FirElvisExpressionBuilder.kt} (77%) rename compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/{FirElvisCallImpl.kt => FirElvisExpressionImpl.kt} (87%) diff --git a/compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt b/compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt index 619db970250..2fc64f024ab 100644 --- a/compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt +++ b/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) { - generate(elvisCall.lhs) + private fun FlowContent.generate(elvisExpression: FirElvisExpression) { + 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) diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt index 019e322a834..0094541c57c 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt +++ b/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("") - 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() ) } } diff --git a/compiler/fir/raw-fir/fir-common/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt b/compiler/fir/raw-fir/fir-common/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt index 17d466584b0..415997ef767 100644 --- a/compiler/fir/raw-fir/fir-common/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt +++ b/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 { - return buildElvisCall { +): FirElvisExpression { + return buildElvisExpression { source = baseSource lhs = this@generateNotNullOrOther rhs = other diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt index c42e0c2fd59..a95ea2854a5 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt +++ b/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, diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateFactory.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateFactory.kt index a0606da2c5e..0f060730aa1 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CandidateFactory.kt +++ b/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) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirDataFlowAnalyzer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirDataFlowAnalyzer.kt index b823f99eeb3..a5dfbe27571 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirDataFlowAnalyzer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirDataFlowAnalyzer.kt @@ -1016,11 +1016,11 @@ abstract class FirDataFlowAnalyzer( // ----------------------------------- Elvis ----------------------------------- - fun exitElvisLhs(elvisCall: FirElvisCall) { - val (lhsExitNode, lhsIsNotNullNode, rhsEnterNode) = graphBuilder.exitElvisLhs(elvisCall) + fun exitElvisLhs(elvisExpression: FirElvisExpression) { + 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, diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/CFGNode.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/CFGNode.kt index aaa2d7aaf34..5f9913f292c 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/CFGNode.kt +++ b/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(owner, level, id) { +class ElvisLhsExitNode(owner: ControlFlowGraph, override val fir: FirElvisExpression, level: Int, id: Int) : CFGNode(owner, level, id) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitElvisLhsExitNode(this, data) } } -class ElvisLhsIsNotNullNode(owner: ControlFlowGraph, override val fir: FirElvisCall, level: Int, id: Int) : CFGNode(owner, level, id) { +class ElvisLhsIsNotNullNode(owner: ControlFlowGraph, override val fir: FirElvisExpression, level: Int, id: Int) : CFGNode(owner, level, id) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitElvisLhsIsNotNullNode(this, data) } } -class ElvisRhsEnterNode(owner: ControlFlowGraph, override val fir: FirElvisCall, level: Int, id: Int) : CFGNode(owner, level, id) { +class ElvisRhsEnterNode(owner: ControlFlowGraph, override val fir: FirElvisExpression, level: Int, id: Int) : CFGNode(owner, level, id) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitElvisRhsEnterNode(this, data) } } -class ElvisExitNode(owner: ControlFlowGraph, override val fir: FirElvisCall, level: Int, id: Int) : AbstractBinaryExitNode(owner, level, id) { +class ElvisExitNode(owner: ControlFlowGraph, override val fir: FirElvisExpression, level: Int, id: Int) : AbstractBinaryExitNode(owner, level, id) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitElvisExitNode(this, data) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphBuilder.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphBuilder.kt index 0b376e2ecc3..710c52db03c 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphBuilder.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphBuilder.kt @@ -91,7 +91,7 @@ class ControlFlowGraphBuilder { private val initBlockExitNodes: Stack = stackOf() private val exitSafeCallNodes: Stack = stackOf() - private val exitElvisCallNodes: Stack = stackOf() + private val exitElvisExpressionNodes: Stack = stackOf() // ----------------------------------- API for node builders ----------------------------------- @@ -996,21 +996,21 @@ class ControlFlowGraphBuilder { // ----------------------------------- Elvis ----------------------------------- - fun exitElvisLhs(elvisCall: FirElvisCall): Triple { - val exitNode = createElvisExitNode(elvisCall).also { - exitElvisCallNodes.push(it) + fun exitElvisLhs(elvisExpression: FirElvisExpression): Triple { + val exitNode = createElvisExitNode(elvisExpression).also { + 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() diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphNodeBuilder.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphNodeBuilder.kt index 36355fea5bc..8c3a96455fe 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphNodeBuilder.kt +++ b/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 = diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/ConstraintSystemCompleter.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/ConstraintSystemCompleter.kt index 21e71da4cd5..4a27618c94f 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/ConstraintSystemCompleter.kt +++ b/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) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt index b261421cbc4..b1c70a05b13 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt +++ b/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 { - return transformSyntheticCall(elvisCall, data) + override fun transformElvisExpression(elvisExpression: FirElvisExpression, data: ExpectedArgumentType?): CompositeTransformResult { + return transformSyntheticCall(elvisExpression, data) } private inline fun transformSyntheticCall( diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt index a83f8ded27f..d9753b6e4fc 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt +++ b/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? { - if (elvisCall.calleeReference !is FirStubReference) return null + fun generateCalleeForElvisExpression(elvisExpression: FirElvisExpression): FirElvisExpression? { + if (elvisExpression.calleeReference !is FirStubReference) return null val argumentList = buildArgumentList { - arguments += elvisCall.lhs - arguments += elvisCall.rhs + arguments += elvisExpression.lhs + 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( diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt index ee4b32c91c5..10b269aeef1 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt +++ b/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 { - return controlFlowStatementsTransformer.transformElvisCall(elvisCall, data) + override fun transformElvisExpression(elvisExpression: FirElvisExpression, data: ResolutionMode): CompositeTransformResult { + return controlFlowStatementsTransformer.transformElvisExpression(elvisExpression, data) } // -------------------------------------------------------------------------- diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt index ee0b37686c9..16d88ab8406 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt +++ b/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 { - if (elvisCall.calleeReference is FirResolvedNamedReference) return elvisCall.compose() - elvisCall.transformAnnotations(transformer, data) - elvisCall.transformLhs(transformer, ResolutionMode.ContextDependent) - dataFlowAnalyzer.exitElvisLhs(elvisCall) - elvisCall.transformRhs(transformer, ResolutionMode.ContextDependent) + override fun transformElvisExpression(elvisExpression: FirElvisExpression, data: ResolutionMode): CompositeTransformResult { + if (elvisExpression.calleeReference is FirResolvedNamedReference) return elvisExpression.compose() + elvisExpression.transformAnnotations(transformer, data) + elvisExpression.transformLhs(transformer, ResolutionMode.ContextDependent) + dataFlowAnalyzer.exitElvisLhs(elvisExpression) + 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) } diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirElvisCall.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirElvisExpression.kt similarity index 82% rename from compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirElvisCall.kt rename to compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirElvisExpression.kt index fec924d568b..312ac4732d3 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirElvisCall.kt +++ b/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 @@ -23,17 +23,17 @@ abstract class FirElvisCall : FirExpression(), FirResolvable { abstract val lhs: FirExpression abstract val rhs: FirExpression - override fun accept(visitor: FirVisitor, data: D): R = visitor.visitElvisCall(this, data) + override fun accept(visitor: FirVisitor, data: D): R = visitor.visitElvisExpression(this, data) abstract override fun replaceTypeRef(newTypeRef: FirTypeRef) abstract override fun replaceCalleeReference(newCalleeReference: FirReference) - abstract override fun transformAnnotations(transformer: FirTransformer, data: D): FirElvisCall + abstract override fun transformAnnotations(transformer: FirTransformer, data: D): FirElvisExpression - abstract override fun transformCalleeReference(transformer: FirTransformer, data: D): FirElvisCall + abstract override fun transformCalleeReference(transformer: FirTransformer, data: D): FirElvisExpression - abstract fun transformLhs(transformer: FirTransformer, data: D): FirElvisCall + abstract fun transformLhs(transformer: FirTransformer, data: D): FirElvisExpression - abstract fun transformRhs(transformer: FirTransformer, data: D): FirElvisCall + abstract fun transformRhs(transformer: FirTransformer, data: D): FirElvisExpression } diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirElvisCallBuilder.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirElvisExpressionBuilder.kt similarity index 77% rename from compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirElvisCallBuilder.kt rename to compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirElvisExpressionBuilder.kt index ebd3c92a626..78cf552a51e 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirElvisCallBuilder.kt +++ b/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 = mutableListOf() var calleeReference: FirReference = FirStubReference lateinit var lhs: FirExpression lateinit var rhs: FirExpression - override fun build(): FirElvisCall { - return FirElvisCallImpl( + override fun build(): FirElvisExpression { + 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() } diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirElvisCallImpl.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirElvisExpressionImpl.kt similarity index 87% rename from compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirElvisCallImpl.kt rename to compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirElvisExpressionImpl.kt index 84d7274983c..95212c624f8 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirElvisCallImpl.kt +++ b/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, override var calleeReference: FirReference, override var lhs: FirExpression, override var rhs: FirExpression, -) : FirElvisCall() { +) : FirElvisExpression() { override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(null) override fun acceptChildren(visitor: FirVisitor, data: D) { @@ -36,7 +36,7 @@ internal class FirElvisCallImpl( rhs.accept(visitor, data) } - override fun transformChildren(transformer: FirTransformer, data: D): FirElvisCallImpl { + override fun transformChildren(transformer: FirTransformer, 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 transformAnnotations(transformer: FirTransformer, data: D): FirElvisCallImpl { + override fun transformAnnotations(transformer: FirTransformer, data: D): FirElvisExpressionImpl { annotations.transformInplace(transformer, data) return this } - override fun transformCalleeReference(transformer: FirTransformer, data: D): FirElvisCallImpl { + override fun transformCalleeReference(transformer: FirTransformer, data: D): FirElvisExpressionImpl { calleeReference = calleeReference.transformSingle(transformer, data) return this } - override fun transformLhs(transformer: FirTransformer, data: D): FirElvisCallImpl { + override fun transformLhs(transformer: FirTransformer, data: D): FirElvisExpressionImpl { lhs = lhs.transformSingle(transformer, data) return this } - override fun transformRhs(transformer: FirTransformer, data: D): FirElvisCallImpl { + override fun transformRhs(transformer: FirTransformer, data: D): FirElvisExpressionImpl { rhs = rhs.transformSingle(transformer, data) return this } diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt index c3a2728624d..af4cf939fbb 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt +++ b/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 : FirVisitor { - return transformElement(elvisCall, data) + open fun transformElvisExpression(elvisExpression: FirElvisExpression, data: D): CompositeTransformResult { + return transformElement(elvisExpression, data) } open fun transformArrayOfCall(arrayOfCall: FirArrayOfCall, data: D): CompositeTransformResult { @@ -916,8 +916,8 @@ abstract class FirTransformer : FirVisitor { - return transformElvisCall(elvisCall, data) + final override fun visitElvisExpression(elvisExpression: FirElvisExpression, data: D): CompositeTransformResult { + return transformElvisExpression(elvisExpression, data) } final override fun visitArrayOfCall(arrayOfCall: FirArrayOfCall, data: D): CompositeTransformResult { diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt index 8baa6642d55..909c4341a5d 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt +++ b/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 { 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) diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt index 8bbb7540bc3..f49206c3e94 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt +++ b/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() { visitElement(checkNotNullCall) } - open fun visitElvisCall(elvisCall: FirElvisCall) { - visitElement(elvisCall) + open fun visitElvisExpression(elvisExpression: FirElvisExpression) { + visitElement(elvisExpression) } open fun visitArrayOfCall(arrayOfCall: FirArrayOfCall) { @@ -914,8 +914,8 @@ abstract class FirVisitorVoid : FirVisitor() { visitCheckNotNullCall(checkNotNullCall) } - final override fun visitElvisCall(elvisCall: FirElvisCall, data: Nothing?) { - visitElvisCall(elvisCall) + final override fun visitElvisExpression(elvisExpression: FirElvisExpression, data: Nothing?) { + visitElvisExpression(elvisExpression) } final override fun visitArrayOfCall(arrayOfCall: FirArrayOfCall, data: Nothing?) { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt index 97fd561cb11..9abafd3e060 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt +++ b/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) { - elvisCall.lhs.accept(this) + override fun visitElvisExpression(elvisExpression: FirElvisExpression) { + elvisExpression.lhs.accept(this) print(" ?: ") - elvisCall.rhs.accept(this) + elvisExpression.rhs.accept(this) } override fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess) { diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/BuilderConfigurator.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/BuilderConfigurator.kt index 8ca7fec3973..ed0acb31658 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/BuilderConfigurator.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/BuilderConfigurator.kt @@ -287,7 +287,7 @@ object BuilderConfigurator : AbstractBuilderConfigurator(FirTree useTypes(stubReferenceType) } - builder(elvisCall) { + builder(elvisExpression) { default("calleeReference", "FirStubReference") useTypes(stubReferenceType) } diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FirTreeBuilder.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FirTreeBuilder.kt index 143a965241d..0a7e15ec530 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FirTreeBuilder.kt +++ b/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) diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt index d620213e822..eeb601cf6c4 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt @@ -187,7 +187,7 @@ object NodeConfigurator : AbstractFieldConfigurator(FirTreeBuild needTransformOtherChildren() } - elvisCall.configure { + elvisExpression.configure { +field("lhs", expression).withTransform() +field("rhs", expression).withTransform() }