QPQ-AG/sophia
10
0
Fork 0
Code Issues 41 Pull Requests 5 Actions Packages Projects Releases 16 Wiki Activity

Fix annotations

Browse Source
This commit is contained in:
Gaith Hallak 2023-03-14 09:09:07 +03:00
parent c6fbaaaf75
commit 7a1e94c1e6
1 changed files with 54 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

112
src/aeso_ast_to_fcode.erl
View File

@ -576,9 +576,9 @@ expr_to_fcode(_Env, _Type, {oracle_query_id, Ann, K}) -> {lit, to_fann(Ann), {or
expr_to_fcode(_Env, _Type, {bytes, Ann, B}) -> {lit, to_fann(Ann), {bytes, B}}; expr_to_fcode(_Env, _Type, {bytes, Ann, B}) -> {lit, to_fann(Ann), {bytes, B}};
%% Variables %% Variables
expr_to_fcode(Env, _Type, {id, _, X}) -> resolve_var(Env, [X]); expr_to_fcode(Env, _Type, {id, Ann, X}) -> resolve_var(Env, Ann, [X]);
expr_to_fcode(Env, Type, {qid, _, X}) -> expr_to_fcode(Env, Type, {qid, Ann, X}) ->
case resolve_var(Env, X) of case resolve_var(Env, Ann, X) of
{builtin_u, FAnn, B, Ar} when B =:= oracle_query; {builtin_u, FAnn, B, Ar} when B =:= oracle_query;
B =:= oracle_get_question; B =:= oracle_get_question;
B =:= oracle_get_answer; B =:= oracle_get_answer;
@ -674,8 +674,8 @@ expr_to_fcode(Env, _Type, {list, Ann, Es}) ->
lists:foldr(fun(E, L) -> {op, to_fann(aeso_syntax:get_ann(E)), '::', [expr_to_fcode(Env, E), L]} end, lists:foldr(fun(E, L) -> {op, to_fann(aeso_syntax:get_ann(E)), '::', [expr_to_fcode(Env, E), L]} end,
{nil, to_fann(Ann)}, Es); {nil, to_fann(Ann)}, Es);
expr_to_fcode(Env, _Type, {app, _, {'..', _}, [A, B]}) -> expr_to_fcode(Env, _Type, {app, As, {'..', _}, [A, B]}) ->
{def_u, FAnn, FromTo, _} = resolve_fun(Env, ["ListInternal", "from_to"]), {def_u, FAnn, FromTo, _} = resolve_fun(Env, As, ["ListInternal", "from_to"]),
{def, FAnn, FromTo, [expr_to_fcode(Env, A), expr_to_fcode(Env, B)]}; {def, FAnn, FromTo, [expr_to_fcode(Env, A), expr_to_fcode(Env, B)]};
expr_to_fcode(Env, _Type, {list_comp, As, Yield, []}) -> expr_to_fcode(Env, _Type, {list_comp, As, Yield, []}) ->
@ -686,7 +686,7 @@ expr_to_fcode(Env, _Type, {list_comp, As, Yield, [{comprehension_bind, Pat = {ty
Bind = {lam, to_fann(As), [Arg], expr_to_fcode(Env1, {switch, As, {typed, As, {id, As, Arg}, PatType}, Bind = {lam, to_fann(As), [Arg], expr_to_fcode(Env1, {switch, As, {typed, As, {id, As, Arg}, PatType},
[{'case', As, Pat, [{guarded, As, [], {list_comp, As, Yield, Rest}}]}, [{'case', As, Pat, [{guarded, As, [], {list_comp, As, Yield, Rest}}]},
{'case', As, {id, As, "_"}, [{guarded, As, [], {list, As, []}}]}]})}, {'case', As, {id, As, "_"}, [{guarded, As, [], {list, As, []}}]}]})},
{def_u, FAnn, FlatMap, _} = resolve_fun(Env, ["ListInternal", "flat_map"]), {def_u, FAnn, FlatMap, _} = resolve_fun(Env, As, ["ListInternal", "flat_map"]),
{def, FAnn, FlatMap, [Bind, expr_to_fcode(Env, BindExpr)]}; {def, FAnn, FlatMap, [Bind, expr_to_fcode(Env, BindExpr)]};
expr_to_fcode(Env, Type, {list_comp, As, Yield, [{comprehension_if, _, Cond}|Rest]}) -> expr_to_fcode(Env, Type, {list_comp, As, Yield, [{comprehension_if, _, Cond}|Rest]}) ->
make_if(expr_to_fcode(Env, Cond), make_if(expr_to_fcode(Env, Cond),
@ -742,7 +742,7 @@ expr_to_fcode(Env, _, {app, _, Fun = {typed, Ann, FunE, {fun_t, _, NamedArgsT, A
Args1 = get_named_args(NamedArgsT, Args), Args1 = get_named_args(NamedArgsT, Args),
FArgs = [expr_to_fcode(Env, Arg) || Arg <- Args1], FArgs = [expr_to_fcode(Env, Arg) || Arg <- Args1],
case expr_to_fcode(Env, Fun) of case expr_to_fcode(Env, Fun) of
{builtin_u, _, B, _Ar, TypeArgs} -> builtin_to_fcode(state_layout(Env), B, FArgs ++ TypeArgs); {builtin_u, FAnn, B, _Ar, TypeArgs} -> builtin_to_fcode(state_layout(Env), FAnn, B, FArgs ++ TypeArgs);
{builtin_u, FAnn, chain_clone, _Ar} -> {builtin_u, FAnn, chain_clone, _Ar} ->
case ArgsT of case ArgsT of
var_args -> fcode_error({var_args_not_set, FunE}); var_args -> fcode_error({var_args_not_set, FunE});
@ -750,17 +750,17 @@ expr_to_fcode(Env, _, {app, _, Fun = {typed, Ann, FunE, {fun_t, _, NamedArgsT, A
%% Here we little cheat on the typechecker, but this inconsistency %% Here we little cheat on the typechecker, but this inconsistency
%% is to be solved in `aeso_fcode_to_fate:type_to_scode/1` %% is to be solved in `aeso_fcode_to_fate:type_to_scode/1`
FInitArgsT = aeb_fate_data:make_typerep([type_to_fcode(Env, T) || T <- ArgsT]), FInitArgsT = aeb_fate_data:make_typerep([type_to_fcode(Env, T) || T <- ArgsT]),
builtin_to_fcode(state_layout(Env), chain_clone, [{lit, FAnn, FInitArgsT}|FArgs]) builtin_to_fcode(state_layout(Env), FAnn, chain_clone, [{lit, FAnn, FInitArgsT}|FArgs])
end; end;
{builtin_u, FAnn, chain_create, _Ar} -> {builtin_u, FAnn, chain_create, _Ar} ->
case {ArgsT, Type} of case {ArgsT, Type} of
{var_args, _} -> fcode_error({var_args_not_set, FunE}); {var_args, _} -> fcode_error({var_args_not_set, FunE});
{_, {con, _, Contract}} -> {_, {con, _, Contract}} ->
FInitArgsT = aeb_fate_data:make_typerep([type_to_fcode(Env, T) || T <- ArgsT]), FInitArgsT = aeb_fate_data:make_typerep([type_to_fcode(Env, T) || T <- ArgsT]),
builtin_to_fcode(state_layout(Env), chain_create, [{lit, FAnn, {contract_code, Contract}}, {lit, FAnn, FInitArgsT}|FArgs]); builtin_to_fcode(state_layout(Env), FAnn, chain_create, [{lit, FAnn, {contract_code, Contract}}, {lit, FAnn, FInitArgsT}|FArgs]);
{_, _} -> fcode_error({not_a_contract_type, Type}) {_, _} -> fcode_error({not_a_contract_type, Type})
end; end;
{builtin_u, _, B, _Ar} -> builtin_to_fcode(state_layout(Env), B, FArgs); {builtin_u, FAnn, B, _Ar} -> builtin_to_fcode(state_layout(Env), FAnn, B, FArgs);
{def_u, FAnn, F, _Ar} -> {def, FAnn, F, FArgs}; {def_u, FAnn, F, _Ar} -> {def, FAnn, F, FArgs};
{remote_u, FAnn, RArgsT, RRetT, Ct, RFun} -> {remote, FAnn, RArgsT, RRetT, Ct, RFun, FArgs}; {remote_u, FAnn, RArgsT, RRetT, Ct, RFun} -> {remote, FAnn, RArgsT, RRetT, Ct, RFun, FArgs};
FFun -> FFun ->
@ -1168,48 +1168,44 @@ op_builtins() ->
mcl_bls12_381_int_to_fr, mcl_bls12_381_int_to_fp, mcl_bls12_381_fr_to_int, mcl_bls12_381_fp_to_int mcl_bls12_381_int_to_fr, mcl_bls12_381_int_to_fp, mcl_bls12_381_fr_to_int, mcl_bls12_381_fp_to_int
]. ].
-spec set_state(state_layout(), fexpr()) -> fexpr(). -spec set_state(state_layout(), fann(), fexpr()) -> fexpr().
set_state({reg, R}, Val) -> set_state({reg, R}, FAnn, Val) ->
{set_state, get_fann(Val), R, Val}; {set_state, FAnn, R, Val};
set_state({tuple, Ls}, Val) -> set_state({tuple, Ls}, FAnn, Val) ->
?make_let(X, Val, ?make_let(X, Val,
lists:foldr(fun({I, L}, Code) -> lists:foldr(fun({I, L}, Code) ->
{'let', get_fann(Val), "_", set_state(L, {proj, get_fann(Val), X, I - 1}), Code} {'let', FAnn, "_", set_state(L, FAnn, {proj, FAnn, X, I - 1}), Code}
end, {tuple, get_fann(Val), []}, indexed(Ls))). end, {tuple, FAnn, []}, indexed(Ls))).
-spec get_state(state_layout()) -> fexpr(). -spec get_state(state_layout(), fann()) -> fexpr().
get_state({reg, R}) -> get_state({reg, R}, FAnn) ->
{get_state, [], R}; {get_state, FAnn, R};
get_state({tuple, Ls}) -> get_state({tuple, Ls}, FAnn) ->
{tuple, [], [get_state(L) || L <- Ls]}. {tuple, FAnn, [get_state(L, FAnn) || L <- Ls]}.
-spec builtin_to_fcode(state_layout(), BuiltinFun, [fexpr()]) -> fexpr() when -spec builtin_to_fcode(state_layout(), fann(), BuiltinFun, [fexpr()]) -> fexpr() when
BuiltinFun :: atom(). %% No need to mention all of them BuiltinFun :: atom(). %% No need to mention all of them
builtin_to_fcode(Layout, set_state, [Val]) -> builtin_to_fcode(Layout, FAnn, set_state, [Val]) ->
set_state(Layout, Val); set_state(Layout, FAnn, Val);
builtin_to_fcode(Layout, get_state, []) -> builtin_to_fcode(Layout, FAnn, get_state, []) ->
get_state(Layout); get_state(Layout, FAnn);
builtin_to_fcode(_Layout, require, [Cond, Msg]) -> builtin_to_fcode(_Layout, FAnn, require, [Cond, Msg]) ->
make_if(Cond, {tuple, get_fann(Cond), []}, {builtin, get_fann(Cond), abort, [Msg]}); make_if(Cond, {tuple, FAnn, []}, {builtin, FAnn, abort, [Msg]});
builtin_to_fcode(_Layout, chain_event, [Event]) -> builtin_to_fcode(_Layout, FAnn, chain_event, [Event]) ->
{def, get_fann(Event), event, [Event]}; {def, FAnn, event, [Event]};
builtin_to_fcode(_Layout, map_delete, [Key, Map]) -> builtin_to_fcode(_Layout, FAnn, map_delete, [Key, Map]) ->
{op, get_fann(Map), map_delete, [Map, Key]}; {op, FAnn, map_delete, [Map, Key]};
builtin_to_fcode(_Layout, map_member, [Key, Map]) -> builtin_to_fcode(_Layout, FAnn, map_member, [Key, Map]) ->
{op, get_fann(Map), map_member, [Map, Key]}; {op, FAnn, map_member, [Map, Key]};
builtin_to_fcode(_Layout, map_lookup, [Key0, Map0]) -> builtin_to_fcode(_Layout, FAnn, map_lookup, [Key0, Map0]) ->
?make_let(Key, Key0, ?make_let(Key, Key0,
?make_let(Map, Map0, ?make_let(Map, Map0,
make_if({op, get_fann(Map), map_member, [Map, Key]}, make_if({op, FAnn, map_member, [Map, Key]},
{con, get_fann(Map), [0, 1], 1, [{op, get_fann(Map), map_get, [Map, Key]}]}, {con, FAnn, [0, 1], 1, [{op, FAnn, map_get, [Map, Key]}]},
{con, get_fann(Map), [0, 1], 0, []}))); {con, FAnn, [0, 1], 0, []})));
builtin_to_fcode(_Layout, map_lookup_default, [Key, Map, Def]) -> builtin_to_fcode(_Layout, FAnn, map_lookup_default, [Key, Map, Def]) ->
{op, get_fann(Map), map_get_d, [Map, Key, Def]}; {op, FAnn, map_get_d, [Map, Key, Def]};
builtin_to_fcode(_Layout, Builtin, Args) -> builtin_to_fcode(_Layout, FAnn, Builtin, Args) ->
FAnn = case Args of
[Arg | _] -> to_fann(aeso_syntax:get_ann(Arg));
_ -> []
end,
case lists:member(Builtin, op_builtins()) of case lists:member(Builtin, op_builtins()) of
true -> {op, FAnn, Builtin, Args}; true -> {op, FAnn, Builtin, Args};
false -> {builtin, FAnn, Builtin, Args} false -> {builtin, FAnn, Builtin, Args}
@ -1226,7 +1222,7 @@ add_init_function(Env, Funs0) ->
InitName = {entrypoint, <<"init">>}, InitName = {entrypoint, <<"init">>},
InitFun = #{ body := InitBody} = maps:get(InitName, Funs), InitFun = #{ body := InitBody} = maps:get(InitName, Funs),
Funs1 = Funs#{ InitName => InitFun#{ return => {tuple, []}, Funs1 = Funs#{ InitName => InitFun#{ return => {tuple, []},
body => builtin_to_fcode(state_layout(Env), set_state, [InitBody]) } }, body => builtin_to_fcode(state_layout(Env), [], set_state, [InitBody]) } },
Funs1 Funs1
end. end.
@ -1342,7 +1338,7 @@ lambda_lift_expr(Layout, UExpr) when element(1, UExpr) == def_u; element(1, UExp
Xs = [ lists:concat(["arg", I]) || I <- lists:seq(1, Ar) ], Xs = [ lists:concat(["arg", I]) || I <- lists:seq(1, Ar) ],
Args = [{var, get_fann(UExpr), X} || X <- Xs] ++ ExtraArgs, Args = [{var, get_fann(UExpr), X} || X <- Xs] ++ ExtraArgs,
Body = case Tag of Body = case Tag of
builtin_u -> builtin_to_fcode(Layout, F, Args); builtin_u -> builtin_to_fcode(Layout, get_fann(UExpr), F, Args);
def_u -> {def, get_fann(UExpr), F, Args} def_u -> {def, get_fann(UExpr), F, Args}
end, end,
make_closure([], Xs, Body); make_closure([], Xs, Body);
@ -1843,19 +1839,19 @@ bind_vars(Env, Xs) ->
-spec bind_var(env(), var_name()) -> env(). -spec bind_var(env(), var_name()) -> env().
bind_var(Env = #{ vars := Vars }, X) -> Env#{ vars := [X | Vars] }. bind_var(Env = #{ vars := Vars }, X) -> Env#{ vars := [X | Vars] }.
-spec resolve_var(env(), [aeso_syntax:name()]) -> fexpr(). -spec resolve_var(env(), aeso_syntax:ann(), [aeso_syntax:name()]) -> fexpr().
resolve_var(#{ vars := Vars } = Env, [X]) -> resolve_var(#{ vars := Vars } = Env, Ann, [X]) ->
case lists:member(X, Vars) of case lists:member(X, Vars) of
true -> {var, [], X}; true -> {var, to_fann(Ann), X};
false -> false ->
case resolve_const(Env, [X]) of case resolve_const(Env, [X]) of
false -> resolve_fun(Env, [X]); false -> resolve_fun(Env, Ann, [X]);
Const -> Const Const -> Const
end end
end; end;
resolve_var(Env, Q) -> resolve_var(Env, Ann, Q) ->
case resolve_const(Env, Q) of case resolve_const(Env, Q) of
false -> resolve_fun(Env, Q); false -> resolve_fun(Env, Ann, Q);
Const -> Const Const -> Const
end. end.
@ -1865,13 +1861,13 @@ resolve_const(#{ consts := Consts }, Q) ->
Val -> Val Val -> Val
end. end.
-spec resolve_fun(env(), [aeso_syntax:name()]) -> fexpr(). -spec resolve_fun(env(), aeso_syntax:ann(), [aeso_syntax:name()]) -> fexpr().
resolve_fun(#{ fun_env := Funs, builtins := Builtin } = Env, Q) -> resolve_fun(#{ fun_env := Funs, builtins := Builtin } = Env, Ann, Q) ->
case {maps:get(Q, Funs, not_found), maps:get(Q, Builtin, not_found)} of case {maps:get(Q, Funs, not_found), maps:get(Q, Builtin, not_found)} of
{not_found, not_found} -> internal_error({unbound_variable, Q}); {not_found, not_found} -> internal_error({unbound_variable, Q});
{_, {B, none}} -> builtin_to_fcode(state_layout(Env), B, []); {_, {B, none}} -> builtin_to_fcode(state_layout(Env), to_fann(Ann), B, []);
{_, {B, Ar}} -> {builtin_u, [], B, Ar}; {_, {B, Ar}} -> {builtin_u, to_fann(Ann), B, Ar};
{{Fun, Ar}, _} -> {def_u, [], Fun, Ar} {{Fun, Ar}, _} -> {def_u, to_fann(Ann), Fun, Ar}
end. end.
-spec init_fresh_names([option()]) -> term(). -spec init_fresh_names([option()]) -> term().