Fix tests

src/aeso_aci.erl

@@ -115,7 +115,7 @@ encode_contract(Namespace = {namespace, _, {con, _, Name}, _}) ->
 
 %%  Encode a function definition. Currently we are only interested in
 %%  the interface and type.
-encode_function(FDef = {letfun, _, {id, _, Name}, Args, Type, _}) ->
+encode_function(FDef = {letfun, _, {id, _, Name}, Args, Type, _, _}) ->
     #{name      => encode_name(Name),
       arguments => encode_args(Args),
       returns   => encode_type(Type),
@@ -347,9 +347,9 @@ contract_funcs({C, _, _, Decls}) when ?IS_CONTRACT_HEAD(C); C == namespace ->
 contract_types({C, _, _, Decls}) when ?IS_CONTRACT_HEAD(C); C == namespace ->
     [ D || D <- Decls, is_type(D) ].
 
-is_fun({letfun, _, _, _, _, _}) -> true;
+is_fun({letfun, _, _, _, _, _, _}) -> true;
-is_fun({fun_decl, _, _, _})     -> true;
+is_fun({fun_decl, _, _, _})        -> true;
-is_fun(_)                       -> false.
+is_fun(_)                          -> false.
 
 is_type({type_def, _, _, _, _}) -> true;
 is_type(_)                      -> false.

src/aeso_ast_infer_types.erl

@@ -285,7 +285,7 @@ bind_contract({Contract, Ann, Id, Contents}, Env)
            contract_call_type(
              {fun_t, AnnF, [], [ArgT || {typed, _, _, ArgT} <- Args], RetT})
           }
-          || {letfun, AnnF, Entrypoint = {id, _, Name}, Args, _Type, {typed, _, _, RetT}} <- Contents,
+          || {letfun, AnnF, Entrypoint = {id, _, Name}, Args, _Type, [], [{typed, _, _, RetT}]} <- Contents,
              Name =/= "init"
         ] ++
         %% Predefined fields
