Added subname TX

CHANGELOG.md

@@ -6,33 +6,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 ### Added
-### Changed
+- Added the `[a..b]` language construct, returning the list of numbers between
-### Removed
-
-## [4.0.0-rc4] - 2019-09-13
-### Added
-- Handle numeric escapes, i.e. `"\x19Ethereum Signed Message:\n"`, and similar strings.
-### Changed
-### Removed
-
-## [4.0.0-rc3] - 2019-09-12
-### Added
-- `Bytes.concat` and `Bytes.split` are added to be able to
-  (de-)construct byte arrays.
-- `[a..b]` language construct, returning the list of numbers between
   `a` and `b` (inclusive). Returns the empty list if `a` > `b`.
-- [Standard libraries] (https://github.com/aeternity/protocol/blob/master/contracts/sophia_stdlib.md)
-- Checks that `init` is not called from other functions.
 ### Changed
-- Error messages are changed into a uniform format, and more helpful
-  messages have been added.
-- `Crypto.<hash_fun>` and `String.<hash_fun>` for byte arrays now only
-  hash the actual byte array - not the internal ABI format.
-- More strict checks for polymorphic oracles and higher order oracles
-  and entrypoints.
-- `AENS.claim` is updated with a `NameFee` field - to be able to do
-  name auctions within contracts.
-- Fixed a bug in `Bytes.to_str` for AEVM.
 ### Removed
 
 ## [4.0.0-rc1] - 2019-08-22
@@ -160,9 +136,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-rc4...HEAD
+[Unreleased]: https://github.com/aeternity/aesophia/compare/v4.0.0-rc1...HEAD
-[4.0.0-rc4]: https://github.com/aeternity/aesophia/compare/v4.0.0-rc3...v4.0.0-rc4
-[4.0.0-rc3]: https://github.com/aeternity/aesophia/compare/v4.0.0-rc1...v4.0.0-rc3
 [4.0.0-rc1]: https://github.com/aeternity/aesophia/compare/v3.2.0...v4.0.0-rc1
 [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

priv/stdlib/List.aes

@@ -32,16 +32,14 @@ namespace List =
     []   => 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) =
+  function nth(n : int, l : list('a)) : option('a) = switch(l)
-    switch(l)
+    []   => None
-      []   => None
+    h::t => if(n == 0) Some(h) else nth(n-1, t)
-      h::t => if(n == 0) Some(h) else nth(n-1, t)
 
   /* Unsafe version of `nth` */
-  function get(n : int, l : list('a)) : 'a =
+  function get(n : int, l : list('a)) : 'a = switch(l)
-    switch(l)
+    [] => abort("Out of index get")
-      [] => abort(if(n < 0) "Negative index get" else "Out of index get")
+    h::t => if(n == 0) h else get(n-1, t)
-      h::t => if(n == 0) h else get(n-1, t)
 
 
   function length(l : list('a)) : int = length_(l, 0)
@@ -50,13 +48,6 @@ namespace List =
     _::t => length_(t, acc + 1)
 
 
-  function from_to(a : int, b : int) : list(int) = [a..b]
-
-  function from_to_step(a : int, b : int, s : int) : list(int) = from_to_step_(a, b, s, [])
-  private function from_to_step_(a, b, s, acc) =
-    if (a > b) reverse(acc) else from_to_step_(a + s, b, s, a :: acc)
-
-
   /* 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, [])
@@ -75,17 +66,14 @@ namespace List =
      []   => abort("insert_at overflow")
      h::t => insert_at_(n-1, e, t, h::acc)
 
-  function insert_by(cmp : (('a, 'a) => bool), x : 'a, l : list('a)) : list('a) =
+  function insert_by(f : (('a, 'a) => bool), x : 'a, l : list('a)) : list('a) =
-    insert_by_(cmp, x, l, [])
-  private function insert_by_(cmp : (('a, 'a) => bool), x : 'a, l : list('a), acc : list('a)) : list('a) =
     switch(l)
-      []   => reverse(x::acc)
+      []        => [x]
-      h::t =>
+      (e :: l') =>
-        if(cmp(x, h)) // x < h
+        if(f(x, e))
-          reverse(acc) ++ (x::l)
+          e :: insert_by(f, x, l')
         else
-          insert_by_(cmp, x, t, h::acc)
+          x :: l
-
 
   function foldr(cons : ('a, 'b) => 'b, nil : 'b, l : list('a)) : 'b = switch(l)
     []   => nil
@@ -95,12 +83,12 @@ namespace List =
     []   => acc
     h::t => foldl(rcons, rcons(acc, h), t)
 
-  function foreach(l : list('a), f : 'a => unit) : unit =
+  function foreach(f : 'a => unit, l : list('a)) : unit =
     switch(l)
-     []    => ()
+     []   => ()
-     e::l' =>
+     e :: l' =>
        f(e)
-       foreach(l', f)
+       foreach(f, l')
 
   function reverse(l : list('a)) : list('a) = foldl((lst, el) => el :: lst, [], l)
 
@@ -156,7 +144,7 @@ namespace List =
     h::t => if(p(h)) partition_(p, t, h::acc_t, acc_f) else partition_(p, t, acc_t, h::acc_f)
 
 
-  function flatten(ll : list(list('a))) : list('a) = foldr((l1, l2) => l1 ++ l2, [], ll)
+  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

priv/stdlib/Option.aes

@@ -19,7 +19,7 @@ namespace Option =
 
   function force(o : option('a)) : 'a = default(abort("Forced None value"), o)
 
-  function on_elem(o : option('a), f : 'a => unit) : unit = match((), f, 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

rebar.config

@@ -2,7 +2,7 @@
 
 {erl_opts, [debug_info]}.
 
-{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git", {ref,"a66dc0a"}}}
+{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git", {ref,"3f85375"}}}
        , {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-rc4"},
+{relx, [{release, {aesophia, "4.0.0-rc1"},
          [aesophia, aebytecode, getopt]},
 
         {dev_mode, true},

rebar.lock

@@ -1,21 +1,17 @@
 {"1.1.0",
 [{<<"aebytecode">>,
   {git,"https://github.com/aeternity/aebytecode.git",
-       {ref,"a66dc0a97facdeaad7e5403018ad195d989e4793"}},
+       {ref,"3f85375cb2288083e442541d5b53f9705f22053a"}},
   0},
  {<<"aeserialization">>,
   {git,"https://github.com/aeternity/aeserialization.git",
-       {ref,"47aaa8f5434b365c50a35bfd1490340b19241991"}},
+       {ref,"816bf994ffb5cee218c3f22dc5fea296c9e0882e"}},
   1},
  {<<"base58">>,
   {git,"https://github.com/aeternity/erl-base58.git",
        {ref,"60a335668a60328a29f9731b67c4a0e9e3d50ab6"}},
   2},
  {<<"eblake2">>,{pkg,<<"eblake2">>,<<"1.0.0">>},0},
- {<<"enacl">>,
-  {git,"https://github.com/aeternity/enacl.git",
-       {ref,"26180f42c0b3a450905d2efd8bc7fd5fd9cece75"}},
-  2},
  {<<"getopt">>,{pkg,<<"getopt">>,<<"1.0.1">>},0},
  {<<"jsx">>,
   {git,"https://github.com/talentdeficit/jsx.git",

src/aeso_aci.erl

@@ -74,9 +74,21 @@ do_contract_interface(Type, ContractString, Options) ->
             string -> do_render_aci_json(JArray)
         end
     catch
-        throw:{error, Errors} -> {error, Errors}
+        %% The compiler errors.
+        error:{parse_errors, Errors} ->
+            {error, join_errors("Parse errors", Errors, fun(E) -> E end)};
+        error:{type_errors, Errors} ->
+            {error, join_errors("Type errors", Errors, fun(E) -> E end)};
+        error:{code_errors, Errors} ->
+            {error, join_errors("Code errors", Errors,
+                                fun (E) -> io_lib:format("~p", [E]) end)}
+        %% General programming errors in the compiler just signal error.
     end.
 
+join_errors(Prefix, Errors, Pfun) ->
+    Ess = [ Pfun(E) || E <- Errors ],
+    list_to_binary(string:join([Prefix|Ess], "\n")).
+
 encode_contract(Contract = {contract, _, {con, _, Name}, _}) ->
     C0 = #{name => encode_name(Name)},
 

src/aeso_ast_to_fcode.erl

@@ -20,7 +20,7 @@
 
 -type fun_name() :: {entrypoint, binary()}
                   | {local_fun, [string()]}
-                  | event.
+                  | init | event.
 -type var_name() :: string().
 -type sophia_name() :: [string()].
 
@@ -67,7 +67,6 @@
                | {def_u, fun_name(), arity()}
                | {remote_u, [ftype()], ftype(), fexpr(), fun_name()}
                | {builtin_u, builtin(), arity()}
-               | {builtin_u, builtin(), arity(), [fexpr()]} %% Typerep arguments to be added after normal args.
                | {lam, [var_name()], fexpr()}.
 
 -type fsplit() :: {split, ftype(), var_name(), [fcase()]}
@@ -141,7 +140,6 @@
                   functions  := #{ fun_name() => fun_def() } }.
 
 -define(HASH_BYTES, 32).
-
 %% -- Entrypoint -------------------------------------------------------------
 
 %% Main entrypoint. Takes typed syntax produced by aeso_ast_infer_types:infer/1,2
@@ -187,8 +185,8 @@ 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", 5}, {"transfer", 4},
+              {["AENS"],     [{"resolve", 2}, {"preclaim", 3}, {"claim", 4}, {"transfer", 4},
-                              {"revoke", 3}]},
+                              {"revoke", 3}, {"subname", 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},
@@ -198,7 +196,7 @@ builtins() ->
               {["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}, {"concat", 2}, {"split", 1}]},
+              {["Bytes"],    [{"to_int", 1}, {"to_str", 1}]},
               {["Int"],      [{"to_str", 1}]},
               {["Address"],  [{"to_str", 1}, {"is_oracle", 1}, {"is_contract", 1}, {"is_payable", 1}]}
              ],
@@ -234,7 +232,7 @@ is_no_code(Env) ->
 %% -- Compilation ------------------------------------------------------------
 
 -spec to_fcode(env(), aeso_syntax:ast()) -> fcode().
-to_fcode(Env, [{contract, Attrs, MainCon = {con, _, Main}, Decls}]) ->
+to_fcode(Env, [{contract, Attrs, {con, _, Main}, Decls}]) ->
     #{ builtins := Builtins } = Env,
     MainEnv = Env#{ context  => {main_contract, Main},
                     builtins => Builtins#{[Main, "state"]          => {get_state, none},
@@ -249,10 +247,8 @@ to_fcode(Env, [{contract, Attrs, MainCon = {con, _, Main}, Decls}]) ->
        state_type    => StateType,
        event_type    => EventType,
        payable       => Payable,
-       functions     => add_init_function(Env1, MainCon, StateType,
+       functions     => add_init_function(Env1, StateType,
                         add_event_function(Env1, EventType, Funs)) };
-to_fcode(_Env, [NotContract]) ->
-    fcode_error({last_declaration_must_be_contract, NotContract});
 to_fcode(Env, [{contract, _, {con, _, Con}, Decls} | Code]) ->
     Env1 = decls_to_fcode(Env#{ context => {abstract_contract, Con} }, Decls),
     to_fcode(Env1, Code);
@@ -274,34 +270,30 @@ 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, _, Id, _}) ->
+decl_to_fcode(Env = #{context := {main_contract, _}}, {fun_decl, Ann, {id, _, Name}, _}) ->
     case is_no_code(Env) of
-        false -> fcode_error({missing_definition, Id});
+        false -> fcode_error({missing_definition, Name, lists:keydelete(entrypoint, 1, Ann)});
         true  -> Env
     end;
 decl_to_fcode(Env, {fun_decl, _, _, _})  -> Env;
 decl_to_fcode(Env, {type_def, _Ann, Name, Args, Def}) ->
     typedef_to_fcode(Env, Name, Args, Def);
-decl_to_fcode(Env = #{ functions := Funs }, {letfun, Ann, Id = {id, _, Name}, Args, Ret, Body}) ->
+decl_to_fcode(Env = #{ functions := Funs }, {letfun, Ann, {id, _, Name}, Args, Ret, Body}) ->
     Attrs = get_attributes(Ann),
     FName = lookup_fun(Env, qname(Env, Name)),
     FArgs = args_to_fcode(Env, Args),
-    FRet  = type_to_fcode(Env, Ret),
     FBody = expr_to_fcode(Env#{ vars => [X || {X, _} <- FArgs] }, Body),
-    [ ensure_first_order_entrypoint(Ann, Id, Args, Ret, FArgs, FRet)
-      || aeso_syntax:get_ann(entrypoint, Ann, false) ],
     Def   = #{ attrs  => Attrs,
                args   => FArgs,
-               return => FRet,
+               return => type_to_fcode(Env, Ret),
                body   => FBody },
     NewFuns = Funs#{ FName => Def },
     Env#{ functions := NewFuns }.
 
 -spec typedef_to_fcode(env(), aeso_syntax:id(), [aeso_syntax:tvar()], aeso_syntax:typedef()) -> env().
-typedef_to_fcode(Env, Id = {id, _, Name}, Xs, Def) ->
+typedef_to_fcode(Env, {id, _, Name}, Xs, Def) ->
-    check_state_and_event_types(Env, Id, Xs),
     Q = qname(Env, Name),
-    FDef = fun(Args) when length(Args) == length(Xs) ->
+    FDef = fun(Args) ->
                 Sub = maps:from_list(lists:zip([X || {tvar, _, X} <- Xs], Args)),
                 case Def of
                     {record_t, Fields} -> {todo, Xs, Args, record_t, Fields};
@@ -312,9 +304,7 @@ typedef_to_fcode(Env, Id = {id, _, Name}, Xs, Def) ->
                                   end || Con <- Cons ],
                         {variant, FCons};
                     {alias_t, Type}    -> {todo, Xs, Args, alias_t, Type}
-                end;
+                end end,
-              (Args) -> internal_error({type_arity_mismatch, Name, length(Args), length(Xs)})
-           end,
     Constructors =
         case Def of
             {variant_t, Cons} ->
@@ -335,14 +325,6 @@ typedef_to_fcode(Env, Id = {id, _, Name}, Xs, Def) ->
            end,
     bind_type(Env2, Q, FDef).
 
-check_state_and_event_types(#{ context := {main_contract, _} }, Id, [_ | _]) ->
-    case Id of
-        {id, _, "state"} -> fcode_error({parameterized_state, Id});
-        {id, _, "event"} -> fcode_error({parameterized_event, Id});
-        _                -> ok
-    end;
-check_state_and_event_types(_, _, _) -> ok.
-
 -spec type_to_fcode(env(), aeso_syntax:type()) -> ftype().
 type_to_fcode(Env, Type) ->
     type_to_fcode(Env, #{}, Type).
@@ -407,31 +389,7 @@ expr_to_fcode(_Env, _Type, {bytes,           _, B}) -> {lit, {bytes, B}};
 
 %% Variables
 expr_to_fcode(Env, _Type, {id, _, X})  -> resolve_var(Env, [X]);
-expr_to_fcode(Env, Type, {qid, Ann, X}) ->
+expr_to_fcode(Env, _Type, {qid, _, X}) -> resolve_var(Env, X);
-    case resolve_var(Env, X) of
-        {builtin_u, B, Ar} when B =:= oracle_query;
-                                B =:= oracle_get_question;
-                                B =:= oracle_get_answer;
-                                B =:= oracle_respond;
-                                B =:= oracle_register;
-                                B =:= oracle_check;
-                                B =:= oracle_check_query ->
-            OType = get_oracle_type(B, Type),
-            {oracle, QType, RType} = type_to_fcode(Env, OType),
-            validate_oracle_type(Ann, OType, QType, RType),
-            TypeArgs = [{lit, {typerep, QType}}, {lit, {typerep, RType}}],
-            {builtin_u, B, Ar, TypeArgs};
-        {builtin_u, B = aens_resolve, Ar} ->
-            {fun_t, _, _, _, ResType} = Type,
-            AensType = type_to_fcode(Env, ResType),
-            validate_aens_resolve_type(Ann, ResType, AensType),
-            TypeArgs = [{lit, {typerep, AensType}}],
-            {builtin_u, B, Ar, TypeArgs};
-        {builtin_u, B = bytes_split, Ar} ->
-            {fun_t, _, _, _, {tuple_t, _, [{bytes_t, _, N}, _]}} = Type,
-            {builtin_u, B, Ar, [{lit, {int, N}}]};
-        Other -> Other
-    end;
 
 %% Constructors
 expr_to_fcode(Env, Type, {C, _, _} = Con) when C == con; C == qcon ->
@@ -441,7 +399,7 @@ expr_to_fcode(Env, _Type, {app, _, {typed, _, {C, _, _} = Con, _}, Args}) when C
     Arity = lists:nth(I + 1, Arities),
     case length(Args) == Arity of
         true  -> {con, Arities, I, [expr_to_fcode(Env, Arg) || Arg <- Args]};
-        false -> internal_error({constructor_arity_mismatch, Con, length(Args), Arity})
+        false -> fcode_error({constructor_arity_mismatch, Con, length(Args), Arity})
     end;
 
 %% Tuples
@@ -552,13 +510,29 @@ expr_to_fcode(Env, _Type, {app, _Ann, {Op, _}, [A]}) when is_atom(Op) ->
     end;
 
 %% Function calls
-expr_to_fcode(Env, _Type, {app, _, Fun = {typed, _, _, {fun_t, _, NamedArgsT, _, _}}, Args}) ->
+expr_to_fcode(Env, Type, {app, _Ann, Fun = {typed, _, _, {fun_t, _, NamedArgsT, _, _}}, Args}) ->
     Args1 = get_named_args(NamedArgsT, Args),
     FArgs = [expr_to_fcode(Env, Arg) || Arg <- Args1],
     case expr_to_fcode(Env, Fun) of
-        {builtin_u, B, _Ar, TypeArgs}     -> builtin_to_fcode(B, FArgs ++ TypeArgs);
+        {builtin_u, B, _} when B =:= oracle_query;
-        {builtin_u, B, _Ar}               -> builtin_to_fcode(B, FArgs);
+                               B =:= oracle_get_question;
-        {def_u, F, _Ar}                   -> {def, F, FArgs};
+                               B =:= oracle_get_answer;
+                               B =:= oracle_respond;
+                               B =:= oracle_register;
+                               B =:= oracle_check;
+                               B =:= oracle_check_query ->
+            %% Get the type of the oracle from the args or the expression itself
+            OType = get_oracle_type(B, Type, Args1),
+            {oracle, QType, RType} = type_to_fcode(Env, OType),
+            TypeArgs = [{lit, {typerep, QType}}, {lit, {typerep, RType}}],
+            builtin_to_fcode(B, FArgs ++ TypeArgs);
+        {builtin_u, B, _} when B =:= aens_resolve ->
+            %% Get the type we are assuming the name resolves to
+            AensType = type_to_fcode(Env, Type),
+            TypeArgs = [{lit, {typerep, AensType}}],
+            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};
         FFun ->
             %% FFun is a closure, with first component the function name and
@@ -622,60 +596,13 @@ make_if(Cond, Then, Else) ->
     {'let', X, Cond, make_if({var, X}, Then, Else)}.
 
 
-get_oracle_type(oracle_register,     {fun_t, _, _, _, OType})       -> OType;
+get_oracle_type(oracle_register,     OType, _Args) -> OType;
-get_oracle_type(oracle_query,        {fun_t, _, _, [OType | _], _}) -> OType;
+get_oracle_type(oracle_query,        _Type, [{typed, _, _Expr, OType} | _])   -> OType;
-get_oracle_type(oracle_get_question, {fun_t, _, _, [OType | _], _}) -> OType;
+get_oracle_type(oracle_get_question, _Type, [{typed, _, _Expr, OType} | _])   -> OType;
-get_oracle_type(oracle_get_answer,   {fun_t, _, _, [OType | _], _}) -> OType;
+get_oracle_type(oracle_get_answer,   _Type, [{typed, _, _Expr, OType} | _])   -> OType;
-get_oracle_type(oracle_check,        {fun_t, _, _, [OType | _], _}) -> OType;
+get_oracle_type(oracle_check,        _Type, [{typed, _, _Expr, OType}])       -> OType;
-get_oracle_type(oracle_check_query,  {fun_t, _, _, [OType | _], _}) -> OType;
+get_oracle_type(oracle_check_query,  _Type, [{typed, _, _Expr, OType} | _])   -> OType;
-get_oracle_type(oracle_respond,      {fun_t, _, _, [OType | _], _}) -> OType.
+get_oracle_type(oracle_respond,      _Type, [_, {typed, _,_Expr, OType} | _]) -> OType.
-
-validate_oracle_type(Ann, Type, QType, RType) ->
-    ensure_monomorphic(QType, {invalid_oracle_type, polymorphic,  query,    Ann, Type}),
-    ensure_monomorphic(RType, {invalid_oracle_type, polymorphic,  response, Ann, Type}),
-    ensure_first_order(QType, {invalid_oracle_type, higher_order, query,    Ann, Type}),
-    ensure_first_order(RType, {invalid_oracle_type, higher_order, response, Ann, Type}),
-    ok.
-
-validate_aens_resolve_type(Ann, {app_t, _, _, [Type]}, {variant, [[], [FType]]}) ->
-    case FType of
-        string         -> ok;
-        address        -> ok;
-        contract       -> ok;
-        {oracle, _, _} -> ok;
-        oracle_query   -> ok;
-        _              -> fcode_error({invalid_aens_resolve_type, Ann, Type})
-    end.
-
-ensure_first_order_entrypoint(Ann, Id = {id, _, Name}, Args, Ret, FArgs, FRet) ->
-    [ ensure_first_order(FT, {invalid_entrypoint, higher_order, Ann1, Id, {argument, X, T}})
-      || {{arg, Ann1, X, T}, {_, FT}} <- lists:zip(Args, FArgs) ],
-    [ ensure_first_order(FRet, {invalid_entrypoint, higher_order, Ann, Id, {result, Ret}})
-      || Name /= "init" ],  %% init can return higher-order values, since they're written to the store
-                            %% rather than being returned.
-    ok.
-
-ensure_monomorphic(Type, Err) ->
-    case is_monomorphic(Type) of
-        true  -> ok;
-        false -> fcode_error(Err)
-    end.
-
-ensure_first_order(Type, Err) ->
-    case is_first_order(Type) of
-        true  -> ok;
-        false -> fcode_error(Err)
-    end.
-
-is_monomorphic({tvar, _})              -> false;
-is_monomorphic(Ts) when is_list(Ts)    -> lists:all(fun is_monomorphic/1, Ts);
-is_monomorphic(Tup) when is_tuple(Tup) -> is_monomorphic(tuple_to_list(Tup));
-is_monomorphic(_)                      -> true.
-
-is_first_order({function, _, _})       -> false;
-is_first_order(Ts) when is_list(Ts)    -> lists:all(fun is_first_order/1, Ts);
-is_first_order(Tup) when is_tuple(Tup) -> is_first_order(tuple_to_list(Tup));
-is_first_order(_)                      -> true.
 
 %% -- Pattern matching --
 
@@ -932,18 +859,19 @@ builtin_to_fcode(Builtin, Args) ->
 
 %% -- Init function --
 
-add_init_function(Env, Main, StateType, Funs0) ->
+add_init_function(Env, StateType, Funs0) ->
     case is_no_code(Env) of
         true  -> Funs0;
         false ->
-            Funs     = add_default_init_function(Env, Main, StateType, Funs0),
+            Funs     = add_default_init_function(Env, StateType, Funs0),
             InitName = {entrypoint, <<"init">>},
-            InitFun  = #{ body := InitBody} = maps:get(InitName, Funs),
+            InitFun  = #{ args := InitArgs } = maps:get(InitName, Funs, none),
-            Funs#{ InitName => InitFun#{ return => {tuple, []},
+            Vars     = [ {var, X} || {X, _} <- InitArgs ],
-                                         body   => {builtin, set_state, [InitBody]} } }
+            Funs#{ init => InitFun#{ return => {tuple, []},
+                                     body   => {builtin, set_state, [{def, InitName, Vars}]} } }
     end.
 
-add_default_init_function(_Env, Main, StateType, Funs) ->
+add_default_init_function(_Env, StateType, Funs) ->
     InitName = {entrypoint, <<"init">>},
     case maps:get(InitName, Funs, none) of
         %% Only add default init function if state is unit.
@@ -952,7 +880,7 @@ add_default_init_function(_Env, Main, StateType, Funs) ->
                                  args   => [],
                                  return => {tuple, []},
                                  body   => {tuple, []}} };
-        none -> fcode_error({missing_init_function, Main});
+        none -> fcode_error(missing_init_function);
         _    -> Funs
     end.
 
@@ -1034,14 +962,9 @@ make_closure(FVs, Xs, Body) ->
 lambda_lift_expr({lam, Xs, Body}) ->
     FVs   = free_vars({lam, Xs, Body}),
     make_closure(FVs, Xs, lambda_lift_expr(Body));
-lambda_lift_expr(UExpr) when element(1, UExpr) == def_u; element(1, UExpr) == builtin_u ->
+lambda_lift_expr({Tag, F, Ar}) when Tag == def_u; Tag == builtin_u ->
-    [Tag, F, Ar | _] = tuple_to_list(UExpr),
-    ExtraArgs = case UExpr of
-                    {builtin_u, _, _, TypeArgs} -> TypeArgs;
-                    _                           -> []
-                end,
     Xs   = [ lists:concat(["arg", I]) || I <- lists:seq(1, Ar) ],
-    Args = [{var, X} || X <- Xs] ++ ExtraArgs,
+    Args = [{var, X} || X <- Xs],
     Body = case Tag of
                builtin_u -> builtin_to_fcode(F, Args);
                def_u     -> {def, F, Args}
@@ -1148,7 +1071,7 @@ lookup_type(Env, {qid, _, Name}, Args) ->
     lookup_type(Env, Name, Args);
 lookup_type(Env, Name, Args) ->
     case lookup_type(Env, Name, Args, not_found) of
-        not_found -> internal_error({unknown_type, Name});
+        not_found -> error({unknown_type, Name});
         Type      -> Type
     end.
 
@@ -1233,7 +1156,7 @@ resolve_var(Env, Q) -> resolve_fun(Env, Q).
 
 resolve_fun(#{ fun_env := Funs, builtins := Builtin }, Q) ->
     case {maps:get(Q, Funs, not_found), maps:get(Q, Builtin, not_found)} of
-        {not_found, not_found} -> internal_error({unbound_variable, Q});
+        {not_found, not_found} -> fcode_error({unbound_variable, Q});
         {_, {B, none}}         -> {builtin, B, []};
         {_, {B, Ar}}           -> {builtin_u, B, Ar};
         {{Fun, Ar}, _}         -> {def_u, Fun, Ar}
@@ -1291,7 +1214,6 @@ free_vars(Expr) ->
         {remote_u, _, _, Ct, _}   -> free_vars(Ct);
         {builtin, _, As}     -> free_vars(As);
         {builtin_u, _, _}    -> [];
-        {builtin_u, _, _, _} -> [];     %% Typereps are always literals
         {con, _, _, As}      -> free_vars(As);
         {tuple, As}          -> free_vars(As);
         {proj, A, _}         -> free_vars(A);
@@ -1320,7 +1242,6 @@ used_defs(Expr) ->
         {remote_u, _, _, Ct, _}   -> used_defs(Ct);
         {builtin, _, As}     -> used_defs(As);
         {builtin_u, _, _}    -> [];
-        {builtin_u, _, _, _} -> [];
         {con, _, _, As}      -> used_defs(As);
         {tuple, As}          -> used_defs(As);
         {proj, A, _}         -> used_defs(A);
@@ -1361,7 +1282,6 @@ rename(Ren, Expr) ->
         {def_u, _, _}         -> Expr;
         {builtin, B, Es}      -> {builtin, B, [rename(Ren, E) || E <- Es]};
         {builtin_u, _, _}     -> Expr;
-        {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};
         {con, Ar, I, Es}      -> {con, Ar, I, [rename(Ren, E) || E <- Es]};
@@ -1476,14 +1396,8 @@ get_attributes(Ann) ->
 indexed(Xs) ->
     lists:zip(lists:seq(1, length(Xs)), Xs).
 
--dialyzer({nowarn_function, [fcode_error/1, internal_error/1]}).
+fcode_error(Err) ->
-
+    error(Err).
-fcode_error(Error) ->
-    aeso_errors:throw(aeso_code_errors:format(Error)).
-
-internal_error(Error) ->
-    Msg = lists:flatten(io_lib:format("~p\n", [Error])),
-    aeso_errors:throw(aeso_errors:new(internal_error, aeso_errors:pos(0, 0), Msg)).
 
 %% -- Pretty printing --------------------------------------------------------
 
@@ -1501,6 +1415,7 @@ pp_fun(Name, #{ args := Args, return := Return, body := Body }) ->
                pp_text(" : "), pp_ftype(Return), pp_text(" =")]),
              prettypr:nest(2, pp_fexpr(Body))).
 
+pp_fun_name(init)            -> pp_text('INIT');
 pp_fun_name(event)           -> pp_text(event);
 pp_fun_name({entrypoint, E}) -> pp_text(binary_to_list(E));
 pp_fun_name({local_fun, Q})  -> pp_text(string:join(Q, ".")).
@@ -1508,8 +1423,7 @@ pp_fun_name({local_fun, Q})  -> pp_text(string:join(Q, ".")).
 pp_text(<<>>) -> prettypr:text("\"\"");
 pp_text(Bin) when is_binary(Bin) -> prettypr:text(lists:flatten(io_lib:format("~p", [binary_to_list(Bin)])));
 pp_text(S) when is_list(S) -> prettypr:text(lists:concat([S]));
-pp_text(A) when is_atom(A) -> prettypr:text(atom_to_list(A));
+pp_text(A) when is_atom(A) -> prettypr:text(atom_to_list(A)).
-pp_text(N) when is_integer(N) -> prettypr:text(integer_to_list(N)).
 
 pp_int(I) -> prettypr:text(integer_to_list(I)).
 
@@ -1583,8 +1497,6 @@ pp_fexpr({'let', X, A, B}) ->
             pp_fexpr(B)]);
 pp_fexpr({builtin_u, B, N}) ->
     pp_beside([pp_text(B), pp_text("/"), pp_text(N)]);
-pp_fexpr({builtin_u, B, N, TypeArgs}) ->
-    pp_beside([pp_text(B), pp_text("@"), pp_fexpr({tuple, TypeArgs}), pp_text("/"), pp_text(N)]);
 pp_fexpr({builtin, B, As}) ->
     pp_call(pp_text(B), As);
 pp_fexpr({remote_u, ArgsT, RetT, Ct, Fun}) ->

src/aeso_builtins.erl

@@ -10,7 +10,6 @@
 -module(aeso_builtins).
 
 -export([ builtin_function/1
-        , bytes_to_raw_string/2
         , check_event_type/1
         , used_builtins/1 ]).
 
@@ -45,7 +44,7 @@ builtin_deps1(addr_to_str)                -> [{baseX_int, 58}];
 builtin_deps1({baseX_int, X})             -> [{baseX_int_pad, X}];
 builtin_deps1({baseX_int_pad, X})         -> [{baseX_int_encode, X}];
 builtin_deps1({baseX_int_encode, X})      -> [{baseX_int_encode_, X}, {baseX_tab, X}, {baseX_digits, X}];
-builtin_deps1({bytes_to_str, _})          -> [bytes_to_str_worker, bytes_to_str_worker_x];
+builtin_deps1({bytes_to_str, _})          -> [bytes_to_str_worker];
 builtin_deps1(string_reverse)             -> [string_reverse_];
 builtin_deps1(require)                    -> [abort];
 builtin_deps1(_)                          -> [].
@@ -90,13 +89,7 @@ option_some(X) -> {tuple, [{integer, 1}, X]}.
 -define(BSL(X, B), op('bsl', ?MUL(B, 8), X)).
 -define(BSR(X, B), op('bsr', ?MUL(B, 8), X)).
 
-op(Op, A, B) -> simpl({binop, Op, operand(A), operand(B)}).
+op(Op, A, B) -> {binop, Op, operand(A), operand(B)}.
-
-%% We generate a lot of B * 8 for integer B from BSL and BSR.
-simpl({binop, '*', {integer, A}, {integer, B}}) when A >= 0, B >= 0, A * B < 1 bsl 256 ->
-    {integer, A * B};
-simpl(Op) -> Op.
-
 
 operand(A) when is_atom(A) -> v(A);
 operand(I) when is_integer(I) -> {integer, I};
@@ -168,10 +161,7 @@ builtin_function(BF) ->
         {baseX_int_encode_, X}     -> bfun(BF, builtin_baseX_int_encode_(X));
         {bytes_to_int, N}          -> bfun(BF, builtin_bytes_to_int(N));
         {bytes_to_str, N}          -> bfun(BF, builtin_bytes_to_str(N));
-        {bytes_concat, A, B}       -> bfun(BF, builtin_bytes_concat(A, B));
-        {bytes_split, A, B}        -> bfun(BF, builtin_bytes_split(A, B));
         bytes_to_str_worker        -> bfun(BF, builtin_bytes_to_str_worker());
-        bytes_to_str_worker_x      -> bfun(BF, builtin_bytes_to_str_worker_x());
         string_reverse             -> bfun(BF, builtin_string_reverse());
         string_reverse_            -> bfun(BF, builtin_string_reverse_())
     end.
@@ -522,60 +512,40 @@ builtin_bytes_to_int(N) when N > 32 ->
            end,
     {[{"b", pointer}], Body, word}.
 
-%% Two versions of this helper function, worker for sections not even 16 bytes long
-%% and worker_x for the full sized chunks.
-builtin_bytes_to_str_worker_x() ->
-    <<Tab:256>> = <<"0123456789ABCDEF________________">>,
-    {[{"w", word}, {"offs", word}, {"acc", word}],
-     {ifte, ?EQ(offs, 16), {seq, [?V(acc), {inline_asm, [?A(?MSIZE), ?A(?MSTORE), ?A(?MSIZE)]}]},
-         ?LET(b,  ?BYTE(offs, w),
-         ?LET(lo, ?BYTE(?MOD(b, 16), Tab),
-         ?LET(hi, ?BYTE(op('bsr', 4 , b), Tab),
-         ?call(bytes_to_str_worker_x, [?V(w), ?ADD(offs, 1), ?ADD(?BSL(acc, 2), ?ADD(?BSL(hi, 1), lo))]))))
-     },
-     word}.
-
 builtin_bytes_to_str_worker() ->
     <<Tab:256>> = <<"0123456789ABCDEF________________">>,
-    {[{"w", word}, {"offs", word}, {"acc", word}, {"stop", word}],
+    {[{"w", word}, {"offs", word}, {"acc", word}],
-     {ifte, ?EQ(stop, offs), {seq, [?BSL(acc, ?MUL(2, ?SUB(16, offs))), {inline_asm, [?A(?MSIZE), ?A(?MSTORE), ?A(?MSIZE)]}]},
+     {seq, [{ifte, ?AND(?GT(offs, 0), ?EQ(0, ?MOD(offs, 16))),
-         ?LET(b,  ?BYTE(offs, w),
+                    {seq, [?V(acc), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]}]},
-         ?LET(lo, ?BYTE(?MOD(b, 16), Tab),
+                    {inline_asm, []}},
-         ?LET(hi, ?BYTE(op('bsr', 4 , b), Tab),
+            {ifte, ?EQ(offs, 32), {inline_asm, [?A(?MSIZE)]},
-         ?call(bytes_to_str_worker, [?V(w), ?ADD(offs, 1), ?ADD(?BSL(acc, 2), ?ADD(?BSL(hi, 1), lo)), ?V(stop)]))))
+                ?LET(b,  ?BYTE(offs, w),
-     },
+                ?LET(lo, ?BYTE(?MOD(b, 16), Tab),
+                ?LET(hi, ?BYTE(op('bsr', 4 , b), Tab),
+                ?call(bytes_to_str_worker,
+                      [?V(w), ?ADD(offs, 1), ?ADD(?BSL(acc, 2), ?ADD(?BSL(hi, 1), lo))]))))
+            }
+           ]},
      word}.
 
-builtin_bytes_to_str_body(Var, N) when N < 16 ->
-    [?call(bytes_to_str_worker, [?V(Var), ?I(0), ?I(0), ?I(N)])];
-builtin_bytes_to_str_body(Var, 16) ->
-    [?call(bytes_to_str_worker_x, [?V(Var), ?I(0), ?I(0)])];
-builtin_bytes_to_str_body(Var, N) when N < 32 ->
-    builtin_bytes_to_str_body(Var, 16) ++ [{inline_asm, [?A(?POP)]}] ++
-    [?call(bytes_to_str_worker, [?BSL(Var, 16), ?I(0), ?I(0), ?I(N - 16)])];
-builtin_bytes_to_str_body(Var, 32) ->
-    builtin_bytes_to_str_body(Var, 16) ++ [{inline_asm, [?A(?POP)]}] ++
-    [?call(bytes_to_str_worker_x, [?BSL(Var, 16), ?I(0), ?I(0)])];
-builtin_bytes_to_str_body(Var, N) when N > 32 ->
-    WholeWords = ((N + 31) div 32) - 1,
-    lists:append(
-    [ [?DEREF(w, ?ADD(Var, 32 * I), {seq, builtin_bytes_to_str_body(w, 32)}), {inline_asm, [?A(?POP)]}]
-      || I <- lists:seq(0, WholeWords - 1) ]) ++
-    [ ?DEREF(w, ?ADD(Var, 32 * WholeWords), {seq, builtin_bytes_to_str_body(w, N - WholeWords * 32)}) ].
-
 builtin_bytes_to_str(N) when N =< 32 ->
     {[{"w", word}],
      ?LET(ret, {inline_asm, [?A(?MSIZE)]},
-     {seq, [?I(N * 2), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]}] ++
+     {seq, [?I(N * 2), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
-            builtin_bytes_to_str_body(w, N) ++
+            ?call(bytes_to_str_worker, [?V(w), ?I(0), ?I(0)]),
-            [{inline_asm, [?A(?POP)]}, ?V(ret)]}),
+            {inline_asm, [?A(?POP)]},
+            ?V(ret)]}),
      string};
 builtin_bytes_to_str(N) when N > 32 ->
+    Work = fun(I) ->
+            [?DEREF(w, ?ADD(p, 32 * I), ?call(bytes_to_str_worker, [?V(w), ?I(0), ?I(0)])),
+             {inline_asm, [?A(?POP)]}]
+           end,
     {[{"p", pointer}],
      ?LET(ret, {inline_asm, [?A(?MSIZE)]},
      {seq, [?I(N * 2), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]}] ++
-            builtin_bytes_to_str_body(p, N) ++
+           lists:append([ Work(I) || I <- lists:seq(0, (N + 31) div 32 - 1) ]) ++
-            [{inline_asm, [?A(?POP)]}, ?V(ret)]}),
+           [?V(ret)]}),
      string}.
 
 builtin_string_reverse() ->
@@ -605,80 +575,3 @@ builtin_string_reverse_() ->
 builtin_addr_to_str() ->
     {[{"a", word}], ?call({baseX_int, 58}, [?V(a)]), word}.
 
-%% At most one word
-%% | ..... | ========= | ........ |
-%%    Offs ^ ^- Len -^   TotalLen ^
-bytes_slice(Offs, Len, TotalLen, Bytes) when TotalLen =< 32 ->
-    %% Bytes are packed into a single word
-    Masked =
-        case Offs of
-            0 -> Bytes;
-            _ -> ?MOD(Bytes, 1 bsl ((32 - Offs) * 8))
-        end,
-    Unpadded =
-        case 32 - (Offs + Len) of
-            0 -> Masked;
-            N -> ?BSR(Masked, N)
-        end,
-    case Len of
-        32 -> Unpadded;
-        _  -> ?BSL(Unpadded, 32 - Len)
-    end;
-bytes_slice(Offs, Len, TotalLen, Bytes) when TotalLen > 32 ->
-    %% Bytes is a pointer to memory. The VM can read at non-aligned addresses.
-    %% Might read one word more than necessary.
-    Word = op('!', Offs, Bytes),
-    case Len == 32 of
-        true -> Word;
-        _    -> ?BSL(?BSR(Word, 32 - Len), 32 - Len)
-    end.
-
-builtin_bytes_concat(A, B) ->
-    Type     = fun(N) when N =< 32 -> word; (_) -> pointer end,
-    MkBytes  = fun([W]) -> W;
-                  (Ws)  -> {tuple, Ws} end,
-    Words    = fun(N) -> (N + 31) div 32 end,
-    WordsRes = Words(A + B),
-    Word = fun(I) when 32 * (I + 1) =< A -> bytes_slice(I * 32, 32, A, ?V(a));
-              (I) when 32 * I < A ->
-                   Len = A rem 32,
-                   Hi  = bytes_slice(32 * I, Len, A, ?V(a)),
-                   Lo  = bytes_slice(0, min(32 - Len, B), B, ?V(b)),
-                   ?ADD(Hi, ?BSR(Lo, Len));
-              (I) ->
-                   Offs = 32 * I - A,
-                   Len  = min(32, B - Offs),
-                   bytes_slice(Offs, Len, B, ?V(b))
-           end,
-    Body =
-        case {A, B} of
-            {0, _} -> ?V(b);
-            {_, 0} -> ?V(a);
-            _      -> MkBytes([ Word(I) || I <- lists:seq(0, WordsRes - 1) ])
-        end,
-    {[{"a", Type(A)}, {"b", Type(B)}], Body, Type(A + B)}.
-
-builtin_bytes_split(A, B) ->
-    Type    = fun(N) when N =< 32 -> word; (_) -> pointer end,
-    MkBytes = fun([W]) -> W;
-                 (Ws)  -> {tuple, Ws} end,
-    Word    = fun(I, Max) ->
-                bytes_slice(I, min(32, Max - I), A + B, ?V(c))
-              end,
-    Body =
-        case {A, B} of
-            {0, _} -> [?I(0), ?V(c)];
-            {_, 0} -> [?V(c), ?I(0)];
-            _      -> [MkBytes([ Word(I, A)     || I <- lists:seq(0, A - 1, 32) ]),
-                       MkBytes([ Word(I, A + B) || I <- lists:seq(A, A + B - 1, 32) ])]
-        end,
-    {[{"c", Type(A + B)}], {tuple, Body}, {tuple, [Type(A), Type(B)]}}.
-
-bytes_to_raw_string(N, Term) when N =< 32 ->
-    {tuple, [?I(N), Term]};
-bytes_to_raw_string(N, Term) when N > 32 ->
-    Elem  = fun(I) -> #binop{op = '!', left = ?I(32 * I), right = ?V(bin)}
-            end,
-    Words = (N + 31) div 32,
-    ?LET(bin, Term, {tuple, [?I(N) | [Elem(I) || I <- lists:seq(0, Words - 1)]]}).
-

src/aeso_code_errors.erl

@@ -1,120 +0,0 @@
-%%%-------------------------------------------------------------------
-%%% @author Ulf Norell
-%%% @copyright (C) 2019, Aeternity Anstalt
-%%% @doc
-%%%     Formatting of code generation errors.
-%%% @end
-%%%
-%%%-------------------------------------------------------------------
--module(aeso_code_errors).
-
--export([format/1, pos/1]).
-
-format({last_declaration_must_be_contract, Decl = {namespace, _, {con, _, C}, _}}) ->
-    Msg = io_lib:format("Expected a contract as the last declaration instead of the namespace '~s'\n",
-                        [C]),
-    mk_err(pos(Decl), Msg);
-format({missing_init_function, Con}) ->
-    Msg = io_lib:format("Missing init function for the contract '~s'.\n", [pp_expr(Con)]),
-    Cxt = "The 'init' function can only be omitted if the state type is 'unit'.\n",
-    mk_err(pos(Con), Msg, Cxt);
-format({missing_definition, Id}) ->
-    Msg = io_lib:format("Missing definition of function '~s'.\n", [pp_expr(Id)]),
-    mk_err(pos(Id), Msg);
-format({parameterized_state, Decl}) ->
-    Msg = "The state type cannot be parameterized.\n",
-    mk_err(pos(Decl), Msg);
-format({parameterized_event, Decl}) ->
-    Msg = "The event type cannot be parameterized.\n",
-    mk_err(pos(Decl), Msg);
-format({invalid_entrypoint, Why, Ann, {id, _, Name}, Thing}) ->
-    What = case Why of higher_order -> "higher-order (contains function types)";
-                       polymorphic  -> "polymorphic (contains type variables)" end,
-    ThingS = case Thing of
-                 {argument, X, T} -> io_lib:format("argument\n~s\n", [pp_typed(X, T)]);
-                 {result, T}      -> io_lib:format("return type\n~s\n", [pp_type(2, T)])
-             end,
-    Bad = case Thing of
-              {argument, _, _} -> io_lib:format("has a ~s type", [What]);
-              {result, _}      -> io_lib:format("is ~s", [What])
-          end,
-    Msg = io_lib:format("The ~sof entrypoint '~s' ~s.\n",
-                        [ThingS, Name, Bad]),
-    case Why of
-        polymorphic  -> mk_err(pos(Ann), Msg, "Use the FATE backend if you want polymorphic entrypoints.\n");
-        higher_order -> mk_err(pos(Ann), Msg)
-    end;
-format({cant_compare_type_aevm, Ann, Op, Type}) ->
-    StringAndTuple = [ "- type string\n"
-                       "- tuple or record of word type\n" || lists:member(Op, ['==', '!=']) ],
-    Msg = io_lib:format("Cannot compare values of type\n"
-                        "~s\n"
-                        "The AEVM only supports '~s' on values of\n"
-                        "- word type (int, bool, bits, address, oracle(_, _), etc)\n"
-                        "~s",
-                        [pp_type(2, Type), Op, StringAndTuple]),
-    Cxt = "Use FATE if you need to compare arbitrary types.\n",
-    mk_err(pos(Ann), Msg, Cxt);
-format({invalid_aens_resolve_type, Ann, T}) ->
-    Msg = io_lib:format("Invalid return type of AENS.resolve:\n"
-                        "~s\n"
-                        "It must be a string or a pubkey type (address, oracle, etc).\n",
-                        [pp_type(2, T)]),
-    mk_err(pos(Ann), Msg);
-format({unapplied_contract_call, Contract}) ->
-    Msg = io_lib:format("The AEVM does not support unapplied contract call to\n"
-                        "~s\n", [pp_expr(2, Contract)]),
-    Cxt = "Use FATE if you need this.\n",
-    mk_err(pos(Contract), Msg, Cxt);
-format({unapplied_builtin, Id}) ->
-    Msg = io_lib:format("The AEVM does not support unapplied use of ~s.\n", [pp_expr(0, Id)]),
-    Cxt = "Use FATE if you need this.\n",
-    mk_err(pos(Id), Msg, Cxt);
-format({invalid_map_key_type, Why, Ann, Type}) ->
-    Msg = io_lib:format("Invalid map key type\n~s\n", [pp_type(2, Type)]),
-    Cxt = case Why of
-             polymorphic -> "Map keys cannot be polymorphic in the AEVM. Use FATE if you need this.\n";
-             function    -> "Map keys cannot be higher-order.\n"
-          end,
-    mk_err(pos(Ann), Msg, Cxt);
-format({invalid_oracle_type, Why, What, Ann, Type}) ->
-    WhyS = case Why of higher_order -> "higher-order (contain function types)";
-                       polymorphic  -> "polymorphic (contain type variables)" end,
-    Msg = io_lib:format("Invalid oracle type\n~s\n", [pp_type(2, Type)]),
-    Cxt = io_lib:format("The ~s type must not be ~s.\n", [What, WhyS]),
-    mk_err(pos(Ann), Msg, Cxt);
-format({higher_order_state, {type_def, Ann, _, _, State}}) ->
-    Msg = io_lib:format("Invalid state type\n~s\n", [pp_type(2, State)]),
-    Cxt = "The state cannot contain functions in the AEVM. Use FATE if you need this.\n",
-    mk_err(pos(Ann), Msg, Cxt);
-
-format(Err) ->
-    mk_err(aeso_errors:pos(0, 0), io_lib:format("Unknown error: ~p\n", [Err])).
-
-pos(Ann) ->
-    File = aeso_syntax:get_ann(file, Ann, no_file),
-    Line = aeso_syntax:get_ann(line, Ann, 0),
-    Col  = aeso_syntax:get_ann(col, Ann, 0),
-    aeso_errors:pos(File, Line, Col).
-
-pp_typed(E, T) ->
-    prettypr:format(prettypr:nest(2,
-    lists:foldr(fun prettypr:beside/2, prettypr:empty(),
-                [aeso_pretty:expr(E), prettypr:text(" : "),
-                 aeso_pretty:type(T)]))).
-
-pp_expr(E) ->
-    pp_expr(0, E).
-
-pp_expr(N, E) ->
-    prettypr:format(prettypr:nest(N, aeso_pretty:expr(E))).
-
-pp_type(N, T) ->
-    prettypr:format(prettypr:nest(N, aeso_pretty:type(T))).
-
-mk_err(Pos, Msg) ->
-    aeso_errors:new(code_error, Pos, lists:flatten(Msg)).
-
-mk_err(Pos, Msg, Cxt) ->
-    aeso_errors:new(code_error, Pos, lists:flatten(Msg), lists:flatten(Cxt)).
-

src/aeso_compiler.erl

@@ -65,18 +65,18 @@ version() ->
             {ok, list_to_binary(VsnString)}
     end.
 
--spec file(string()) -> {ok, map()} | {error, [aeso_errors:error()]}.
+-spec file(string()) -> {ok, map()} | {error, binary()}.
 file(Filename) ->
     file(Filename, []).
 
--spec file(string(), options()) -> {ok, map()} | {error, [aeso_errors:error()]}.
+-spec file(string(), options()) -> {ok, map()} | {error, binary()}.
 file(File, Options0) ->
     Options = add_include_path(File, Options0),
     case read_contract(File) of
         {ok, Bin} -> from_string(Bin, [{src_file, File} | Options]);
         {error, Error} ->
-            Msg = lists:flatten([File,": ",file:format_error(Error)]),
+	    ErrorString = [File,": ",file:format_error(Error)],
-            {error, [aeso_errors:new(file_error, Msg)]}
+	    {error, join_errors("File errors", [ErrorString], fun(E) -> E end)}
     end.
 
 add_include_path(File, Options) ->
@@ -88,7 +88,7 @@ add_include_path(File, Options) ->
             [{include, {file_system, [Cwd, Dir]}} | Options]
     end.
 
--spec from_string(binary() | string(), options()) -> {ok, map()} | {error, [aeso_errors:error()]}.
+-spec from_string(binary() | string(), options()) -> {ok, map()} | {error, binary()}.
 from_string(Contract, Options) ->
     from_string(proplists:get_value(backend, Options, aevm), Contract, Options).
 
@@ -98,14 +98,22 @@ from_string(Backend, ContractString, Options) ->
     try
         from_string1(Backend, ContractString, Options)
     catch
-        throw:{error, Errors} -> {error, Errors}
+        %% The compiler errors.
+        error:{parse_errors, Errors} ->
+            {error, join_errors("Parse errors", Errors, fun(E) -> E end)};
+        error:{type_errors, Errors} ->
+            {error, join_errors("Type errors", Errors, fun(E) -> E end)};
+        error:{code_errors, Errors} ->
+            {error, join_errors("Code errors", Errors,
+                                fun (E) -> io_lib:format("~p", [E]) end)}
+        %% General programming errors in the compiler just signal error.
     end.
 
 from_string1(aevm, ContractString, Options) ->
     #{icode := Icode} = string_to_code(ContractString, Options),
     TypeInfo  = extract_type_info(Icode),
     Assembler = assemble(Icode, Options),
-    pp_assembler(aevm, Assembler, Options),
+    pp_assembler(Assembler, Options),
     ByteCodeList = to_bytecode(Assembler, Options),
     ByteCode = << << B:8 >> || B <- ByteCodeList >>,
     pp_bytecode(ByteCode, Options),
@@ -120,7 +128,6 @@ from_string1(aevm, ContractString, Options) ->
 from_string1(fate, ContractString, Options) ->
     #{fcode := FCode} = string_to_code(ContractString, Options),
     FateCode = aeso_fcode_to_fate:compile(FCode, Options),
-    pp_assembler(fate, FateCode, Options),
     ByteCode = aeb_fate_code:serialize(FateCode, []),
     {ok, Version} = version(),
     {ok, #{byte_code => ByteCode,
@@ -137,7 +144,7 @@ string_to_code(ContractString, Options) ->
     Ast = parse(ContractString, Options),
     pp_sophia_code(Ast, Options),
     pp_ast(Ast, Options),
-    {TypeEnv, TypedAst} = aeso_ast_infer_types:infer(Ast, [return_env | Options]),
+    {TypeEnv, TypedAst} = aeso_ast_infer_types:infer(Ast, [return_env]),
     pp_typed_ast(TypedAst, Options),
     case proplists:get_value(backend, Options, aevm) of
         aevm ->
@@ -153,6 +160,10 @@ string_to_code(ContractString, Options) ->
                type_env  => TypeEnv}
     end.
 
+join_errors(Prefix, Errors, Pfun) ->
+    Ess = [ Pfun(E) || E <- Errors ],
+    list_to_binary(string:join([Prefix|Ess], "\n")).
+
 -define(CALL_NAME,   "__call").
 -define(DECODE_NAME, "__decode").
 
@@ -164,7 +175,7 @@ string_to_code(ContractString, Options) ->
 %%       a special return type (typerep, T)
 -spec check_call(string(), string(), [string()], options()) -> {ok, string(), {[Type], Type}, [term()]}
                                                                    | {ok, string(), [term()]}
-                                                                   | {error, [aeso_errors:error()]}
+                                                                   | {error, term()}
     when Type :: term().
 check_call(Source, "init" = FunName, Args, Options) ->
     case check_call1(Source, FunName, Args, Options) of
@@ -219,7 +230,16 @@ check_call1(ContractString0, FunName, Args, Options) ->
                 {ok, FunName, CallArgs}
         end
     catch
-        throw:{error, Errors} -> {error, Errors}
+        error:{parse_errors, Errors} ->
+            {error, join_errors("Parse errors", Errors, fun (E) -> E end)};
+        error:{type_errors, Errors} ->
+            {error, join_errors("Type errors", Errors, fun (E) -> E end)};
+        error:{badmatch, {error, missing_call_function}} ->
+            {error, join_errors("Type errors", ["missing __call function"],
+                                fun (E) -> E end)};
+        throw:Error ->                          %Don't ask
+            {error, join_errors("Code errors", [Error],
+                                fun (E) -> io_lib:format("~p", [E]) end)}
     end.
 
 arguments_of_body(CallName, _FunName, Fcode) ->
@@ -267,31 +287,24 @@ last_contract_indent(Decls) ->
     end.
 
 -spec to_sophia_value(string(), string(), ok | error | revert, aeb_aevm_data:data()) ->
-        {ok, aeso_syntax:expr()} | {error, [aeso_errors:error()]}.
+        {ok, aeso_syntax:expr()} | {error, term()}.
 to_sophia_value(ContractString, Fun, ResType, Data) ->
     to_sophia_value(ContractString, Fun, ResType, Data, [{backend, aevm}]).
 
 -spec to_sophia_value(string(), string(), ok | error | revert, binary(), options()) ->
-        {ok, aeso_syntax:expr()} | {error, [aeso_errors:error()]}.
+        {ok, aeso_syntax:expr()} | {error, term()}.
 to_sophia_value(_, _, error, Err, _Options) ->
     {ok, {app, [], {id, [], "error"}, [{string, [], Err}]}};
 to_sophia_value(_, _, revert, Data, Options) ->
     case proplists:get_value(backend, Options, aevm) of
         aevm ->
             case aeb_heap:from_binary(string, Data) of
-                {ok, Err} ->
+                {ok, Err} -> {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}};
-                    {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}};
+                {error, _} = Err -> Err
-                {error, _} ->
-                    Msg = "Could not interpret the revert message\n",
-                    {error, [aeso_errors:new(data_error, Msg)]}
             end;
         fate ->
-            try aeb_fate_encoding:deserialize(Data) of
+            Err = aeb_fate_encoding:deserialize(Data),
-                Err -> {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}}
+            {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}}
-            catch _:_ ->
-                Msg = "Could not deserialize the revert message\n",
-                {error, [aeso_errors:new(data_error, Msg)]}
-            end
     end;
 to_sophia_value(ContractString, FunName, ok, Data, Options0) ->
     Options = [no_code | Options0],
@@ -311,41 +324,49 @@ to_sophia_value(ContractString, FunName, ok, Data, Options0) ->
                             {ok, aeso_vm_decode:from_aevm(VmType, Type, VmValue)}
                         catch throw:cannot_translate_to_sophia ->
                             Type0Str = prettypr:format(aeso_pretty:type(Type0)),
-                            Msg = io_lib:format("Cannot translate VM value ~p\n  of type ~p\n  to Sophia type ~s\n",
+                            {error, join_errors("Translation error", [lists:flatten(io_lib:format("Cannot translate VM value ~p\n  of type ~p\n  to Sophia type ~s\n",
-                                                [Data, VmType, Type0Str]),
+                                                                                    [Data, VmType, Type0Str]))],
-                            {error, [aeso_errors:new(data_error, Msg)]}
+                                                fun (E) -> E end)}
                         end;
                     {error, _Err} ->
-                        Msg = io_lib:format("Failed to decode binary as type ~p\n", [VmType]),
+                        {error, join_errors("Decode errors", [lists:flatten(io_lib:format("Failed to decode binary at type ~p", [VmType]))],
-                        {error, [aeso_errors:new(data_error, Msg)]}
+                                            fun(E) -> E end)}
                 end;
             fate ->
-                try
+               try
-                    {ok, aeso_vm_decode:from_fate(Type, aeb_fate_encoding:deserialize(Data))}
+                   {ok, aeso_vm_decode:from_fate(Type, aeb_fate_encoding:deserialize(Data))}
-                catch throw:cannot_translate_to_sophia ->
+               catch throw:cannot_translate_to_sophia ->
-                        Type1 = prettypr:format(aeso_pretty:type(Type)),
+                   {error, join_errors("Translation error",
-                        Msg = io_lib:format("Cannot translate FATE value ~p\n  of Sophia type ~s\n",
+                                       [lists:flatten(io_lib:format("Cannot translate fate value ~p\n of Sophia type ~s\n",
-                                            [aeb_fate_encoding:deserialize(Data), Type1]),
+                                                                    [aeb_fate_encoding:deserialize(Data), Type]))],
-                        {error, [aeso_errors:new(data_error, Msg)]};
+                                       fun (E) -> E end)};
-                      _:_ ->
+                     _:R ->
-                        Type1 = prettypr:format(aeso_pretty:type(Type)),
+                   {error, iolist_to_binary(io_lib:format("Decode error ~p: ~p\n", [R, erlang:get_stacktrace()]))}
-                        Msg = io_lib:format("Failed to decode binary as type ~s\n", [Type1]),
-                        {error, [aeso_errors:new(data_error, Msg)]}
                end
         end
     catch
-        throw:{error, Errors} -> {error, Errors}
+        error:{parse_errors, Errors} ->
+            {error, join_errors("Parse errors", Errors, fun (E) -> E end)};
+        error:{type_errors, Errors} ->
+            {error, join_errors("Type errors", Errors, fun (E) -> E end)};
+        error:{badmatch, {error, missing_function}} ->
+            {error, join_errors("Type errors", ["no function: '" ++ FunName ++ "'"],
+                                fun (E) -> E end)};
+        throw:Error ->                          %Don't ask
+            {error, join_errors("Code errors", [Error],
+                                fun (E) -> io_lib:format("~p", [E]) end)}
     end.
 
 
 -spec create_calldata(string(), string(), [string()]) ->
                              {ok, binary(), aeb_aevm_data:type(), aeb_aevm_data:type()}
-                             | {error, [aeso_errors:error()]}.
+                             | {error, term()}.
 create_calldata(Code, Fun, Args) ->
     create_calldata(Code, Fun, Args, [{backend, aevm}]).
 
 -spec create_calldata(string(), string(), [string()], [{atom(), any()}]) ->
-                             {ok, binary()} | {error, [aeso_errors:error()]}.
+                             {ok, binary()}
+                             | {error, term()}.
 create_calldata(Code, Fun, Args, Options0) ->
     Options = [no_code | Options0],
     case proplists:get_value(backend, Options, aevm) of
@@ -365,7 +386,7 @@ create_calldata(Code, Fun, Args, Options0) ->
 
 -spec decode_calldata(string(), string(), binary()) ->
                              {ok, [aeso_syntax:type()], [aeso_syntax:expr()]}
-                             | {error, [aeso_errors:error()]}.
+                             | {error, term()}.
 decode_calldata(ContractString, FunName, Calldata) ->
     decode_calldata(ContractString, FunName, Calldata, [{backend, aevm}]).
 
@@ -392,14 +413,15 @@ decode_calldata(ContractString, FunName, Calldata, Options0) ->
                             %% Values are Sophia expressions in AST format
                             {ok, ArgTypes, Values}
                         catch throw:cannot_translate_to_sophia ->
-                            Type0Str = prettypr:format(aeso_pretty:type(Type0)),
+                                Type0Str = prettypr:format(aeso_pretty:type(Type0)),
-                            Msg = io_lib:format("Cannot translate VM value ~p\n  of type ~p\n  to Sophia type ~s\n",
+                                {error, join_errors("Translation error",
-                                                [VmValue, VmType, Type0Str]),
+                                                    [lists:flatten(io_lib:format("Cannot translate VM value ~p\n  of type ~p\n  to Sophia type ~s\n",
-                            {error, [aeso_errors:new(data_error, Msg)]}
+                                                                                 [VmValue, VmType, Type0Str]))],
+                                                    fun (E) -> E end)}
                         end;
                     {error, _Err} ->
-                        Msg = io_lib:format("Failed to decode calldata as type ~p\n", [VmType]),
+                        {error, join_errors("Decode errors", [lists:flatten(io_lib:format("Failed to decode binary at type ~p", [VmType]))],
-                        {error, [aeso_errors:new(data_error, Msg)]}
+                                            fun(E) -> E end)}
                 end;
             fate ->
                 case aeb_fate_abi:decode_calldata(FunName, Calldata) of
@@ -411,30 +433,35 @@ decode_calldata(ContractString, FunName, Calldata, Options0) ->
                             {ok, ArgTypes, AstArgs}
                         catch throw:cannot_translate_to_sophia ->
                                 Type0Str = prettypr:format(aeso_pretty:type(Type0)),
-                                Msg = io_lib:format("Cannot translate FATE value ~p\n  to Sophia type ~s\n",
+                                {error, join_errors("Translation error",
-                                                    [FateArgs, Type0Str]),
+                                                    [lists:flatten(io_lib:format("Cannot translate fate value ~p\n of Sophia type ~s\n",
-                                {error, [aeso_errors:new(data_error, Msg)]}
+                                                                                 [FateArgs, Type0Str]))],
+                                                    fun (E) -> E end)}
                         end;
                     {error, _} ->
-                        Msg = io_lib:format("Failed to decode calldata binary\n", []),
+                        {error, join_errors("Decode errors", ["Failed to decode binary"],
-                        {error, [aeso_errors:new(data_error, Msg)]}
+                                            fun(E) -> E end)}
                 end
         end
     catch
-        throw:{error, Errors} -> {error, Errors}
+        error:{parse_errors, Errors} ->
+            {error, join_errors("Parse errors", Errors, fun (E) -> E end)};
+        error:{type_errors, Errors} ->
+            {error, join_errors("Type errors", Errors, fun (E) -> E end)};
+        error:{badmatch, {error, missing_function}} ->
+            {error, join_errors("Type errors", ["no function: '" ++ FunName ++ "'"],
+                                fun (E) -> E end)};
+        throw:Error ->                          %Don't ask
+            {error, join_errors("Code errors", [Error],
+                                fun (E) -> io_lib:format("~p", [E]) end)}
     end.
 
 get_arg_icode(Funs) ->
     case [ Args || {[_, ?CALL_NAME], _, _, {funcall, _, Args}, _} <- Funs ] of
         [Args] -> Args;
-        []     -> error_missing_call_function()
+        []     -> error({missing_call_function, Funs})
     end.
 
--dialyzer({nowarn_function, error_missing_call_function/0}).
-error_missing_call_function() ->
-    Msg = "Internal error: missing '__call'-function",
-    aeso_errors:throw(aeso_errors:new(internal_error, Msg)).
-
 get_call_type([{contract, _, _, Defs}]) ->
     case [ {lists:last(QFunName), FunType}
           || {letfun, _, {id, _, ?CALL_NAME}, [], _Ret,
@@ -442,14 +469,13 @@ get_call_type([{contract, _, _, Defs}]) ->
                     {app, _,
                         {typed, _, {qid, _, QFunName}, FunType}, _}, _}} <- Defs ] of
         [Call] -> {ok, Call};
-        []     -> error_missing_call_function()
+        []     -> {error, missing_call_function}
     end;
 get_call_type([_ | Contracts]) ->
     %% The __call should be in the final contract
     get_call_type(Contracts).
 
--dialyzer({nowarn_function, get_decode_type/2}).
+get_decode_type(FunName, [{contract, _, _, Defs}]) ->
-get_decode_type(FunName, [{contract, Ann, _, Defs}]) ->
     GetType = fun({letfun, _, {id, _, Name}, Args, Ret, _})               when Name == FunName -> [{Args, Ret}];
                  ({fun_decl, _, {id, _, Name}, {fun_t, _, _, Args, Ret}}) when Name == FunName -> [{Args, Ret}];
                  (_) -> [] end,
@@ -458,10 +484,7 @@ get_decode_type(FunName, [{contract, Ann, _, Defs}]) ->
         []            ->
             case FunName of
                 "init" -> {ok, [], {tuple_t, [], []}};
-                 _ ->
+                 _ -> {error, missing_function}
-                    Msg = io_lib:format("Function '~s' is missing in contract\n", [FunName]),
-                    Pos = aeso_code_errors:pos(Ann),
-                    aeso_errors:throw(aeso_errors:new(data_error, Pos, Msg))
             end
     end;
 get_decode_type(FunName, [_ | Contracts]) ->
@@ -533,11 +556,9 @@ pp_sophia_code(C, Opts)->  pp(C, Opts, pp_sophia_code, fun(Code) ->
 pp_ast(C, Opts)      ->  pp(C, Opts, pp_ast, fun aeso_ast:pp/1).
 pp_typed_ast(C, Opts)->  pp(C, Opts, pp_typed_ast, fun aeso_ast:pp_typed/1).
 pp_icode(C, Opts)    ->  pp(C, Opts, pp_icode, fun aeso_icode:pp/1).
+pp_assembler(C, Opts)->  pp(C, Opts, pp_assembler, fun aeb_asm:pp/1).
 pp_bytecode(C, Opts) ->  pp(C, Opts, pp_bytecode, fun aeb_disassemble:pp/1).
 
-pp_assembler(aevm, C, Opts) ->  pp(C, Opts, pp_assembler, fun aeb_asm:pp/1);
-pp_assembler(fate, C, Opts) ->  pp(C, Opts, pp_assembler, fun(Asm) -> io:format("~s", [aeb_fate_asm:pp(Asm)]) end).
-
 pp(Code, Options, Option, PPFun) ->
     case proplists:lookup(Option, Options) of
         {Option, true} ->
@@ -561,7 +582,37 @@ parse(Text, Options) ->
 
 -spec parse(string(), sets:set(), aeso_compiler:options()) -> none() | aeso_syntax:ast().
 parse(Text, Included, Options) ->
-    aeso_parser:string(Text, Included, Options).
+    %% Try and return something sensible here!
+    case aeso_parser:string(Text, Included, Options) of
+        %% Yay, it worked!
+        {ok, Contract} -> Contract;
+        %% Scan errors.
+        {error, {Pos, scan_error}} ->
+            parse_error(Pos, "scan error");
+        {error, {Pos, scan_error_no_state}} ->
+            parse_error(Pos, "scan error");
+        %% Parse errors.
+        {error, {Pos, parse_error, Error}} ->
+            parse_error(Pos, Error);
+        {error, {Pos, ambiguous_parse, As}} ->
+            ErrorString = io_lib:format("Ambiguous ~p", [As]),
+            parse_error(Pos, ErrorString);
+        %% Include error
+        {error, {Pos, include_error, File}} ->
+            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]}).
 
 read_contract(Name) ->
     file:read_file(Name).
+
+pos_error({Line, Pos}) ->
+    io_lib:format("line ~p, column ~p", [Line, Pos]);
+pos_error({no_file, Line, Pos}) ->
+    pos_error({Line, Pos});
+pos_error({File, Line, Pos}) ->
+    io_lib:format("file ~s, line ~p, column ~p", [File, Line, Pos]).

src/aeso_constants.erl

@@ -0,0 +1,42 @@
+-module(aeso_constants).
+
+-export([string/1, get_type/1]).
+
+string(Str) ->
+    case aeso_parser:string("let _ = " ++ Str) of
+        {ok, [{letval, _, _, _, E}]} -> {ok, E};
+        {ok, Other}                  -> error({internal_error, should_be_letval, Other});
+        Err                          -> Err
+    end.
+
+get_type(Str) ->
+    case aeso_parser:string("let _ = " ++ Str) of
+        {ok, [Ast]} ->
+            AstT = aeso_ast_infer_types:infer_constant(Ast),
+            T = ast_to_type(AstT),
+            {ok, T};
+        {ok, Other} -> error({internal_error, should_be_letval, Other});
+        Err         -> Err
+    end.
+
+ast_to_type({id, _, T}) ->
+    T;
+ast_to_type({tuple_t, _, []}) -> "()";
+ast_to_type({tuple_t, _, Ts}) ->
+    "(" ++ list_ast_to_type(Ts) ++ ")";
+ast_to_type({app_t,_, {id, _, "list"}, [T]}) ->
+    lists:flatten("list(" ++ ast_to_type(T) ++ ")");
+ast_to_type({app_t,_, {id, _, "option"}, [T]}) ->
+    lists:flatten("option(" ++ ast_to_type(T) ++ ")").
+
+list_ast_to_type([T]) ->
+    ast_to_type(T);
+list_ast_to_type([T|Ts]) ->
+    ast_to_type(T)
+        ++ ", "
+        ++ list_ast_to_type(Ts).
+
+
+
+
+

src/aeso_errors.erl

@@ -1,112 +0,0 @@
-%%%-------------------------------------------------------------------
-%%% @copyright (C) 2019, Aeternity Anstalt
-%%% @doc ADT for structured error messages + formatting.
-%%%
-%%% @end
-%%%-------------------------------------------------------------------
-
--module(aeso_errors).
-
--type src_file()   :: no_file | iolist().
-
--record(pos, { file = no_file :: src_file()
-             , line = 0       :: non_neg_integer()
-             , col  = 0       :: non_neg_integer()
-             }).
-
--type pos()        :: #pos{}.
--type error_type() :: type_error | parse_error | code_error
-                    | file_error | data_error | internal_error.
-
--record(err, { pos = #pos{}   :: pos()
-             , type           :: error_type()
-             , message        :: iolist()
-             , context = none :: none | iolist()
-             }).
-
--opaque error() :: #err{}.
-
--export_type([error/0, pos/0]).
-
--export([ err_msg/1
-        , msg/1
-        , new/2
-        , new/3
-        , new/4
-        , pos/2
-        , pos/3
-        , pp/1
-        , to_json/1
-        , throw/1
-        , type/1
-        ]).
-
-new(Type, Msg) ->
-    new(Type, pos(0, 0), Msg).
-
-new(Type, Pos, Msg) ->
-    #err{ type = Type, pos = Pos, message = Msg }.
-
-new(Type, Pos, Msg, Ctxt) ->
-    #err{ type = Type, pos = Pos, message = Msg, context = Ctxt }.
-
-pos(Line, Col) ->
-    #pos{ line = Line, col = Col }.
-
-pos(File, Line, Col) ->
-    #pos{ file = File, line = Line, col = Col }.
-
--spec throw(_) -> ok | no_return().
-throw([]) -> ok;
-throw(Errs) when is_list(Errs) ->
-    SortedErrs = lists:sort(fun(E1, E2) -> E1#err.pos =< E2#err.pos end, Errs),
-    erlang:throw({error, SortedErrs});
-throw(#err{} = Err) ->
-    erlang:throw({error, [Err]}).
-
-msg(#err{ message = Msg, context = none }) -> Msg;
-msg(#err{ message = Msg, context = Ctxt }) -> Msg ++ Ctxt.
-
-err_msg(#err{ pos = Pos } = Err) ->
-    lists:flatten(io_lib:format("~s~s", [str_pos(Pos), msg(Err)])).
-
-str_pos(#pos{file = no_file, line = L, col = C}) ->
-    io_lib:format("~p:~p:", [L, C]);
-str_pos(#pos{file = F, line = L, col = C}) ->
-    io_lib:format("~s:~p:~p:", [F, L, C]).
-
-type(#err{ type = Type }) -> Type.
-
-pp(#err{ type = Kind, pos = Pos } = Err) ->
-    lists:flatten(io_lib:format("~s~s:\n~s", [pp_kind(Kind), pp_pos(Pos), msg(Err)])).
-
-pp_kind(type_error)     -> "Type error";
-pp_kind(parse_error)    -> "Parse error";
-pp_kind(code_error)     -> "Code generation error";
-pp_kind(file_error)     -> "File error";
-pp_kind(data_error)     -> "Data error";
-pp_kind(internal_error) -> "Internal error".
-
-pp_pos(#pos{file = no_file, line = 0, col = 0}) ->
-    "";
-pp_pos(#pos{file = no_file, line = L, col = C}) ->
-    io_lib:format(" at line ~p, col ~p", [L, C]);
-pp_pos(#pos{file = F, line = L, col = C}) ->
-    io_lib:format(" in '~s' at line ~p, col ~p", [F, L, C]).
-
-to_json(#err{pos = Pos, type = Type, message = Msg, context = Cxt}) ->
-    Json = #{ pos     => pos_to_json(Pos),
-              type    => atom_to_binary(Type, utf8),
-              message => iolist_to_binary(Msg) },
-    case Cxt of
-        none -> Json;
-        _    -> Json#{ context => iolist_to_binary(Cxt) }
-    end.
-
-pos_to_json(#pos{ file = File, line = Line, col = Col }) ->
-    Json = #{ line => Line, col => Col },
-    case File of
-        no_file -> Json;
-        _       -> Json#{ file => iolist_to_binary(File) }
-    end.
-

src/aeso_fcode_to_fate.erl

@@ -106,8 +106,6 @@
      Op =:= 'AUTH_TX_HASH'         orelse
      Op =:= 'BYTES_TO_INT'         orelse
      Op =:= 'BYTES_TO_STR'         orelse
-     Op =:= 'BYTES_CONCAT'         orelse
-     Op =:= 'BYTES_SPLIT'          orelse
      Op =:= 'ORACLE_CHECK'         orelse
      Op =:= 'ORACLE_CHECK_QUERY'   orelse
      Op =:= 'IS_ORACLE'            orelse
@@ -145,6 +143,7 @@ compile(FCode, Options) ->
 make_function_id(X) ->
     aeb_fate_code:symbol_identifier(make_function_name(X)).
 
+make_function_name(init)               -> <<"INIT">>;
 make_function_name(event)              -> <<"Chain.event">>;
 make_function_name({entrypoint, Name}) -> Name;
 make_function_name({local_fun, Xs})    -> list_to_binary("." ++ string:join(Xs, ".")).
@@ -492,10 +491,6 @@ builtin_to_scode(Env, bytes_to_int, [_] = Args) ->
     call_to_scode(Env, aeb_fate_ops:bytes_to_int(?a, ?a), Args);
 builtin_to_scode(Env, bytes_to_str, [_] = Args) ->
     call_to_scode(Env, aeb_fate_ops:bytes_to_str(?a, ?a), Args);
-builtin_to_scode(Env, bytes_concat, [_, _] = Args) ->
-    call_to_scode(Env, aeb_fate_ops:bytes_concat(?a, ?a, ?a), Args);
-builtin_to_scode(Env, bytes_split, [_, _] = Args) ->
-    call_to_scode(Env, aeb_fate_ops:bytes_split(?a, ?a, ?a), Args);
 builtin_to_scode(Env, abort, [_] = Args) ->
     call_to_scode(Env, aeb_fate_ops:abort(?a), Args);
 builtin_to_scode(Env, chain_spend, [_, _] = Args) ->
@@ -562,8 +557,8 @@ builtin_to_scode(Env, aens_resolve, [_Name, _Key, _Type] = 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, _NameFee] = 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, ?a),
+    call_to_scode(Env, [aeb_fate_ops:aens_claim(?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),
@@ -571,6 +566,8 @@ builtin_to_scode(Env, aens_transfer, [_Sign, _From, _To, _Name] = Args) ->
 builtin_to_scode(Env, aens_revoke, [_Sign, _Account, _Name] = Args) ->
     call_to_scode(Env, [aeb_fate_ops:aens_revoke(?a, ?a, ?a),
                         tuple(0)], Args);
+builtin_to_scode(Env, aens_subname, [_Sign, _Account, _Name, _Subnames] = Args) ->
+    call_to_scode(Env, [aeb_fate_ops:aens_subname(?a, ?a, ?a, ?a), tuple(0)], Args);
 builtin_to_scode(_Env, auth_tx_hash, []) ->
     [aeb_fate_ops:auth_tx_hash(?a)].
 
@@ -852,8 +849,6 @@ attributes(I) ->
         {'AUTH_TX_HASH', A}                   -> Pure(A, []);
         {'BYTES_TO_INT', A, B}                -> Pure(A, [B]);
         {'BYTES_TO_STR', A, B}                -> Pure(A, [B]);
-        {'BYTES_CONCAT', A, B, C}             -> Pure(A, [B, C]);
-        {'BYTES_SPLIT', A, B, C}              -> Pure(A, [B, C]);
         {'ORACLE_CHECK', A, B, C, D}          -> Impure(A, [B, C, D]);
         {'ORACLE_CHECK_QUERY', A, B, C, D, E} -> Impure(A, [B, C, D, E]);
         {'IS_ORACLE', A, B}                   -> Impure(A, [B]);
@@ -890,10 +885,11 @@ 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, E}         -> Impure(none, [A, B, C, D, E]);
+        {'AENS_CLAIM', A, B, C, D}            -> Impure(none, [A, B, C, D]);
         '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]);
+        {'AENS_SUBNAME', A, B, C}             -> Impure(none, [A, B, C]);
         {'ABORT', A}                          -> Impure(pc, A);
         {'EXIT', A}                           -> Impure(pc, A);
         'NOP'                                 -> Pure(none, [])

src/aeso_icode.erl

@@ -16,7 +16,6 @@
          set_payable/2,
          enter_namespace/2,
          get_namespace/1,
-         in_main_contract/1,
          qualify/2,
          set_functions/2,
          map_typerep/2,
@@ -75,7 +74,6 @@ builtin_types() ->
     Word = fun([]) -> word end,
     #{ "bool"         => Word
      , "int"          => Word
-     , "char"         => Word
      , "bits"         => Word
      , "string"       => fun([]) -> string end
      , "address"      => Word
@@ -122,10 +120,6 @@ enter_namespace(NS, Icode = #{ namespace := NS1 }) ->
 enter_namespace(NS, Icode) ->
     Icode#{ namespace => NS }.
 
--spec in_main_contract(icode()) -> boolean().
-in_main_contract(#{ namespace := {con, _, Main}, contract_name := Main }) -> true;
-in_main_contract(_Icode) -> false.
-
 -spec get_namespace(icode()) -> false | aeso_syntax:con() | aeso_syntax:qcon().
 get_namespace(Icode) -> maps:get(namespace, Icode, false).
 

src/aeso_icode_to_asm.erl

@@ -27,7 +27,7 @@ convert(#{ contract_name := _ContractName
               },
         _Options) ->
     %% Create a function dispatcher
-    DispatchFun = {"%main", [], [{"arg", "_"}],
+    DispatchFun = {"_main", [], [{"arg", "_"}],
                    {switch, {var_ref, "arg"},
                     [{{tuple, [fun_hash(Fun),
                                {tuple, make_args(Args)}]},
@@ -44,7 +44,7 @@ convert(#{ contract_name := _ContractName
     %% taken from the stack
     StopLabel = make_ref(),
     StatefulStopLabel = make_ref(),
-    MainFunction = lookup_fun(Funs, "%main"),
+    MainFunction = lookup_fun(Funs, "_main"),
 
     StateTypeValue = aeso_ast_to_icode:type_value(StateType),
 

src/aeso_parse_lib.erl

@@ -9,14 +9,12 @@
 -module(aeso_parse_lib).
 
 -export([parse/2,
-         return/1, fail/0, fail/1, fail/2, map/2, bind/2,
+         return/1, fail/0, fail/1, map/2, bind/2,
          lazy/1, choice/1, choice/2, tok/1, layout/0,
          left/2, right/2, between/3, optional/1,
          many/1, many1/1, sep/2, sep1/2,
          infixl/2, infixr/2]).
 
--export([current_file/0, set_current_file/1]).
-
 %% -- Types ------------------------------------------------------------------
 
 -export_type([parser/1, parser_expr/1, pos/0, token/0, tokens/0]).
@@ -100,10 +98,6 @@ apply_p(X, K) -> K(X).
 -spec lazy(fun(() -> parser(A))) -> parser(A).
 lazy(Delayed) -> ?lazy(Delayed).
 
-%% @doc A parser that always fails at a known location.
--spec fail(pos(), term()) -> parser(none()).
-fail(Pos, Err) -> ?fail({Pos, Err}).
-
 %% @doc A parser that always fails.
 -spec fail(term()) -> parser(none()).
 fail(Err) -> ?fail(Err).
@@ -161,7 +155,7 @@ layout() -> ?layout.
 -spec parse(parser(A), tokens()) -> {ok, A} | {error, term()}.
 parse(P, S) ->
   case parse1(apply_p(P, fun(X) -> {return_plus, X, {fail, no_error}} end), S) of
-    {[], {Pos, Err}} -> {error, {add_current_file(Pos), parse_error, flatten_error(Err)}};
+    {[], {Pos, Err}} -> {error, {Pos, parse_error, flatten_error(Err)}};
     {[A], _}         -> {ok, A};
     {As, _}          -> {error, {{1, 1}, ambiguous_parse, As}}
   end.
@@ -291,7 +285,7 @@ parse1({tok_bind, Map}, Ts, Acc, Err) ->
                     %%            y + y)(4)
                     case maps:get(vclose, Map, '$not_found') of
                         '$not_found' ->
-                            {Acc, unexpected_token_error(Ts, maps:keys(Map), T)};
+                            {Acc, unexpected_token_error(Ts, T)};
                         F ->
                             VClose = {vclose, pos(T)},
                             Ts2    = pop_layout(VClose, Ts#ts{ last = VClose }),
@@ -328,52 +322,12 @@ current_pos(#ts{ tokens   = [T | _] }) -> pos(T);
 current_pos(#ts{ last     = T })       -> end_pos(pos(T)).
 
 -spec mk_error(#ts{}, term()) -> error().
-mk_error(_Ts, {Pos, Err}) ->
-    {Pos, Err};
 mk_error(Ts, Err) ->
     {current_pos(Ts), Err}.
 
 -spec unexpected_token_error(#ts{}, token()) -> error().
 unexpected_token_error(Ts, T) ->
-    unexpected_token_error(Ts, [], T).
+    mk_error(Ts, io_lib:format("Unexpected token ~p", [tag(T)])).
-
-unexpected_token_error(Ts, Expect, {Tag, _}) when Tag == vclose; Tag == vsemi ->
-    Braces = [')', ']', '}'],
-    Fix    = case lists:filter(fun(T) -> lists:member(T, Braces) end, Expect) of
-                 []      -> " Probable causes:\n"
-                            "  - something is missing in the previous statement, or\n"
-                            "  - this line should be indented more.";
-                 [T | _] -> io_lib:format(" Did you forget a ~p?", [T])
-             end,
-    Msg = io_lib:format("Unexpected indentation.~s", [Fix]),
-    mk_error(Ts, Msg);
-unexpected_token_error(Ts, Expect, T) ->
-    ExpectCon = lists:member(con, Expect),
-    ExpectId  = lists:member(id,  Expect),
-    Fix = case T of
-              {id, _,  X}   when ExpectCon, hd(X) /= $_ -> io_lib:format(" Did you mean ~s?", [mk_upper(X)]);
-              {con, _, X}   when ExpectId               -> io_lib:format(" Did you mean ~s?", [mk_lower(X)]);
-              {qcon, _, Xs} when ExpectCon              -> io_lib:format(" Did you mean ~s?", [lists:last(Xs)]);
-              {qid, _,  Xs} when ExpectId               -> io_lib:format(" Did you mean ~s?", [lists:last(Xs)]);
-              _ -> ""
-          end,
-    mk_error(Ts, io_lib:format("Unexpected ~s.~s", [describe(T), Fix])).
-
-mk_upper([C | Rest]) -> string:to_upper([C]) ++ Rest.
-mk_lower([C | Rest]) -> string:to_lower([C]) ++ Rest.
-
-
-describe({id, _, X})     -> io_lib:format("identifier ~s", [X]);
-describe({con, _, X})    -> io_lib:format("identifier ~s", [X]);
-describe({qid, _, Xs})   -> io_lib:format("qualified identifier ~s", [string:join(Xs, ".")]);
-describe({qcon, _, Xs})  -> io_lib:format("qualified identifier ~s", [string:join(Xs, ".")]);
-describe({tvar, _, X})   -> io_lib:format("type variable ~s", [X]);
-describe({char, _, _})   -> "character literal";
-describe({string, _, _}) -> "string literal";
-describe({hex, _, _})    -> "integer literal";
-describe({int, _, _})    -> "integer literal";
-describe({bytes, _, _})  -> "bytes literal";
-describe(T)              -> io_lib:format("token '~s'", [tag(T)]).
 
 %% Get the next token from a token stream. Inserts layout tokens if necessary.
 -spec next_token(#ts{}) -> false | {token(), #ts{}}.
@@ -457,13 +411,3 @@ merge_with(Fun, Map1, Map2) ->
                         end, Map2, maps:to_list(Map1))
     end.
 
-%% Current source file
-current_file() ->
-    get('$current_file').
-
-set_current_file(File) ->
-    put('$current_file', File).
-
-add_current_file({L, C}) -> {current_file(), L, C};
-add_current_file(Pos)    -> Pos.
-

src/aeso_parse_lib.hrl

@@ -19,7 +19,7 @@
 -import(aeso_parse_lib,
         [tok/1, tok/2, between/3, many/1, many1/1, sep/2, sep1/2,
          infixl/1, infixr/1, choice/1, choice/2, return/1, layout/0,
-         fail/0, fail/1, fail/2, map/2, infixl/2, infixr/2, infixl1/2, infixr1/2,
+         fail/0, fail/1, map/2, infixl/2, infixr/2, infixl1/2, infixr1/2,
          left/2, right/2, optional/1]).
 
 

src/aeso_parser.erl

@@ -11,9 +11,10 @@
          type/1]).
 
 -include("aeso_parse_lib.hrl").
--import(aeso_parse_lib, [current_file/0, set_current_file/1]).
 
--type parse_result() :: aeso_syntax:ast() | none().
+-type parse_result() :: {ok, aeso_syntax:ast()}
+                      | {error, {aeso_parse_lib:pos(), atom(), term()}}
+                      | {error, {aeso_parse_lib:pos(), atom()}}.
 
 -type include_hash() :: {string(), binary()}.
 
@@ -32,19 +33,13 @@ string(String, Opts) ->
 string(String, Included, Opts) ->
     case parse_and_scan(file(), String, Opts) of
         {ok, AST} ->
-            case expand_includes(AST, Included, Opts) of
+            expand_includes(AST, Included, Opts);
-                {ok, AST1}   -> AST1;
+        Err = {error, _} ->
-                {error, Err} -> parse_error(Err)
+            Err
-            end;
-        {error, Err} ->
-            parse_error(Err)
     end.
 
 type(String) ->
-    case parse_and_scan(type(), String, []) of
+    parse_and_scan(type(), String, []).
-        {ok, AST}    -> {ok, AST};
-        {error, Err} -> {error, [mk_error(Err)]}
-    end.
 
 parse_and_scan(P, S, Opts) ->
     set_current_file(proplists:get_value(src_file, Opts, no_file)),
@@ -53,28 +48,6 @@ parse_and_scan(P, S, Opts) ->
         Error        -> Error
     end.
 
--dialyzer({nowarn_function, parse_error/1}).
-parse_error(Err) ->
-    aeso_errors:throw(mk_error(Err)).
-
-mk_p_err(Pos, Msg) ->
-    aeso_errors:new(parse_error, mk_pos(Pos), lists:flatten(Msg)).
-
-mk_error({Pos, ScanE}) when ScanE == scan_error; ScanE == scan_error_no_state ->
-    mk_p_err(Pos, "Scan error\n");
-mk_error({Pos, parse_error, Err}) ->
-    Msg = io_lib:format("~s\n", [Err]),
-    mk_p_err(Pos, Msg);
-mk_error({Pos, ambiguous_parse, As}) ->
-    Msg = io_lib:format("Ambiguous parse result: ~p\n", [As]),
-    mk_p_err(Pos, Msg);
-mk_error({Pos, include_error, File}) ->
-    Msg = io_lib:format("Couldn't find include file '~s'\n", [File]),
-    mk_p_err(Pos, Msg).
-
-mk_pos({Line, Col})       -> aeso_errors:pos(Line, Col);
-mk_pos({File, Line, Col}) -> aeso_errors:pos(File, Line, Col).
-
 %% -- Parsing rules ----------------------------------------------------------
 
 file() -> choice([], block(decl())).
@@ -452,6 +425,12 @@ bracket_list(P) -> brackets(comma_sep(P)).
 -spec pos_ann(ann_line(), ann_col()) -> ann().
 pos_ann(Line, Col) -> [{file, current_file()}, {line, Line}, {col, Col}].
 
+current_file() ->
+    get('$current_file').
+
+set_current_file(File) ->
+    put('$current_file', File).
+
 ann_pos(Ann) ->
     {proplists:get_value(file, Ann),
      proplists:get_value(line, Ann),
@@ -554,9 +533,14 @@ parse_pattern(E) -> bad_expr_err("Not a valid pattern", E).
 parse_field_pattern({field, Ann, F, E}) ->
     {field, Ann, F, parse_pattern(E)}.
 
+return_error({no_file, L, C}, Err) ->
+    fail(io_lib:format("~p:~p:\n~s", [L, C, Err]));
+return_error({F, L, C}, Err) ->
+    fail(io_lib:format("In ~s at ~p:~p:\n~s", [F, L, C, Err])).
+
 -spec ret_doc_err(ann(), prettypr:document()) -> aeso_parse_lib:parser(none()).
 ret_doc_err(Ann, Doc) ->
-    fail(ann_pos(Ann), prettypr:format(Doc)).
+    return_error(ann_pos(Ann), prettypr:format(Doc)).
 
 -spec bad_expr_err(string(), aeso_syntax:expr()) -> aeso_parse_lib:parser(none()).
 bad_expr_err(Reason, E) ->
@@ -616,7 +600,7 @@ stdlib_options() ->
 get_include_code(File, Ann, Opts) ->
     case {read_file(File, Opts), read_file(File, stdlib_options())} of
         {{ok, _}, {ok,_ }} ->
-            fail(ann_pos(Ann), "Illegal redefinition of standard library " ++ File);
+            return_error(ann_pos(Ann), "Illegal redefinition of standard library " ++ File);
         {_, {ok, Bin}} ->
             {ok, binary_to_list(Bin)};
         {{ok, Bin}, _} ->

src/aeso_scan.erl

@@ -95,11 +95,9 @@ parse_char([$', C, $']) -> C.
 
 unescape(Str) -> unescape(Str, []).
 
+%% TODO: numeric escapes
 unescape([$"], Acc) ->
     list_to_binary(lists:reverse(Acc));
-unescape([$\\, $x, D1, D2 | Chars ], Acc) ->
-    C = list_to_integer([D1, D2], 16),
-    unescape(Chars, [C | Acc]);
 unescape([$\\, Code | Chars], Acc) ->
     Ok = fun(C) -> unescape(Chars, [C | Acc]) end,
     case Code of

src/aesophia.app.src

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

test/aeso_abi_tests.erl

@@ -72,58 +72,6 @@ encode_decode_sophia_test() ->
     ok = Check("r", "{x = (\"foo\", 0), y = Red}"),
     ok.
 
-to_sophia_value_neg_test() ->
-    Code = [ "contract Foo =\n"
-             "  entrypoint x(y : int) : string = \"hello\"\n" ],
-
-    {error, [Err1]} = aeso_compiler:to_sophia_value(Code, "x", ok, encode(12)),
-    ?assertEqual("Data error:\nFailed to decode binary as type string\n", aeso_errors:pp(Err1)),
-    {error, [Err2]} = aeso_compiler:to_sophia_value(Code, "x", ok, encode(12), [{backend, fate}]),
-    ?assertEqual("Data error:\nFailed to decode binary as type string\n", aeso_errors:pp(Err2)),
-
-    {error, [Err3]} = aeso_compiler:to_sophia_value(Code, "x", revert, encode(12)),
-    ?assertEqual("Data error:\nCould not interpret the revert message\n", aeso_errors:pp(Err3)),
-    {error, [Err4]} = aeso_compiler:to_sophia_value(Code, "x", revert, encode(12), [{backend, fate}]),
-    ?assertEqual("Data error:\nCould not deserialize the revert message\n", aeso_errors:pp(Err4)),
-    ok.
-
-encode_calldata_neg_test() ->
-    Code = [ "contract Foo =\n"
-             "  entrypoint x(y : int) : string = \"hello\"\n" ],
-
-    ExpErr1 = "Type error at line 5, col 34:\nCannot unify int\n         and bool\n"
-              "when checking the application at line 5, column 34 of\n"
-              "  x : (int) => string\nto arguments\n  true : bool\n",
-    {error, [Err1]} = aeso_compiler:create_calldata(Code, "x", ["true"]),
-    ?assertEqual(ExpErr1, aeso_errors:pp(Err1)),
-    {error, [Err2]} = aeso_compiler:create_calldata(Code, "x", ["true"], [{backend, fate}]),
-    ?assertEqual(ExpErr1, aeso_errors:pp(Err2)),
-
-    ok.
-
-decode_calldata_neg_test() ->
-    Code1 = [ "contract Foo =\n"
-              "  entrypoint x(y : int) : string = \"hello\"\n" ],
-    Code2 = [ "contract Foo =\n"
-              "  entrypoint x(y : string) : int = 42\n" ],
-
-    {ok, CallDataAEVM} = aeso_compiler:create_calldata(Code1, "x", ["42"]),
-    {ok, CallDataFATE} = aeso_compiler:create_calldata(Code1, "x", ["42"], [{backend, fate}]),
-
-    {error, [Err1]} = aeso_compiler:decode_calldata(Code2, "x", CallDataAEVM),
-    ?assertEqual("Data error:\nFailed to decode calldata as type {tuple,[string]}\n", aeso_errors:pp(Err1)),
-    {error, [Err2]} = aeso_compiler:decode_calldata(Code2, "x", <<1,2,3>>, [{backend, fate}]),
-    ?assertEqual("Data error:\nFailed to decode calldata binary\n", aeso_errors:pp(Err2)),
-    {error, [Err3]} = aeso_compiler:decode_calldata(Code2, "x", CallDataFATE, [{backend, fate}]),
-    ?assertEqual("Data error:\nCannot translate FATE value \"*\"\n  to Sophia type (string)\n", aeso_errors:pp(Err3)),
-
-    {error, [Err4]} = aeso_compiler:decode_calldata(Code2, "y", CallDataAEVM),
-    ?assertEqual("Data error at line 1, col 1:\nFunction 'y' is missing in contract\n", aeso_errors:pp(Err4)),
-    {error, [Err5]} = aeso_compiler:decode_calldata(Code2, "y", CallDataFATE, [{backend, fate}]),
-    ?assertEqual("Data error at line 1, col 1:\nFunction 'y' is missing in contract\n", aeso_errors:pp(Err5)),
-    ok.
-
-
 encode_decode_sophia_string(SophiaType, String) ->
     io:format("String ~p~n", [String]),
     Code = [ "contract MakeCall =\n"
@@ -132,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_code]) 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_code]) 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} ->
@@ -204,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_code]),
+                                                        "oq_1111111111111111111111111111113AFEFpt5"], []),
 
     ok.
 
@@ -213,10 +161,8 @@ permissive_literals_fail_test() ->
         "contract OracleTest =\n"
         "  stateful entrypoint haxx(o : oracle(list(string), option(int))) =\n"
         "    Chain.spend(o, 1000000)\n",
-    {error, [Err]} =
+        {error, <<"Type errors\nCannot unify", _/binary>>} =
-        aeso_compiler:check_call(Contract, "haxx", ["#123"], []),
+            aeso_compiler:check_call(Contract, "haxx", ["#123"], []),
-    ?assertMatch("Type error at line 3, col 5:\nCannot unify" ++ _, aeso_errors:pp(Err)),
-    ?assertEqual(type_error, aeso_errors:type(Err)),
     ok.
 
 encode_decode_calldata(FunName, Types, Args) ->
@@ -228,7 +174,7 @@ encode_decode_calldata(FunName, Types, Args, RetType) ->
 
 encode_decode_calldata_(Code, FunName, Args, RetVMType) ->
     {ok, Calldata} = aeso_compiler:create_calldata(Code, FunName, Args, []),
-    {ok, _, {ArgTypes, RetType}, _} = aeso_compiler:check_call(Code, FunName, Args, [{backend, aevm}, no_code]),
+    {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),

test/aeso_aci_tests.erl

@@ -107,11 +107,11 @@ aci_test_contract(Name) ->
 
 check_stub(Stub, Options) ->
     case aeso_parser:string(binary_to_list(Stub), Options) of
-        Ast ->
+        {ok, Ast} ->
             try
                 %% io:format("AST: ~120p\n", [Ast]),
                 aeso_ast_infer_types:infer(Ast, [])
-            catch throw:{type_errors, TE} ->
+            catch _:{type_errors, TE} ->
                 io:format("Type error:\n~s\n", [TE]),
                 error(TE);
                   _:R ->

test/aeso_compiler_tests.erl

@@ -16,80 +16,58 @@
 %%  are made on the output, just that it is a binary which indicates
 %%  that the compilation worked.
 simple_compile_test_() ->
-    [ {"Testing the " ++ ContractName ++ " contract with the " ++ atom_to_list(Backend) ++ " backend",
+     [ {"Testing the " ++ ContractName ++ " contract with the " ++ atom_to_list(Backend) ++ " backend",
-       fun() ->
+        fun() ->
-           case compile(Backend, ContractName) of
+            case compile(Backend, ContractName) of
-               #{byte_code := ByteCode,
+                #{byte_code := ByteCode,
-                 contract_source := _,
+                  contract_source := _,
-                 type_info := _} when Backend == aevm ->
+                  type_info := _} when Backend == aevm ->
-                   ?assertMatch(Code when is_binary(Code), ByteCode);
+                    ?assertMatch(Code when is_binary(Code), ByteCode);
-               #{fate_code := Code} when Backend == fate ->
+                #{fate_code := Code} when Backend == fate ->
-                   Code1 = aeb_fate_code:deserialize(aeb_fate_code:serialize(Code)),
+                    Code1 = aeb_fate_code:deserialize(aeb_fate_code:serialize(Code)),
-                   ?assertMatch({X, X}, {Code1, Code});
+                    ?assertMatch({X, X}, {Code1, Code});
-               ErrBin ->
+                ErrBin ->
-                   io:format("\n~s", [ErrBin]),
+                    io:format("\n~s", [ErrBin]),
-                   error(ErrBin)
+                    error(ErrBin)
-           end
+            end
-       end} || ContractName <- compilable_contracts(), Backend <- [aevm, fate],
+        end} || ContractName <- compilable_contracts(), Backend <- [aevm, fate],
-               not lists:member(ContractName, not_yet_compilable(Backend))] ++
+                not lists:member(ContractName, not_yet_compilable(Backend))] ++
-    [ {"Test file not found error",
+     [ {"Testing error messages of " ++ ContractName,
-       fun() ->
+        fun() ->
-           {error, Errors} = aeso_compiler:file("does_not_exist.aes"),
+            case compile(aevm, ContractName) of
-           ExpErr = <<"File error:\ndoes_not_exist.aes: no such file or directory">>,
+                <<"Type errors\n", ErrorString/binary>> ->
-           check_errors([ExpErr], Errors)
+                    check_errors(lists:sort(ExpectedErrors), ErrorString);
-       end} ] ++
+                <<"Parse errors\n", ErrorString/binary>> ->
-    [ {"Testing error messages of " ++ ContractName,
+                    check_errors(lists:sort(ExpectedErrors), ErrorString)
-       fun() ->
+            end
-           Errors = compile(aevm, ContractName),
+        end} ||
-           check_errors(ExpectedErrors, Errors)
+            {ContractName, ExpectedErrors} <- failing_contracts() ] ++
-       end} ||
+     [ {"Testing include with explicit files",
-           {ContractName, ExpectedErrors} <- failing_contracts() ] ++
+        fun() ->
-    [ {"Testing " ++ atom_to_list(Backend) ++ " code generation error messages of " ++ ContractName,
+            FileSystem = maps:from_list(
-       fun() ->
+                [ begin
-           Errors = compile(Backend, ContractName),
+                    {ok, Bin} = file:read_file(filename:join([aeso_test_utils:contract_path(), File])),
-           Expect =
+                    {File, Bin}
-               case is_binary(ExpectedError) of
+                  end || File <- ["included.aes", "../contracts/included2.aes"] ]),
-                   true  -> [ExpectedError];
+            #{byte_code := Code1} = compile(aevm, "include", [{include, {explicit_files, FileSystem}}]),
-                   false ->
+            #{byte_code := Code2} = compile(aevm, "include"),
-                       case proplists:get_value(Backend, ExpectedError, no_error) of
+            ?assertMatch(true, Code1 == Code2)
-                           no_error -> no_error;
+        end} ] ++
-                           Err      -> [Err]
+     [ {"Testing deadcode elimination for " ++ atom_to_list(Backend),
-                       end
+        fun() ->
-               end,
+            #{ byte_code := NoDeadCode } = compile(Backend, "nodeadcode"),
-           check_errors(Expect, Errors)
+            #{ byte_code := DeadCode   } = compile(Backend, "deadcode"),
-       end} ||
+            SizeNoDeadCode = byte_size(NoDeadCode),
-           {ContractName, ExpectedError} <- failing_code_gen_contracts(),
+            SizeDeadCode   = byte_size(DeadCode),
-           Backend <- [aevm, fate] ] ++
+            Delta          = if Backend == aevm -> 40;
-    [ {"Testing include with explicit files",
+                                Backend == fate -> 20 end,
-       fun() ->
+            ?assertMatch({_, _, true}, {SizeDeadCode, SizeNoDeadCode, SizeDeadCode + Delta < SizeNoDeadCode}),
-           FileSystem = maps:from_list(
+            ok
-               [ begin
+        end} || Backend <- [aevm, fate] ].
-                   {ok, Bin} = file:read_file(filename:join([aeso_test_utils:contract_path(), File])),
-                   {File, Bin}
-                 end || File <- ["included.aes", "../contracts/included2.aes"] ]),
-           #{byte_code := Code1} = compile(aevm, "include", [{include, {explicit_files, FileSystem}}]),
-           #{byte_code := Code2} = compile(aevm, "include"),
-           ?assertMatch(true, Code1 == Code2)
-       end} ] ++
-    [ {"Testing deadcode elimination for " ++ atom_to_list(Backend),
-       fun() ->
-           #{ byte_code := NoDeadCode } = compile(Backend, "nodeadcode"),
-           #{ byte_code := DeadCode   } = compile(Backend, "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}),
-           ok
-       end} || Backend <- [aevm, fate] ] ++
-    [].
 
-check_errors(no_error, Actual) -> ?assertMatch(#{}, Actual);
+check_errors(Expect, ErrorString) ->
-check_errors(Expect, #{}) ->
+    %% This removes the final single \n as well.
-    ?assertEqual({error, Expect}, ok);
+    Actual = binary:split(<<ErrorString/binary,$\n>>, <<"\n\n">>, [global,trim]),
-check_errors(Expect0, Actual0) ->
-    Expect = lists:sort(Expect0),
-    Actual = [ list_to_binary(string:trim(aeso_errors:pp(Err))) || Err <- Actual0 ],
     case {Expect -- Actual, Actual -- Expect} of
         {[], Extra}   -> ?assertMatch({unexpected, []}, {unexpected, Extra});
         {Missing, []} -> ?assertMatch({missing, []}, {missing, Missing});
@@ -102,10 +80,9 @@ compile(Backend, Name) ->
 
 compile(Backend, Name, Options) ->
     String = aeso_test_utils:read_contract(Name),
-    case aeso_compiler:from_string(String, [{src_file, Name ++ ".aes"}, {backend, Backend} | Options]) of
+    case aeso_compiler:from_string(String, [{src_file, Name}, {backend, Backend} | Options]) of
-        {ok, Map}                                        -> Map;
+        {ok, Map}            -> Map;
-        {error, ErrorString} when is_binary(ErrorString) -> ErrorString;
+        {error, ErrorString} -> ErrorString
-        {error, Errors}                                  -> Errors
     end.
 
 %% compilable_contracts() -> [ContractName].
@@ -143,7 +120,6 @@ compilable_contracts() ->
      "address_chain",
      "namespace_bug",
      "bytes_to_x",
-     "bytes_concat",
      "aens",
      "tuple_match",
      "cyclic_include",
@@ -151,8 +127,7 @@ compilable_contracts() ->
      "double_include",
      "manual_stdlib_include",
      "list_comp",
-     "payable",
+     "payable"
-     "unapplied_builtins"
     ].
 
 not_yet_compilable(fate) -> [];
@@ -160,514 +135,242 @@ not_yet_compilable(aevm) -> [].
 
 %% Contracts that should produce type errors
 
--define(Pos(Kind, File, Line, Col), (list_to_binary(Kind))/binary, " error in '",
-                                    (list_to_binary(File))/binary, ".aes' at line " ??Line ", col " ??Col ":\n").
--define(Pos(Line, Col), ?Pos(__Kind, __File, Line, Col)).
-
--define(ERROR(Kind, Name, Errs),
-    (fun() ->
-        __Kind = Kind,
-        __File = ??Name,
-        {__File, Errs}
-     end)()).
-
--define(TYPE_ERROR(Name, Errs), ?ERROR("Type", Name, Errs)).
--define(PARSE_ERROR(Name, Errs), ?ERROR("Parse", Name, Errs)).
-
 failing_contracts() ->
-    %% Parse errors
+    [ {"name_clash",
-    [ ?PARSE_ERROR(field_parse_error,
+       [<<"Duplicate definitions of abort at\n"
-       [<<?Pos(5, 26)
-          "Cannot use nested fields or keys in record construction: p.x">>])
-    , ?PARSE_ERROR(vsemi,  [<<?Pos(3, 3) "Unexpected indentation. Did you forget a '}'?">>])
-    , ?PARSE_ERROR(vclose, [<<?Pos(4, 3) "Unexpected indentation. Did you forget a ']'?">>])
-    , ?PARSE_ERROR(indent_fail, [<<?Pos(3, 2) "Unexpected token 'entrypoint'.">>])
-
-    %% Type errors
-    , ?TYPE_ERROR(name_clash,
-       [<<?Pos(14, 3)
-          "Duplicate definitions of abort at\n"
           "  - (builtin location)\n"
           "  - line 14, column 3">>,
-        <<?Pos(15, 3)
+        <<"Duplicate definitions of require at\n"
-          "Duplicate definitions of require at\n"
           "  - (builtin location)\n"
           "  - line 15, column 3">>,
-        <<?Pos(11, 3)
+        <<"Duplicate definitions of double_def at\n"
-          "Duplicate definitions of double_def at\n"
           "  - line 10, column 3\n"
           "  - line 11, column 3">>,
-        <<?Pos(5, 3)
+        <<"Duplicate definitions of double_proto at\n"
-          "Duplicate definitions of double_proto at\n"
           "  - line 4, column 3\n"
           "  - line 5, column 3">>,
-        <<?Pos(8, 3)
+        <<"Duplicate definitions of proto_and_def at\n"
-          "Duplicate definitions of proto_and_def at\n"
           "  - line 7, column 3\n"
           "  - line 8, column 3">>,
-        <<?Pos(16, 3)
+        <<"Duplicate definitions of put at\n"
-          "Duplicate definitions of put at\n"
           "  - (builtin location)\n"
           "  - line 16, column 3">>,
-        <<?Pos(17, 3)
+        <<"Duplicate definitions of state at\n"
-          "Duplicate definitions of state at\n"
           "  - (builtin location)\n"
-          "  - line 17, column 3">>])
+          "  - line 17, column 3">>]}
-    , ?TYPE_ERROR(type_errors,
+    , {"type_errors",
-       [<<?Pos(17, 23)
+       [<<"Unbound variable zz at line 17, column 23">>,
-          "Unbound variable zz at line 17, column 23">>,
+        <<"Cannot unify int\n"
-        <<?Pos(26, 9)
-          "Cannot unify int\n"
           "         and list(int)\n"
           "when checking the application at line 26, column 9 of\n"
           "  (::) : (int, list(int)) => list(int)\n"
           "to arguments\n"
           "  x : int\n"
           "  x : int">>,
-        <<?Pos(9, 48)
+        <<"Cannot unify string\n"
-          "Cannot unify string\n"
           "         and int\n"
           "when checking the assignment of the field\n"
           "  x : map(string, string) (at line 9, column 48)\n"
           "to the old value __x and the new value\n"
           "  __x {[\"foo\"] @ x = x + 1} : map(string, int)">>,
-        <<?Pos(34, 47)
+        <<"Cannot unify int\n"
-          "Cannot unify int\n"
           "         and string\n"
           "when checking the type of the expression at line 34, column 47\n"
           "  1 : int\n"
           "against the expected type\n"
           "  string">>,
-        <<?Pos(34, 52)
+        <<"Cannot unify string\n"
-          "Cannot unify string\n"
           "         and int\n"
           "when checking the type of the expression at line 34, column 52\n"
           "  \"bla\" : string\n"
           "against the expected type\n"
           "  int">>,
-        <<?Pos(32, 18)
+        <<"Cannot unify string\n"
-          "Cannot unify string\n"
           "         and int\n"
           "when checking the type of the expression at line 32, column 18\n"
           "  \"x\" : string\n"
           "against the expected type\n"
           "  int">>,
-        <<?Pos(11, 58)
+        <<"Cannot unify string\n"
-          "Cannot unify string\n"
           "         and int\n"
           "when checking the type of the expression at line 11, column 58\n"
           "  \"foo\" : string\n"
           "against the expected type\n"
           "  int">>,
-        <<?Pos(38, 13)
+        <<"Cannot unify int\n"
-          "Cannot unify int\n"
           "         and string\n"
           "when comparing the types of the if-branches\n"
           "  - w : int (at line 38, column 13)\n"
           "  - z : string (at line 39, column 10)">>,
-        <<?Pos(22, 40)
+        <<"Not a record type: string\n"
-          "Not a record type: string\n"
           "arising from the projection of the field y (at line 22, column 40)">>,
-        <<?Pos(21, 44)
+        <<"Not a record type: string\n"
-          "Not a record type: string\n"
           "arising from an assignment of the field y (at line 21, column 44)">>,
-        <<?Pos(20, 40)
+        <<"Not a record type: string\n"
-          "Not a record type: string\n"
           "arising from an assignment of the field y (at line 20, column 40)">>,
-        <<?Pos(19, 37)
+        <<"Not a record type: string\n"
-          "Not a record type: string\n"
           "arising from an assignment of the field y (at line 19, column 37)">>,
-        <<?Pos(13, 27)
+        <<"Ambiguous record type with field y (at line 13, column 27) could be one of\n"
-          "Ambiguous record type with field y (at line 13, column 27) could be one of\n"
           "  - r (at line 4, column 10)\n"
           "  - r' (at line 5, column 10)">>,
-        <<?Pos(26, 7)
+        <<"Repeated name x in pattern\n"
-          "Repeated name x in pattern\n"
           "  x :: x (at line 26, column 7)">>,
-        <<?Pos(44, 14)
+        <<"Repeated argument x to function repeated_arg (at line 44, column 14).">>,
-          "Repeated argument x to function repeated_arg (at line 44, column 14).">>,
+        <<"Repeated argument y to function repeated_arg (at line 44, column 14).">>,
-        <<?Pos(44, 14)
+        <<"No record type with fields y, z (at line 14, column 24)">>,
-          "Repeated argument y to function repeated_arg (at line 44, column 14).">>,
+        <<"The field z is missing when constructing an element of type r2 (at line 15, column 26)">>,
-        <<?Pos(14, 24)
+        <<"Record type r2 does not have field y (at line 15, column 24)">>,
-          "No record type with fields y, z (at line 14, column 24)">>,
+        <<"Let binding at line 47, column 5 must be followed by an expression">>,
-        <<?Pos(15, 26)
+        <<"Let binding at line 50, column 5 must be followed by an expression">>,
-          "The field z is missing when constructing an element of type r2 (at line 15, column 26)">>,
+        <<"Let binding at line 54, column 5 must be followed by an expression">>,
-        <<?Pos(15, 24)
+        <<"Let binding at line 58, column 5 must be followed by an expression">>]}
-          "Record type r2 does not have field y (at line 15, column 24)">>,
+    , {"init_type_error",
-        <<?Pos(47, 5)
+       [<<"Cannot unify string\n"
-          "Let binding at line 47, column 5 must be followed by an expression">>,
-        <<?Pos(50, 5)
-          "Let binding at line 50, column 5 must be followed by an expression">>,
-        <<?Pos(54, 5)
-          "Let binding at line 54, column 5 must be followed by an expression">>,
-        <<?Pos(58, 5)
-          "Let binding at line 58, column 5 must be followed by an expression">>])
-    , ?TYPE_ERROR(init_type_error,
-       [<<?Pos(7, 3)
-          "Cannot unify string\n"
           "         and map(int, int)\n"
-          "when checking that 'init' returns a value of type 'state' at line 7, column 3">>])
+          "when checking that 'init' returns a value of type 'state' at line 7, column 3">>]}
-    , ?TYPE_ERROR(missing_state_type,
+    , {"missing_state_type",
-       [<<?Pos(5, 3)
+       [<<"Cannot unify string\n"
-          "Cannot unify string\n"
           "         and unit\n"
-          "when checking that 'init' returns a value of type 'state' at line 5, column 3">>])
+          "when checking that 'init' returns a value of type 'state' at line 5, column 3">>]}
-    , ?TYPE_ERROR(missing_fields_in_record_expression,
+    , {"missing_fields_in_record_expression",
-       [<<?Pos(7, 42)
+       [<<"The field x is missing when constructing an element of type r('a) (at line 7, column 42)">>,
-          "The field x is missing when constructing an element of type r('a) (at line 7, column 42)">>,
+        <<"The field y is missing when constructing an element of type r(int) (at line 8, column 42)">>,
-        <<?Pos(8, 42)
+        <<"The fields y, z are missing when constructing an element of type r('a) (at line 6, column 42)">>]}
-          "The field y is missing when constructing an element of type r(int) (at line 8, column 42)">>,
+    , {"namespace_clash",
-        <<?Pos(6, 42)
+       [<<"The contract Call (at line 4, column 10) has the same name as a namespace at (builtin location)">>]}
-          "The fields y, z are missing when constructing an element of type r('a) (at line 6, column 42)">>])
+    , {"bad_events",
-    , ?TYPE_ERROR(namespace_clash,
+        [<<"The indexed type string (at line 9, column 25) is not a word type">>,
-       [<<?Pos(4, 10)
+         <<"The indexed type alias_string (at line 10, column 25) equals string which is not a word type">>]}
-          "The contract Call (at line 4, column 10) has the same name as a namespace at (builtin location)">>])
+    , {"bad_events2",
-    , ?TYPE_ERROR(bad_events,
+        [<<"The event constructor BadEvent1 (at line 9, column 7) has too many non-indexed values (max 1)">>,
-        [<<?Pos(9, 25)
+         <<"The event constructor BadEvent2 (at line 10, column 7) has too many indexed values (max 3)">>]}
-           "The indexed type string (at line 9, column 25) is not a word type">>,
+    , {"type_clash",
-         <<?Pos(10, 25)
+        [<<"Cannot unify int\n"
-           "The indexed type alias_string (at line 10, column 25) equals string which is not a word type">>])
-    , ?TYPE_ERROR(bad_events2,
-        [<<?Pos(9, 7)
-           "The event constructor BadEvent1 (at line 9, column 7) has too many non-indexed values (max 1)">>,
-         <<?Pos(10, 7)
-           "The event constructor BadEvent2 (at line 10, column 7) has too many indexed values (max 3)">>])
-    , ?TYPE_ERROR(type_clash,
-        [<<?Pos(12, 42)
-           "Cannot unify int\n"
            "         and string\n"
            "when checking the record projection at line 12, column 42\n"
            "  r.foo : (gas : int, value : int) => Remote.themap\n"
            "against the expected type\n"
-           "  (gas : int, value : int) => map(string, int)">>])
+           "  (gas : int, value : int) => map(string, int)">>]}
-    , ?TYPE_ERROR(bad_include_and_ns,
+    , {"bad_include_and_ns",
-        [<<?Pos(2, 11)
+        [<<"Include of 'included.aes' at line 2, column 11\nnot allowed, include only allowed at top level.">>,
-           "Include of 'included.aes' at line 2, column 11\nnot allowed, include only allowed at top level.">>,
+         <<"Nested namespace not allowed\nNamespace 'Foo' at line 3, column 13 not defined at top level.">>]}
-         <<?Pos(3, 13)
+    , {"bad_address_literals",
-           "Nested namespace not allowed\nNamespace 'Foo' at line 3, column 13 not defined at top level.">>])
+        [<<"The type bytes(32) is not a contract type\n"
-    , ?TYPE_ERROR(bad_address_literals,
-        [<<?Pos(32, 5)
-           "The type bytes(32) is not a contract type\n"
            "when checking that the contract literal at line 32, column 5\n"
            "  ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ\n"
            "has the type\n"
            "  bytes(32)">>,
-         <<?Pos(30, 5)
+         <<"The type oracle(int, bool) is not a contract type\n"
-           "The type oracle(int, bool) is not a contract type\n"
            "when checking that the contract literal at line 30, column 5\n"
            "  ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ\n"
            "has the type\n"
            "  oracle(int, bool)">>,
-         <<?Pos(28, 5)
+         <<"The type address is not a contract type\n"
-           "The type address is not a contract type\n"
            "when checking that the contract literal at line 28, column 5\n"
            "  ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ\n"
            "has the type\n"
            "  address">>,
-         <<?Pos(25, 5)
+         <<"Cannot unify oracle_query('a, 'b)\n"
-           "Cannot unify oracle_query('a, 'b)\n"
            "         and Remote\n"
            "when checking the type of the expression at line 25, column 5\n"
            "  oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY :\n"
            "    oracle_query('a, 'b)\n"
            "against the expected type\n"
            "  Remote">>,
-         <<?Pos(23, 5)
+         <<"Cannot unify oracle_query('c, 'd)\n"
-           "Cannot unify oracle_query('c, 'd)\n"
            "         and bytes(32)\n"
            "when checking the type of the expression at line 23, column 5\n"
            "  oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY :\n"
            "    oracle_query('c, 'd)\n"
            "against the expected type\n"
            "  bytes(32)">>,
-         <<?Pos(21, 5)
+         <<"Cannot unify oracle_query('e, 'f)\n"
-           "Cannot unify oracle_query('e, 'f)\n"
            "         and oracle(int, bool)\n"
            "when checking the type of the expression at line 21, column 5\n"
            "  oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY :\n"
            "    oracle_query('e, 'f)\n"
            "against the expected type\n"
            "  oracle(int, bool)">>,
-         <<?Pos(18, 5)
+         <<"Cannot unify oracle('g, 'h)\n"
-           "Cannot unify oracle('g, 'h)\n"
            "         and Remote\n"
            "when checking the type of the expression at line 18, column 5\n"
            "  ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5 :\n"
            "    oracle('g, 'h)\n"
            "against the expected type\n"
            "  Remote">>,
-         <<?Pos(16, 5)
+         <<"Cannot unify oracle('i, 'j)\n"
-           "Cannot unify oracle('i, 'j)\n"
            "         and bytes(32)\n"
            "when checking the type of the expression at line 16, column 5\n"
            "  ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5 :\n"
            "    oracle('i, 'j)\n"
            "against the expected type\n"
            "  bytes(32)">>,
-         <<?Pos(14, 5)
+         <<"Cannot unify oracle('k, 'l)\n"
-           "Cannot unify oracle('k, 'l)\n"
            "         and oracle_query(int, bool)\n"
            "when checking the type of the expression at line 14, column 5\n"
            "  ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5 :\n"
            "    oracle('k, 'l)\n"
            "against the expected type\n"
            "  oracle_query(int, bool)">>,
-         <<?Pos(11, 5)
+         <<"Cannot unify address\n"
-           "Cannot unify address\n"
            "         and oracle(int, bool)\n"
            "when checking the type of the expression at line 11, column 5\n"
            "  ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt : address\n"
            "against the expected type\n"
            "  oracle(int, bool)">>,
-         <<?Pos(9, 5)
+         <<"Cannot unify address\n"
-           "Cannot unify address\n"
            "         and Remote\n"
            "when checking the type of the expression at line 9, column 5\n"
            "  ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt : address\n"
            "against the expected type\n"
            "  Remote">>,
-         <<?Pos(7, 5)
+         <<"Cannot unify address\n"
-           "Cannot unify address\n"
            "         and bytes(32)\n"
            "when checking the type of the expression at line 7, column 5\n"
            "  ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt : address\n"
            "against the expected type\n"
-           "  bytes(32)">>])
+           "  bytes(32)">>]}
-    , ?TYPE_ERROR(stateful,
+    , {"stateful",
-       [<<?Pos(13, 35)
+       [<<"Cannot reference stateful function Chain.spend (at line 13, column 35)\nin the definition of non-stateful function fail1.">>,
-          "Cannot reference stateful function Chain.spend (at line 13, column 35)\nin the definition of non-stateful function fail1.">>,
+        <<"Cannot reference stateful function local_spend (at line 14, column 35)\nin the definition of non-stateful function fail2.">>,
-        <<?Pos(14, 35)
+        <<"Cannot reference stateful function Chain.spend (at line 16, column 15)\nin the definition of non-stateful function fail3.">>,
-          "Cannot reference stateful function local_spend (at line 14, column 35)\nin the definition of non-stateful function fail2.">>,
+        <<"Cannot reference stateful function Chain.spend (at line 20, column 31)\nin the definition of non-stateful function fail4.">>,
-        <<?Pos(16, 15)
+        <<"Cannot reference stateful function Chain.spend (at line 35, column 47)\nin the definition of non-stateful function fail5.">>,
-          "Cannot reference stateful function Chain.spend (at line 16, column 15)\nin the definition of non-stateful function fail3.">>,
+        <<"Cannot pass non-zero value argument 1000 (at line 48, column 57)\nin the definition of non-stateful function fail6.">>,
-        <<?Pos(20, 31)
+        <<"Cannot pass non-zero value argument 1000 (at line 49, column 56)\nin the definition of non-stateful function fail7.">>,
-          "Cannot reference stateful function Chain.spend (at line 20, column 31)\nin the definition of non-stateful function fail4.">>,
+        <<"Cannot pass non-zero value argument 1000 (at line 52, column 17)\nin the definition of non-stateful function fail8.">>]}
-        <<?Pos(35, 47)
+    , {"bad_init_state_access",
-          "Cannot reference stateful function Chain.spend (at line 35, column 47)\nin the definition of non-stateful function fail5.">>,
+       [<<"The init function should return the initial state as its result and cannot write the state,\n"
-        <<?Pos(48, 57)
-          "Cannot pass non-zero value argument 1000 (at line 48, column 57)\nin the definition of non-stateful function fail6.">>,
-        <<?Pos(49, 56)
-          "Cannot pass non-zero value argument 1000 (at line 49, column 56)\nin the definition of non-stateful function fail7.">>,
-        <<?Pos(52, 17)
-          "Cannot pass non-zero value argument 1000 (at line 52, column 17)\nin the definition of non-stateful function fail8.">>])
-    , ?TYPE_ERROR(bad_init_state_access,
-       [<<?Pos(11, 5)
-          "The init function should return the initial state as its result and cannot write the state,\n"
           "but it calls\n"
           "  - set_state (at line 11, column 5), which calls\n"
           "  - roundabout (at line 8, column 38), which calls\n"
           "  - put (at line 7, column 39)">>,
-        <<?Pos(12, 5)
+        <<"The init function should return the initial state as its result and cannot read the state,\n"
-          "The init function should return the initial state as its result and cannot read the state,\n"
           "but it calls\n"
           "  - new_state (at line 12, column 5), which calls\n"
           "  - state (at line 5, column 29)">>,
-        <<?Pos(13, 13)
+        <<"The init function should return the initial state as its result and cannot read the state,\n"
-          "The init function should return the initial state as its result and cannot read the state,\n"
           "but it calls\n"
-          "  - state (at line 13, column 13)">>])
+          "  - state (at line 13, column 13)">>]}
-    , ?TYPE_ERROR(modifier_checks,
+    , {"field_parse_error",
-       [<<?Pos(11, 3)
+       [<<"line 6, column 1: In field_parse_error at 5:26:\n"
-          "The function all_the_things (at line 11, column 3) cannot be both public and private.">>,
+          "Cannot use nested fields or keys in record construction: p.x\n">>]}
-        <<?Pos(3, 3)
+    , {"modifier_checks",
-          "Namespaces cannot contain entrypoints (at line 3, column 3). Use 'function' instead.">>,
+       [<<"The function all_the_things (at line 11, column 3) cannot be both public and private.">>,
-        <<?Pos(5, 10)
+        <<"Namespaces cannot contain entrypoints (at line 3, column 3). Use 'function' instead.">>,
-          "The contract Remote (at line 5, column 10) has no entrypoints. Since Sophia version 3.2, public\ncontract functions must be declared with the 'entrypoint' keyword instead of\n'function'.">>,
+        <<"The contract Remote (at line 5, column 10) has no entrypoints. Since Sophia version 3.2, public\ncontract functions must be declared with the 'entrypoint' keyword instead of\n'function'.">>,
-        <<?Pos(12, 3)
+        <<"The entrypoint wha (at line 12, column 3) cannot be private. Use 'function' instead.">>,
-          "The entrypoint wha (at line 12, column 3) cannot be private. Use 'function' instead.">>,
+        <<"Use 'entrypoint' for declaration of foo (at line 6, column 3):\n  entrypoint foo : () => unit">>,
-        <<?Pos(6, 3)
+        <<"Use 'entrypoint' instead of 'function' for public function foo (at line 10, column 3):\n  entrypoint foo() = ()">>,
-          "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 6, column 3):\n  entrypoint foo : () => unit">>]}
-        <<?Pos(10, 3)
+    , {"list_comp_not_a_list",
-          "Use 'entrypoint' instead of 'function' for public function foo (at line 10, column 3):\n  entrypoint foo() = ()">>,
+      [<<"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)">>
-        <<?Pos(6, 3)
+      ]}
-          "Use 'entrypoint' instead of 'function' for public function foo (at line 6, column 3):\n  entrypoint foo : () => unit">>])
+    , {"list_comp_if_not_bool",
-    , ?TYPE_ERROR(list_comp_not_a_list,
+      [<<"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">>
-      [<<?Pos(2, 36)
+      ]}
-         "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_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">>
-    , ?TYPE_ERROR(list_comp_if_not_bool,
+      ]}
-      [<<?Pos(2, 44)
-         "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">>
-      ])
-    , ?TYPE_ERROR(list_comp_bad_shadow,
-      [<<?Pos(2, 53)
-         "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">>
-      ])
-    , ?TYPE_ERROR(map_as_map_key,
-       [<<?Pos(5, 25)
-         "Invalid key type\n"
-         "  map(int, int)\n"
-         "Map keys cannot contain other maps.">>,
-        <<?Pos(6, 25)
-         "Invalid key type\n"
-         "  lm\n"
-         "Map keys cannot contain other maps.">>])
-    , ?TYPE_ERROR(calling_init_function,
-       [<<?Pos(7, 28)
-          "The 'init' function is called exclusively by the create contract transaction\n"
-          "and cannot be called from the contract code.">>])
-    , ?TYPE_ERROR(bad_top_level_decl,
-        [<<?Pos(1, 1) "The definition of 'square' must appear inside a contract or namespace.">>])
-    , ?TYPE_ERROR(missing_event_type,
-        [<<?Pos(3, 5)
-           "Unbound variable Chain.event at line 3, column 5\n"
-           "Did you forget to define the event type?">>])
-    , ?TYPE_ERROR(bad_bytes_concat,
-        [<<?Pos(12, 40)
-           "Failed to resolve byte array lengths in call to Bytes.concat with arguments of type\n"
-           "  - 'g  (at line 12, column 20)\n"
-           "  - 'h  (at line 12, column 23)\n"
-           "and result type\n"
-           "  - bytes(10)  (at line 12, column 28)">>,
-         <<?Pos(13, 28)
-           "Failed to resolve byte array lengths in call to Bytes.concat with arguments of type\n"
-           "  - 'd  (at line 13, column 20)\n"
-           "  - 'e  (at line 13, column 23)\n"
-           "and result type\n"
-           "  - 'f  (at line 13, column 14)">>,
-         <<?Pos(15, 5)
-           "Cannot unify bytes(26)\n"
-           "         and bytes(25)\n"
-           "at line 15, column 5">>,
-         <<?Pos(17, 5)
-           "Failed to resolve byte array lengths in call to Bytes.concat with arguments of type\n"
-           "  - bytes(6)  (at line 16, column 24)\n"
-           "  - 'b  (at line 16, column 34)\n"
-           "and result type\n"
-           "  - 'c  (at line 16, column 39)">>,
-         <<?Pos(19, 25)
-           "Cannot resolve length of byte array.">>])
-    , ?TYPE_ERROR(bad_bytes_split,
-         [<<?Pos(13, 5)
-            "Failed to resolve byte array lengths in call to Bytes.split with argument of type\n"
-            "  - 'f  (at line 12, column 20)\n"
-            "and result types\n"
-            "  - 'e  (at line 13, column 5)\n"
-            "  - bytes(20)  (at line 12, column 29)">>,
-          <<?Pos(16, 5)
-            "Failed to resolve byte array lengths in call to Bytes.split with argument of type\n"
-            "  - bytes(15)  (at line 15, column 24)\n"
-            "and result types\n"
-            "  - 'c  (at line 16, column 5)\n"
-            "  - 'd  (at line 16, column 5)">>,
-          <<?Pos(19, 5)
-            "Failed to resolve byte array lengths in call to Bytes.split with argument of type\n"
-            "  - 'b  (at line 18, column 20)\n"
-            "and result types\n"
-            "  - bytes(20)  (at line 18, column 25)\n"
-            "  - 'a  (at line 19, column 5)">>])
-    ].
-
--define(Path(File), "code_errors/" ??File).
--define(Msg(File, Line, Col, Err), <<?Pos("Code generation", ?Path(File), Line, Col) Err>>).
-
--define(SAME(File, Line, Col, Err), {?Path(File), ?Msg(File, Line, Col, Err)}).
--define(AEVM(File, Line, Col, Err), {?Path(File), [{aevm, ?Msg(File, Line, Col, Err)}]}).
--define(FATE(File, Line, Col, Err), {?Path(File), [{fate, ?Msg(File, Line, Col, Err)}]}).
--define(BOTH(File, Line, Col, ErrAEVM, ErrFATE),
-        {?Path(File), [{aevm, ?Msg(File, Line, Col, ErrAEVM)},
-                       {fate, ?Msg(File, Line, Col, ErrFATE)}]}).
-
-failing_code_gen_contracts() ->
-    [ ?SAME(last_declaration_must_be_contract, 1, 1,
-            "Expected a contract as the last declaration instead of the namespace 'LastDeclarationIsNotAContract'")
-    , ?SAME(missing_definition, 2, 14,
-            "Missing definition of function 'foo'.")
-    , ?AEVM(polymorphic_entrypoint, 2, 17,
-            "The argument\n"
-            "  x : 'a\n"
-            "of entrypoint 'id' has a polymorphic (contains type variables) type.\n"
-            "Use the FATE backend if you want polymorphic entrypoints.")
-    , ?AEVM(polymorphic_entrypoint_return, 2, 3,
-            "The return type\n"
-            "  'a\n"
-            "of entrypoint 'fail' is polymorphic (contains type variables).\n"
-            "Use the FATE backend if you want polymorphic entrypoints.")
-    , ?SAME(higher_order_entrypoint, 2, 20,
-            "The argument\n"
-            "  f : (int) => int\n"
-            "of entrypoint 'apply' has a higher-order (contains function types) type.")
-    , ?SAME(higher_order_entrypoint_return, 2, 3,
-            "The return type\n"
-            "  (int) => int\n"
-            "of entrypoint 'add' is higher-order (contains function types).")
-    , ?SAME(missing_init_function, 1, 10,
-            "Missing init function for the contract 'MissingInitFunction'.\n"
-            "The 'init' function can only be omitted if the state type is 'unit'.")
-    , ?SAME(parameterised_state, 3, 8,
-            "The state type cannot be parameterized.")
-    , ?SAME(parameterised_event, 3, 12,
-            "The event type cannot be parameterized.")
-    , ?SAME(polymorphic_aens_resolve, 4, 5,
-            "Invalid return type of AENS.resolve:\n"
-            "  'a\n"
-            "It must be a string or a pubkey type (address, oracle, etc).")
-    , ?SAME(bad_aens_resolve, 6, 5,
-            "Invalid return type of AENS.resolve:\n"
-            "  list(int)\n"
-            "It must be a string or a pubkey type (address, oracle, etc).")
-    , ?AEVM(polymorphic_compare, 4, 5,
-            "Cannot compare values of type\n"
-            "  'a\n"
-            "The AEVM only supports '==' on values of\n"
-            "- word type (int, bool, bits, address, oracle(_, _), etc)\n"
-            "- type string\n"
-            "- tuple or record of word type\n"
-            "Use FATE if you need to compare arbitrary types.")
-    , ?AEVM(complex_compare, 4, 5,
-            "Cannot compare values of type\n"
-            "  (string * int)\n"
-            "The AEVM only supports '!=' on values of\n"
-            "- word type (int, bool, bits, address, oracle(_, _), etc)\n"
-            "- type string\n"
-            "- tuple or record of word type\n"
-            "Use FATE if you need to compare arbitrary types.")
-    , ?AEVM(complex_compare_leq, 4, 5,
-            "Cannot compare values of type\n"
-            "  (int * int)\n"
-            "The AEVM only supports '=<' on values of\n"
-            "- word type (int, bool, bits, address, oracle(_, _), etc)\n"
-            "Use FATE if you need to compare arbitrary types.")
-    , ?AEVM(higher_order_compare, 4, 5,
-            "Cannot compare values of type\n"
-            "  (int) => int\n"
-            "The AEVM only supports '<' on values of\n"
-            "- word type (int, bool, bits, address, oracle(_, _), etc)\n"
-            "Use FATE if you need to compare arbitrary types.")
-    , ?AEVM(unapplied_contract_call, 6, 19,
-            "The AEVM does not support unapplied contract call to\n"
-            "  r : Remote\n"
-            "Use FATE if you need this.")
-    , ?AEVM(unapplied_named_arg_builtin, 4, 15,
-            "The AEVM does not support unapplied use of Oracle.register.\n"
-            "Use FATE if you need this.")
-    , ?AEVM(polymorphic_map_keys, 4, 34,
-            "Invalid map key type\n"
-            "  'a\n"
-            "Map keys cannot be polymorphic in the AEVM. Use FATE if you need this.")
-    , ?AEVM(higher_order_map_keys, 4, 42,
-            "Invalid map key type\n"
-            "  (int) => int\n"
-            "Map keys cannot be higher-order.")
-    , ?SAME(polymorphic_query_type, 3, 5,
-            "Invalid oracle type\n"
-            "  oracle('a, 'b)\n"
-            "The query type must not be polymorphic (contain type variables).")
-    , ?SAME(polymorphic_response_type, 3, 5,
-            "Invalid oracle type\n"
-            "  oracle(string, 'r)\n"
-            "The response type must not be polymorphic (contain type variables).")
-    , ?SAME(higher_order_query_type, 3, 5,
-            "Invalid oracle type\n"
-            "  oracle((int) => int, string)\n"
-            "The query type must not be higher-order (contain function types).")
-    , ?SAME(higher_order_response_type, 3, 5,
-            "Invalid oracle type\n"
-            "  oracle(string, (int) => int)\n"
-            "The response type must not be higher-order (contain function types).")
-    , ?AEVM(higher_order_state, 3, 3,
-            "Invalid state type\n"
-            "  {f : (int) => int}\n"
-            "The state cannot contain functions in the AEVM. Use FATE if you need this.")
     ].
 

test/aeso_parser_tests.erl

@@ -39,7 +39,7 @@ simple_contracts_test_() ->
             RightAssoc = fun(Op) -> CheckParens({a, Op, {b, Op, c}}) end,
             NonAssoc   = fun(Op) ->
                             OpAtom = list_to_atom(Op),
-                            ?assertThrow({error, [_]},
+                            ?assertError({error, {_, parse_error, _}},
                                          parse_expr(NoPar({a, Op, {b, Op, c}}))) end,
             Stronger = fun(Op1, Op2) ->
                     CheckParens({{a, Op1, b}, Op2, c}),
@@ -74,7 +74,10 @@ roundtrip_contract(Name) ->
 parse_string(Text) -> parse_string(Text, []).
 
 parse_string(Text, Opts) ->
-    aeso_parser:string(Text, Opts).
+    case aeso_parser:string(Text, Opts) of
+        {ok, Contract} -> Contract;
+        Err -> error(Err)
+    end.
 
 parse_expr(Text) ->
     [{letval, _, _, _, Expr}] =

test/contracts/aens.aes

@@ -1,6 +1,8 @@
 // AENS tests
 contract AENSTest =
 
+  type subnames = map(string, map(string, address))
+
   // Name resolution
 
   stateful entrypoint resolve_word(name : string, key : string) : option(address) =
@@ -22,16 +24,14 @@ contract AENSTest =
 
   stateful entrypoint claim(addr : address,
                           name : string,
-                          salt : int,
+                          salt : int) : unit =
-                          name_fee : int) : unit =
+    AENS.claim(addr, name, salt)
-    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, name_fee, signature = sign)
+    AENS.claim(addr, name, salt, signature = sign)
 
   // TODO: update() -- how to handle pointers?
 
@@ -54,3 +54,15 @@ contract AENSTest =
                                    name      : string,
                                    sign      : signature) : unit =
     AENS.revoke(owner, name, signature = sign)
+
+
+  stateful entrypoint subname(owner    : address,
+                              name     : string,
+                              subnames : subnames) : unit =
+    AENS.subname(owner, name, subnames)
+
+  stateful entrypoint signedSubname(owner    : address,
+                                    name     : string,
+                                    subnames : subnames,
+                                    sign     : signature) : unit =
+    AENS.subname(owner, name, subnames, signature = sign)

test/contracts/bad_bytes_concat.aes

@@ -1,19 +0,0 @@
-contract BytesConcat =
-
-  entrypoint test1(x : bytes(10), y : bytes(20)) =
-    Bytes.concat(x, y)
-
-  entrypoint test2(x : bytes(10), y) : bytes(15) =
-    Bytes.concat(x, y)
-
-  entrypoint test3(x, y : bytes(20)) : bytes(25) =
-    Bytes.concat(x, y)
-
-  entrypoint fail1(x, y) : bytes(10) = Bytes.concat(x, y)
-  entrypoint fail2(x, y) = Bytes.concat(x, y)
-  entrypoint fail3(x : bytes(6), y : bytes(20)) : bytes(25) =
-    Bytes.concat(x, y)
-  entrypoint fail4(x : bytes(6), y) : _ =
-    Bytes.concat(x, y)
-
-  entrypoint fail5(x) = Bytes.to_str(x)

test/contracts/bad_bytes_split.aes

@@ -1,20 +0,0 @@
-contract BytesSplit =
-
-  entrypoint test1(x) : bytes(10) * bytes(20) =
-    Bytes.split(x)
-
-  entrypoint test2(x : bytes(15)) : bytes(10) * _ =
-    Bytes.split(x)
-
-  entrypoint test3(x : bytes(25)) : _ * bytes(20) =
-    Bytes.split(x)
-
-  entrypoint fail1(x) : _ * bytes(20) =
-    Bytes.split(x)
-
-  entrypoint fail2(x : bytes(15)) : _ =
-    Bytes.split(x)
-
-  entrypoint fail3(x) : bytes(20) * _ =
-    Bytes.split(x)
-

test/contracts/bad_top_level_decl.aes

@@ -1,3 +0,0 @@
-function square(x) = x ^ 2
-contract Main =
-  entrypoint main() = square(10)

test/contracts/basic_auth.aes

@@ -15,5 +15,3 @@ contract BasicAuth =
   entrypoint to_sign(h : hash, n : int) =
     Crypto.blake2b((h, n))
 
-  entrypoint weird_string() : string =
-    "\x19Weird String\x42\nMore\n"

test/contracts/bytes_concat.aes

@@ -1,4 +0,0 @@
-contract BytesConcat =
-  entrypoint rot(a : bytes(3)) =
-    switch (Bytes.split(a))
-      (b, c) => Bytes.concat(c : bytes(2), b)

test/contracts/calling_init_function.aes

@@ -1,7 +0,0 @@
-contract CallingInitFunction =
-
-  type state = int * int
-
-  entrypoint init() = (1, 2)
-
-  entrypoint call_init() = init()

test/contracts/code_errors/bad_aens_resolve.aes

@@ -1,9 +0,0 @@
-contract BadAENSresolve =
-
-  type t('a) = option(list('a))
-
-  function fail() : t(int) =
-    AENS.resolve("foo.aet", "whatever")
-
-  entrypoint main() = ()
-

test/contracts/code_errors/complex_compare.aes

@@ -1,4 +0,0 @@
-contract ComplexCompare =
-
-  entrypoint test(x : string * int) =
-    ("foo", 1) != x

test/contracts/code_errors/complex_compare_leq.aes

@@ -1,4 +0,0 @@
-contract ComplexCompare =
-
-  entrypoint test(x : int) =
-    (1, 2) =< (x, x + 1)

test/contracts/code_errors/higher_order_compare.aes

@@ -1,8 +0,0 @@
-contract HigherOrderCompare =
-
-  function cmp(x : int => int, y) : bool =
-    x < y
-
-  entrypoint test() =
-    let f(x) = (y) => x + y
-    cmp(f(1), f(2))

test/contracts/code_errors/higher_order_entrypoint.aes

@@ -1,2 +0,0 @@
-contract HigherOrderEntrypoint =
-  entrypoint apply(f : int => int, x : int) = f(x)

test/contracts/code_errors/higher_order_entrypoint_return.aes

@@ -1,2 +0,0 @@
-contract HigherOrderEntrypoint =
-  entrypoint add(x : int) = (y) => x + y

test/contracts/code_errors/higher_order_map_keys.aes

@@ -1,6 +0,0 @@
-contract MapAsMapKey =
-  type t('key) = map('key, int)
-
-  function foo(m) : t(int => int) = {[m] = 0}
-
-  entrypoint main() = ()

test/contracts/code_errors/higher_order_query_type.aes

@@ -1,5 +0,0 @@
-contract HigherOrderQueryType =
-  stateful function foo(o) : oracle_query(_, string ) =
-    Oracle.query(o, (x) => x + 1, 100, RelativeTTL(100), RelativeTTL(100))
-
-  entrypoint main() = ()

test/contracts/code_errors/higher_order_response_type.aes

@@ -1,5 +0,0 @@
-contract HigherOrderResponseType =
-  stateful function foo(o, q : oracle_query(string, _)) =
-    Oracle.respond(o, q, (x) => x + 1)
-
-  entrypoint main() = ()

test/contracts/code_errors/higher_order_state.aes

@@ -1,7 +0,0 @@
-contract HigherOrderState =
-
-  record state = {f : int => int}
-
-  entrypoint init() = {f = (x) => x}
-  entrypoint apply(n) = state.f(n)
-  stateful entrypoint inc() = put(state{ f = (x) => state.f(x + 1) })

test/contracts/code_errors/last_declaration_must_be_contract.aes

@@ -1,2 +0,0 @@
-namespace LastDeclarationIsNotAContract =
-  function add(x, y) = x + y

test/contracts/code_errors/missing_definition.aes

@@ -1,3 +0,0 @@
-contract MissingDefinition =
-  entrypoint foo : int => int
-  entrypoint main() = foo(0)

test/contracts/code_errors/missing_init_function.aes

@@ -1,3 +0,0 @@
-contract MissingInitFunction =
-  type state = int * int
-

test/contracts/code_errors/parameterised_event.aes

@@ -1,4 +0,0 @@
-contract ParameterisedEvent =
-
-  datatype event('a) = Event(int)
-

test/contracts/code_errors/parameterised_state.aes

@@ -1,4 +0,0 @@
-contract ParameterisedState =
-
-  type state('a) = list('a)
-

test/contracts/code_errors/polymorphic_aens_resolve.aes

@@ -1,7 +0,0 @@
-contract PolymorphicAENSresolve =
-
-  function fail() : option('a) =
-    AENS.resolve("foo.aet", "whatever")
-
-  entrypoint main() = ()
-

test/contracts/code_errors/polymorphic_compare.aes

@@ -1,7 +0,0 @@
-contract PolymorphicCompare =
-
-  function cmp(x : 'a, y : 'a) : bool =
-    x == y
-
-  entrypoint test() =
-    cmp(4, 6) && cmp(true, false)

test/contracts/code_errors/polymorphic_entrypoint.aes

@@ -1,3 +0,0 @@
-contract PolymorphicEntrypoint =
-  entrypoint id(x : 'a) : 'a = x
-

test/contracts/code_errors/polymorphic_entrypoint_return.aes

@@ -1,3 +0,0 @@
-contract PolymorphicEntrypoint =
-  entrypoint fail() : 'a = abort("fail")
-

test/contracts/code_errors/polymorphic_map_keys.aes

@@ -1,6 +0,0 @@
-contract MapAsMapKey =
-  type t('key) = map('key, int)
-
-  function foo(m) : t('a) = {[m] = 0}
-
-  entrypoint main() = ()

test/contracts/code_errors/polymorphic_query_type.aes

@@ -1,5 +0,0 @@
-contract PolymorphicQueryType =
-  stateful function is_oracle(o) =
-    Oracle.check(o)
-
-  entrypoint main() = ()

test/contracts/code_errors/polymorphic_response_type.aes

@@ -1,5 +0,0 @@
-contract PolymorphicResponseType =
-  function is_oracle(o : oracle(string, 'r)) =
-    Oracle.check(o)
-
-  entrypoint main(o : oracle(string, int)) = is_oracle(o)

test/contracts/code_errors/unapplied_contract_call.aes

@@ -1,9 +0,0 @@
-contract Remote =
-  entrypoint foo : int => int
-
-contract UnappliedContractCall =
-
-  function f(r) = r.foo
-
-  entrypoint test(r) = f(r)(0)
-

test/contracts/code_errors/unapplied_named_arg_builtin.aes

@@ -1,5 +0,0 @@
-contract UnappliedNamedArgBuiltin =
-  // Allowed in FATE, but not AEVM
-  stateful entrypoint main(s) =
-    let reg = Oracle.register
-    reg(signature = s, Contract.address, 100, RelativeTTL(100)) : oracle(int, int)

test/contracts/complex_types.aes

@@ -50,7 +50,7 @@ contract ComplexTypes =
   entrypoint remote_pair(n : int, s : string) : int * string =
     state.worker.pair(gas = 10000, n, s)
 
-  function map(f, xs) =
+  entrypoint map(f, xs) =
     switch(xs)
       []      => []
       x :: xs => f(x) :: map(f, xs)

test/contracts/indent_fail.aes

@@ -1,3 +0,0 @@
-contract IndentFail =
-  entrypoint twoSpace() = ()
- entrypoint oneSpace() = ()

test/contracts/local_poly_fail.aes

@@ -1,7 +0,0 @@
-
-contract Fail =
-
-  entrypoint tttt() : bool * int =
-    let f(x : 'a) : 'a = x
-    (f(true), f(1))
-

test/contracts/map_as_map_key.aes

@@ -1,6 +0,0 @@
-contract MapAsMapKey =
-  type t('key) = map('key, int)
-  type lm = list(map(int, int))
-
-  entrypoint foo(m) : t(map(int, int)) = {[m] = 0}
-  entrypoint bar(m) : t(lm) = Map.delete(m, {})

test/contracts/missing_event_type.aes

@@ -1,3 +0,0 @@
-contract MissingEventType =
-  entrypoint main() =
-    Chain.event("MAIN")

test/contracts/test.aes

@@ -91,11 +91,10 @@ contract Identity =
   // }
   // let id(x) = x
   // let main(xs) = map(double,xs)
-  function z(f,x) = x
+  entrypoint z(f,x) = x
   function s(n) = (f,x)=>f(n(f,x))
   function add(m,n) = (f,x)=>m(f,n(f,x))
-
+  entrypoint main(_) =
-  entrypoint main() =
     let three=s(s(s(z)))
     add(three,three)
        (((i)=>i+1),0)

test/contracts/tuple_match.aes

@@ -1,6 +1,6 @@
 contract TuplesMatch =
 
-  function tuplify3() = (t) => switch(t)
+  entrypoint tuplify3() = (t) => switch(t)
     (x, y, z) => 3
 
   entrypoint fst(p : int * string) =

test/contracts/unapplied_builtins.aes

@@ -1,63 +0,0 @@
-// Builtins without named arguments can appear unapplied in both AEVM and FATE.
-// Named argument builtins are:
-//    Oracle.register
-//    Oracle.respond
-//    AENS.preclaim
-//    AENS.claim
-//    AENS.transfer
-//    AENS.revoke
-//    Oracle.extend
-contract UnappliedBuiltins =
-  entrypoint main() = ()
-  type o = oracle(int, int)
-  type t = list(int * string)
-  type m = map(int, int)
-  datatype event = Event(int)
-  stateful function chain_spend()        = Chain.spend
-  function chain_event()                 = Chain.event
-  function chain_balance()               = Chain.balance
-  function chain_block_hash()            = Chain.block_hash
-  function call_gas_left()               = Call.gas_left
-  function b_abort()                     = abort
-  function b_require()                   = require
-  function oracle_query_fee()            = Oracle.query_fee
-  stateful function oracle_query()       = Oracle.query        : (o, _, _, _, _) => _
-  function oracle_get_question()         = Oracle.get_question : (o, _) => _
-  function oracle_get_answer()           = Oracle.get_answer   : (o, _) => _
-  function oracle_check()                = Oracle.check        : o => _
-  function oracle_check_query()          = Oracle.check_query  : (o, _) => _
-  function aens_resolve()                = AENS.resolve        : (_, _) => option(string)
-  function map_lookup()                  = Map.lookup          : (_, m) => _
-  function map_lookup_default()          = Map.lookup_default  : (_, m, _) => _
-  function map_member()                  = Map.member          : (_, m) => _
-  function map_size()                    = Map.size : m => _
-  function map_delete()                  = Map.delete : (_, m) => _
-  function map_from_list()               = Map.from_list : _ => m
-  function map_to_list()                 = Map.to_list : m => _
-  function crypto_verify_sig()           = Crypto.verify_sig
-  function crypto_verify_sig_secp256k1() = Crypto.verify_sig_secp256k1
-  function crypto_ecverify_secp256k1()   = Crypto.ecverify_secp256k1
-  function crypto_ecrecover_secp256k1()  = Crypto.ecrecover_secp256k1
-  function crypto_sha3()                 = Crypto.sha3    : t => _
-  function crypto_sha256()               = Crypto.sha256  : t => _
-  function crypto_blake2b()              = Crypto.blake2b : t => _
-  function string_sha256()               = String.sha256
-  function string_blake2b()              = String.blake2b
-  function string_length()               = String.length
-  function string_concat()               = String.concat
-  function string_sha3()                 = String.sha3
-  function bits_test()                   = Bits.test
-  function bits_set()                    = Bits.set
-  function bits_clear()                  = Bits.clear
-  function bits_union()                  = Bits.union
-  function bits_intersection()           = Bits.intersection
-  function bits_difference()             = Bits.difference
-  function bits_sum()                    = Bits.sum
-  function int_to_str()                  = Int.to_str
-  function address_to_str()              = Address.to_str
-  function address_is_oracle()           = Address.is_oracle
-  function address_is_contract()         = Address.is_contract
-  function address_is_payable()          = Address.is_payable
-  function bytes_to_int()                = Bytes.to_int : bytes(10) => int
-  function bytes_to_str()                = Bytes.to_str : bytes(99) => string
-

test/contracts/vclose.aes

@@ -1,4 +0,0 @@
-contract VClose =
-  entrypoint missing_bracket() =
-    let x = [1, 2, 3
-  entrypoint bar() = ()

test/contracts/vsemi.aes

@@ -1,3 +0,0 @@
-contract VSemi =
-  record missing_brace = { x : int
-  entrypoint foo() = ()