From 0d81af771e12efe802bd7a6ef8ef19accac11d9e Mon Sep 17 00:00:00 2001 From: Gaith Hallak Date: Mon, 4 Oct 2021 08:22:49 +0300 Subject: [PATCH] Fix tests --- src/aeso_aci.erl | 8 ++++---- src/aeso_ast_infer_types.erl | 24 +++++++++++------------- src/aeso_ast_to_fcode.erl | 8 ++++---- src/aeso_compiler.erl | 10 +++++----- src/aeso_syntax_utils.erl | 1 - test/aeso_calldata_tests.erl | 2 +- test/aeso_parser_tests.erl | 4 ++-- 7 files changed, 27 insertions(+), 30 deletions(-) diff --git a/src/aeso_aci.erl b/src/aeso_aci.erl index 0382593..ceac831 100644 --- a/src/aeso_aci.erl +++ b/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({fun_decl, _, _, _}) -> true; -is_fun(_) -> false. +is_fun({letfun, _, _, _, _, _, _}) -> true; +is_fun({fun_decl, _, _, _}) -> true; +is_fun(_) -> false. is_type({type_def, _, _, _, _}) -> true; is_type(_) -> false. diff --git a/src/aeso_ast_infer_types.erl b/src/aeso_ast_infer_types.erl index 96dc09f..bc9e87e 100644 --- a/src/aeso_ast_infer_types.erl +++ b/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 -> - [{letfun, AnnF, FunF, Args, RetTypeF, [], [Expr]}] = Clauses, - {letfun, AnnF, FunF, Args, RetTypeF, Expr}; + false -> [Clause] = Clauses, Clause; 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, - {typed, NoAnn, - {switch, NoAnn, Tuple(Args), - [ {'case', AnnC, Tuple(ArgsC), Guards, Bodies} - || {letfun, AnnC, _, ArgsC, _, Guards, Bodies} <- Clauses ]}, RetType}} + {letfun, Ann, Fun, Args, RetType, [], + [{typed, NoAnn, + {switch, NoAnn, Tuple(Args), + [ {'case', AnnC, Tuple(ArgsC), Guards, Bodies} + || {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) -> - {letfun, Ann, Name, unfold_types(Env, Args, Options), unfold_types_in_type(Env, Type, Options), unfold_types(Env, 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)]}; 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) -> diff --git a/src/aeso_ast_to_fcode.erl b/src/aeso_ast_to_fcode.erl index b486467..fa8ae0f 100644 --- a/src/aeso_ast_to_fcode.erl +++ b/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)}}]; diff --git a/src/aeso_compiler.erl b/src/aeso_compiler.erl index dad3faa..1f06759 100644 --- a/src/aeso_compiler.erl +++ b/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, - {typed, _, - {app, _, - {typed, _, {qid, _, QFunName}, FunType}, _}, _}} <- Defs ] of + || {letfun, _, {id, _, ?CALL_NAME}, [], _Ret, [], + [{typed, _, + {app, _, + {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 diff --git a/src/aeso_syntax_utils.erl b/src/aeso_syntax_utils.erl index 6f9c16c..a1f4b13 100644 --- a/src/aeso_syntax_utils.erl +++ b/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() diff --git a/test/aeso_calldata_tests.erl b/test/aeso_calldata_tests.erl index f10fc3e..fa96803 100644 --- a/test/aeso_calldata_tests.erl +++ b/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). diff --git a/test/aeso_parser_tests.erl b/test/aeso_parser_tests.erl index f8e2eee..4d16aea 100644 --- a/test/aeso_parser_tests.erl +++ b/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, _, "_"}, - {id, _, "x"}}]}], parse_string(Text)), + [{letfun, _, {id, _, "id"}, [{id, _, "x"}], {id, _, "_"}, [], + [{id, _, "x"}]}]}], parse_string(Text)), ok end}, {"Operator precedence test.",