azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[FIR] Rename FirElvisCall to FirElvisExpression

Browse Source 
FirElvisCall is not a FirCall, so FirElvisExpression is more
  convenient name
This commit is contained in:
Dmitriy Novozhilov
2020-07-02 16:33:22 +03:00
parent 1db2ba51d2
commit 59bedaaa55
24 changed files with 92 additions and 93 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt
+4 -4
View File
@@ -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)
compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt
+7 -7
View File
@@ -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
+2 -3
View File
@@ -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
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt
+1 -1
View File
@@ -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
+1 -1
View File
@@ -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
+3 -3
View File
@@ -1016,11 +1016,11 @@ abstract class FirDataFlowAnalyzer<FLOW : Flow>(
// ----------------------------------- 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,
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/CFGNode.kt
+4 -4
View File
@@ -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
+8 -8
View File
@@ -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> {
val exitNode = createElvisExitNode(elvisCall).also {
exitElvisCallNodes.push(it)
fun exitElvisLhs(elvisExpression: FirElvisExpression): Triple<ElvisLhsExitNode, ElvisLhsIsNotNullNode, ElvisRhsEnterNode> {
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()
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphNodeBuilder.kt
+4 -4
View File
@@ -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
+1 -1
View File
@@ -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
+2 -2
View File
@@ -435,8 +435,8 @@ class FirCallCompletionResultsWriterTransformer(
return transformSyntheticCall(checkNotNullCall, data)
}
override fun transformElvisCall(elvisCall: FirElvisCall, data: ExpectedArgumentType?): CompositeTransformResult<FirStatement> {
return transformSyntheticCall(elvisCall, data)
override fun transformElvisExpression(elvisExpression: FirElvisExpression, data: ExpectedArgumentType?): CompositeTransformResult<FirStatement> {
return transformSyntheticCall(elvisExpression, data)
}
private inline fun <reified D> transformSyntheticCall(
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt
+5 -5
View File
@@ -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(
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirBodyResolveTransformer.kt
+2 -2
View File
@@ -304,8 +304,8 @@ open class FirBodyResolveTransformer(
return controlFlowStatementsTransformer.transformThrowExpression(throwExpression, data)
}
override fun transformElvisCall(elvisCall: FirElvisCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
return controlFlowStatementsTransformer.transformElvisCall(elvisCall, data)
override fun transformElvisExpression(elvisExpression: FirElvisExpression, data: ResolutionMode): CompositeTransformResult<FirStatement> {
return controlFlowStatementsTransformer.transformElvisExpression(elvisExpression, data)
}
// --------------------------------------------------------------------------
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt
+8 -8
View File
@@ -209,16 +209,16 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
// ------------------------------- Elvis -------------------------------
override fun transformElvisCall(elvisCall: FirElvisCall, data: ResolutionMode): CompositeTransformResult<FirStatement> {
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<FirStatement> {
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)
}
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirElvisCall.kt → compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirElvisExpression.kt
+6 -6
View File
@@ -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/FirElvisCallBuilder.kt → compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirElvisExpressionBuilder.kt
+8 -8
View File
@@ -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 {
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()
}
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirElvisCallImpl.kt → compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirElvisExpressionImpl.kt
+8 -8
View File
@@ -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
+5 -5
View File
@@ -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> {
return transformElement(elvisCall, data)
open fun transformElvisExpression(elvisExpression: FirElvisExpression, data: D): CompositeTransformResult<FirStatement> {
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> {
return transformElvisCall(elvisCall, data)
final override fun visitElvisExpression(elvisExpression: FirElvisExpression, data: D): CompositeTransformResult<FirStatement> {
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
+2 -2
View File
@@ -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
+5 -5
View File
@@ -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) {
visitElement(elvisCall)
open fun visitElvisExpression(elvisExpression: FirElvisExpression) {
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?) {
visitElvisCall(elvisCall)
final override fun visitElvisExpression(elvisExpression: FirElvisExpression, data: Nothing?) {
visitElvisExpression(elvisExpression)
}
final override fun visitArrayOfCall(arrayOfCall: FirArrayOfCall, data: Nothing?) {
compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt
+3 -3
View File
@@ -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) {
compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/BuilderConfigurator.kt
+1 -1
View File
@@ -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
+1 -1
View File
@@ -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
+1 -1
View File
@@ -187,7 +187,7 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
needTransformOtherChildren()
}
elvisCall.configure {
elvisExpression.configure {
+field("lhs", expression).withTransform()
+field("rhs", expression).withTransform()
}