FIC: add codegen tests, adapt previously tests for SAMs

2019-11-19 10:14:53 +03:00
parent b7c43fc7db
commit 3849b5e723
9 changed files with 327 additions and 69 deletions
@@ -0,0 +1,18 @@
+// !LANGUAGE: +NewInference +FunctionInterfaceConversion +SamConversionPerArgument +SamConversionForKotlinFunctions
+
+fun interface KRunnable {
+    fun invoke()
+}
+
+fun test(a: Any?) {
+    a as () -> Unit
+    KRunnable(a).invoke()
+}
+
+fun box(): String {
+    var result = "Fail"
+    test {
+        result = "OK"
+    }
+    return result
+}
@@ -0,0 +1,28 @@
+// !LANGUAGE: +NewInference +FunctionInterfaceConversion +SamConversionPerArgument +SamConversionForKotlinFunctions
+// WITH_RUNTIME
+
+fun interface MyRunnable {
+    fun invoke()
+}
+
+class A {
+    inline fun doWork(noinline job: () -> Unit) {
+        MyRunnable(job).invoke()
+    }
+
+    fun doNoninlineWork(job: () -> Unit) {
+        MyRunnable(job).invoke()
+    }
+}
+
+fun box(): String {
+    var result = false
+    A().doWork { result = true }
+    if (!result) return "Fail 1"
+
+    result = false
+    A().doNoninlineWork { result = true }
+    if (!result) return "Fail 2"
+
+    return "OK"
+}
@@ -0,0 +1,24 @@
+// !LANGUAGE: +NewInference +FunctionInterfaceConversion +SamConversionPerArgument +SamConversionForKotlinFunctions
+// TARGET_BACKEND: JVM
+// WITH_RUNTIME
+
+fun interface KRunnable {
+    fun invoke()
+}
+
+fun isNull(r: KRunnable?): Boolean {
+    if (r == null) return true
+    r.invoke()
+    return false
+}
+
+fun nullableFun(fromNull: Boolean): (() -> Unit)? =
+    if (fromNull) null else {{}}
+
+fun box(): String {
+    if (!isNull(nullableFun(true))) return "Fail 1"
+    if (isNull(nullableFun(false))) return "Fail 2"
+    if (!isNull(null)) return "Fail 3"
+    if (isNull {}) return "Fail 4"
+    return "OK"
+}
@@ -0,0 +1,41 @@
+// !LANGUAGE: +NewInference +FunctionInterfaceConversion +SamConversionPerArgument +SamConversionForKotlinFunctions
+// WITH_RUNTIME
+
+fun interface Fn<T, R> {
+    fun run(s: String, i: Int, t: T): R
+}
+
+class J {
+    fun runConversion(f1: Fn<String, Int>, f2: Fn<Int, String>): Int {
+        return f1.run("Bar", 1, f2.run("Foo", 42, 239))
+    }
+}
+
+fun box(): String {
+    val j = J()
+    var x = ""
+
+    val fsi = object : Fn<String, Int> {
+        override fun run(s: String, i: Int, t: String): Int {
+            x += "$s$i$t "
+            return i
+        }
+    }
+
+    val fis = object : Fn<Int, String> {
+        override fun run(s: String, i: Int, t: Int): String {
+            x += "$s$i$t "
+            return s
+        }
+    }
+
+    val r1 = j.runConversion(fsi) { s, i, ti -> x += "L$s$i$ti "; "L$s"}
+    val r2 = j.runConversion({ s, i, ts -> x += "L$s$i$ts"; i }, fis)
+
+    if (r1 != 1) return "fail r1: $r1"
+    if (r2 != 1) return "fail r2: $r2"
+
+    if (x != "LFoo42239 Bar1LFoo Foo42239 LBar1Foo") return x
+
+    return "OK"
+}
@@ -0,0 +1,24 @@
+// !LANGUAGE: +NewInference +FunctionInterfaceConversion +SamConversionPerArgument +SamConversionForKotlinFunctions
+
+// TARGET_BACKEND: JVM
+// WITH_RUNTIME
+
+fun interface KRunnable {
+    fun invoke()
+}
+
+fun runTwice(r: KRunnable) {
+    r.invoke()
+    r.invoke()
+}
+
+class A() {
+    fun f() {}
+}
+
+fun box(): String {
+    var x = 0
+    runTwice({ x++; A() }()::f)
+    if (x != 1) return "Fail"
+    return "OK"
+}
@@ -11610,6 +11610,54 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
        }
    }

