[K/JS] Fix autoboxing for inlined function ^KT-60785 Fixed

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsLoweringPhases.kt

@@ -727,7 +727,7 @@ private val inlineClassUsageLoweringPhase = makeBodyLoweringPhase(
 )
 
 private val autoboxingTransformerPhase = makeBodyLoweringPhase(
-    ::AutoboxingTransformer,
+    { AutoboxingTransformer(it, shouldCalculateActualTypeForInlinedFunction = true) },
     name = "AutoboxingTransformer",
     description = "Insert box/unbox intrinsics"
 )

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/AutoboxingTransformer.kt

@@ -31,7 +31,10 @@ import org.jetbrains.kotlin.ir.util.render
 
 // Copied and adapted from Kotlin/Native
 
-abstract class AbstractValueUsageLowering(val context: JsCommonBackendContext) : AbstractValueUsageTransformer(context.irBuiltIns),
+abstract class AbstractValueUsageLowering(
+    val context: JsCommonBackendContext,
+    private val shouldCalculateActualTypeForInlinedFunction: Boolean = false
+) : AbstractValueUsageTransformer(context.irBuiltIns),
     BodyLoweringPass {
 
     val icUtils = context.inlineClassesUtils
@@ -52,11 +55,19 @@ abstract class AbstractValueUsageLowering(val context: JsCommonBackendContext) :
 
     abstract fun IrExpression.useExpressionAsType(actualType: IrType, expectedType: IrType): IrExpression
 
-    protected fun IrExpression.getActualType() = when (this) {
+    protected fun IrExpression.getActualType(): IrType = when (this) {
         is IrConstructorCall -> symbol.owner.returnType
         is IrCall -> symbol.owner.realOverrideTarget.returnType
         is IrGetField -> this.symbol.owner.type
 
+        is IrInlinedFunctionBlock -> {
+            if (shouldCalculateActualTypeForInlinedFunction) {
+                inlineCall.getActualType()
+            } else {
+                this.type
+            }
+        }
+
         is IrTypeOperatorCall -> {
             if (operator == IrTypeOperator.REINTERPRET_CAST) {
                 this.typeOperand
@@ -120,7 +131,10 @@ abstract class AbstractValueUsageLowering(val context: JsCommonBackendContext) :
         )
 }
 
-class AutoboxingTransformer(context: JsCommonBackendContext) : AbstractValueUsageLowering(context) {
+class AutoboxingTransformer(
+    context: JsCommonBackendContext,
+    shouldCalculateActualTypeForInlinedFunction: Boolean = false
+) : AbstractValueUsageLowering(context, shouldCalculateActualTypeForInlinedFunction) {
     private var processingReturnStack = mutableListOf<IrReturn>()
 
     private fun IrExpression.useReturnableExpressionAsType(expectedType: IrType): IrExpression {

js/js.translator/testData/box/coroutines/boxingUnboxingInsideTheSuspendFunction.kt

@@ -0,0 +1,35 @@
+// WITH_STDLIB
+// EXPECTED_REACHABLE_NODES: 1292
+// KT-60785
+
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
+
+value class SomeValue(val a: String) {
+    override fun toString() = when (a) {
+        "fa" -> "O"
+        "il" -> "K"
+        else -> ""
+    }
+}
+
+suspend fun foo() = mapOf(SomeValue("fa") to SomeValue("il"))
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(object : Continuation<Unit> {
+        override val context = EmptyCoroutineContext
+        override fun resumeWith(result: Result<Unit>) {}
+    })
+}
+
+fun box(): String {
+    var result = ""
+
+    builder {
+        for ((k, v) in foo()) {
+            result += "$k$v"
+        }
+    }
+
+    return result
+}