@@ -293,7 +293,7 @@ bind_contract({Contract, Ann, Id, Contents}, Env)
         [ {field_t, Sys, {id, Sys, ?CONSTRUCTOR_MOCK_NAME},
            contract_call_type(
              case [ [ArgT || {typed, _, _, ArgT} <- Args]
-                    || {letfun, AnnF, {id, _, "init"}, Args, _, _} <- Contents,
+                    || {letfun, AnnF, {id, _, "init"}, Args, _, _, _} <- Contents,
                        aeso_syntax:get_ann(entrypoint, AnnF, false)]
                  ++ [ Args
                       || {fun_decl, AnnF, {id, _, "init"}, {fun_t, _, _, Args, _}} <- Contents,
@@ -1376,9 +1376,7 @@ desugar_clauses(Ann, Fun, {type_sig, _, _, _, ArgTypes, RetType}, Clauses) ->
             _                             -> true
         end,
     case NeedDesugar of
-        false ->
+        false -> [Clause] = Clauses, Clause;
-            [{letfun, AnnF, FunF, Args, RetTypeF, [], [Expr]}] = Clauses,
-            {letfun, AnnF, FunF, Args, RetTypeF, Expr};
         true  ->
             NoAnn = [{origin, system}],
             Args = [ {typed, NoAnn, {id, NoAnn, "x#" ++ integer_to_list(I)}, Type}
@@ -1386,11 +1384,11 @@ desugar_clauses(Ann, Fun, {type_sig, _, _, _, ArgTypes, RetType}, Clauses) ->
             Tuple = fun([X]) -> X;
                        (As) -> {typed, NoAnn, {tuple, NoAnn, As}, {tuple_t, NoAnn, ArgTypes}}
                     end,
-            {letfun, Ann, Fun, Args, RetType,
+            {letfun, Ann, Fun, Args, RetType, [],
-             {typed, NoAnn,
+             [{typed, NoAnn,
-              {switch, NoAnn, Tuple(Args),
+               {switch, NoAnn, Tuple(Args),
-                [ {'case', AnnC, Tuple(ArgsC), Guards, Bodies}
+                 [ {'case', AnnC, Tuple(ArgsC), Guards, Bodies}
-                || {letfun, AnnC, _, ArgsC, _, Guards, Bodies} <- Clauses ]}, RetType}}
+                 || {letfun, AnnC, _, ArgsC, _, Guards, Bodies} <- Clauses ]}, RetType}]}
     end.
 
 print_typesig({Name, TypeSig}) ->
@@ -1458,7 +1456,7 @@ check_state_dependencies(Env, Defs) ->
     SetState  = Top ++ ["put"],
     Init      = Top ++ ["init"],
     UsedNames = fun(X) -> [{Xs, Ann} || {{term, Xs}, Ann} <- aeso_syntax_utils:used(X)] end,
-    Funs      = [ {Top ++ [Name], Fun} || Fun = {letfun, _, {id, _, Name}, _Args, _Type, _Body} <- Defs ],
+    Funs      = [ {Top ++ [Name], Fun} || Fun = {letfun, _, {id, _, Name}, _Args, _Type, [], _Bodies} <- Defs ],
     Deps      = maps:from_list([{Name, UsedNames(Def)} || {Name, Def} <- Funs]),
     case maps:get(Init, Deps, false) of
         false -> ok;    %% No init, so nothing to check
@@ -2435,8 +2433,8 @@ unfold_types(Env, {type_def, Ann, Name, Args, Def}, Options) ->
     {type_def, Ann, Name, Args, unfold_types_in_type(Env, Def, Options)};
 unfold_types(Env, {fun_decl, Ann, Name, Type}, Options) ->
     {fun_decl, Ann, Name, unfold_types(Env, Type, Options)};
-unfold_types(Env, {letfun, Ann, Name, Args, Type, Body}, Options) ->
+unfold_types(Env, {letfun, Ann, Name, Args, Type, [], [Body]}, Options) ->
-    {letfun, Ann, Name, unfold_types(Env, Args, Options), unfold_types_in_type(Env, Type, Options), unfold_types(Env, Body, Options)};
+    {letfun, Ann, Name, unfold_types(Env, Args, Options), unfold_types_in_type(Env, Type, Options), [], [unfold_types(Env, Body, Options)]};
 unfold_types(Env, T, Options) when is_tuple(T) ->
     list_to_tuple(unfold_types(Env, tuple_to_list(T), Options));
 unfold_types(Env, [H|T], Options) ->

src/aeso_ast_to_fcode.erl

@@ -385,7 +385,7 @@ decl_to_fcode(Env = #{context := {contract_def, _}}, {fun_decl, _, Id, _}) ->
 decl_to_fcode(Env, {fun_decl, _, _, _})  -> Env;
 decl_to_fcode(Env, {type_def, _Ann, Name, Args, Def}) ->
     typedef_to_fcode(Env, Name, Args, Def);
-decl_to_fcode(Env = #{ functions := Funs }, {letfun, Ann, Id = {id, _, Name}, Args, Ret, Body}) ->
+decl_to_fcode(Env = #{ functions := Funs }, {letfun, Ann, Id = {id, _, Name}, Args, Ret, [], [Body]}) ->
     Attrs = get_attributes(Ann),
     FName = lookup_fun(Env, qname(Env, Name)),
     FArgs = args_to_fcode(Env, Args),
@@ -673,7 +673,7 @@ expr_to_fcode(Env, Type, {list_comp, As, Yield, [{comprehension_if, _, Cond}|Res
            );
 expr_to_fcode(Env, Type, {list_comp, As, Yield, [LV = {letval, _, _, _}|Rest]}) ->
     expr_to_fcode(Env, Type, {block, As, [LV, {list_comp, As, Yield, Rest}]});
-expr_to_fcode(Env, Type, {list_comp, As, Yield, [LF = {letfun, _, _, _, _, _}|Rest]}) ->
+expr_to_fcode(Env, Type, {list_comp, As, Yield, [LF = {letfun, _, _, _, _, _, _}|Rest]}) ->
     expr_to_fcode(Env, Type, {block, As, [LF, {list_comp, As, Yield, Rest}]});
 
 %% Conditionals
@@ -1111,7 +1111,7 @@ stmts_to_fcode(Env, [{letval, _, {typed, _, {id, _, X}, _}, Expr} | Stmts]) ->
     {'let', X, expr_to_fcode(Env, Expr), stmts_to_fcode(bind_var(Env, X), Stmts)};
 stmts_to_fcode(Env, [{letval, Ann, Pat, Expr} | Stmts]) ->
     expr_to_fcode(Env, {switch, Ann, Expr, [{'case', Ann, Pat, [], [{block, Ann, Stmts}]}]});
-stmts_to_fcode(Env, [{letfun, Ann, {id, _, X}, Args, _Type, Expr} | Stmts]) ->
+stmts_to_fcode(Env, [{letfun, Ann, {id, _, X}, Args, _Type, [], [Expr]} | Stmts]) ->
     LamArgs = [ case Arg of
                     {typed, Ann1, Id, T} -> {arg, Ann1, Id, T};
                     _ -> internal_error({bad_arg, Arg})   %% pattern matching has been desugared
@@ -1706,7 +1706,7 @@ add_child_con(Env = #{child_con_env := CEnv}, Name, Fcode) ->
 -spec add_fun_env(env(), [aeso_syntax:decl()]) -> env().
 add_fun_env(Env = #{ context := {abstract_contract, _} }, _) -> Env;  %% no functions from abstract contracts
 add_fun_env(Env = #{ fun_env := FunEnv }, Decls) ->
-    Entry = fun({letfun, Ann, {id, _, Name}, Args, _, _}) ->
+    Entry = fun({letfun, Ann, {id, _, Name}, Args, _, _, _}) ->
                 [{qname(Env, Name), {make_fun_name(Env, Ann, Name), length(Args)}}];
                ({fun_decl, Ann, {id, _, Name}, {fun_t, _, _, ArgTypes, _}}) ->
                 [{qname(Env, Name), {make_fun_name(Env, Ann, Name), length(ArgTypes)}}];

src/aeso_compiler.erl

@@ -474,10 +474,10 @@ error_missing_call_function() ->
 
 get_call_type([{Contract, _, _, Defs}]) when ?IS_CONTRACT_HEAD(Contract) ->
     case [ {lists:last(QFunName), FunType}
-          || {letfun, _, {id, _, ?CALL_NAME}, [], _Ret,
+          || {letfun, _, {id, _, ?CALL_NAME}, [], _Ret, [],
-                {typed, _,
+                [{typed, _,
-                    {app, _,
+                     {app, _,
-                        {typed, _, {qid, _, QFunName}, FunType}, _}, _}} <- Defs ] of
+                         {typed, _, {qid, _, QFunName}, FunType}, _}, _}]} <- Defs ] of
         [Call] -> {ok, Call};
         []     -> error_missing_call_function()
     end;
@@ -487,7 +487,7 @@ get_call_type([_ | Contracts]) ->
 
 -dialyzer({nowarn_function, get_decode_type/2}).
 get_decode_type(FunName, [{Contract, Ann, _, Defs}]) when ?IS_CONTRACT_HEAD(Contract) ->
-    GetType = fun({letfun, _, {id, _, Name}, Args, Ret, _})               when Name == FunName -> [{Args, Ret}];
+    GetType = fun({letfun, _, {id, _, Name}, Args, Ret, _, _})            when Name == FunName -> [{Args, Ret}];
                  ({fun_decl, _, {id, _, Name}, {fun_t, _, _, Args, Ret}}) when Name == FunName -> [{Args, Ret}];
                  (_) -> [] end,
     case lists:flatmap(GetType, Defs) of

src/aeso_syntax_utils.erl

@@ -48,7 +48,6 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
             {type_def, _, I, _, D}        -> Plus(BindType(I), Decl(D));
             {fun_decl, _, _, T}           -> Type(T);
             {letval, _, P, E}             -> Scoped(BindExpr(P), Expr(E));
-            {letfun, _, F, Xs, T, E}      -> Sum([BindExpr(F), Type(T), Expr(Xs ++ [E])]);
             {letfun, _, F, Xs, T, Gs, Es} -> Sum([BindExpr(F), Type(T), Expr(Xs ++ Gs ++ Es)]);
             {fun_clauses, _, _, T, Cs}    -> Sum([Type(T) | [Decl(C) || C <- Cs]]);
             %% typedef()

test/aeso_calldata_tests.erl

@@ -59,7 +59,7 @@ calldata_aci_test_() ->
         end} || {ContractName, Fun, Args} <- compilable_contracts()].
 
 parse_args(Fun, Args) ->
-    [{contract_main, _, _, [{letfun, _, _, _, _, {app, _, _, AST}}]}] =
+    [{contract_main, _, _, [{letfun, _, _, _, _, _, [{app, _, _, AST}]}]}] =
         aeso_parser:string("main contract Temp = function foo() = " ++ Fun ++ "(" ++ string:join(Args, ", ") ++ ")"),
     strip_ann(AST).
 

test/aeso_parser_tests.erl

@@ -16,8 +16,8 @@ simple_contracts_test_() ->
                    "  function id(x) = x\n",
             ?assertMatch(
                 [{contract_main, _, {con, _, "Identity"},
-                    [{letfun, _, {id, _, "id"}, [{id, _, "x"}], {id, _, "_"},
+                    [{letfun, _, {id, _, "id"}, [{id, _, "x"}], {id, _, "_"}, [],
-                        {id, _, "x"}}]}], parse_string(Text)),
+                        [{id, _, "x"}]}]}], parse_string(Text)),
             ok
        end},
       {"Operator precedence test.",