From df460a842b574c1094148147b268653adf43f19b Mon Sep 17 00:00:00 2001 From: Dmitry Petrov Date: Mon, 13 Dec 2021 10:33:04 +0300 Subject: [PATCH] JVM_IR KT-50076 avoid CHECKCAST on moved dispatch receiver parameter --- .../FirBlackBoxCodegenTestGenerated.java | 6 +++ .../codegen/FirBytecodeTextTestGenerated.java | 12 +++++ .../backend/jvm/codegen/ExpressionCodegen.kt | 6 +++ ...nheritedDefaultMethodsOnClassesLowering.kt | 39 +++++++++++++- .../jvm/lower/JvmOptimizationLowering.kt | 4 +- .../ir/expressions/IrTypeOperatorCall.kt | 4 +- ...uspendCallInSuperInterfaceCallArguments.kt | 35 ++++++++++++ .../interfaceSuperCall.kt | 53 +++++++++++++++++-- ...noCheckcastOnDelegatingDefaultImplsCall.kt | 24 +++++++++ .../checkcast/noCheckcastOnSuper.kt | 9 ++++ .../codegen/BlackBoxCodegenTestGenerated.java | 6 +++ .../codegen/BytecodeTextTestGenerated.java | 12 +++++ .../IrBlackBoxCodegenTestGenerated.java | 6 +++ .../codegen/IrBytecodeTextTestGenerated.java | 12 +++++ .../LightAnalysisModeTestGenerated.java | 5 ++ .../testData/codegen/customSimple.asm.ir.txt | 1 - 16 files changed, 223 insertions(+), 11 deletions(-) create mode 100644 compiler/testData/codegen/box/coroutines/suspendCallInSuperInterfaceCallArguments.kt create mode 100644 compiler/testData/codegen/bytecodeText/checkcast/noCheckcastOnDelegatingDefaultImplsCall.kt create mode 100644 compiler/testData/codegen/bytecodeText/checkcast/noCheckcastOnSuper.kt diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java index 2eefc2aa662..28ed8e51e8a 100644 --- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java +++ b/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 { diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBytecodeTextTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBytecodeTextTestGenerated.java index e2cda54efdf..a2964cee377 100644 --- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBytecodeTextTestGenerated.java +++ b/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 diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt index 7d0867c024e..42755a4cdb1 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt +++ b/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) diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/InheritedDefaultMethodsOnClassesLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/InheritedDefaultMethodsOnClassesLowering.kt index 5059250bdde..e83bcfbdbb8 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/InheritedDefaultMethodsOnClassesLowering.kt +++ b/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", diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmOptimizationLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmOptimizationLowering.kt index 3441251c26f..7279f317f89 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmOptimizationLowering.kt +++ b/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) } diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrTypeOperatorCall.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrTypeOperatorCall.kt index f23ff69a9fe..cd9f97dbdb0 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrTypeOperatorCall.kt +++ b/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 using as primitive type operation in JS + * C-like reinterpret_cast 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; } diff --git a/compiler/testData/codegen/box/coroutines/suspendCallInSuperInterfaceCallArguments.kt b/compiler/testData/codegen/box/coroutines/suspendCallInSuperInterfaceCallArguments.kt new file mode 100644 index 00000000000..5f3013620f8 --- /dev/null +++ b/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.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 +} diff --git a/compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/interfaceSuperCall.kt b/compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/interfaceSuperCall.kt index 2f8434c6776..70061fab8b1 100644 --- a/compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/interfaceSuperCall.kt +++ b/compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/interfaceSuperCall.kt @@ -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.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.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.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.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.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.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" } diff --git a/compiler/testData/codegen/bytecodeText/checkcast/noCheckcastOnDelegatingDefaultImplsCall.kt b/compiler/testData/codegen/bytecodeText/checkcast/noCheckcastOnDelegatingDefaultImplsCall.kt new file mode 100644 index 00000000000..fb017c7a6cf --- /dev/null +++ b/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 diff --git a/compiler/testData/codegen/bytecodeText/checkcast/noCheckcastOnSuper.kt b/compiler/testData/codegen/bytecodeText/checkcast/noCheckcastOnSuper.kt new file mode 100644 index 00000000000..71238a753a9 --- /dev/null +++ b/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 diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java index 9e072c9cab1..dd9ad83a56a 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java +++ b/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 { diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BytecodeTextTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BytecodeTextTestGenerated.java index 12bea02a010..653316e9538 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BytecodeTextTestGenerated.java +++ b/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 diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java index ae2d6a721fe..3df863c4080 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java +++ b/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 { diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBytecodeTextTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBytecodeTextTestGenerated.java index 3f583db480b..97c64841993 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBytecodeTextTestGenerated.java +++ b/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 diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java index bb5e63ceca4..46d32185bfd 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java +++ b/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"); diff --git a/plugins/parcelize/parcelize-compiler/testData/codegen/customSimple.asm.ir.txt b/plugins/parcelize/parcelize-compiler/testData/codegen/customSimple.asm.ir.txt index f9d1e2de183..8f9fc368c82 100644 --- a/plugins/parcelize/parcelize-compiler/testData/codegen/customSimple.asm.ir.txt +++ b/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;)