JVM_IR: implement single-abstract-method conversions

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ArgumentsGenerationUtils.kt

@@ -379,7 +379,7 @@ private fun StatementGenerator.pregenerateValueArguments(call: CallBuilder, reso
     generateSamConversionForValueArgumentsIfRequired(call, resolvedCall.resultingDescriptor)
 }
 
-private fun StatementGenerator.generateSamConversionForValueArgumentsIfRequired(call: CallBuilder, originalDescriptor: CallableDescriptor) {
+fun StatementGenerator.generateSamConversionForValueArgumentsIfRequired(call: CallBuilder, originalDescriptor: CallableDescriptor) {
     val underlyingDescriptor = context.extensions.samConversion.getOriginalForSamAdapter(originalDescriptor) ?: return
 
     val originalValueParameters = originalDescriptor.valueParameters

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/AssignmentGenerator.kt

@@ -72,6 +72,7 @@ class AssignmentGenerator(statementGenerator: StatementGenerator) : StatementGen
                 val opCall = statementGenerator.pregenerateCallReceivers(opResolvedCall)
                 opCall.setExplicitReceiverValue(irLValue)
                 opCall.irValueArgumentsByIndex[0] = ktRight.genExpr()
+                statementGenerator.generateSamConversionForValueArgumentsIfRequired(opCall, opResolvedCall.resultingDescriptor)
                 val irOpCall = CallGenerator(statementGenerator).generateCall(ktExpression, opCall, origin)
 
                 if (isSimpleAssignment) {

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/intermediate/ArrayAccessAssignmentReceiver.kt

@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.ir.expressions.impl.inlineStatement
 import org.jetbrains.kotlin.ir.expressions.isAssignmentOperatorWithResult
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi2ir.generators.CallGenerator
+import org.jetbrains.kotlin.psi2ir.generators.generateSamConversionForValueArgumentsIfRequired
 import org.jetbrains.kotlin.psi2ir.generators.pregenerateValueArgumentsUsing
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.calls.tasks.isDynamic
@@ -98,8 +99,8 @@ class ArrayAccessAssignmentReceiver(
         return LValueWithGetterAndSetterCalls(
             callGenerator,
             descriptor,
-            { indexedGetCall()?.fillArrayAndIndexArguments(irArrayValue, indexedGetResolvedCall!!, ktExpressionToIrIndexValue) },
-            { indexedSetCall()?.fillArrayAndIndexArguments(irArrayValue, indexedSetResolvedCall!!, ktExpressionToIrIndexValue) },
+            { indexedGetCall()?.fillArguments(irArrayValue, indexedGetResolvedCall!!, ktExpressionToIrIndexValue, null) },
+            { indexedSetCall()?.fillArguments(irArrayValue, indexedSetResolvedCall!!, ktExpressionToIrIndexValue, it) },
             callGenerator.translateType(kotlinType),
             startOffset, endOffset, origin
         )
@@ -107,24 +108,22 @@ class ArrayAccessAssignmentReceiver(
 
     override fun assign(value: IrExpression): IrExpression {
         val call = indexedSetCall() ?: throw AssertionError("Array access without indexed-get call")
-        val ktExpressionToIrIndexExpression = ktIndexExpressions.zip(irIndexExpressions).toMap()
-        call.setExplicitReceiverValue(OnceExpressionValue(irArray))
-        callGenerator.statementGenerator.pregenerateValueArgumentsUsing(call, indexedSetResolvedCall!!) {
-            ktExpressionToIrIndexExpression[it]
-        }
-        call.lastArgument = value
+        val ktExpressionToIrIndexExpression = ktIndexExpressions.zip(irIndexExpressions.map { OnceExpressionValue(it) }).toMap()
+        call.fillArguments(OnceExpressionValue(irArray), indexedSetResolvedCall!!, ktExpressionToIrIndexExpression, value)
         return callGenerator.generateCall(startOffset, endOffset, call, IrStatementOrigin.EQ)
     }
 
-    private fun CallBuilder.fillArrayAndIndexArguments(
+    private fun CallBuilder.fillArguments(
         arrayValue: IntermediateValue,
         resolvedCall: ResolvedCall<FunctionDescriptor>,
-        ktExpressionToIrIndexValue: Map<KtExpression, IntermediateValue>
+        ktExpressionToIrIndexValue: Map<KtExpression, IntermediateValue>,
+        value: IrExpression?
     ) = apply {
         setExplicitReceiverValue(arrayValue)
-
         callGenerator.statementGenerator.pregenerateValueArgumentsUsing(this, resolvedCall) { ktExpression ->
             ktExpressionToIrIndexValue[ktExpression]?.load()
         }
+        value?.let { lastArgument = it }
+        callGenerator.statementGenerator.generateSamConversionForValueArgumentsIfRequired(this, resolvedCall.resultingDescriptor)
     }
 }

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/intermediate/LValueWithGetterAndSetterCalls.kt

@@ -26,7 +26,7 @@ class LValueWithGetterAndSetterCalls(
     val callGenerator: CallGenerator,
     val descriptor: CallableDescriptor,
     val getterCall: () -> CallBuilder?,
-    val setterCall: () -> CallBuilder?,
+    val setterCall: (IrExpression) -> CallBuilder?,
     override val type: IrType,
     val startOffset: Int,
     val endOffset: Int,
@@ -39,8 +39,7 @@ class LValueWithGetterAndSetterCalls(
     }
 
     override fun store(irExpression: IrExpression): IrExpression {
-        val call = setterCall() ?: throw AssertionError("No setter call for $descriptor")
-        call.irValueArgumentsByIndex[call.argumentsCount - 1] = irExpression
+        val call = setterCall(irExpression) ?: throw AssertionError("No setter call for $descriptor")
         return callGenerator.generateCall(startOffset, endOffset, call, origin)
     }