From 1333267983dd7254ece3d44e633ba03869ea0b60 Mon Sep 17 00:00:00 2001 From: Svyatoslav Kuzmich Date: Fri, 10 Jan 2020 14:46:57 +0300 Subject: [PATCH] [JS IR] Add serialization regressions tests --- .../box/ir/serializationRegressions/README.md | 3 + .../dispatchReceiverValue.kt | 20 ++++++ .../genericProperty.kt | 29 +++++++++ .../innerClassInEnumEntryClass.kt | 25 +++++++ .../useImportedMember.kt | 65 +++++++++++++++++++ .../codegen/BlackBoxCodegenTestGenerated.java | 33 ++++++++++ .../LightAnalysisModeTestGenerated.java | 33 ++++++++++ .../ir/FirBlackBoxCodegenTestGenerated.java | 33 ++++++++++ .../ir/IrBlackBoxCodegenTestGenerated.java | 33 ++++++++++ .../IrJsCodegenBoxTestGenerated.java | 33 ++++++++++ .../semantics/JsCodegenBoxTestGenerated.java | 33 ++++++++++ 11 files changed, 340 insertions(+) create mode 100644 compiler/testData/codegen/box/ir/serializationRegressions/README.md create mode 100644 compiler/testData/codegen/box/ir/serializationRegressions/dispatchReceiverValue.kt create mode 100644 compiler/testData/codegen/box/ir/serializationRegressions/genericProperty.kt create mode 100644 compiler/testData/codegen/box/ir/serializationRegressions/innerClassInEnumEntryClass.kt create mode 100644 compiler/testData/codegen/box/ir/serializationRegressions/useImportedMember.kt diff --git a/compiler/testData/codegen/box/ir/serializationRegressions/README.md b/compiler/testData/codegen/box/ir/serializationRegressions/README.md new file mode 100644 index 00000000000..cd4ddeb00ce --- /dev/null +++ b/compiler/testData/codegen/box/ir/serializationRegressions/README.md @@ -0,0 +1,3 @@ +Directory contains copies of codegen box tests that used to fail during IR serialization or deserialization. + +They are splitted into multiple modules to force serialization and deserializations in applicable backend. \ No newline at end of file diff --git a/compiler/testData/codegen/box/ir/serializationRegressions/dispatchReceiverValue.kt b/compiler/testData/codegen/box/ir/serializationRegressions/dispatchReceiverValue.kt new file mode 100644 index 00000000000..313f89bae58 --- /dev/null +++ b/compiler/testData/codegen/box/ir/serializationRegressions/dispatchReceiverValue.kt @@ -0,0 +1,20 @@ +// !LANGUAGE: +MultiPlatformProjects +// IGNORE_BACKEND: JS_IR +// IGNORE_BACKEND_FIR: JVM_IR +// MODULE: lib +// FILE: common.kt + +expect class C { + val value: String + + fun test(result: String = value): String +} + +// FILE: platform.kt +actual class C(actual val value: String) { + actual fun test(result: String): String = result +} + +// MODULE: main(lib) +// FILE: main.kt +fun box() = C("Fail").test("OK") diff --git a/compiler/testData/codegen/box/ir/serializationRegressions/genericProperty.kt b/compiler/testData/codegen/box/ir/serializationRegressions/genericProperty.kt new file mode 100644 index 00000000000..e07ec7b7f59 --- /dev/null +++ b/compiler/testData/codegen/box/ir/serializationRegressions/genericProperty.kt @@ -0,0 +1,29 @@ +// IGNORE_BACKEND_FIR: JVM_IR +// IGNORE_BACKEND: NATIVE +// IGNORE_BACKEND: JS_IR +//For KT-6020 + +// MODULE: lib +// FILE: lib.kt +import kotlin.reflect.KProperty1 +import kotlin.reflect.KMutableProperty1 +import kotlin.reflect.KProperty + +class Value(var value: T = null as T, var text: String? = null) + +val Value.additionalText by DVal(Value::text) //works + +val Value.additionalValue by DVal(Value::value) //not work + +class DVal>(val kmember: P) { + operator fun getValue(t: T, p: KProperty<*>): R { + return kmember.get(t) + } +} + +// MODULE: main(lib) +// FILE: main.kt +fun box(): String { + val p = Value("O", "K") + return p.additionalValue + p.additionalText +} diff --git a/compiler/testData/codegen/box/ir/serializationRegressions/innerClassInEnumEntryClass.kt b/compiler/testData/codegen/box/ir/serializationRegressions/innerClassInEnumEntryClass.kt new file mode 100644 index 00000000000..73c4d9bea99 --- /dev/null +++ b/compiler/testData/codegen/box/ir/serializationRegressions/innerClassInEnumEntryClass.kt @@ -0,0 +1,25 @@ +// IGNORE_BACKEND_FIR: JVM_IR +// IGNORE_BACKEND: JS_IR + +// MODULE: lib +// FILE: lib.kt +enum class A { + X { + val x = "OK" + + inner class Inner { + val y = x + } + + val z = Inner() + + override val test: String + get() = z.y + }; + + abstract val test: String +} + +// MODULE: main(lib) +// FILE: main.kt +fun box() = A.X.test diff --git a/compiler/testData/codegen/box/ir/serializationRegressions/useImportedMember.kt b/compiler/testData/codegen/box/ir/serializationRegressions/useImportedMember.kt new file mode 100644 index 00000000000..103576fbc36 --- /dev/null +++ b/compiler/testData/codegen/box/ir/serializationRegressions/useImportedMember.kt @@ -0,0 +1,65 @@ +// IGNORE_BACKEND: JS_IR +// IGNORE_BACKEND_FIR: JVM_IR +// MODULE: lib +// FILE: lib.kt +import C.f +import C.p +import C.ext +import C.g1 +import C.g2 +import C.fromClass +import C.fromInterface +import C.genericFromSuper + +interface I { + fun T.fromInterface(): T = this + + fun genericFromSuper(g: G) = g +} + +open class BaseClass { + val T.fromClass: T + get() = this +} + +object C: BaseClass(), I { + fun f(s: Int) = 1 + fun f(s: String) = 2 + fun Boolean.f() = 3 + + var p: Int = 4 + val Int.ext: Int + get() = 6 + + fun g1(t: T): T = t + val T.g2: T + get() = this +} + +// MODULE: main(lib) +// FILE: main.kt +import C.f +import C.p +import C.ext +import C.g1 +import C.g2 +import C.fromClass +import C.fromInterface +import C.genericFromSuper + +fun box(): String { + if (f(1) != 1) return "1" + if (f("s") != 2) return "2" + if (true.f() != 3) return "3" + if (p != 4) return "4" + p = 5 + if (p != 5) return "5" + if (5.ext != 6) return "6" + if (g1("7") != "7") return "7" + if ("8".g2 != "8") return "8" + if (9.fromInterface() != 9) return "9" + if ("10".fromClass != "10") return "10" + if (genericFromSuper("11") != "11") return "11" + + return "OK" +} \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java index 5943b3aa715..84b7ee95d74 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java @@ -14483,6 +14483,39 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { runTest("compiler/testData/codegen/box/ir/primitiveNumberComparisons/mixedNumberTypes.kt"); } } + + @TestMetadata("compiler/testData/codegen/box/ir/serializationRegressions") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SerializationRegressions extends AbstractBlackBoxCodegenTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath); + } + + public void testAllFilesPresentInSerializationRegressions() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/serializationRegressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + } + + @TestMetadata("dispatchReceiverValue.kt") + public void testDispatchReceiverValue() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/dispatchReceiverValue.kt"); + } + + @TestMetadata("genericProperty.kt") + public void testGenericProperty() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/genericProperty.kt"); + } + + @TestMetadata("innerClassInEnumEntryClass.kt") + public void testInnerClassInEnumEntryClass() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/innerClassInEnumEntryClass.kt"); + } + + @TestMetadata("useImportedMember.kt") + public void testUseImportedMember() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/useImportedMember.kt"); + } + } } @TestMetadata("compiler/testData/codegen/box/javaInterop") diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java index 1bf48f9292d..b4e7cd00a41 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java @@ -14483,6 +14483,39 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes runTest("compiler/testData/codegen/box/ir/primitiveNumberComparisons/mixedNumberTypes.kt"); } } + + @TestMetadata("compiler/testData/codegen/box/ir/serializationRegressions") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SerializationRegressions extends AbstractLightAnalysisModeTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath); + } + + public void testAllFilesPresentInSerializationRegressions() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/serializationRegressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + } + + @TestMetadata("dispatchReceiverValue.kt") + public void testDispatchReceiverValue() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/dispatchReceiverValue.kt"); + } + + @TestMetadata("genericProperty.kt") + public void testGenericProperty() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/genericProperty.kt"); + } + + @TestMetadata("innerClassInEnumEntryClass.kt") + public void testInnerClassInEnumEntryClass() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/innerClassInEnumEntryClass.kt"); + } + + @TestMetadata("useImportedMember.kt") + public void testUseImportedMember() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/useImportedMember.kt"); + } + } } @TestMetadata("compiler/testData/codegen/box/javaInterop") diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java index a499c3e3d7e..5dc321ffa68 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java @@ -13333,6 +13333,39 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT runTest("compiler/testData/codegen/box/ir/primitiveNumberComparisons/mixedNumberTypes.kt"); } } + + @TestMetadata("compiler/testData/codegen/box/ir/serializationRegressions") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SerializationRegressions extends AbstractFirBlackBoxCodegenTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_IR, testDataFilePath, "// IGNORE_BACKEND_FIR: "); + } + + public void testAllFilesPresentInSerializationRegressions() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/serializationRegressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @TestMetadata("dispatchReceiverValue.kt") + public void testDispatchReceiverValue() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/dispatchReceiverValue.kt"); + } + + @TestMetadata("genericProperty.kt") + public void testGenericProperty() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/genericProperty.kt"); + } + + @TestMetadata("innerClassInEnumEntryClass.kt") + public void testInnerClassInEnumEntryClass() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/innerClassInEnumEntryClass.kt"); + } + + @TestMetadata("useImportedMember.kt") + public void testUseImportedMember() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/useImportedMember.kt"); + } + } } @TestMetadata("compiler/testData/codegen/box/javaInterop") diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java index 6e56abdea8a..d73d33d3b02 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java @@ -13333,6 +13333,39 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes runTest("compiler/testData/codegen/box/ir/primitiveNumberComparisons/mixedNumberTypes.kt"); } } + + @TestMetadata("compiler/testData/codegen/box/ir/serializationRegressions") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SerializationRegressions extends AbstractIrBlackBoxCodegenTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); + } + + public void testAllFilesPresentInSerializationRegressions() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/serializationRegressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @TestMetadata("dispatchReceiverValue.kt") + public void testDispatchReceiverValue() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/dispatchReceiverValue.kt"); + } + + @TestMetadata("genericProperty.kt") + public void testGenericProperty() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/genericProperty.kt"); + } + + @TestMetadata("innerClassInEnumEntryClass.kt") + public void testInnerClassInEnumEntryClass() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/innerClassInEnumEntryClass.kt"); + } + + @TestMetadata("useImportedMember.kt") + public void testUseImportedMember() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/useImportedMember.kt"); + } + } } @TestMetadata("compiler/testData/codegen/box/javaInterop") 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 7d209855d43..278da75c2de 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 @@ -11593,6 +11593,39 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { runTest("compiler/testData/codegen/box/ir/primitiveNumberComparisons/mixedNumberTypes.kt"); } } + + @TestMetadata("compiler/testData/codegen/box/ir/serializationRegressions") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SerializationRegressions extends AbstractIrJsCodegenBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS_IR, testDataFilePath); + } + + public void testAllFilesPresentInSerializationRegressions() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/serializationRegressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + } + + @TestMetadata("dispatchReceiverValue.kt") + public void testDispatchReceiverValue() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/dispatchReceiverValue.kt"); + } + + @TestMetadata("genericProperty.kt") + public void testGenericProperty() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/genericProperty.kt"); + } + + @TestMetadata("innerClassInEnumEntryClass.kt") + public void testInnerClassInEnumEntryClass() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/innerClassInEnumEntryClass.kt"); + } + + @TestMetadata("useImportedMember.kt") + public void testUseImportedMember() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/useImportedMember.kt"); + } + } } @TestMetadata("compiler/testData/codegen/box/javaInterop") 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 d95e57118fd..9e842ddb6c6 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 @@ -12733,6 +12733,39 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { runTest("compiler/testData/codegen/box/ir/primitiveNumberComparisons/mixedNumberTypes.kt"); } } + + @TestMetadata("compiler/testData/codegen/box/ir/serializationRegressions") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SerializationRegressions extends AbstractJsCodegenBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS, testDataFilePath); + } + + public void testAllFilesPresentInSerializationRegressions() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/serializationRegressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + } + + @TestMetadata("dispatchReceiverValue.kt") + public void testDispatchReceiverValue() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/dispatchReceiverValue.kt"); + } + + @TestMetadata("genericProperty.kt") + public void testGenericProperty() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/genericProperty.kt"); + } + + @TestMetadata("innerClassInEnumEntryClass.kt") + public void testInnerClassInEnumEntryClass() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/innerClassInEnumEntryClass.kt"); + } + + @TestMetadata("useImportedMember.kt") + public void testUseImportedMember() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/useImportedMember.kt"); + } + } } @TestMetadata("compiler/testData/codegen/box/javaInterop")