[FIR2IR] Properly set statement origin for all parts of += calls

^KT-65649 Fixed

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt

@@ -548,11 +548,12 @@ internal fun FirReference.statementOrigin(): IrStatementOrigin? = when (this) {
                 IrStatementOrigin.COMPONENT_N.withIndex(name.asString().removePrefix(DATA_CLASS_COMPONENT_PREFIX).toInt())
 
             source?.kind is KtFakeSourceElementKind.DesugaredCompoundAssignment -> when (name) {
-                OperatorNameConventions.PLUS_ASSIGN -> IrStatementOrigin.PLUSEQ
-                OperatorNameConventions.MINUS_ASSIGN -> IrStatementOrigin.MINUSEQ
-                OperatorNameConventions.TIMES_ASSIGN -> IrStatementOrigin.MULTEQ
-                OperatorNameConventions.DIV_ASSIGN -> IrStatementOrigin.DIVEQ
-                OperatorNameConventions.MOD_ASSIGN, OperatorNameConventions.REM_ASSIGN -> IrStatementOrigin.PERCEQ
+                OperatorNameConventions.PLUS_ASSIGN, OperatorNameConventions.PLUS -> IrStatementOrigin.PLUSEQ
+                OperatorNameConventions.MINUS_ASSIGN, OperatorNameConventions.MINUS -> IrStatementOrigin.MINUSEQ
+                OperatorNameConventions.TIMES_ASSIGN, OperatorNameConventions.TIMES -> IrStatementOrigin.MULTEQ
+                OperatorNameConventions.DIV_ASSIGN, OperatorNameConventions.DIV -> IrStatementOrigin.DIVEQ
+                OperatorNameConventions.MOD_ASSIGN, OperatorNameConventions.MOD,
+                OperatorNameConventions.REM_ASSIGN, OperatorNameConventions.REM -> IrStatementOrigin.PERCEQ
                 else -> null
             }
 

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt

@@ -478,11 +478,23 @@ class CallAndReferenceGenerator(
                 }
                 is IrSimpleFunctionSymbol -> {
                     require(firSymbol is FirCallableSymbol<*>) { "Illegal symbol: ${firSymbol!!::class}" }
+                    val callOrigin = calleeReference.statementOrigin()
+                    /*
+                     * For `x += y` -> `x = x.plus(y)` receiver of call `plus` should also have an augmented assignment origin.
+                     * But it's hard to detect this origin during conversion the receiver itself, so we update it afterward.
+                     */
+                    if (
+                        explicitReceiverExpression != null &&
+                        calleeReference.source?.kind is KtFakeSourceElementKind.DesugaredCompoundAssignment &&
+                        callOrigin != null
+                    ) {
+                        explicitReceiverExpression.updateStatementOrigin(callOrigin)
+                    }
                     IrCallImpl(
                         startOffset, endOffset, irType, symbol,
                         typeArgumentsCount = firSymbol.typeParameterSymbols.size,
                         valueArgumentsCount = firSymbol.valueParametersSize(),
-                        origin = calleeReference.statementOrigin(),
+                        origin = callOrigin,
                         superQualifierSymbol = dispatchReceiver?.superQualifierSymbol()
                     )
                 }
@@ -1343,4 +1355,12 @@ class CallAndReferenceGenerator(
             "Unresolved reference: ${calleeReference.render()}"
         )
     }
+
+    private fun IrExpression.updateStatementOrigin(newOrigin: IrStatementOrigin) {
+        when (this) {
+            is IrFieldAccessExpression -> origin = origin ?: newOrigin
+            is IrMemberAccessExpression<*> -> origin = origin ?: newOrigin
+            is IrValueAccessExpression -> origin = origin ?: newOrigin
+        }
+    }
 }