JVM_IR KT-50076 avoid CHECKCAST on moved dispatch receiver parameter

compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java

@@ -10067,6 +10067,12 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
             runTest("compiler/testData/codegen/box/coroutines/stopAfter.kt");
         }
 
+        @Test
+        @TestMetadata("suspendCallInSuperInterfaceCallArguments.kt")
+        public void testSuspendCallInSuperInterfaceCallArguments() throws Exception {
+            runTest("compiler/testData/codegen/box/coroutines/suspendCallInSuperInterfaceCallArguments.kt");
+        }
+
         @Test
         @TestMetadata("suspendCallsInArguments.kt")
         public void testSuspendCallsInArguments() throws Exception {

compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBytecodeTextTestGenerated.java

@@ -1073,6 +1073,18 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest {
         public void testKt22714() throws Exception {
             runTest("compiler/testData/codegen/bytecodeText/checkcast/kt22714.kt");
         }
+
+        @Test
+        @TestMetadata("noCheckcastOnDelegatingDefaultImplsCall.kt")
+        public void testNoCheckcastOnDelegatingDefaultImplsCall() throws Exception {
+            runTest("compiler/testData/codegen/bytecodeText/checkcast/noCheckcastOnDelegatingDefaultImplsCall.kt");
+        }
+
+        @Test
+        @TestMetadata("noCheckcastOnSuper.kt")
+        public void testNoCheckcastOnSuper() throws Exception {
+            runTest("compiler/testData/codegen/bytecodeText/checkcast/noCheckcastOnSuper.kt");
+        }
     }
 
     @Nested

compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt

@@ -1050,6 +1050,12 @@ class ExpressionCodegen(
                 MaterialValue(this, boxedRightType, expression.type)
             }
 
+            IrTypeOperator.REINTERPRET_CAST -> {
+                val targetType = typeMapper.mapType(typeOperand)
+                expression.argument.accept(this, data).materialize()
+                MaterialValue(this, targetType, typeOperand)
+            }
+
             IrTypeOperator.INSTANCEOF -> {
                 expression.argument.accept(this, data).materializeAt(context.irBuiltIns.anyNType)
                 val type = typeMapper.boxType(typeOperand)

compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/InheritedDefaultMethodsOnClassesLowering.kt

@@ -29,6 +29,9 @@ import org.jetbrains.kotlin.ir.builders.irReturn
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.IrCall
 import org.jetbrains.kotlin.ir.expressions.IrExpression
+import org.jetbrains.kotlin.ir.expressions.IrTypeOperator
+import org.jetbrains.kotlin.ir.expressions.impl.IrTypeOperatorCallImpl
+import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.util.*
 import org.jetbrains.kotlin.ir.visitors.*
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
@@ -88,6 +91,7 @@ private class InheritedDefaultMethodsOnClassesLowering(val context: JvmBackendCo
         val irFunction = context.cachedDeclarations.getDefaultImplsRedirection(classOverride)
 
         val superMethod = firstSuperMethodFromKotlin(irFunction, interfaceImplementation).owner
+        val superClassType = superMethod.parentAsClass.defaultType
         val defaultImplFun = context.cachedDeclarations.getDefaultImplsFunction(superMethod)
         val classStartOffset = classOverride.parentAsClass.startOffset
         context.createIrBuilder(irFunction.symbol, classStartOffset, classStartOffset).apply {
@@ -100,7 +104,12 @@ private class InheritedDefaultMethodsOnClassesLowering(val context: JvmBackendCo
                         passTypeArgumentsFrom(irFunction, offset = superMethod.parentAsClass.typeParameters.size)
 
                         var offset = 0
-                        irFunction.dispatchReceiverParameter?.let { putValueArgument(offset++, irGet(it)) }
+                        irFunction.dispatchReceiverParameter?.let {
+                            putValueArgument(
+                                offset++,
+                                irGet(it).reinterpretAsDispatchReceiverOfType(superClassType)
+                            )
+                        }
                         irFunction.extensionReceiverParameter?.let { putValueArgument(offset++, irGet(it)) }
                         irFunction.valueParameters.mapIndexed { i, parameter -> putValueArgument(i + offset, irGet(parameter)) }
                     }
@@ -153,7 +162,8 @@ private class InterfaceSuperCallsLowering(val context: JvmBackendContext) : IrEl
     }
 
     override fun visitCall(expression: IrCall): IrExpression {
-        if (expression.superQualifierSymbol?.owner?.isInterface != true || expression.isSuperToAny()) {
+        val superQualifierClass = expression.superQualifierSymbol?.owner
+        if (superQualifierClass == null || !superQualifierClass.isInterface || expression.isSuperToAny()) {
             return super.visitCall(expression)
         }
 
@@ -162,10 +172,35 @@ private class InterfaceSuperCallsLowering(val context: JvmBackendContext) : IrEl
 
         val redirectTarget = context.cachedDeclarations.getDefaultImplsFunction(superCallee)
         val newCall = createDelegatingCallWithPlaceholderTypeArguments(expression, redirectTarget, context.irBuiltIns)
+        postprocessMovedThis(newCall)
         return super.visitCall(newCall)
     }
+
+    private fun postprocessMovedThis(irCall: IrCall) {
+        val movedThisParameter = irCall.symbol.owner.valueParameters
+            .find { it.origin == IrDeclarationOrigin.MOVED_DISPATCH_RECEIVER }
+            ?: return
+        val movedThisParameterIndex = movedThisParameter.index
+        irCall.putValueArgument(
+            movedThisParameterIndex,
+            irCall.getValueArgument(movedThisParameterIndex)?.reinterpretAsDispatchReceiverOfType(movedThisParameter.type)
+        )
+    }
 }
 
+// Given a dispatch receiver expression, wrap it in REINTERPRET_CAST to the given type,
+// unless it's a value of inline class (which could be boxed at this point).
+// Avoids a CHECKCAST on a moved dispatch receiver argument.
+internal fun IrExpression.reinterpretAsDispatchReceiverOfType(irType: IrType): IrExpression =
+    if (this.type.isInlineClassType())
+        this
+    else
+        IrTypeOperatorCallImpl(
+            this.startOffset, this.endOffset,
+            irType, IrTypeOperator.REINTERPRET_CAST, irType,
+            this
+        )
+
 internal val interfaceDefaultCallsPhase = makeIrFilePhase(
     lowering = ::InterfaceDefaultCallsLowering,
     name = "InterfaceDefaultCalls",

compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmOptimizationLowering.kt

@@ -84,7 +84,9 @@ class JvmOptimizationLowering(val context: JvmBackendContext) : FileLoweringPass
         override fun visitCall(expression: IrCall, data: IrDeclaration?): IrExpression {
             expression.transformChildren(this, data)
 
-            if (expression.symbol.owner.origin == IrDeclarationOrigin.DEFAULT_PROPERTY_ACCESSOR) {
+            val callee = expression.symbol.owner
+
+            if (callee.origin == IrDeclarationOrigin.DEFAULT_PROPERTY_ACCESSOR) {
                 return optimizePropertyAccess(expression, data)
             }
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrTypeOperatorCall.kt

@@ -50,7 +50,6 @@ enum class IrTypeOperator {
 
     /**
      * SAM conversion: value of functional type F is used where Single Abstract Method interface value is expected.
-     * Currently this is possible in Kotlin/JVM only, however, there's a big demand for SAM conversion for Kotlin interfaces.
      */
     SAM_CONVERSION,
 
@@ -61,7 +60,8 @@ enum class IrTypeOperator {
     IMPLICIT_DYNAMIC_CAST,
 
     /**
-     * C-like reinterpret_cast<T> using as primitive type operation in JS
+     * C-like reinterpret_cast<T> using as primitive type operation in JS.
+     * On JVM, tells back-end to treat argument as a value of a given type (even though exact JVM types might differ).
      */
     REINTERPRET_CAST;
 }

compiler/testData/codegen/box/coroutines/suspendCallInSuperInterfaceCallArguments.kt

@@ -0,0 +1,35 @@
+// WITH_STDLIB
+// WITH_COROUTINES
+// TARGET_BACKEND: JVM
+
+import helpers.*
+import kotlin.coroutines.*
+
+interface IFoo {
+    fun foo(a: String): String =
+        bar() + a
+
+    fun bar(): String
+}
+
+suspend fun suspendK(a: String) =
+    a + "K"
+
+class FooImpl : IFoo {
+    suspend fun test(a: String): String =
+        super<IFoo>.foo(suspendK(a))
+
+    override fun bar(): String = "O"
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+fun box(): String {
+    var result = "FAIL"
+    builder {
+        result = FooImpl().test("")
+    }
+    return result
+}

compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/interfaceSuperCall.kt

@@ -1,15 +1,58 @@
 // WITH_STDLIB
 
-interface A {
+interface IFoo {
-    fun f(x: String) = x
+    fun foo(): String = "K"
 }
 
 @Suppress("OPTIONAL_DECLARATION_USAGE_IN_NON_COMMON_SOURCE")
 @kotlin.jvm.JvmInline
-value class B(val y: String) : A {
+value class IcStr(val y: String) : IFoo {
-    override fun f(x: String) = super.f(x + y)
+    override fun foo(): String = y + super<IFoo>.foo()
+}
+
+@Suppress("OPTIONAL_DECLARATION_USAGE_IN_NON_COMMON_SOURCE")
+@kotlin.jvm.JvmInline
+value class IcInt(val i: Int) : IFoo {
+    override fun foo(): String = "O" + super<IFoo>.foo()
+}
+
+@Suppress("OPTIONAL_DECLARATION_USAGE_IN_NON_COMMON_SOURCE")
+@kotlin.jvm.JvmInline
+value class IcLong(val l: Long) : IFoo {
+    override fun foo(): String = "O" + super<IFoo>.foo()
+}
+
+@Suppress("OPTIONAL_DECLARATION_USAGE_IN_NON_COMMON_SOURCE")
+@kotlin.jvm.JvmInline
+value class IcAny(val a: Any?) : IFoo {
+    override fun foo(): String = "O" + super<IFoo>.foo()
+}
+
+@Suppress("OPTIONAL_DECLARATION_USAGE_IN_NON_COMMON_SOURCE")
+@kotlin.jvm.JvmInline
+value class IcOverIc(val o: IcLong) : IFoo {
+    override fun foo(): String = "O" + super<IFoo>.foo()
+}
+
+@Suppress("OPTIONAL_DECLARATION_USAGE_IN_NON_COMMON_SOURCE")
+@kotlin.jvm.JvmInline
+value class IcOverSuperInterface(val x: IFoo) : IFoo {
+    override fun foo(): String = "O" + super<IFoo>.foo()
+}
+
+fun check(message: String, iFoo: IFoo) {
+    val actual = iFoo.foo()
+    if (actual != "OK")
+        throw Exception("$message: \"$actual\" != OK")
 }
 
 fun box(): String {
-    return B("K").f("O")
+    check("IcStr", IcStr("O"))
+    check("IcInt", IcInt(42))
+    check("IcLong", IcLong(42L))
+    check("IcAny", IcAny(""))
+    check("IcOverIc", IcOverIc(IcLong(42L)))
+    check("IcOverSuperInterface", IcOverSuperInterface(IcInt(42)))
+
+    return "OK"
 }

compiler/testData/codegen/bytecodeText/checkcast/noCheckcastOnDelegatingDefaultImplsCall.kt

@@ -0,0 +1,24 @@
+interface Z {
+    fun testFun() : String {
+        return privateFun()
+    }
+
+    fun testProperty() : String {
+        return privateProp
+    }
+
+    private fun privateFun(): String {
+        return "O"
+    }
+
+    private val privateProp: String
+        get() = "K"
+}
+
+object Z2 : Z
+
+fun box() : String {
+    return Z2.testFun() + Z2.testProperty()
+}
+
+// 0 CHECKCAST

compiler/testData/codegen/bytecodeText/checkcast/noCheckcastOnSuper.kt

@@ -0,0 +1,9 @@
+interface Tr {
+    fun extra(): String = "e"
+}
+
+class N : Tr {
+    override fun extra(): String = super.extra()
+}
+
+// 0 CHECKCAST

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java

@@ -9965,6 +9965,12 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
             runTest("compiler/testData/codegen/box/coroutines/stopAfter.kt");
         }
 
+        @Test
+        @TestMetadata("suspendCallInSuperInterfaceCallArguments.kt")
+        public void testSuspendCallInSuperInterfaceCallArguments() throws Exception {
+            runTest("compiler/testData/codegen/box/coroutines/suspendCallInSuperInterfaceCallArguments.kt");
+        }
+
         @Test
         @TestMetadata("suspendCallsInArguments.kt")
         public void testSuspendCallsInArguments() throws Exception {

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BytecodeTextTestGenerated.java

@@ -1061,6 +1061,18 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest {
         public void testKt22714() throws Exception {
             runTest("compiler/testData/codegen/bytecodeText/checkcast/kt22714.kt");
         }
+
+        @Test
+        @TestMetadata("noCheckcastOnDelegatingDefaultImplsCall.kt")
+        public void testNoCheckcastOnDelegatingDefaultImplsCall() throws Exception {
+            runTest("compiler/testData/codegen/bytecodeText/checkcast/noCheckcastOnDelegatingDefaultImplsCall.kt");
+        }
+
+        @Test
+        @TestMetadata("noCheckcastOnSuper.kt")
+        public void testNoCheckcastOnSuper() throws Exception {
+            runTest("compiler/testData/codegen/bytecodeText/checkcast/noCheckcastOnSuper.kt");
+        }
     }
 
     @Nested

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java

@@ -10067,6 +10067,12 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
             runTest("compiler/testData/codegen/box/coroutines/stopAfter.kt");
         }
 
+        @Test
+        @TestMetadata("suspendCallInSuperInterfaceCallArguments.kt")
+        public void testSuspendCallInSuperInterfaceCallArguments() throws Exception {
+            runTest("compiler/testData/codegen/box/coroutines/suspendCallInSuperInterfaceCallArguments.kt");
+        }
+
         @Test
         @TestMetadata("suspendCallsInArguments.kt")
         public void testSuspendCallsInArguments() throws Exception {

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBytecodeTextTestGenerated.java

@@ -1073,6 +1073,18 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest {
         public void testKt22714() throws Exception {
             runTest("compiler/testData/codegen/bytecodeText/checkcast/kt22714.kt");
         }
+
+        @Test
+        @TestMetadata("noCheckcastOnDelegatingDefaultImplsCall.kt")
+        public void testNoCheckcastOnDelegatingDefaultImplsCall() throws Exception {
+            runTest("compiler/testData/codegen/bytecodeText/checkcast/noCheckcastOnDelegatingDefaultImplsCall.kt");
+        }
+
+        @Test
+        @TestMetadata("noCheckcastOnSuper.kt")
+        public void testNoCheckcastOnSuper() throws Exception {
+            runTest("compiler/testData/codegen/bytecodeText/checkcast/noCheckcastOnSuper.kt");
+        }
     }
 
     @Nested

compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java

@@ -7822,6 +7822,11 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
             runTest("compiler/testData/codegen/box/coroutines/stopAfter.kt");
         }
 
+        @TestMetadata("suspendCallInSuperInterfaceCallArguments.kt")
+        public void testSuspendCallInSuperInterfaceCallArguments() throws Exception {
+            runTest("compiler/testData/codegen/box/coroutines/suspendCallInSuperInterfaceCallArguments.kt");
+        }
+
         @TestMetadata("suspendCallsInArguments.kt")
         public void testSuspendCallsInArguments() throws Exception {
             runTest("compiler/testData/codegen/box/coroutines/suspendCallsInArguments.kt");

plugins/parcelize/parcelize-compiler/testData/codegen/customSimple.asm.ir.txt

@@ -11,7 +11,6 @@ final class User$Companion : java/lang/Object, kotlinx/parcelize/Parceler {
         LABEL (L0)
         LINENUMBER (10)
           ALOAD (0)
-          CHECKCAST (kotlinx/parcelize/Parceler)
           ILOAD (1)
           INVOKESTATIC (kotlinx/parcelize/Parceler$DefaultImpls, newArray, (Lkotlinx/parcelize/Parceler;I)[Ljava/lang/Object;)
           CHECKCAST ([LUser;)