change aebytecode ver to the one from full node with my changes on top

CHANGELOG.md

@@ -9,37 +9,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 ### Removed
 
-## [4.0.0-rc1] - 2019-08-22
-### Added
-- FATE backend - the compiler is able to produce VM code for both `AEVM` and `FATE`. Many
-  of the APIs now take `{backend, aevm | fate}` to decide wich backend to produce artifacts
-  for.
-- New builtin functions `Crypto.ecrecover_secp256k1: (hash, bytes(65)) => option(bytes(20))`
-  and `Crypto.ecverify_secp256k1 : (hash, bytes(20), bytes(65)) => bool` for recovering
-  and verifying an Ethereum address for a message hash and a signature.
-- Sophia supports list comprehensions known from languages like Python, Haskell or Erlang.
-  Example syntax:
-```
-[x + y | x <- [1,2,3,4,5], let k = x*x, if (k > 5), y <- [k, k+1, k+2]]
-// yields [12,13,14,20,21,22,30,31,32]
-```
-- A new contract, and endpoint, modifier `payable` is introduced. Contracts, and enpoints,
-  that shall be able to receive funds should be marked as payable. `Address.is_payable(a)`
-  can be used to check if an (contract) address is payable or not.
-### Changed
-- New syntax for tuple types. Now 0-tuple type is encoded as `unit` instead of `()` and
-  regular tuples are encoded by interspersing inner types with `*`, for instance `int * string`.
-  Parens are not necessary. Note it only affects the types, values remain as their were before,
-  so `(1, "a") : int * string`
-- The `AENS.transfer` and `AENS.revoke` functions have been updated to take a name `string`
-  instead of a name `hash`.
-- Fixed a bug where the `AEVM` backend complained about a missing `init` function when
-  trying to generate calldata from an ACI-generated interface.
-- Compiler now returns the ABI-version in the compiler result map.
-- Renamed `Crypto.ecverify` and `Crypto.ecverify_secp256k1` into `Crypto.verify_sig` and
-  `Crypto.verify_sig_secp256k1` respectively.
-### Removed
-
 ## [3.2.0] - 2019-06-28
 ### Added
 - New builtin function `require : (bool, string) => ()`. Defined as
@@ -134,8 +103,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Simplify calldata creation - instead of passing a compiled contract, simply
   pass a (stubbed) contract string.
 
-[Unreleased]: https://github.com/aeternity/aesophia/compare/v4.0.0-rc1...HEAD
-[4.0.0-rc1]: https://github.com/aeternity/aesophia/compare/v3.2.0...v4.0.0-rc1
+[Unreleased]: https://github.com/aeternity/aesophia/compare/v3.2.0...HEAD
 [3.2.0]: https://github.com/aeternity/aesophia/compare/v3.1.0...v3.2.0
 [3.1.0]: https://github.com/aeternity/aesophia/compare/v3.0.0...v3.1.0
 [3.0.0]: https://github.com/aeternity/aesophia/compare/v2.1.0...v3.0.0

rebar.config

@@ -2,7 +2,7 @@
 
 {erl_opts, [debug_info]}.
 
