add test

test/Main.hs

@@ -28,9 +28,9 @@ import Typecheck qualified
 
 slowTests :: IO TestTree
 slowTests =
-  sequentialTestGroup
+  testGroup
     "Juvix slow tests"
-    AllFinish
+    -- AllFinish
     <$> sequence
       [ return Runtime.allTests,
         return Reg.allTests,

test/Tree/Eval/Positive.hs

@@ -249,5 +249,10 @@ tests =
       "Test042: Uncurried function type unification"
       $(mkRelDir ".")
       $(mkRelFile "test042.jvt")
-      $(mkRelFile "out/test042.out")
+      $(mkRelFile "out/test042.out"),
+    PosTest
+      "Test043: Unary closure calls"
+      $(mkRelDir ".")
+      $(mkRelFile "test043.jvt")
+      $(mkRelFile "out/test043.out")
   ]

test/Tree/Transformation.hs

@@ -3,6 +3,7 @@ module Tree.Transformation where
 import Base
 import Tree.Transformation.Apply qualified as Apply
 import Tree.Transformation.CheckNoAnoma qualified as CheckNoAnoma
+import Tree.Transformation.ConvertUnaryCalls qualified as ConvertUnaryCalls
 import Tree.Transformation.IdentityTrans qualified as IdentityTrans
 import Tree.Transformation.Reachability qualified as Reachability
 
@@ -12,6 +13,7 @@ allTests =
     "JuvixTree transformations"
     [ IdentityTrans.allTests,
       Apply.allTests,
+      ConvertUnaryCalls.allTests,
       Reachability.allTests,
       CheckNoAnoma.allTests
     ]

test/Tree/Transformation/Apply.hs

@@ -15,7 +15,8 @@ allTests =
           [ "Test007: Higher-order functions",
             "Test022: Self-application",
             "Test025: Dynamic closure extension",
-            "Test032: Church numerals"
+            "Test032: Church numerals",
+            "Test043: Unary closure calls"
           ]
           Eval.tests
     )

test/Tree/Transformation/ConvertUnaryCalls.hs

@@ -0,0 +1,33 @@
+module Tree.Transformation.ConvertUnaryCalls (allTests) where
+
+import Base
+import Juvix.Compiler.Tree.Transformation
+import Tree.Eval.Positive qualified as Eval
+import Tree.Transformation.Base
+
+allTests :: TestTree
+allTests =
+  testGroup
+    "ConvertUnaryCalls"
+    ( map liftTest $
+        Eval.filterTests
+          [ "Test007: Higher-order functions",
+            "Test022: Self-application",
+            "Test025: Dynamic closure extension",
+            "Test032: Church numerals",
+            "Test043: Unary closure calls"
+          ]
+          Eval.tests
+    )
+
+pipe :: [TransformationId]
+pipe = [ConvertUnaryCalls]
+
+liftTest :: Eval.PosTest -> TestTree
+liftTest _testEval =
+  fromTest
+    Test
+      { _testTransformations = pipe,
+        _testAssertion = const (return ()),
+        _testEval
+      }

tests/Tree/positive/out/test043.out

@@ -0,0 +1 @@
+11

tests/Tree/positive/test043.jvt

@@ -0,0 +1,41 @@
+
+type List {
+  nil : List;
+  cons : (*, List) -> List;
+}
+
+function lambda_add(integer) : integer;
+function lambda_add2(integer, integer) : integer;
+function mapnat(integer -> integer, List) : List;
+function main() : List;
+
+function lambda_add(_X' : integer) : integer {
+  add(1, _X')
+}
+
+function lambda_add2(_X : integer, _Y : integer) : integer {
+  add(_X, _Y)
+}
+
+function mapnat(f : integer -> integer, _X : List) : List {
+  case[List](_X) {
+    nil: alloc[nil]()
+    cons: save {
+      alloc[cons](ccall(f, tmp[0].cons[0]), call[mapnat](f, tmp[0].cons[1]))
+    }
+  }
+}
+
+function mysum(f : (integer, integer) -> integer, _X : List) : integer {
+  case[List](_X) {
+    nil: 0
+    cons: save {
+      ccall(f, tmp[0].cons[0], call[mysum](f, tmp[0].cons[1]))
+    }
+  }
+}
+
+function main() : integer {
+  call[mysum](calloc[lambda_add2](), call[mapnat](calloc[lambda_add](), alloc[cons](1, alloc[cons](3, alloc[cons](4, alloc[nil]())))))
+  -- result: 11
+}