+    @TestMetadata("compiler/testData/codegen/box/funInterface")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class FunInterface extends AbstractBlackBoxCodegenTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInFunInterface() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/funInterface"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
+        }
+
+        @TestMetadata("basicFunInterface.kt")
+        public void testBasicFunInterface() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/basicFunInterface.kt");
+        }
+
+        @TestMetadata("basicFunInterfaceConversion.kt")
+        public void testBasicFunInterfaceConversion() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/basicFunInterfaceConversion.kt");
+        }
+
+        @TestMetadata("castFromAny.kt")
+        public void testCastFromAny() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/castFromAny.kt");
+        }
+
+        @TestMetadata("inlinedSamWrapper.kt")
+        public void testInlinedSamWrapper() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/inlinedSamWrapper.kt");
+        }
+
+        @TestMetadata("nullableSam.kt")
+        public void testNullableSam() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/nullableSam.kt");
+        }
+
+        @TestMetadata("partialSam.kt")
+        public void testPartialSam() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/partialSam.kt");
+        }
+
+        @TestMetadata("receiverEvaluatedOnce.kt")
+        public void testReceiverEvaluatedOnce() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/receiverEvaluatedOnce.kt");
+        }
+    }
+
    @TestMetadata("compiler/testData/codegen/box/functions")
    @TestDataPath("$PROJECT_ROOT")
    @RunWith(JUnit3RunnerWithInners.class)
@@ -13668,29 +13716,6 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
            }
        }

-        @TestMetadata("compiler/testData/codegen/box/inlineClasses/funInterface")
-        @TestDataPath("$PROJECT_ROOT")
-        @RunWith(JUnit3RunnerWithInners.class)
-        public static class FunInterface extends AbstractBlackBoxCodegenTest {
-            private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
-            }
-
-            public void testAllFilesPresentInFunInterface() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/funInterface"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
-            }
-
-            @TestMetadata("basicFunInterface.kt")
-            public void testBasicFunInterface() throws Exception {
-                runTest("compiler/testData/codegen/box/inlineClasses/funInterface/basicFunInterface.kt");
-            }
-
-            @TestMetadata("basicFunInterfaceConversion.kt")
-            public void testBasicFunInterfaceConversion() throws Exception {
-                runTest("compiler/testData/codegen/box/inlineClasses/funInterface/basicFunInterfaceConversion.kt");
-            }
-        }
-
        @TestMetadata("compiler/testData/codegen/box/inlineClasses/functionNameMangling")
        @TestDataPath("$PROJECT_ROOT")
        @RunWith(JUnit3RunnerWithInners.class)
@@ -11610,6 +11610,54 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
        }
    }

+    @TestMetadata("compiler/testData/codegen/box/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 {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/funInterface"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
+        }
+
+        @TestMetadata("basicFunInterface.kt")
+        public void testBasicFunInterface() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/basicFunInterface.kt");
+        }
+
+        @TestMetadata("basicFunInterfaceConversion.kt")
+        public void testBasicFunInterfaceConversion() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/basicFunInterfaceConversion.kt");
+        }
+
+        @TestMetadata("castFromAny.kt")
+        public void testCastFromAny() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/castFromAny.kt");
+        }
+
+        @TestMetadata("inlinedSamWrapper.kt")
+        public void testInlinedSamWrapper() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/inlinedSamWrapper.kt");
+        }
+
+        @TestMetadata("nullableSam.kt")
+        public void testNullableSam() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/nullableSam.kt");
+        }
+
+        @TestMetadata("partialSam.kt")
+        public void testPartialSam() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/partialSam.kt");
+        }
+
+        @TestMetadata("receiverEvaluatedOnce.kt")
+        public void testReceiverEvaluatedOnce() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/receiverEvaluatedOnce.kt");
+        }
+    }
+
    @TestMetadata("compiler/testData/codegen/box/functions")
    @TestDataPath("$PROJECT_ROOT")
    @RunWith(JUnit3RunnerWithInners.class)
@@ -13668,29 +13716,6 @@ 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 {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/funInterface"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
-            }
-
-            @TestMetadata("basicFunInterface.kt")
-            public void testBasicFunInterface() throws Exception {
-                runTest("compiler/testData/codegen/box/inlineClasses/funInterface/basicFunInterface.kt");
-            }
-
-            @TestMetadata("basicFunInterfaceConversion.kt")
-            public void testBasicFunInterfaceConversion() throws Exception {
-                runTest("compiler/testData/codegen/box/inlineClasses/funInterface/basicFunInterfaceConversion.kt");
-            }
-        }
-
        @TestMetadata("compiler/testData/codegen/box/inlineClasses/functionNameMangling")
        @TestDataPath("$PROJECT_ROOT")
        @RunWith(JUnit3RunnerWithInners.class)
@@ -10460,6 +10460,54 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
        }
    }

