Works also when the function parameter are passed in the rhs

Fix some religo contract

src/passes/2-simplify/cameligo.ml

@@ -812,10 +812,8 @@ and simpl_declaration : Raw.declaration -> declaration Location.wrap list result
         ok (var , tl)
       in
       let%bind lhs_type' = bind_map_option (fun x -> simpl_type_expression (snd x)) lhs_type in
-      match args with
-      | [] ->
-          let%bind rhs' = simpl_expression let_rhs in
-          ok @@ [loc x @@ (Declaration_constant (Var.of_name var.value , lhs_type' , inline, rhs'))]
+      let let_rhs = match args with
+      | [] -> let_rhs
       | param1::others ->
           let fun_ = {
             kwd_fun = Region.ghost;
@@ -824,9 +822,15 @@ and simpl_declaration : Raw.declaration -> declaration Location.wrap list result
             arrow   = Region.ghost;
             body    = let_rhs
           } in
-          let rhs = Raw.EFun {region=Region.ghost ; value=fun_} in
-          let%bind rhs' = simpl_expression rhs in
-          let%bind ty = bind_map_list typed_pattern_to_typed_vars args in
+          Raw.EFun {region=Region.ghost ; value=fun_} 
+      in
+      let f_args = (match let_rhs with 
+      | Raw.EFun f -> nseq_to_list f.value.binders
+      | _ -> []
+      )
+      in
+      let%bind rhs' = simpl_expression let_rhs in
+      let%bind ty = bind_map_list typed_pattern_to_typed_vars f_args in
       let aux acc ty = Option.map (t_function (snd ty)) acc in
       let func_type = List.fold_right' aux lhs_type' ty in
       ok @@ [loc x @@ (Declaration_constant (Var.of_name var.value , func_type , inline, rhs'))]

src/test/contracts/balance_constant.religo

@@ -12,6 +12,6 @@ generated. unrecognized constant: {"constant":"BALANCE","location":"generated"}
 
 type storage = tez;
 
-let main2 = (p: unit, storage) => ([]: list(operation), balance);
+let main2 = (p: unit, s: storage) => ([]: list(operation), balance);
 
 let main = (x: (unit, storage)) => main2(x[0],x[1]);

src/test/contracts/counter.religo

@@ -1,7 +1,6 @@
 
 type storage = int;
 
-let main2 = (p: int, storage): string => ([]: list(operation), p + storage);
+let main2 = (p: int, s: storage): string => ([]: list(operation), p + s);
 
 let main = (x: (int, storage)) : string => main2(x[0],x[1]);
-

src/test/contracts/lambda.religo

@@ -5,6 +5,6 @@ type storage = unit;
      (fun x -> ()) ()
    */
 
-let main2 = ((p: unit), storage) => (((xxx: unit)) => ())();
+let main2 = ((p: unit), s: storage) => (((xxx: unit)) => ())();
 
 let main = (x: (unit, storage)) => main2(x[0], x[1]);

src/test/contracts/lambda2.religo

@@ -4,7 +4,7 @@ type storage = unit;
    let main (p:unit) storage = (fun x -> ()) ()
    */
 
-let main2 = (z: unit, storage) =>
+let main2 = (z: unit, s: storage) =>
   ((f: (unit => unit)) => f())((z: unit) => unit);
 
 let main = (x: (unit, storage)) => main2(x[0],x[1]);

src/test/contracts/letin.religo

@@ -1,9 +1,9 @@
 type storage = (int, int);
 
-let main2 = ((n : int), storage) => {
+let main2 = ((n : int), s: storage) => {
   let x: (int, int) = {
     let x: int = 7;
-    (x + n, storage[0] + storage[1]);
+    (x + n, s[0] + s[1]);
   };
   ([]: list(operation), x);
 };

src/test/contracts/list.religo

@@ -6,7 +6,7 @@ let x: list(int) = [];
 let y: list(int) = [3, 4, 5];
 let z: list(int) = [2, ...y];
 
-let main2 = (p: param, storage) => {
+let main2 = (p: param, storage : storage) => {
   let storage =
     switch (p) {
     | [] => storage

src/test/contracts/match.religo

@@ -4,9 +4,9 @@ type param =
   | Add(int)
   | Sub(int);
 
-let main2 = ((p: param), storage) => {
+let main2 = ((p: param), s: storage) => {
   let storage =
-    storage
+    s
     + (
       switch (p) {
       | Add(n) => n

src/test/contracts/match_bis.religo

@@ -12,7 +12,7 @@ let subtract = ((a: int), (b: int)) => a - b;
 
 /* real entrypoint that re-routes the flow based on the action provided */
 
-let main2 = ((p: action), storage) => {
+let main2 = ((p: action), storage : storage) => {
   let storage =
     switch (p) {
     | Increment(n) => add(storage, n)