JVM_IR KT-50076 avoid CHECKCAST on moved dispatch receiver parameter

2021-12-13 10:33:04 +03:00
parent 6f148c594f
commit df460a842b
16 changed files with 223 additions and 11 deletions
@@ -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 {
@@ -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
@@ -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)
@@ -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",
@@ -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)
            }

@@ -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;
 }
@@ -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
+}
@@ -1,15 +1,58 @@
 // WITH_STDLIB

-interface A {
-    fun f(x: String) = x
+interface IFoo {
+    fun foo(): String = "K"
 }

@Suppress("OPTIONAL_DECLARATION_USAGE_IN_NON_COMMON_SOURCE")
@kotlin.jvm.JvmInline
-value class B(val y: String) : A {
-    override fun f(x: String) = super.f(x + y)
+value class IcStr(val y: String) : IFoo {
+    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"
 }
@@ -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
@@ -0,0 +1,9 @@
+interface Tr {
+    fun extra(): String = "e"
+}
+
+class N : Tr {
+    override fun extra(): String = super.extra()
+}
+
+// 0 CHECKCAST
@@ -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 {
@@ -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
@@ -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 {
@@ -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
@@ -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");
@@ -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;)