Improve ReasonLIGO output.

src/passes/01-parser/reasonligo/Pretty.ml

@@ -174,13 +174,13 @@ and pp_clause {value; _} =
 and pp_cond_expr {value; _} =
   let {test; ifso; kwd_else; ifnot; _} = value in
   let if_then =
-    string "if" ^^ string "(" ^^ pp_expr test ^^ string ")" ^^ string " {" ^^ hardline 
+    string "if" ^^ string "(" ^^ pp_expr test ^^ string ")" ^^ string " {" ^^ break 0 
     ^^ group (nest 2 (break 2 ^^ pp_expr ifso)) ^^ hardline ^^ string "}" in
   if kwd_else#is_ghost then
     if_then
   else
     if_then
-    ^^ string " else" ^^ string " {" ^^ hardline ^^ group (nest 2 (break 2 ^^ pp_expr ifnot)) ^^ hardline ^^ string "}"
+    ^^ string " else" ^^ string " {" ^^ break 0 ^^ group (nest 2 (break 2 ^^ pp_expr ifnot)) ^^ hardline ^^ string "}"
 
 and pp_annot_expr {value; _} =
   let expr, _, type_expr = value.inside in
@@ -201,7 +201,7 @@ and pp_bool_expr = function
 and pp_bin_op op {value; _} =
   let {arg1; arg2; _} = value
   and length = String.length op + 1 in
-  pp_expr arg1 ^/^ string (op ^ " ") ^^ nest length (pp_expr arg2)
+  pp_expr arg1 ^^ string " " ^^ string (op ^ " ") ^^ nest length (pp_expr arg2)
 
 and pp_un_op op {value; _} =
   string (op ^ " ") ^^ pp_expr value.arg
@@ -372,8 +372,11 @@ and pp_fun {value; _} =
       None -> empty
     | Some (_,e) ->
         group (break 0 ^^ string ":" ^^ nest 2 (break 1 ^^ pp_type_expr e))
-  in prefix 2 0 (string "(" ^^ binders ^^ string ")" ^^ annot
+  in 
-     ^^ string " => ") (pp_expr body)
+  match body with 
+  | ESeq _ -> string "(" ^^ binders ^^ string ")" ^^ annot ^^ string " => " ^^ pp_expr body
+  | _ -> (prefix 2 0 (string "(" ^^ binders ^^ string ")" ^^ annot
+     ^^ string " => ") (pp_expr body))
 
 and pp_seq {value; _} =
   let {compound; elements; _} = value in

src/test/contracts/expected/address.religo.expected

@@ -1,6 +1,5 @@
 let main = 