+    @TestMetadata("compiler/testData/codegen/box/funInterface")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class FunInterface extends AbstractFirBlackBoxCodegenTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_IR, testDataFilePath, "// IGNORE_BACKEND_FIR: ");
+        }
+
+        public void testAllFilesPresentInFunInterface() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/funInterface"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM_IR, true);
+        }
+
+        @TestMetadata("basicFunInterface.kt")
+        public void testBasicFunInterface() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/basicFunInterface.kt");
+        }
+
+        @TestMetadata("basicFunInterfaceConversion.kt")
+        public void testBasicFunInterfaceConversion() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/basicFunInterfaceConversion.kt");
+        }
+
+        @TestMetadata("castFromAny.kt")
+        public void testCastFromAny() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/castFromAny.kt");
+        }
+
+        @TestMetadata("inlinedSamWrapper.kt")
+        public void testInlinedSamWrapper() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/inlinedSamWrapper.kt");
+        }
+
+        @TestMetadata("nullableSam.kt")
+        public void testNullableSam() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/nullableSam.kt");
+        }
+
+        @TestMetadata("partialSam.kt")
+        public void testPartialSam() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/partialSam.kt");
+        }
+
+        @TestMetadata("receiverEvaluatedOnce.kt")
+        public void testReceiverEvaluatedOnce() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/receiverEvaluatedOnce.kt");
+        }
+    }
+
    @TestMetadata("compiler/testData/codegen/box/functions")
    @TestDataPath("$PROJECT_ROOT")
    @RunWith(JUnit3RunnerWithInners.class)
@@ -10460,6 +10460,54 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
        }
    }

+    @TestMetadata("compiler/testData/codegen/box/funInterface")
+    @TestDataPath("$PROJECT_ROOT")
+    @RunWith(JUnit3RunnerWithInners.class)
+    public static class FunInterface extends AbstractIrBlackBoxCodegenTest {
+        private void runTest(String testDataFilePath) throws Exception {
+            KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+        }
+
+        public void testAllFilesPresentInFunInterface() throws Exception {
+            KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/funInterface"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM_IR, true);
+        }
+
+        @TestMetadata("basicFunInterface.kt")
+        public void testBasicFunInterface() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/basicFunInterface.kt");
+        }
+
+        @TestMetadata("basicFunInterfaceConversion.kt")
+        public void testBasicFunInterfaceConversion() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/basicFunInterfaceConversion.kt");
+        }
+
+        @TestMetadata("castFromAny.kt")
+        public void testCastFromAny() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/castFromAny.kt");
+        }
+
+        @TestMetadata("inlinedSamWrapper.kt")
+        public void testInlinedSamWrapper() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/inlinedSamWrapper.kt");
+        }
+
+        @TestMetadata("nullableSam.kt")
+        public void testNullableSam() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/nullableSam.kt");
+        }
+
+        @TestMetadata("partialSam.kt")
+        public void testPartialSam() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/partialSam.kt");
+        }
+
+        @TestMetadata("receiverEvaluatedOnce.kt")
+        public void testReceiverEvaluatedOnce() throws Exception {
+            runTest("compiler/testData/codegen/box/funInterface/receiverEvaluatedOnce.kt");
+        }
+    }
+
    @TestMetadata("compiler/testData/codegen/box/functions")
    @TestDataPath("$PROJECT_ROOT")
    @RunWith(JUnit3RunnerWithInners.class)
@@ -12518,29 +12566,6 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
            }
        }

-        @TestMetadata("compiler/testData/codegen/box/inlineClasses/funInterface")
-        @TestDataPath("$PROJECT_ROOT")
-        @RunWith(JUnit3RunnerWithInners.class)
-        public static class FunInterface extends AbstractIrBlackBoxCodegenTest {
-            private void runTest(String testDataFilePath) throws Exception {
-                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
-            }
-
-            public void testAllFilesPresentInFunInterface() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/funInterface"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM_IR, true);
-            }
-
-            @TestMetadata("basicFunInterface.kt")
-            public void testBasicFunInterface() throws Exception {
-                runTest("compiler/testData/codegen/box/inlineClasses/funInterface/basicFunInterface.kt");
-            }
-
-            @TestMetadata("basicFunInterfaceConversion.kt")
-            public void testBasicFunInterfaceConversion() throws Exception {
-                runTest("compiler/testData/codegen/box/inlineClasses/funInterface/basicFunInterfaceConversion.kt");
-            }
-        }
-
        @TestMetadata("compiler/testData/codegen/box/inlineClasses/functionNameMangling")
        @TestDataPath("$PROJECT_ROOT")
        @RunWith(JUnit3RunnerWithInners.class)