From d5d3d9f112ab4bc5fc432b90203c8aa0fccf74aa Mon Sep 17 00:00:00 2001 From: pyos Date: Wed, 2 Jun 2021 15:30:13 +0200 Subject: [PATCH] Add regression tests for KT-46890 and other stuff --- .../FirBlackBoxCodegenTestGenerated.java | 46 +++++++++++++++++++ .../backend/jvm/codegen/ExpressionCodegen.kt | 4 -- .../box/inlineClasses/result/directCall1.kt | 11 +++++ .../box/inlineClasses/result/directCall2.kt | 13 ++++++ .../inlineClasses/result/doubleOverride.kt | 19 ++++++++ .../inlineClasses/result/extensionOverride.kt | 14 ++++++ .../result/inlineMethodOnResult.kt | 11 +++++ .../result/lambdaTakesResultThroughBridge.kt | 7 +++ .../codegen/BlackBoxCodegenTestGenerated.java | 46 +++++++++++++++++++ .../IrBlackBoxCodegenTestGenerated.java | 46 +++++++++++++++++++ .../LightAnalysisModeTestGenerated.java | 43 +++++++++++++++++ .../IrJsCodegenBoxES6TestGenerated.java | 43 +++++++++++++++++ .../IrJsCodegenBoxTestGenerated.java | 43 +++++++++++++++++ .../semantics/JsCodegenBoxTestGenerated.java | 43 +++++++++++++++++ .../IrCodegenBoxWasmTestGenerated.java | 43 +++++++++++++++++ 15 files changed, 428 insertions(+), 4 deletions(-) create mode 100644 compiler/testData/codegen/box/inlineClasses/result/directCall1.kt create mode 100644 compiler/testData/codegen/box/inlineClasses/result/directCall2.kt create mode 100644 compiler/testData/codegen/box/inlineClasses/result/doubleOverride.kt create mode 100644 compiler/testData/codegen/box/inlineClasses/result/extensionOverride.kt create mode 100644 compiler/testData/codegen/box/inlineClasses/result/inlineMethodOnResult.kt create mode 100644 compiler/testData/codegen/box/inlineClasses/result/lambdaTakesResultThroughBridge.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 bd9193d02d6..e696c30ccb8 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 @@ -20196,6 +20196,52 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } } + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/result") + @TestDataPath("$PROJECT_ROOT") + public class Result { + @Test + public void testAllFilesPresentInResult() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/result"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("directCall1.kt") + public void testDirectCall1() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/directCall1.kt"); + } + + @Test + @TestMetadata("directCall2.kt") + public void testDirectCall2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/directCall2.kt"); + } + + @Test + @TestMetadata("doubleOverride.kt") + public void testDoubleOverride() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/doubleOverride.kt"); + } + + @Test + @TestMetadata("extensionOverride.kt") + public void testExtensionOverride() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/extensionOverride.kt"); + } + + @Test + @TestMetadata("inlineMethodOnResult.kt") + public void testInlineMethodOnResult() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/inlineMethodOnResult.kt"); + } + + @Test + @TestMetadata("lambdaTakesResultThroughBridge.kt") + public void testLambdaTakesResultThroughBridge() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/lambdaTakesResultThroughBridge.kt"); + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/returnResult") @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 185e5e0a591..af6f6ea913f 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 @@ -677,10 +677,6 @@ class ExpressionCodegen( return when { // Only care about `Result`; `Result?` is boxed in any case. type.erasedUpperBound.fqNameWhenAvailable != StandardNames.RESULT_FQ_NAME || type.isNullable() -> null - // In `SuspendLambda.invoke`, we take a boxed result and store it in a field of type `Any?` (or pass it - // to `create(Any?)`). Normally, we'd unbox here and the box at the store/call, but the boxing is elided - // by the hack in `PromisedValue.materializedAt`, and so we remove the unboxing as well. TODO: unhack this. - parentAsClass.origin == JvmLoweredDeclarationOrigin.SUSPEND_LAMBDA && name == OperatorNameConventions.INVOKE -> false // If there's a bridge, it will unbox `Result` along with transforming all other arguments. parentAsClass.declarations.any { function -> function is IrSimpleFunction && function != this && diff --git a/compiler/testData/codegen/box/inlineClasses/result/directCall1.kt b/compiler/testData/codegen/box/inlineClasses/result/directCall1.kt new file mode 100644 index 00000000000..92cbc739504 --- /dev/null +++ b/compiler/testData/codegen/box/inlineClasses/result/directCall1.kt @@ -0,0 +1,11 @@ +// WITH_RUNTIME +// IGNORE_BACKEND: JVM, WASM +interface I { + fun foo(x: T): T +} + +class C : I> { + override fun foo(x: Result) = x +} + +fun box() = C().foo(Result.success("OK")).getOrNull() diff --git a/compiler/testData/codegen/box/inlineClasses/result/directCall2.kt b/compiler/testData/codegen/box/inlineClasses/result/directCall2.kt new file mode 100644 index 00000000000..fab440cbd77 --- /dev/null +++ b/compiler/testData/codegen/box/inlineClasses/result/directCall2.kt @@ -0,0 +1,13 @@ +// WITH_RUNTIME +// IGNORE_BACKEND: JVM, WASM +interface I { + fun foo(x: T): Any? +} + +class C : I> { + override fun foo(x: Result) = x.getOrNullNoinline() +} + +fun Result.getOrNullNoinline() = getOrNull() + +fun box() = C().foo(Result.success("OK")) diff --git a/compiler/testData/codegen/box/inlineClasses/result/doubleOverride.kt b/compiler/testData/codegen/box/inlineClasses/result/doubleOverride.kt new file mode 100644 index 00000000000..536cda6d7cb --- /dev/null +++ b/compiler/testData/codegen/box/inlineClasses/result/doubleOverride.kt @@ -0,0 +1,19 @@ +// WITH_RUNTIME +// IGNORE_BACKEND: JVM +interface C { + abstract fun foo(x: T): String +} + +open class D : C> { + open override fun foo(x: Result): String = "???" +} + +class E : D() { + override fun foo(x: Result): String = x.get() +} + +fun Result.get(): T = getOrNull()!! + +fun C>.bar(x: T) = foo(Result.success(x)) + +fun box() = E().bar("OK") diff --git a/compiler/testData/codegen/box/inlineClasses/result/extensionOverride.kt b/compiler/testData/codegen/box/inlineClasses/result/extensionOverride.kt new file mode 100644 index 00000000000..0230d96bfd8 --- /dev/null +++ b/compiler/testData/codegen/box/inlineClasses/result/extensionOverride.kt @@ -0,0 +1,14 @@ +// WITH_RUNTIME +fun Result.get(): T = getOrNull()!! + +interface C { + abstract fun Result.foo(): String +} + +class D : C { + override fun Result.foo() = get() +} + +fun C.bar(x: T) = Result.success(x).foo() + +fun box() = D().bar("OK") diff --git a/compiler/testData/codegen/box/inlineClasses/result/inlineMethodOnResult.kt b/compiler/testData/codegen/box/inlineClasses/result/inlineMethodOnResult.kt new file mode 100644 index 00000000000..f7667771f7c --- /dev/null +++ b/compiler/testData/codegen/box/inlineClasses/result/inlineMethodOnResult.kt @@ -0,0 +1,11 @@ +// WITH_RUNTIME +// IGNORE_BACKEND: WASM +interface I { + fun foo(x: T): V +} + +class C : I, Any?> { + override fun foo(x: Result) = x.getOrNull() +} + +fun box() = (C() as I, Any?>).foo(Result.success("OK")) diff --git a/compiler/testData/codegen/box/inlineClasses/result/lambdaTakesResultThroughBridge.kt b/compiler/testData/codegen/box/inlineClasses/result/lambdaTakesResultThroughBridge.kt new file mode 100644 index 00000000000..3df354f4308 --- /dev/null +++ b/compiler/testData/codegen/box/inlineClasses/result/lambdaTakesResultThroughBridge.kt @@ -0,0 +1,7 @@ +// WITH_RUNTIME +// IGNORE_BACKEND: WASM +fun Result.getOrNullNoinline() = getOrNull() + +val x = { a: Int, b: Result -> b.getOrNullNoinline() } + +fun box() = x(1, Result.success("OK")) 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 0915adaa53a..b5f3e2403b0 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 @@ -20166,6 +20166,52 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } } + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/result") + @TestDataPath("$PROJECT_ROOT") + public class Result { + @Test + public void testAllFilesPresentInResult() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/result"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + } + + @Test + @TestMetadata("directCall1.kt") + public void testDirectCall1() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/directCall1.kt"); + } + + @Test + @TestMetadata("directCall2.kt") + public void testDirectCall2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/directCall2.kt"); + } + + @Test + @TestMetadata("doubleOverride.kt") + public void testDoubleOverride() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/doubleOverride.kt"); + } + + @Test + @TestMetadata("extensionOverride.kt") + public void testExtensionOverride() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/extensionOverride.kt"); + } + + @Test + @TestMetadata("inlineMethodOnResult.kt") + public void testInlineMethodOnResult() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/inlineMethodOnResult.kt"); + } + + @Test + @TestMetadata("lambdaTakesResultThroughBridge.kt") + public void testLambdaTakesResultThroughBridge() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/lambdaTakesResultThroughBridge.kt"); + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/returnResult") @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 b8815f37402..d65c5afc93b 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 @@ -20196,6 +20196,52 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } } + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/result") + @TestDataPath("$PROJECT_ROOT") + public class Result { + @Test + public void testAllFilesPresentInResult() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/result"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("directCall1.kt") + public void testDirectCall1() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/directCall1.kt"); + } + + @Test + @TestMetadata("directCall2.kt") + public void testDirectCall2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/directCall2.kt"); + } + + @Test + @TestMetadata("doubleOverride.kt") + public void testDoubleOverride() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/doubleOverride.kt"); + } + + @Test + @TestMetadata("extensionOverride.kt") + public void testExtensionOverride() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/extensionOverride.kt"); + } + + @Test + @TestMetadata("inlineMethodOnResult.kt") + public void testInlineMethodOnResult() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/inlineMethodOnResult.kt"); + } + + @Test + @TestMetadata("lambdaTakesResultThroughBridge.kt") + public void testLambdaTakesResultThroughBridge() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/lambdaTakesResultThroughBridge.kt"); + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/returnResult") @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 8ced3997687..68007217136 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java @@ -16785,6 +16785,49 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/result") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Result extends AbstractLightAnalysisModeTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath); + } + + public void testAllFilesPresentInResult() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/result"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + } + + @TestMetadata("directCall1.kt") + public void testDirectCall1() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/directCall1.kt"); + } + + @TestMetadata("directCall2.kt") + public void testDirectCall2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/directCall2.kt"); + } + + @TestMetadata("doubleOverride.kt") + public void testDoubleOverride() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/doubleOverride.kt"); + } + + @TestMetadata("extensionOverride.kt") + public void testExtensionOverride() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/extensionOverride.kt"); + } + + @TestMetadata("inlineMethodOnResult.kt") + public void testInlineMethodOnResult() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/inlineMethodOnResult.kt"); + } + + @TestMetadata("lambdaTakesResultThroughBridge.kt") + public void testLambdaTakesResultThroughBridge() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/lambdaTakesResultThroughBridge.kt"); + } + } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/returnResult") @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 43894387556..8b9632eaef0 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 @@ -14729,6 +14729,49 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/result") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Result extends AbstractIrJsCodegenBoxES6Test { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS_IR_ES6, testDataFilePath); + } + + public void testAllFilesPresentInResult() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/result"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + } + + @TestMetadata("directCall1.kt") + public void testDirectCall1() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/directCall1.kt"); + } + + @TestMetadata("directCall2.kt") + public void testDirectCall2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/directCall2.kt"); + } + + @TestMetadata("doubleOverride.kt") + public void testDoubleOverride() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/doubleOverride.kt"); + } + + @TestMetadata("extensionOverride.kt") + public void testExtensionOverride() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/extensionOverride.kt"); + } + + @TestMetadata("inlineMethodOnResult.kt") + public void testInlineMethodOnResult() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/inlineMethodOnResult.kt"); + } + + @TestMetadata("lambdaTakesResultThroughBridge.kt") + public void testLambdaTakesResultThroughBridge() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/lambdaTakesResultThroughBridge.kt"); + } + } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/returnResult") @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 27993884fce..64a2ea02df0 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 @@ -14135,6 +14135,49 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/result") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Result extends AbstractIrJsCodegenBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS_IR, testDataFilePath); + } + + public void testAllFilesPresentInResult() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/result"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + } + + @TestMetadata("directCall1.kt") + public void testDirectCall1() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/directCall1.kt"); + } + + @TestMetadata("directCall2.kt") + public void testDirectCall2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/directCall2.kt"); + } + + @TestMetadata("doubleOverride.kt") + public void testDoubleOverride() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/doubleOverride.kt"); + } + + @TestMetadata("extensionOverride.kt") + public void testExtensionOverride() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/extensionOverride.kt"); + } + + @TestMetadata("inlineMethodOnResult.kt") + public void testInlineMethodOnResult() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/inlineMethodOnResult.kt"); + } + + @TestMetadata("lambdaTakesResultThroughBridge.kt") + public void testLambdaTakesResultThroughBridge() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/lambdaTakesResultThroughBridge.kt"); + } + } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/returnResult") @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 cb8a72000ed..3ace06aa4a1 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 @@ -14200,6 +14200,49 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/result") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Result extends AbstractJsCodegenBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS, testDataFilePath); + } + + public void testAllFilesPresentInResult() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/result"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + } + + @TestMetadata("directCall1.kt") + public void testDirectCall1() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/directCall1.kt"); + } + + @TestMetadata("directCall2.kt") + public void testDirectCall2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/directCall2.kt"); + } + + @TestMetadata("doubleOverride.kt") + public void testDoubleOverride() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/doubleOverride.kt"); + } + + @TestMetadata("extensionOverride.kt") + public void testExtensionOverride() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/extensionOverride.kt"); + } + + @TestMetadata("inlineMethodOnResult.kt") + public void testInlineMethodOnResult() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/inlineMethodOnResult.kt"); + } + + @TestMetadata("lambdaTakesResultThroughBridge.kt") + public void testLambdaTakesResultThroughBridge() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/lambdaTakesResultThroughBridge.kt"); + } + } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/returnResult") @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 999af21bc7d..b7a4ccaa5a5 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 @@ -8065,6 +8065,49 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/result") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Result extends AbstractIrCodegenBoxWasmTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); + } + + public void testAllFilesPresentInResult() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/result"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @TestMetadata("directCall1.kt") + public void testDirectCall1() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/directCall1.kt"); + } + + @TestMetadata("directCall2.kt") + public void testDirectCall2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/directCall2.kt"); + } + + @TestMetadata("doubleOverride.kt") + public void testDoubleOverride() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/doubleOverride.kt"); + } + + @TestMetadata("extensionOverride.kt") + public void testExtensionOverride() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/extensionOverride.kt"); + } + + @TestMetadata("inlineMethodOnResult.kt") + public void testInlineMethodOnResult() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/inlineMethodOnResult.kt"); + } + + @TestMetadata("lambdaTakesResultThroughBridge.kt") + public void testLambdaTakesResultThroughBridge() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/lambdaTakesResultThroughBridge.kt"); + } + } + @TestMetadata("compiler/testData/codegen/box/inlineClasses/returnResult") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class)