-  (p: key_hash): address => 
+  (p: key_hash): address => {
-    {
     let c: contract(unit) = Tezos.implicit_account(p);
     Tezos.address(c)
   };

src/test/contracts/expected/amount.religo.expected

@@ -1,7 +1,6 @@
 let check_ = 
   (p: unit): int => 
-    if(Tezos.amount
+    if(Tezos.amount == 100000000mutez) {
-    == 100000000mutez) {
       42
     } else {
       0

src/test/contracts/expected/bytes_unpack.religo.expected

@@ -1,20 +1,17 @@
 let id_string = 
-  (p: string): option(string) => 
+  (p: string): option(string) => {
-    {
     let packed: bytes = Bytes.pack(p);
     ((Bytes.unpack(packed)) : option(string))
   };
 
 let id_int = 
-  (p: int): option(int) => 
+  (p: int): option(int) => {
-    {
     let packed: bytes = Bytes.pack(p);
     ((Bytes.unpack(packed)) : option(int))
   };
 
 let id_address = 
-  (p: address): option(address) => 
+  (p: address): option(address) => {
-    {
     let packed: bytes = Bytes.pack(p);
     ((Bytes.unpack(packed)) : option(address))
   };

src/test/contracts/expected/check_signature.religo.expected

@@ -1,6 +1,5 @@
 let check_signature = 
-  (param: (key, signature, bytes)): bool => 
+  (param: (key, signature, bytes)): bool => {
-    {
     let (pk, signed, msg) = param;
     Crypto.check(pk, signed, msg)
   };

src/test/contracts/expected/closure.religo.expected

@@ -1,6 +1,5 @@
 let test = 
-  (k: int): int => 
+  (k: int): int => {
-    {
     let j: int = k + 5;
     let close: (int => int) = (i: int) => i + j;
     let j: int = 20;

src/test/contracts/expected/condition-shadowing.religo.expected

@@ -1,9 +1,7 @@
 let main = 
-  (i: int) => 
+  (i: int) => {
-    {
     let result = 0;
-      if(i
+    if(i == 2) {
-      == 2) {
     
       let result = 42;
       result

src/test/contracts/expected/condition.religo.expected

@@ -1,7 +1,6 @@
 let main = 
   (i: int) => 
-    if(i
+    if(i == 2) {
-    == 2) {
       42
     } else {
       0

src/test/contracts/expected/eq_bool.religo.expected

@@ -1,7 +1,6 @@
 let main = 
   ((a, b): (bool, bool)) => 
-    if(a
+    if(a == b) {
-    == b) {
       999
     } else {
       1

src/test/contracts/expected/high-order.religo.expected

@@ -1,6 +1,5 @@
 let foobar = 
-  (i: int): int => 
+  (i: int): int => {
-    {
     let foo: int => int = (i: int) => i;
     let bar: ((int => int) => int) = 
       (f: (int => int)) => f(i);
@@ -8,15 +7,13 @@ let foobar =
   };
 
 let higher2 = 
-  (i: int, f: (int => int)): int => 
+  (i: int, f: (int => int)): int => {
-    {
     let ii: int = f(i);
     ii
   };
 
 let foobar2 = 
-  (i: int): int => 
+  (i: int): int => {
-    {
     let foo2: int => int = (i: int) => i;
     higher2(i, foo2)
   };
@@ -24,8 +21,7 @@ let foobar2 =
 let a: int = 0;
 
 let foobar3 = 
-  (i: int): int => 
+  (i: int): int => {
-    {
     let foo2: int => int = (i: int) => a + i;
     higher2(i, foo2)
   };
@@ -37,15 +33,13 @@ let g = (i: int): int => f(i);
 let foobar4 = (i: int): int => g(g(i));
 
 let higher3 = 
-  (i: int, f: (int => int), g: (int => int)): int => 
+  (i: int, f: (int => int), g: (int => int)): int => {
-    {
     let ii: int = f(g(i));
     ii
   };
 
 let foobar5 = 
-  (i: int): int => 
+  (i: int): int => {
-    {
     let a: int = 0;
     let foo: int => int = (i: int) => a + i;
     let goo: int => int = (i: int) => foo(i);

src/test/contracts/expected/key_hash.religo.expected

@@ -1,8 +1,6 @@
 let check_hash_key = 
-  (kh1_k2: (key_hash, key)): (bool, key_hash) => 
+  (kh1_k2: (key_hash, key)): (bool, key_hash) => {
-    {
     let (kh1, k2) = kh1_k2;
     let kh2: key_hash = Crypto.hash_key(k2);
-      ((kh1
+    ((kh1 == kh2), kh2)
-       == kh2), kh2)
   };

src/test/contracts/expected/letin.religo.expected

@@ -1,8 +1,7 @@
 type storage = (int, int);
 
 let main = 
-  (n: (int, storage)): (list(operation), storage) => 
+  (n: (int, storage)): (list(operation), storage) => {
-    {
     let x: (int, int) = 
       {
         let x: int = 7;
@@ -18,8 +17,7 @@ let f1 = (a: string) => true;
 let f2 = (a: string) => true;
 
 let letin_nesting = 
-  (_: unit) => 
+  (_: unit) => {
-    {
     let s = "test";
     let p0 = f0(s);
     assert(p0);
@@ -31,8 +29,7 @@ let letin_nesting =
   };
 
 let letin_nesting2 = 
-  (x: int) => 
+  (x: int) => {
-    {
     let y = 2;
     let z = 3;
     x + y + z

src/test/contracts/expected/list.religo.expected

@@ -11,8 +11,7 @@ let y: list(int) = [3, 4, 5];
 let z: list(int) = [2, ...y];
 
 let main = 
-  ((action, s): (parameter, storage)): return => 
+  ((action, s): (parameter, storage)): return => {
-    {
     let storage = 
       switch(action) {
       | [] => s
@@ -24,8 +23,7 @@ let main =
 let size_ = (s: list(int)): nat => List.length(s);
 
 let fold_op = 
-  (s: list(int)): int => 
+  (s: list(int)): int => {
-    {
     let aggregate = (t: (int, int)) => t[0] + t[1];
     List.fold(aggregate, s, 10)
   };
@@ -35,8 +33,7 @@ let map_op =
     List.map((cur: int) => cur + 1, s);
 
 let iter_op = 
-  (s: list(int)): unit => 
+  (s: list(int)): unit => {
-    {
     let do_nothing = (useless: int) => unit;
     List.iter(do_nothing, s)
   };

src/test/contracts/expected/loop.religo.expected

@@ -1,7 +1,6 @@
 let rec aux_simple = 
   (i: int): int => 
-    if(i
+    if(i < 100) {
-    < 100) {
       aux_simple(i + 1)
     } else {
       i
@@ -12,13 +11,11 @@ let counter_simple = (n: int): int => aux_simple(n);
 type sum_aggregator = {counter: int, sum: int };
 
 let counter = 
-  (n: int): int => 
+  (n: int): int => {
-    {
     let initial: sum_aggregator = {counter: 0, sum: 0 };
     let rec aggregate = 
       (prev: sum_aggregator): int => 
-          if(prev.counter
+        if(prev.counter <= n) {
-          <= n) {
         
           
           aggregate({
@@ -33,8 +30,7 @@ let counter =
 
 let rec aux_nest = 
   (prev: sum_aggregator): sum_aggregator => 
-    if(prev.counter
+    if(prev.counter < 100) {
-    < 100) {
     
       let sum: int = prev.sum + aux_simple(prev.counter);
       aux_nest({counter: prev.counter + 1, sum: sum })
@@ -43,8 +39,7 @@ let rec aux_nest =
     };
 
 let counter_nest = 
-  (n: int): int => 
+  (n: int): int => {
-    {
     let initial: sum_aggregator = {counter: 0, sum: 0 };
     let out: sum_aggregator = aux_nest(initial);
     out.sum

src/test/contracts/expected/map.religo.expected

@@ -40,30 +40,26 @@ let get_ = (m: foobar): option(int) => Map.find_opt(42, m);
 let mem = (km: (int, foobar)): bool => Map.mem(km[0], km[1]);
 
 let iter_op = 
-  (m: foobar): unit => 
+  (m: foobar): unit => {
-    {
     let assert_eq = (i: int, j: int) => assert(i == j);
     Map.iter(assert_eq, m)
   };
 
 let map_op = 
-  (m: foobar): foobar => 
+  (m: foobar): foobar => {
-    {
     let increment = (z: int, j: int) => j + 1;
     Map.map(increment, m)
   };
 
 let fold_op = 
-  (m: foobar): foobar => 
+  (m: foobar): foobar => {
-    {
     let aggregate = 
       (i: int, j: (int, int)) => i + j[0] + j[1];
     Map.fold(aggregate, m, 10)
   };
 
 let deep_op = 
-  (m: foobar): foobar => 
+  (m: foobar): foobar => {
-    {
     let coco = (0, m);
     let coco = (0, Map.remove(42, coco[1]));
     let coco = (0, Map.update(32, Some (16), coco[1]));

src/test/contracts/expected/match.religo.expected

@@ -5,11 +5,9 @@ type parameter = Add(int) | Sub(int);
 type return = (list(operation), storage);
 
 let main = 
-  ((action, store): (parameter, storage)) => 
+  ((action, store): (parameter, storage)) => {
-    {
     let store = 
-        store
+      store + (switch(action) {
-        + (switch(action) {
          | Add(n) => n
          | Sub(n) => -n
          });

src/test/contracts/expected/match_bis.religo.expected

@@ -7,8 +7,7 @@ let add = ((a: int), (b: int)) => a + b;
 let sub = ((a: int), (b: int)) => a - b;
 
 let main = 
-  ((action, store): (parameter, storage)) => 
+  ((action, store): (parameter, storage)) => {
-    {
     let store = 
       switch(action) {
       | Increment(n) => add(store, n)

src/test/contracts/expected/michelson_pair_tree.religo.expected

@@ -6,8 +6,7 @@ type storage = michelson_pair
 type return = (list(operation), storage);
 
 let main = 
-  ((action, store): (unit, storage)): return => 
+  ((action, store): (unit, storage)): return => {
-    {
     let foo = (3, (1, 2n));
     (([] : list(operation)), (foo : storage))
   };

src/test/contracts/expected/multisig.religo.expected

@@ -30,33 +30,28 @@ type return = (list(operation), storage);
 type parameter = CheckMessage(check_message_pt);
 
 let check_message = 
-  ((param, s): (check_message_pt, storage)): return => 
+  ((param, s): (check_message_pt, storage)): return => {
-    {
     let message: message = param.message;
     let s = 
-        if(param.counter
+      if(param.counter != s.counter) {
-        != s.counter) {
         (failwith("Counters does not match") : storage)
       } else {
       
         let packed_payload: bytes = 
           
-            Bytes.pack((message, param.counter, s.id,
+          Bytes.pack((message, param.counter, s.id, chain_id));
-              chain_id));
         let valid: nat = 0n;
         let keys: authorized_keys = s.auth;
         let aux = 
           ((vk, pkh_sig):
            ((nat, authorized_keys), (key_hash, signature)))
           :
-              (nat, authorized_keys) => 
+            (nat, authorized_keys) => {
-              {
             let (valid, keys) = vk;
             switch(keys) {
             | [] => vk
             | [key, ...keys] =>
-                    if(pkh_sig[0]
+                if(pkh_sig[0] == Crypto.hash_key(key)) {
-                    == Crypto.hash_key(key)) {
                 
                   let valid = 
                     if(
@@ -65,9 +60,7 @@ let check_message =
                        packed_payload)) {
                       valid + 1n
                     } else {
-                        
+                      (failwith("Invalid signature") : nat)
-                          (failwith("Invalid signature")
-                            : nat)
                     };
                   (valid, keys)
                 } else {
@@ -77,8 +70,7 @@ let check_message =
           };
         let (valid, keys) = 
           List.fold(aux, param.signatures, (valid, keys));
-          if(valid
+        if(valid < s.threshold) {
-          < s.threshold) {
         
           (
             failwith("Not enough signatures passed the check")

src/test/contracts/expected/no_semicolon.religo.expected

@@ -1,10 +1,8 @@
 type f = int;
 
 let a = 
-  (b: f) => 
+  (b: f) => {
-    {
+    if(b == 2) {
-      if(b
-      == 2) {
       3
     } else {
       4
@@ -12,7 +10,6 @@ let a =
   };
 
 let c = 
-  (c: f) => 
+  (c: f) => {
-    {
     3
   };

src/test/contracts/expected/pledge.religo.expected

@@ -5,18 +5,15 @@ type parameter =
 | Distribute((unit => list(operation)));
 
 let donate = 
-  ((p, s): (unit, storage)): (list(operation), storage) => 
+  ((p, s): (unit, storage)): (list(operation), storage) => {
-    {
     (([] : list(operation)), s)
   };
 
 let distribute = 
   ((p, s): ((unit => list(operation)), storage))
   :
-    (list(operation), storage) => 
+    (list(operation), storage) => {
-    {
+    if(Tezos.sender == s) {
-      if(Tezos.sender
-      == s) {
       (p(()), s)
     } else {
     
@@ -27,8 +24,7 @@ let distribute =
   };
 
 let main = 
-  ((p, s): (parameter, storage)): (list(operation), storage) => 
+  ((p, s): (parameter, storage)): (list(operation), storage) => {
-    {
     switch(p) {
     | Donate => donate(((), s))
     | Distribute msg => distribute((msg, s))

src/test/contracts/expected/recursion.religo.expected

@@ -1,7 +1,6 @@
 let rec sum = 
   ((n, acc): (int, int)): int => 
-    if(n
+    if(n < 1) {
-    < 1) {
       acc
     } else {
       sum((n - 1, acc + n))
@@ -9,8 +8,7 @@ let rec sum =
 
 let rec fibo = 
   ((n, n_1, n_0): (int, int, int)): int => 
-    if(n
+    if(n < 2) {
-    < 2) {
       n_1
     } else {
       fibo((n - 1, n_1 + n_0, n_1))

src/test/contracts/expected/set_delegate.religo.expected

@@ -1,6 +1,5 @@
 let main = 
-  (p: key_hash): list(operation) => 
+  (p: key_hash): list(operation) => {
-    {
     let unused: operation = (Tezos.set_delegate(Some (p)));
     ([] : list(operation))
   };

src/test/contracts/expected/super-counter.religo.expected

@@ -5,8 +5,7 @@ type storage = int;
 type return = (list(operation), storage);
 
 let main = 
-  ((action, store): (parameter, storage)): return => 
+  ((action, store): (parameter, storage)): return => {
-    {
     let store = 
       switch(action) {
       | Increment(n) => store + n

src/test/contracts/expected/tuple_type.religo.expected

@@ -1,8 +1,7 @@
 type fun_type = (int, int) => int;
 
 let arguments = 
-  (b: int, c: int) => 
+  (b: int, c: int) => {
-    {
     b + c
   };
 
@@ -14,8 +13,7 @@ let arguments_test =
 type tuple_type = ((int, int)) => int;
 
 let tuple = 
-  ((a, b): (int, int)) => 
+  ((a, b): (int, int)) => {
-    {
     a + b
   };
 
@@ -24,8 +22,7 @@ let tuple_type_def = (b: tuple_type) => b((5, 3));
 let tuple_test = (_: int) => tuple_type_def(tuple);
 
 let arguments_inline = 
-  (b: int, c: int) => 
+  (b: int, c: int) => {
-    {
     b + c
   };
 
@@ -36,8 +33,7 @@ let arguments_test_inline =
   (_: int) => arguments_type_def_inline(arguments_inline);
 
 let tuple_inline = 
-  ((a, b): (int, int)) => 
+  ((a, b): (int, int)) => {
-    {
     a + b
   };
 

src/test/contracts/expected/tuples_no_annotation.religo.expected

@@ -3,7 +3,6 @@ type storage = (int, string, nat, bool);
 type parameter = int;
 
 let main = 
-  ((p, storage): (parameter, storage)) => 
+  ((p, storage): (parameter, storage)) => {
-    {
     ([] : list(operation), (2, "2", 2n, false))
   };

src/test/contracts/expected/website2.religo.expected

@@ -7,8 +7,7 @@ let add = ((a, b): (int, int)): int => a + b;
 let sub = ((a, b): (int, int)): int => a - b;
 
 let main = 
-  ((p, storage): (parameter, storage)) => 
+  ((p, storage): (parameter, storage)) => {
-    {
     let storage = 
       switch(p) {
       | Increment(n) => add((storage, n))