From 89a6ecd77d4f0b397b0057328e12f3120163e75e Mon Sep 17 00:00:00 2001
From: Jinseong Jeon <jsjeon@google.com>
Date: Tue, 12 May 2020 23:43:02 -0700
Subject: [PATCH] [FIR] Update argument mapping while transforming integer
 operator.

---
 .../IntegerLiteralTypeApproximationTransformer.kt | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/IntegerLiteralTypeApproximationTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/IntegerLiteralTypeApproximationTransformer.kt
index 3b2e826d497..a59597bb6f3 100644
--- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/IntegerLiteralTypeApproximationTransformer.kt
+++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/IntegerLiteralTypeApproximationTransformer.kt
@@ -77,13 +77,26 @@ class IntegerLiteralTypeApproximationTransformer(
         // e.g. Byte doesn't have `and` in member scope. It's an extension
         if (resultSymbol == null) return functionCall.compose()
         functionCall.resultType = data?.let { functionCall.resultType.resolvedTypeFromPrototype(it) } ?: resultSymbol.fir.returnTypeRef
+        // If the original call has argument mapping, values in that mapping refer to value parameters in that original symbol. We should
+        // map those original value parameters back to indices, and then renew the argument mapping with new value parameters in the result
+        // symbol. Otherwise, while putting the value argument to the converted IR call, it will encounter an unknown value parameter,
+        // resulting in an out-of-bound error.
+        val newArgumentMapping =
+            functionCall.argumentMapping?.mapValues { (_, oldValueParameter) ->
+                val index = operator.valueParameters.indexOf(oldValueParameter)
+                if (index != -1) resultSymbol.fir.valueParameters[index] else oldValueParameter
+            }
         return functionCall.transformCalleeReference(
             StoreCalleeReference,
             buildResolvedNamedReference {
                 name = operator.name
                 resolvedSymbol = resultSymbol!!
             }
-        ).compose()
+        ).apply {
+            newArgumentMapping?.let {
+                replaceArgumentList(buildResolvedArgumentList(it))
+            }
+        }.compose()
     }
 
     override fun transformOperatorCall(operatorCall: FirOperatorCall, data: ConeKotlinType?): CompositeTransformResult<FirStatement> {