From ec77e1896c3a0eb3896c69fe51d3966a9e321539 Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Wed, 26 Oct 2022 16:54:27 +0200 Subject: [PATCH] FIR2IR: cleanup CallAndReferenceGenerator --- .../generators/CallAndReferenceGenerator.kt | 33 ++++++++++++++++++- 1 file changed, 32 insertions(+), 1 deletion(-) diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt index 9f8851ed177..9571f6a037d 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt @@ -116,6 +116,7 @@ class CallAndReferenceGenerator( origin = origin ).applyTypeArguments(callableReferenceAccess).applyReceivers(callableReferenceAccess, explicitReceiverExpression) } + is IrLocalDelegatedPropertySymbol -> { IrLocalDelegatedPropertyReferenceImpl( startOffset, endOffset, type, symbol, @@ -125,6 +126,7 @@ class CallAndReferenceGenerator( origin = origin ) } + is IrFieldSymbol -> { val fieldSymbol = computeFieldSymbolForCallableReference(callableReferenceAccess, symbol) val referencedField = fieldSymbol.owner @@ -146,6 +148,7 @@ class CallAndReferenceGenerator( origin ).applyReceivers(callableReferenceAccess, explicitReceiverExpression) } + is IrFunctionSymbol -> { assert(type.isFunctionTypeOrSubtype()) { "Callable reference whose symbol refers to a function should be of functional type." @@ -171,6 +174,7 @@ class CallAndReferenceGenerator( .applyReceivers(callableReferenceAccess, explicitReceiverExpression) } } + else -> { IrErrorCallExpressionImpl( startOffset, endOffset, type, "Unsupported callable reference: ${callableReferenceAccess.render()}" @@ -299,16 +303,19 @@ class CallAndReferenceGenerator( OperatorNameConventions.GET -> IrDynamicOperator.ARRAY_ACCESS else -> error("Unexpected name") } + is KtFakeSourceElementKind.DesugaredPrefixNameReference -> when (calleeReference.resolved?.name) { OperatorNameConventions.INC -> IrDynamicOperator.PREFIX_INCREMENT OperatorNameConventions.DEC -> IrDynamicOperator.PREFIX_DECREMENT else -> error("Unexpected name") } + is KtFakeSourceElementKind.DesugaredPostfixNameReference -> when (calleeReference.resolved?.name) { OperatorNameConventions.INC -> IrDynamicOperator.POSTFIX_INCREMENT OperatorNameConventions.DEC -> IrDynamicOperator.POSTFIX_DECREMENT else -> error("Unexpected name") } + else -> null } @@ -345,10 +352,12 @@ class CallAndReferenceGenerator( } IrDynamicOperatorExpressionImpl(startOffset, endOffset, theType, operator) } + is FirPropertySymbol -> { val name = calleeReference.resolved?.name ?: error("There must be a name") IrDynamicMemberExpressionImpl(startOffset, endOffset, type, name.identifier, explicitReceiverExpression) } + else -> generateErrorCallExpression(startOffset, endOffset, calleeReference, type) } }.applyTypeArguments(qualifiedAccess).applyReceivers(qualifiedAccess, convertedExplicitReceiver) @@ -429,6 +438,7 @@ class CallAndReferenceGenerator( superQualifierSymbol = dispatchReceiver.superQualifierSymbol() ) } + is IrLocalDelegatedPropertySymbol -> { IrCallImpl( startOffset, endOffset, type, symbol.owner.getter.symbol, @@ -438,6 +448,7 @@ class CallAndReferenceGenerator( superQualifierSymbol = dispatchReceiver.superQualifierSymbol() ) } + is IrPropertySymbol -> { val getter = symbol.owner.getter val backingField = symbol.owner.backingField @@ -449,16 +460,19 @@ class CallAndReferenceGenerator( origin = IrStatementOrigin.GET_PROPERTY, superQualifierSymbol = dispatchReceiver.superQualifierSymbol() ) + backingField != null -> IrGetFieldImpl( startOffset, endOffset, backingField.symbol, type, superQualifierSymbol = dispatchReceiver.superQualifierSymbol() ) + else -> IrErrorCallExpressionImpl( startOffset, endOffset, type, description = "No getter or backing field found for ${calleeReference.render()}" ) } } + is IrFieldSymbol -> if (annotationMode) { val resolvedSymbol = calleeReference.resolvedSymbol ?: error("should have resolvedSymbol") val returnType = (resolvedSymbol as FirCallableSymbol<*>).resolvedReturnTypeRef.toIrType() @@ -472,6 +486,7 @@ class CallAndReferenceGenerator( superQualifierSymbol = dispatchReceiver.superQualifierSymbol() ) } + is IrValueSymbol -> { IrGetValueImpl( startOffset, endOffset, type, symbol, @@ -479,6 +494,7 @@ class CallAndReferenceGenerator( else calleeReference.statementOrigin() ) } + is IrEnumEntrySymbol -> IrGetEnumValueImpl(startOffset, endOffset, type, symbol) else -> generateErrorCallExpression(startOffset, endOffset, calleeReference, type) } @@ -513,6 +529,7 @@ class CallAndReferenceGenerator( arguments.add(assignedValue) } } + else -> generateErrorCallExpression(startOffset, endOffset, calleeReference) } }.applyTypeArguments(variableAssignment).applyReceivers(variableAssignment, convertedExplicitReceiver) @@ -548,6 +565,7 @@ class CallAndReferenceGenerator( is IrFieldSymbol -> IrSetFieldImpl(startOffset, endOffset, symbol, type, origin).apply { value = assignedValue } + is IrLocalDelegatedPropertySymbol -> { val setter = symbol.owner.setter when { @@ -561,9 +579,11 @@ class CallAndReferenceGenerator( putContextReceiverArguments(variableAssignment) putValueArgument(0, assignedValue) } + else -> generateErrorCallExpression(startOffset, endOffset, calleeReference) } } + is IrPropertySymbol -> { val irProperty = symbol.owner val setter = irProperty.setter @@ -578,6 +598,7 @@ class CallAndReferenceGenerator( ).apply { putValueArgument(putContextReceiverArguments(variableAssignment), assignedValue) } + backingField != null -> IrSetFieldImpl( startOffset, endOffset, backingField.symbol, type, origin = null, // NB: to be consistent with PSI2IR, origin should be null here @@ -585,9 +606,11 @@ class CallAndReferenceGenerator( ).apply { value = assignedValue } + else -> generateErrorCallExpression(startOffset, endOffset, calleeReference) } } + is IrSimpleFunctionSymbol -> { IrCallImpl( startOffset, endOffset, type, symbol, @@ -598,9 +621,11 @@ class CallAndReferenceGenerator( putValueArgument(0, assignedValue) } } + is IrVariableSymbol -> { IrSetValueImpl(startOffset, endOffset, type, symbol, assignedValue, origin) } + else -> generateErrorCallExpression(startOffset, endOffset, calleeReference) } }.applyTypeArguments(variableAssignment).applyReceivers(variableAssignment, explicitReceiverExpression) @@ -647,6 +672,7 @@ class CallAndReferenceGenerator( } } + else -> { IrErrorCallExpressionImpl( startOffset, @@ -798,6 +824,7 @@ class CallAndReferenceGenerator( } } } + is IrDynamicOperatorExpression -> apply { if (call == null) return@apply val (valueParameters, argumentMapping, substitutor) = extractArgumentsMapping(call) @@ -812,11 +839,13 @@ class CallAndReferenceGenerator( } } } + is IrErrorCallExpressionImpl -> apply { for (argument in call?.arguments.orEmpty()) { addArgument(visitor.convertToIrExpression(argument)) } } + else -> this } } @@ -879,7 +908,7 @@ class CallAndReferenceGenerator( if (parameter.isVararg && !argumentMapping.containsValue(parameter)) { val defaultValue = parameter.defaultValue val value = if (defaultValue != null) { - convertArgument(defaultValue, parameter, ConeSubstitutor.Empty, annotationMode) + convertArgument(defaultValue, parameter, ConeSubstitutor.Empty, annotationMode = true) } else { val elementType = parameter.returnTypeRef.toIrType() IrVarargImpl( @@ -1050,12 +1079,14 @@ class CallAndReferenceGenerator( } } } + is IrFieldAccessExpression -> { val ownerField = symbol.owner if (!ownerField.isStatic) { receiver = qualifiedAccess.findIrDispatchReceiver(explicitReceiverExpression) } } + is IrDynamicOperatorExpression -> { receiver = explicitReceiverExpression ?: error("No receiver for dynamic") }