From 6c5cf8eda35122a6e6bd26d0ab9b78a9b5c59aed Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Mon, 14 Sep 2020 13:10:36 +0300 Subject: [PATCH] [FIR] Cleanup code in body resolve --- .../body/resolve/BodyResolveContext.kt | 4 +- .../body/resolve/FirBodyResolveTransformer.kt | 47 ++++++-- ...ControlFlowStatementsResolveTransformer.kt | 12 ++- .../FirDeclarationsResolveTransformer.kt | 100 +++++++++--------- .../FirExpressionsResolveTransformer.kt | 28 ++--- 5 files changed, 109 insertions(+), 82 deletions(-) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveContext.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveContext.kt index 6e39b8d45ad..a20d1eb5b04 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveContext.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveContext.kt @@ -70,9 +70,7 @@ class BodyResolveContext( @OptIn(PrivateForInline::class) inline fun withNewTowerDataForClassParts(newContexts: FirTowerDataContextsForClassParts, f: () -> T): T { val old = towerDataContextsForClassParts - towerDataContextsForClassParts = newContexts - return try { f() } finally { @@ -180,7 +178,7 @@ class BodyResolveContext( fun createSnapshotForLocalClasses( returnTypeCalculator: ReturnTypeCalculator, targetedLocalClasses: Set> - ) = BodyResolveContext(returnTypeCalculator, dataFlowAnalyzerContext, targetedLocalClasses, outerLocalClassForNested).apply { + ): BodyResolveContext = BodyResolveContext(returnTypeCalculator, dataFlowAnalyzerContext, targetedLocalClasses, outerLocalClassForNested).apply { file = this@BodyResolveContext.file towerDataContextForAnonymousFunctions.putAll(this@BodyResolveContext.towerDataContextForAnonymousFunctions) containers = this@BodyResolveContext.containers 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 7a2e1ac300a..59618303921 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 @@ -100,7 +100,7 @@ open class FirBodyResolveTransformer( wrappedArgumentExpression: FirWrappedArgumentExpression, data: ResolutionMode ): CompositeTransformResult { - return (wrappedArgumentExpression.transformChildren(this, data) as FirStatement).compose() + return transformElement(wrappedArgumentExpression, data) } override fun transformQualifiedAccessExpression( @@ -139,7 +139,10 @@ open class FirBodyResolveTransformer( return expressionsTransformer.transformComparisonExpression(comparisonExpression, data) } - override fun transformTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: ResolutionMode): CompositeTransformResult { + override fun transformTypeOperatorCall( + typeOperatorCall: FirTypeOperatorCall, + data: ResolutionMode + ): CompositeTransformResult { return expressionsTransformer.transformTypeOperatorCall(typeOperatorCall, data) } @@ -189,7 +192,10 @@ open class FirBodyResolveTransformer( return declarationsTransformer.transformWrappedDelegateExpression(wrappedDelegateExpression, data) } - override fun transformConstExpression(constExpression: FirConstExpression, data: ResolutionMode): CompositeTransformResult { + override fun transformConstExpression( + constExpression: FirConstExpression, + data: ResolutionMode + ): CompositeTransformResult { return expressionsTransformer.transformConstExpression(constExpression, data) } @@ -204,7 +210,10 @@ open class FirBodyResolveTransformer( return expressionsTransformer.transformDelegatedConstructorCall(delegatedConstructorCall, data) } - override fun transformAugmentedArraySetCall(augmentedArraySetCall: FirAugmentedArraySetCall, data: ResolutionMode): CompositeTransformResult { + override fun transformAugmentedArraySetCall( + augmentedArraySetCall: FirAugmentedArraySetCall, + data: ResolutionMode + ): CompositeTransformResult { return expressionsTransformer.transformAugmentedArraySetCall(augmentedArraySetCall, data) } @@ -249,15 +258,24 @@ open class FirBodyResolveTransformer( return declarationsTransformer.transformRegularClass(regularClass, data) } - override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: ResolutionMode): CompositeTransformResult { + override fun transformAnonymousObject( + anonymousObject: FirAnonymousObject, + data: ResolutionMode + ): CompositeTransformResult { return declarationsTransformer.transformAnonymousObject(anonymousObject, data) } - override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: ResolutionMode): CompositeTransformResult { + override fun transformSimpleFunction( + simpleFunction: FirSimpleFunction, + data: ResolutionMode + ): CompositeTransformResult { return declarationsTransformer.transformSimpleFunction(simpleFunction, data) } - override fun > transformFunction(function: FirFunction, data: ResolutionMode): CompositeTransformResult { + override fun > transformFunction( + function: FirFunction, + data: ResolutionMode + ): CompositeTransformResult { return declarationsTransformer.transformFunction(function, data) } @@ -272,7 +290,10 @@ open class FirBodyResolveTransformer( return declarationsTransformer.transformAnonymousInitializer(anonymousInitializer, data) } - override fun transformAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: ResolutionMode): CompositeTransformResult { + override fun transformAnonymousFunction( + anonymousFunction: FirAnonymousFunction, + data: ResolutionMode + ): CompositeTransformResult { return declarationsTransformer.transformAnonymousFunction(anonymousFunction, data) } @@ -317,11 +338,17 @@ open class FirBodyResolveTransformer( return controlFlowStatementsTransformer.transformJump(jump, data) } - override fun transformThrowExpression(throwExpression: FirThrowExpression, data: ResolutionMode): CompositeTransformResult { + override fun transformThrowExpression( + throwExpression: FirThrowExpression, + data: ResolutionMode + ): CompositeTransformResult { return controlFlowStatementsTransformer.transformThrowExpression(throwExpression, data) } - override fun transformElvisExpression(elvisExpression: FirElvisExpression, data: ResolutionMode): CompositeTransformResult { + 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 7e37098280f..ab70600c345 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 @@ -45,9 +45,8 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran // Do-while has a specific scope structure (its block and condition effectively share the scope) return withNewLocalScope { doWhileLoop.also(dataFlowAnalyzer::enterDoWhileLoop) - .apply { - transformer.expressionsTransformer.transformBlockInCurrentScope(block, context) - dataFlowAnalyzer + .also { + transformer.expressionsTransformer.transformBlockInCurrentScope(it.block, context) } .also(dataFlowAnalyzer::enterDoWhileLoopCondition).transformCondition(transformer, context) .also(dataFlowAnalyzer::exitDoWhileLoop) @@ -140,7 +139,7 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran return tryExpression.compose() } - tryExpression.annotations.forEach { it.accept(this, data) } + tryExpression.transformAnnotations(transformer, ResolutionMode.ContextIndependent) dataFlowAnalyzer.enterTryExpression(tryExpression) tryExpression.transformTryBlock(transformer, ResolutionMode.ContextDependent) dataFlowAnalyzer.exitTryMainBlock(tryExpression) @@ -211,7 +210,10 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran // ------------------------------- Elvis ------------------------------- - override fun transformElvisExpression(elvisExpression: FirElvisExpression, data: ResolutionMode): CompositeTransformResult { + 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) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt index ce5e9ad7a7c..b4ebfb47a1b 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt @@ -410,7 +410,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor if (anonymousObject.classKind == ClassKind.ENUM_ENTRY) { anonymousObject.getPrimaryConstructorIfAny()?.symbol?.callableId?.className?.shortName() } else null - var result = withScopesForClass(labelName, anonymousObject, type) { + val result = withScopesForClass(labelName, anonymousObject, type) { transformDeclarationContent(anonymousObject, data).single as FirAnonymousObject } if (!implicitTypeOnly && result.controlFlowGraphReference == null) { @@ -431,12 +431,10 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor lambdaResolution.expectedReturnTypeRef ?: anonymousFunction.returnTypeRef.takeUnless { it is FirImplicitTypeRef } val result = transformFunction(anonymousFunction, withExpectedType(expectedReturnType)).single as FirAnonymousFunction val body = result.body - return if (result.returnTypeRef is FirImplicitTypeRef && body != null) { + if (result.returnTypeRef is FirImplicitTypeRef && body != null) { result.transformReturnTypeRef(transformer, withExpectedType(body.resultType)) - result - } else { - result } + return result } val label = anonymousFunction.label @@ -492,7 +490,6 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor function: F, resolutionMode: ResolutionMode, ): CompositeTransformResult { - @Suppress("UNCHECKED_CAST") val result = transformFunction(function, resolutionMode).single as F @@ -691,15 +688,15 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor it.type, it, anonymousFunction, returnTypeVariable = null, components, candidate = null ) } - var af = anonymousFunction - val valueParameters = - if (resolvedLambdaAtom == null) af.valueParameters - else { + var lambda = anonymousFunction + val valueParameters = when (resolvedLambdaAtom) { + null -> lambda.valueParameters + else -> { val singleParameterType = resolvedLambdaAtom.parameters.singleOrNull() - val itParam = when { - af.valueParameters.isEmpty() && singleParameterType != null -> { + when { + lambda.valueParameters.isEmpty() && singleParameterType != null -> { val name = Name.identifier("it") - buildValueParameter { + val itParam = buildValueParameter { session = this@FirDeclarationsResolveTransformer.session origin = FirDeclarationOrigin.Source returnTypeRef = buildResolvedTypeRef { type = singleParameterType } @@ -709,42 +706,42 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor isNoinline = false isVararg = false } + listOf(itParam) } - else -> null - } - if (itParam != null) { - listOf(itParam) - } else { - af.valueParameters.mapIndexed { index, param -> - if (param.returnTypeRef is FirResolvedTypeRef) { - param - } else { - param.transformReturnTypeRef( - StoreType, - param.returnTypeRef.resolvedTypeFromPrototype( - resolvedLambdaAtom.parameters[index] + + else -> { + lambda.valueParameters.mapIndexed { index, param -> + if (param.returnTypeRef is FirResolvedTypeRef) { + param + } else { + param.transformReturnTypeRef( + StoreType, + param.returnTypeRef.resolvedTypeFromPrototype( + resolvedLambdaAtom.parameters[index] + ) ) - ) - param + param + } } } } - } - val returnTypeRefFromResolvedAtom = resolvedLambdaAtom?.returnType?.let { af.returnTypeRef.resolvedTypeFromPrototype(it) } - af = af.copy( - receiverTypeRef = af.receiverTypeRef?.takeIf { it !is FirImplicitTypeRef } - ?: resolvedLambdaAtom?.receiver?.let { af.receiverTypeRef?.resolvedTypeFromPrototype(it) }, + } + val returnTypeRefFromResolvedAtom = + resolvedLambdaAtom?.returnType?.let { lambda.returnTypeRef.resolvedTypeFromPrototype(it) } + lambda = lambda.copy( + receiverTypeRef = lambda.receiverTypeRef?.takeIf { it !is FirImplicitTypeRef } + ?: resolvedLambdaAtom?.receiver?.let { lambda.receiverTypeRef?.resolvedTypeFromPrototype(it) }, valueParameters = valueParameters, - returnTypeRef = (af.returnTypeRef as? FirResolvedTypeRef) + returnTypeRef = (lambda.returnTypeRef as? FirResolvedTypeRef) ?: returnTypeRefFromResolvedAtom - ?: af.returnTypeRef + ?: lambda.returnTypeRef ) - af = af.transformValueParameters(ImplicitToErrorTypeTransformer, null) + lambda = lambda.transformValueParameters(ImplicitToErrorTypeTransformer, null) val bodyExpectedType = returnTypeRefFromResolvedAtom ?: expectedTypeRef - val labelName = af.label?.name?.let { Name.identifier(it) } - withLabelAndReceiverType(labelName, af, af.receiverTypeRef?.coneType) { - af = transformFunction(af, withExpectedType(bodyExpectedType)).single as FirAnonymousFunction + val labelName = lambda.label?.name?.let { Name.identifier(it) } + withLabelAndReceiverType(labelName, lambda, lambda.receiverTypeRef?.coneType) { + lambda = transformFunction(lambda, withExpectedType(bodyExpectedType)).single as FirAnonymousFunction } // To separate function and separate commit val writer = FirCallCompletionResultsWriterTransformer( @@ -755,20 +752,20 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor integerOperatorsTypeUpdater, integerLiteralTypeApproximator ) - af.transformSingle(writer, expectedTypeRef.coneTypeSafe()?.toExpectedType()) - val returnTypes = dataFlowAnalyzer.returnExpressionsOfAnonymousFunction(af) + lambda.transformSingle(writer, expectedTypeRef.coneTypeSafe()?.toExpectedType()) + val returnTypes = dataFlowAnalyzer.returnExpressionsOfAnonymousFunction(lambda) .mapNotNull { (it as? FirExpression)?.resultType?.coneType } - af.replaceReturnTypeRef( - af.returnTypeRef.resolvedTypeFromPrototype( + lambda.replaceReturnTypeRef( + lambda.returnTypeRef.resolvedTypeFromPrototype( inferenceComponents.ctx.commonSuperTypeOrNull(returnTypes) ?: session.builtinTypes.unitType.type ) ) - af.replaceTypeRef( - af.constructFunctionalTypeRef( + lambda.replaceTypeRef( + lambda.constructFunctionalTypeRef( isSuspend = expectedTypeRef.coneTypeSafe()?.isSuspendFunctionType(session) == true ) ) - af.addReturn().compose() + lambda.addReturn().compose() } is ResolutionMode.WithStatus -> { throw AssertionError("Should not be here in WithStatus mode") @@ -861,12 +858,11 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor components.context.replaceTowerDataContext(forMembersResolution) - val newContexts = - FirTowerDataContextsForClassParts( - newTowerDataContextForStaticNestedClasses, - scopeForConstructorHeader, - primaryConstructorParametersScope - ) + val newContexts = FirTowerDataContextsForClassParts( + newTowerDataContextForStaticNestedClasses, + scopeForConstructorHeader, + primaryConstructorParametersScope + ) context.withNewTowerDataForClassParts(newContexts) { block() diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt index ed22adb1232..8db46574fd6 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt @@ -50,8 +50,10 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform if (expression.resultType is FirImplicitTypeRef && expression !is FirWrappedExpression) { val type = buildErrorTypeRef { source = expression.source - diagnostic = - ConeSimpleDiagnostic("Type calculating for ${expression::class} is not supported", DiagnosticKind.InferenceError) + diagnostic = ConeSimpleDiagnostic( + "Type calculating for ${expression::class} is not supported", + DiagnosticKind.InferenceError + ) } expression.resultType = type } @@ -260,8 +262,8 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform if (functionCall.calleeReference !is FirSimpleNamedReference) return functionCall.compose() if (functionCall.calleeReference is FirNamedReferenceWithCandidate) return functionCall.compose() dataFlowAnalyzer.enterCall() - functionCall.annotations.forEach { it.accept(this, data) } - functionCall.transform(InvocationKindTransformer, null) + functionCall.transformAnnotations(transformer, data) + functionCall.transformSingle(InvocationKindTransformer, null) functionCall.transformTypeArguments(transformer, ResolutionMode.ContextIndependent) val expectedTypeRef = data.expectedType val (completeInference, callCompleted) = @@ -302,9 +304,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform block.transformStatementsIndexed(transformer) { index -> val value = if (index == numberOfStatements - 1) data else ResolutionMode.ContextIndependent - transformer.onBeforeStatementResolution(block.statements[index]) - TransformData.Data(value) } if (data == ResolutionMode.ContextIndependent) { @@ -334,7 +334,8 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform ): CompositeTransformResult { return (comparisonExpression.transformChildren(transformer, ResolutionMode.ContextIndependent) as FirComparisonExpression).also { it.resultType = comparisonExpression.typeRef.resolvedTypeFromPrototype(builtinTypes.booleanType.type) - }.transformSingle(integerLiteralTypeApproximator, null).also(dataFlowAnalyzer::exitComparisonExpressionCall).compose() + }.transformSingle(integerLiteralTypeApproximator, null) + .also(dataFlowAnalyzer::exitComparisonExpressionCall).compose() } override fun transformAssignmentOperatorStatement( @@ -347,7 +348,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform val leftArgument = assignmentOperatorStatement.leftArgument.transformSingle(transformer, ResolutionMode.ContextIndependent) val rightArgument = assignmentOperatorStatement.rightArgument.transformSingle(transformer, ResolutionMode.ContextDependent) - fun createFunctionCall(name: Name) = buildFunctionCall { + fun createFunctionCall(name: Name): FirFunctionCall = buildFunctionCall { source = assignmentOperatorStatement.source?.fakeElement(FirFakeSourceElementKind.DesugaredCompoundAssignment) explicitReceiver = leftArgument argumentList = buildUnaryArgumentList(rightArgument) @@ -424,7 +425,6 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform equalityOperatorCall: FirEqualityOperatorCall, data: ResolutionMode ): CompositeTransformResult { - // TODO: add approximation of integer literals val result = (equalityOperatorCall.transformChildren(transformer, ResolutionMode.ContextIndependent) as FirEqualityOperatorCall) .also { it.resultType = equalityOperatorCall.typeRef.resolvedTypeFromPrototype(builtinTypes.booleanType.type) } .transformSingle(integerLiteralTypeApproximator, null) @@ -451,7 +451,8 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform val baseTypeArguments = argument.typeRef.coneTypeSafe()?.fullyExpandedType(session)?.typeArguments val type = coneTypeSafe() - return if (type?.typeArguments?.isEmpty() != true || + return if ( + type?.typeArguments?.isEmpty() != true || type is ConeTypeParameterType || baseTypeArguments?.isEmpty() != false || (type is ConeClassLikeType && @@ -471,6 +472,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform typeOperatorCall.transformConversionTypeRef(transformer, ResolutionMode.ContextIndependent) }.transformOtherChildren(transformer, ResolutionMode.ContextIndependent) resolved.argumentList.transformArguments(integerLiteralTypeApproximator, null) + val conversionTypeRef = resolved.conversionTypeRef.withTypeArgumentsForBareType(resolved.argument) resolved.transformChildren(object : FirDefaultTransformer() { override fun transformElement(element: E, data: Nothing?): CompositeTransformResult { @@ -485,6 +487,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform } } }, null) + when (resolved.operation) { FirOperation.IS, FirOperation.NOT_IS -> { resolved.resultType = session.builtinTypes.booleanType @@ -504,7 +507,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform ), ) } - else -> error("Unknown type operator") + else -> error("Unknown type operator: ${resolved.operation}") } dataFlowAnalyzer.exitTypeOperatorCall(resolved) return resolved.transform(integerLiteralTypeApproximator, null) @@ -591,7 +594,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform return callableReferenceAccess.compose() } - callableReferenceAccess.annotations.forEach { it.accept(this, data) } + callableReferenceAccess.transformAnnotations(transformer, data) val explicitReceiver = callableReferenceAccess.explicitReceiver val transformedLHS = explicitReceiver?.transformSingle(this, ResolutionMode.ContextIndependent)?.apply { if (this is FirResolvedQualifier && callableReferenceAccess.hasQuestionMarkAtLHS) { @@ -872,6 +875,7 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform assert(augmentedArraySetCall.operation in FirOperation.ASSIGNMENTS) assert(augmentedArraySetCall.operation != FirOperation.ASSIGN) + augmentedArraySetCall.transformAnnotations(transformer, data) val operatorName = FirOperationNameConventions.ASSIGNMENTS.getValue(augmentedArraySetCall.operation) val firstCalls = with(augmentedArraySetCall.setGetBlock.statements.last() as FirFunctionCall) setCall@{