-{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git", {ref,"10cc127"}}}
+{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git", {ref,"adf3664"}}}
        , {getopt, "1.0.1"}
        , {eblake2, "1.0.0"}
        , {jsx, {git, "https://github.com/talentdeficit/jsx.git",
@@ -15,7 +15,7 @@
             {base_plt_apps, [erts, kernel, stdlib, crypto, mnesia]}
            ]}.
 
-{relx, [{release, {aesophia, "4.0.0-rc1"},
+{relx, [{release, {aesophia, "3.2.0"},
          [aesophia, aebytecode, getopt]},
 
         {dev_mode, true},

rebar.lock

@@ -1,7 +1,7 @@
 {"1.1.0",
 [{<<"aebytecode">>,
   {git,"https://github.com/aeternity/aebytecode.git",
-       {ref,"10cc1278831ad7e90138533466ceef4bcafd74a9"}},
+       {ref,"adf3664dd03626c115756f79fa0e602fda24318d"}},
   0},
  {<<"aeserialization">>,
   {git,"https://github.com/aeternity/aeserialization.git",

src/aeso_aci.erl

@@ -113,7 +113,7 @@ encode_contract(Contract = {contract, _, {con, _, Name}, _}) ->
                || F <- sort_decls(contract_funcs(Contract)),
                   is_entrypoint(F) ],
 
-    #{contract => C3#{functions => Fdefs, payable => is_payable(Contract)}};
+    #{contract => C3#{functions => Fdefs}};
 encode_contract(Namespace = {namespace, _, {con, _, Name}, _}) ->
     Tdefs = [ encode_typedef(T) || T <- sort_decls(contract_types(Namespace)) ],
     #{namespace => #{name => encode_name(Name),
@@ -125,14 +125,12 @@ encode_function(FDef = {letfun, _, {id, _, Name}, Args, Type, _}) ->
     #{name      => encode_name(Name),
       arguments => encode_args(Args),
       returns   => encode_type(Type),
-      stateful  => is_stateful(FDef),
-      payable   => is_payable(FDef)};
+      stateful  => is_stateful(FDef)};
 encode_function(FDecl = {fun_decl, _, {id, _, Name}, {fun_t, _, _, Args, Type}}) ->
     #{name      => encode_name(Name),
       arguments => encode_anon_args(Args),
       returns   => encode_type(Type),
-      stateful  => is_stateful(FDecl),
-      payable   => is_payable(FDecl)}.
+      stateful  => is_stateful(FDecl)}.
 
 encode_anon_args(Types) ->
     Anons = [ list_to_binary("_" ++ integer_to_list(X)) || X <- lists:seq(1, length(Types))],
@@ -236,13 +234,12 @@ do_render_aci_json(Json) ->
     {ok, list_to_binary(string:join(DecodedContracts, "\n"))}.
 
 decode_contract(#{contract := #{name := Name,
-                                payable := Payable,
                                 type_defs := Ts0,
                                 functions := Fs} = C}) ->
     MkTDef = fun(N, T) -> #{name => N, vars => [], typedef => T} end,
     Ts = [ MkTDef(<<"state">>, maps:get(state, C)) || maps:is_key(state, C) ] ++
          [ MkTDef(<<"event">>, maps:get(event, C)) || maps:is_key(event, C) ] ++ Ts0,
-    [payable(Payable), "contract ", io_lib:format("~s", [Name])," =\n",
+    ["contract ", io_lib:format("~s", [Name])," =\n",
      decode_tdefs(Ts), decode_funcs(Fs)];
 decode_contract(#{namespace := #{name := Name, type_defs := Ts}}) when Ts /= [] ->
     ["namespace ", io_lib:format("~s", [Name])," =\n",
@@ -252,8 +249,8 @@ decode_contract(_) -> [].
 decode_funcs(Fs) -> [ decode_func(F) || F <- Fs ].
 
 %% decode_func(#{name := init}) -> [];
-decode_func(#{name := Name, payable := Payable, arguments := As, returns := T}) ->
-    ["  ", payable(Payable), "entrypoint ", io_lib:format("~s", [Name]), " : ",
+decode_func(#{name := Name, arguments := As, returns := T}) ->
+    ["  entrypoint", " ", io_lib:format("~s", [Name]), " : ",
      decode_args(As), " => ", decode_type(T), $\n].
 
 decode_args(As) ->
@@ -324,16 +321,13 @@ decode_deftype(#{record := _Efs}) -> "record";
 decode_deftype(#{variant := _})   -> "datatype";
 decode_deftype(_T)                      -> "type".
 
-decode_tvars([]) -> [];  %No tvars, no parentheses
+decode_tvars([]) -> [];                         %No tvars, no parentheses
 decode_tvars(Vs) ->
     Dvs = [ decode_tvar(V) || V <- Vs ],
     [$(,lists:join(", ", Dvs),$)].
 
 decode_tvar(#{name := N}) -> io_lib:format("~s", [N]).
 
-payable(true)  -> "payable ";
-payable(false) -> "".
-
 %% #contract{Ann, Con, [Declarations]}.
 
 contract_funcs({C, _, _, Decls}) when C == contract; C == namespace ->
@@ -358,7 +352,6 @@ sort_decls(Ds) ->
 
 is_entrypoint(Node) -> aeso_syntax:get_ann(entrypoint, Node, false).
 is_stateful(Node) -> aeso_syntax:get_ann(stateful, Node, false).
-is_payable(Node) -> aeso_syntax:get_ann(payable, Node, false).
 
 typedef_name({type_def, _, {id, _, Name}, _, _}) -> Name.
 

src/aeso_ast_infer_types.erl

@@ -83,7 +83,7 @@
 
 -type fun_info()  :: {aeso_syntax:ann(), typesig() | type()}.
 -type type_info() :: {aeso_syntax:ann(), typedef()}.
--type var_info()  :: {aeso_syntax:ann(), utype()}.
+-type var_info()  :: {aeso_syntax:ann(), type()}.
 
 -type fun_env()  :: [{name(), fun_info()}].
 -type type_env() :: [{name(), type_info()}].
@@ -139,11 +139,11 @@ on_current_scope(Env = #env{ namespace = NS, scopes = Scopes }, Fun) ->
 on_scopes(Env = #env{ scopes = Scopes }, Fun) ->
     Env#env{ scopes = maps:map(fun(_, Scope) -> Fun(Scope) end, Scopes) }.
 
--spec bind_var(aeso_syntax:id(), utype(), env()) -> env().
+-spec bind_var(aeso_syntax:id(), type(), env()) -> env().
 bind_var({id, Ann, X}, T, Env) ->
     Env#env{ vars = [{X, {Ann, T}} | Env#env.vars] }.
 
--spec bind_vars([{aeso_syntax:id(), utype()}], env()) -> env().
+-spec bind_vars([{aeso_syntax:id(), type()}], env()) -> env().
 bind_vars([], Env) -> Env;
 bind_vars([{X, T} | Vars], Env) ->
     bind_vars(Vars, bind_var(X, T, Env)).
@@ -363,8 +363,6 @@ global_env() ->
     Pair    = fun(A, B) -> {tuple_t, Ann, [A, B]} end,
     Fun     = fun(Ts, T) -> {type_sig, Ann, [], Ts, T} end,
     Fun1    = fun(S, T) -> Fun([S], T) end,
-    %% Lambda    = fun(Ts, T) -> {fun_t, Ann, [], Ts, T} end,
-    %% Lambda1   = fun(S, T) -> Lambda([S], T) end,
     StateFun  = fun(Ts, T) -> {type_sig, [stateful|Ann], [], Ts, T} end,
     TVar      = fun(X) -> {tvar, Ann, "'" ++ X} end,
     SignId    = {id, Ann, "signature"},
@@ -443,7 +441,7 @@ global_env() ->
         { funs = MkDefs(
                      [{"resolve",  Fun([String, String], option_t(Ann, A))},
                       {"preclaim", SignFun([Address, Hash], Unit)},
-                      {"claim",    SignFun([Address, String, Int], Unit)},
+                      {"claim",    SignFun([Address, String, Int, Int], Unit)},
                       {"transfer", SignFun([Address, Address, String], Unit)},
                       {"revoke",   SignFun([Address, String], Unit)}]) },
 
@@ -460,10 +458,8 @@ global_env() ->
     %% Crypto/Curve operations
     CryptoScope = #scope
         { funs = MkDefs(
-                     [{"verify_sig",           Fun([Hash, Address, SignId], Bool)},
-                      {"verify_sig_secp256k1", Fun([Hash, Bytes(64), SignId], Bool)},
-                      {"ecverify_secp256k1",   Fun([Hash, Bytes(20), Bytes(65)], Bool)},
-                      {"ecrecover_secp256k1",  Fun([Hash, Bytes(65)], Option(Bytes(20)))},
+                     [{"ecverify", Fun([Hash, Address, SignId], Bool)},
+                      {"ecverify_secp256k1", Fun([Hash, Bytes(64), Bytes(64)], Bool)},
                       {"sha3",     Fun1(A, Hash)},
                       {"sha256",   Fun1(A, Hash)},
                       {"blake2b",  Fun1(A, Hash)}]) },
@@ -505,8 +501,7 @@ global_env() ->
     IntScope     = #scope{ funs = MkDefs([{"to_str", Fun1(Int,     String)}]) },
     AddressScope = #scope{ funs = MkDefs([{"to_str", Fun1(Address, String)},
                                           {"is_oracle", Fun1(Address, Bool)},
-                                          {"is_contract", Fun1(Address, Bool)},
-                                          {"is_payable", Fun1(Address, Bool)}]) },
+                                          {"is_contract", Fun1(Address, Bool)}]) },
 
     #env{ scopes =
             #{ []           => TopScope
@@ -1079,58 +1074,6 @@ infer_expr(Env, {list, As, Elems}) ->
     ElemType = fresh_uvar(As),
     NewElems = [check_expr(Env, X, ElemType) || X <- Elems],
     {typed, As, {list, As, NewElems}, {app_t, As, {id, As, "list"}, [ElemType]}};
-infer_expr(Env, {list_comp, As, Yield, []}) ->
-    {typed, _, TypedYield, Type} = infer_expr(Env, Yield),
-    {typed, As, {list_comp, As, TypedYield, []}, {app_t, As, {id, As, "list"}, [Type]}};
-infer_expr(Env, {list_comp, As, Yield, [{comprehension_bind, Arg, BExpr}|Rest]}) ->
-    BindVarType = fresh_uvar(As),
-    TypedBind = {typed, As2, _, TypeBExpr} = infer_expr(Env, BExpr),
-    unify( Env
-         , TypeBExpr
-         , {app_t, As, {id, As, "list"}, [BindVarType]}
-         , {list_comp, TypedBind, TypeBExpr, {app_t, As2, {id, As, "list"}, [BindVarType]}}),
-    NewE = bind_var(Arg, BindVarType, Env),
-    {typed, _, {list_comp, _, TypedYield, TypedRest}, ResType} =
-        infer_expr(NewE, {list_comp, As, Yield, Rest}),
-    { typed
-    , As
-    , {list_comp, As, TypedYield, [{comprehension_bind, {typed, Arg, BindVarType}, TypedBind}|TypedRest]}
-    , ResType};
-infer_expr(Env, {list_comp, AttrsL, Yield, [{comprehension_if, AttrsIF, Cond}|Rest]}) ->
-    NewCond = check_expr(Env, Cond, {id, AttrsIF, "bool"}),
-    {typed, _, {list_comp, _, TypedYield, TypedRest}, ResType} =
-        infer_expr(Env, {list_comp, AttrsL, Yield, Rest}),
-    { typed
-    , AttrsL
-    , {list_comp, AttrsL, TypedYield, [{comprehension_if, AttrsIF, NewCond}|TypedRest]}
-    , ResType};
-infer_expr(Env, {list_comp, AsLC, Yield, [{letval, AsLV, Pattern, Type, E}|Rest]}) ->
-    NewE = {typed, _, _, PatType} = infer_expr(Env, {typed, AsLV, E, arg_type(Type)}),
-    BlockType = fresh_uvar(AsLV),
-    {'case', _, NewPattern, NewRest} =
-        infer_case( Env
-                  , AsLC
-                  , Pattern
-                  , PatType
-                  , {list_comp, AsLC, Yield, Rest}
-                  , BlockType),
-    {typed, _, {list_comp, _, TypedYield, TypedRest}, ResType} = NewRest,
-    { typed
-    , AsLC
-    , {list_comp, AsLC, TypedYield, [{letval, AsLV, NewPattern, Type, NewE}|TypedRest]}
-    , ResType
-    };
-infer_expr(Env, {list_comp, AsLC, Yield, [Def={letfun, AsLF, _, _, _, _}|Rest]}) ->
-    {{Name, TypeSig}, LetFun} = infer_letfun(Env, Def),
-    FunT = freshen_type(AsLF, typesig_to_fun_t(TypeSig)),
-    NewE = bind_var({id, AsLF, Name}, FunT, Env),
-    {typed, _, {list_comp, _, TypedYield, TypedRest}, ResType} =
-        infer_expr(NewE, {list_comp, AsLC, Yield, Rest}),
-    { typed
-    , AsLC
-    , {list_comp, AsLC, TypedYield, [LetFun|TypedRest]}
-    , ResType
-    };
 infer_expr(Env, {typed, As, Body, Type}) ->
     Type1 = check_type(Env, Type),
     {typed, _, NewBody, NewType} = check_expr(Env, Body, Type1),
@@ -2310,13 +2253,6 @@ pp_when({check_expr, Expr, Inferred0, Expected0}) ->
 pp_when({checking_init_type, Ann}) ->
     io_lib:format("when checking that 'init' returns a value of type 'state' at ~s\n",
                   [pp_loc(Ann)]);
-pp_when({list_comp, BindExpr, Inferred0, Expected0}) ->
-    {Inferred, Expected} = instantiate({Inferred0, Expected0}),
-    io_lib:format("when checking rvalue of list comprehension binding at ~s\n~s\n"
-                  "against type \n~s\n",
-                  [pp_loc(BindExpr), pp_typed("  ", BindExpr, Inferred), pp_type("  ", Expected)]
-                 );
-
 pp_when(unknown) -> "".
 
 -spec pp_why_record(why_record()) -> iolist().

src/aeso_ast_to_fcode.erl

@@ -16,7 +16,7 @@
 
 -type option() :: term().
 
--type attribute() :: stateful | payable | pure | private.
+-type attribute() :: stateful | pure | private.
 
 -type fun_name() :: {entrypoint, binary()}
                   | {local_fun, [string()]}
@@ -32,9 +32,8 @@
               map_delete | map_member | map_size | string_length |
               string_concat | bits_set | bits_clear | bits_test | bits_sum |
               bits_intersection | bits_union | bits_difference |
-              contract_to_address | crypto_verify_sig | crypto_verify_sig_secp256k1 |
-              crypto_sha3 | crypto_sha256 | crypto_blake2b |
-              crypto_ecverify_secp256k1 | crypto_ecrecover_secp256k1.
+              contract_to_address | crypto_ecverify | crypto_ecverify_secp256k1 |
+              crypto_sha3 | crypto_sha256 | crypto_blake2b.
 
 -type flit() :: {int, integer()}
               | {string, binary()}
@@ -50,7 +49,7 @@
                | nil
                | {var, var_name()}
                | {def, fun_name(), [fexpr()]}
-               | {remote, [ftype()], ftype(), fexpr(), fun_name(), [fexpr()]}
+               | {remote, fexpr(), fun_name(), [fexpr()]}
                | {builtin, builtin(), [fexpr()]}
                | {con, arities(), tag(), [fexpr()]}
                | {tuple, [fexpr()]}
@@ -65,7 +64,7 @@
                %% lambdas) are generated by the fcode compiler, but translated
                %% to closures by the lambda lifter.
                | {def_u, fun_name(), arity()}
-               | {remote_u, [ftype()], ftype(), fexpr(), fun_name()}
+               | {remote_u, fexpr(), fun_name(), arity()}
                | {builtin_u, builtin(), arity()}
                | {lam, [var_name()], fexpr()}.
 
@@ -109,8 +108,7 @@
 -type fcode() :: #{ contract_name := string(),
                     state_type    := ftype(),
                     event_type    := ftype() | none,
-                    functions     := #{ fun_name() => fun_def() },
-                    payable       := boolean() }.
+                    functions     := #{ fun_name() => fun_def() } }.
 
 -type type_def() :: fun(([ftype()]) -> ftype()).
 
@@ -185,20 +183,19 @@ builtins() ->
               {["Oracle"],   [{"register", 4}, {"query_fee", 1}, {"query", 5}, {"get_question", 2},
                               {"respond", 4}, {"extend", 3}, {"get_answer", 2},
                               {"check", 1}, {"check_query", 2}]},
-              {["AENS"],     [{"resolve", 2}, {"preclaim", 3}, {"claim", 4}, {"transfer", 4},
+              {["AENS"],     [{"resolve", 2}, {"preclaim", 3}, {"claim", 5}, {"transfer", 4},
                               {"revoke", 3}]},
               {["Map"],      [{"from_list", 1}, {"to_list", 1}, {"lookup", 2},
                               {"lookup_default", 3}, {"delete", 2}, {"member", 2}, {"size", 1}]},
-              {["Crypto"],   [{"verify_sig", 3}, {"verify_sig_secp256k1", 3},
-                              {"ecverify_secp256k1", 3}, {"ecrecover_secp256k1", 2},
-                              {"sha3", 1}, {"sha256", 1}, {"blake2b", 1}]},
+              {["Crypto"],   [{"ecverify", 3}, {"ecverify_secp256k1", 3}, {"sha3", 1},
+                              {"sha256", 1}, {"blake2b", 1}]},
               {["Auth"],     [{"tx_hash", none}]},
               {["String"],   [{"length", 1}, {"concat", 2}, {"sha3", 1}, {"sha256", 1}, {"blake2b", 1}]},
               {["Bits"],     [{"set", 2}, {"clear", 2}, {"test", 2}, {"sum", 1}, {"intersection", 2},
                               {"union", 2}, {"difference", 2}, {"none", none}, {"all", none}]},
               {["Bytes"],    [{"to_int", 1}, {"to_str", 1}]},
               {["Int"],      [{"to_str", 1}]},
-              {["Address"],  [{"to_str", 1}, {"is_oracle", 1}, {"is_contract", 1}, {"is_payable", 1}]}
+              {["Address"],  [{"to_str", 1}, {"is_oracle", 1}, {"is_contract", 1}]}
              ],
     maps:from_list([ {NS ++ [Fun], {MkName(NS, Fun), Arity}}
                      || {NS, Funs} <- Scopes,
@@ -226,13 +223,10 @@ init_type_env() ->
        ["Chain", "ttl"] => ?type({variant, [[integer], [integer]]})
      }.
 
-is_no_code(Env) ->
-    proplists:get_value(no_code, maps:get(options, Env, []), false).
-
 %% -- Compilation ------------------------------------------------------------
 
 -spec to_fcode(env(), aeso_syntax:ast()) -> fcode().
-to_fcode(Env, [{contract, Attrs, {con, _, Main}, Decls}]) ->
+to_fcode(Env, [{contract, _, {con, _, Main}, Decls}]) ->
     #{ builtins := Builtins } = Env,
     MainEnv = Env#{ context  => {main_contract, Main},
                     builtins => Builtins#{[Main, "state"]          => {get_state, none},
@@ -242,12 +236,10 @@ to_fcode(Env, [{contract, Attrs, {con, _, Main}, Decls}]) ->
         decls_to_fcode(MainEnv, Decls),
     StateType = lookup_type(Env1, [Main, "state"], [], {tuple, []}),
     EventType = lookup_type(Env1, [Main, "event"], [], none),
-    Payable   = proplists:get_value(payable, Attrs, false),
     #{ contract_name => Main,
        state_type    => StateType,
        event_type    => EventType,
-       payable       => Payable,
-       functions     => add_init_function(Env1, StateType,
+       functions     => add_init_function(Env1,
                         add_event_function(Env1, EventType, Funs)) };
 to_fcode(Env, [{contract, _, {con, _, Con}, Decls} | Code]) ->
     Env1 = decls_to_fcode(Env#{ context => {abstract_contract, Con} }, Decls),
@@ -271,7 +263,7 @@ decls_to_fcode(Env, Decls) ->
 -spec decl_to_fcode(env(), aeso_syntax:decl()) -> env().
 decl_to_fcode(Env, {type_decl, _, _, _}) -> Env;
 decl_to_fcode(Env = #{context := {main_contract, _}}, {fun_decl, Ann, {id, _, Name}, _}) ->
-    case is_no_code(Env) of
+    case proplists:get_value(no_code, maps:get(options, Env, []), false) of
         false -> fcode_error({missing_definition, Name, lists:keydelete(entrypoint, 1, Ann)});
         true  -> Env
     end;
@@ -412,10 +404,9 @@ expr_to_fcode(Env, Type, {proj, _Ann, Rec = {typed, _, _, RecType}, {id, _, X}})
         {con, _, _} when X == "address" ->
             {op, contract_to_address, [expr_to_fcode(Env, Rec)]};
         {con, _, _} ->
-            {fun_t, _, _, Args, Ret} = Type,
-            FArgs = [type_to_fcode(Env, Arg) || Arg <- Args],
-            {remote_u, FArgs, type_to_fcode(Env, Ret), expr_to_fcode(Env, Rec),
-                       {entrypoint, list_to_binary(X)}};
+            {fun_t, _, Named, Args, _} = Type,
+            Arity = length(Named) + length(Args),
+            {remote_u, expr_to_fcode(Env, Rec), {entrypoint, list_to_binary(X)}, Arity};
         {record_t, _} ->
             {proj, expr_to_fcode(Env, Rec), field_index(Rec, X)}
     end;
@@ -453,23 +444,6 @@ expr_to_fcode(Env, _Type, {list, _, Es}) ->
     lists:foldr(fun(E, L) -> {op, '::', [expr_to_fcode(Env, E), L]} end,
                 nil, Es);
 
-expr_to_fcode(Env, _Type, {list_comp, _, Yield, []}) ->
-    {op, '::', [expr_to_fcode(Env, Yield), nil]};
-expr_to_fcode(Env, _Type, {list_comp, As, Yield, [{comprehension_bind, {typed, {id, _, Arg}, _}, BindExpr}|Rest]}) ->
-    Env1 = bind_var(Env, Arg),
-    Bind = {lam, [Arg], expr_to_fcode(Env1, {list_comp, As, Yield, Rest})},
-    {def_u, FlatMap, _} = resolve_fun(Env, ["List", "flat_map"]),
-    {def, FlatMap, [Bind, expr_to_fcode(Env, BindExpr)]};
-expr_to_fcode(Env, Type, {list_comp, As, Yield, [{comprehension_if, _, Cond}|Rest]}) ->
-    make_if(expr_to_fcode(Env, Cond),
-            expr_to_fcode(Env, Type, {list_comp, As, Yield, Rest}),
-            nil
-           );
-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, {block, As, [LF, {list_comp, As, Yield, Rest}]});
-
 %% Conditionals
 expr_to_fcode(Env, _Type, {'if', _, Cond, Then, Else}) ->
     make_if(expr_to_fcode(Env, Cond),
@@ -529,7 +503,7 @@ expr_to_fcode(Env, Type, {app, _Ann, Fun = {typed, _, _, {fun_t, _, NamedArgsT,
             builtin_to_fcode(B, FArgs ++ TypeArgs);
         {builtin_u, B, _Ar}       -> builtin_to_fcode(B, FArgs);
         {def_u, F, _Ar}           -> {def, F, FArgs};
-        {remote_u, ArgsT, RetT, Ct, RFun} -> {remote, ArgsT, RetT, Ct, RFun, FArgs};
+        {remote_u, Ct, RFun, _Ar} -> {remote, Ct, RFun, FArgs};
         FFun ->
             %% FFun is a closure, with first component the function name and
             %% second component the environment
@@ -826,10 +800,8 @@ op_builtins() ->
     [map_from_list, map_to_list, map_delete, map_member, map_size,
      string_length, string_concat, string_sha3, string_sha256, string_blake2b,
      bits_set, bits_clear, bits_test, bits_sum, bits_intersection, bits_union,
-     bits_difference, int_to_str, address_to_str, crypto_verify_sig,
-     crypto_verify_sig_secp256k1, crypto_sha3, crypto_sha256, crypto_blake2b,
-     crypto_ecverify_secp256k1, crypto_ecrecover_secp256k1
-    ].
+     bits_difference, int_to_str, address_to_str, crypto_ecverify,
+     crypto_ecverify_secp256k1, crypto_sha3, crypto_sha256, crypto_blake2b].
 
 builtin_to_fcode(require, [Cond, Msg]) ->
     make_if(Cond, {tuple, []}, {builtin, abort, [Msg]});
@@ -855,30 +827,16 @@ builtin_to_fcode(Builtin, Args) ->
 
 %% -- Init function --
 
-add_init_function(Env, StateType, Funs0) ->
-    case is_no_code(Env) of
-        true  -> Funs0;
-        false ->
-            Funs     = add_default_init_function(Env, StateType, Funs0),
-            InitName = {entrypoint, <<"init">>},
-            InitFun  = #{ args := InitArgs } = maps:get(InitName, Funs, none),
-            Vars     = [ {var, X} || {X, _} <- InitArgs ],
-            Funs#{ init => InitFun#{ return => {tuple, []},
-                                     body   => {builtin, set_state, [{def, InitName, Vars}]} } }
-    end.
-
-add_default_init_function(_Env, StateType, Funs) ->
+add_init_function(_Env, Funs) ->
     InitName = {entrypoint, <<"init">>},
-    case maps:get(InitName, Funs, none) of
-        %% Only add default init function if state is unit.
-        none when StateType == {tuple, []} ->
-            Funs#{ InitName => #{attrs  => [],
-                                 args   => [],
-                                 return => {tuple, []},
-                                 body   => {tuple, []}} };
-        none -> fcode_error(missing_init_function);
-        _    -> Funs
-    end.
+    InitFun = #{ args := InitArgs } =
+        case maps:get(InitName, Funs, none) of
+            none -> #{ attrs => [], args => [], return => {tuple, []}, body => {tuple, []} };
+            Info -> Info
+        end,
+    Vars = [ {var, X} || {X, _} <- InitArgs ],
+    Funs#{ init => InitFun#{ return => {tuple, []},
+                             body   => {builtin, set_state, [{def, InitName, Vars}]} } }.
 
 %% -- Event function --
 
@@ -966,13 +924,12 @@ lambda_lift_expr({Tag, F, Ar}) when Tag == def_u; Tag == builtin_u ->
                def_u     -> {def, F, Args}
            end,
     make_closure([], Xs, Body);
-lambda_lift_expr({remote_u, ArgsT, RetT, Ct, F}) ->
+lambda_lift_expr({remote_u, Ct, F, Ar}) ->
     FVs  = free_vars(Ct),
     Ct1  = lambda_lift_expr(Ct),
-    GasAndValueArgs = 2,
-    Xs   = [ lists:concat(["arg", I]) || I <- lists:seq(1, length(ArgsT) + GasAndValueArgs) ],
+    Xs   = [ lists:concat(["arg", I]) || I <- lists:seq(1, Ar) ],
     Args = [{var, X} || X <- Xs],
-    make_closure(FVs, Xs, {remote, ArgsT, RetT, Ct1, F, Args});
+    make_closure(FVs, Xs, {remote, Ct1, F, Args});
 lambda_lift_expr(Expr) ->
     case Expr of
         {lit, _}               -> Expr;
@@ -981,7 +938,7 @@ lambda_lift_expr(Expr) ->
         {closure, _, _}        -> Expr;
         {def, D, As}           -> {def, D, lambda_lift_exprs(As)};
         {builtin, B, As}       -> {builtin, B, lambda_lift_exprs(As)};
-        {remote, ArgsT, RetT, Ct, F, As} -> {remote, ArgsT, RetT, lambda_lift_expr(Ct), F, lambda_lift_exprs(As)};
+        {remote, Ct, F, As}    -> {remote, lambda_lift_expr(Ct), F, lambda_lift_exprs(As)};
         {con, Ar, C, As}       -> {con, Ar, C, lambda_lift_exprs(As)};
         {tuple, As}            -> {tuple, lambda_lift_exprs(As)};
         {proj, A, I}           -> {proj, lambda_lift_expr(A), I};
@@ -1007,16 +964,13 @@ lambda_lift_exprs(As) -> [lambda_lift_expr(A) || A <- As].
 
 -spec optimize_fcode(fcode()) -> fcode().
 optimize_fcode(Code = #{ functions := Funs }) ->
-    Code1 = Code#{ functions := maps:map(fun(Name, Def) -> optimize_fun(Code, Name, Def) end, Funs) },
-    eliminate_dead_code(Code1).
+    Code#{ functions := maps:map(fun(Name, Def) -> optimize_fun(Code, Name, Def) end, Funs) }.
 
 -spec optimize_fun(fcode(), fun_name(), fun_def()) -> fun_def().
 optimize_fun(Fcode, Fun, Def = #{ body := Body }) ->
     %% io:format("Optimizing ~p =\n~s\n", [_Fun, prettypr:format(pp_fexpr(_Body))]),
     Def#{ body := inliner(Fcode, Fun, Body) }.
 
-%% --- Inlining ---
-
 -spec inliner(fcode(), fun_name(), fexpr()) -> fexpr().
 inliner(Fcode, Fun, {def, Fun1, Args} = E) when Fun1 /= Fun ->
     case should_inline(Fcode, Fun1) of
@@ -1029,33 +983,6 @@ should_inline(_Fcode, _Fun1) -> false == list_to_atom("true").  %% Dialyzer
 
 inline(_Fcode, Fun, Args) -> {def, Fun, Args}. %% TODO
 
-%% --- Deadcode elimination ---
-
--spec eliminate_dead_code(fcode()) -> fcode().
-eliminate_dead_code(Code = #{ functions := Funs }) ->
-    UsedFuns = used_functions(Funs),
-    Code#{ functions := maps:filter(fun(Name, _) -> maps:is_key(Name, UsedFuns) end,
-                                    Funs) }.
-
--spec used_functions(#{ fun_name() => fun_def() }) -> #{ fun_name() => true }.
-used_functions(Funs) ->
-    Exported = [ Fun || {Fun, #{ attrs := Attrs }} <- maps:to_list(Funs),
-                        not lists:member(private, Attrs) ],
-    used_functions(#{}, Exported, Funs).
-
-used_functions(Used, [], _) -> Used;
-used_functions(Used, [Name | Rest], Defs) ->
-    case maps:is_key(Name, Used) of
-        true  -> used_functions(Used, Rest, Defs);
-        false ->
-            New =
-                case maps:get(Name, Defs, undef) of
-                    undef             -> []; %% We might be compiling a stub
-                    #{ body := Body } -> used_defs(Body)
-                end,
-            used_functions(Used#{ Name => true }, New ++ Rest, Defs)
-    end.
-
 %% -- Helper functions -------------------------------------------------------
 
 %% -- Types --
@@ -1206,8 +1133,8 @@ free_vars(Expr) ->
         nil                  -> [];
         {def, _, As}         -> free_vars(As);
         {def_u, _, _}        -> [];
-        {remote, _, _, Ct, _, As} -> free_vars([Ct | As]);
-        {remote_u, _, _, Ct, _}   -> free_vars(Ct);
+        {remote, Ct, _, As}  -> free_vars([Ct | As]);
+        {remote_u, Ct, _, _} -> free_vars(Ct);
         {builtin, _, As}     -> free_vars(As);
         {builtin_u, _, _}    -> [];
         {con, _, _, As}      -> free_vars(As);
@@ -1225,34 +1152,6 @@ free_vars(Expr) ->
         {'case', P, A}       -> free_vars(A) -- lists:sort(fsplit_pat_vars(P))
     end.
 
-used_defs(Xs) when is_list(Xs) ->
-    lists:umerge([ used_defs(X) || X <- Xs ]);
-used_defs(Expr) ->
-    case Expr of
-        {var, _}             -> [];
-        {lit, _}             -> [];
-        nil                  -> [];
-        {def, F, As}         -> lists:umerge([F], used_defs(As));
-        {def_u, F, _}        -> [F];
-        {remote, _, _, Ct, _, As} -> used_defs([Ct | As]);
-        {remote_u, _, _, Ct, _}   -> used_defs(Ct);
-        {builtin, _, As}     -> used_defs(As);
-        {builtin_u, _, _}    -> [];
-        {con, _, _, As}      -> used_defs(As);
-        {tuple, As}          -> used_defs(As);
-        {proj, A, _}         -> used_defs(A);
-        {set_proj, A, _, B}  -> used_defs([A, B]);
-        {op, _, As}          -> used_defs(As);
-        {'let', _, A, B}     -> used_defs([A, B]);
-        {funcall, A, Bs}     -> used_defs([A | Bs]);
-        {lam, _, B}          -> used_defs(B);
-        {closure, F, A}      -> lists:umerge([F], used_defs(A));
-        {switch, A}          -> used_defs(A);
-        {split, _, _, As}    -> used_defs(As);
-        {nosplit, A}         -> used_defs(A);
-        {'case', _, A}       -> used_defs(A)
-    end.
-
 get_named_args(NamedArgsT, Args) ->
     IsNamed = fun({named_arg, _, _, _}) -> true;
                  (_) -> false end,
@@ -1278,8 +1177,8 @@ rename(Ren, Expr) ->
         {def_u, _, _}         -> Expr;
         {builtin, B, Es}      -> {builtin, B, [rename(Ren, E) || E <- Es]};
         {builtin_u, _, _}     -> Expr;
-        {remote, ArgsT, RetT, Ct, F, Es} -> {remote,   ArgsT, RetT, rename(Ren, Ct), F, [rename(Ren, E) || E <- Es]};
-        {remote_u, ArgsT, RetT, Ct, F}   -> {remote_u, ArgsT, RetT, rename(Ren, Ct), F};
+        {remote, Ct, F, Es}   -> {remote, rename(Ren, Ct), F, [rename(Ren, E) || E <- Es]};
+        {remote_u, Ct, F, Ar} -> {remote_u, rename(Ren, Ct), F, Ar};
         {con, Ar, I, Es}      -> {con, Ar, I, [rename(Ren, E) || E <- Es]};
         {tuple, Es}           -> {tuple, [rename(Ren, E) || E <- Es]};
         {proj, E, I}          -> {proj, rename(Ren, E), I};
@@ -1383,9 +1282,7 @@ field_value({field_t, _, {id, _, X}, _}, Fields) ->
 %% -- Attributes --
 
 get_attributes(Ann) ->
-    [stateful || proplists:get_value(stateful, Ann, false)] ++
-    [payable  || proplists:get_value(payable, Ann, false)] ++
-    [private  || not proplists:get_value(entrypoint, Ann, false)].
+    [stateful || proplists:get_value(stateful, Ann, false)].
 
 %% -- Basic utilities --
 
@@ -1495,10 +1392,10 @@ pp_fexpr({builtin_u, B, N}) ->
     pp_beside([pp_text(B), pp_text("/"), pp_text(N)]);
 pp_fexpr({builtin, B, As}) ->
     pp_call(pp_text(B), As);
-pp_fexpr({remote_u, ArgsT, RetT, Ct, Fun}) ->
-    pp_beside([pp_fexpr(Ct), pp_text("."), pp_fun_name(Fun), pp_text(" : "), pp_ftype({function, ArgsT, RetT})]);
-pp_fexpr({remote, ArgsT, RetT, Ct, Fun, As}) ->
-    pp_call(pp_parens(pp_beside([pp_fexpr(Ct), pp_text("."), pp_fun_name(Fun), pp_text(" : "), pp_ftype({function, ArgsT, RetT})])), As);
+pp_fexpr({remote_u, Ct, Fun, Ar}) ->
+    pp_beside([pp_fexpr(Ct), pp_text("."), pp_fun_name(Fun), pp_text("/"), pp_int(Ar)]);
+pp_fexpr({remote, Ct, Fun, As}) ->
+    pp_call(pp_beside([pp_fexpr(Ct), pp_text("."), pp_fun_name(Fun)]), As);
 pp_fexpr({funcall, Fun, As}) ->
     pp_call(pp_fexpr(Fun), As);
 pp_fexpr({switch, Split}) -> pp_split(Split).
@@ -1551,4 +1448,3 @@ pp_pat(Pat)              -> pp_fexpr(Pat).
 is_infix(Op) ->
     C = hd(atom_to_list(Op)),
     C < $a orelse C > $z.
-

src/aeso_ast_to_icode.erl

@@ -17,15 +17,11 @@
 
 -spec convert_typed(aeso_syntax:ast(), list()) -> aeso_icode:icode().
 convert_typed(TypedTree, Options) ->
-    {Payable, Name} =
-        case lists:last(TypedTree) of
-            {contract, Attrs, {con, _, Con}, _} ->
-                {proplists:get_value(payable, Attrs, false), Con};
-            _ ->
-                gen_error(last_declaration_must_be_contract)
+    Name = case lists:last(TypedTree) of
+               {contract, _, {con, _, Con}, _} -> Con;
+               _ -> gen_error(last_declaration_must_be_contract)
            end,
-    NewIcode = aeso_icode:set_payable(Payable,
-                   aeso_icode:set_name(Name, aeso_icode:new(Options))),
+    NewIcode = aeso_icode:set_name(Name, aeso_icode:new(Options)),
     Icode    = code(TypedTree, NewIcode, Options),
     deadcode_elimination(Icode).
 
@@ -91,7 +87,6 @@ contract_to_icode([{type_def, _Attrib, Id = {id, _, Name}, Args, Def} | Rest],
     contract_to_icode(Rest, Icode2);
 contract_to_icode([{letfun, Attrib, Name, Args, _What, Body={typed,_,_,T}}|Rest], Icode) ->
     FunAttrs = [ stateful || proplists:get_value(stateful, Attrib, false) ] ++
-               [ payable  || proplists:get_value(payable, Attrib, false) ] ++
                [ private  || is_private(Attrib, Icode) ],
     %% TODO: Handle types
     FunName = ast_id(Name),
@@ -268,10 +263,10 @@ ast_body(?qid_app(["AENS", "preclaim"], Args, _, _), Icode) ->
               [word, word, sign_t()], {tuple, []});
 
 ast_body(?qid_app(["AENS", "claim"], Args, _, _), Icode) ->
-    {Sign, [Addr, Name, Salt]} = get_signature_arg(Args),
+    {Sign, [Addr, Name, Salt, NameFee]} = get_signature_arg(Args),
     prim_call(?PRIM_CALL_AENS_CLAIM, #integer{value = 0},
-              [ast_body(Addr, Icode), ast_body(Name, Icode), ast_body(Salt, Icode), ast_body(Sign, Icode)],
-              [word, string, word, sign_t()], {tuple, []});
+              [ast_body(Addr, Icode), ast_body(Name, Icode), ast_body(Salt, Icode), ast_body(Sign, Icode), ast_body(NameFee, Icode)],
+              [word, string, word, sign_t(), word], {tuple, []});
 
 ast_body(?qid_app(["AENS", "transfer"], Args, _, _), Icode) ->
     {Sign, [FromAddr, ToAddr, Name]} = get_signature_arg(Args),
@@ -355,26 +350,16 @@ ast_body({map, Ann, Map, [Upd | Upds]}, Icode) ->
     ast_body({map, Ann, {map, Ann, Map, [Upd]}, Upds}, Icode);
 
 %% Crypto
-ast_body(?qid_app(["Crypto", "verify_sig"], [Msg, PK, Sig], _, _), Icode) ->
-    prim_call(?PRIM_CALL_CRYPTO_VERIFY_SIG, #integer{value = 0},
+ast_body(?qid_app(["Crypto", "ecverify"], [Msg, PK, Sig], _, _), Icode) ->
+    prim_call(?PRIM_CALL_CRYPTO_ECVERIFY, #integer{value = 0},
               [ast_body(Msg, Icode), ast_body(PK, Icode), ast_body(Sig, Icode)],
               [word, word, sign_t()], word);
 
-ast_body(?qid_app(["Crypto", "verify_sig_secp256k1"], [Msg, PK, Sig], _, _), Icode) ->
-    prim_call(?PRIM_CALL_CRYPTO_VERIFY_SIG_SECP256K1, #integer{value = 0},
+ast_body(?qid_app(["Crypto", "ecverify_secp256k1"], [Msg, PK, Sig], _, _), Icode) ->
+    prim_call(?PRIM_CALL_CRYPTO_ECVERIFY_SECP256K1, #integer{value = 0},
               [ast_body(Msg, Icode), ast_body(PK, Icode), ast_body(Sig, Icode)],
               [bytes_t(32), bytes_t(64), bytes_t(64)], word);
 
-ast_body(?qid_app(["Crypto", "ecverify_secp256k1"], [Msg, Addr, Sig], _, _), Icode) ->
-    prim_call(?PRIM_CALL_CRYPTO_ECVERIFY_SECP256K1, #integer{value = 0},
-              [ast_body(Msg, Icode), ast_body(Addr, Icode), ast_body(Sig, Icode)],
-              [word, bytes_t(20), bytes_t(65)], word);
-
-ast_body(?qid_app(["Crypto", "ecrecover_secp256k1"], [Msg, Sig], _, _), Icode) ->
-    prim_call(?PRIM_CALL_CRYPTO_ECRECOVER_SECP256K1, #integer{value = 0},
-              [ast_body(Msg, Icode), ast_body(Sig, Icode)],
-              [word, bytes_t(65)], aeso_icode:option_typerep(bytes_t(20)));
-
 ast_body(?qid_app(["Crypto", "sha3"], [Term], [Type], _), Icode) ->
     generic_hash_primop(?PRIM_CALL_CRYPTO_SHA3, Term, Type, Icode);
 ast_body(?qid_app(["Crypto", "sha256"], [Term], [Type], _), Icode) ->
@@ -438,9 +423,6 @@ ast_body(?qid_app(["Address", "is_oracle"], [Addr], _, _), Icode) ->
 ast_body(?qid_app(["Address", "is_contract"], [Addr], _, _), Icode) ->
     prim_call(?PRIM_CALL_ADDR_IS_CONTRACT, #integer{value = 0},
               [ast_body(Addr, Icode)], [word], word);
-ast_body(?qid_app(["Address", "is_payable"], [Addr], _, _), Icode) ->
-    prim_call(?PRIM_CALL_ADDR_IS_PAYABLE, #integer{value = 0},
-              [ast_body(Addr, Icode)], [word], word);
 
 ast_body(?qid_app(["Bytes", "to_int"], [Bytes], _, _), Icode) ->
     {typed, _, _, {bytes_t, _, N}} = Bytes,
@@ -537,24 +519,6 @@ ast_body({app,As,Fun,Args}, Icode) ->
             #funcall{function=ast_body(Fun, Icode),
                      args=[ast_body(A, Icode) || A <- Args]}
     end;
-ast_body({list_comp, _, Yield, []}, Icode) ->
-    #list{elems = [ast_body(Yield, Icode)]};
-ast_body({list_comp, As, Yield, [{comprehension_bind, {typed, Arg, ArgType}, BindExpr}|Rest]}, Icode) ->
-    #funcall
-        { function = #var_ref{ name = ["List", "flat_map"] }
-        , args =
-              [ #lambda{ args=[#arg{name = ast_id(Arg), type = ast_type(ArgType, Icode)}]
-                       , body = ast_body({list_comp, As, Yield, Rest}, Icode)
-                       }
-              , ast_body(BindExpr, Icode)
-              ]
-        };
-ast_body({list_comp, As, Yield, [{comprehension_if, AsIF, Cond}|Rest]}, Icode) ->
-    ast_body({'if', AsIF, Cond, {list_comp, As, Yield, Rest}, {list, As, []}}, Icode);
-ast_body({list_comp, As, Yield, [LV = {letval, _, _, _, _}|Rest]}, Icode) ->
-    ast_body({block, As, [LV, {list_comp, As, Yield, Rest}]}, Icode);
-ast_body({list_comp, As, Yield, [LF = {letfun, _, _, _, _, _}|Rest]}, Icode) ->
-    ast_body({block, As, [LF, {list_comp, As, Yield, Rest}]}, Icode);
 ast_body({'if',_,Dec,Then,Else}, Icode) ->
     #ifte{decision = ast_body(Dec, Icode)
          ,then     = ast_body(Then, Icode)

src/aeso_compiler.erl

@@ -36,7 +36,6 @@
                 | pp_assembler
                 | pp_bytecode
                 | no_code
-                | no_implicit_stdlib
                 | {backend, aevm | fate}
                 | {include, {file_system, [string()]} |
                             {explicit_files, #{string() => binary()}}}
@@ -123,8 +122,7 @@ from_string1(aevm, ContractString, Options) ->
            compiler_version => Version,
            contract_source => ContractString,
            type_info => TypeInfo,
-           abi_version => aeb_aevm_abi:abi_version(),
-           payable => maps:get(payable, Icode)
+           abi_version => aeb_aevm_abi:abi_version()
           }};
 from_string1(fate, ContractString, Options) ->
     #{fcode := FCode} = string_to_code(ContractString, Options),
@@ -136,22 +134,12 @@ from_string1(fate, ContractString, Options) ->
            contract_source => ContractString,
            type_info => [],
            fate_code => FateCode,
-           abi_version => aeb_fate_abi:abi_version(),
-           payable => maps:get(payable, FCode)
+           abi_version => aeb_fate_abi:abi_version()
           }}.
 
 -spec string_to_code(string(), options()) -> map().
 string_to_code(ContractString, Options) ->
-    Ast = case lists:member(no_implicit_stdlib, Options) of
-              true -> parse(ContractString, Options);
-              false ->
-                  IncludedSTD = sets:from_list(
-                                  [aeso_parser:hash_include(F, C)
-                                   || {F, C} <- aeso_stdlib:stdlib_list()]),
-                  InitAst = parse(ContractString, IncludedSTD, Options),
-                  STD = parse_stdlib(),
-                  STD ++ InitAst
-          end,
+    Ast = parse(ContractString, Options),
     pp_sophia_code(Ast, Options),
     pp_ast(Ast, Options),
     {TypeEnv, TypedAst} = aeso_ast_infer_types:infer(Ast, [return_env]),
@@ -317,7 +305,7 @@ to_sophia_value(_, _, revert, Data, Options) ->
             {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}}
     end;
 to_sophia_value(ContractString, FunName, ok, Data, Options0) ->
-    Options = [no_implicit_stdlib, no_code | Options0],
+    Options = [no_code | Options0],
     try
         Code = string_to_code(ContractString, Options),
         #{ typed_ast := TypedAst, type_env  := TypeEnv} = Code,
@@ -378,7 +366,7 @@ create_calldata(Code, Fun, Args) ->
                              {ok, binary()}
                              | {error, term()}.
 create_calldata(Code, Fun, Args, Options0) ->
-    Options = [no_implicit_stdlib, no_code | Options0],
+    Options = [no_code | Options0],
     case proplists:get_value(backend, Options, aevm) of
         aevm ->
             case check_call(Code, Fun, Args, Options) of
@@ -401,7 +389,7 @@ decode_calldata(ContractString, FunName, Calldata) ->
     decode_calldata(ContractString, FunName, Calldata, [{backend, aevm}]).
 
 decode_calldata(ContractString, FunName, Calldata, Options0) ->
-    Options = [no_implicit_stdlib, no_code | Options0],
+    Options = [no_code | Options0],
     try
         Code = string_to_code(ContractString, Options),
         #{ typed_ast := TypedAst, type_env  := TypeEnv} = Code,
@@ -551,9 +539,8 @@ to_bytecode([], _) -> [].
 
 extract_type_info(#{functions := Functions} =_Icode) ->
     ArgTypesOnly = fun(As) -> [ T || {_, T} <- As ] end,
-    Payable = fun(Attrs) -> proplists:get_value(payable, Attrs, false) end,
     TypeInfo = [aeb_aevm_abi:function_type_info(list_to_binary(lists:last(Name)),
-                                            Payable(Attrs), ArgTypesOnly(Args), TypeRep)
+                                            ArgTypesOnly(Args), TypeRep)
                 || {Name, Attrs, Args,_Body, TypeRep} <- Functions,
                    not is_tuple(Name),
                    not lists:member(private, Attrs)
@@ -577,16 +564,9 @@ pp(Code, Options, Option, PPFun) ->
             ok
     end.
 
-%% -------------------------------------------------------------------
 
--spec parse_stdlib() -> none() | aeso_syntax:ast().
-parse_stdlib() ->
-    lists:foldr(
-      fun ({Lib, LibCode}, Acc) ->
-              parse(LibCode, [{src_file, binary_to_list(Lib)}]) ++ Acc
-      end,
-      [],
-      aeso_stdlib:stdlib_list()).
+%% -------------------------------------------------------------------
+%% TODO: Tempoary parser hook below...
 
 sophia_type_to_typerep(String) ->
     {ok, Ast} = aeso_parser:type(String),
@@ -595,14 +575,9 @@ sophia_type_to_typerep(String) ->
     catch _:_ -> {error, bad_type}
     end.
 
--spec parse(string(), aeso_compiler:options()) -> none() | aeso_syntax:ast().
 parse(Text, Options) ->
-    parse(Text, sets:new(), Options).
-
--spec parse(string(), sets:set(), aeso_compiler:options()) -> none() | aeso_syntax:ast().
-parse(Text, Included, Options) ->
     %% Try and return something sensible here!
-    case aeso_parser:string(Text, Included, Options) of
+    case aeso_parser:string(Text, Options) of
         %% Yay, it worked!
         {ok, Contract} -> Contract;
         %% Scan errors.
@@ -621,7 +596,6 @@ parse(Text, Included, Options) ->
             parse_error(Pos, io_lib:format("could not find include file '~s'", [File]))
     end.
 
--spec parse_error(aeso_parse_lib:pos(), string()) -> none().
 parse_error(Pos, ErrorString) ->
     Error = io_lib:format("~s: ~s", [pos_error(Pos), ErrorString]),
     error({parse_errors, [Error]}).

src/aeso_fcode_to_fate.erl

@@ -98,20 +98,17 @@
      Op =:= 'SHA3'            orelse
      Op =:= 'SHA256'          orelse
      Op =:= 'BLAKE2B'         orelse
-     Op =:= 'VERIFY_SIG'           orelse
-     Op =:= 'VERIFY_SIG_SECP256K1' orelse
-     Op =:= 'ECVERIFY_SECP256K1'   orelse
-     Op =:= 'ECRECOVER_SECP256K1'  orelse
-     Op =:= 'CONTRACT_TO_ADDRESS'  orelse
-     Op =:= 'AUTH_TX_HASH'         orelse
-     Op =:= 'BYTES_TO_INT'         orelse
-     Op =:= 'BYTES_TO_STR'         orelse
-     Op =:= 'ORACLE_CHECK'         orelse
-     Op =:= 'ORACLE_CHECK_QUERY'   orelse
-     Op =:= 'IS_ORACLE'            orelse
-     Op =:= 'IS_CONTRACT'          orelse
-     Op =:= 'IS_PAYABLE'           orelse
-     Op =:= 'CREATOR'              orelse
+     Op =:= 'ECVERIFY'        orelse
+     Op =:= 'ECVERIFY_SECP256K1' orelse
+     Op =:= 'CONTRACT_TO_ADDRESS' orelse
+     Op =:= 'AUTH_TX_HASH'    orelse
+     Op =:= 'BYTES_TO_INT'    orelse
+     Op =:= 'BYTES_TO_STR'    orelse
+     Op =:= 'ORACLE_CHECK'    orelse
+     Op =:= 'ORACLE_CHECK_QUERY' orelse
+     Op =:= 'IS_ORACLE'       orelse
+     Op =:= 'IS_CONTRACT'     orelse
+     Op =:= 'CREATOR'         orelse
      false)).
 
 -record(env, { contract, vars = [], locals = [], tailpos = true }).
@@ -130,10 +127,12 @@ debug(Tag, Options, Fmt, Args) ->
 %% @doc Main entry point.
 compile(FCode, Options) ->
     #{ contract_name := ContractName,
+       state_type    := StateType,
        functions     := Functions } = FCode,
     SFuns  = functions_to_scode(ContractName, Functions, Options),
     SFuns1 = optimize_scode(SFuns, Options),
-    FateCode = to_basic_blocks(SFuns1),
+    SFuns2 = add_default_init_function(SFuns1, StateType),
+    FateCode = to_basic_blocks(SFuns2),
     debug(compile, Options, "~s\n", [aeb_fate_asm:pp(FateCode)]),
     FateCode.
 
@@ -148,17 +147,15 @@ make_function_name({local_fun, Xs})    -> list_to_binary("." ++ string:join(Xs,
 functions_to_scode(ContractName, Functions, Options) ->
     FunNames = maps:keys(Functions),
     maps:from_list(
-        [ {make_function_name(Name), function_to_scode(ContractName, FunNames, Name, Attrs, Args, Body, Type, Options)}
+        [ {make_function_name(Name), function_to_scode(ContractName, FunNames, Name, Args, Body, Type, Options)}
         || {Name, #{args   := Args,
                     body   := Body,
-                    attrs  := Attrs,
                     return := Type}} <- maps:to_list(Functions)]).
 
-function_to_scode(ContractName, Functions, _Name, Attrs0, Args, Body, ResType, _Options) ->
+function_to_scode(ContractName, Functions, _Name, Args, Body, ResType, _Options) ->
     {ArgTypes, ResType1} = typesig_to_scode(Args, ResType),
-    Attrs = Attrs0 -- [stateful], %% Only track private and payable from here.
-    SCode = to_scode(init_env(ContractName, Functions, Args), Body),
-    {Attrs, {ArgTypes, ResType1}, SCode}.
+    SCode    = to_scode(init_env(ContractName, Functions, Args), Body),
+    {{ArgTypes, ResType1}, SCode}.
 
 -define(tvars, '$tvars').
 
@@ -194,6 +191,21 @@ type_to_scode({tvar, X}) ->
         J -> {tvar, J}
     end.
 
+add_default_init_function(SFuns, StateType) when StateType /= {tuple, []} ->
+    %% Only add default if the type is unit.
+    SFuns;
+add_default_init_function(SFuns, {tuple, []}) ->
+    %% Only add default if the init function is not present
+    InitName = make_function_name({entrypoint, <<"init">>}),
+    case maps:find(InitName, SFuns) of
+        {ok, _} ->
+            SFuns;
+        error ->
+            Sig = {[], {tuple, []}},
+            Body = [tuple(0)],
+            SFuns#{ InitName => {Sig, Body} }
+    end.
+
 %% -- Phase I ----------------------------------------------------------------
 %%  Icode to structured assembly
 
@@ -315,19 +327,21 @@ to_scode(Env, {funcall, Fun, Args}) ->
 to_scode(Env, {builtin, B, Args}) ->
     builtin_to_scode(Env, B, Args);
 
-to_scode(Env, {remote, ArgsT, RetT, Ct, Fun, [Gas, Value | Args]}) ->
+to_scode(Env, {remote, Ct, Fun, [{builtin, call_gas_left, _}, Value | Args]}) ->
+    %% Gas is not limited.
     Lbl = make_function_id(Fun),
-    {ArgTypes, RetType0} = typesig_to_scode([{"_", T} || T <- ArgsT], RetT),
-    ArgType = ?i(aeb_fate_data:make_typerep({tuple, ArgTypes})),
-    RetType = ?i(aeb_fate_data:make_typerep(RetType0)),
-    case Gas of
-        {builtin, call_gas_left, _} ->
-            Call = aeb_fate_ops:call_r(?a, Lbl, ArgType, RetType, ?a),
-            call_to_scode(Env, Call, [Ct, Value | Args]);
-        _ ->
-            Call = aeb_fate_ops:call_gr(?a, Lbl, ArgType, RetType, ?a, ?a),
-            call_to_scode(Env, Call, [Ct, Value, Gas | Args])
-    end;
+    Call = if Env#env.tailpos -> aeb_fate_ops:call_tr(?a, Lbl, ?a);
+              true            -> aeb_fate_ops:call_r(?a, Lbl, ?a)
+           end,
+    call_to_scode(Env, Call, [Ct, Value | Args]);
+
+to_scode(Env, {remote, Ct, Fun, [Gas, Value | Args]}) ->
+    %% Gas is limited.
+    Lbl = make_function_id(Fun),
+    Call = if Env#env.tailpos -> aeb_fate_ops:call_gtr(?a, Lbl, ?a, ?a);
+              true            -> aeb_fate_ops:call_gr(?a, Lbl, ?a, ?a)
+           end,
+    call_to_scode(Env, Call, [Ct, Value, Gas | Args]);
 
 to_scode(Env, {closure, Fun, FVs}) ->
     to_scode(Env, {tuple, [{lit, {string, make_function_id(Fun)}}, FVs]});
@@ -528,15 +542,13 @@ builtin_to_scode(Env, address_is_oracle, [_] = Args) ->
     call_to_scode(Env, aeb_fate_ops:is_oracle(?a, ?a), Args);
 builtin_to_scode(Env, address_is_contract, [_] = Args) ->
     call_to_scode(Env, aeb_fate_ops:is_contract(?a, ?a), Args);
-builtin_to_scode(Env, address_is_payable, [_] = Args) ->
-    call_to_scode(Env, aeb_fate_ops:is_payable(?a, ?a), Args);
 builtin_to_scode(Env, aens_resolve, [_Name, _Key, _Type] = Args) ->
     call_to_scode(Env, aeb_fate_ops:aens_resolve(?a, ?a, ?a, ?a), Args);
 builtin_to_scode(Env, aens_preclaim, [_Sign, _Account, _Hash] = Args) ->
     call_to_scode(Env, [aeb_fate_ops:aens_preclaim(?a, ?a, ?a),
                         tuple(0)], Args);
-builtin_to_scode(Env, aens_claim, [_Sign, _Account, _NameString, _Salt] = Args) ->
-    call_to_scode(Env, [aeb_fate_ops:aens_claim(?a, ?a, ?a, ?a),
+builtin_to_scode(Env, aens_claim, [_Sign, _Account, _NameString, _Salt, _NameFee] = Args) ->
+    call_to_scode(Env, [aeb_fate_ops:aens_claim(?a, ?a, ?a, ?a, ?a),
                         tuple(0)], Args);
 builtin_to_scode(Env, aens_transfer, [_Sign, _From, _To, _Name] = Args) ->
     call_to_scode(Env, [aeb_fate_ops:aens_transfer(?a, ?a, ?a, ?a),
@@ -583,17 +595,15 @@ op_to_scode(bits_union)        -> aeb_fate_ops:bits_or(?a, ?a, ?a);
 op_to_scode(bits_difference)   -> aeb_fate_ops:bits_diff(?a, ?a, ?a);
 op_to_scode(address_to_str)    -> aeb_fate_ops:addr_to_str(?a, ?a);
 op_to_scode(int_to_str)        -> aeb_fate_ops:int_to_str(?a, ?a);
-op_to_scode(contract_to_address)         -> aeb_fate_ops:contract_to_address(?a, ?a);
-op_to_scode(crypto_verify_sig)           -> aeb_fate_ops:verify_sig(?a, ?a, ?a, ?a);
-op_to_scode(crypto_verify_sig_secp256k1) -> aeb_fate_ops:verify_sig_secp256k1(?a, ?a, ?a, ?a);
-op_to_scode(crypto_ecverify_secp256k1)   -> aeb_fate_ops:ecverify_secp256k1(?a, ?a, ?a, ?a);
-op_to_scode(crypto_ecrecover_secp256k1)  -> aeb_fate_ops:ecrecover_secp256k1(?a, ?a, ?a);
-op_to_scode(crypto_sha3)                 -> aeb_fate_ops:sha3(?a, ?a);
-op_to_scode(crypto_sha256)               -> aeb_fate_ops:sha256(?a, ?a);
-op_to_scode(crypto_blake2b)              -> aeb_fate_ops:blake2b(?a, ?a);
-op_to_scode(string_sha3)                 -> aeb_fate_ops:sha3(?a, ?a);
-op_to_scode(string_sha256)               -> aeb_fate_ops:sha256(?a, ?a);
-op_to_scode(string_blake2b)              -> aeb_fate_ops:blake2b(?a, ?a).
+op_to_scode(contract_to_address)       -> aeb_fate_ops:contract_to_address(?a, ?a);
+op_to_scode(crypto_ecverify)           -> aeb_fate_ops:ecverify(?a, ?a, ?a, ?a);
+op_to_scode(crypto_ecverify_secp256k1) -> aeb_fate_ops:ecverify_secp256k1(?a, ?a, ?a, ?a);
+op_to_scode(crypto_sha3)               -> aeb_fate_ops:sha3(?a, ?a);
+op_to_scode(crypto_sha256)             -> aeb_fate_ops:sha256(?a, ?a);
+op_to_scode(crypto_blake2b)            -> aeb_fate_ops:blake2b(?a, ?a);
+op_to_scode(string_sha3)               -> aeb_fate_ops:sha3(?a, ?a);
+op_to_scode(string_sha256)             -> aeb_fate_ops:sha256(?a, ?a);
+op_to_scode(string_blake2b)            -> aeb_fate_ops:blake2b(?a, ?a).
 
 %% PUSH and STORE ?a are the same, so we use STORE to make optimizations
 %% easier, and specialize to PUSH (which is cheaper) at the end.
@@ -618,12 +628,12 @@ flatten_s(I) -> I.
 
 -define(MAX_SIMPL_ITERATIONS, 10).
 
-optimize_fun(_Funs, Name, {Attrs, Sig, Code}, Options) ->
+optimize_fun(_Funs, Name, {{Args, Res}, Code}, Options) ->
     Code0 = flatten(Code),
     debug(opt, Options, "Optimizing ~s\n", [Name]),
     Code1 = simpl_loop(0, Code0, Options),
     Code2 = desugar(Code1),
-    {Attrs, Sig, Code2}.
+    {{Args, Res}, Code2}.
 
 simpl_loop(N, Code, Options) when N >= ?MAX_SIMPL_ITERATIONS ->
     debug(opt, Options, "  No simpl_loop fixed_point after ~p iterations.\n\n", [N]),
@@ -737,9 +747,11 @@ attributes(I) ->
         'RETURN'                              -> Impure(pc, []);
         {'RETURNR', A}                        -> Impure(pc, A);
         {'CALL', _}                           -> Impure(?a, []);
-        {'CALL_R', A, _, B, C, D}             -> Impure(?a, [A, B, C, D]);
-        {'CALL_GR', A, _, B, C, D, E}         -> Impure(?a, [A, B, C, D, E]);
+        {'CALL_R', A, _, B}                   -> Impure(?a, [A, B]);
+        {'CALL_GR', A, _, B, C}               -> Impure(?a, [A, B, C]);
         {'CALL_T', _}                         -> Impure(pc, []);
+        {'CALL_TR', A, _, B}                  -> Impure(pc, [A, B]);
+        {'CALL_GTR', A, _, B, C}              -> Impure(pc, [A, B, C]);
         {'CALL_VALUE', A}                     -> Pure(A, []);
         {'JUMP', _}                           -> Impure(pc, []);
         {'JUMPIF', A, _}                      -> Impure(pc, A);
@@ -813,10 +825,8 @@ attributes(I) ->
         {'SHA3', A, B}                        -> Pure(A, [B]);
         {'SHA256', A, B}                      -> Pure(A, [B]);
         {'BLAKE2B', A, B}                     -> Pure(A, [B]);
-        {'VERIFY_SIG', A, B, C, D}            -> Pure(A, [B, C, D]);
-        {'VERIFY_SIG_SECP256K1', A, B, C, D}  -> Pure(A, [B, C, D]);
+        {'ECVERIFY', A, B, C, D}              -> Pure(A, [B, C, D]);
         {'ECVERIFY_SECP256K1', A, B, C, D}    -> Pure(A, [B, C, D]);
-        {'ECRECOVER_SECP256K1', A, B, C}      -> Pure(A, [B, C]);
         {'CONTRACT_TO_ADDRESS', A, B}         -> Pure(A, [B]);
         {'AUTH_TX_HASH', A}                   -> Pure(A, []);
         {'BYTES_TO_INT', A, B}                -> Pure(A, [B]);
@@ -825,7 +835,6 @@ attributes(I) ->
         {'ORACLE_CHECK_QUERY', A, B, C, D, E} -> Impure(A, [B, C, D, E]);
         {'IS_ORACLE', A, B}                   -> Impure(A, [B]);
         {'IS_CONTRACT', A, B}                 -> Impure(A, [B]);
-        {'IS_PAYABLE', A, B}                  -> Impure(A, [B]);
         {'CREATOR', A}                        -> Pure(A, []);
         {'ADDRESS', A}                        -> Pure(A, []);
         {'BALANCE', A}                        -> Impure(A, []);
@@ -857,7 +866,7 @@ attributes(I) ->
         {'ORACLE_QUERY_FEE', A, B}            -> Impure(A, [B]);
         {'AENS_RESOLVE', A, B, C, D}          -> Impure(A, [B, C, D]);
         {'AENS_PRECLAIM', A, B, C}            -> Impure(none, [A, B, C]);
-        {'AENS_CLAIM', A, B, C, D}            -> Impure(none, [A, B, C, D]);
+        {'AENS_CLAIM', A, B, C, D, E}         -> Impure(none, [A, B, C, D, E]);
         'AENS_UPDATE'                         -> Impure(none, []);%% TODO
         {'AENS_TRANSFER', A, B, C, D}         -> Impure(none, [A, B, C, D]);
         {'AENS_REVOKE', A, B, C}              -> Impure(none, [A, B, C]);
@@ -1274,9 +1283,9 @@ desugar(I) -> [I].
 to_basic_blocks(Funs) ->
     to_basic_blocks(maps:to_list(Funs), aeb_fate_code:new()).
 
-to_basic_blocks([{Name, {Attrs, Sig, Code}}|Left], Acc) ->
+to_basic_blocks([{Name, {Sig, Code}}|Left], Acc) ->
     BB = bb(Name, Code ++ [aeb_fate_ops:return()]),
-    to_basic_blocks(Left, aeb_fate_code:insert_fun(Name, Attrs, Sig, BB, Acc));
+    to_basic_blocks(Left, aeb_fate_code:insert_fun(Name, Sig, BB, Acc));
 to_basic_blocks([], Acc) ->
     Acc.
 
@@ -1404,6 +1413,8 @@ reorder_blocks(Ref, Code, Blocks, Acc) ->
         ['RETURN'|_]          -> reorder_blocks(Blocks, Acc1);
         [{'RETURNR', _}|_]    -> reorder_blocks(Blocks, Acc1);
         [{'CALL_T', _}|_]     -> reorder_blocks(Blocks, Acc1);
+        [{'CALL_TR', _, _, _}|_] -> reorder_blocks(Blocks, Acc1);
+        [{'CALL_GTR', _, _, _}|_] -> reorder_blocks(Blocks, Acc1);
         [{'EXIT', _}|_]       -> reorder_blocks(Blocks, Acc1);
         [{'ABORT', _}|_]      -> reorder_blocks(Blocks, Acc1);
         [{switch, _, _}|_]    -> reorder_blocks(Blocks, Acc1);
@@ -1443,10 +1454,13 @@ chase_labels([L | Ls], Map, Live) ->
     chase_labels(New ++ Ls, Map, Live#{ L => true }).
 
 %% Replace PUSH, RETURN by RETURNR, drop returns after tail calls.
-tweak_returns(['RETURN', {'PUSH', A} | Code])          -> [{'RETURNR', A} | Code];
-tweak_returns(['RETURN' | Code = [{'CALL_T', _} | _]]) -> Code;
-tweak_returns(['RETURN' | Code = [{'ABORT', _} | _]])  -> Code;
-tweak_returns(['RETURN' | Code = [{'EXIT', _} | _]])   -> Code;
+tweak_returns(['RETURN', {'PUSH', A} | Code])                     -> [{'RETURNR', A} | Code];
+tweak_returns(['RETURN' | Code = [{'CALL_T', _} | _]])            -> Code;
+tweak_returns(['RETURN' | Code = [{'CALL_TR', _, _, _} | _]])     -> Code;
+tweak_returns(['RETURN' | Code = [{'CALL_GT', _} | _]])           -> Code;
+tweak_returns(['RETURN' | Code = [{'CALL_GTR', _, _, _, _} | _]]) -> Code;
+tweak_returns(['RETURN' | Code = [{'ABORT', _} | _]])             -> Code;
+tweak_returns(['RETURN' | Code = [{'EXIT', _} | _]])              -> Code;
 tweak_returns(Code) -> Code.
 
 %% -- Split basic blocks at CALL instructions --
@@ -1487,4 +1501,3 @@ set_labels(_, I) -> I.
 
 with_ixs(Xs) ->
     lists:zip(lists:seq(0, length(Xs) - 1), Xs).
-

src/aeso_icode.erl

@@ -13,7 +13,6 @@
          pp/1,
          set_name/2,
          set_namespace/2,
-         set_payable/2,
          enter_namespace/2,
          get_namespace/1,
          qualify/2,
@@ -49,7 +48,6 @@
                   , type_vars => #{ string() => aeb_aevm_data:type() }
                   , constructors => #{ [string()] => integer() }  %% name to tag
                   , options => [any()]
-                  , payable => boolean()
                   }.
 
 pp(Icode) ->
@@ -67,8 +65,7 @@ new(Options) ->
      , types => builtin_types()
      , type_vars => #{}
      , constructors => builtin_constructors()
-     , options => Options
-     , payable => false }.
+     , options => Options}.
 
 builtin_types() ->
     Word = fun([]) -> word end,
@@ -106,10 +103,6 @@ new_env() ->
 set_name(Name, Icode) ->
     maps:put(contract_name, Name, Icode).
 
--spec set_payable(boolean(), icode()) -> icode().
-set_payable(Payable, Icode) ->
-    maps:put(payable, Payable, Icode).
-
 -spec set_namespace(aeso_syntax:con() | aeso_syntax:qcon(), icode()) -> icode().
 set_namespace(NS, Icode) -> Icode#{ namespace => NS }.
 

src/aeso_parser.erl

@@ -6,8 +6,6 @@
 
 -export([string/1,
          string/2,
-         string/3,
-         hash_include/2,
          type/1]).
 
 -include("aeso_parse_lib.hrl").
@@ -16,24 +14,15 @@
                       | {error, {aeso_parse_lib:pos(), atom(), term()}}
                       | {error, {aeso_parse_lib:pos(), atom()}}.
 
--type include_hash() :: {string(), binary()}.
-
 -spec string(string()) -> parse_result().
 string(String) ->
-    string(String, sets:new(), []).
+    string(String, []).
 
 -spec string(string(), aeso_compiler:options()) -> parse_result().
 string(String, Opts) ->
-    case lists:keyfind(src_file, 1, Opts) of
-        {src_file, File} -> string(String, sets:add_element(File, sets:new()), Opts);
-        false -> string(String, sets:new(), Opts)
-    end.
-
--spec string(string(), sets:set(include_hash()), aeso_compiler:options()) -> parse_result().
-string(String, Included, Opts) ->
     case parse_and_scan(file(), String, Opts) of
         {ok, AST} ->
-            expand_includes(AST, Included, Opts);
+            expand_includes(AST, Opts);
         Err = {error, _} ->
             Err
     end.
@@ -57,7 +46,6 @@ decl() ->
     choice(
       %% Contract declaration
     [ ?RULE(keyword(contract),  con(), tok('='), maybe_block(decl()), {contract, _1, _2, _4})
-    , ?RULE(token(payable),     keyword(contract), con(), tok('='), maybe_block(decl()), add_modifiers([_1], {contract, _2, _3, _5}))
     , ?RULE(keyword(namespace), con(), tok('='), maybe_block(decl()), {namespace, _1, _2, _4})
     , ?RULE(keyword(include),   str(), {include, get_ann(_1), _2})
 
@@ -82,7 +70,7 @@ fun_or_entry() ->
             ?RULE(keyword(entrypoint), {entrypoint, _1})]).
 
 modifiers() ->
-    many(choice([token(stateful), token(payable), token(private), token(public)])).
+    many(choice([token(stateful), token(private), token(public)])).
 
 add_modifiers(Mods, Entry = {entrypoint, _}, Node) ->
     add_modifiers(Mods ++ [Entry], Node);
@@ -242,25 +230,11 @@ exprAtom() ->
         , {bool, keyword(false), false}
         , ?LET_P(Fs, brace_list(?LAZY_P(field_assignment())), record(Fs))
         , {list, [], bracket_list(Expr)}
-        , ?RULE(keyword('['), Expr, token('|'), comma_sep(comprehension_exp()), tok(']'), list_comp_e(_1, _2, _4))
         , ?RULE(tok('['), Expr, binop('..'), Expr, tok(']'), _3(_2, _4))
         , ?RULE(keyword('('), comma_sep(Expr), tok(')'), tuple_e(_1, _2))
         ])
     end).
 
-comprehension_exp() ->
-    ?LAZY_P(choice(
-      [ comprehension_bind()
-      , letdecl()
-      , comprehension_if()
-      ])).
-
-comprehension_if() ->
-    ?RULE(keyword('if'), parens(expr()), {comprehension_if, _1, _2}).
-
-comprehension_bind() ->
-    ?RULE(id(), tok('<-'), expr(), {comprehension_bind, _1, _3}).
-
 arg_expr() ->
     ?LAZY_P(
         choice([ ?RULE(id(), tok('='), expr(), {named_arg, [], _1, _3})
@@ -507,8 +481,6 @@ fun_t(Domains, Type) ->
 tuple_e(_Ann, [Expr]) -> Expr;  %% Not a tuple
 tuple_e(Ann, Exprs)   -> {tuple, Ann, Exprs}.
 
-list_comp_e(Ann, Expr, Binds) -> {list_comp, Ann, Expr, Binds}.
-
 -spec parse_pattern(aeso_syntax:expr()) -> aeso_parse_lib:parser(aeso_syntax:pat()).
 parse_pattern({app, Ann, Con = {'::', _}, Es}) ->
     {app, Ann, Con, lists:map(fun parse_pattern/1, Es)};
@@ -549,36 +521,26 @@ bad_expr_err(Reason, E) ->
                             prettypr:nest(2, aeso_pretty:expr(E))])).
 
 %% -- Helper functions -------------------------------------------------------
-expand_includes(AST, Included, Opts) ->
-    expand_includes(AST, Included, [], Opts).
+expand_includes(AST, Opts) ->
+    expand_includes(AST, [], Opts).
 
-expand_includes([], _Included, Acc, _Opts) ->
+expand_includes([], Acc, _Opts) ->
     {ok, lists:reverse(Acc)};
-expand_includes([{include, Ann, {string, SAnn, File}} | AST], Included, Acc, Opts) ->
-    case get_include_code(File, Ann, Opts) of
-        {ok, Code} ->
-            Hashed = hash_include(File, Code),
-            case sets:is_element(Hashed, Included) of
-                false ->
-                    Opts1 = lists:keystore(src_file, 1, Opts, {src_file, File}),
-                    Included1 = sets:add_element(Hashed, Included),
-                    case string(Code, Included1, Opts1) of
-                        {ok, AST1} ->
-                            Dependencies = [ {include, Ann, {string, SAnn, Dep}}
-                                             || Dep <- aeso_stdlib:dependencies(File)
-                                           ],
-                            expand_includes(Dependencies ++ AST1 ++ AST, Included1, Acc, Opts);
-                        Err = {error, _} ->
-                            Err
-                    end;
-                true ->
-                    expand_includes(AST, Included, Acc, Opts)
+expand_includes([{include, _, S = {string, _, File}} | AST], Acc, Opts) ->
+    case read_file(File, Opts) of
+        {ok, Bin} ->
+            Opts1 = lists:keystore(src_file, 1, Opts, {src_file, File}),
+            case string(binary_to_list(Bin), Opts1) of
+                {ok, AST1} ->
+                    expand_includes(AST1 ++ AST, Acc, Opts);
+                Err = {error, _} ->
+                    Err
             end;
-        Err = {error, _} ->
-            Err
+        {error, _} ->
+            {error, {get_pos(S), include_error, File}}
     end;
-expand_includes([E | AST], Included, Acc, Opts) ->
-    expand_includes(AST, Included, [E | Acc], Opts).
+expand_includes([E | AST], Acc, Opts) ->
+    expand_includes(AST, [E | Acc], Opts).
 
 read_file(File, Opts) ->
     case proplists:get_value(include, Opts, {explicit_files, #{}}) of
@@ -593,20 +555,3 @@ read_file(File, Opts) ->
             end
     end.
 
-get_include_code(File, Ann, Opts) ->
-    case {read_file(File, Opts), maps:find(File, aeso_stdlib:stdlib())} of
-        {{ok, _}, {ok,_ }} ->
-            return_error(ann_pos(Ann), "Illegal redefinition of standard library " ++ File);
-        {_, {ok, Lib}} ->
-            {ok, Lib};
-        {{ok, Bin}, _} ->
-            {ok, binary_to_list(Bin)};
-        {_, _} ->
-            {error, {ann_pos(Ann), include_error, File}}
-    end.
-
--spec hash_include(string() | binary(), string()) -> include_hash().
-hash_include(File, Code) when is_binary(File) ->
-    hash_include(binary_to_list(File), Code);
-hash_include(File, Code) when is_list(File) ->
-    {filename:basename(File), crypto:hash(sha256, Code)}.

src/aeso_pretty.erl

@@ -235,8 +235,6 @@ type(Type, Options) ->
 -spec type(aeso_syntax:type()) -> doc().
 type({fun_t, _, Named, Args, Ret}) ->
     follow(hsep(args_type(Named ++ Args), text("=>")), type(Ret));
-type({type_sig, _, Named, Args, Ret}) ->
-    follow(hsep(tuple_type(Named ++ Args), text("=>")), type(Ret));
 type({app_t, _, Type, []}) ->
     type(Type);
 type({app_t, _, Type, Args}) ->

src/aeso_scan.erl

@@ -37,7 +37,7 @@ lexer() ->
         , {"[^/*]+|[/*]", skip()} ],
 
     Keywords = ["contract", "include", "let", "switch", "type", "record", "datatype", "if", "elif", "else", "function",
-                "stateful", "payable", "true", "false", "mod", "public", "entrypoint", "private", "indexed", "namespace"],
+                "stateful", "true", "false", "mod", "public", "entrypoint", "private", "indexed", "namespace"],
     KW = string:join(Keywords, "|"),
 
     Rules =

src/aeso_stdlib.erl

@@ -1,434 +0,0 @@
-%%%-------------------------------------------------------------------
-%%% @author Radosław Rowicki
-%%% @copyright (C) 2019, Aeternity Anstalt
-%%% @doc
-%%%     Standard library for Sophia
-%%% @end
-%%% Created : 6 July 2019
-%%%
-%%%-------------------------------------------------------------------
-
--module(aeso_stdlib).
-
--export([stdlib/0, stdlib_list/0, dependencies/1]).
-
-stdlib() ->
-    maps:from_list(stdlib_list()).
-
-stdlib_list() ->
-    [ {<<"List.aes">>, std_list()}
-    , {<<"Func.aes">>, std_func()}
-    , {<<"Option.aes">>, std_option()}
-    , {<<"Pair.aes">>, std_pair()}
-    , {<<"Triple.aes">>, std_triple()}
-    ].
-
-dependencies(Q) ->
-    case Q of
-        <<"Option.aes">> ->
-            [<<"List.aes">>];
-        _ -> []
-    end.
-
-std_func() ->
-"
-namespace Func =
-
-  function id(x : 'a) : 'a = x
-
-  function const(x : 'a) : 'b => 'a = (y) => x
-
-  function flip(f : ('a, 'b) => 'c) : ('b, 'a) => 'c = (b, a) => f(a, b)
-
-  function comp(f : 'b => 'c, g : 'a => 'b) : 'a => 'c = (x) => f(g(x))
-
-  function pipe(f : 'a => 'b, g : 'b => 'c) : 'a => 'c = (x) => g(f(x))
-
-  function rapply(x : 'a, f : 'a => 'b) : 'b = f(x)
-
-  /* The Z combinator - replacement for local and anonymous recursion.
-   */
-  function recur(f : ('arg => 'res, 'arg) => 'res) : 'arg => 'res =
-    (x) => f(recur(f), x)
-
-  function iter(n : int, f : 'a => 'a) : 'a => 'a = iter_(n, f, (x) => x)
-  private function iter_(n : int, f : 'a => 'a, acc : 'a => 'a) : 'a => 'a =
-    if(n == 0) acc
-    elif(n == 1) comp(f, acc)
-    else iter_(n / 2, comp(f, f), if(n mod 2 == 0) acc else comp(f, acc))
-
-  function curry2(f : ('a, 'b) => 'c) : 'a => ('b => 'c) =
-    (x) => (y) => f(x, y)
-  function curry3(f : ('a, 'b, 'c) => 'd) : 'a => ('b => ('c => 'd)) =
-    (x) => (y) => (z) => f(x, y, z)
-
-  function uncurry2(f : 'a => ('b => 'c)) : ('a, 'b) => 'c =
-    (x, y) => f(x)(y)
-  function uncurry3(f : 'a => ('b => ('c => 'd))) : ('a, 'b, 'c) => 'd =
-    (x, y, z) => f(x)(y)(z)
-
-  function tuplify2(f : ('a, 'b) => 'c) : (('a * 'b)) => 'c =
-    (t) => switch(t)
-      (x, y) => f(x, y)
-  function tuplify3(f : ('a, 'b, 'c) => 'd) : 'a * 'b * 'c => 'd =
-    (t) => switch(t)
-      (x, y, z) => f(x, y, z)
-
-  function untuplify2(f : 'a * 'b => 'c) : ('a, 'b) => 'c =
-    (x, y) => f((x, y))
-  function untuplify3(f : 'a * 'b * 'c => 'd) : ('a, 'b, 'c) => 'd =
-    (x, y, z) => f((x, y, z))
-".
-
-std_list() ->"
-namespace List =
-
-  function is_empty(l : list('a)) : bool = switch(l)
-    [] => true
-    _  => false
-
-  function first(l : list('a)) : option('a) = switch(l)
-    []   => None
-    h::_ => Some(h)
-
-  function tail(l : list('a)) : option(list('a)) = switch(l)
-    []   => None
-    _::t => Some(t)
-
-  function last(l : list('a)) : option('a) = switch(l)
-    []  => None
-    [x] => Some(x)
-    _::t => last(t)
-
-  function find(p : 'a => bool, l : list('a)) : option('a) = switch(l)
-    []   => None
-    h::t => if(p(h)) Some(h) else find(p, t)
-
-  function find_all(p : 'a => bool, l : list('a)) : list('a) = find_all_(p, l, [])
-  private function find_all_(p : 'a => bool, l : list('a), acc : list('a)) : list('a) = switch(l)
-    []   => reverse(acc)
-    h::t => find_all_(p, t, if(p(h)) h::acc else acc)
-
-  function find_indices(p : 'a => bool, l : list('a)) : list(int) = find_indices_(p, l, 0, [])
-  private function find_indices_( p : 'a => bool
-                                , l : list('a)
-                                , n : int
-                                , acc : list(int)
-                                ) : list(int) = switch(l)
-    []   => reverse(acc)
-    h::t => find_indices_(p, t, n+1, if(p(h)) n::acc else acc)
-
-  function nth(n : int, l : list('a)) : option('a) = switch(l)
-    []   => None
-    h::t => if(n == 0) Some(h) else nth(n-1, t)
-
-  /* Unsafe version of `nth` */
-  function get(n : int, l : list('a)) : 'a = switch(l)
-    [] => abort(\"Out of index get\")
-    h::t => if(n == 0) h else get(n-1, t)
-
-
-  function length(l : list('a)) : int = length_(l, 0)
-  private function length_(l : list('a), acc : int) : int = switch(l)
-    []   => acc
-    _::t => length_(t, acc + 1)
-
-
-  /* Unsafe. Replaces `n`th element of `l` with `e`. Crashes on over/underflow */
-  function replace_at(n : int, e : 'a, l : list('a)) : list('a) =
-    if(n<0) abort(\"insert_at underflow\") else replace_at_(n, e, l, [])
-  private function replace_at_(n : int, e : 'a, l : list('a), acc : list('a)) : list('a) =
-   switch(l)
-     []   => abort(\"replace_at overflow\")
-     h::t => if (n == 0) reverse(e::acc) ++ t
-             else replace_at_(n-1, e, t, h::acc)
-
-  /* Unsafe. Adds `e` to `l` to be its `n`th element. Crashes on over/underflow */
-  function insert_at(n : int, e : 'a, l : list('a)) : list('a) =
-    if(n<0) abort(\"insert_at underflow\") else insert_at_(n, e, l, [])
-  private function insert_at_(n : int, e : 'a, l : list('a), acc : list('a)) : list('a) =
-   if (n == 0) reverse(e::acc) ++ l
-   else switch(l)
-     []   => abort(\"insert_at overflow\")
-     h::t => insert_at_(n-1, e, t, h::acc)
-
-  function insert_by(f : (('a, 'a) => bool), x : 'a, l : list('a)) : list('a) =
-    switch(l)
-      []        => [x]
-      (e :: l') =>
-        if(f(x, e))
-          e :: insert_by(f, x, l')
-        else
-          x :: l
-
-  function foldr(cons : ('a, 'b) => 'b, nil : 'b, l : list('a)) : 'b = switch(l)
-    []   => nil
-    h::t => cons(h, foldr(cons, nil, t))
-
-  function foldl(rcons : ('b, 'a) => 'b, acc : 'b, l : list('a)) : 'b = switch(l)
-    []   => acc
-    h::t => foldl(rcons, rcons(acc, h), t)
-
-  function foreach(f : 'a => unit, l : list('a)) : unit =
-    switch(l)
-     []   => ()
-     e :: l' =>
-       f(e)
-       foreach(f, l')
-
-
-  function reverse(l : list('a)) : list('a) = foldl((lst, el) => el :: lst, [], l)
-
-
-  function map(f : 'a => 'b, l : list('a)) : list('b) = map_(f, l, [])
-  private function map_(f : 'a => 'b, l : list('a), acc : list('b)) : list('b) = switch(l)
-    []   => reverse(acc)
-    h::t => map_(f, t, f(h)::acc)
-
-  function flat_map(f : 'a => list('b), l : list('a)) : list('b) = flat_map_(f, l, [])
-  private function flat_map_(f : 'a => list('b), l : list('a), acc : list('b)) : list('b) = switch(l)
-    []   => reverse(acc)
-    h::t => flat_map_(f, t, reverse(f(h)) ++ acc)
-
-  function filter(p : 'a => bool, l : list('a)) : list('a) = filter_(p, l, [])
-  private function filter_(p : 'a => bool, l : list('a), acc : list('a)) : list('a) = switch(l)
-    []   => reverse(acc)
-    h::t => filter_(p, t, if(p(h)) h::acc else acc)
-
-  /* Take `n` first elements */
-  function take(n : int, l : list('a)) : list('a) =
-    if(n < 0) abort(\"Take negative number of elements\") else take_(n, l, [])
-  private function take_(n : int, l : list('a), acc : list('a)) : list('a) =
-    if(n == 0) reverse(acc)
-    else switch(l)
-      []   => reverse(acc)
-      h::t => take_(n-1, t, h::acc)
-
-  /* Drop `n` first elements */
-  function drop(n : int, l : list('a)) : list('a) =
-   if(n < 0) abort(\"Drop negative number of elements\")
-   elif (n == 0) l
-   else switch(l)
-      []   => []
-      h::t => drop(n-1, t)
-
-  /* Get the longest prefix of a list in which every element matches predicate `p` */
-  function take_while(p : 'a => bool, l : list('a)) : list('a) = take_while_(p, l, [])
-  private function take_while_(p : 'a => bool, l : list('a), acc : list('a)) : list('a) = switch(l)
-    []   => reverse(acc)
-    h::t => if(p(h)) take_while_(p, t, h::acc) else reverse(acc)
-
-  /* Drop elements from `l` until `p` holds */
-  function drop_while(p : 'a => bool, l : list('a)) : list('a) = switch(l)
-    []   => []
-    h::t => if(p(h)) drop_while(p, t) else l
-
-  /* Splits list into two lists of elements that respectively match and don't match predicate `p` */
-  function partition(p : 'a => bool, l : list('a)) : (list('a) * list('a)) = partition_(p, l, [], [])
-  private function partition_( p : 'a => bool
-                             , l : list('a)
-                             , acc_t : list('a)
-                             , acc_f : list('a)
-                             ) : (list('a) * list('a)) = switch(l)
-    []   => (reverse(acc_t), reverse(acc_f))
-    h::t => if(p(h)) partition_(p, t, h::acc_t, acc_f) else partition_(p, t, acc_t, h::acc_f)
-
-
-  function concats(ll : list(list('a))) : list('a) = foldr((l1, l2) => l1 ++ l2, [], ll)
-
-  function all(p : 'a => bool, l : list('a)) : bool = switch(l)
-    []   => true
-    h::t => if(p(h)) all(p, t) else false
-
-  function any(p : 'a => bool, l : list('a)) : bool = switch(l)
-    []   => false
-    h::t => if(p(h)) true else any(p, t)
-
-  function sum(l : list(int)) : int = foldl ((a, b) => a + b, 0, l)
-
-  function product(l : list(int)) : int = foldl((a, b) => a * b, 1, l)
-
-
-  /* Zips two list by applying bimapping function on respective elements. Drops longer tail. */
-  function zip_with(f : ('a, 'b) => 'c, l1 : list('a), l2 : list('b)) : list('c) = zip_with_(f, l1, l2, [])
-  private function zip_with_( f : ('a, 'b) => 'c
-                            , l1 : list('a)
-                            , l2 : list('b)
-                            , acc : list('c)
-                            ) : list('c) = switch ((l1, l2))
-    (h1::t1, h2::t2) => zip_with_(f, t1, t2, f(h1, h2)::acc)
-    _ => reverse(acc)
-
-  /* Zips two lists into list of pairs. Drops longer tail. */
-  function zip(l1 : list('a), l2 : list('b)) : list('a * 'b) = zip_with((a, b) => (a, b), l1, l2)
-
-  function unzip(l : list('a * 'b)) : list('a) * list('b) = unzip_(l, [], [])
-  private function unzip_( l     : list('a * 'b)
-                         , acc_l : list('a)
-                         , acc_r : list('b)
-                         ) : (list('a) * list('b)) = switch(l)
-    []               => (reverse(acc_l), reverse(acc_r))
-    (left, right)::t => unzip_(t, left::acc_l, right::acc_r)
-
-
-  // TODO: Improve?
-  function sort(lesser_cmp : ('a, 'a) => bool, l : list('a)) : list('a) = switch(l)
-    []   => []
-    h::t => switch (partition((x) => lesser_cmp(x, h), t))
-      (lesser, bigger) => sort(lesser_cmp, lesser) ++ h::sort(lesser_cmp, bigger)
-
-
-  function intersperse(delim : 'a, l : list('a)) : list('a) = intersperse_(delim, l, [])
-  private function intersperse_(delim : 'a, l : list('a), acc : list('a)) : list('a) = switch(l)
-    []   => reverse(acc)
-    [e]  => reverse(e::acc)
-    h::t => intersperse_(delim, t, delim::h::acc)
-
-
-  function enumerate(l : list('a)) : list(int * 'a) = enumerate_(l, 0, [])
-  private function enumerate_(l : list('a), n : int, acc : list(int * 'a)) : list(int * 'a) = switch(l)
-    []   => reverse(acc)
-    h::t => enumerate_(t, n + 1, (n, h)::acc)
-
-".
-
-std_option() -> "
-namespace Option =
-
-  function is_none(o : option('a)) : bool = switch(o)
-    None => true
-    Some(_) => false
-
-  function is_some(o : option('a)) : bool = switch(o)
-    None => false
-    Some(_) => true
-
-
-  function match(n : 'b, s : 'a => 'b, o : option('a)) : 'b = switch(o)
-    None => n
-    Some(x) => s(x)
-
-  function default(def : 'a, o : option('a)) : 'a = match(def, (x) => x, o)
-
-  function force(o : option('a)) : 'a = default(abort(\"Forced None value\"), o)
-
-  function on_elem(f : 'a => unit, o : option('a)) : unit = match((), f, o)
-
-
-  function map(f : 'a => 'b, o : option('a)) : option('b) = switch(o)
-    None => None
-    Some(x) => Some(f(x))
-
-  function map2(f : ('a, 'b) => 'c
-               , o1 : option('a)
-               , o2 : option('b)
-               ) : option('c) = switch((o1, o2))
-    (Some(x1), Some(x2)) => Some(f(x1, x2))
-    _ => None
-
-  function map3( f : ('a, 'b, 'c) => 'd
-               , o1 : option('a)
-               , o2 : option('b)
-               , o3 : option('c)
-               ) : option('d) = switch((o1, o2, o3))
-    (Some(x1), Some(x2), Some(x3)) => Some(f(x1, x2, x3))
-    _ => None
-
-  function app_over(f : option ('a => 'b), o : option('a)) : option('b) = switch((f, o))
-    (Some(ff), Some(xx)) => Some(ff(xx))
-    _ => None
-
-  function flat_map(f : 'a => option('b), o : option('a)) : option('b) = switch(o)
-    None => None
-    Some(x) => f(x)
-
-
-  function to_list(o : option('a)) : list('a) = switch(o)
-    None => []
-    Some(x) => [x]
-
-  function filter_options(l : list(option('a))) : list('a) = filter_options_(l, [])
-  private function filter_options_(l : list (option('a)), acc : list('a)) : list('a) = switch(l)
-    []         => List.reverse(acc)
-    None::t    => filter_options_(t, acc)
-    Some(x)::t => filter_options_(t, x::acc)
-
-  function seq_options(l : list (option('a))) : option (list('a)) = seq_options_(l, [])
-  private function seq_options_(l : list (option('a)), acc : list('a)) : option(list('a)) = switch(l)
-    []         => Some(List.reverse(acc))
-    None::t    => None
-    Some(x)::t => seq_options_(t, x::acc)
-
-
-  function choose(o1 : option('a), o2 : option('a)) : option('a) =
-    if(is_some(o1)) o1 else o2
-
-  function choose_first(l : list(option('a))) : option('a) = switch(l)
-    [] => None
-    None::t    => choose_first(t)
-    Some(x)::_ => Some(x)
-".
-
-std_pair() -> "
-namespace Pair =
-
-  function fst(t : ('a * 'b)) : 'a = switch(t)
-    (x, _) => x
-
-  function snd(t : ('a * 'b)) : 'b = switch(t)
-    (_, y) => y
-
-
-  function map1(f : 'a => 'c, t : ('a * 'b)) : ('c * 'b) = switch(t)
-    (x, y) => (f(x), y)
-
-  function map2(f : 'b => 'c, t : ('a * 'b)) : ('a * 'c) = switch(t)
-    (x, y) => (x, f(y))
-
-  function bimap(f : 'a => 'c, g : 'b => 'd, t : ('a * 'b)) : ('c * 'd) = switch(t)
-    (x, y) => (f(x), g(y))
-
-
-  function swap(t : ('a * 'b)) : ('b * 'a) = switch(t)
-    (x, y) => (y, x)
-".
-
-std_triple() -> "
-namespace Triple =
-
-  function fst(t : ('a * 'b * 'c)) : 'a = switch(t)
-    (x, _, _) => x
-
-  function snd(t : ('a * 'b * 'c)) : 'b = switch(t)
-    (_, y, _) => y
-
-  function thd(t : ('a * 'b * 'c)) : 'c = switch(t)
-    (_, _, z) => z
-
-
-  function map1(f : 'a => 'm, t : ('a * 'b * 'c)) : ('m * 'b * 'c) = switch(t)
-    (x, y, z) => (f(x), y, z)
-
-  function map2(f : 'b => 'm, t : ('a * 'b * 'c)) : ('a * 'm * 'c) = switch(t)
-    (x, y, z) => (x, f(y), z)
-
-  function map3(f : 'c => 'm, t : ('a * 'b * 'c)) : ('a * 'b * 'm) = switch(t)
-    (x, y, z) => (x, y, f(z))
-
-  function trimap( f : 'a => 'x
-                 , g : 'b => 'y
-                 , h : 'c => 'z
-                 , t : ('a * 'b * 'c)
-                 ) : ('x * 'y * 'z) = switch(t)
-    (x, y, z) => (f(x), g(y), h(z))
-
-
-  function swap(t : ('a * 'b * 'c)) : ('c * 'b * 'a) = switch(t)
-    (x, y, z) => (z, y, x)
-
-  function rotr(t : ('a * 'b * 'c)) : ('c * 'a * 'b) = switch(t)
-    (x, y, z) => (z, x, y)
-
-  function rotl(t : ('a * 'b * 'c)) : ('b * 'c * 'a) = switch(t)
-    (x, y, z) => (y, z, x)
-".

src/aeso_syntax.erl

@@ -92,7 +92,6 @@
      | {proj, ann(), expr(), id()}
      | {tuple, ann(), [expr()]}
      | {list, ann(), [expr()]}
-     | {list_comp, ann(), expr(), [comprehension_exp()]}
      | {typed, ann(), expr(), type()}
      | {record, ann(), [field(expr())]}
      | {record, ann(), expr(), [field(expr())]} %% record update
@@ -105,10 +104,6 @@
      | id() | qid() | con() | qcon()
      | constant().
 
--type comprehension_exp() :: [{ comprehension_bind, ann(), id(), expr()}
-                             | {comprehension_if, expr()}
-                             | letbind()].
-
 -type arg_expr() :: expr() | {named_arg, ann(), id(), expr()}.
 
 %% When lvalue is a projection this is sugar for accessing fields in nested

src/aeso_syntax_utils.erl

@@ -71,15 +71,6 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
             {proj, _, E, _}        -> Expr(E);
             {tuple, _, As}         -> Expr(As);
             {list, _, As}          -> Expr(As);
-            {list_comp, _, Y, []}  -> Expr(Y);
-            {list_comp, A, Y, [{comprehension_bind, I, E}|R]} ->
-                Plus(Expr(E), Scoped(BindExpr(I), Expr({list_comp, A, Y, R})));
-            {list_comp, A, Y, [{comprehension_if, E}|R]} ->
-                Plus(Expr(E), Expr({list_comp, A, Y, R}));
-            {list_comp, A, Y, [D = {letval, _, F, _, _} | R]} ->
-                Plus(Decl(D), Scoped(BindExpr(F), Expr({list_comp, A, Y, R})));
-            {list_comp, A, Y, [D = {letfun, _, F, _, _, _} | R]} ->
-                Plus(Decl(D), Scoped(BindExpr(F), Expr({list_comp, A, Y, R})));
             {typed, _, E, T}       -> Plus(Expr(E), Type(T));
             {record, _, Fs}        -> Expr(Fs);
             {record, _, E, Fs}     -> Expr([E | Fs]);

src/aesophia.app.src

@@ -1,6 +1,6 @@
 {application, aesophia,
  [{description, "Contract Language for aeternity"},
-  {vsn, "4.0.0-rc1"},
+  {vsn, "3.2.0"},
   {registered, []},
   {applications,
    [kernel,

test/aeso_abi_tests.erl

@@ -80,11 +80,11 @@ encode_decode_sophia_string(SophiaType, String) ->
            , "  record r = {x : an_alias(int), y : variant}\n"
            , "  datatype variant = Red | Blue(map(string, int))\n"
            , "  entrypoint foo : arg_type => arg_type\n" ],
-    case aeso_compiler:check_call(lists:flatten(Code), "foo", [String], [no_implicit_stdlib]) of
+    case aeso_compiler:check_call(lists:flatten(Code), "foo", [String], []) of
         {ok, _, {[Type], _}, [Arg]} ->
             io:format("Type ~p~n", [Type]),
             Data = encode(Arg),
-            case aeso_compiler:to_sophia_value(Code, "foo", ok, Data, [no_implicit_stdlib]) of
+            case aeso_compiler:to_sophia_value(Code, "foo", ok, Data) of
                 {ok, Sophia} ->
                     lists:flatten(io_lib:format("~s", [prettypr:format(aeso_pretty:expr(Sophia))]));
                 {error, Err} ->
@@ -152,7 +152,7 @@ oracle_test() ->
         "    Oracle.get_question(o, q)\n",
     {ok, _, {[word, word], {list, string}}, [16#123, 16#456]} =
         aeso_compiler:check_call(Contract, "question", ["ok_111111111111111111111111111111ZrdqRz9",
-                                                        "oq_1111111111111111111111111111113AFEFpt5"], [no_implicit_stdlib]),
+                                                        "oq_1111111111111111111111111111113AFEFpt5"], []),
 
     ok.
 
@@ -162,7 +162,7 @@ permissive_literals_fail_test() ->
         "  stateful entrypoint haxx(o : oracle(list(string), option(int))) =\n"
         "    Chain.spend(o, 1000000)\n",
         {error, <<"Type errors\nCannot unify", _/binary>>} =
-            aeso_compiler:check_call(Contract, "haxx", ["#123"], [no_implicit_stdlib]),
+            aeso_compiler:check_call(Contract, "haxx", ["#123"], []),
     ok.
 
 encode_decode_calldata(FunName, Types, Args) ->
@@ -173,8 +173,8 @@ encode_decode_calldata(FunName, Types, Args, RetType) ->
     encode_decode_calldata_(Code, FunName, Args, RetType).
 
 encode_decode_calldata_(Code, FunName, Args, RetVMType) ->
-    {ok, Calldata} = aeso_compiler:create_calldata(Code, FunName, Args, [no_implicit_stdlib]),
-    {ok, _, {ArgTypes, RetType}, _} = aeso_compiler:check_call(Code, FunName, Args, [{backend, aevm}, no_implicit_stdlib]),
+    {ok, Calldata} = aeso_compiler:create_calldata(Code, FunName, Args),
+    {ok, _, {ArgTypes, RetType}, _} = aeso_compiler:check_call(Code, FunName, Args, [{backend, aevm}]),
     ?assertEqual(RetType, RetVMType),
     CalldataType = {tuple, [word, {tuple, ArgTypes}]},
     {ok, {_Hash, ArgTuple}} = aeb_heap:from_binary(CalldataType, Calldata),
@@ -182,7 +182,7 @@ encode_decode_calldata_(Code, FunName, Args, RetVMType) ->
         "init" ->
             ok;
         _ ->
-            {ok, _ArgTypes, ValueASTs} = aeso_compiler:decode_calldata(Code, FunName, Calldata, [no_implicit_stdlib]),
+            {ok, _ArgTypes, ValueASTs} = aeso_compiler:decode_calldata(Code, FunName, Calldata),
             Values = [ prettypr:format(aeso_pretty:expr(V)) || V <- ValueASTs ],
             ?assertMatch({X, X}, {Args, Values})
     end,

test/aeso_aci_tests.erl

@@ -9,27 +9,25 @@ simple_aci_test_() ->
 
 test_contract(N) ->
     {Contract,MapACI,DecACI} = test_cases(N),
-    {ok,JSON} = aeso_aci:contract_interface(json, Contract, [no_implicit_stdlib]),
+    {ok,JSON} = aeso_aci:contract_interface(json, Contract),
     ?assertEqual([MapACI], JSON),
     ?assertEqual({ok, DecACI}, aeso_aci:render_aci_json(JSON)).
 
 test_cases(1) ->
-    Contract = <<"payable contract C =\n"
-		 "  payable stateful entrypoint a(i : int) = i+1\n">>,
+    Contract = <<"contract C =\n"
+		 "  entrypoint a(i : int) = i+1\n">>,
     MapACI = #{contract =>
 		   #{name => <<"C">>,
 		     type_defs => [],
-                     payable => true,
 		     functions =>
 			 [#{name => <<"a">>,
 			    arguments =>
 				[#{name => <<"i">>,
 				   type => <<"int">>}],
 			    returns => <<"int">>,
-			    stateful => true,
-                            payable  => true}]}},
-    DecACI = <<"payable contract C =\n"
-	       "  payable entrypoint a : (int) => int\n">>,
+			    stateful => false}]}},
+    DecACI = <<"contract C =\n"
+	       "  entrypoint a : (int) => int\n">>,
     {Contract,MapACI,DecACI};
 
 test_cases(2) ->
@@ -37,7 +35,7 @@ test_cases(2) ->
 		 "  type allan = int\n"
 		 "  entrypoint a(i : allan) = i+1\n">>,
     MapACI = #{contract =>
-                       #{name => <<"C">>, payable => false,
+                       #{name => <<"C">>,
                          type_defs =>
                              [#{name => <<"allan">>,
                                 typedef => <<"int">>,
@@ -48,8 +46,7 @@ test_cases(2) ->
                                        type => <<"C.allan">>}],
                                 name => <<"a">>,
                                 returns => <<"int">>,
-                                stateful => false,
-                                payable  => false}]}},
+                                stateful => false}]}},
     DecACI = <<"contract C =\n"
                "  type allan = int\n"
                "  entrypoint a : (C.allan) => int\n">>,
@@ -67,8 +64,8 @@ test_cases(3) ->
 				   type =>
 				       #{<<"C.bert">> => [<<"string">>]}}],
 			    name => <<"a">>,returns => <<"int">>,
-			    stateful => false, payable  => false}],
-		     name => <<"C">>, payable => false,
+			    stateful => false}],
+		     name => <<"C">>,
                      event => #{variant => [#{<<"SingleEventDefined">> => []}]},
                      state => <<"unit">>,
 		     type_defs =>
@@ -90,8 +87,7 @@ aci_test_() ->
       fun() -> aci_test_contract(ContractName) end}
      || ContractName <- all_contracts()].
 
-all_contracts() -> [C || C <- aeso_compiler_tests:compilable_contracts()
-                             , not aeso_compiler_tests:wants_stdlib(C)].
+all_contracts() -> aeso_compiler_tests:compilable_contracts().
 
 aci_test_contract(Name) ->
     String = aeso_test_utils:read_contract(Name),

test/aeso_calldata_tests.erl

@@ -21,14 +21,12 @@ calldata_test_() ->
            ContractString = aeso_test_utils:read_contract(ContractName),
            AevmExprs =
               case not lists:member(ContractName, not_yet_compilable(aevm)) of
-                  true -> ast_exprs(ContractString, Fun, Args, [{backend, aevm}]
-                                    ++ [no_implicit_stdlib || not aeso_compiler_tests:wants_stdlib(ContractName)]);
+                  true -> ast_exprs(ContractString, Fun, Args, [{backend, aevm}]);
                   false -> undefined
               end,
            FateExprs =
               case not lists:member(ContractName, not_yet_compilable(fate)) of
-                  true -> ast_exprs(ContractString, Fun, Args, [{backend, fate}]
-                                    ++ [no_implicit_stdlib || not aeso_compiler_tests:wants_stdlib(ContractName)]);
+                  true -> ast_exprs(ContractString, Fun, Args, [{backend, fate}]);
                   false -> undefined
               end,
            case FateExprs == undefined orelse AevmExprs == undefined of
@@ -47,14 +45,12 @@ calldata_aci_test_() ->
            io:format("ACI:\n~s\n", [ContractACIBin]),
            AevmExprs =
               case not lists:member(ContractName, not_yet_compilable(aevm)) of
-                  true -> ast_exprs(ContractACI, Fun, Args, [{backend, aevm}]
-                                    ++ [no_implicit_stdlib || not aeso_compiler_tests:wants_stdlib(ContractName)]);
+                  true -> ast_exprs(ContractACI, Fun, Args, [{backend, aevm}]);
                   false -> undefined
               end,
            FateExprs =
               case not lists:member(ContractName, not_yet_compilable(fate)) of
-                  true -> ast_exprs(ContractACI, Fun, Args, [{backend, fate}]
-                                    ++ [no_implicit_stdlib || not aeso_compiler_tests:wants_stdlib(ContractName)]);
+                  true -> ast_exprs(ContractACI, Fun, Args, [{backend, fate}]);
                   false -> undefined
               end,
            case FateExprs == undefined orelse AevmExprs == undefined of
@@ -120,11 +116,10 @@ compilable_contracts() ->
      {"complex_types", "filter_some", ["[Some(11), Some(12), None]"]},
      {"complex_types", "init", ["ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ"]},
      {"__call" "init", []},
-     {"bitcoin_auth", "authorize", ["1", "#0102030405060708090a0b0c0d0e0f101718192021222324252627282930313233343536373839401a1b1c1d1e1f20212223242526272829303132333435363738"]},
+     {"bitcoin_auth", "authorize", ["1", "#0102030405060708090a0b0c0d0e0f101718192021222324252627282930313233343536373839401a1b1c1d1e1f202122232425262728293031323334353637"]},
      {"bitcoin_auth", "to_sign", ["#0102030405060708090a0b0c0d0e0f1017181920212223242526272829303132", "2"]},
      {"stub", "foo", ["42"]},
-     {"stub", "foo", ["-42"]},
-     {"payable", "foo", ["42"]}
+     {"stub", "foo", ["-42"]}
     ].
 
 not_yet_compilable(fate) ->

test/aeso_compiler_tests.erl

@@ -53,17 +53,15 @@ simple_compile_test_() ->
             #{byte_code := Code2} = compile(aevm, "include"),
             ?assertMatch(true, Code1 == Code2)
         end} ] ++
-     [ {"Testing deadcode elimination for " ++ atom_to_list(Backend),
+     [ {"Testing deadcode elimination",
         fun() ->
-            #{ byte_code := NoDeadCode } = compile(Backend, "nodeadcode"),
-            #{ byte_code := DeadCode   } = compile(Backend, "deadcode"),
+            #{ byte_code := NoDeadCode } = compile(aevm, "nodeadcode"),
+            #{ byte_code := DeadCode   } = compile(aevm, "deadcode"),
             SizeNoDeadCode = byte_size(NoDeadCode),
             SizeDeadCode   = byte_size(DeadCode),
-            Delta          = if Backend == aevm -> 40;
-                                Backend == fate -> 20 end,
-            ?assertMatch({_, _, true}, {SizeDeadCode, SizeNoDeadCode, SizeDeadCode + Delta < SizeNoDeadCode}),
+            ?assertMatch({_, _, true}, {SizeDeadCode, SizeNoDeadCode, SizeDeadCode + 40 < SizeNoDeadCode}),
             ok
-        end} || Backend <- [aevm, fate] ].
+        end} ].
 
 check_errors(Expect, ErrorString) ->
     %% This removes the final single \n as well.
@@ -75,9 +73,7 @@ check_errors(Expect, ErrorString) ->
     end.
 
 compile(Backend, Name) ->
-    compile(Backend, Name,
-            [{include, {file_system, [aeso_test_utils:contract_path()]}}]
-            ++ [no_implicit_stdlib || not wants_stdlib(Name)]).
+    compile(Backend, Name, [{include, {file_system, [aeso_test_utils:contract_path()]}}]).
 
 compile(Backend, Name, Options) ->
     String = aeso_test_utils:read_contract(Name),
@@ -122,13 +118,7 @@ compilable_contracts() ->
      "namespace_bug",
      "bytes_to_x",
      "aens",
-     "tuple_match",
-     "cyclic_include",
-     "stdlib_include",
-     "double_include",
-     "manual_stdlib_include",
-     "list_comp",
-     "payable"
+     "tuple_match"
     ].
 
 not_yet_compilable(fate) -> [];
@@ -364,23 +354,4 @@ failing_contracts() ->
         <<"Use 'entrypoint' for declaration of foo (at line 6, column 3):\n  entrypoint foo : () => unit">>,
         <<"Use 'entrypoint' instead of 'function' for public function foo (at line 10, column 3):\n  entrypoint foo() = ()">>,
         <<"Use 'entrypoint' instead of 'function' for public function foo (at line 6, column 3):\n  entrypoint foo : () => unit">>]}
-    , {"list_comp_not_a_list",
-      [<<"Cannot unify int\n         and list('a)\nwhen checking rvalue of list comprehension binding at line 2, column 36\n  1 : int\nagainst type \n  list('a)">>
-      ]}
-    , {"list_comp_if_not_bool",
-      [<<"Cannot unify int\n         and bool\nwhen checking the type of the expression at line 2, column 44\n  3 : int\nagainst the expected type\n  bool">>
-      ]}
-    , {"list_comp_bad_shadow",
-      [<<"Cannot unify int\n         and string\nwhen checking the type of the pattern at line 2, column 53\n  x : int\nagainst the expected type\n  string">>
-      ]}
     ].
-
-wants_stdlib(Name) ->
-    lists:member
-      (Name,
-       [ "stdlib_include",
-         "list_comp",
-         "list_comp_not_a_list",
-         "list_comp_if_not_bool",
-         "list_comp_bad_shadow"
-       ]).

test/aeso_parser_tests.erl

@@ -15,7 +15,7 @@ simple_contracts_test_() ->
             ?assertMatch(
                 [{contract, _, {con, _, "Identity"},
                     [{letfun, _, {id, _, "id"}, [{arg, _, {id, _, "x"}, {id, _, "_"}}], {id, _, "_"},
-                        {id, _, "x"}}]}], parse_string(Text, [no_implicit_stdlib])),
+                        {id, _, "x"}}]}], parse_string(Text)),
             ok
        end},
       {"Operator precedence test.",
@@ -71,23 +71,21 @@ parse_contract(Name) ->
 roundtrip_contract(Name) ->
     round_trip(aeso_test_utils:read_contract(Name)).
 
-parse_string(Text) -> parse_string(Text, []).
-
-parse_string(Text, Opts) ->
-    case aeso_parser:string(Text, Opts) of
+parse_string(Text) ->
+    case aeso_parser:string(Text) of
         {ok, Contract} -> Contract;
         Err -> error(Err)
     end.
 
 parse_expr(Text) ->
     [{letval, _, _, _, Expr}] =
-        parse_string("let _ = " ++ Text, [no_implicit_stdlib]),
+        parse_string("let _ = " ++ Text),
     Expr.
 
 round_trip(Text) ->
-    Contract  = parse_string(Text, [no_implicit_stdlib]),
+    Contract  = parse_string(Text),
     Text1     = prettypr:format(aeso_pretty:decls(Contract)),
-    Contract1 = parse_string(Text1, [no_implicit_stdlib]),
+    Contract1 = parse_string(Text1),
     NoSrcLoc  = remove_line_numbers(Contract),
     NoSrcLoc1 = remove_line_numbers(Contract1),
     ?assertMatch(NoSrcLoc, diff(NoSrcLoc, NoSrcLoc1)).

test/contracts/address_chain.aes

@@ -31,6 +31,3 @@ contract AddrChain =
 
   entrypoint c_creator() : address =
     Contract.creator
-
-  entrypoint is_payable(a : address) : bool =
-    Address.is_payable(a)

test/contracts/aens.aes

@@ -22,14 +22,16 @@ contract AENSTest =
 
   stateful entrypoint claim(addr : address,
                           name : string,
-                          salt : int) : unit =
-    AENS.claim(addr, name, salt)
+                          salt : int,
+                          name_fee : int) : unit =
+    AENS.claim(addr, name, salt, name_fee)
 
   stateful entrypoint signedClaim(addr : address,
                                 name : string,
                                 salt : int,
+                                name_fee : int,
                                 sign : signature) : unit =
-    AENS.claim(addr, name, salt, signature = sign)
+    AENS.claim(addr, name, salt, name_fee, signature = sign)
 
   // TODO: update() -- how to handle pointers?
 
@@ -52,4 +54,3 @@ contract AENSTest =
                                    name      : string,
                                    sign      : signature) : unit =
     AENS.revoke(owner, name, signature = sign)
-

test/contracts/basic_auth.aes

@@ -10,7 +10,7 @@ contract BasicAuth =
     put(state{ nonce = n + 1 })
     switch(Auth.tx_hash)
       None          => abort("Not in Auth context")
-      Some(tx_hash) => Crypto.verify_sig(to_sign(tx_hash, n), state.owner, s)
+      Some(tx_hash) => Crypto.ecverify(to_sign(tx_hash, n), state.owner, s)
 
   entrypoint to_sign(h : hash, n : int) =
     Crypto.blake2b((h, n))

test/contracts/bitcoin_auth.aes

@@ -1,9 +1,9 @@
 contract BitcoinAuth =
-  record state = { nonce : int, owner : bytes(20) }
+  record state = { nonce : int, owner : bytes(64) }
 
-  entrypoint init(owner' : bytes(20)) = { nonce = 1, owner = owner' }
+  entrypoint init(owner' : bytes(64)) = { nonce = 1, owner = owner' }
 
-  stateful entrypoint authorize(n : int, s : bytes(65)) : bool =
+  stateful entrypoint authorize(n : int, s : signature) : bool =
     require(n >= state.nonce, "Nonce too low")
     require(n =< state.nonce, "Nonce too high")
     put(state{ nonce = n + 1 })

test/contracts/cyclic_include.aes

@@ -1,4 +0,0 @@
-include "cyclic_include_forth.aes"
-
-contract CI =
-  entrypoint ci() = Back.back() + Forth.forth()

test/contracts/cyclic_include_back.aes

@@ -1,4 +0,0 @@
-include "cyclic_include_forth.aes"
-
-namespace Back =
-  function back() = 2

test/contracts/cyclic_include_forth.aes

@@ -1,4 +0,0 @@
-include "cyclic_include_back.aes"
-
-namespace Forth =
-  function forth() = 3

test/contracts/deadcode.aes

@@ -1,5 +1,5 @@
 
-namespace MyList =
+namespace List =
 
   function map1(f : 'a => 'b, xs : list('a)) =
     switch(xs)
@@ -14,8 +14,8 @@ namespace MyList =
 contract Deadcode =
 
   entrypoint inc1(xs : list(int)) : list(int) =
-    MyList.map1((x) => x + 1, xs)
+    List.map1((x) => x + 1, xs)
 
   entrypoint inc2(xs : list(int)) : list(int) =
-    MyList.map1((x) => x + 1, xs)
+    List.map1((x) => x + 1, xs)
 

test/contracts/double_include.aes

@@ -1,7 +0,0 @@
-include "included.aes"
-include "../contracts/included.aes"
-
-contract Include =
-  entrypoint foo() =
-    Included.foo()
-

test/contracts/list_comp.aes

@@ -1,23 +0,0 @@
-contract ListComp =
-
-    entrypoint sample1() = [1,2,3]
-    entrypoint sample2() = [4,5]
-
-    entrypoint l1() = [x | x <- sample1()]
-    entrypoint l1_true() = [1,2,3]
-
-    entrypoint l2() = [x + y | x <- sample1(), y <- sample2()]
-    entrypoint l2_true() = [5,6,6,7,7,8]
-
-    entrypoint l3() = [x ++ y | x <- [[":)"] | x <- [1,2]]
-                              , y <- [[":("]]]  
-    entrypoint l3_true() = [[":)", ":("], [":)", ":("]]
-
-    entrypoint l4() = [(a, b, c) | let is_pit(a, b, c) = a*a + b*b == c*c
-                                 , let base = [1,2,3,4,5,6,7,8,9,10]
-                                 , a <- base
-                                 , b <- base, if (b >= a)
-                                 , c <- base, if (c >= b)
-                                 , if (is_pit(a, b, c))
-                                 ]
-    entrypoint l4_true() = [(3, 4, 5), (6, 8, 10)]

test/contracts/list_comp_bad_shadow.aes

@@ -1,2 +0,0 @@
-contract BadComp =
-  entrypoint failing() = [x + 1 | x <- [1,2,3], let x = "XD"]

test/contracts/list_comp_if_not_bool.aes

@@ -1,2 +0,0 @@
-contract BadComp =
-  entrypoint failing() = [x | x <- [], if (3)] 

test/contracts/list_comp_not_a_list.aes

@@ -1,2 +0,0 @@
-contract ListCompBad =
-  entrypoint failing() = [x | x <- 1]

test/contracts/manual_stdlib_include.aes

@@ -1,7 +0,0 @@
-// This contract should be compiled with no_implicit_stdlib option.
-// It should include Lists.aes implicitly however, because Option.aes depends on it.
-include "Option.aes"
-
-contract Test =
-  entrypoint i_should_build() =
-    List.is_empty(Option.to_list(None))

test/contracts/multi_sig.aes

@@ -28,8 +28,8 @@ contract MultiSig =
       let n = length(owners) + 1
       { nRequired  = nRequired,
         nOwners    = n,
-        owners     = Map.from_list(MyList.zip([1..n], caller() :: owners)),
-        ownerIndex = Map.from_list(MyList.zip(caller() :: owners, [1..n])) }
+        owners     = Map.from_list(List.zip([1..n], caller() :: owners)),
+        ownerIndex = Map.from_list(List.zip(caller() :: owners, [1..n])) }
 
     function lookup(map, key) =
       switch(Map.get(key, map))

test/contracts/nodeadcode.aes

@@ -1,5 +1,5 @@
 
-namespace MyList =
+namespace List =
 
   function map1(f : 'a => 'b, xs : list('a)) =
     switch(xs)
@@ -14,8 +14,8 @@ namespace MyList =
 contract Deadcode =
 
   entrypoint inc1(xs : list(int)) : list(int) =
-    MyList.map1((x) => x + 1, xs)
+    List.map1((x) => x + 1, xs)
 
   entrypoint inc2(xs : list(int)) : list(int) =
-    MyList.map2((x) => x + 1, xs)
+    List.map2((x) => x + 1, xs)
 

test/contracts/payable.aes

@@ -1,3 +0,0 @@
-payable contract Test =
-  payable entrypoint foo(x : int) = ()
-  function bar() = 42

test/contracts/reason/voting.re

@@ -47,7 +47,7 @@ module Voting : Voting = {
   let init(proposalNames: args): state =
     { chairPerson: caller(),
       voters:      AddrMap.empty,
-      proposals:   MyList.map((name) => {name: name, voteCount: 0}, proposalNames)
+      proposals:   List.map((name) => {name: name, voteCount: 0}, proposalNames)
     };
 
   /* Boilerplate */
@@ -73,7 +73,7 @@ module Voting : Voting = {
   };
 
   let addVote(candidate, weight) = {
-    let proposal = MyList.nth(state().proposals, candidate);
+    let proposal = List.nth(state().proposals, candidate);
     proposal.voteCount = proposal.voteCount + weight;
   };
 
@@ -121,6 +121,6 @@ module Voting : Voting = {
 
   /* const */
   let currentTally() =
-    MyList.map((p) => (p.name, p.voteCount), state().proposals);
+    List.map((p) => (p.name, p.voteCount), state().proposals);
 
 }

test/contracts/reason/voting_test.re

@@ -13,7 +13,7 @@ open Voting;
 
 let print_tally() = {
   let tally = call(other, () => currentTally());
-  MyList.map(((name, count)) => Printf.printf("%s: %d\n", name, count), tally);
+  List.map(((name, count)) => Printf.printf("%s: %d\n", name, count), tally);
   let winner = call(other, () => winnerName());
   Printf.printf("Winner: %s\n", winner);
 };

test/contracts/stdlib_include.aes

@@ -1,3 +0,0 @@
-contract StdInc =
-  entrypoint test() = List.map((x) => Func.id(x), [1,2,3,4])
-

test/contracts/voting.aes

@@ -36,7 +36,7 @@ contract Voting =
   function init(proposalNames: list(string)): state =
     { chairPerson = caller(),
       voters      = Map.empty,
-      proposals   = MyList.map((name) => {name = name, voteCount = 0}, proposalNames) }
+      proposals   = List.map((name) => {name = name, voteCount = 0}, proposalNames) }
 
   function initVoter() = { weight = 1, vote = NotVoted}
 
@@ -53,7 +53,7 @@ contract Voting =
       _            => delegate
 
   function addVote(candidate, weight) =
-    let proposal = MyList.nth(state.proposals, candidate)
+    let proposal = List.nth(state.proposals, candidate)
     proposal{ voteCount = proposal.voteCount + weight }
 
   function delegateVote(delegateTo: address, weight: uint) =
@@ -93,5 +93,5 @@ contract Voting =
 
   // const
   function currentTally() =
-    MyList.map((p) => (p.name, p.voteCount), state.proposals)
+    List.map((p) => (p.name, p.voteCount), state.proposals)