From 4099dfc7e056de648c0e7cd1ac968e773e797bd5 Mon Sep 17 00:00:00 2001 From: Ilmir Usmanov Date: Fri, 12 Mar 2021 19:25:12 +0100 Subject: [PATCH] JVM_IR: Do not unbox Result argument inside SAM adapters #KT-45259 Fixed --- .../FirBlackBoxCodegenTestGenerated.java | 22 ++++++++++++++++++ .../backend/jvm/codegen/ExpressionCodegen.kt | 4 +++- .../inlineClasses/funInterface/argumentIC.kt | 20 ++++++++++++++++ .../funInterface/argumentResult.kt | 19 +++++++++++++++ .../codegen/BlackBoxCodegenTestGenerated.java | 22 ++++++++++++++++++ .../IrBlackBoxCodegenTestGenerated.java | 22 ++++++++++++++++++ .../LightAnalysisModeTestGenerated.java | 23 +++++++++++++++++++ .../IrJsCodegenBoxES6TestGenerated.java | 23 +++++++++++++++++++ .../IrJsCodegenBoxTestGenerated.java | 23 +++++++++++++++++++ .../semantics/JsCodegenBoxTestGenerated.java | 23 +++++++++++++++++++ .../IrCodegenBoxWasmTestGenerated.java | 23 +++++++++++++++++++ 11 files changed, 223 insertions(+), 1 deletion(-) create mode 100644 compiler/testData/codegen/box/inlineClasses/funInterface/argumentIC.kt create mode 100644 compiler/testData/codegen/box/inlineClasses/funInterface/argumentResult.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 e034fb2f921..b56d0ce1e47 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 @@ -18628,6 +18628,28 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } } + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/funInterface") + @TestDataPath("$PROJECT_ROOT") + public class FunInterface { + @Test + public void testAllFilesPresentInFunInterface() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("argumentIC.kt") + public void testArgumentIC() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterface/argumentIC.kt"); + } + + @Test + @TestMetadata("argumentResult.kt") + public void testArgumentResult() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterface/argumentResult.kt"); + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/functionNameMangling") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt index fb439eb082f..53f15311364 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt @@ -658,12 +658,14 @@ class ExpressionCodegen( val genericOrAnyOverride = irFunction.overriddenSymbols.any { val overriddenParam = if (index < 0) it.owner.dispatchReceiverParameter!! else it.owner.valueParameters[index] overriddenParam.type.erasedUpperBound.fqNameWhenAvailable != StandardNames.RESULT_FQ_NAME - } || irFunction.parentAsClass.origin == JvmLoweredDeclarationOrigin.LAMBDA_IMPL + } || irFunction.parentAsClass.let { it.origin == JvmLoweredDeclarationOrigin.LAMBDA_IMPL && !it.isSamAdapter() } if (!genericOrAnyOverride) return StackValue.unboxInlineClass(OBJECT_TYPE, arg.type.erasedUpperBound.defaultType.toIrBasedKotlinType(), mv) } + private fun IrClass.isSamAdapter(): Boolean = this.superTypes.any { it.getClass()?.isFun == true } + private fun onlyResultInlineClassParameters(): Boolean = irFunction.valueParameters.all { !it.type.erasedUpperBound.isInline || it.type.erasedUpperBound.fqNameWhenAvailable == StandardNames.RESULT_FQ_NAME } diff --git a/compiler/testData/codegen/box/inlineClasses/funInterface/argumentIC.kt b/compiler/testData/codegen/box/inlineClasses/funInterface/argumentIC.kt new file mode 100644 index 00000000000..790cc611b7e --- /dev/null +++ b/compiler/testData/codegen/box/inlineClasses/funInterface/argumentIC.kt @@ -0,0 +1,20 @@ +// WITH_RUNTIME +// KJS_WITH_FULL_RUNTIME + +inline class Result(val isSuccess: Boolean) + +fun interface ResultHandler { + fun onResult(result: Result) +} + +fun doSmth(resultHandler: ResultHandler) { + resultHandler.onResult(Result(true)) +} + +fun box(): String { + var res = "FAIL" + doSmth { result -> + res = if (result.isSuccess) "OK" else "FAIL 1" + } + return res +} diff --git a/compiler/testData/codegen/box/inlineClasses/funInterface/argumentResult.kt b/compiler/testData/codegen/box/inlineClasses/funInterface/argumentResult.kt new file mode 100644 index 00000000000..b271de1a9e8 --- /dev/null +++ b/compiler/testData/codegen/box/inlineClasses/funInterface/argumentResult.kt @@ -0,0 +1,19 @@ +// WITH_RUNTIME +// KJS_WITH_FULL_RUNTIME +// IGNORE_BACKEND: JVM + +fun interface ResultHandler { + fun onResult(result: Result) +} + +fun doSmth(resultHandler: ResultHandler) { + resultHandler.onResult(Result.success(true)) +} + +fun box(): String { + var res = "FAIL" + doSmth { result -> + res = if (result.isSuccess) "OK" else "FAIL 1" + } + return res +} 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 5b747375c2b..6faf50924d5 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 @@ -18628,6 +18628,28 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } } + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/funInterface") + @TestDataPath("$PROJECT_ROOT") + public class FunInterface { + @Test + public void testAllFilesPresentInFunInterface() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + } + + @Test + @TestMetadata("argumentIC.kt") + public void testArgumentIC() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterface/argumentIC.kt"); + } + + @Test + @TestMetadata("argumentResult.kt") + public void testArgumentResult() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterface/argumentResult.kt"); + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/functionNameMangling") @TestDataPath("$PROJECT_ROOT") 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 f4518a0374a..30e678a0990 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 @@ -18628,6 +18628,28 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } } + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/funInterface") + @TestDataPath("$PROJECT_ROOT") + public class FunInterface { + @Test + public void testAllFilesPresentInFunInterface() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("argumentIC.kt") + public void testArgumentIC() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterface/argumentIC.kt"); + } + + @Test + @TestMetadata("argumentResult.kt") + public void testArgumentResult() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterface/argumentResult.kt"); + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/functionNameMangling") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java index dc967907f94..f93eb691f6b 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java @@ -15504,6 +15504,29 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/funInterface") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class FunInterface extends AbstractLightAnalysisModeTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath); + } + + public void testAllFilesPresentInFunInterface() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + } + + @TestMetadata("argumentIC.kt") + public void testArgumentIC() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterface/argumentIC.kt"); + } + + @TestMetadata("argumentResult.kt") + public void testArgumentResult() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterface/argumentResult.kt"); + } + } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/functionNameMangling") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenBoxES6TestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenBoxES6TestGenerated.java index d7e5bbea970..8e617730727 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenBoxES6TestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenBoxES6TestGenerated.java @@ -13657,6 +13657,29 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/funInterface") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class FunInterface extends AbstractIrJsCodegenBoxES6Test { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS_IR_ES6, testDataFilePath); + } + + public void testAllFilesPresentInFunInterface() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + } + + @TestMetadata("argumentIC.kt") + public void testArgumentIC() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterface/argumentIC.kt"); + } + + @TestMetadata("argumentResult.kt") + public void testArgumentResult() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterface/argumentResult.kt"); + } + } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/functionNameMangling") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java index 44bbbbcf677..c1f8b450f72 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java @@ -13114,6 +13114,29 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/funInterface") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class FunInterface extends AbstractIrJsCodegenBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS_IR, testDataFilePath); + } + + public void testAllFilesPresentInFunInterface() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + } + + @TestMetadata("argumentIC.kt") + public void testArgumentIC() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterface/argumentIC.kt"); + } + + @TestMetadata("argumentResult.kt") + public void testArgumentResult() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterface/argumentResult.kt"); + } + } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/functionNameMangling") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java index c978b54f095..631ee91a3be 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java @@ -13179,6 +13179,29 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/funInterface") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class FunInterface extends AbstractJsCodegenBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS, testDataFilePath); + } + + public void testAllFilesPresentInFunInterface() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + } + + @TestMetadata("argumentIC.kt") + public void testArgumentIC() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterface/argumentIC.kt"); + } + + @TestMetadata("argumentResult.kt") + public void testArgumentResult() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterface/argumentResult.kt"); + } + } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/functionNameMangling") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/wasm/semantics/IrCodegenBoxWasmTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/wasm/semantics/IrCodegenBoxWasmTestGenerated.java index a44affb9273..ec4fc854be0 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/wasm/semantics/IrCodegenBoxWasmTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/wasm/semantics/IrCodegenBoxWasmTestGenerated.java @@ -7365,6 +7365,29 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/funInterface") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class FunInterface extends AbstractIrCodegenBoxWasmTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); + } + + public void testAllFilesPresentInFunInterface() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/funInterface"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @TestMetadata("argumentIC.kt") + public void testArgumentIC() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterface/argumentIC.kt"); + } + + @TestMetadata("argumentResult.kt") + public void testArgumentResult() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterface/argumentResult.kt"); + } + } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/functionNameMangling") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class)