From 318d4d17ba3305b96fa13338f5ddcc5de722c3fc Mon Sep 17 00:00:00 2001 From: Dmitry Petrov Date: Mon, 20 Apr 2020 18:25:25 +0300 Subject: [PATCH] KT-38337 Fix inline class value coercion in delegated members --- .../kotlin/codegen/FunctionCodegen.java | 50 ++++++++++++++-- .../ir/FirBlackBoxCodegenTestGenerated.java | 58 +++++++++++++++++-- .../interfaceImplementationByDelegation.kt | 0 .../interfaceDelegation/kt38337.kt | 13 +++++ ...DelegationWithInlineClassParameterTypes.kt | 40 +++++++++++++ ...DelegationWithInlineClassParameterTypes.kt | 47 +++++++++++++++ .../memberFunDelegatedToInlineClassInt.kt | 20 +++++++ .../memberFunDelegatedToInlineClassLong.kt | 20 +++++++ ...nlineClassWithInlineClassParameterTypes.kt | 42 ++++++++++++++ ...DelegationWithInlineClassParameterTypes.kt | 42 ++++++++++++++ .../codegen/BlackBoxCodegenTestGenerated.java | 58 +++++++++++++++++-- .../LightAnalysisModeTestGenerated.java | 58 +++++++++++++++++-- .../ir/IrBlackBoxCodegenTestGenerated.java | 58 +++++++++++++++++-- .../IrJsCodegenBoxTestGenerated.java | 58 +++++++++++++++++-- .../semantics/JsCodegenBoxTestGenerated.java | 58 +++++++++++++++++-- 15 files changed, 586 insertions(+), 36 deletions(-) rename compiler/testData/codegen/box/inlineClasses/{ => interfaceDelegation}/interfaceImplementationByDelegation.kt (100%) create mode 100644 compiler/testData/codegen/box/inlineClasses/interfaceDelegation/kt38337.kt create mode 100644 compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberExtValDelegationWithInlineClassParameterTypes.kt create mode 100644 compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberExtVarDelegationWithInlineClassParameterTypes.kt create mode 100644 compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegatedToInlineClassInt.kt create mode 100644 compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegatedToInlineClassLong.kt create mode 100644 compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegationToInlineClassWithInlineClassParameterTypes.kt create mode 100644 compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegationWithInlineClassParameterTypes.kt diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java index 48c4edfb863..655aaab406e 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java @@ -1588,19 +1588,34 @@ public class FunctionCodegen { @NotNull MethodContext context, @NotNull MemberCodegen parentCodegen ) { - Method delegateToMethod = typeMapper.mapToCallableMethod(delegatedTo, /* superCall = */ false).getAsmMethod(); Method delegateMethod = typeMapper.mapAsmMethod(delegateFunction); - Type[] argTypes = delegateMethod.getArgumentTypes(); + List argKotlinTypes = getKotlinTypesForJvmParameters(delegateFunction); + + Method delegateToMethod = typeMapper.mapToCallableMethod(delegatedTo, /* superCall = */ false).getAsmMethod(); Type[] originalArgTypes = delegateToMethod.getArgumentTypes(); + List originalArgKotlinTypes = getKotlinTypesForJvmParameters(delegatedTo); InstructionAdapter iv = new InstructionAdapter(mv); iv.load(0, OBJECT_TYPE); field.put(iv); - for (int i = 0, reg = 1; i < argTypes.length; i++) { - StackValue.local(reg, argTypes[i]).put(originalArgTypes[i], iv); - //noinspection AssignmentToForLoopParameter - reg += argTypes[i].getSize(); + + // When delegating to inline class, we invoke static implementation method + // that takes inline class underlying value as 1st argument. + int toArgsShift = toClass.isInline() ? 1 : 0; + + int reg = 1; + for (int i = 0; i < argTypes.length; ++i) { + Type argType = argTypes[i]; + KotlinType argKotlinType = argKotlinTypes.get(i); + + Type toArgType = originalArgTypes[i + toArgsShift]; + KotlinType toArgKotlinType = originalArgKotlinTypes.get(i); + + StackValue.local(reg, argType, argKotlinType) + .put(toArgType, toArgKotlinType, iv); + + reg += argType.getSize(); } String internalName = typeMapper.mapClass(toClass).getInternalName(); @@ -1614,6 +1629,7 @@ public class FunctionCodegen { iv.invokevirtual(internalName, delegateToMethod.getName(), delegateToMethod.getDescriptor(), false); } + //noinspection ConstantConditions StackValue stackValue = AsmUtil.genNotNullAssertions( state, StackValue.onStack(delegateToMethod.getReturnType(), delegatedTo.getReturnType()), @@ -1638,6 +1654,28 @@ public class FunctionCodegen { public boolean skipGenericSignature() { return skipGenericSignature; } + + private List getKotlinTypesForJvmParameters(@NotNull FunctionDescriptor functionDescriptor) { + List kotlinTypes = new ArrayList<>(); + + ReceiverParameterDescriptor extensionReceiver = functionDescriptor.getExtensionReceiverParameter(); + if (extensionReceiver != null) { + kotlinTypes.add(extensionReceiver.getType()); + } + + for (ValueParameterDescriptor parameter : functionDescriptor.getValueParameters()) { + kotlinTypes.add(parameter.getType()); + } + + if (functionDescriptor.isSuspend()) { + // Suspend functions take continuation type as last argument. + // It's not an inline class, so we don't really care about exact KotlinType here. + // Just make sure argument types are counted properly. + kotlinTypes.add(null); + } + + return kotlinTypes; + } } ); } diff --git a/compiler/fir/fir2ir/tests/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java b/compiler/fir/fir2ir/tests/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java index 3901a18ea31..b931c003f70 100644 --- a/compiler/fir/fir2ir/tests/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java +++ b/compiler/fir/fir2ir/tests/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java @@ -12519,11 +12519,6 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT runTest("compiler/testData/codegen/box/inlineClasses/inlineFunctionInsideInlineClass.kt"); } - @TestMetadata("interfaceImplementationByDelegation.kt") - public void testInterfaceImplementationByDelegation() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/interfaceImplementationByDelegation.kt"); - } - @TestMetadata("iterateOverArrayOfInlineClassValues.kt") public void testIterateOverArrayOfInlineClassValues() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/iterateOverArrayOfInlineClassValues.kt"); @@ -13570,6 +13565,59 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/interfaceDelegation") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InterfaceDelegation extends AbstractFirBlackBoxCodegenTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_IR, testDataFilePath, "// IGNORE_BACKEND_FIR: "); + } + + public void testAllFilesPresentInInterfaceDelegation() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @TestMetadata("interfaceImplementationByDelegation.kt") + public void testInterfaceImplementationByDelegation() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/interfaceImplementationByDelegation.kt"); + } + + @TestMetadata("kt38337.kt") + public void testKt38337() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/kt38337.kt"); + } + + @TestMetadata("memberExtValDelegationWithInlineClassParameterTypes.kt") + public void testMemberExtValDelegationWithInlineClassParameterTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberExtValDelegationWithInlineClassParameterTypes.kt"); + } + + @TestMetadata("memberExtVarDelegationWithInlineClassParameterTypes.kt") + public void testMemberExtVarDelegationWithInlineClassParameterTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberExtVarDelegationWithInlineClassParameterTypes.kt"); + } + + @TestMetadata("memberFunDelegatedToInlineClassInt.kt") + public void testMemberFunDelegatedToInlineClassInt() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegatedToInlineClassInt.kt"); + } + + @TestMetadata("memberFunDelegatedToInlineClassLong.kt") + public void testMemberFunDelegatedToInlineClassLong() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegatedToInlineClassLong.kt"); + } + + @TestMetadata("memberFunDelegationToInlineClassWithInlineClassParameterTypes.kt") + public void testMemberFunDelegationToInlineClassWithInlineClassParameterTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegationToInlineClassWithInlineClassParameterTypes.kt"); + } + + @TestMetadata("memberFunDelegationWithInlineClassParameterTypes.kt") + public void testMemberFunDelegationWithInlineClassParameterTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegationWithInlineClassParameterTypes.kt"); + } + } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/compiler/testData/codegen/box/inlineClasses/interfaceImplementationByDelegation.kt b/compiler/testData/codegen/box/inlineClasses/interfaceDelegation/interfaceImplementationByDelegation.kt similarity index 100% rename from compiler/testData/codegen/box/inlineClasses/interfaceImplementationByDelegation.kt rename to compiler/testData/codegen/box/inlineClasses/interfaceDelegation/interfaceImplementationByDelegation.kt diff --git a/compiler/testData/codegen/box/inlineClasses/interfaceDelegation/kt38337.kt b/compiler/testData/codegen/box/inlineClasses/interfaceDelegation/kt38337.kt new file mode 100644 index 00000000000..180c5a8b527 --- /dev/null +++ b/compiler/testData/codegen/box/inlineClasses/interfaceDelegation/kt38337.kt @@ -0,0 +1,13 @@ +// KJS_WITH_FULL_RUNTIME +// WITH_RUNTIME +// IGNORE_BACKEND_FIR: JVM_IR + +inline class Wrapper(val id: Int) + +class DMap(private val map: Map) : + Map by map + +fun box(): String { + val dmap = DMap(mutableMapOf(Wrapper(42) to "OK")) + return dmap[Wrapper(42)] ?: "Fail" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberExtValDelegationWithInlineClassParameterTypes.kt b/compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberExtValDelegationWithInlineClassParameterTypes.kt new file mode 100644 index 00000000000..f7d09410c3b --- /dev/null +++ b/compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberExtValDelegationWithInlineClassParameterTypes.kt @@ -0,0 +1,40 @@ +// KJS_WITH_FULL_RUNTIME +// WITH_RUNTIME +// IGNORE_BACKEND_FIR: JVM_IR +import kotlin.test.assertEquals + +inline class S(val x: String) + +interface IFoo { + val S.extVal: String +} + +interface GFoo { + val T.extVal: String +} + +object FooImpl : IFoo { + override val S.extVal: String + get() = x +} + +object GFooImpl : GFoo { + override val S.extVal: String + get() = x +} + +class TestFoo : IFoo by FooImpl + +class TestGFoo : GFoo by GFooImpl + +fun box(): String { + with(TestFoo()) { + assertEquals("OK", S("OK").extVal) + } + + with(TestGFoo()) { + assertEquals("OK", S("OK").extVal) + } + + return "OK" +} diff --git a/compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberExtVarDelegationWithInlineClassParameterTypes.kt b/compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberExtVarDelegationWithInlineClassParameterTypes.kt new file mode 100644 index 00000000000..e637e022329 --- /dev/null +++ b/compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberExtVarDelegationWithInlineClassParameterTypes.kt @@ -0,0 +1,47 @@ +// KJS_WITH_FULL_RUNTIME +// WITH_RUNTIME +// IGNORE_BACKEND_FIR: JVM_IR + +import kotlin.test.assertEquals + +inline class S(val xs: Array) + +interface IFoo { + var S.extVar: String +} + +interface GFoo { + var T.extVar: String +} + +object FooImpl : IFoo { + override var S.extVar: String + get() = xs[0] + set(value) { xs[0] = value } +} + +object GFooImpl : GFoo { + override var S.extVar: String + get() = xs[0] + set(value) { xs[0] = value } +} + +class TestFoo : IFoo by FooImpl + +class TestGFoo : GFoo by GFooImpl + +fun box(): String { + with(TestFoo()) { + val s = S(arrayOf("Fail 1")) + s.extVar = "OK" + assertEquals("OK", s.extVar) + } + + with(TestGFoo()) { + val s = S(arrayOf("Fail 2")) + s.extVar = "OK" + assertEquals("OK", s.extVar) + } + + return "OK" +} diff --git a/compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegatedToInlineClassInt.kt b/compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegatedToInlineClassInt.kt new file mode 100644 index 00000000000..bf756beb4ca --- /dev/null +++ b/compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegatedToInlineClassInt.kt @@ -0,0 +1,20 @@ +// KJS_WITH_FULL_RUNTIME +// WITH_RUNTIME +// IGNORE_BACKEND_FIR: JVM_IR +import kotlin.test.assertEquals + +interface IFoo { + fun foo(s: String): String +} + +inline class Z(val x: Int) : IFoo { + override fun foo(s: String): String = x.toString() + s +} + +class Test(x: Int) : IFoo by Z(x) + +fun box(): String { + assertEquals("1OK", Test(1).foo("OK")) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegatedToInlineClassLong.kt b/compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegatedToInlineClassLong.kt new file mode 100644 index 00000000000..22720dddbe1 --- /dev/null +++ b/compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegatedToInlineClassLong.kt @@ -0,0 +1,20 @@ +// KJS_WITH_FULL_RUNTIME +// WITH_RUNTIME +// IGNORE_BACKEND_FIR: JVM_IR +import kotlin.test.assertEquals + +interface IFoo { + fun foo(s: String): String +} + +inline class Z(val x: Long) : IFoo { + override fun foo(s: String): String = x.toString() + s +} + +class Test(x: Long) : IFoo by Z(x) + +fun box(): String { + assertEquals("1OK", Test(1L).foo("OK")) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegationToInlineClassWithInlineClassParameterTypes.kt b/compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegationToInlineClassWithInlineClassParameterTypes.kt new file mode 100644 index 00000000000..648f32a4ddd --- /dev/null +++ b/compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegationToInlineClassWithInlineClassParameterTypes.kt @@ -0,0 +1,42 @@ +// KJS_WITH_FULL_RUNTIME +// WITH_RUNTIME +// IGNORE_BACKEND_FIR: JVM_IR +import kotlin.test.assertEquals + +inline class S(val x: String) + +interface IFoo { + fun memberFun(s1: S, s2: String): String + fun memberFunT(x1: T, x2: String): String + fun genericMemberFun(x1: T, x2: X): String + fun S.memberExtFun(s: String): String + fun T.memberExtFunT(x: String): String + fun T.genericMemberExtFun(x: X): String +} + +inline class FooImpl(val xs: Array) : IFoo { + override fun memberFun(s1: S, s2: String): String = xs[0] + s1.x + s2 + override fun memberFunT(x1: S, x2: String): String = xs[0] + x1.x + x2 + override fun genericMemberFun(x1: S, x2: X): String = xs[0] + x1.x + x2.toString() + override fun S.memberExtFun(s: String): String = xs[0] + this.x + s + override fun S.memberExtFunT(x: String): String = xs[0] + this.x + x + override fun S.genericMemberExtFun(x: X): String = xs[0] + this.x + x.toString() +} + +class Test : IFoo by FooImpl(arrayOf("1")) + +fun box(): String { + val test = Test() + + assertEquals("1OK", test.memberFun(S("O"), "K")) + assertEquals("1OK", test.memberFunT(S("O"), "K")) + assertEquals("1OK", test.genericMemberFun(S("O"), "K")) + + with(test) { + assertEquals("1OK", S("O").memberExtFun("K")) + assertEquals("1OK", S("O").memberExtFunT("K")) + assertEquals("1OK", S("O").genericMemberExtFun("K")) + } + + return "OK" +} diff --git a/compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegationWithInlineClassParameterTypes.kt b/compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegationWithInlineClassParameterTypes.kt new file mode 100644 index 00000000000..b95884783ae --- /dev/null +++ b/compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegationWithInlineClassParameterTypes.kt @@ -0,0 +1,42 @@ +// KJS_WITH_FULL_RUNTIME +// WITH_RUNTIME +// IGNORE_BACKEND_FIR: JVM_IR +import kotlin.test.assertEquals + +inline class S(val x: String) + +interface IFoo { + fun memberFun(s1: S, s2: String): String + fun memberFunT(x1: T, x2: String): String + fun genericMemberFun(x1: T, x2: X): String + fun S.memberExtFun(s: String): String + fun T.memberExtFunT(x: String): String + fun T.genericMemberExtFun(x: X): String +} + +object FooImpl : IFoo { + override fun memberFun(s1: S, s2: String): String = s1.x + s2 + override fun memberFunT(x1: S, x2: String): String = x1.x + x2 + override fun genericMemberFun(x1: S, x2: X): String = x1.x + x2.toString() + override fun S.memberExtFun(s: String): String = this.x + s + override fun S.memberExtFunT(x: String): String = this.x + x + override fun S.genericMemberExtFun(x: X): String = this.x + x.toString() +} + +class Test : IFoo by FooImpl + +fun box(): String { + val test = Test() + + assertEquals("OK", test.memberFun(S("O"), "K")) + assertEquals("OK", test.memberFunT(S("O"), "K")) + assertEquals("OK", test.genericMemberFun(S("O"), "K")) + + with(test) { + assertEquals("OK", S("O").memberExtFun("K")) + assertEquals("OK", S("O").memberExtFunT("K")) + assertEquals("OK", S("O").genericMemberExtFun("K")) + } + + return "OK" +} diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java index 99d6a2dd12f..7d4d29ad8df 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java @@ -13734,11 +13734,6 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { runTest("compiler/testData/codegen/box/inlineClasses/inlineFunctionInsideInlineClass.kt"); } - @TestMetadata("interfaceImplementationByDelegation.kt") - public void testInterfaceImplementationByDelegation() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/interfaceImplementationByDelegation.kt"); - } - @TestMetadata("iterateOverArrayOfInlineClassValues.kt") public void testIterateOverArrayOfInlineClassValues() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/iterateOverArrayOfInlineClassValues.kt"); @@ -14785,6 +14780,59 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/interfaceDelegation") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InterfaceDelegation extends AbstractBlackBoxCodegenTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath); + } + + public void testAllFilesPresentInInterfaceDelegation() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + } + + @TestMetadata("interfaceImplementationByDelegation.kt") + public void testInterfaceImplementationByDelegation() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/interfaceImplementationByDelegation.kt"); + } + + @TestMetadata("kt38337.kt") + public void testKt38337() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/kt38337.kt"); + } + + @TestMetadata("memberExtValDelegationWithInlineClassParameterTypes.kt") + public void testMemberExtValDelegationWithInlineClassParameterTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberExtValDelegationWithInlineClassParameterTypes.kt"); + } + + @TestMetadata("memberExtVarDelegationWithInlineClassParameterTypes.kt") + public void testMemberExtVarDelegationWithInlineClassParameterTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberExtVarDelegationWithInlineClassParameterTypes.kt"); + } + + @TestMetadata("memberFunDelegatedToInlineClassInt.kt") + public void testMemberFunDelegatedToInlineClassInt() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegatedToInlineClassInt.kt"); + } + + @TestMetadata("memberFunDelegatedToInlineClassLong.kt") + public void testMemberFunDelegatedToInlineClassLong() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegatedToInlineClassLong.kt"); + } + + @TestMetadata("memberFunDelegationToInlineClassWithInlineClassParameterTypes.kt") + public void testMemberFunDelegationToInlineClassWithInlineClassParameterTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegationToInlineClassWithInlineClassParameterTypes.kt"); + } + + @TestMetadata("memberFunDelegationWithInlineClassParameterTypes.kt") + public void testMemberFunDelegationWithInlineClassParameterTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegationWithInlineClassParameterTypes.kt"); + } + } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java index 031cb6381ff..9f5caef081f 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java @@ -13739,11 +13739,6 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes runTest("compiler/testData/codegen/box/inlineClasses/inlineFunctionInsideInlineClass.kt"); } - @TestMetadata("interfaceImplementationByDelegation.kt") - public void testInterfaceImplementationByDelegation() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/interfaceImplementationByDelegation.kt"); - } - @TestMetadata("iterateOverArrayOfInlineClassValues.kt") public void testIterateOverArrayOfInlineClassValues() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/iterateOverArrayOfInlineClassValues.kt"); @@ -14785,6 +14780,59 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/interfaceDelegation") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InterfaceDelegation extends AbstractLightAnalysisModeTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath); + } + + public void testAllFilesPresentInInterfaceDelegation() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + } + + @TestMetadata("interfaceImplementationByDelegation.kt") + public void testInterfaceImplementationByDelegation() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/interfaceImplementationByDelegation.kt"); + } + + @TestMetadata("kt38337.kt") + public void testKt38337() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/kt38337.kt"); + } + + @TestMetadata("memberExtValDelegationWithInlineClassParameterTypes.kt") + public void testMemberExtValDelegationWithInlineClassParameterTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberExtValDelegationWithInlineClassParameterTypes.kt"); + } + + @TestMetadata("memberExtVarDelegationWithInlineClassParameterTypes.kt") + public void testMemberExtVarDelegationWithInlineClassParameterTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberExtVarDelegationWithInlineClassParameterTypes.kt"); + } + + @TestMetadata("memberFunDelegatedToInlineClassInt.kt") + public void testMemberFunDelegatedToInlineClassInt() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegatedToInlineClassInt.kt"); + } + + @TestMetadata("memberFunDelegatedToInlineClassLong.kt") + public void testMemberFunDelegatedToInlineClassLong() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegatedToInlineClassLong.kt"); + } + + @TestMetadata("memberFunDelegationToInlineClassWithInlineClassParameterTypes.kt") + public void testMemberFunDelegationToInlineClassWithInlineClassParameterTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegationToInlineClassWithInlineClassParameterTypes.kt"); + } + + @TestMetadata("memberFunDelegationWithInlineClassParameterTypes.kt") + public void testMemberFunDelegationWithInlineClassParameterTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegationWithInlineClassParameterTypes.kt"); + } + } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java index 416877185c1..6db275da011 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java @@ -12519,11 +12519,6 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes runTest("compiler/testData/codegen/box/inlineClasses/inlineFunctionInsideInlineClass.kt"); } - @TestMetadata("interfaceImplementationByDelegation.kt") - public void testInterfaceImplementationByDelegation() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/interfaceImplementationByDelegation.kt"); - } - @TestMetadata("iterateOverArrayOfInlineClassValues.kt") public void testIterateOverArrayOfInlineClassValues() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/iterateOverArrayOfInlineClassValues.kt"); @@ -13570,6 +13565,59 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/interfaceDelegation") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InterfaceDelegation extends AbstractIrBlackBoxCodegenTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInInterfaceDelegation() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @TestMetadata("interfaceImplementationByDelegation.kt") + public void testInterfaceImplementationByDelegation() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/interfaceImplementationByDelegation.kt"); + } + + @TestMetadata("kt38337.kt") + public void testKt38337() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/kt38337.kt"); + } + + @TestMetadata("memberExtValDelegationWithInlineClassParameterTypes.kt") + public void testMemberExtValDelegationWithInlineClassParameterTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberExtValDelegationWithInlineClassParameterTypes.kt"); + } + + @TestMetadata("memberExtVarDelegationWithInlineClassParameterTypes.kt") + public void testMemberExtVarDelegationWithInlineClassParameterTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberExtVarDelegationWithInlineClassParameterTypes.kt"); + } + + @TestMetadata("memberFunDelegatedToInlineClassInt.kt") + public void testMemberFunDelegatedToInlineClassInt() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegatedToInlineClassInt.kt"); + } + + @TestMetadata("memberFunDelegatedToInlineClassLong.kt") + public void testMemberFunDelegatedToInlineClassLong() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegatedToInlineClassLong.kt"); + } + + @TestMetadata("memberFunDelegationToInlineClassWithInlineClassParameterTypes.kt") + public void testMemberFunDelegationToInlineClassWithInlineClassParameterTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegationToInlineClassWithInlineClassParameterTypes.kt"); + } + + @TestMetadata("memberFunDelegationWithInlineClassParameterTypes.kt") + public void testMemberFunDelegationWithInlineClassParameterTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegationWithInlineClassParameterTypes.kt"); + } + } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java b/js/js.tests/test/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java index c615a1e100a..3b2466c371b 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java +++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java @@ -10789,11 +10789,6 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { runTest("compiler/testData/codegen/box/inlineClasses/inlineFunctionInsideInlineClass.kt"); } - @TestMetadata("interfaceImplementationByDelegation.kt") - public void testInterfaceImplementationByDelegation() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/interfaceImplementationByDelegation.kt"); - } - @TestMetadata("iterateOverArrayOfInlineClassValues.kt") public void testIterateOverArrayOfInlineClassValues() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/iterateOverArrayOfInlineClassValues.kt"); @@ -11765,6 +11760,59 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/interfaceDelegation") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InterfaceDelegation extends AbstractIrJsCodegenBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS_IR, testDataFilePath); + } + + public void testAllFilesPresentInInterfaceDelegation() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + } + + @TestMetadata("interfaceImplementationByDelegation.kt") + public void testInterfaceImplementationByDelegation() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/interfaceImplementationByDelegation.kt"); + } + + @TestMetadata("kt38337.kt") + public void testKt38337() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/kt38337.kt"); + } + + @TestMetadata("memberExtValDelegationWithInlineClassParameterTypes.kt") + public void testMemberExtValDelegationWithInlineClassParameterTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberExtValDelegationWithInlineClassParameterTypes.kt"); + } + + @TestMetadata("memberExtVarDelegationWithInlineClassParameterTypes.kt") + public void testMemberExtVarDelegationWithInlineClassParameterTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberExtVarDelegationWithInlineClassParameterTypes.kt"); + } + + @TestMetadata("memberFunDelegatedToInlineClassInt.kt") + public void testMemberFunDelegatedToInlineClassInt() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegatedToInlineClassInt.kt"); + } + + @TestMetadata("memberFunDelegatedToInlineClassLong.kt") + public void testMemberFunDelegatedToInlineClassLong() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegatedToInlineClassLong.kt"); + } + + @TestMetadata("memberFunDelegationToInlineClassWithInlineClassParameterTypes.kt") + public void testMemberFunDelegationToInlineClassWithInlineClassParameterTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegationToInlineClassWithInlineClassParameterTypes.kt"); + } + + @TestMetadata("memberFunDelegationWithInlineClassParameterTypes.kt") + public void testMemberFunDelegationWithInlineClassParameterTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegationWithInlineClassParameterTypes.kt"); + } + } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java index 59c58cda63d..3f741719b51 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java +++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java @@ -10854,11 +10854,6 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { runTest("compiler/testData/codegen/box/inlineClasses/inlineFunctionInsideInlineClass.kt"); } - @TestMetadata("interfaceImplementationByDelegation.kt") - public void testInterfaceImplementationByDelegation() throws Exception { - runTest("compiler/testData/codegen/box/inlineClasses/interfaceImplementationByDelegation.kt"); - } - @TestMetadata("iterateOverArrayOfInlineClassValues.kt") public void testIterateOverArrayOfInlineClassValues() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/iterateOverArrayOfInlineClassValues.kt"); @@ -11830,6 +11825,59 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/interfaceDelegation") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InterfaceDelegation extends AbstractJsCodegenBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS, testDataFilePath); + } + + public void testAllFilesPresentInInterfaceDelegation() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + } + + @TestMetadata("interfaceImplementationByDelegation.kt") + public void testInterfaceImplementationByDelegation() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/interfaceImplementationByDelegation.kt"); + } + + @TestMetadata("kt38337.kt") + public void testKt38337() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/kt38337.kt"); + } + + @TestMetadata("memberExtValDelegationWithInlineClassParameterTypes.kt") + public void testMemberExtValDelegationWithInlineClassParameterTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberExtValDelegationWithInlineClassParameterTypes.kt"); + } + + @TestMetadata("memberExtVarDelegationWithInlineClassParameterTypes.kt") + public void testMemberExtVarDelegationWithInlineClassParameterTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberExtVarDelegationWithInlineClassParameterTypes.kt"); + } + + @TestMetadata("memberFunDelegatedToInlineClassInt.kt") + public void testMemberFunDelegatedToInlineClassInt() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegatedToInlineClassInt.kt"); + } + + @TestMetadata("memberFunDelegatedToInlineClassLong.kt") + public void testMemberFunDelegatedToInlineClassLong() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegatedToInlineClassLong.kt"); + } + + @TestMetadata("memberFunDelegationToInlineClassWithInlineClassParameterTypes.kt") + public void testMemberFunDelegationToInlineClassWithInlineClassParameterTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegationToInlineClassWithInlineClassParameterTypes.kt"); + } + + @TestMetadata("memberFunDelegationWithInlineClassParameterTypes.kt") + public void testMemberFunDelegationWithInlineClassParameterTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegationWithInlineClassParameterTypes.kt"); + } + } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class)