Merge pull request #150 from aeternity/fix_changelog

Fix CHANGELOG

.gitignore

@@ -19,3 +19,5 @@ rebar3.crashdump
 *.erl~
 *.aes~
 aesophia
+.qcci
+current_counterexample.eqc

CHANGELOG.md

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

priv/stdlib/Func.aes

@@ -0,0 +1,46 @@
+namespace Func =
+
+  function id(x : 'a) : 'a = x
+
+  function const(x : 'a) : 'b => 'a = (y) => x
+
+  function flip(f : ('a, 'b) => 'c) : ('b, 'a) => 'c = (b, a) => f(a, b)
+
+  function comp(f : 'b => 'c, g : 'a => 'b) : 'a => 'c = (x) => f(g(x))
+
+  function pipe(f : 'a => 'b, g : 'b => 'c) : 'a => 'c = (x) => g(f(x))
+
+  function rapply(x : 'a, f : 'a => 'b) : 'b = f(x)
+
+  /* The Z combinator - replacement for local and anonymous recursion.
+   */
+  function recur(f : ('arg => 'res, 'arg) => 'res) : 'arg => 'res =
+    (x) => f(recur(f), x)
+
+  function iter(n : int, f : 'a => 'a) : 'a => 'a = iter_(n, f, (x) => x)
+  private function iter_(n : int, f : 'a => 'a, acc : 'a => 'a) : 'a => 'a =
+    if(n == 0) acc
+    elif(n == 1) comp(f, acc)
+    else iter_(n / 2, comp(f, f), if(n mod 2 == 0) acc else comp(f, acc))
+
+  function curry2(f : ('a, 'b) => 'c) : 'a => ('b => 'c) =
+    (x) => (y) => f(x, y)
+  function curry3(f : ('a, 'b, 'c) => 'd) : 'a => ('b => ('c => 'd)) =
+    (x) => (y) => (z) => f(x, y, z)
+
+  function uncurry2(f : 'a => ('b => 'c)) : ('a, 'b) => 'c =
+    (x, y) => f(x)(y)
+  function uncurry3(f : 'a => ('b => ('c => 'd))) : ('a, 'b, 'c) => 'd =
+    (x, y, z) => f(x)(y)(z)
+
+  function tuplify2(f : ('a, 'b) => 'c) : (('a * 'b)) => 'c =
+    (t) => switch(t)
+      (x, y) => f(x, y)
+  function tuplify3(f : ('a, 'b, 'c) => 'd) : 'a * 'b * 'c => 'd =
+    (t) => switch(t)
+      (x, y, z) => f(x, y, z)
+
+  function untuplify2(f : 'a * 'b => 'c) : ('a, 'b) => 'c =
+    (x, y) => f((x, y))
+  function untuplify3(f : 'a * 'b * 'c => 'd) : ('a, 'b, 'c) => 'd =
+    (x, y, z) => f((x, y, z))

priv/stdlib/List.aes

@@ -0,0 +1,214 @@
+include "ListInternal.aes"
+
+namespace List =
+
+  function is_empty(l : list('a)) : bool = switch(l)
+    [] => true
+    _  => false
+
+  function first(l : list('a)) : option('a) = switch(l)
+    []   => None
+    h::_ => Some(h)
+
+  function tail(l : list('a)) : option(list('a)) = switch(l)
+    []   => None
+    _::t => Some(t)
+
+  function last(l : list('a)) : option('a) = switch(l)
+    []  => None
+    [x] => Some(x)
+    _::t => last(t)
+
+  function find(p : 'a => bool, l : list('a)) : option('a) = switch(l)
+    []   => None
+    h::t => if(p(h)) Some(h) else find(p, t)
+
+  function find_indices(p : 'a => bool, l : list('a)) : list(int) = find_indices_(p, l, 0, [])
+  private function find_indices_( p : 'a => bool
+                                , l : list('a)
+                                , n : int
+                                , acc : list(int)
+                                ) : list(int) = switch(l)
+    []   => reverse(acc)
+    h::t => find_indices_(p, t, n+1, if(p(h)) n::acc else acc)
+
+  function nth(n : int, l : list('a)) : option('a) =
+    switch(l)
+      []   => None
+      h::t => if(n == 0) Some(h) else nth(n-1, t)
+
+  /* Unsafe version of `nth` */
+  function get(n : int, l : list('a)) : 'a =
+    switch(l)
+      [] => abort(if(n < 0) "Negative index get" else "Out of index get")
+      h::t => if(n == 0) h else get(n-1, t)
+
+
+  function length(l : list('a)) : int = length_(l, 0)
+  private function length_(l : list('a), acc : int) : int = switch(l)
+    []   => acc
+    _::t => length_(t, acc + 1)
+
+
+  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, [])
+  private function replace_at_(n : int, e : 'a, l : list('a), acc : list('a)) : list('a) =
+   switch(l)
+     []   => abort("replace_at overflow")
+     h::t => if (n == 0) reverse(e::acc) ++ t
+             else replace_at_(n-1, e, t, h::acc)
+
+  /* Unsafe. Adds `e` to `l` to be its `n`th element. Crashes on over/underflow */
+  function insert_at(n : int, e : 'a, l : list('a)) : list('a) =
+    if(n<0) abort("insert_at underflow") else insert_at_(n, e, l, [])
+  private function insert_at_(n : int, e : 'a, l : list('a), acc : list('a)) : list('a) =
+   if (n == 0) reverse(e::acc) ++ l
+   else switch(l)
+     []   => abort("insert_at overflow")
+     h::t => insert_at_(n-1, e, t, h::acc)
+
+  function insert_by(cmp : (('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)
+      h::t =>
+        if(cmp(x, h)) // x < h
+          reverse(acc) ++ (x::l)
+        else
+          insert_by_(cmp, x, t, h::acc)
+
+
+  function foldr(cons : ('a, 'b) => 'b, nil : 'b, l : list('a)) : 'b = switch(l)
+    []   => nil
+    h::t => cons(h, foldr(cons, nil, t))
+
+  function foldl(rcons : ('b, 'a) => 'b, acc : 'b, l : list('a)) : 'b = switch(l)
+    []   => acc
+    h::t => foldl(rcons, rcons(acc, h), t)
+
+  function foreach(l : list('a), f : 'a => unit) : unit =
+    switch(l)
+     []    => ()
+     e::l' =>
+       f(e)
+       foreach(l', f)
+
+  function reverse(l : list('a)) : list('a) = foldl((lst, el) => el :: lst, [], l)
+
+  function map(f : 'a => 'b, l : list('a)) : list('b) = map_(f, l, [])
+  private function map_(f : 'a => 'b, l : list('a), acc : list('b)) : list('b) = switch(l)
+    []   => reverse(acc)
+    h::t => map_(f, t, f(h)::acc)
+
+  function flat_map(f : 'a => list('b), l : list('a)) : list('b) =
+    ListInternal.flat_map(f, l)
+
+  function filter(p : 'a => bool, l : list('a)) : list('a) = filter_(p, l, [])
+  private function filter_(p : 'a => bool, l : list('a), acc : list('a)) : list('a) = switch(l)
+    []   => reverse(acc)
+    h::t => filter_(p, t, if(p(h)) h::acc else acc)
+
+  /* Take `n` first elements */
+  function take(n : int, l : list('a)) : list('a) =
+    if(n < 0) abort("Take negative number of elements") else take_(n, l, [])
+  private function take_(n : int, l : list('a), acc : list('a)) : list('a) =
+    if(n == 0) reverse(acc)
+    else switch(l)
+      []   => reverse(acc)
+      h::t => take_(n-1, t, h::acc)
+
+  /* Drop `n` first elements */
+  function drop(n : int, l : list('a)) : list('a) =
+   if(n < 0) abort("Drop negative number of elements")
+   elif (n == 0) l
+   else switch(l)
+      []   => []
+      h::t => drop(n-1, t)
+
+  /* Get the longest prefix of a list in which every element matches predicate `p` */
+  function take_while(p : 'a => bool, l : list('a)) : list('a) = take_while_(p, l, [])
+  private function take_while_(p : 'a => bool, l : list('a), acc : list('a)) : list('a) = switch(l)
+    []   => reverse(acc)
+    h::t => if(p(h)) take_while_(p, t, h::acc) else reverse(acc)
+
+  /* Drop elements from `l` until `p` holds */
+  function drop_while(p : 'a => bool, l : list('a)) : list('a) = switch(l)
+    []   => []
+    h::t => if(p(h)) drop_while(p, t) else l
+
+  /* Splits list into two lists of elements that respectively match and don't match predicate `p` */
+  function partition(p : 'a => bool, l : list('a)) : (list('a) * list('a)) = partition_(p, l, [], [])
+  private function partition_( p : 'a => bool
+                             , l : list('a)
+                             , acc_t : list('a)
+                             , acc_f : list('a)
+                             ) : (list('a) * list('a)) = switch(l)
+    []   => (reverse(acc_t), reverse(acc_f))
+    h::t => if(p(h)) partition_(p, t, h::acc_t, acc_f) else partition_(p, t, acc_t, h::acc_f)
+
+
+  function flatten(ll : list(list('a))) : list('a) = foldr((l1, l2) => l1 ++ l2, [], ll)
+
+  function all(p : 'a => bool, l : list('a)) : bool = switch(l)
+    []   => true
+    h::t => if(p(h)) all(p, t) else false
+
+  function any(p : 'a => bool, l : list('a)) : bool = switch(l)
+    []   => false
+    h::t => if(p(h)) true else any(p, t)
+
+  function sum(l : list(int)) : int = foldl ((a, b) => a + b, 0, l)
+
+  function product(l : list(int)) : int = foldl((a, b) => a * b, 1, l)
+
+
+  /* Zips two list by applying bimapping function on respective elements. Drops longer tail. */
+  function zip_with(f : ('a, 'b) => 'c, l1 : list('a), l2 : list('b)) : list('c) = zip_with_(f, l1, l2, [])
+  private function zip_with_( f : ('a, 'b) => 'c
+                            , l1 : list('a)
+                            , l2 : list('b)
+                            , acc : list('c)
+                            ) : list('c) = switch ((l1, l2))
+    (h1::t1, h2::t2) => zip_with_(f, t1, t2, f(h1, h2)::acc)
+    _ => reverse(acc)
+
+  /* Zips two lists into list of pairs. Drops longer tail. */
+  function zip(l1 : list('a), l2 : list('b)) : list('a * 'b) = zip_with((a, b) => (a, b), l1, l2)
+
+  function unzip(l : list('a * 'b)) : list('a) * list('b) = unzip_(l, [], [])
+  private function unzip_( l     : list('a * 'b)
+                         , acc_l : list('a)
+                         , acc_r : list('b)
+                         ) : (list('a) * list('b)) = switch(l)
+    []               => (reverse(acc_l), reverse(acc_r))
+    (left, right)::t => unzip_(t, left::acc_l, right::acc_r)
+
+
+  // TODO: Improve?
+  function sort(lesser_cmp : ('a, 'a) => bool, l : list('a)) : list('a) = switch(l)
+    []   => []
+    h::t => switch (partition((x) => lesser_cmp(x, h), t))
+      (lesser, bigger) => sort(lesser_cmp, lesser) ++ h::sort(lesser_cmp, bigger)
+
+
+  function intersperse(delim : 'a, l : list('a)) : list('a) = intersperse_(delim, l, [])
+  private function intersperse_(delim : 'a, l : list('a), acc : list('a)) : list('a) = switch(l)
+    []   => reverse(acc)
+    [e]  => reverse(e::acc)
+    h::t => intersperse_(delim, t, delim::h::acc)
+
+
+  function enumerate(l : list('a)) : list(int * 'a) = enumerate_(l, 0, [])
+  private function enumerate_(l : list('a), n : int, acc : list(int * 'a)) : list(int * 'a) = switch(l)
+    []   => reverse(acc)
+    h::t => enumerate_(t, n + 1, (n, h)::acc)
+

priv/stdlib/ListInternal.aes

@@ -0,0 +1,16 @@
+namespace ListInternal =
+
+  // -- Flatmap ----------------------------------------------------------------
+
+  function flat_map(f : 'a => list('b), xs : list('a)) : list('b) =
+    switch(xs)
+      []      => []
+      x :: xs => f(x) ++ flat_map(f, xs)
+
+  // -- From..to ---------------------------------------------------------------
+
+  function from_to(a : int, b : int) : list(int) = from_to_(a, b, [])
+
+  private function from_to_(a, b, acc) =
+    if (a > b) acc else from_to_(a, b - 1, b :: acc)
+

priv/stdlib/Option.aes

@@ -0,0 +1,76 @@
+include "List.aes"
+
+namespace Option =
+
+  function is_none(o : option('a)) : bool = switch(o)
+    None => true
+    Some(_) => false
+
+  function is_some(o : option('a)) : bool = switch(o)
+    None => false
+    Some(_) => true
+
+
+  function match(n : 'b, s : 'a => 'b, o : option('a)) : 'b = switch(o)
+    None => n
+    Some(x) => s(x)
+
+  function default(def : 'a, o : option('a)) : 'a = match(def, (x) => x, o)
+
+  function force(o : option('a)) : 'a = default(abort("Forced None value"), o)
+
+  function on_elem(o : option('a), f : 'a => unit) : unit = match((), f, o)
+
+  function map(f : 'a => 'b, o : option('a)) : option('b) = switch(o)
+    None => None
+    Some(x) => Some(f(x))
+
+  function map2(f : ('a, 'b) => 'c
+               , o1 : option('a)
+               , o2 : option('b)
+               ) : option('c) = switch((o1, o2))
+    (Some(x1), Some(x2)) => Some(f(x1, x2))
+    _ => None
+
+  function map3( f : ('a, 'b, 'c) => 'd
+               , o1 : option('a)
+               , o2 : option('b)
+               , o3 : option('c)
+               ) : option('d) = switch((o1, o2, o3))
+    (Some(x1), Some(x2), Some(x3)) => Some(f(x1, x2, x3))
+    _ => None
+
+  function app_over(f : option ('a => 'b), o : option('a)) : option('b) = switch((f, o))
+    (Some(ff), Some(xx)) => Some(ff(xx))
+    _ => None
+
+  function flat_map(f : 'a => option('b), o : option('a)) : option('b) = switch(o)
+    None => None
+    Some(x) => f(x)
+
+
+  function to_list(o : option('a)) : list('a) = switch(o)
+    None => []
+    Some(x) => [x]
+
+  function filter_options(l : list(option('a))) : list('a) = filter_options_(l, [])
+  private function filter_options_(l : list (option('a)), acc : list('a)) : list('a) = switch(l)
+    []         => List.reverse(acc)
+    None::t    => filter_options_(t, acc)
+    Some(x)::t => filter_options_(t, x::acc)
+
+  function seq_options(l : list (option('a))) : option (list('a)) = seq_options_(l, [])
+  private function seq_options_(l : list (option('a)), acc : list('a)) : option(list('a)) = switch(l)
+    []         => Some(List.reverse(acc))
+    None::t    => None
+    Some(x)::t => seq_options_(t, x::acc)
+
+
+  function choose(o1 : option('a), o2 : option('a)) : option('a) =
+    if(is_some(o1)) o1 else o2
+
+  function choose_first(l : list(option('a))) : option('a) = switch(l)
+    [] => None
+    None::t    => choose_first(t)
+    Some(x)::_ => Some(x)
+

priv/stdlib/Pair.aes

@@ -0,0 +1,20 @@
+namespace Pair =
+
+  function fst(t : ('a * 'b)) : 'a = switch(t)
+    (x, _) => x
+
+  function snd(t : ('a * 'b)) : 'b = switch(t)
+    (_, y) => y
+
+  function map1(f : 'a => 'c, t : ('a * 'b)) : ('c * 'b) = switch(t)
+    (x, y) => (f(x), y)
+
+  function map2(f : 'b => 'c, t : ('a * 'b)) : ('a * 'c) = switch(t)
+    (x, y) => (x, f(y))
+
+  function bimap(f : 'a => 'c, g : 'b => 'd, t : ('a * 'b)) : ('c * 'd) = switch(t)
+    (x, y) => (f(x), g(y))
+
+  function swap(t : ('a * 'b)) : ('b * 'a) = switch(t)
+    (x, y) => (y, x)
+

priv/stdlib/Triple.aes

@@ -0,0 +1,37 @@
+namespace Triple =
+
+  function fst(t : ('a * 'b * 'c)) : 'a = switch(t)
+    (x, _, _) => x
+
+  function snd(t : ('a * 'b * 'c)) : 'b = switch(t)
+    (_, y, _) => y
+
+  function thd(t : ('a * 'b * 'c)) : 'c = switch(t)
+    (_, _, z) => z
+
+
+  function map1(f : 'a => 'm, t : ('a * 'b * 'c)) : ('m * 'b * 'c) = switch(t)
+    (x, y, z) => (f(x), y, z)
+
+  function map2(f : 'b => 'm, t : ('a * 'b * 'c)) : ('a * 'm * 'c) = switch(t)
+    (x, y, z) => (x, f(y), z)
+
+  function map3(f : 'c => 'm, t : ('a * 'b * 'c)) : ('a * 'b * 'm) = switch(t)
+    (x, y, z) => (x, y, f(z))
+
+  function trimap( f : 'a => 'x
+                 , g : 'b => 'y
+                 , h : 'c => 'z
+                 , t : ('a * 'b * 'c)
+                 ) : ('x * 'y * 'z) = switch(t)
+    (x, y, z) => (f(x), g(y), h(z))
+
+  function swap(t : ('a * 'b * 'c)) : ('c * 'b * 'a) = switch(t)
+    (x, y, z) => (z, y, x)
+
+  function rotr(t : ('a * 'b * 'c)) : ('c * 'a * 'b) = switch(t)
+    (x, y, z) => (z, x, y)
+
+  function rotl(t : ('a * 'b * 'c)) : ('b * 'c * 'a) = switch(t)
+    (x, y, z) => (y, z, x)
+

rebar.config

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

rebar.lock

@@ -1,17 +1,21 @@
 {"1.1.0",
 [{<<"aebytecode">>,
   {git,"https://github.com/aeternity/aebytecode.git",
-       {ref,"c63ac888dd71c305cbc6d4f70953a176bf1f78f7"}},
+       {ref,"a66dc0a97facdeaad7e5403018ad195d989e4793"}},
   0},
  {<<"aeserialization">>,
   {git,"https://github.com/aeternity/aeserialization.git",
-       {ref,"816bf994ffb5cee218c3f22dc5fea296c9e0882e"}},
+       {ref,"47aaa8f5434b365c50a35bfd1490340b19241991"}},
   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,21 +74,9 @@ do_contract_interface(Type, ContractString, Options) ->
             string -> do_render_aci_json(JArray)
         end
     catch
-        %% The compiler errors.
+        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:{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)},
 
@@ -113,7 +101,7 @@ encode_contract(Contract = {contract, _, {con, _, Name}, _}) ->
                || F <- sort_decls(contract_funcs(Contract)),
                   is_entrypoint(F) ],
 
-    #{contract => C3#{functions => Fdefs}};
+    #{contract => C3#{functions => Fdefs, payable => is_payable(Contract)}};
 encode_contract(Namespace = {namespace, _, {con, _, Name}, _}) ->
     Tdefs = [ encode_typedef(T) || T <- sort_decls(contract_types(Namespace)) ],
     #{namespace => #{name => encode_name(Name),
@@ -125,12 +113,14 @@ encode_function(FDef = {letfun, _, {id, _, Name}, Args, Type, _}) ->
     #{name      => encode_name(Name),
       arguments => encode_args(Args),
       returns   => encode_type(Type),
-      stateful  => is_stateful(FDef)};
+      stateful  => is_stateful(FDef),
+      payable   => is_payable(FDef)};
 encode_function(FDecl = {fun_decl, _, {id, _, Name}, {fun_t, _, _, Args, Type}}) ->
     #{name      => encode_name(Name),
       arguments => encode_anon_args(Args),
       returns   => encode_type(Type),
-      stateful  => is_stateful(FDecl)}.
+      stateful  => is_stateful(FDecl),
+      payable   => is_payable(FDecl)}.
 
 encode_anon_args(Types) ->
     Anons = [ list_to_binary("_" ++ integer_to_list(X)) || X <- lists:seq(1, length(Types))],
@@ -234,12 +224,13 @@ do_render_aci_json(Json) ->
     {ok, list_to_binary(string:join(DecodedContracts, "\n"))}.
 
 decode_contract(#{contract := #{name := Name,
+                                payable := Payable,
                                 type_defs := Ts0,
                                 functions := Fs} = C}) ->
     MkTDef = fun(N, T) -> #{name => N, vars => [], typedef => T} end,
     Ts = [ MkTDef(<<"state">>, maps:get(state, C)) || maps:is_key(state, C) ] ++
          [ MkTDef(<<"event">>, maps:get(event, C)) || maps:is_key(event, C) ] ++ Ts0,
-    ["contract ", io_lib:format("~s", [Name])," =\n",
+    [payable(Payable), "contract ", io_lib:format("~s", [Name])," =\n",
      decode_tdefs(Ts), decode_funcs(Fs)];
 decode_contract(#{namespace := #{name := Name, type_defs := Ts}}) when Ts /= [] ->
     ["namespace ", io_lib:format("~s", [Name])," =\n",
@@ -249,8 +240,8 @@ decode_contract(_) -> [].
 decode_funcs(Fs) -> [ decode_func(F) || F <- Fs ].
 
 %% decode_func(#{name := init}) -> [];
-decode_func(#{name := Name, arguments := As, returns := T}) ->
+decode_func(#{name := Name, payable := Payable, arguments := As, returns := T}) ->
-    ["  entrypoint", " ", io_lib:format("~s", [Name]), " : ",
+    ["  ", payable(Payable), "entrypoint ", io_lib:format("~s", [Name]), " : ",
      decode_args(As), " => ", decode_type(T), $\n].
 
 decode_args(As) ->
@@ -264,7 +255,10 @@ decode_types(Ets) ->
 
 decode_type(#{tuple := Ets}) ->
     Ts = decode_types(Ets),
-    [$(,lists:join(",", Ts),$)];
+    case Ts of
+        [] -> ["unit"];
+        _ -> [$(,lists:join(" * ", Ts),$)]
+    end;
 decode_type(#{record := Efs}) ->
     Fs = decode_fields(Efs),
     [${,lists:join(",", Fs),$}];
@@ -325,6 +319,9 @@ decode_tvars(Vs) ->
 
 decode_tvar(#{name := N}) -> io_lib:format("~s", [N]).
 
+payable(true)  -> "payable ";
+payable(false) -> "".
+
 %% #contract{Ann, Con, [Declarations]}.
 
 contract_funcs({C, _, _, Decls}) when C == contract; C == namespace ->
@@ -349,6 +346,7 @@ sort_decls(Ds) ->
 
 is_entrypoint(Node) -> aeso_syntax:get_ann(entrypoint, Node, false).
 is_stateful(Node) -> aeso_syntax:get_ann(stateful, Node, false).
+is_payable(Node) -> aeso_syntax:get_ann(payable, Node, false).
 
 typedef_name({type_def, _, {id, _, Name}, _, _}) -> Name.
 

src/aeso_ast_to_fcode.erl

@@ -16,11 +16,11 @@
 
 -type option() :: term().
 
--type attribute() :: stateful | pure | private.
+-type attribute() :: stateful | payable | pure | private.
 
 -type fun_name() :: {entrypoint, binary()}
                   | {local_fun, [string()]}
-                  | init | event.
+                  | event.
 -type var_name() :: string().
 -type sophia_name() :: [string()].
 
@@ -32,8 +32,9 @@
               map_delete | map_member | map_size | string_length |
               string_concat | bits_set | bits_clear | bits_test | bits_sum |
               bits_intersection | bits_union | bits_difference |
-              contract_to_address | crypto_ecverify | crypto_ecverify_secp256k1 |
+              contract_to_address | crypto_verify_sig | crypto_verify_sig_secp256k1 |
-              crypto_sha3 | crypto_sha256 | crypto_blake2b.
+              crypto_sha3 | crypto_sha256 | crypto_blake2b |
+              crypto_ecverify_secp256k1 | crypto_ecrecover_secp256k1.
 
 -type flit() :: {int, integer()}
               | {string, binary()}
@@ -49,7 +50,7 @@
                | nil
                | {var, var_name()}
                | {def, fun_name(), [fexpr()]}
-               | {remote, fexpr(), fun_name(), [fexpr()]}
+               | {remote, [ftype()], ftype(), fexpr(), fun_name(), [fexpr()]}
                | {builtin, builtin(), [fexpr()]}
                | {con, arities(), tag(), [fexpr()]}
                | {tuple, [fexpr()]}
@@ -64,8 +65,9 @@
                %% lambdas) are generated by the fcode compiler, but translated
                %% to closures by the lambda lifter.
                | {def_u, fun_name(), arity()}
-               | {remote_u, fexpr(), 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()]}
@@ -108,7 +110,8 @@
 -type fcode() :: #{ contract_name := string(),
                     state_type    := ftype(),
                     event_type    := ftype() | none,
-                    functions     := #{ fun_name() => fun_def() } }.
+                    functions     := #{ fun_name() => fun_def() },
+                    payable       := boolean() }.
 
 -type type_def() :: fun(([ftype()]) -> ftype()).
 
@@ -138,6 +141,7 @@
                   functions  := #{ fun_name() => fun_def() } }.
 
 -define(HASH_BYTES, 32).
+
 %% -- Entrypoint -------------------------------------------------------------
 
 %% Main entrypoint. Takes typed syntax produced by aeso_ast_infer_types:infer/1,2
@@ -183,19 +187,20 @@ builtins() ->
               {["Oracle"],   [{"register", 4}, {"query_fee", 1}, {"query", 5}, {"get_question", 2},
                               {"respond", 4}, {"extend", 3}, {"get_answer", 2},
                               {"check", 1}, {"check_query", 2}]},
-              {["AENS"],     [{"resolve", 2}, {"preclaim", 3}, {"claim", 4}, {"transfer", 4},
+              {["AENS"],     [{"resolve", 2}, {"preclaim", 3}, {"claim", 5}, {"transfer", 4},
                               {"revoke", 3}]},
               {["Map"],      [{"from_list", 1}, {"to_list", 1}, {"lookup", 2},
                               {"lookup_default", 3}, {"delete", 2}, {"member", 2}, {"size", 1}]},
-              {["Crypto"],   [{"ecverify", 3}, {"ecverify_secp256k1", 3}, {"sha3", 1},
+              {["Crypto"],   [{"verify_sig", 3}, {"verify_sig_secp256k1", 3},
-                              {"sha256", 1}, {"blake2b", 1}]},
+                              {"ecverify_secp256k1", 3}, {"ecrecover_secp256k1", 2},
+                              {"sha3", 1}, {"sha256", 1}, {"blake2b", 1}]},
               {["Auth"],     [{"tx_hash", none}]},
               {["String"],   [{"length", 1}, {"concat", 2}, {"sha3", 1}, {"sha256", 1}, {"blake2b", 1}]},
               {["Bits"],     [{"set", 2}, {"clear", 2}, {"test", 2}, {"sum", 1}, {"intersection", 2},
                               {"union", 2}, {"difference", 2}, {"none", none}, {"all", none}]},
-              {["Bytes"],    [{"to_int", 1}, {"to_str", 1}]},
+              {["Bytes"],    [{"to_int", 1}, {"to_str", 1}, {"concat", 2}, {"split", 1}]},
               {["Int"],      [{"to_str", 1}]},
-              {["Address"],  [{"to_str", 1}, {"is_oracle", 1}, {"is_contract", 1}]}
+              {["Address"],  [{"to_str", 1}, {"is_oracle", 1}, {"is_contract", 1}, {"is_payable", 1}]}
              ],
     maps:from_list([ {NS ++ [Fun], {MkName(NS, Fun), Arity}}
                      || {NS, Funs} <- Scopes,
@@ -223,10 +228,13 @@ init_type_env() ->
        ["Chain", "ttl"] => ?type({variant, [[integer], [integer]]})
      }.
 
+is_no_code(Env) ->
+    proplists:get_value(no_code, maps:get(options, Env, []), false).
+
 %% -- Compilation ------------------------------------------------------------
 
 -spec to_fcode(env(), aeso_syntax:ast()) -> fcode().
-to_fcode(Env, [{contract, _, {con, _, Main}, Decls}]) ->
+to_fcode(Env, [{contract, Attrs, MainCon = {con, _, Main}, Decls}]) ->
     #{ builtins := Builtins } = Env,
     MainEnv = Env#{ context  => {main_contract, Main},
                     builtins => Builtins#{[Main, "state"]          => {get_state, none},
@@ -236,10 +244,15 @@ to_fcode(Env, [{contract, _, {con, _, Main}, Decls}]) ->
         decls_to_fcode(MainEnv, Decls),
     StateType = lookup_type(Env1, [Main, "state"], [], {tuple, []}),
     EventType = lookup_type(Env1, [Main, "event"], [], none),
+    Payable   = proplists:get_value(payable, Attrs, false),
     #{ contract_name => Main,
        state_type    => StateType,
        event_type    => EventType,
-       functions     => add_event_function(Env1, EventType, Funs) };
+       payable       => Payable,
+       functions     => add_init_function(Env1, MainCon, 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);
@@ -261,25 +274,34 @@ 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, _}) ->
+    case is_no_code(Env) of
+        false -> fcode_error({missing_definition, Id});
+        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, _, Name}, Args, Ret, Body}) ->
+decl_to_fcode(Env = #{ functions := Funs }, {letfun, Ann, Id = {id, _, Name}, Args, Ret, Body}) ->
     Attrs = get_attributes(Ann),
     FName = lookup_fun(Env, qname(Env, Name)),
     FArgs = args_to_fcode(Env, Args),
+    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 => type_to_fcode(Env, Ret),
+               return => FRet,
                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, _, Name}, Xs, Def) ->
+typedef_to_fcode(Env, Id = {id, _, Name}, Xs, Def) ->
+    check_state_and_event_types(Env, Id, Xs),
     Q = qname(Env, Name),
-    FDef = fun(Args) ->
+    FDef = fun(Args) when length(Args) == length(Xs) ->
                 Sub = maps:from_list(lists:zip([X || {tvar, _, X} <- Xs], Args)),
                 case Def of
                     {record_t, Fields} -> {todo, Xs, Args, record_t, Fields};
@@ -290,7 +312,9 @@ typedef_to_fcode(Env, {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} ->
@@ -311,6 +335,14 @@ typedef_to_fcode(Env, {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).
@@ -375,7 +407,31 @@ 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, _, X}) -> resolve_var(Env, X);
+expr_to_fcode(Env, Type, {qid, Ann, 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 ->
@@ -385,7 +441,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 -> fcode_error({constructor_arity_mismatch, Con, length(Args), Arity})
+        false -> internal_error({constructor_arity_mismatch, Con, length(Args), Arity})
     end;
 
 %% Tuples
@@ -398,9 +454,10 @@ expr_to_fcode(Env, Type, {proj, _Ann, Rec = {typed, _, _, RecType}, {id, _, X}})
         {con, _, _} when X == "address" ->
             {op, contract_to_address, [expr_to_fcode(Env, Rec)]};
         {con, _, _} ->
-            {fun_t, _, Named, Args, _} = Type,
+            {fun_t, _, _, Args, Ret} = Type,
-            Arity = length(Named) + length(Args),
+            FArgs = [type_to_fcode(Env, Arg) || Arg <- Args],
-            {remote_u, expr_to_fcode(Env, Rec), {entrypoint, list_to_binary(X)}, Arity};
+            {remote_u, FArgs, type_to_fcode(Env, Ret), expr_to_fcode(Env, Rec),
+                       {entrypoint, list_to_binary(X)}};
         {record_t, _} ->
             {proj, expr_to_fcode(Env, Rec), field_index(Rec, X)}
     end;
@@ -438,6 +495,27 @@ expr_to_fcode(Env, _Type, {list, _, Es}) ->
     lists:foldr(fun(E, L) -> {op, '::', [expr_to_fcode(Env, E), L]} end,
                 nil, Es);
 
+expr_to_fcode(Env, _Type, {app, _, {'..', _}, [A, B]}) ->
+    {def_u, FromTo, _} = resolve_fun(Env, ["ListInternal", "from_to"]),
+    {def, FromTo, [expr_to_fcode(Env, A), expr_to_fcode(Env, B)]};
+
+expr_to_fcode(Env, _Type, {list_comp, _, Yield, []}) ->
+    {op, '::', [expr_to_fcode(Env, Yield), nil]};
+expr_to_fcode(Env, _Type, {list_comp, As, Yield, [{comprehension_bind, {typed, {id, _, Arg}, _}, BindExpr}|Rest]}) ->
+    Env1 = bind_var(Env, Arg),
+    Bind = {lam, [Arg], expr_to_fcode(Env1, {list_comp, As, Yield, Rest})},
+    {def_u, FlatMap, _} = resolve_fun(Env, ["ListInternal", "flat_map"]),
+    {def, FlatMap, [Bind, expr_to_fcode(Env, BindExpr)]};
+expr_to_fcode(Env, Type, {list_comp, As, Yield, [{comprehension_if, _, Cond}|Rest]}) ->
+    make_if(expr_to_fcode(Env, Cond),
+            expr_to_fcode(Env, Type, {list_comp, As, Yield, Rest}),
+            nil
+           );
+expr_to_fcode(Env, Type, {list_comp, As, Yield, [LV = {letval, _, _, _, _}|Rest]}) ->
+    expr_to_fcode(Env, Type, {block, As, [LV, {list_comp, As, Yield, Rest}]});
+expr_to_fcode(Env, Type, {list_comp, As, Yield, [LF = {letfun, _, _, _, _, _}|Rest]}) ->
+    expr_to_fcode(Env, Type, {block, As, [LF, {list_comp, As, Yield, Rest}]});
+
 %% Conditionals
 expr_to_fcode(Env, _Type, {'if', _, Cond, Then, Else}) ->
     make_if(expr_to_fcode(Env, Cond),
@@ -474,30 +552,14 @@ expr_to_fcode(Env, _Type, {app, _Ann, {Op, _}, [A]}) when is_atom(Op) ->
     end;
 
 %% Function calls
-expr_to_fcode(Env, Type, {app, _Ann, Fun = {typed, _, _, {fun_t, _, NamedArgsT, _, _}}, Args}) ->
+expr_to_fcode(Env, _Type, {app, _, 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, _} when B =:= oracle_query;
+        {builtin_u, B, _Ar, TypeArgs}     -> builtin_to_fcode(B, FArgs ++ TypeArgs);
-                               B =:= oracle_get_question;
-                               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, Ct, RFun, _Ar} -> {remote, Ct, RFun, 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
             %% second component the environment
@@ -560,13 +622,60 @@ make_if(Cond, Then, Else) ->
     {'let', X, Cond, make_if({var, X}, Then, Else)}.
 
 
-get_oracle_type(oracle_register,     OType, _Args) -> OType;
+get_oracle_type(oracle_register,     {fun_t, _, _, _, OType})       -> OType;
-get_oracle_type(oracle_query,        _Type, [{typed, _, _Expr, OType} | _])   -> OType;
+get_oracle_type(oracle_query,        {fun_t, _, _, [OType | _], _}) -> OType;
-get_oracle_type(oracle_get_question, _Type, [{typed, _, _Expr, OType} | _])   -> OType;
+get_oracle_type(oracle_get_question, {fun_t, _, _, [OType | _], _}) -> OType;
-get_oracle_type(oracle_get_answer,   _Type, [{typed, _, _Expr, OType} | _])   -> OType;
+get_oracle_type(oracle_get_answer,   {fun_t, _, _, [OType | _], _}) -> OType;
-get_oracle_type(oracle_check,        _Type, [{typed, _, _Expr, OType}])       -> OType;
+get_oracle_type(oracle_check,        {fun_t, _, _, [OType | _], _}) -> OType;
-get_oracle_type(oracle_check_query,  _Type, [{typed, _, _Expr, OType} | _])   -> OType;
+get_oracle_type(oracle_check_query,  {fun_t, _, _, [OType | _], _}) -> OType;
-get_oracle_type(oracle_respond,      _Type, [_, {typed, _,_Expr, OType} | _]) -> OType.
+get_oracle_type(oracle_respond,      {fun_t, _, _, [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 --
 
@@ -794,8 +903,10 @@ op_builtins() ->
     [map_from_list, map_to_list, map_delete, map_member, map_size,
      string_length, string_concat, string_sha3, string_sha256, string_blake2b,
      bits_set, bits_clear, bits_test, bits_sum, bits_intersection, bits_union,
-     bits_difference, int_to_str, address_to_str, crypto_ecverify,
+     bits_difference, int_to_str, address_to_str, crypto_verify_sig,
-     crypto_ecverify_secp256k1, crypto_sha3, crypto_sha256, crypto_blake2b].
+     crypto_verify_sig_secp256k1, crypto_sha3, crypto_sha256, crypto_blake2b,
+     crypto_ecverify_secp256k1, crypto_ecrecover_secp256k1
+    ].
 
 builtin_to_fcode(require, [Cond, Msg]) ->
     make_if(Cond, {tuple, []}, {builtin, abort, [Msg]});
@@ -819,6 +930,32 @@ builtin_to_fcode(Builtin, Args) ->
         false -> {builtin, Builtin, Args}
     end.
 
+%% -- Init function --
+
+add_init_function(Env, Main, StateType, Funs0) ->
+    case is_no_code(Env) of
+        true  -> Funs0;
+        false ->
+            Funs     = add_default_init_function(Env, Main, StateType, Funs0),
+            InitName = {entrypoint, <<"init">>},
+            InitFun  = #{ body := InitBody} = maps:get(InitName, Funs),
+            Funs#{ InitName => InitFun#{ return => {tuple, []},
+                                         body   => {builtin, set_state, [InitBody]} } }
+    end.
+
+add_default_init_function(_Env, Main, StateType, Funs) ->
+    InitName = {entrypoint, <<"init">>},
+    case maps:get(InitName, Funs, none) of
+        %% Only add default init function if state is unit.
+        none when StateType == {tuple, []} ->
+            Funs#{ InitName => #{attrs  => [],
+                                 args   => [],
+                                 return => {tuple, []},
+                                 body   => {tuple, []}} };
+        none -> fcode_error({missing_init_function, Main});
+        _    -> Funs
+    end.
+
 %% -- Event function --
 
 add_event_function(_Env, none, Funs) -> Funs;
@@ -897,20 +1034,26 @@ 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({Tag, F, Ar}) when Tag == def_u; Tag == builtin_u ->
+lambda_lift_expr(UExpr) when element(1, UExpr) == def_u; element(1, UExpr) == 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],
+    Args = [{var, X} || X <- Xs] ++ ExtraArgs,
     Body = case Tag of
                builtin_u -> builtin_to_fcode(F, Args);
                def_u     -> {def, F, Args}
            end,
     make_closure([], Xs, Body);
-lambda_lift_expr({remote_u, Ct, F, Ar}) ->
+lambda_lift_expr({remote_u, ArgsT, RetT, Ct, F}) ->
     FVs  = free_vars(Ct),
     Ct1  = lambda_lift_expr(Ct),
-    Xs   = [ lists:concat(["arg", I]) || I <- lists:seq(1, Ar) ],
+    GasAndValueArgs = 2,
+    Xs   = [ lists:concat(["arg", I]) || I <- lists:seq(1, length(ArgsT) + GasAndValueArgs) ],
     Args = [{var, X} || X <- Xs],
-    make_closure(FVs, Xs, {remote, Ct1, F, Args});
+    make_closure(FVs, Xs, {remote, ArgsT, RetT, Ct1, F, Args});
 lambda_lift_expr(Expr) ->
     case Expr of
         {lit, _}               -> Expr;
@@ -919,7 +1062,7 @@ lambda_lift_expr(Expr) ->
         {closure, _, _}        -> Expr;
         {def, D, As}           -> {def, D, lambda_lift_exprs(As)};
         {builtin, B, As}       -> {builtin, B, lambda_lift_exprs(As)};
-        {remote, Ct, F, As}    -> {remote, lambda_lift_expr(Ct), F, lambda_lift_exprs(As)};
+        {remote, ArgsT, RetT, Ct, F, As} -> {remote, ArgsT, RetT, lambda_lift_expr(Ct), F, lambda_lift_exprs(As)};
         {con, Ar, C, As}       -> {con, Ar, C, lambda_lift_exprs(As)};
         {tuple, As}            -> {tuple, lambda_lift_exprs(As)};
         {proj, A, I}           -> {proj, lambda_lift_expr(A), I};
@@ -945,13 +1088,16 @@ lambda_lift_exprs(As) -> [lambda_lift_expr(A) || A <- As].
 
 -spec optimize_fcode(fcode()) -> fcode().
 optimize_fcode(Code = #{ functions := Funs }) ->
-    Code#{ functions := maps:map(fun(Name, Def) -> optimize_fun(Code, Name, Def) end, Funs) }.
+    Code1 = Code#{ functions := maps:map(fun(Name, Def) -> optimize_fun(Code, Name, Def) end, Funs) },
+    eliminate_dead_code(Code1).
 
 -spec optimize_fun(fcode(), fun_name(), fun_def()) -> fun_def().
 optimize_fun(Fcode, Fun, Def = #{ body := Body }) ->
     %% io:format("Optimizing ~p =\n~s\n", [_Fun, prettypr:format(pp_fexpr(_Body))]),
     Def#{ body := inliner(Fcode, Fun, Body) }.
 
+%% --- Inlining ---
+
 -spec inliner(fcode(), fun_name(), fexpr()) -> fexpr().
 inliner(Fcode, Fun, {def, Fun1, Args} = E) when Fun1 /= Fun ->
     case should_inline(Fcode, Fun1) of
@@ -964,6 +1110,33 @@ should_inline(_Fcode, _Fun1) -> false == list_to_atom("true").  %% Dialyzer
 
 inline(_Fcode, Fun, Args) -> {def, Fun, Args}. %% TODO
 
+%% --- Deadcode elimination ---
+
+-spec eliminate_dead_code(fcode()) -> fcode().
+eliminate_dead_code(Code = #{ functions := Funs }) ->
+    UsedFuns = used_functions(Funs),
+    Code#{ functions := maps:filter(fun(Name, _) -> maps:is_key(Name, UsedFuns) end,
+                                    Funs) }.
+
+-spec used_functions(#{ fun_name() => fun_def() }) -> #{ fun_name() => true }.
+used_functions(Funs) ->
+    Exported = [ Fun || {Fun, #{ attrs := Attrs }} <- maps:to_list(Funs),
+                        not lists:member(private, Attrs) ],
+    used_functions(#{}, Exported, Funs).
+
+used_functions(Used, [], _) -> Used;
+used_functions(Used, [Name | Rest], Defs) ->
+    case maps:is_key(Name, Used) of
+        true  -> used_functions(Used, Rest, Defs);
+        false ->
+            New =
+                case maps:get(Name, Defs, undef) of
+                    undef             -> []; %% We might be compiling a stub
+                    #{ body := Body } -> used_defs(Body)
+                end,
+            used_functions(Used#{ Name => true }, New ++ Rest, Defs)
+    end.
+
 %% -- Helper functions -------------------------------------------------------
 
 %% -- Types --
@@ -975,7 +1148,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 -> error({unknown_type, Name});
+        not_found -> internal_error({unknown_type, Name});
         Type      -> Type
     end.
 
@@ -1001,6 +1174,8 @@ add_fun_env(Env = #{ context := {abstract_contract, _} }, _) -> Env;  %% no func
 add_fun_env(Env = #{ fun_env := FunEnv }, Decls) ->
     Entry = fun({letfun, Ann, {id, _, Name}, Args, _, _}) ->
                 [{qname(Env, Name), {make_fun_name(Env, Ann, Name), length(Args)}}];
+               ({fun_decl, Ann, {id, _, Name}, {fun_t, _, _, ArgTypes, _}}) ->
+                [{qname(Env, Name), {make_fun_name(Env, Ann, Name), length(ArgTypes)}}];
                (_) -> [] end,
     FunEnv1 = maps:from_list(lists:flatmap(Entry, Decls)),
     Env#{ fun_env := maps:merge(FunEnv, FunEnv1) }.
@@ -1009,8 +1184,7 @@ make_fun_name(#{ context := Context }, Ann, Name) ->
     Entrypoint = proplists:get_value(entrypoint, Ann, false),
     case Context of
         {main_contract, Main} ->
-            if Name == "init" -> init;
+            if Entrypoint     -> {entrypoint, list_to_binary(Name)};
-               Entrypoint     -> {entrypoint, list_to_binary(Name)};
                true           -> {local_fun, [Main, Name]}
             end;
         {namespace, Lib} ->
@@ -1059,7 +1233,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} -> fcode_error({unbound_variable, Q});
+        {not_found, not_found} -> internal_error({unbound_variable, Q});
         {_, {B, none}}         -> {builtin, B, []};
         {_, {B, Ar}}           -> {builtin_u, B, Ar};
         {{Fun, Ar}, _}         -> {def_u, Fun, Ar}
@@ -1094,6 +1268,16 @@ pat_vars({tuple, Ps})         -> pat_vars(Ps);
 pat_vars({con, _, _, Ps})     -> pat_vars(Ps);
 pat_vars(Ps) when is_list(Ps) -> [X || P <- Ps, X <- pat_vars(P)].
 
+-spec fsplit_pat_vars(fsplit_pat()) -> [var_name()].
+fsplit_pat_vars({var, X})            -> [X || X /= "_"];
+fsplit_pat_vars({bool, _})           -> [];
+fsplit_pat_vars({int, _})            -> [];
+fsplit_pat_vars({string, _})         -> [];
+fsplit_pat_vars(nil)                 -> [];
+fsplit_pat_vars({'::', P, Q})        -> [P, Q];
+fsplit_pat_vars({tuple, Ps})         -> Ps;
+fsplit_pat_vars({con, _, _, Ps})     -> Ps.
+
 free_vars(Xs) when is_list(Xs) ->
     lists:umerge([ free_vars(X) || X <- Xs ]);
 free_vars(Expr) ->
@@ -1103,10 +1287,11 @@ free_vars(Expr) ->
         nil                  -> [];
         {def, _, As}         -> free_vars(As);
         {def_u, _, _}        -> [];
-        {remote, Ct, _, As}  -> free_vars([Ct | As]);
+        {remote, _, _, Ct, _, As} -> free_vars([Ct | As]);
-        {remote_u, Ct, _, _} -> free_vars(Ct);
+        {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);
@@ -1119,7 +1304,36 @@ free_vars(Expr) ->
         {switch, A}          -> free_vars(A);
         {split, _, X, As}    -> free_vars([{var, X} | As]);
         {nosplit, A}         -> free_vars(A);
-        {'case', P, A}       -> free_vars(A) -- lists:sort(pat_vars(P))
+        {'case', P, A}       -> free_vars(A) -- lists:sort(fsplit_pat_vars(P))
+    end.
+
+used_defs(Xs) when is_list(Xs) ->
+    lists:umerge([ used_defs(X) || X <- Xs ]);
+used_defs(Expr) ->
+    case Expr of
+        {var, _}             -> [];
+        {lit, _}             -> [];
+        nil                  -> [];
+        {def, F, As}         -> lists:umerge([F], used_defs(As));
+        {def_u, F, _}        -> [F];
+        {remote, _, _, Ct, _, As} -> used_defs([Ct | As]);
+        {remote_u, _, _, Ct, _}   -> used_defs(Ct);
+        {builtin, _, As}     -> used_defs(As);
+        {builtin_u, _, _}    -> [];
+        {builtin_u, _, _, _} -> [];
+        {con, _, _, As}      -> used_defs(As);
+        {tuple, As}          -> used_defs(As);
+        {proj, A, _}         -> used_defs(A);
+        {set_proj, A, _, B}  -> used_defs([A, B]);
+        {op, _, As}          -> used_defs(As);
+        {'let', _, A, B}     -> used_defs([A, B]);
+        {funcall, A, Bs}     -> used_defs([A | Bs]);
+        {lam, _, B}          -> used_defs(B);
+        {closure, F, A}      -> lists:umerge([F], used_defs(A));
+        {switch, A}          -> used_defs(A);
+        {split, _, _, As}    -> used_defs(As);
+        {nosplit, A}         -> used_defs(A);
+        {'case', _, A}       -> used_defs(A)
     end.
 
 get_named_args(NamedArgsT, Args) ->
@@ -1147,8 +1361,9 @@ rename(Ren, Expr) ->
         {def_u, _, _}         -> Expr;
         {builtin, B, Es}      -> {builtin, B, [rename(Ren, E) || E <- Es]};
         {builtin_u, _, _}     -> Expr;
-        {remote, Ct, F, Es}   -> {remote, rename(Ren, Ct), F, [rename(Ren, E) || E <- Es]};
+        {builtin_u, _, _, _}  -> Expr;
-        {remote_u, Ct, F, Ar} -> {remote_u, rename(Ren, Ct), F, Ar};
+        {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]};
         {tuple, Es}           -> {tuple, [rename(Ren, E) || E <- Es]};
         {proj, E, I}          -> {proj, rename(Ren, E), I};
@@ -1252,15 +1467,23 @@ field_value({field_t, _, {id, _, X}, _}, Fields) ->
 %% -- Attributes --
 
 get_attributes(Ann) ->
-    [stateful || proplists:get_value(stateful, Ann, false)].
+    [stateful || proplists:get_value(stateful, Ann, false)] ++
+    [payable  || proplists:get_value(payable, Ann, false)] ++
+    [private  || not proplists:get_value(entrypoint, Ann, false)].
 
 %% -- Basic utilities --
 
 indexed(Xs) ->
     lists:zip(lists:seq(1, length(Xs)), Xs).
 
-fcode_error(Err) ->
+-dialyzer({nowarn_function, [fcode_error/1, internal_error/1]}).
-    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 --------------------------------------------------------
 
@@ -1278,14 +1501,17 @@ 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, ".")).
 
 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) -> prettypr:text(lists:concat([S])).
+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(N) when is_integer(N) -> prettypr:text(integer_to_list(N)).
+
+pp_int(I) -> prettypr:text(integer_to_list(I)).
 
 pp_beside([])       -> prettypr:empty();
 pp_beside([X])      -> X;
@@ -1317,18 +1543,18 @@ pp_fexpr(nil) ->
 pp_fexpr({var, X})   -> pp_text(X);
 pp_fexpr({def, Fun}) -> pp_fun_name(Fun);
 pp_fexpr({def_u, Fun, Ar}) ->
-    pp_beside([pp_fun_name(Fun), pp_text("/"), pp_text(Ar)]);
+    pp_beside([pp_fun_name(Fun), pp_text("/"), pp_int(Ar)]);
 pp_fexpr({def, Fun, Args}) ->
     pp_call(pp_fun_name(Fun), Args);
 pp_fexpr({con, _, I, []}) ->
-    pp_beside(pp_text("C"), pp_text(I));
+    pp_beside(pp_text("C"), pp_int(I));
 pp_fexpr({con, _, I, Es}) ->
     pp_beside(pp_fexpr({con, [], I, []}),
               pp_fexpr({tuple, Es}));
 pp_fexpr({tuple, Es}) ->
     pp_parens(pp_par(pp_punctuate(pp_text(","), [pp_fexpr(E) || E <- Es])));
 pp_fexpr({proj, E, I}) ->
-    pp_beside([pp_fexpr(E), pp_text("."), pp_text(I)]);
+    pp_beside([pp_fexpr(E), pp_text("."), pp_int(I)]);
 pp_fexpr({lam, Xs, A}) ->
     pp_par([pp_fexpr({tuple, [{var, X} || X <- Xs]}), pp_text("=>"),
             prettypr:nest(2, pp_fexpr(A))]);
@@ -1339,7 +1565,7 @@ pp_fexpr({closure, Fun, ClEnv}) ->
           end,
     pp_call(pp_text("__CLOSURE__"), [{def, Fun} | FVs]);
 pp_fexpr({set_proj, E, I, A}) ->
-    pp_beside(pp_fexpr(E), pp_braces(pp_beside([pp_text(I), pp_text(" = "), pp_fexpr(A)])));
+    pp_beside(pp_fexpr(E), pp_braces(pp_beside([pp_int(I), pp_text(" = "), pp_fexpr(A)])));
 pp_fexpr({op, Op, [A, B] = Args}) ->
     case is_infix(Op) of
         false -> pp_call(pp_text(Op), Args);
@@ -1357,12 +1583,14 @@ 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, Ct, Fun, Ar}) ->
+pp_fexpr({remote_u, ArgsT, RetT, Ct, Fun}) ->
-    pp_beside([pp_fexpr(Ct), pp_text("."), pp_fun_name(Fun), pp_text("/"), pp_text(Ar)]);
+    pp_beside([pp_fexpr(Ct), pp_text("."), pp_fun_name(Fun), pp_text(" : "), pp_ftype({function, ArgsT, RetT})]);
-pp_fexpr({remote, Ct, Fun, As}) ->
+pp_fexpr({remote, ArgsT, RetT, Ct, Fun, As}) ->
-    pp_call(pp_beside([pp_fexpr(Ct), pp_text("."), pp_fun_name(Fun)]), As);
+    pp_call(pp_parens(pp_beside([pp_fexpr(Ct), pp_text("."), pp_fun_name(Fun), pp_text(" : "), pp_ftype({function, ArgsT, RetT})])), As);
 pp_fexpr({funcall, Fun, As}) ->
     pp_call(pp_fexpr(Fun), As);
 pp_fexpr({switch, Split}) -> pp_split(Split).
@@ -1415,4 +1643,3 @@ pp_pat(Pat)              -> pp_fexpr(Pat).
 is_infix(Op) ->
     C = hd(atom_to_list(Op)),
     C < $a orelse C > $z.
-

src/aeso_builtins.erl

@@ -10,6 +10,7 @@
 -module(aeso_builtins).
 
 -export([ builtin_function/1
+        , bytes_to_raw_string/2
         , check_event_type/1
         , used_builtins/1 ]).
 
@@ -44,7 +45,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];
+builtin_deps1({bytes_to_str, _})          -> [bytes_to_str_worker, bytes_to_str_worker_x];
 builtin_deps1(string_reverse)             -> [string_reverse_];
 builtin_deps1(require)                    -> [abort];
 builtin_deps1(_)                          -> [].
@@ -89,7 +90,13 @@ 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) -> {binop, Op, operand(A), operand(B)}.
+op(Op, A, B) -> simpl({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};
@@ -161,7 +168,10 @@ 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.
@@ -512,40 +522,60 @@ builtin_bytes_to_int(N) when N > 32 ->
            end,
     {[{"b", pointer}], Body, word}.
 
-builtin_bytes_to_str_worker() ->
+%% 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}],
-     {seq, [{ifte, ?AND(?GT(offs, 0), ?EQ(0, ?MOD(offs, 16))),
+     {ifte, ?EQ(offs, 16), {seq, [?V(acc), {inline_asm, [?A(?MSIZE), ?A(?MSTORE), ?A(?MSIZE)]}]},
-                    {seq, [?V(acc), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]}]},
-                    {inline_asm, []}},
-            {ifte, ?EQ(offs, 32), {inline_asm, [?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,
+         ?call(bytes_to_str_worker_x, [?V(w), ?ADD(offs, 1), ?ADD(?BSL(acc, 2), ?ADD(?BSL(hi, 1), lo))]))))
-                      [?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}],
+     {ifte, ?EQ(stop, offs), {seq, [?BSL(acc, ?MUL(2, ?SUB(16, offs))), {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, [?V(w), ?ADD(offs, 1), ?ADD(?BSL(acc, 2), ?ADD(?BSL(hi, 1), lo)), ?V(stop)]))))
+     },
+     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)]}] ++
-            ?call(bytes_to_str_worker, [?V(w), ?I(0), ?I(0)]),
+            builtin_bytes_to_str_body(w, N) ++
-            {inline_asm, [?A(?POP)]},
+            [{inline_asm, [?A(?POP)]}, ?V(ret)]}),
-            ?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)]}] ++
-           lists:append([ Work(I) || I <- lists:seq(0, (N + 31) div 32 - 1) ]) ++
+            builtin_bytes_to_str_body(p, N) ++
-           [?V(ret)]}),
+            [{inline_asm, [?A(?POP)]}, ?V(ret)]}),
      string}.
 
 builtin_string_reverse() ->
@@ -575,3 +605,80 @@ 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

@@ -0,0 +1,120 @@
+%%%-------------------------------------------------------------------
+%%% @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

@@ -35,6 +35,7 @@
                 | pp_icode
                 | pp_assembler
                 | pp_bytecode
+                | no_code
                 | {backend, aevm | fate}
                 | {include, {file_system, [string()]} |
                             {explicit_files, #{string() => binary()}}}
@@ -64,18 +65,18 @@ version() ->
             {ok, list_to_binary(VsnString)}
     end.
 
--spec file(string()) -> {ok, map()} | {error, binary()}.
+-spec file(string()) -> {ok, map()} | {error, [aeso_errors:error()]}.
 file(Filename) ->
     file(Filename, []).
 
--spec file(string(), options()) -> {ok, map()} | {error, binary()}.
+-spec file(string(), options()) -> {ok, map()} | {error, [aeso_errors:error()]}.
 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} ->
-	    ErrorString = [File,": ",file:format_error(Error)],
+            Msg = lists:flatten([File,": ",file:format_error(Error)]),
-	    {error, join_errors("File errors", [ErrorString], fun(E) -> E end)}
+            {error, [aeso_errors:new(file_error, Msg)]}
     end.
 
 add_include_path(File, Options) ->
@@ -87,7 +88,7 @@ add_include_path(File, Options) ->
             [{include, {file_system, [Cwd, Dir]}} | Options]
     end.
 
--spec from_string(binary() | string(), options()) -> {ok, map()} | {error, binary()}.
+-spec from_string(binary() | string(), options()) -> {ok, map()} | {error, [aeso_errors:error()]}.
 from_string(Contract, Options) ->
     from_string(proplists:get_value(backend, Options, aevm), Contract, Options).
 
@@ -97,22 +98,14 @@ from_string(Backend, ContractString, Options) ->
     try
         from_string1(Backend, ContractString, Options)
     catch
-        %% The compiler errors.
+        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:{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(Assembler, Options),
+    pp_assembler(aevm, Assembler, Options),
     ByteCodeList = to_bytecode(Assembler, Options),
     ByteCode = << << B:8 >> || B <- ByteCodeList >>,
     pp_bytecode(ByteCode, Options),
@@ -120,26 +113,31 @@ from_string1(aevm, ContractString, Options) ->
     {ok, #{byte_code => ByteCode,
            compiler_version => Version,
            contract_source => ContractString,
-           type_info => TypeInfo
+           type_info => TypeInfo,
+           abi_version => aeb_aevm_abi:abi_version(),
+           payable => maps:get(payable, Icode)
           }};
 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,
            compiler_version => Version,
            contract_source => ContractString,
            type_info => [],
-           fate_code => FateCode
+           fate_code => FateCode,
+           abi_version => aeb_fate_abi:abi_version(),
+           payable => maps:get(payable, FCode)
           }}.
 
--spec string_to_code(string(), [option()]) -> map().
+-spec string_to_code(string(), options()) -> map().
 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]),
+    {TypeEnv, TypedAst} = aeso_ast_infer_types:infer(Ast, [return_env | Options]),
     pp_typed_ast(TypedAst, Options),
     case proplists:get_value(backend, Options, aevm) of
         aevm ->
@@ -155,10 +153,6 @@ 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").
 
@@ -170,7 +164,7 @@ join_errors(Prefix, Errors, Pfun) ->
 %%       a special return type (typerep, T)
 -spec check_call(string(), string(), [string()], options()) -> {ok, string(), {[Type], Type}, [term()]}
                                                                    | {ok, string(), [term()]}
-                                                                   | {error, term()}
+                                                                   | {error, [aeso_errors:error()]}
     when Type :: term().
 check_call(Source, "init" = FunName, Args, Options) ->
     case check_call1(Source, FunName, Args, Options) of
@@ -225,16 +219,7 @@ check_call1(ContractString0, FunName, Args, Options) ->
                 {ok, FunName, CallArgs}
         end
     catch
-        error:{parse_errors, Errors} ->
+        throw:{error, Errors} -> {error, 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) ->
@@ -282,20 +267,34 @@ last_contract_indent(Decls) ->
     end.
 
 -spec to_sophia_value(string(), string(), ok | error | revert, aeb_aevm_data:data()) ->
-        {ok, aeso_syntax:expr()} | {error, term()}.
+        {ok, aeso_syntax:expr()} | {error, [aeso_errors:error()]}.
 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, term()}.
+        {ok, aeso_syntax:expr()} | {error, [aeso_errors:error()]}.
 to_sophia_value(_, _, error, Err, _Options) ->
     {ok, {app, [], {id, [], "error"}, [{string, [], Err}]}};
-to_sophia_value(_, _, revert, Data, _Options) ->
+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, {app, [], {id, [], "abort"}, [{string, [], Err}]}};
+                {ok, Err} ->
-        {error, _} = Err -> Err
+                    {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}};
+                {error, _} ->
+                    Msg = "Could not interpret the revert message\n",
+                    {error, [aeso_errors:new(data_error, Msg)]}
             end;
-to_sophia_value(ContractString, FunName, ok, Data, Options) ->
+        fate ->
+            try aeb_fate_encoding:deserialize(Data) of
+                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],
     try
         Code = string_to_code(ContractString, Options),
         #{ typed_ast := TypedAst, type_env  := TypeEnv} = Code,
@@ -312,50 +311,43 @@ to_sophia_value(ContractString, FunName, ok, Data, Options) ->
                             {ok, aeso_vm_decode:from_aevm(VmType, Type, VmValue)}
                         catch throw:cannot_translate_to_sophia ->
                             Type0Str = prettypr:format(aeso_pretty:type(Type0)),
-                            {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",
+                            Msg = io_lib:format("Cannot translate VM value ~p\n  of type ~p\n  to Sophia type ~s\n",
-                                                                                    [Data, VmType, Type0Str]))],
+                                                [Data, VmType, Type0Str]),
-                                                fun (E) -> E end)}
+                            {error, [aeso_errors:new(data_error, Msg)]}
                         end;
                     {error, _Err} ->
-                        {error, join_errors("Decode errors", [lists:flatten(io_lib:format("Failed to decode binary at type ~p", [VmType]))],
+                        Msg = io_lib:format("Failed to decode binary as type ~p\n", [VmType]),
-                                            fun(E) -> E end)}
+                        {error, [aeso_errors:new(data_error, Msg)]}
                 end;
             fate ->
                 try
                     {ok, aeso_vm_decode:from_fate(Type, aeb_fate_encoding:deserialize(Data))}
                 catch throw:cannot_translate_to_sophia ->
-                   {error, join_errors("Translation error",
+                        Type1 = prettypr:format(aeso_pretty:type(Type)),
-                                       [lists:flatten(io_lib:format("Cannot translate fate value ~p\n of Sophia type ~s\n",
+                        Msg = io_lib:format("Cannot translate FATE value ~p\n  of Sophia type ~s\n",
-                                                                    [aeb_fate_encoding:deserialize(Data), Type]))],
+                                            [aeb_fate_encoding:deserialize(Data), Type1]),
-                                       fun (E) -> E end)};
+                        {error, [aeso_errors:new(data_error, Msg)]};
-                     _:R ->
+                      _:_ ->
-                   {error, iolist_to_binary(io_lib:format("Decode error ~p: ~p\n", [R, erlang:get_stacktrace()]))}
+                        Type1 = prettypr:format(aeso_pretty:type(Type)),
+                        Msg = io_lib:format("Failed to decode binary as type ~s\n", [Type1]),
+                        {error, [aeso_errors:new(data_error, Msg)]}
                end
         end
     catch
-        error:{parse_errors, Errors} ->
+        throw:{error, Errors} -> {error, 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, term()}.
+                             | {error, [aeso_errors:error()]}.
 create_calldata(Code, Fun, Args) ->
     create_calldata(Code, Fun, Args, [{backend, aevm}]).
 
 -spec create_calldata(string(), string(), [string()], [{atom(), any()}]) ->
-                             {ok, binary()}
+                             {ok, binary()} | {error, [aeso_errors:error()]}.
-                             | {error, term()}.
+create_calldata(Code, Fun, Args, Options0) ->
-create_calldata(Code, Fun, Args, Options) ->
+    Options = [no_code | Options0],
     case proplists:get_value(backend, Options, aevm) of
         aevm ->
             case check_call(Code, Fun, Args, Options) of
@@ -373,11 +365,12 @@ create_calldata(Code, Fun, Args, Options) ->
 
 -spec decode_calldata(string(), string(), binary()) ->
                              {ok, [aeso_syntax:type()], [aeso_syntax:expr()]}
-                             | {error, term()}.
+                             | {error, [aeso_errors:error()]}.
 decode_calldata(ContractString, FunName, Calldata) ->
     decode_calldata(ContractString, FunName, Calldata, [{backend, aevm}]).
 
-decode_calldata(ContractString, FunName, Calldata, Options) ->
+decode_calldata(ContractString, FunName, Calldata, Options0) ->
+    Options = [no_code | Options0],
     try
         Code = string_to_code(ContractString, Options),
         #{ typed_ast := TypedAst, type_env  := TypeEnv} = Code,
@@ -400,14 +393,13 @@ decode_calldata(ContractString, FunName, Calldata, Options) ->
                             {ok, ArgTypes, Values}
                         catch throw:cannot_translate_to_sophia ->
                             Type0Str = prettypr:format(aeso_pretty:type(Type0)),
-                                {error, join_errors("Translation error",
+                            Msg = io_lib:format("Cannot translate VM value ~p\n  of type ~p\n  to Sophia type ~s\n",
-                                                    [lists:flatten(io_lib:format("Cannot translate VM value ~p\n  of type ~p\n  to Sophia type ~s\n",
+                                                [VmValue, VmType, Type0Str]),
-                                                                                 [VmValue, VmType, Type0Str]))],
+                            {error, [aeso_errors:new(data_error, Msg)]}
-                                                    fun (E) -> E end)}
                         end;
                     {error, _Err} ->
-                        {error, join_errors("Decode errors", [lists:flatten(io_lib:format("Failed to decode binary at type ~p", [VmType]))],
+                        Msg = io_lib:format("Failed to decode calldata as type ~p\n", [VmType]),
-                                            fun(E) -> E end)}
+                        {error, [aeso_errors:new(data_error, Msg)]}
                 end;
             fate ->
                 case aeb_fate_abi:decode_calldata(FunName, Calldata) of
@@ -419,35 +411,30 @@ decode_calldata(ContractString, FunName, Calldata, Options) ->
                             {ok, ArgTypes, AstArgs}
                         catch throw:cannot_translate_to_sophia ->
                                 Type0Str = prettypr:format(aeso_pretty:type(Type0)),
-                                {error, join_errors("Translation error",
+                                Msg = io_lib:format("Cannot translate FATE value ~p\n  to Sophia type ~s\n",
-                                                    [lists:flatten(io_lib:format("Cannot translate fate value ~p\n of Sophia type ~s\n",
+                                                    [FateArgs, Type0Str]),
-                                                                                 [FateArgs, Type0Str]))],
+                                {error, [aeso_errors:new(data_error, Msg)]}
-                                                    fun (E) -> E end)}
                         end;
                     {error, _} ->
-                        {error, join_errors("Decode errors", ["Failed to decode binary"],
+                        Msg = io_lib:format("Failed to decode calldata binary\n", []),
-                                            fun(E) -> E end)}
+                        {error, [aeso_errors:new(data_error, Msg)]}
                 end
         end
     catch
-        error:{parse_errors, Errors} ->
+        throw:{error, Errors} -> {error, 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, Funs})
+        []     -> error_missing_call_function()
     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,
@@ -455,13 +442,14 @@ 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).
 
-get_decode_type(FunName, [{contract, _, _, Defs}]) ->
+-dialyzer({nowarn_function, get_decode_type/2}).
+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,
@@ -470,7 +458,10 @@ get_decode_type(FunName, [{contract, _, _, 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]) ->
@@ -527,8 +518,9 @@ to_bytecode([], _) -> [].
 
 extract_type_info(#{functions := Functions} =_Icode) ->
     ArgTypesOnly = fun(As) -> [ T || {_, T} <- As ] end,
+    Payable = fun(Attrs) -> proplists:get_value(payable, Attrs, false) end,
     TypeInfo = [aeb_aevm_abi:function_type_info(list_to_binary(lists:last(Name)),
-                                            ArgTypesOnly(Args), TypeRep)
+                                            Payable(Attrs), ArgTypesOnly(Args), TypeRep)
                 || {Name, Attrs, Args,_Body, TypeRep} <- Functions,
                    not is_tuple(Name),
                    not lists:member(private, Attrs)
@@ -541,9 +533,11 @@ 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} ->
@@ -552,9 +546,7 @@ pp(Code, Options, Option, PPFun) ->
             ok
     end.
 
-
 %% -------------------------------------------------------------------
-%% TODO: Tempoary parser hook below...
 
 sophia_type_to_typerep(String) ->
     {ok, Ast} = aeso_parser:type(String),
@@ -563,37 +555,13 @@ sophia_type_to_typerep(String) ->
     catch _:_ -> {error, bad_type}
     end.
 
+-spec parse(string(), aeso_compiler:options()) -> none() | aeso_syntax:ast().
 parse(Text, Options) ->
-    %% Try and return something sensible here!
+    parse(Text, sets:new(), Options).
-    case aeso_parser:string(Text, 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.
 
-parse_error(Pos, ErrorString) ->
+-spec parse(string(), sets:set(), aeso_compiler:options()) -> none() | aeso_syntax:ast().
-    Error = io_lib:format("~s: ~s", [pos_error(Pos), ErrorString]),
+parse(Text, Included, Options) ->
-    error({parse_errors, [Error]}).
+    aeso_parser:string(Text, Included, Options).
 
 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

@@ -1,42 +0,0 @@
--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

@@ -0,0 +1,112 @@
+%%%-------------------------------------------------------------------
+%%% @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

@@ -98,26 +98,34 @@
      Op =:= 'SHA3'            orelse
      Op =:= 'SHA256'          orelse
      Op =:= 'BLAKE2B'         orelse
-     Op =:= 'ECVERIFY'        orelse
+     Op =:= 'VERIFY_SIG'           orelse
+     Op =:= 'VERIFY_SIG_SECP256K1' orelse
      Op =:= 'ECVERIFY_SECP256K1'   orelse
+     Op =:= 'ECRECOVER_SECP256K1'  orelse
      Op =:= 'CONTRACT_TO_ADDRESS'  orelse
      Op =:= 'AUTH_TX_HASH'         orelse
      Op =:= 'BYTES_TO_INT'         orelse
      Op =:= 'BYTES_TO_STR'         orelse
+     Op =:= 'BYTES_CONCAT'         orelse
+     Op =:= 'BYTES_SPLIT'          orelse
      Op =:= 'ORACLE_CHECK'         orelse
      Op =:= 'ORACLE_CHECK_QUERY'   orelse
      Op =:= 'IS_ORACLE'            orelse
      Op =:= 'IS_CONTRACT'          orelse
+     Op =:= 'IS_PAYABLE'           orelse
      Op =:= 'CREATOR'              orelse
      false)).
 
--record(env, { contract, vars = [], locals = [], tailpos = true }).
+-record(env, { contract, vars = [], locals = [], current_function, tailpos = true }).
 
 %% -- Debugging --------------------------------------------------------------
 
-debug(Tag, Options, Fmt, Args) ->
+is_debug(Tag, Options) ->
     Tags = proplists:get_value(debug, Options, []),
-    case Tags == all orelse lists:member(Tag, Tags) of
+    Tags == all orelse lists:member(Tag, Tags).
+
+debug(Tag, Options, Fmt, Args) ->
+    case is_debug(Tag, Options) of
         true  -> io:format(Fmt, Args);
         false -> ok
     end.
@@ -127,19 +135,16 @@ debug(Tag, Options, Fmt, Args) ->
 %% @doc Main entry point.
 compile(FCode, Options) ->
     #{ contract_name := ContractName,
-       state_type    := StateType,
        functions     := Functions } = FCode,
     SFuns  = functions_to_scode(ContractName, Functions, Options),
     SFuns1 = optimize_scode(SFuns, Options),
-    SFuns2 = add_default_init_function(SFuns1, StateType),
+    FateCode = to_basic_blocks(SFuns1),
-    FateCode = to_basic_blocks(SFuns2),
     debug(compile, Options, "~s\n", [aeb_fate_asm:pp(FateCode)]),
     FateCode.
 
 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, ".")).
@@ -147,15 +152,17 @@ make_function_name({local_fun, Xs})    -> list_to_binary("." ++ string:join(Xs,
 functions_to_scode(ContractName, Functions, Options) ->
     FunNames = maps:keys(Functions),
     maps:from_list(
-        [ {make_function_name(Name), function_to_scode(ContractName, FunNames, Name, Args, Body, Type, Options)}
+        [ {make_function_name(Name), function_to_scode(ContractName, FunNames, Name, Attrs, Args, Body, Type, Options)}
         || {Name, #{args   := Args,
                     body   := Body,
+                    attrs  := Attrs,
                     return := Type}} <- maps:to_list(Functions)]).
 
-function_to_scode(ContractName, Functions, _Name, Args, Body, ResType, _Options) ->
+function_to_scode(ContractName, Functions, Name, Attrs0, Args, Body, ResType, _Options) ->
     {ArgTypes, ResType1} = typesig_to_scode(Args, ResType),
-    SCode    = to_scode(init_env(ContractName, Functions, Args), Body),
+    Attrs = Attrs0 -- [stateful], %% Only track private and payable from here.
-    {{ArgTypes, ResType1}, SCode}.
+    SCode = to_scode(init_env(ContractName, Functions, Name, Args), Body),
+    {Attrs, {ArgTypes, ResType1}, SCode}.
 
 -define(tvars, '$tvars').
 
@@ -191,30 +198,16 @@ type_to_scode({tvar, X}) ->
         J -> {tvar, J}
     end.
 
-add_default_init_function(SFuns, StateType) when StateType /= {tuple, []} ->
-    %% Only add default if the type is unit.
-    SFuns;
-add_default_init_function(SFuns, {tuple, []}) ->
-    %% Only add default if the init function is not present
-    InitName = make_function_name(init),
-    case maps:find(InitName, SFuns) of
-        {ok, _} ->
-            SFuns;
-        error ->
-            Sig = {[], {tuple, []}},
-            Body = [tuple(0)],
-            SFuns#{ InitName => {Sig, Body} }
-    end.
-
 %% -- Phase I ----------------------------------------------------------------
 %%  Icode to structured assembly
 
 %% -- Environment functions --
 
-init_env(ContractName, FunNames, Args) ->
+init_env(ContractName, FunNames, Name, Args) ->
     #env{ vars      = [ {X, {arg, I}} || {I, {X, _}} <- with_ixs(Args) ],
           contract  = ContractName,
           locals    = FunNames,
+          current_function = Name,
           tailpos   = true }.
 
 next_var(#env{ vars = Vars }) ->
@@ -317,6 +310,24 @@ to_scode(Env, {'let', X, Expr, Body}) ->
       aeb_fate_ops:store({var, I}, {stack, 0}),
       to_scode(Env1, Body) ];
 
+to_scode(Env = #env{ current_function = Fun, tailpos = true }, {def, Fun, Args}) ->
+    %% Tail-call to current function, f(e0..en). Compile to
+    %%      [ let xi = ei ]
+    %%      [ STORE argi xi ]
+    %%      jump 0
+    {Vars, Code, _Env} =
+        lists:foldl(fun(Arg, {Is, Acc, Env1}) ->
+                        {I, Env2} = bind_local("_", Env1),
+                        ArgCode   = to_scode(notail(Env2), Arg),
+                        Acc1 = [Acc, ArgCode,
+                                aeb_fate_ops:store({var, I}, ?a)],
+                        {[I | Is], Acc1, Env2}
+                    end, {[], [], Env}, Args),
+    [ Code,
+      [ aeb_fate_ops:store({arg, I}, {var, J})
+        || {I, J} <- lists:zip(lists:seq(0, length(Vars) - 1),
+                               lists:reverse(Vars)) ],
+      loop ];
 to_scode(Env, {def, Fun, Args}) ->
     FName = make_function_id(Fun),
     Lbl   = aeb_fate_data:make_string(FName),
@@ -327,21 +338,19 @@ to_scode(Env, {funcall, Fun, Args}) ->
 to_scode(Env, {builtin, B, Args}) ->
     builtin_to_scode(Env, B, Args);
 
-to_scode(Env, {remote, Ct, Fun, [{builtin, call_gas_left, _}, Value | Args]}) ->
+to_scode(Env, {remote, ArgsT, RetT, Ct, Fun, [Gas, Value | Args]}) ->
-    %% Gas is not limited.
     Lbl = make_function_id(Fun),
-    Call = if Env#env.tailpos -> aeb_fate_ops:call_tr(?a, Lbl, ?a);
+    {ArgTypes, RetType0} = typesig_to_scode([{"_", T} || T <- ArgsT], RetT),
-              true            -> aeb_fate_ops:call_r(?a, Lbl, ?a)
+    ArgType = ?i(aeb_fate_data:make_typerep({tuple, ArgTypes})),
-           end,
+    RetType = ?i(aeb_fate_data:make_typerep(RetType0)),
+    case Gas of
+        {builtin, call_gas_left, _} ->
+            Call = aeb_fate_ops:call_r(?a, Lbl, ArgType, RetType, ?a),
             call_to_scode(Env, Call, [Ct, Value | Args]);
-
+        _ ->
-to_scode(Env, {remote, Ct, Fun, [Gas, Value | Args]}) ->
+            Call = aeb_fate_ops:call_gr(?a, Lbl, ArgType, RetType, ?a, ?a),
-    %% Gas is limited.
+            call_to_scode(Env, Call, [Ct, Value, Gas | Args])
-    Lbl = make_function_id(Fun),
+    end;
-    Call = if Env#env.tailpos -> aeb_fate_ops:call_gtr(?a, Lbl, ?a, ?a);
-              true            -> aeb_fate_ops:call_gr(?a, Lbl, ?a, ?a)
-           end,
-    call_to_scode(Env, Call, [Ct, Value, Gas | Args]);
 
 to_scode(Env, {closure, Fun, FVs}) ->
     to_scode(Env, {tuple, [{lit, {string, make_function_id(Fun)}}, FVs]});
@@ -483,6 +492,10 @@ 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) ->
@@ -542,13 +555,15 @@ builtin_to_scode(Env, address_is_oracle, [_] = Args) ->
     call_to_scode(Env, aeb_fate_ops:is_oracle(?a, ?a), Args);
 builtin_to_scode(Env, address_is_contract, [_] = Args) ->
     call_to_scode(Env, aeb_fate_ops:is_contract(?a, ?a), Args);
+builtin_to_scode(Env, address_is_payable, [_] = Args) ->
+    call_to_scode(Env, aeb_fate_ops:is_payable(?a, ?a), Args);
 builtin_to_scode(Env, aens_resolve, [_Name, _Key, _Type] = Args) ->
     call_to_scode(Env, aeb_fate_ops:aens_resolve(?a, ?a, ?a, ?a), Args);
 builtin_to_scode(Env, aens_preclaim, [_Sign, _Account, _Hash] = Args) ->
     call_to_scode(Env, [aeb_fate_ops:aens_preclaim(?a, ?a, ?a),
                         tuple(0)], Args);
-builtin_to_scode(Env, aens_claim, [_Sign, _Account, _NameString, _Salt] = Args) ->
+builtin_to_scode(Env, aens_claim, [_Sign, _Account, _NameString, _Salt, _NameFee] = Args) ->
-    call_to_scode(Env, [aeb_fate_ops:aens_claim(?a, ?a, ?a, ?a),
+    call_to_scode(Env, [aeb_fate_ops:aens_claim(?a, ?a, ?a, ?a, ?a),
                         tuple(0)], Args);
 builtin_to_scode(Env, aens_transfer, [_Sign, _From, _To, _Name] = Args) ->
     call_to_scode(Env, [aeb_fate_ops:aens_transfer(?a, ?a, ?a, ?a),
@@ -596,8 +611,10 @@ op_to_scode(bits_difference)   -> aeb_fate_ops:bits_diff(?a, ?a, ?a);
 op_to_scode(address_to_str)    -> aeb_fate_ops:addr_to_str(?a, ?a);
 op_to_scode(int_to_str)        -> aeb_fate_ops:int_to_str(?a, ?a);
 op_to_scode(contract_to_address)         -> aeb_fate_ops:contract_to_address(?a, ?a);
-op_to_scode(crypto_ecverify)           -> aeb_fate_ops:ecverify(?a, ?a, ?a, ?a);
+op_to_scode(crypto_verify_sig)           -> aeb_fate_ops:verify_sig(?a, ?a, ?a, ?a);
+op_to_scode(crypto_verify_sig_secp256k1) -> aeb_fate_ops:verify_sig_secp256k1(?a, ?a, ?a, ?a);
 op_to_scode(crypto_ecverify_secp256k1)   -> aeb_fate_ops:ecverify_secp256k1(?a, ?a, ?a, ?a);
+op_to_scode(crypto_ecrecover_secp256k1)  -> aeb_fate_ops:ecrecover_secp256k1(?a, ?a, ?a);
 op_to_scode(crypto_sha3)                 -> aeb_fate_ops:sha3(?a, ?a);
 op_to_scode(crypto_sha256)               -> aeb_fate_ops:sha256(?a, ?a);
 op_to_scode(crypto_blake2b)              -> aeb_fate_ops:blake2b(?a, ?a);
@@ -628,12 +645,12 @@ flatten_s(I) -> I.
 
 -define(MAX_SIMPL_ITERATIONS, 10).
 
-optimize_fun(_Funs, Name, {{Args, Res}, Code}, Options) ->
+optimize_fun(_Funs, Name, {Attrs, Sig, Code}, Options) ->
     Code0 = flatten(Code),
     debug(opt, Options, "Optimizing ~s\n", [Name]),
     Code1 = simpl_loop(0, Code0, Options),
     Code2 = desugar(Code1),
-    {{Args, Res}, Code2}.
+    {Attrs, Sig, Code2}.
 
 simpl_loop(N, Code, Options) when N >= ?MAX_SIMPL_ITERATIONS ->
     debug(opt, Options, "  No simpl_loop fixed_point after ~p iterations.\n\n", [N]),
@@ -672,12 +689,15 @@ pp_ann(Ind, [{i, #{ live_in := In, live_out := Out }, I} | Code]) ->
     Fmt = fun([]) -> "()";
              (Xs) -> string:join([lists:concat(["var", N]) || {var, N} <- Xs], " ")
           end,
-    Op  = [Ind, aeb_fate_pp:format_op(I, #{})],
+    Op  = [Ind, pp_op(I)],
     Ann = [["   % ", Fmt(In), " -> ", Fmt(Out)] || In ++ Out /= []],
     [io_lib:format("~-40s~s\n", [Op, Ann]),
      pp_ann(Ind, Code)];
 pp_ann(_, []) -> [].
 
+pp_op(loop) -> "LOOP";
+pp_op(I)    ->
+    aeb_fate_pp:format_op(I, #{}).
 
 pp_arg(?i(I))    -> io_lib:format("~w", [I]);
 pp_arg({arg, N}) -> io_lib:format("arg~p", [N]);
@@ -744,14 +764,13 @@ attributes(I) ->
     Pure   = fun(W, R) -> Attr(W, R, true) end,
     Impure = fun(W, R) -> Attr(W, R, false) end,
     case I of
+        loop                                  -> Impure(pc, []);
         'RETURN'                              -> Impure(pc, []);
         {'RETURNR', A}                        -> Impure(pc, A);
         {'CALL', _}                           -> Impure(?a, []);
-        {'CALL_R', A, _, B}                   -> Impure(?a, [A, B]);
+        {'CALL_R', A, _, B, C, D}             -> Impure(?a, [A, B, C, D]);
-        {'CALL_GR', A, _, B, C}               -> Impure(?a, [A, B, C]);
+        {'CALL_GR', A, _, B, C, D, E}         -> Impure(?a, [A, B, C, D, E]);
         {'CALL_T', _}                         -> Impure(pc, []);
-        {'CALL_TR', A, _, B}                  -> Impure(pc, [A, B]);
-        {'CALL_GTR', A, _, B, C}              -> Impure(pc, [A, B, C]);
         {'CALL_VALUE', A}                     -> Pure(A, []);
         {'JUMP', _}                           -> Impure(pc, []);
         {'JUMPIF', A, _}                      -> Impure(pc, A);
@@ -825,16 +844,21 @@ attributes(I) ->
         {'SHA3', A, B}                        -> Pure(A, [B]);
         {'SHA256', A, B}                      -> Pure(A, [B]);
         {'BLAKE2B', A, B}                     -> Pure(A, [B]);
-        {'ECVERIFY', A, B, C, D}              -> Pure(A, [B, C, D]);
+        {'VERIFY_SIG', A, B, C, D}            -> Pure(A, [B, C, D]);
+        {'VERIFY_SIG_SECP256K1', A, B, C, D}  -> Pure(A, [B, C, D]);
         {'ECVERIFY_SECP256K1', A, B, C, D}    -> Pure(A, [B, C, D]);
+        {'ECRECOVER_SECP256K1', A, B, C}      -> Pure(A, [B, C]);
         {'CONTRACT_TO_ADDRESS', A, B}         -> Pure(A, [B]);
         {'AUTH_TX_HASH', A}                   -> Pure(A, []);
         {'BYTES_TO_INT', A, B}                -> Pure(A, [B]);
         {'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]);
         {'IS_CONTRACT', A, B}                 -> Impure(A, [B]);
+        {'IS_PAYABLE', A, B}                  -> Impure(A, [B]);
         {'CREATOR', A}                        -> Pure(A, []);
         {'ADDRESS', A}                        -> Pure(A, []);
         {'BALANCE', A}                        -> Impure(A, []);
@@ -866,7 +890,7 @@ attributes(I) ->
         {'ORACLE_QUERY_FEE', A, B}            -> Impure(A, [B]);
         {'AENS_RESOLVE', A, B, C, D}          -> Impure(A, [B, C, D]);
         {'AENS_PRECLAIM', A, B, C}            -> Impure(none, [A, B, C]);
-        {'AENS_CLAIM', A, B, C, D}            -> Impure(none, [A, B, C, D]);
+        {'AENS_CLAIM', A, B, C, D, E}         -> Impure(none, [A, B, C, D, E]);
         'AENS_UPDATE'                         -> Impure(none, []);%% TODO
         {'AENS_TRANSFER', A, B, C, D}         -> Impure(none, [A, B, C, D]);
         {'AENS_REVOKE', A, B, C}              -> Impure(none, [A, B, C]);
@@ -945,15 +969,29 @@ simpl_s({switch, Arg, Type, Alts, Def}, Options) ->
     {switch, Arg, Type, [simplify(A, Options) || A <- Alts], simplify(Def, Options)};
 simpl_s(I, _) -> I.
 
-simpl_top(I, Code, Options) ->
+%% Safe-guard against loops in the rewriting. Shouldn't happen so throw an
-    apply_rules(rules(), I, Code, Options).
+%% error if we run out.
+-define(SIMPL_FUEL, 5000).
 
-apply_rules(Rules, I, Code, Options) ->
+simpl_top(I, Code, Options) ->
-    Cons = fun(X, Xs) -> simpl_top(X, Xs, Options) end,
+    simpl_top(?SIMPL_FUEL, I, Code, Options).
+
+simpl_top(0, I, Code, _Options) ->
+    error({out_of_fuel, I, Code});
+simpl_top(Fuel, I, Code, Options) ->
+    apply_rules(Fuel, rules(), I, Code, Options).
+
+apply_rules(Fuel, Rules, I, Code, Options) ->
+    Cons = fun(X, Xs) -> simpl_top(Fuel - 1, X, Xs, Options) end,
     case apply_rules_once(Rules, I, Code) of
         false -> [I | Code];
         {RName, New, Rest} ->
-            debug(opt_rules, Options, "  Applied ~p:\n~s  ==>\n~s\n", [RName, pp_ann("    ", [I | Code]), pp_ann("    ", New ++ Rest)]),
+            case is_debug(opt_rules, Options) of
+                true ->
+                    {OldCode, NewCode} = drop_common_suffix([I | Code], New ++ Rest),
+                    debug(opt_rules, Options, "  Applied ~p:\n~s  ==>\n~s\n", [RName, pp_ann("    ", OldCode), pp_ann("    ", NewCode)]);
+                false -> ok
+            end,
             lists:foldr(Cons, Rest, New)
     end.
 
@@ -977,6 +1015,7 @@ merge_rules() ->
 rules() ->
     merge_rules() ++
     [?RULE(r_swap_push),
+     ?RULE(r_swap_pop),
      ?RULE(r_swap_write),
      ?RULE(r_constant_propagation),
      ?RULE(r_prune_impossible_branches),
@@ -1014,12 +1053,13 @@ inline_push(Ann1, Arg, Stack, [{i, Ann2, I} = AI | Code], Acc) ->
                     {As0, As1} = split_stack_arg(Stack, As),
                     Acc1 = [{i, merge_ann(Ann1, Ann2), from_op_view(Op, R, As0 ++ [Arg] ++ As1)} | Acc],
                     {lists:reverse(Acc1), Code};
-                false ->
+                false when Arg /= R ->
                     {AI1, {i, Ann1b, _}} = swap_instrs({i, Ann1, {'STORE', ?a, Arg}}, AI),
-                    inline_push(Ann1b, Arg, Stack + Produces - Consumes, Code, [AI1 | Acc])
+                    inline_push(Ann1b, Arg, Stack + Produces - Consumes, Code, [AI1 | Acc]);
-            end;
                 false -> false
             end;
+        _ -> false
+    end;
 inline_push(_, _, _, _, _) -> false.
 
 split_stack_arg(N, As) -> split_stack_arg(N, As, []).
@@ -1030,16 +1070,42 @@ split_stack_arg(N, [A | As], Acc) ->
             true    -> N end,
     split_stack_arg(N1, As, [A | Acc]).
 
-%% Move PUSH A past non-stack instructions.
+%% Move PUSHes past non-stack instructions.
-r_swap_push(Push = {i, _, {'STORE', ?a, _}}, [I | Code]) ->
+r_swap_push(Push = {i, _, PushI}, [I | Code]) ->
+    case op_view(PushI) of
+        {_, ?a, _} ->
             case independent(Push, I) of
                 true ->
                     {I1, Push1} = swap_instrs(Push, I),
                     {[I1, Push1], Code};
                 false -> false
             end;
+        _ -> false
+    end;
 r_swap_push(_, _) -> false.
 
+%% Move non-stack instruction past POPs.
+r_swap_pop(IA = {i, _, I}, [JA = {i, _, J} | Code]) ->
+    case independent(IA, JA) of
+        true ->
+            case {op_view(I), op_view(J)} of
+                {false, _} -> false;
+                {_, false} -> false;
+                {{_, IR, IAs}, {_, RJ, JAs}} ->
+                    NonStackI = not lists:member(?a, [IR | IAs]),
+                    %% RJ /= ?a to not conflict with r_swap_push
+                    PopJ      = RJ /= ?a andalso lists:member(?a, JAs),
+                    case NonStackI andalso PopJ of
+                        false -> false;
+                        true  ->
+                            {JA1, IA1} = swap_instrs(IA, JA),
+                            {[JA1, IA1], Code}
+                    end
+            end;
+        false -> false
+    end;
+r_swap_pop(_, _) -> false.
+
 %% Match up writes to variables with instructions further down.
 r_swap_write(I = {i, _, _}, [J | Code]) ->
     case {var_writes(I), independent(I, J)} of
@@ -1175,6 +1241,8 @@ r_float_switch_body(I = {i, _, _}, [switch_body | Code]) ->
 r_float_switch_body(_, _) -> false.
 
 %% Inline stores
+r_inline_store({i, _, {'STORE', R, R}}, Code) ->
+    {[], Code};
 r_inline_store(I = {i, _, {'STORE', R = {var, _}, A}}, Code) ->
     %% Not when A is var unless updating the annotations properly.
     Inline = case A of
@@ -1268,7 +1336,11 @@ unannotate({i, _Ann, I}) -> [I].
 
 %% Desugar and specialize
 desugar({'ADD', ?a, ?i(1), ?a}) -> [aeb_fate_ops:inc()];
+desugar({'ADD', A,  ?i(1), A})  -> [aeb_fate_ops:inc(A)];
+desugar({'ADD', ?a, ?a, ?i(1)}) -> [aeb_fate_ops:inc()];
+desugar({'ADD', A,  A,  ?i(1)}) -> [aeb_fate_ops:inc(A)];
 desugar({'SUB', ?a, ?a, ?i(1)}) -> [aeb_fate_ops:dec()];
+desugar({'SUB', A, A, ?i(1)})   -> [aeb_fate_ops:dec(A)];
 desugar({'STORE', ?a, A})       -> [aeb_fate_ops:push(A)];
 desugar({switch, Arg, Type, Alts, Def}) ->
     [{switch, Arg, Type, [desugar(A) || A <- Alts], desugar(Def)}];
@@ -1283,9 +1355,9 @@ desugar(I) -> [I].
 to_basic_blocks(Funs) ->
     to_basic_blocks(maps:to_list(Funs), aeb_fate_code:new()).
 
-to_basic_blocks([{Name, {Sig, Code}}|Left], Acc) ->
+to_basic_blocks([{Name, {Attrs, Sig, Code}}|Left], Acc) ->
     BB = bb(Name, Code ++ [aeb_fate_ops:return()]),
-    to_basic_blocks(Left, aeb_fate_code:insert_fun(Name, Sig, BB, Acc));
+    to_basic_blocks(Left, aeb_fate_code:insert_fun(Name, Attrs, Sig, BB, Acc));
 to_basic_blocks([], Acc) ->
     Acc.
 
@@ -1340,7 +1412,7 @@ block(Blk = #blk{code     = [{switch, Arg, Type, Alts, Default} | Code],
     {DefRef, DefBlk} =
         case Default of
             missing when Catchall == none ->
-                FreshBlk([aeb_fate_ops:abort(?i(<<"Incomplete patterns">>))], none);
+                FreshBlk([aeb_fate_ops:exit(?i(<<"Incomplete patterns">>))], none);
             missing -> {Catchall, []};
             _       -> FreshBlk(Default ++ [{jump, RestRef}], Catchall)
                        %% ^ fall-through to the outer catchall
@@ -1413,8 +1485,7 @@ reorder_blocks(Ref, Code, Blocks, Acc) ->
         ['RETURN'|_]          -> reorder_blocks(Blocks, Acc1);
         [{'RETURNR', _}|_]    -> reorder_blocks(Blocks, Acc1);
         [{'CALL_T', _}|_]     -> reorder_blocks(Blocks, Acc1);
-        [{'CALL_TR', _, _, _}|_] -> reorder_blocks(Blocks, Acc1);
+        [{'EXIT', _}|_]       -> reorder_blocks(Blocks, Acc1);
-        [{'CALL_GTR', _, _, _}|_] -> reorder_blocks(Blocks, Acc1);
         [{'ABORT', _}|_]      -> reorder_blocks(Blocks, Acc1);
         [{switch, _, _}|_]    -> reorder_blocks(Blocks, Acc1);
         [{jump, L}|_]         ->
@@ -1455,10 +1526,8 @@ chase_labels([L | Ls], Map, Live) ->
 %% Replace PUSH, RETURN by RETURNR, drop returns after tail calls.
 tweak_returns(['RETURN', {'PUSH', A} | Code])          -> [{'RETURNR', A} | Code];
 tweak_returns(['RETURN' | Code = [{'CALL_T', _} | _]]) -> Code;
-tweak_returns(['RETURN' | Code = [{'CALL_TR', _, _, _} | _]])     -> Code;
-tweak_returns(['RETURN' | Code = [{'CALL_GT', _} | _]])           -> Code;
-tweak_returns(['RETURN' | Code = [{'CALL_GTR', _, _, _, _} | _]]) -> Code;
 tweak_returns(['RETURN' | Code = [{'ABORT', _} | _]])  -> Code;
+tweak_returns(['RETURN' | Code = [{'EXIT', _} | _]])   -> Code;
 tweak_returns(Code) -> Code.
 
 %% -- Split basic blocks at CALL instructions --
@@ -1472,10 +1541,13 @@ split_calls(Ref, [], Acc, Blocks) ->
 split_calls(Ref, [I | Code], Acc, Blocks) when element(1, I) == 'CALL';
                                                element(1, I) == 'CALL_R';
                                                element(1, I) == 'CALL_GR';
-                                               element(1, I) == 'jumpif' ->
+                                               element(1, I) == 'jumpif';
+                                               I == loop ->
     split_calls(make_ref(), Code, [], [{Ref, lists:reverse([I | Acc])} | Blocks]);
 split_calls(Ref, [{'ABORT', _} = I | _Code], Acc, Blocks) ->
     lists:reverse([{Ref, lists:reverse([I | Acc])} | Blocks]);
+split_calls(Ref, [{'EXIT', _} = I | _Code], Acc, Blocks) ->
+    lists:reverse([{Ref, lists:reverse([I | Acc])} | Blocks]);
 split_calls(Ref, [I | Code], Acc, Blocks) ->
     split_calls(Ref, Code, [I | Acc], Blocks).
 
@@ -1483,6 +1555,7 @@ split_calls(Ref, [I | Code], Acc, Blocks) ->
 
 set_labels(Labels, {Ref, Code}) when is_reference(Ref) ->
     {maps:get(Ref, Labels), [ set_labels(Labels, I) || I <- Code ]};
+set_labels(_Labels, loop)              -> aeb_fate_ops:jump(0);
 set_labels(Labels, {jump, Ref})        -> aeb_fate_ops:jump(maps:get(Ref, Labels));
 set_labels(Labels, {jumpif, Arg, Ref}) -> aeb_fate_ops:jumpif(Arg, maps:get(Ref, Labels));
 set_labels(Labels, {switch, Arg, Refs}) ->
@@ -1498,3 +1571,10 @@ set_labels(_, I) -> I.
 with_ixs(Xs) ->
     lists:zip(lists:seq(0, length(Xs) - 1), Xs).
 
+drop_common_suffix(Xs, Ys) ->
+    drop_common_suffix_r(lists:reverse(Xs), lists:reverse(Ys)).
+
+drop_common_suffix_r([X | Xs], [X | Ys]) ->
+    drop_common_suffix_r(Xs, Ys);
+drop_common_suffix_r(Xs, Ys) ->
+    {lists:reverse(Xs), lists:reverse(Ys)}.

src/aeso_icode.erl

@@ -13,8 +13,10 @@
          pp/1,
          set_name/2,
          set_namespace/2,
+         set_payable/2,
          enter_namespace/2,
          get_namespace/1,
+         in_main_contract/1,
          qualify/2,
          set_functions/2,
          map_typerep/2,
@@ -48,6 +50,7 @@
                   , type_vars => #{ string() => aeb_aevm_data:type() }
                   , constructors => #{ [string()] => integer() }  %% name to tag
                   , options => [any()]
+                  , payable => boolean()
                   }.
 
 pp(Icode) ->
@@ -65,16 +68,19 @@ new(Options) ->
      , types => builtin_types()
      , type_vars => #{}
      , constructors => builtin_constructors()
-     , options => Options}.
+     , options => Options
+     , payable => false }.
 
 builtin_types() ->
     Word = fun([]) -> word end,
     #{ "bool"         => Word
      , "int"          => Word
+     , "char"         => Word
      , "bits"         => Word
      , "string"       => fun([]) -> string end
      , "address"      => Word
      , "hash"         => Word
+     , "unit"         => fun([]) -> {tuple, []} end
      , "signature"    => fun([]) -> {tuple, [word, word]} end
      , "oracle"       => fun([_, _]) -> word end
      , "oracle_query" => fun([_, _]) -> word end
@@ -103,6 +109,10 @@ new_env() ->
 set_name(Name, Icode) ->
     maps:put(contract_name, Name, Icode).
 
+-spec set_payable(boolean(), icode()) -> icode().
+set_payable(Payable, Icode) ->
+    maps:put(payable, Payable, Icode).
+
 -spec set_namespace(aeso_syntax:con() | aeso_syntax:qcon(), icode()) -> icode().
 set_namespace(NS, Icode) -> Icode#{ namespace => NS }.
 
@@ -112,6 +122,10 @@ 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,12 +9,14 @@
 -module(aeso_parse_lib).
 
 -export([parse/2,
-         return/1, fail/0, fail/1, map/2, bind/2,
+         return/1, fail/0, fail/1, fail/2, 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]).
@@ -98,6 +100,10 @@ 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).
@@ -155,7 +161,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, {Pos, parse_error, flatten_error(Err)}};
+    {[], {Pos, Err}} -> {error, {add_current_file(Pos), parse_error, flatten_error(Err)}};
     {[A], _}         -> {ok, A};
     {As, _}          -> {error, {{1, 1}, ambiguous_parse, As}}
   end.
@@ -285,7 +291,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, T)};
+                            {Acc, unexpected_token_error(Ts, maps:keys(Map), T)};
                         F ->
                             VClose = {vclose, pos(T)},
                             Ts2    = pop_layout(VClose, Ts#ts{ last = VClose }),
@@ -322,12 +328,52 @@ 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) ->
-    mk_error(Ts, io_lib:format("Unexpected token ~p", [tag(T)])).
+    unexpected_token_error(Ts, [], 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{}}.
@@ -411,3 +457,13 @@ 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, map/2, infixl/2, infixr/2, infixl1/2, infixr1/2,
+         fail/0, fail/1, fail/2, map/2, infixl/2, infixr/2, infixl1/2, infixr1/2,
          left/2, right/2, optional/1]).
 
 

src/aeso_parser.erl

@@ -6,29 +6,45 @@
 
 -export([string/1,
          string/2,
+         string/3,
+         hash_include/2,
          type/1]).
 
 -include("aeso_parse_lib.hrl").
+-import(aeso_parse_lib, [current_file/0, set_current_file/1]).
 
--type parse_result() :: {ok, aeso_syntax:ast()}
+-type parse_result() :: aeso_syntax:ast() | none().
-                      | {error, {aeso_parse_lib:pos(), atom(), term()}}
+
-                      | {error, {aeso_parse_lib:pos(), atom()}}.
+-type include_hash() :: {string(), binary()}.
 
 -spec string(string()) -> parse_result().
 string(String) ->
-    string(String, []).
+    string(String, sets:new(), []).
 
 -spec string(string(), aeso_compiler:options()) -> parse_result().
 string(String, Opts) ->
+    case lists:keyfind(src_file, 1, Opts) of
+        {src_file, File} -> string(String, sets:add_element(File, sets:new()), Opts);
+        false -> string(String, sets:new(), Opts)
+    end.
+
+-spec string(string(), sets:set(include_hash()), aeso_compiler:options()) -> parse_result().
+string(String, Included, Opts) ->
     case parse_and_scan(file(), String, Opts) of
         {ok, AST} ->
-            expand_includes(AST, Opts);
+            case expand_includes(AST, Included, Opts) of
-        Err = {error, _} ->
+                {ok, AST1}   -> AST1;
-            Err
+                {error, Err} -> parse_error(Err)
+            end;
+        {error, Err} ->
+            parse_error(Err)
     end.
 
 type(String) ->
-    parse_and_scan(type(), String, []).
+    case parse_and_scan(type(), String, []) of
+        {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)),
@@ -37,6 +53,28 @@ 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())).
@@ -46,6 +84,7 @@ decl() ->
     choice(
       %% Contract declaration
     [ ?RULE(keyword(contract),  con(), tok('='), maybe_block(decl()), {contract, _1, _2, _4})
+    , ?RULE(token(payable),     keyword(contract), con(), tok('='), maybe_block(decl()), add_modifiers([_1], {contract, _2, _3, _5}))
     , ?RULE(keyword(namespace), con(), tok('='), maybe_block(decl()), {namespace, _1, _2, _4})
     , ?RULE(keyword(include),   str(), {include, get_ann(_1), _2})
 
@@ -70,7 +109,7 @@ fun_or_entry() ->
             ?RULE(keyword(entrypoint), {entrypoint, _1})]).
 
 modifiers() ->
-    many(choice([token(stateful), token(private), token(public)])).
+    many(choice([token(stateful), token(payable), token(private), token(public)])).
 
 add_modifiers(Mods, Entry = {entrypoint, _}, Node) ->
     add_modifiers(Mods ++ [Entry], Node);
@@ -138,9 +177,10 @@ type() -> ?LAZY_P(type100()).
 type100() -> type200().
 
 type200() ->
-    ?RULE(many({fun_domain(), keyword('=>')}), type300(), fun_t(_1, _2)).
+    ?RULE(many({type300(), keyword('=>')}), type300(), fun_t(_1, _2)).
 
-type300() -> type400().
+type300() ->
+    ?RULE(sep1(type400(), tok('*')), tuple_t(get_ann(lists:nth(1, _1)), _1)).
 
 type400() ->
     choice(
@@ -155,11 +195,17 @@ type400() ->
 
 typeAtom() ->
     ?LAZY_P(choice(
-    [ id(), token(con), token(qcon), token(qid), tvar()
+    [ parens(type())
-    , ?RULE(keyword('('), comma_sep(type()), tok(')'), tuple_t(_1, _2))
+    , args_t()
+    , id(), token(con), token(qcon), token(qid), tvar()
     ])).
 
-fun_domain() -> ?RULE(?LAZY_P(type300()), fun_domain(_1)).
+args_t() ->
+    ?LAZY_P(choice(
+    [ ?RULE(tok('('), tok(')'), {args_t, get_ann(_1), []})
+      %% Singleton case handled separately
+    , ?RULE(tok('('), type(), tok(','), sep1(type(), tok(',')), tok(')'), {args_t, get_ann(_1), [_2|_4]})
+    ])).
 
 %% -- Statements -------------------------------------------------------------
 
@@ -222,11 +268,25 @@ exprAtom() ->
         , {bool, keyword(false), false}
         , ?LET_P(Fs, brace_list(?LAZY_P(field_assignment())), record(Fs))
         , {list, [], bracket_list(Expr)}
+        , ?RULE(keyword('['), Expr, token('|'), comma_sep(comprehension_exp()), tok(']'), list_comp_e(_1, _2, _4))
         , ?RULE(tok('['), Expr, binop('..'), Expr, tok(']'), _3(_2, _4))
         , ?RULE(keyword('('), comma_sep(Expr), tok(')'), tuple_e(_1, _2))
         ])
     end).
 
+comprehension_exp() ->
+    ?LAZY_P(choice(
+      [ comprehension_bind()
+      , letdecl()
+      , comprehension_if()
+      ])).
+
+comprehension_if() ->
+    ?RULE(keyword('if'), parens(expr()), {comprehension_if, _1, _2}).
+
+comprehension_bind() ->
+    ?RULE(id(), tok('<-'), expr(), {comprehension_bind, _1, _3}).
+
 arg_expr() ->
     ?LAZY_P(
         choice([ ?RULE(id(), tok('='), expr(), {named_arg, [], _1, _3})
@@ -392,12 +452,6 @@ 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),
@@ -467,15 +521,14 @@ tuple_t(_Ann, [Type]) -> Type;  %% Not a tuple
 tuple_t(Ann, Types)   -> {tuple_t, Ann, Types}.
 
 fun_t(Domains, Type) ->
-    lists:foldr(fun({Dom, Ann}, T) -> {fun_t, Ann, [], Dom, T} end,
+    lists:foldr(fun({{args_t, _, Dom}, Ann}, T) -> {fun_t, Ann, [], Dom, T};
+                    ({Dom, Ann}, T)             -> {fun_t, Ann, [], [Dom], T} end,
                 Type, Domains).
 
 tuple_e(_Ann, [Expr]) -> Expr;  %% Not a tuple
 tuple_e(Ann, Exprs)   -> {tuple, Ann, Exprs}.
 
-%% TODO: not nice
+list_comp_e(Ann, Expr, Binds) -> {list_comp, Ann, Expr, Binds}.
-fun_domain({tuple_t, _, Args}) -> Args;
-fun_domain(T)                  -> [T].
 
 -spec parse_pattern(aeso_syntax:expr()) -> aeso_parse_lib:parser(aeso_syntax:pat()).
 parse_pattern({app, Ann, Con = {'::', _}, Es}) ->
@@ -501,14 +554,9 @@ 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) ->
-    return_error(ann_pos(Ann), prettypr:format(Doc)).
+    fail(ann_pos(Ann), prettypr:format(Doc)).
 
 -spec bad_expr_err(string(), aeso_syntax:expr()) -> aeso_parse_lib:parser(none()).
 bad_expr_err(Reason, E) ->
@@ -517,26 +565,37 @@ bad_expr_err(Reason, E) ->
                             prettypr:nest(2, aeso_pretty:expr(E))])).
 
 %% -- Helper functions -------------------------------------------------------
-expand_includes(AST, Opts) ->
-    expand_includes(AST, [], Opts).
 
-expand_includes([], Acc, _Opts) ->
+expand_includes(AST, Included, Opts) ->
+    Ann  = [{origin, system}],
+    AST1 = [ {include, Ann, {string, Ann, File}}
+             || File <- lists:usort(auto_imports(AST)) ] ++ AST,
+    expand_includes(AST1, Included, [], Opts).
+
+expand_includes([], _Included, Acc, _Opts) ->
     {ok, lists:reverse(Acc)};
-expand_includes([{include, _, S = {string, _, File}} | AST], Acc, Opts) ->
+expand_includes([{include, Ann, {string, _SAnn, File}} | AST], Included, Acc, Opts) ->
-    case read_file(File, Opts) of
+    case get_include_code(File, Ann, Opts) of
-        {ok, Bin} ->
+        {ok, Code} ->
+            Hashed = hash_include(File, Code),
+            case sets:is_element(Hashed, Included) of
+                false ->
                     Opts1 = lists:keystore(src_file, 1, Opts, {src_file, File}),
-            case string(binary_to_list(Bin), Opts1) of
+                    Included1 = sets:add_element(Hashed, Included),
+                    case parse_and_scan(file(), Code, Opts1) of
                         {ok, AST1} ->
-                    expand_includes(AST1 ++ AST, Acc, Opts);
+                            expand_includes(AST1 ++ AST, Included1, Acc, Opts);
                         Err = {error, _} ->
                             Err
                     end;
-        {error, _} ->
+                true ->
-            {error, {get_pos(S), include_error, File}}
+                    expand_includes(AST, Included, Acc, Opts)
             end;
-expand_includes([E | AST], Acc, Opts) ->
+        Err = {error, _} ->
-    expand_includes(AST, [E | Acc], Opts).
+            Err
+    end;
+expand_includes([E | AST], Included, Acc, Opts) ->
+    expand_includes(AST, Included, [E | Acc], Opts).
 
 read_file(File, Opts) ->
     case proplists:get_value(include, Opts, {explicit_files, #{}}) of
@@ -551,3 +610,31 @@ read_file(File, Opts) ->
             end
     end.
 
+stdlib_options() ->
+    [{include, {file_system, [aeso_stdlib:stdlib_include_path()]}}].
+
+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);
+        {_, {ok, Bin}} ->
+            {ok, binary_to_list(Bin)};
+        {{ok, Bin}, _} ->
+            {ok, binary_to_list(Bin)};
+        {_, _} ->
+            {error, {ann_pos(Ann), include_error, File}}
+    end.
+
+-spec hash_include(string() | binary(), string()) -> include_hash().
+hash_include(File, Code) when is_binary(File) ->
+    hash_include(binary_to_list(File), Code);
+hash_include(File, Code) when is_list(File) ->
+    {filename:basename(File), crypto:hash(sha256, Code)}.
+
+auto_imports({comprehension_bind, _, _}) -> [<<"ListInternal.aes">>];
+auto_imports({'..', _})                  -> [<<"ListInternal.aes">>];
+auto_imports(L) when is_list(L) ->
+    lists:flatmap(fun auto_imports/1, L);
+auto_imports(T) when is_tuple(T) ->
+    auto_imports(tuple_to_list(T));
+auto_imports(_) -> [].

src/aeso_pretty.erl

@@ -222,7 +222,7 @@ typedef({variant_t, Constructors}) ->
 
 -spec constructor_t(aeso_syntax:constructor_t()) -> doc().
 constructor_t({constr_t, _, C, []}) -> name(C);
-constructor_t({constr_t, _, C, Args}) -> beside(name(C), tuple_type(Args)).
+constructor_t({constr_t, _, C, Args}) -> beside(name(C), args_type(Args)).
 
 -spec field_t(aeso_syntax:field_t()) -> doc().
 field_t({field_t, _, Name, Type}) ->
@@ -234,13 +234,17 @@ type(Type, Options) ->
 
 -spec type(aeso_syntax:type()) -> doc().
 type({fun_t, _, Named, Args, Ret}) ->
+    follow(hsep(args_type(Named ++ Args), text("=>")), type(Ret));
+type({type_sig, _, Named, Args, Ret}) ->
     follow(hsep(tuple_type(Named ++ Args), text("=>")), type(Ret));
 type({app_t, _, Type, []}) ->
     type(Type);
 type({app_t, _, Type, Args}) ->
-    beside(type(Type), tuple_type(Args));
+    beside(type(Type), args_type(Args));
 type({tuple_t, _, Args}) ->
     tuple_type(Args);
+type({args_t, _, Args}) ->
+    args_type(Args);
 type({bytes_t, _, any}) -> text("bytes(_)");
 type({bytes_t, _, Len}) ->
     text(lists:concat(["bytes(", Len, ")"]));
@@ -256,10 +260,20 @@ type(T = {con, _, _})  -> name(T);
 type(T = {qcon, _, _}) -> name(T);
 type(T = {tvar, _, _}) -> name(T).
 
--spec tuple_type([aeso_syntax:type()]) -> doc().
+-spec args_type([aeso_syntax:type()]) -> doc().
-tuple_type(Args) ->
+args_type(Args) ->
     tuple(lists:map(fun type/1, Args)).
 
+-spec tuple_type([aeso_syntax:type()]) -> doc().
+tuple_type([]) ->
+    text("unit");
+tuple_type(Factors) ->
+    beside(
+      [ text("(")
+      , par(punctuate(text(" *"), lists:map(fun type/1, Factors)), 0)
+      , text(")")
+      ]).
+
 -spec arg_expr(aeso_syntax:arg_expr()) -> doc().
 arg_expr({named_arg, _, Name, E}) ->
     follow(hsep(expr(Name), text("=")), expr(E));

src/aeso_scan.erl

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

src/aeso_stdlib.erl

@@ -0,0 +1,17 @@
+%%%-------------------------------------------------------------------
+%%% @author Radosław Rowicki
+%%% @copyright (C) 2019, Aeternity Anstalt
+%%% @doc
+%%%     Standard library for Sophia
+%%% @end
+%%% Created : 6 July 2019
+%%%
+%%%-------------------------------------------------------------------
+
+-module(aeso_stdlib).
+
+-export([stdlib_include_path/0]).
+
+stdlib_include_path() ->
+    filename:join([code:priv_dir(aesophia), "stdlib"]).
+

src/aeso_syntax.erl

@@ -59,6 +59,7 @@
 -type type() :: {fun_t, ann(), [named_arg_t()], [type()], type()}
               | {app_t, ann(), type(), [type()]}
               | {tuple_t, ann(), [type()]}
+              | {args_t, ann(), [type()]}   %% old tuple syntax, old for error messages
               | {bytes_t, ann(), integer() | any}
               | id()  | qid()
               | con() | qcon()  %% contracts
@@ -92,6 +93,7 @@
      | {proj, ann(), expr(), id()}
      | {tuple, ann(), [expr()]}
      | {list, ann(), [expr()]}
+     | {list_comp, ann(), expr(), [comprehension_exp()]}
      | {typed, ann(), expr(), type()}
      | {record, ann(), [field(expr())]}
      | {record, ann(), expr(), [field(expr())]} %% record update
@@ -104,6 +106,10 @@
      | id() | qid() | con() | qcon()
      | constant().
 
+-type comprehension_exp() :: [ {comprehension_bind, id(), expr()}
+                             | {comprehension_if, ann(), expr()}
+                             | letbind() ].
+
 -type arg_expr() :: expr() | {named_arg, ann(), id(), expr()}.
 
 %% When lvalue is a projection this is sugar for accessing fields in nested

src/aeso_syntax_utils.erl

@@ -49,7 +49,7 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
             {type_def, _, I, _, D}   -> Plus(BindType(I), Decl(D));
             {fun_decl, _, _, T}      -> Type(T);
             {letval, _, F, T, E}     -> Sum([BindExpr(F), Type(T), Expr(E)]);
-            {letfun, _, F, Xs, T, E} -> Sum([BindExpr(F), Type(T), Scoped(BindExpr(Xs), Expr(E))]);
+            {letfun, _, F, Xs, T, E} -> Sum([BindExpr(F), Type(T), Expr(Xs ++ [E])]);
             %% typedef()
             {alias_t, T}    -> Type(T);
             {record_t, Fs}  -> Type(Fs);
@@ -71,6 +71,15 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
             {proj, _, E, _}        -> Expr(E);
             {tuple, _, As}         -> Expr(As);
             {list, _, As}          -> Expr(As);
+            {list_comp, _, Y, []}  -> Expr(Y);
+            {list_comp, A, Y, [{comprehension_bind, I, E}|R]} ->
+                Plus(Expr(E), Scoped(BindExpr(I), Expr({list_comp, A, Y, R})));
+            {list_comp, A, Y, [{comprehension_if, _, E}|R]} ->
+                Plus(Expr(E), Expr({list_comp, A, Y, R}));
+            {list_comp, A, Y, [D = {letval, _, F, _, _} | R]} ->
+                Plus(Decl(D), Scoped(BindExpr(F), Expr({list_comp, A, Y, R})));
+            {list_comp, A, Y, [D = {letfun, _, F, _, _, _} | R]} ->
+                Plus(Decl(D), Scoped(BindExpr(F), Expr({list_comp, A, Y, R})));
             {typed, _, E, T}       -> Plus(Expr(E), Type(T));
             {record, _, Fs}        -> Expr(Fs);
             {record, _, E, Fs}     -> Expr([E | Fs]);
@@ -83,7 +92,7 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
             {field, _, LV, E}    -> Expr([LV, E]);
             {field, _, LV, _, E} -> Expr([LV, E]);
             %% arg()
-            {arg, _, X, T} -> Plus(Expr(X), Type(T));
+            {arg, _, Y, T} -> Plus(BindExpr(Y), Type(T));
             %% alt()
             {'case', _, P, E} -> Scoped(BindExpr(P), Expr(E));
             %% elim()
@@ -115,12 +124,12 @@ used_types([Top] = _CurrentNS, T) ->
 entity_alg() ->
     IsBound = fun({K, _}) -> lists:member(K, [bound_term, bound_type]) end,
     Unbind  = fun(bound_term) -> term; (bound_type) -> type end,
-    Remove  = fun(Keys, Map) -> lists:foldl(fun maps:remove/2, Map, Keys) end,
+    Remove  = fun(Keys, Map) -> maps:without(Keys, Map) end,
     Scoped = fun(Xs, Ys) ->
-                Bound  = [E || E <- maps:keys(Ys), IsBound(E)],
+                Bound  = [E || E <- maps:keys(Xs), IsBound(E)],
-                Others = Remove(Bound, Ys),
                 Bound1 = [ {Unbind(Tag), X} || {Tag, X} <- Bound ],
-                maps:merge(Remove(Bound1, Xs), Others)
+                Others = Remove(Bound1, Ys),
+                maps:merge(Remove(Bound, Xs), Others)
             end,
     #alg{ zero   = #{}
         , plus   = fun maps:merge/2

src/aesophia.app.src

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

test/aeso_abi_tests.erl

@@ -66,25 +66,77 @@ encode_decode_sophia_test() ->
     ok = Check("bool", "true"),
     ok = Check("bool", "false"),
     ok = Check("string", "\"Hello\""),
-    ok = Check("(string, list(int), option(bool))",
+    ok = Check("string * list(int) * option(bool)",
                "(\"Hello\", [1, 2, 3], Some(true))"),
     ok = Check("variant", "Blue({[\"x\"] = 1})"),
     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"
            , "  type arg_type = ", SophiaType, "\n"
-           , "  type an_alias('a) = (string, 'a)\n"
+           , "  type an_alias('a) = string * 'a\n"
            , "  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], []) of
+    case aeso_compiler:check_call(lists:flatten(Code), "foo", [String], [no_code]) of
         {ok, _, {[Type], _}, [Arg]} ->
             io:format("Type ~p~n", [Type]),
             Data = encode(Arg),
-            case aeso_compiler:to_sophia_value(Code, "foo", ok, Data) of
+            case aeso_compiler:to_sophia_value(Code, "foo", ok, Data, [no_code]) of
                 {ok, Sophia} ->
                     lists:flatten(io_lib:format("~s", [prettypr:format(aeso_pretty:expr(Sophia))]));
                 {error, Err} ->
@@ -137,10 +189,10 @@ parameterized_contract(FunName, Types) ->
 parameterized_contract(ExtraCode, FunName, Types) ->
     lists:flatten(
         ["contract Remote =\n"
-         "  entrypoint bla : () => ()\n\n"
+         "  entrypoint bla : () => unit\n\n"
          "contract Dummy =\n",
          ExtraCode, "\n",
-         "  type an_alias('a) = (string, 'a)\n"
+         "  type an_alias('a) = string * 'a\n"
          "  record r = {x : an_alias(int), y : variant}\n"
          "  datatype variant = Red | Blue(map(string, int))\n"
          "  entrypoint ", FunName, " : (", string:join(Types, ", "), ") => int\n" ]).
@@ -152,7 +204,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"], []),
+                                                        "oq_1111111111111111111111111111113AFEFpt5"], [no_code]),
 
     ok.
 
@@ -161,8 +213,10 @@ permissive_literals_fail_test() ->
         "contract OracleTest =\n"
         "  stateful entrypoint haxx(o : oracle(list(string), option(int))) =\n"
         "    Chain.spend(o, 1000000)\n",
-        {error, <<"Type errors\nCannot unify", _/binary>>} =
+    {error, [Err]} =
         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) ->
@@ -173,8 +227,8 @@ encode_decode_calldata(FunName, Types, Args, RetType) ->
     encode_decode_calldata_(Code, FunName, Args, RetType).
 
 encode_decode_calldata_(Code, FunName, Args, RetVMType) ->
-    {ok, Calldata} = aeso_compiler:create_calldata(Code, FunName, Args),
+    {ok, Calldata} = aeso_compiler:create_calldata(Code, FunName, Args, []),
-    {ok, _, {ArgTypes, RetType}, _} = aeso_compiler:check_call(Code, FunName, Args, [{backend, aevm}]),
+    {ok, _, {ArgTypes, RetType}, _} = aeso_compiler:check_call(Code, FunName, Args, [{backend, aevm}, no_code]),
     ?assertEqual(RetType, RetVMType),
     CalldataType = {tuple, [word, {tuple, ArgTypes}]},
     {ok, {_Hash, ArgTuple}} = aeb_heap:from_binary(CalldataType, Calldata),
@@ -182,7 +236,7 @@ encode_decode_calldata_(Code, FunName, Args, RetVMType) ->
         "init" ->
             ok;
         _ ->
-            {ok, _ArgTypes, ValueASTs} = aeso_compiler:decode_calldata(Code, FunName, Calldata),
+            {ok, _ArgTypes, ValueASTs} = aeso_compiler:decode_calldata(Code, FunName, Calldata, []),
             Values = [ prettypr:format(aeso_pretty:expr(V)) || V <- ValueASTs ],
             ?assertMatch({X, X}, {Args, Values})
     end,

test/aeso_aci_tests.erl

@@ -14,20 +14,22 @@ test_contract(N) ->
     ?assertEqual({ok, DecACI}, aeso_aci:render_aci_json(JSON)).
 
 test_cases(1) ->
-    Contract = <<"contract C =\n"
+    Contract = <<"payable contract C =\n"
-		 "  entrypoint a(i : int) = i+1\n">>,
+		 "  payable stateful entrypoint a(i : int) = i+1\n">>,
     MapACI = #{contract =>
 		   #{name => <<"C">>,
 		     type_defs => [],
+                     payable => true,
 		     functions =>
 			 [#{name => <<"a">>,
 			    arguments =>
 				[#{name => <<"i">>,
 				   type => <<"int">>}],
 			    returns => <<"int">>,
-			    stateful => false}]}},
+			    stateful => true,
-    DecACI = <<"contract C =\n"
+                            payable  => true}]}},
-	       "  entrypoint a : (int) => int\n">>,
+    DecACI = <<"payable contract C =\n"
+	       "  payable entrypoint a : (int) => int\n">>,
     {Contract,MapACI,DecACI};
 
 test_cases(2) ->
@@ -35,7 +37,7 @@ test_cases(2) ->
 		 "  type allan = int\n"
 		 "  entrypoint a(i : allan) = i+1\n">>,
     MapACI = #{contract =>
-                       #{name => <<"C">>,
+                       #{name => <<"C">>, payable => false,
                          type_defs =>
                              [#{name => <<"allan">>,
                                 typedef => <<"int">>,
@@ -46,14 +48,15 @@ test_cases(2) ->
                                        type => <<"C.allan">>}],
                                 name => <<"a">>,
                                 returns => <<"int">>,
-                                stateful => false}]}},
+                                stateful => false,
+                                payable  => false}]}},
     DecACI = <<"contract C =\n"
                "  type allan = int\n"
                "  entrypoint a : (C.allan) => int\n">>,
     {Contract,MapACI,DecACI};
 test_cases(3) ->
     Contract = <<"contract C =\n"
-                 "  type state = ()\n"
+                 "  type state = unit\n"
                  "  datatype event = SingleEventDefined\n"
 		 "  datatype bert('a) = Bin('a)\n"
 		 "  entrypoint a(i : bert(string)) = 1\n">>,
@@ -64,10 +67,10 @@ test_cases(3) ->
 				   type =>
 				       #{<<"C.bert">> => [<<"string">>]}}],
 			    name => <<"a">>,returns => <<"int">>,
-			    stateful => false}],
+			    stateful => false, payable  => false}],
-		     name => <<"C">>,
+		     name => <<"C">>, payable => false,
                      event => #{variant => [#{<<"SingleEventDefined">> => []}]},
-                     state => #{tuple => []},
+                     state => <<"unit">>,
 		     type_defs =>
 			 [#{name => <<"bert">>,
 			    typedef =>
@@ -75,7 +78,7 @@ test_cases(3) ->
 				      [#{<<"Bin">> => [<<"'a">>]}]},
 			    vars => [#{name => <<"'a">>}]}]}},
     DecACI = <<"contract C =\n"
-               "  type state = ()\n"
+               "  type state = unit\n"
                "  datatype event = SingleEventDefined\n"
 	       "  datatype bert('a) = Bin('a)\n"
 	       "  entrypoint a : (C.bert(string)) => int\n">>,
@@ -104,11 +107,11 @@ aci_test_contract(Name) ->
 
 check_stub(Stub, Options) ->
     case aeso_parser:string(binary_to_list(Stub), Options) of
-        {ok, Ast} ->
+        Ast ->
             try
                 %% io:format("AST: ~120p\n", [Ast]),
                 aeso_ast_infer_types:infer(Ast, [])
-            catch _:{type_errors, TE} ->
+            catch throw:{type_errors, TE} ->
                 io:format("Type error:\n~s\n", [TE]),
                 error(TE);
                   _:R ->

test/aeso_calldata_tests.erl

@@ -36,10 +36,34 @@ calldata_test_() ->
            end
         end} || {ContractName, Fun, Args} <- compilable_contracts()].
 
+calldata_aci_test_() ->
+     [ {"Testing " ++ ContractName ++ " contract calling " ++ Fun,
+        fun() ->
+           ContractString       = aeso_test_utils:read_contract(ContractName),
+           {ok, ContractACIBin} = aeso_aci:contract_interface(string, ContractString),
+           ContractACI = binary_to_list(ContractACIBin),
+           io:format("ACI:\n~s\n", [ContractACIBin]),
+           AevmExprs =
+              case not lists:member(ContractName, not_yet_compilable(aevm)) of
+                  true -> ast_exprs(ContractACI, Fun, Args, [{backend, aevm}]);
+                  false -> undefined
+              end,
+           FateExprs =
+              case not lists:member(ContractName, not_yet_compilable(fate)) of
+                  true -> ast_exprs(ContractACI, Fun, Args, [{backend, fate}]);
+                  false -> undefined
+              end,
+           case FateExprs == undefined orelse AevmExprs == undefined of
+               true -> ok;
+               false ->
+                   ?assertEqual(FateExprs, AevmExprs)
+           end
+        end} || {ContractName, Fun, Args} <- compilable_contracts()].
+
 
 ast_exprs(ContractString, Fun, Args, Opts) ->
-    {ok, Data} = aeso_compiler:create_calldata(ContractString, Fun, Args, Opts),
+    {ok, Data} = (catch aeso_compiler:create_calldata(ContractString, Fun, Args, Opts)),
-    {ok, _Types, Exprs} = aeso_compiler:decode_calldata(ContractString, Fun, Data, Opts),
+    {ok, _Types, Exprs} = (catch aeso_compiler:decode_calldata(ContractString, Fun, Data, Opts)),
     ?assert(is_list(Exprs)),
     Exprs.
 
@@ -92,11 +116,14 @@ compilable_contracts() ->
      {"complex_types", "filter_some", ["[Some(11), Some(12), None]"]},
      {"complex_types", "init", ["ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ"]},
      {"__call" "init", []},
-     {"bitcoin_auth", "authorize", ["1", "#0102030405060708090a0b0c0d0e0f101718192021222324252627282930313233343536373839401a1b1c1d1e1f202122232425262728293031323334353637"]},
+     {"bitcoin_auth", "authorize", ["1", "#0102030405060708090a0b0c0d0e0f101718192021222324252627282930313233343536373839401a1b1c1d1e1f20212223242526272829303132333435363738"]},
-     {"bitcoin_auth", "to_sign", ["#0102030405060708090a0b0c0d0e0f1017181920212223242526272829303132", "2"]}
+     {"bitcoin_auth", "to_sign", ["#0102030405060708090a0b0c0d0e0f1017181920212223242526272829303132", "2"]},
+     {"stub", "foo", ["42"]},
+     {"stub", "foo", ["-42"]},
+     {"payable", "foo", ["42"]}
     ].
 
 not_yet_compilable(fate) ->
-    ["address_chain"];
+    [];
 not_yet_compilable(aevm) ->
-    ["__call"].
+    [].

test/aeso_compiler_tests.erl

@@ -32,16 +32,34 @@ simple_compile_test_() ->
            end
        end} || ContractName <- compilable_contracts(), Backend <- [aevm, fate],
                not lists:member(ContractName, not_yet_compilable(Backend))] ++
+    [ {"Test file not found error",
+       fun() ->
+           {error, Errors} = aeso_compiler:file("does_not_exist.aes"),
+           ExpErr = <<"File error:\ndoes_not_exist.aes: no such file or directory">>,
+           check_errors([ExpErr], Errors)
+       end} ] ++
     [ {"Testing error messages of " ++ ContractName,
        fun() ->
-            case compile(aevm, ContractName) of
+           Errors = compile(aevm, ContractName),
-                <<"Type errors\n", ErrorString/binary>> ->
+           check_errors(ExpectedErrors, Errors)
-                    check_errors(lists:sort(ExpectedErrors), ErrorString);
-                <<"Parse errors\n", ErrorString/binary>> ->
-                    check_errors(lists:sort(ExpectedErrors), ErrorString)
-            end
        end} ||
            {ContractName, ExpectedErrors} <- failing_contracts() ] ++
+    [ {"Testing " ++ atom_to_list(Backend) ++ " code generation error messages of " ++ ContractName,
+       fun() ->
+           Errors = compile(Backend, ContractName),
+           Expect =
+               case is_binary(ExpectedError) of
+                   true  -> [ExpectedError];
+                   false ->
+                       case proplists:get_value(Backend, ExpectedError, no_error) of
+                           no_error -> no_error;
+                           Err      -> [Err]
+                       end
+               end,
+           check_errors(Expect, Errors)
+       end} ||
+           {ContractName, ExpectedError} <- failing_code_gen_contracts(),
+           Backend <- [aevm, fate] ] ++
     [ {"Testing include with explicit files",
        fun() ->
            FileSystem = maps:from_list(
@@ -53,19 +71,25 @@ simple_compile_test_() ->
            #{byte_code := Code2} = compile(aevm, "include"),
            ?assertMatch(true, Code1 == Code2)
        end} ] ++
-     [ {"Testing deadcode elimination",
+    [ {"Testing deadcode elimination for " ++ atom_to_list(Backend),
        fun() ->
-            #{ byte_code := NoDeadCode } = compile(aevm, "nodeadcode"),
+           #{ byte_code := NoDeadCode } = compile(Backend, "nodeadcode"),
-            #{ byte_code := DeadCode   } = compile(aevm, "deadcode"),
+           #{ byte_code := DeadCode   } = compile(Backend, "deadcode"),
            SizeNoDeadCode = byte_size(NoDeadCode),
            SizeDeadCode   = byte_size(DeadCode),
-            ?assertMatch({_, _, true}, {SizeDeadCode, SizeNoDeadCode, SizeDeadCode + 40 < SizeNoDeadCode}),
+           Delta          = if Backend == aevm -> 40;
+                               Backend == fate -> 20 end,
+           ?assertMatch({_, _, true}, {SizeDeadCode, SizeNoDeadCode, SizeDeadCode + Delta < SizeNoDeadCode}),
            ok
-        end} ].
+       end} || Backend <- [aevm, fate] ] ++
+    [].
 
-check_errors(Expect, ErrorString) ->
+check_errors(no_error, Actual) -> ?assertMatch(#{}, Actual);
-    %% This removes the final single \n as well.
+check_errors(Expect, #{}) ->
-    Actual = binary:split(<<ErrorString/binary,$\n>>, <<"\n\n">>, [global,trim]),
+    ?assertEqual({error, Expect}, ok);
+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});
@@ -73,13 +97,15 @@ check_errors(Expect, ErrorString) ->
     end.
 
 compile(Backend, Name) ->
-    compile(Backend, Name, [{include, {file_system, [aeso_test_utils:contract_path()]}}]).
+    compile(Backend, Name,
+            [{include, {file_system, [aeso_test_utils:contract_path()]}}]).
 
 compile(Backend, Name, Options) ->
     String = aeso_test_utils:read_contract(Name),
-    case aeso_compiler:from_string(String, [{src_file, Name}, {backend, Backend} | Options]) of
+    case aeso_compiler:from_string(String, [{src_file, Name ++ ".aes"}, {backend, Backend} | Options]) of
         {ok, Map}                                        -> Map;
-        {error, ErrorString} -> ErrorString
+        {error, ErrorString} when is_binary(ErrorString) -> ErrorString;
+        {error, Errors}                                  -> Errors
     end.
 
 %% compilable_contracts() -> [ContractName].
@@ -117,7 +143,16 @@ compilable_contracts() ->
      "address_chain",
      "namespace_bug",
      "bytes_to_x",
-     "aens"
+     "bytes_concat",
+     "aens",
+     "tuple_match",
+     "cyclic_include",
+     "stdlib_include",
+     "double_include",
+     "manual_stdlib_include",
+     "list_comp",
+     "payable",
+     "unapplied_builtins"
     ].
 
 not_yet_compilable(fate) -> [];
@@ -125,232 +160,514 @@ 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() ->
-    [ {"name_clash",
+    %% Parse errors
-       [<<"Duplicate definitions of abort at\n"
+    [ ?PARSE_ERROR(field_parse_error,
+       [<<?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">>,
-        <<"Duplicate definitions of require at\n"
+        <<?Pos(15, 3)
+          "Duplicate definitions of require at\n"
           "  - (builtin location)\n"
           "  - line 15, column 3">>,
-        <<"Duplicate definitions of double_def at\n"
+        <<?Pos(11, 3)
+          "Duplicate definitions of double_def at\n"
           "  - line 10, column 3\n"
           "  - line 11, column 3">>,
-        <<"Duplicate definitions of double_proto at\n"
+        <<?Pos(5, 3)
+          "Duplicate definitions of double_proto at\n"
           "  - line 4, column 3\n"
           "  - line 5, column 3">>,
-        <<"Duplicate definitions of proto_and_def at\n"
+        <<?Pos(8, 3)
+          "Duplicate definitions of proto_and_def at\n"
           "  - line 7, column 3\n"
           "  - line 8, column 3">>,
-        <<"Duplicate definitions of put at\n"
+        <<?Pos(16, 3)
+          "Duplicate definitions of put at\n"
           "  - (builtin location)\n"
           "  - line 16, column 3">>,
-        <<"Duplicate definitions of state at\n"
+        <<?Pos(17, 3)
+          "Duplicate definitions of state at\n"
           "  - (builtin location)\n"
-          "  - line 17, column 3">>]}
+          "  - line 17, column 3">>])
-    , {"type_errors",
+    , ?TYPE_ERROR(type_errors,
-       [<<"Unbound variable zz at line 17, column 23">>,
+       [<<?Pos(17, 23)
-        <<"Cannot unify int\n"
+          "Unbound variable zz at line 17, column 23">>,
+        <<?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">>,
-        <<"Cannot unify string\n"
+        <<?Pos(9, 48)
+          "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)">>,
-        <<"Cannot unify int\n"
+        <<?Pos(34, 47)
+          "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">>,
-        <<"Cannot unify string\n"
+        <<?Pos(34, 52)
+          "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">>,
-        <<"Cannot unify string\n"
+        <<?Pos(32, 18)
+          "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">>,
-        <<"Cannot unify string\n"
+        <<?Pos(11, 58)
+          "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">>,
-        <<"Cannot unify int\n"
+        <<?Pos(38, 13)
+          "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)">>,
-        <<"Not a record type: string\n"
+        <<?Pos(22, 40)
+          "Not a record type: string\n"
           "arising from the projection of the field y (at line 22, column 40)">>,
-        <<"Not a record type: string\n"
+        <<?Pos(21, 44)
+          "Not a record type: string\n"
           "arising from an assignment of the field y (at line 21, column 44)">>,
-        <<"Not a record type: string\n"
+        <<?Pos(20, 40)
+          "Not a record type: string\n"
           "arising from an assignment of the field y (at line 20, column 40)">>,
-        <<"Not a record type: string\n"
+        <<?Pos(19, 37)
+          "Not a record type: string\n"
           "arising from an assignment of the field y (at line 19, column 37)">>,
-        <<"Ambiguous record type with field y (at line 13, column 27) could be one of\n"
+        <<?Pos(13, 27)
+          "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)">>,
-        <<"Repeated name x in pattern\n"
+        <<?Pos(26, 7)
+          "Repeated name x in pattern\n"
           "  x :: x (at line 26, column 7)">>,
-        <<"Repeated argument x to function repeated_arg (at line 44, column 14).">>,
+        <<?Pos(44, 14)
-        <<"Repeated argument y to function repeated_arg (at line 44, column 14).">>,
+          "Repeated argument x to function repeated_arg (at line 44, column 14).">>,
-        <<"No record type with fields y, z (at line 14, column 24)">>,
+        <<?Pos(44, 14)
-        <<"The field z is missing when constructing an element of type r2 (at line 15, column 26)">>,
+          "Repeated argument y to function repeated_arg (at line 44, column 14).">>,
-        <<"Record type r2 does not have field y (at line 15, column 24)">>,
+        <<?Pos(14, 24)
-        <<"Let binding at line 47, column 5 must be followed by an expression">>,
+          "No record type with fields y, z (at line 14, column 24)">>,
-        <<"Let binding at line 50, column 5 must be followed by an expression">>,
+        <<?Pos(15, 26)
-        <<"Let binding at line 54, 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 58, column 5 must be followed by an expression">>]}
+        <<?Pos(15, 24)
-    , {"init_type_error",
+          "Record type r2 does not have field y (at line 15, column 24)">>,
-       [<<"Cannot unify string\n"
+        <<?Pos(47, 5)
+          "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">>])
-    , {"missing_state_type",
+    , ?TYPE_ERROR(missing_state_type,
-       [<<"Cannot unify string\n"
+       [<<?Pos(5, 3)
-          "         and ()\n"
+          "Cannot unify string\n"
-          "when checking that 'init' returns a value of type 'state' at line 5, column 3">>]}
+          "         and unit\n"
-    , {"missing_fields_in_record_expression",
+          "when checking that 'init' returns a value of type 'state' at line 5, column 3">>])
-       [<<"The field x is missing when constructing an element of type r('a) (at line 7, column 42)">>,
+    , ?TYPE_ERROR(missing_fields_in_record_expression,
-        <<"The field y is missing when constructing an element of type r(int) (at line 8, column 42)">>,
+       [<<?Pos(7, 42)
-        <<"The fields y, z are missing when constructing an element of type r('a) (at line 6, column 42)">>]}
+          "The field x is missing when constructing an element of type r('a) (at line 7, column 42)">>,
-    , {"namespace_clash",
+        <<?Pos(8, 42)
-       [<<"The contract Call (at line 4, column 10) has the same name as a namespace at (builtin location)">>]}
+          "The field y is missing when constructing an element of type r(int) (at line 8, column 42)">>,
-    , {"bad_events",
+        <<?Pos(6, 42)
-        [<<"The indexed type string (at line 9, column 25) is not a word type">>,
+          "The fields y, z are missing when constructing an element of type r('a) (at line 6, column 42)">>])
-         <<"The indexed type alias_string (at line 10, column 25) equals string which is not a word type">>]}
+    , ?TYPE_ERROR(namespace_clash,
-    , {"bad_events2",
+       [<<?Pos(4, 10)
-        [<<"The event constructor BadEvent1 (at line 9, column 7) has too many non-indexed values (max 1)">>,
+          "The contract Call (at line 4, column 10) has the same name as a namespace at (builtin location)">>])
-         <<"The event constructor BadEvent2 (at line 10, column 7) has too many indexed values (max 3)">>]}
+    , ?TYPE_ERROR(bad_events,
-    , {"type_clash",
+        [<<?Pos(9, 25)
-        [<<"Cannot unify int\n"
+           "The indexed type string (at line 9, column 25) is not a word type">>,
+         <<?Pos(10, 25)
+           "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)">>])
-    , {"bad_include_and_ns",
+    , ?TYPE_ERROR(bad_include_and_ns,
-        [<<"Include of 'included.aes' at line 2, column 11\nnot allowed, include only allowed at top level.">>,
+        [<<?Pos(2, 11)
-         <<"Nested namespace not allowed\nNamespace 'Foo' at line 3, column 13 not defined at top level.">>]}
+           "Include of 'included.aes' at line 2, column 11\nnot allowed, include only allowed at top level.">>,
-    , {"bad_address_literals",
+         <<?Pos(3, 13)
-        [<<"The type bytes(32) is not a contract type\n"
+           "Nested namespace not allowed\nNamespace 'Foo' at line 3, column 13 not defined at top level.">>])
+    , ?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)">>,
-         <<"The type oracle(int, bool) is not a contract type\n"
+         <<?Pos(30, 5)
+           "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)">>,
-         <<"The type address is not a contract type\n"
+         <<?Pos(28, 5)
+           "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">>,
-         <<"Cannot unify oracle_query('a, 'b)\n"
+         <<?Pos(25, 5)
+           "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">>,
-         <<"Cannot unify oracle_query('c, 'd)\n"
+         <<?Pos(23, 5)
+           "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)">>,
-         <<"Cannot unify oracle_query('e, 'f)\n"
+         <<?Pos(21, 5)
+           "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)">>,
-         <<"Cannot unify oracle('g, 'h)\n"
+         <<?Pos(18, 5)
+           "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">>,
-         <<"Cannot unify oracle('i, 'j)\n"
+         <<?Pos(16, 5)
+           "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)">>,
-         <<"Cannot unify oracle('k, 'l)\n"
+         <<?Pos(14, 5)
+           "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)">>,
-         <<"Cannot unify address\n"
+         <<?Pos(11, 5)
+           "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)">>,
-         <<"Cannot unify address\n"
+         <<?Pos(9, 5)
+           "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">>,
-         <<"Cannot unify address\n"
+         <<?Pos(7, 5)
+           "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)">>])
-    , {"stateful",
+    , ?TYPE_ERROR(stateful,
-       [<<"Cannot reference stateful function Chain.spend (at line 13, column 35)\nin the definition of non-stateful function fail1.">>,
+       [<<?Pos(13, 35)
-        <<"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 13, column 35)\nin the definition of non-stateful function fail1.">>,
-        <<"Cannot reference stateful function Chain.spend (at line 16, column 15)\nin the definition of non-stateful function fail3.">>,
+        <<?Pos(14, 35)
-        <<"Cannot reference stateful function Chain.spend (at line 20, column 31)\nin the definition of non-stateful function fail4.">>,
+          "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 35, column 45)\nin the definition of non-stateful function fail5.">>,
+        <<?Pos(16, 15)
-        <<"Cannot pass non-zero value argument 1000 (at line 48, column 57)\nin the definition of non-stateful function fail6.">>,
+          "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 49, column 56)\nin the definition of non-stateful function fail7.">>,
+        <<?Pos(20, 31)
-        <<"Cannot pass non-zero value argument 1000 (at line 52, column 17)\nin the definition of non-stateful function fail8.">>]}
+          "Cannot reference stateful function Chain.spend (at line 20, column 31)\nin the definition of non-stateful function fail4.">>,
-    , {"bad_init_state_access",
+        <<?Pos(35, 47)
-       [<<"The init function should return the initial state as its result and cannot write the state,\n"
+          "Cannot reference stateful function Chain.spend (at line 35, column 47)\nin the definition of non-stateful function fail5.">>,
+        <<?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)">>,
-        <<"The init function should return the initial state as its result and cannot read the state,\n"
+        <<?Pos(12, 5)
+          "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)">>,
-        <<"The init function should return the initial state as its result and cannot read the state,\n"
+        <<?Pos(13, 13)
+          "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)">>])
-    , {"field_parse_error",
+    , ?TYPE_ERROR(modifier_checks,
-       [<<"line 6, column 1: In field_parse_error at 5:26:\n"
+       [<<?Pos(11, 3)
-          "Cannot use nested fields or keys in record construction: p.x\n">>]}
+          "The function all_the_things (at line 11, column 3) cannot be both public and private.">>,
-    , {"modifier_checks",
+        <<?Pos(3, 3)
-       [<<"The function all_the_things (at line 11, column 3) cannot be both public and private.">>,
+          "Namespaces cannot contain entrypoints (at line 3, column 3). Use 'function' instead.">>,
-        <<"Namespaces cannot contain entrypoints (at line 3, column 3). Use 'function' instead.">>,
+        <<?Pos(5, 10)
-        <<"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'.">>,
-        <<"The entrypoint wha (at line 12, column 3) cannot be private. Use 'function' instead.">>,
+        <<?Pos(12, 3)
-        <<"Use 'entrypoint' for declaration of foo (at line 6, column 3):\n  entrypoint foo : () => ()">>,
+          "The entrypoint wha (at line 12, column 3) cannot be private. Use 'function' instead.">>,
-        <<"Use 'entrypoint' instead of 'function' for public function foo (at line 10, column 3):\n  entrypoint foo() = ()">>,
+        <<?Pos(6, 3)
-        <<"Use 'entrypoint' instead of 'function' for public function foo (at line 6, column 3):\n  entrypoint foo : () => ()">>]}
+          "Use 'entrypoint' for declaration of foo (at line 6, column 3):\n  entrypoint foo : () => unit">>,
+        <<?Pos(10, 3)
+          "Use 'entrypoint' instead of 'function' for public function foo (at line 10, column 3):\n  entrypoint foo() = ()">>,
+        <<?Pos(6, 3)
+          "Use 'entrypoint' instead of 'function' for public function foo (at line 6, column 3):\n  entrypoint foo : () => unit">>])
+    , ?TYPE_ERROR(list_comp_not_a_list,
+      [<<?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)">>
+      ])
+    , ?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),
-                            ?assertError({error, {_, parse_error, _}},
+                            ?assertThrow({error, [_]},
                                          parse_expr(NoPar({a, Op, {b, Op, c}}))) end,
             Stronger = fun(Op1, Op2) ->
                     CheckParens({{a, Op1, b}, Op2, c}),
@@ -71,11 +71,10 @@ parse_contract(Name) ->
 roundtrip_contract(Name) ->
     round_trip(aeso_test_utils:read_contract(Name)).
 
-parse_string(Text) ->
+parse_string(Text) -> parse_string(Text, []).
-    case aeso_parser:string(Text) of
+
-        {ok, Contract} -> Contract;
+parse_string(Text, Opts) ->
-        Err -> error(Err)
+    aeso_parser:string(Text, Opts).
-    end.
 
 parse_expr(Text) ->
     [{letval, _, _, _, Expr}] =
@@ -84,12 +83,16 @@ parse_expr(Text) ->
 
 round_trip(Text) ->
     Contract  = parse_string(Text),
-    Text1     = prettypr:format(aeso_pretty:decls(Contract)),
+    Text1     = prettypr:format(aeso_pretty:decls(strip_stdlib(Contract))),
     Contract1 = parse_string(Text1),
     NoSrcLoc  = remove_line_numbers(Contract),
     NoSrcLoc1 = remove_line_numbers(Contract1),
     ?assertMatch(NoSrcLoc, diff(NoSrcLoc, NoSrcLoc1)).
 
+strip_stdlib([{namespace, _, {con, _, "ListInternal"}, _} | Decls]) ->
+    strip_stdlib(Decls);
+strip_stdlib(Decls) -> Decls.
+
 remove_line_numbers({line, _L}) -> {line, 0};
 remove_line_numbers({col,  _C}) -> {col, 0};
 remove_line_numbers([H|T]) ->

test/contracts/abort_test.aes

@@ -8,7 +8,7 @@ contract AbortTest =
     { value = v }
 
   // Aborting
-  public function do_abort(v : int, s : string) : () =
+  public function do_abort(v : int, s : string) : unit =
     put_value(v)
     revert_abort(s)
 

test/contracts/abort_test_int.aes

@@ -1,9 +1,9 @@
 contract Interface =
-  function do_abort : (int, string) => ()
+  function do_abort : (int, string) => unit
   function get_value : () => int
-  function put_value : (int) => ()
+  function put_value : (int) => unit
   function get_values : () => list(int)
-  function put_values : (int) => ()
+  function put_values : (int) => unit
 
 contract AbortTestInt =
 

test/contracts/address_chain.aes

@@ -1,5 +1,5 @@
 contract Remote =
-  entrypoint main : (int) => ()
+  entrypoint main : (int) => unit
 
 contract AddrChain =
   type o_type = oracle(string, map(string, int))
@@ -31,3 +31,6 @@ contract AddrChain =
 
   entrypoint c_creator() : address =
     Contract.creator
+
+  entrypoint is_payable(a : address) : bool =
+    Address.is_payable(a)

test/contracts/address_literals.aes

@@ -1,6 +1,6 @@
 
 contract Remote =
-  entrypoint foo : () => ()
+  entrypoint foo : () => unit
 
 contract AddressLiterals =
   entrypoint addr() : address =

test/contracts/aens.aes

@@ -12,44 +12,45 @@ contract AENSTest =
   // Transactions
 
   stateful entrypoint preclaim(addr  : address,     // Claim on behalf of this account (can be Contract.address)
-                             chash : hash) : () = // Commitment hash
+                             chash : hash) : unit = // Commitment hash
     AENS.preclaim(addr, chash)
 
   stateful entrypoint signedPreclaim(addr  : address, // Claim on behalf of this account (can be Contract.address)
                                    chash : hash,             // Commitment hash
-                                   sign  : signature) : () = // Signed by addr (if not Contract.address)
+                                   sign  : signature) : unit = // Signed by addr (if not Contract.address)
     AENS.preclaim(addr, chash, signature = sign)
 
   stateful entrypoint claim(addr : address,
                           name : string,
-                          salt : int) : () =
+                          salt : int,
-    AENS.claim(addr, name, salt)
+                          name_fee : int) : unit =
+    AENS.claim(addr, name, salt, name_fee)
 
   stateful entrypoint signedClaim(addr : address,
                                 name : string,
                                 salt : int,
-                                sign : signature) : () =
+                                name_fee : int,
-    AENS.claim(addr, name, salt, signature = sign)
+                                sign : signature) : unit =
+    AENS.claim(addr, name, salt, name_fee, signature = sign)
 
   // TODO: update() -- how to handle pointers?
 
   stateful entrypoint transfer(owner     : address,
                              new_owner : address,
-                             name_hash : hash) : () =
+                             name      : string) : unit =
-    AENS.transfer(owner, new_owner, name_hash)
+    AENS.transfer(owner, new_owner, name)
 
   stateful entrypoint signedTransfer(owner     : address,
                                      new_owner : address,
-                                   name_hash : hash,
+                                     name      : string,
-                                   sign      : signature) : () =
+                                     sign      : signature) : unit =
-    AENS.transfer(owner, new_owner, name_hash, signature = sign)
+    AENS.transfer(owner, new_owner, name, signature = sign)
 
   stateful entrypoint revoke(owner     : address,
-                           name_hash : hash) : () =
+                           name      : string) : unit =
-    AENS.revoke(owner, name_hash)
+    AENS.revoke(owner, name)
 
   stateful entrypoint signedRevoke(owner     : address,
-                                 name_hash : hash,
+                                   name      : string,
-                                 sign      : signature) : () =
+                                   sign      : signature) : unit =
-    AENS.revoke(owner, name_hash, signature = sign)
+    AENS.revoke(owner, name, signature = sign)
-

test/contracts/all_syntax.aes

@@ -24,7 +24,7 @@ contract AllSyntax =
         if(valWithType(Map.empty) == None)
           print(42 mod 10 * 5 / 3)
 
-  function funWithType(x : int, y) : (int, list(int)) = (x, 0 :: [y] ++ [])
+  function funWithType(x : int, y) : int * list(int) = (x, 0 :: [y] ++ [])
   function funNoType() =
     let foo = (x, y : bool) =>
                 if (! (y && x =< 0x0b || true)) [x]

test/contracts/bad_address_literals.aes

@@ -1,6 +1,6 @@
 
 contract Remote =
-  entrypoint foo : () => ()
+  entrypoint foo : () => unit
 
 contract AddressLiterals =
   entrypoint addr1() : bytes(32) =

test/contracts/bad_bytes_concat.aes

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,20 @@
+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

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

test/contracts/basic_auth.aes

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

test/contracts/bitcoin_auth.aes

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

test/contracts/bytes_concat.aes

@@ -0,0 +1,4 @@
+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

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

test/contracts/code_errors/bad_aens_resolve.aes

@@ -0,0 +1,9 @@
+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

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

test/contracts/code_errors/complex_compare_leq.aes

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

test/contracts/code_errors/higher_order_compare.aes

@@ -0,0 +1,8 @@
+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

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

test/contracts/code_errors/higher_order_entrypoint_return.aes

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

test/contracts/code_errors/higher_order_map_keys.aes

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,7 @@
+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

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

test/contracts/code_errors/missing_definition.aes

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

test/contracts/code_errors/missing_init_function.aes

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

test/contracts/code_errors/parameterised_event.aes

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

test/contracts/code_errors/parameterised_state.aes

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

test/contracts/code_errors/polymorphic_aens_resolve.aes

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

test/contracts/code_errors/polymorphic_compare.aes

@@ -0,0 +1,7 @@
+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

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

test/contracts/code_errors/polymorphic_entrypoint_return.aes

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

test/contracts/code_errors/polymorphic_map_keys.aes

@@ -0,0 +1,6 @@
+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

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

test/contracts/code_errors/polymorphic_response_type.aes

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -3,8 +3,8 @@ contract Remote =
   entrypoint up_to       : (int)               => list(int)
   entrypoint sum         : (list(int))         => int
   entrypoint some_string : ()                  => string
-  entrypoint pair        : (int, string)       => (int, string)
+  entrypoint pair        : (int, string)       => int * string
-  entrypoint squares     : (int)               => list((int, int))
+  entrypoint squares     : (int)               => list(int * int)
   entrypoint filter_some : (list(option(int))) => list(int)
   entrypoint all_some    : (list(option(int))) => option(list(int))
 
@@ -47,10 +47,10 @@ contract ComplexTypes =
 
   entrypoint pair(x : int, y : string) = (x, y)
 
-  entrypoint remote_pair(n : int, s : string) : (int, string) =
+  entrypoint remote_pair(n : int, s : string) : int * string =
     state.worker.pair(gas = 10000, n, s)
 
-  entrypoint map(f, xs) =
+  function map(f, xs) =
     switch(xs)
       []      => []
       x :: xs => f(x) :: map(f, xs)
@@ -58,7 +58,7 @@ contract ComplexTypes =
   entrypoint squares(n) =
     map((i) => (i, i * i), up_to(n))
 
-  entrypoint remote_squares(n) : list((int, int)) =
+  entrypoint remote_squares(n) : list(int * int) =
     state.worker.squares(n)
 
   // option types

test/contracts/cyclic_include.aes

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

test/contracts/cyclic_include_back.aes

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

test/contracts/cyclic_include_forth.aes

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

test/contracts/deadcode.aes

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

test/contracts/double_include.aes

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

test/contracts/events.aes

@@ -1,5 +1,5 @@
 contract Remote =
-  entrypoint dummy : () => ()
+  entrypoint dummy : () => unit
 
 contract Events =
 

test/contracts/funargs.aes

@@ -40,7 +40,7 @@ contract FunctionArguments =
   entrypoint traffic_light(c : colour) =
      Red
 
-  entrypoint tuples(t : ()) =
+  entrypoint tuples(t : unit) =
      t
 
   entrypoint due(t : Chain.ttl) =

test/contracts/indent_fail.aes

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

test/contracts/list_comp.aes

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

test/contracts/list_comp_bad_shadow.aes

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

test/contracts/list_comp_if_not_bool.aes

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

test/contracts/list_comp_not_a_list.aes

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

test/contracts/local_poly_fail.aes

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

test/contracts/manual_stdlib_include.aes

@@ -0,0 +1,6 @@
+// This should include Lists.aes implicitly, since Option.aes does.
+include "Option.aes"
+
+contract Test =
+  entrypoint i_should_build() =
+    List.is_empty(Option.to_list(None))

test/contracts/map_as_map_key.aes

@@ -0,0 +1,6 @@
+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/maps.aes

@@ -93,8 +93,8 @@ contract Maps =
   entrypoint tolist_state_s() = tolist_s(state.map_s)
 
   // Map.from_list
-  entrypoint fromlist_i(xs : list((int,    pt))) = Map.from_list(xs)
+  entrypoint fromlist_i(xs : list(int    * pt)) = Map.from_list(xs)
-  entrypoint fromlist_s(xs : list((string, pt))) = Map.from_list(xs)
+  entrypoint fromlist_s(xs : list(string * pt)) = Map.from_list(xs)
   stateful entrypoint fromlist_state_i(xs) = put(state{ map_i = fromlist_i(xs) })
   stateful entrypoint fromlist_state_s(xs) = put(state{ map_s = fromlist_s(xs) })
 

test/contracts/missing_event_type.aes

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

test/contracts/modifier_checks.aes

@@ -3,7 +3,7 @@ namespace Lib =
   entrypoint foo() = ()
 
 contract Remote =
-  public function foo : () => ()
+  public function foo : () => unit
   function bla() = ()
 
 contract Contract =

test/contracts/multi_sig.aes

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

test/contracts/nodeadcode.aes

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

test/contracts/oracles.aes

@@ -60,23 +60,23 @@ contract Oracles =
     res
 
   stateful entrypoint extendOracle(o    : oracle_id,
-                        ttl  : ttl) : () =
+                        ttl  : ttl) : unit =
     Oracle.extend(o, ttl)
 
   stateful entrypoint signedExtendOracle(o    : oracle_id,
                               sign : signature,   // Signed oracle address
-                              ttl  : ttl) : () =
+                              ttl  : ttl) : unit =
     Oracle.extend(o, signature = sign, ttl)
 
   stateful entrypoint respond(o    : oracle_id,
                    q    : query_id,
-                   r    : answer_t) : () =
+                   r    : answer_t) : unit =
     Oracle.respond(o, q, r)
 
   stateful entrypoint signedRespond(o    : oracle_id,
                          q    : query_id,
                          sign : signature,
-                         r    : answer_t) : () =
+                         r    : answer_t) : unit =
     Oracle.respond(o, q, signature = sign, r)
 
   entrypoint getQuestion(o : oracle_id,

test/contracts/oracles_no_vm.aes

@@ -21,7 +21,7 @@ contract Oracles =
   function respond(o    : oracle_id,
                    q    : query_id,
                    sign : signature,
-                   r    : answer_t) : () =
+                   r    : answer_t) : unit =
     Oracle.respond(o, q, signature = sign, r)
 
 

test/contracts/payable.aes

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

test/contracts/reason/voting.re

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

test/contracts/reason/voting_test.re

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