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

CHANGELOG.md

@@ -9,95 +9,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 ### Removed
 
-## [4.2.0] - 2020-01-15
-### Added
-- Allow separate entrypoint/function type signature and definition, and pattern
-  matching in left-hand sides:
-  ```
-    function
-      length : list('a) => int
-      length([])      = 0
-      length(x :: xs) = 1 + length(xs)
-  ```
-- Allow pattern matching in list comprehension generators (filtering out match
-  failures):
-  ```
-    function somes(xs : list(option('a))) : list('a) =
-      [ x | Some(x) <- xs ]
-  ```
-- Allow pattern matching in let-bindings (aborting on match failures):
-  ```
-    function test(m : map(int, int)) =
-        let Some(x) = Map.lookup(m, 0)
-        x
-  ```
-### Changed
-- FATE code generator improvements.
-- Bug fix: Handle qualified constructors in patterns.
-- Bug fix: Allow switching also on negative numbers.
-### Removed
-
-## [4.1.0] - 2019-11-26
-### Added
-- Support encoding and decoding bit fields in call arguments and results.
-### Changed
-- Various improvements to FATE code generator.
-### Removed
-
-## [4.0.0] - 2019-10-11
-### Added
-- `Address.to_contract` - casts an address to a (any) contract type.
-- Pragma to check compiler version, e.g. `@compiler >= 4.0`.
-- Handle numeric escapes, i.e. `"\x19Ethereum Signed Message:\n"`, and similar strings.
-- `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.
-- 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
-- Nice type error if contract function is called as from a namespace.
-- Fail on function definitions in contracts other than the main contract.
-- Bug fix in variable optimization - don't discard writes to the store/state.
-- Bug fixes in error reporting.
-- Bug fix in variable liveness analysis for FATE.
-- 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.
-- 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
@@ -192,10 +103,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Simplify calldata creation - instead of passing a compiled contract, simply
   pass a (stubbed) contract string.
 
-[Unreleased]: https://github.com/aeternity/aesophia/compare/v4.2.0...HEAD
-[4.2.0]: https://github.com/aeternity/aesophia/compare/v4.2.0...v4.1.0
-[4.1.0]: https://github.com/aeternity/aesophia/compare/v4.1.0...v4.0.0
-[4.0.0]: https://github.com/aeternity/aesophia/compare/v4.0.0...v3.2.0
+[Unreleased]: https://github.com/aeternity/aesophia/compare/v3.2.0...HEAD
 [3.2.0]: https://github.com/aeternity/aesophia/compare/v3.1.0...v3.2.0
 [3.1.0]: https://github.com/aeternity/aesophia/compare/v3.0.0...v3.1.0
 [3.0.0]: https://github.com/aeternity/aesophia/compare/v2.1.0...v3.0.0

priv/stdlib/Func.aes

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

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

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

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

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

@@ -1,37 +0,0 @@
-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,"4f4d6d3"}}}
+{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git", {ref,"adf3664"}}}
        , {getopt, "1.0.1"}
        , {eblake2, "1.0.0"}
        , {jsx, {git, "https://github.com/talentdeficit/jsx.git",
@@ -15,7 +15,7 @@
             {base_plt_apps, [erts, kernel, stdlib, crypto, mnesia]}
            ]}.
 
-{relx, [{release, {aesophia, "4.2.0"},
+{relx, [{release, {aesophia, "3.2.0"},
          [aesophia, aebytecode, getopt]},
 
         {dev_mode, true},

rebar.lock

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

src/aeso_aci.erl

@@ -74,9 +74,21 @@ do_contract_interface(Type, ContractString, Options) ->
             string -> do_render_aci_json(JArray)
         end
     catch
-        throw:{error, Errors} -> {error, Errors}
+        %% The compiler errors.
+        error:{parse_errors, Errors} ->
+            {error, join_errors("Parse errors", Errors, fun(E) -> E end)};
+        error:{type_errors, Errors} ->
+            {error, join_errors("Type errors", Errors, fun(E) -> E end)};
+        error:{code_errors, Errors} ->
+            {error, join_errors("Code errors", Errors,
+                                fun (E) -> io_lib:format("~p", [E]) end)}
+        %% General programming errors in the compiler just signal error.
     end.
 
+join_errors(Prefix, Errors, Pfun) ->
+    Ess = [ Pfun(E) || E <- Errors ],
+    list_to_binary(string:join([Prefix|Ess], "\n")).
+
 encode_contract(Contract = {contract, _, {con, _, Name}, _}) ->
     C0 = #{name => encode_name(Name)},
 
@@ -101,7 +113,7 @@ encode_contract(Contract = {contract, _, {con, _, Name}, _}) ->
                || F <- sort_decls(contract_funcs(Contract)),
                   is_entrypoint(F) ],
 
-    #{contract => C3#{functions => Fdefs, payable => is_payable(Contract)}};
+    #{contract => C3#{functions => Fdefs}};
 encode_contract(Namespace = {namespace, _, {con, _, Name}, _}) ->
     Tdefs = [ encode_typedef(T) || T <- sort_decls(contract_types(Namespace)) ],
     #{namespace => #{name => encode_name(Name),
@@ -113,14 +125,12 @@ encode_function(FDef = {letfun, _, {id, _, Name}, Args, Type, _}) ->
     #{name      => encode_name(Name),
       arguments => encode_args(Args),
       returns   => encode_type(Type),
-      stateful  => is_stateful(FDef),
-      payable   => is_payable(FDef)};
+      stateful  => is_stateful(FDef)};
 encode_function(FDecl = {fun_decl, _, {id, _, Name}, {fun_t, _, _, Args, Type}}) ->
     #{name      => encode_name(Name),
       arguments => encode_anon_args(Args),
       returns   => encode_type(Type),
-      stateful  => is_stateful(FDecl),
-      payable   => is_payable(FDecl)}.
+      stateful  => is_stateful(FDecl)}.
 
 encode_anon_args(Types) ->
     Anons = [ list_to_binary("_" ++ integer_to_list(X)) || X <- lists:seq(1, length(Types))],
@@ -129,7 +139,7 @@ encode_anon_args(Types) ->
 
 encode_args(Args) -> [ encode_arg(A) || A <- Args ].
 
-encode_arg({typed, _, Id, T}) ->
+encode_arg({arg, _, Id, T}) ->
     #{name => encode_type(Id),
       type => encode_type(T)}.
 
@@ -224,13 +234,12 @@ do_render_aci_json(Json) ->
     {ok, list_to_binary(string:join(DecodedContracts, "\n"))}.
 
 decode_contract(#{contract := #{name := Name,
-                                payable := Payable,
                                 type_defs := Ts0,
                                 functions := Fs} = C}) ->
     MkTDef = fun(N, T) -> #{name => N, vars => [], typedef => T} end,
     Ts = [ MkTDef(<<"state">>, maps:get(state, C)) || maps:is_key(state, C) ] ++
          [ MkTDef(<<"event">>, maps:get(event, C)) || maps:is_key(event, C) ] ++ Ts0,
-    [payable(Payable), "contract ", io_lib:format("~s", [Name])," =\n",
+    ["contract ", io_lib:format("~s", [Name])," =\n",
      decode_tdefs(Ts), decode_funcs(Fs)];
 decode_contract(#{namespace := #{name := Name, type_defs := Ts}}) when Ts /= [] ->
     ["namespace ", io_lib:format("~s", [Name])," =\n",
@@ -240,8 +249,8 @@ decode_contract(_) -> [].
 decode_funcs(Fs) -> [ decode_func(F) || F <- Fs ].
 
 %% decode_func(#{name := init}) -> [];
-decode_func(#{name := Name, payable := Payable, arguments := As, returns := T}) ->
-    ["  ", payable(Payable), "entrypoint ", io_lib:format("~s", [Name]), " : ",
+decode_func(#{name := Name, arguments := As, returns := T}) ->
+    ["  entrypoint", " ", io_lib:format("~s", [Name]), " : ",
      decode_args(As), " => ", decode_type(T), $\n].
 
 decode_args(As) ->
@@ -319,9 +328,6 @@ 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 ->
@@ -346,7 +352,6 @@ sort_decls(Ds) ->
 
 is_entrypoint(Node) -> aeso_syntax:get_ann(entrypoint, Node, false).
 is_stateful(Node) -> aeso_syntax:get_ann(stateful, Node, false).
-is_payable(Node) -> aeso_syntax:get_ann(payable, Node, false).
 
 typedef_name({type_def, _, {id, _, Name}, _, _}) -> Name.
 

src/aeso_builtins.erl

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

src/aeso_code_errors.erl

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

src/aeso_compiler.erl

@@ -15,7 +15,6 @@
         , create_calldata/3  %% deprecated
         , create_calldata/4
         , version/0
-        , numeric_version/0
         , sophia_type_to_typerep/1
         , to_sophia_value/4  %% deprecated, need a backend
         , to_sophia_value/5
@@ -23,7 +22,6 @@
         , decode_calldata/4
         , parse/2
         , add_include_path/2
-        , validate_byte_code/3
         ]).
 
 -include_lib("aebytecode/include/aeb_opcodes.hrl").
@@ -67,29 +65,18 @@ version() ->
             {ok, list_to_binary(VsnString)}
     end.
 
--spec numeric_version() -> {ok, [non_neg_integer()]} | {error, term()}.
-numeric_version() ->
-    case version() of
-        {ok, Bin} ->
-            [NoSuf | _] = binary:split(Bin, <<"-">>),
-            Numbers     = binary:split(NoSuf, <<".">>, [global]),
-            {ok, [binary_to_integer(Num) || Num <- Numbers]};
-        {error, _} = Err ->
-            Err
-    end.
-
--spec file(string()) -> {ok, map()} | {error, [aeso_errors:error()]}.
+-spec file(string()) -> {ok, map()} | {error, binary()}.
 file(Filename) ->
     file(Filename, []).
 
--spec file(string(), options()) -> {ok, map()} | {error, [aeso_errors:error()]}.
+-spec file(string(), options()) -> {ok, map()} | {error, binary()}.
 file(File, Options0) ->
     Options = add_include_path(File, Options0),
     case read_contract(File) of
         {ok, Bin} -> from_string(Bin, [{src_file, File} | Options]);
         {error, Error} ->
-            Msg = lists:flatten([File,": ",file:format_error(Error)]),
-            {error, [aeso_errors:new(file_error, Msg)]}
+	    ErrorString = [File,": ",file:format_error(Error)],
+	    {error, join_errors("File errors", [ErrorString], fun(E) -> E end)}
     end.
 
 add_include_path(File, Options) ->
@@ -101,7 +88,7 @@ add_include_path(File, Options) ->
             [{include, {file_system, [Cwd, Dir]}} | Options]
     end.
 
--spec from_string(binary() | string(), options()) -> {ok, map()} | {error, [aeso_errors:error()]}.
+-spec from_string(binary() | string(), options()) -> {ok, map()} | {error, binary()}.
 from_string(Contract, Options) ->
     from_string(proplists:get_value(backend, Options, aevm), Contract, Options).
 
@@ -111,14 +98,22 @@ from_string(Backend, ContractString, Options) ->
     try
         from_string1(Backend, ContractString, Options)
     catch
-        throw:{error, Errors} -> {error, Errors}
+        %% The compiler errors.
+        error:{parse_errors, Errors} ->
+            {error, join_errors("Parse errors", Errors, fun(E) -> E end)};
+        error:{type_errors, Errors} ->
+            {error, join_errors("Type errors", Errors, fun(E) -> E end)};
+        error:{code_errors, Errors} ->
+            {error, join_errors("Code errors", Errors,
+                                fun (E) -> io_lib:format("~p", [E]) end)}
+        %% General programming errors in the compiler just signal error.
     end.
 
 from_string1(aevm, ContractString, Options) ->
     #{icode := Icode} = string_to_code(ContractString, Options),
     TypeInfo  = extract_type_info(Icode),
     Assembler = assemble(Icode, Options),
-    pp_assembler(aevm, Assembler, Options),
+    pp_assembler(Assembler, Options),
     ByteCodeList = to_bytecode(Assembler, Options),
     ByteCode = << << B:8 >> || B <- ByteCodeList >>,
     pp_bytecode(ByteCode, Options),
@@ -127,13 +122,11 @@ from_string1(aevm, ContractString, Options) ->
            compiler_version => Version,
            contract_source => ContractString,
            type_info => TypeInfo,
-           abi_version => aeb_aevm_abi:abi_version(),
-           payable => maps:get(payable, Icode)
+           abi_version => aeb_aevm_abi:abi_version()
           }};
 from_string1(fate, ContractString, Options) ->
     #{fcode := FCode} = string_to_code(ContractString, Options),
     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,
@@ -141,8 +134,7 @@ from_string1(fate, ContractString, Options) ->
            contract_source => ContractString,
            type_info => [],
            fate_code => FateCode,
-           abi_version => aeb_fate_abi:abi_version(),
-           payable => maps:get(payable, FCode)
+           abi_version => aeb_fate_abi:abi_version()
           }}.
 
 -spec string_to_code(string(), options()) -> map().
@@ -150,7 +142,7 @@ string_to_code(ContractString, Options) ->
     Ast = parse(ContractString, Options),
     pp_sophia_code(Ast, Options),
     pp_ast(Ast, Options),
-    {TypeEnv, TypedAst} = aeso_ast_infer_types:infer(Ast, [return_env | Options]),
+    {TypeEnv, TypedAst} = aeso_ast_infer_types:infer(Ast, [return_env]),
     pp_typed_ast(TypedAst, Options),
     case proplists:get_value(backend, Options, aevm) of
         aevm ->
@@ -166,6 +158,10 @@ string_to_code(ContractString, Options) ->
                type_env  => TypeEnv}
     end.
 
+join_errors(Prefix, Errors, Pfun) ->
+    Ess = [ Pfun(E) || E <- Errors ],
+    list_to_binary(string:join([Prefix|Ess], "\n")).
+
 -define(CALL_NAME,   "__call").
 -define(DECODE_NAME, "__decode").
 
@@ -177,7 +173,7 @@ string_to_code(ContractString, Options) ->
 %%       a special return type (typerep, T)
 -spec check_call(string(), string(), [string()], options()) -> {ok, string(), {[Type], Type}, [term()]}
                                                                    | {ok, string(), [term()]}
-                                                                   | {error, [aeso_errors:error()]}
+                                                                   | {error, term()}
     when Type :: term().
 check_call(Source, "init" = FunName, Args, Options) ->
     case check_call1(Source, FunName, Args, Options) of
@@ -232,7 +228,16 @@ check_call1(ContractString0, FunName, Args, Options) ->
                 {ok, FunName, CallArgs}
         end
     catch
-        throw:{error, Errors} -> {error, Errors}
+        error:{parse_errors, Errors} ->
+            {error, join_errors("Parse errors", Errors, fun (E) -> E end)};
+        error:{type_errors, Errors} ->
+            {error, join_errors("Type errors", Errors, fun (E) -> E end)};
+        error:{badmatch, {error, missing_call_function}} ->
+            {error, join_errors("Type errors", ["missing __call function"],
+                                fun (E) -> E end)};
+        throw:Error ->                          %Don't ask
+            {error, join_errors("Code errors", [Error],
+                                fun (E) -> io_lib:format("~p", [E]) end)}
     end.
 
 arguments_of_body(CallName, _FunName, Fcode) ->
@@ -280,31 +285,24 @@ last_contract_indent(Decls) ->
     end.
 
 -spec to_sophia_value(string(), string(), ok | error | revert, aeb_aevm_data:data()) ->
-        {ok, aeso_syntax:expr()} | {error, [aeso_errors:error()]}.
+        {ok, aeso_syntax:expr()} | {error, term()}.
 to_sophia_value(ContractString, Fun, ResType, Data) ->
     to_sophia_value(ContractString, Fun, ResType, Data, [{backend, aevm}]).
 
 -spec to_sophia_value(string(), string(), ok | error | revert, binary(), options()) ->
-        {ok, aeso_syntax:expr()} | {error, [aeso_errors:error()]}.
+        {ok, aeso_syntax:expr()} | {error, term()}.
 to_sophia_value(_, _, error, Err, _Options) ->
     {ok, {app, [], {id, [], "error"}, [{string, [], Err}]}};
 to_sophia_value(_, _, revert, Data, Options) ->
     case proplists:get_value(backend, Options, aevm) of
         aevm ->
             case aeb_heap:from_binary(string, Data) of
-                {ok, Err} ->
-                    {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}};
-                {error, _} ->
-                    Msg = "Could not interpret the revert message\n",
-                    {error, [aeso_errors:new(data_error, Msg)]}
+                {ok, Err} -> {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}};
+                {error, _} = Err -> Err
             end;
         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
+            Err = aeb_fate_encoding:deserialize(Data),
+            {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}}
     end;
 to_sophia_value(ContractString, FunName, ok, Data, Options0) ->
     Options = [no_code | Options0],
@@ -324,41 +322,49 @@ to_sophia_value(ContractString, FunName, ok, Data, Options0) ->
                             {ok, aeso_vm_decode:from_aevm(VmType, Type, VmValue)}
                         catch throw:cannot_translate_to_sophia ->
                             Type0Str = prettypr:format(aeso_pretty:type(Type0)),
-                            Msg = io_lib:format("Cannot translate VM value ~p\n  of type ~p\n  to Sophia type ~s\n",
-                                                [Data, VmType, Type0Str]),
-                            {error, [aeso_errors:new(data_error, Msg)]}
+                            {error, join_errors("Translation error", [lists:flatten(io_lib:format("Cannot translate VM value ~p\n  of type ~p\n  to Sophia type ~s\n",
+                                                                                    [Data, VmType, Type0Str]))],
+                                                fun (E) -> E end)}
                         end;
                     {error, _Err} ->
-                        Msg = io_lib:format("Failed to decode binary as type ~p\n", [VmType]),
-                        {error, [aeso_errors:new(data_error, Msg)]}
+                        {error, join_errors("Decode errors", [lists:flatten(io_lib:format("Failed to decode binary at type ~p", [VmType]))],
+                                            fun(E) -> E end)}
                 end;
             fate ->
                try
                    {ok, aeso_vm_decode:from_fate(Type, aeb_fate_encoding:deserialize(Data))}
                catch throw:cannot_translate_to_sophia ->
-                        Type1 = prettypr:format(aeso_pretty:type(Type)),
-                        Msg = io_lib:format("Cannot translate FATE value ~p\n  of Sophia type ~s\n",
-                                            [aeb_fate_encoding:deserialize(Data), Type1]),
-                        {error, [aeso_errors:new(data_error, Msg)]};
-                      _:_ ->
-                        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)]}
+                   {error, join_errors("Translation error",
+                                       [lists:flatten(io_lib:format("Cannot translate fate value ~p\n of Sophia type ~s\n",
+                                                                    [aeb_fate_encoding:deserialize(Data), Type]))],
+                                       fun (E) -> E end)};
+                     _:R ->
+                   {error, iolist_to_binary(io_lib:format("Decode error ~p: ~p\n", [R, erlang:get_stacktrace()]))}
                end
         end
     catch
-        throw:{error, Errors} -> {error, Errors}
+        error:{parse_errors, Errors} ->
+            {error, join_errors("Parse errors", Errors, fun (E) -> E end)};
+        error:{type_errors, Errors} ->
+            {error, join_errors("Type errors", Errors, fun (E) -> E end)};
+        error:{badmatch, {error, missing_function}} ->
+            {error, join_errors("Type errors", ["no function: '" ++ FunName ++ "'"],
+                                fun (E) -> E end)};
+        throw:Error ->                          %Don't ask
+            {error, join_errors("Code errors", [Error],
+                                fun (E) -> io_lib:format("~p", [E]) end)}
     end.
 
 
 -spec create_calldata(string(), string(), [string()]) ->
                              {ok, binary(), aeb_aevm_data:type(), aeb_aevm_data:type()}
-                             | {error, [aeso_errors:error()]}.
+                             | {error, term()}.
 create_calldata(Code, Fun, Args) ->
     create_calldata(Code, Fun, Args, [{backend, aevm}]).
 
 -spec create_calldata(string(), string(), [string()], [{atom(), any()}]) ->
-                             {ok, binary()} | {error, [aeso_errors:error()]}.
+                             {ok, binary()}
+                             | {error, term()}.
 create_calldata(Code, Fun, Args, Options0) ->
     Options = [no_code | Options0],
     case proplists:get_value(backend, Options, aevm) of
@@ -378,7 +384,7 @@ create_calldata(Code, Fun, Args, Options0) ->
 
 -spec decode_calldata(string(), string(), binary()) ->
                              {ok, [aeso_syntax:type()], [aeso_syntax:expr()]}
-                             | {error, [aeso_errors:error()]}.
+                             | {error, term()}.
 decode_calldata(ContractString, FunName, Calldata) ->
     decode_calldata(ContractString, FunName, Calldata, [{backend, aevm}]).
 
@@ -389,8 +395,8 @@ decode_calldata(ContractString, FunName, Calldata, Options0) ->
         #{ typed_ast := TypedAst, type_env  := TypeEnv} = Code,
 
         {ok, Args, _} = get_decode_type(FunName, TypedAst),
-        GetType       = fun({typed, _, _, T}) -> T; (T) -> T end,
-        ArgTypes      = lists:map(GetType, Args),
+        DropArg       = fun({arg, _, _, T}) -> T; (T) -> T end,
+        ArgTypes      = lists:map(DropArg, Args),
         Type0         = {tuple_t, [], ArgTypes},
         %% user defined data types such as variants needed to match against
         Type          = aeso_ast_infer_types:unfold_types_in_type(TypeEnv, Type0, [unfold_record_types, unfold_variant_types]),
@@ -406,13 +412,14 @@ decode_calldata(ContractString, FunName, Calldata, Options0) ->
                             {ok, ArgTypes, Values}
                         catch throw:cannot_translate_to_sophia ->
                                 Type0Str = prettypr:format(aeso_pretty:type(Type0)),
-                            Msg = io_lib:format("Cannot translate VM value ~p\n  of type ~p\n  to Sophia type ~s\n",
-                                                [VmValue, VmType, Type0Str]),
-                            {error, [aeso_errors:new(data_error, Msg)]}
+                                {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",
+                                                                                 [VmValue, VmType, Type0Str]))],
+                                                    fun (E) -> E end)}
                         end;
                     {error, _Err} ->
-                        Msg = io_lib:format("Failed to decode calldata as type ~p\n", [VmType]),
-                        {error, [aeso_errors:new(data_error, Msg)]}
+                        {error, join_errors("Decode errors", [lists:flatten(io_lib:format("Failed to decode binary at type ~p", [VmType]))],
+                                            fun(E) -> E end)}
                 end;
             fate ->
                 case aeb_fate_abi:decode_calldata(FunName, Calldata) of
@@ -424,30 +431,35 @@ decode_calldata(ContractString, FunName, Calldata, Options0) ->
                             {ok, ArgTypes, AstArgs}
                         catch throw:cannot_translate_to_sophia ->
                                 Type0Str = prettypr:format(aeso_pretty:type(Type0)),
-                                Msg = io_lib:format("Cannot translate FATE value ~p\n  to Sophia type ~s\n",
-                                                    [FateArgs, Type0Str]),
-                                {error, [aeso_errors:new(data_error, Msg)]}
+                                {error, join_errors("Translation error",
+                                                    [lists:flatten(io_lib:format("Cannot translate fate value ~p\n of Sophia type ~s\n",
+                                                                                 [FateArgs, Type0Str]))],
+                                                    fun (E) -> E end)}
                         end;
                     {error, _} ->
-                        Msg = io_lib:format("Failed to decode calldata binary\n", []),
-                        {error, [aeso_errors:new(data_error, Msg)]}
+                        {error, join_errors("Decode errors", ["Failed to decode binary"],
+                                            fun(E) -> E end)}
                 end
         end
     catch
-        throw:{error, Errors} -> {error, Errors}
+        error:{parse_errors, Errors} ->
+            {error, join_errors("Parse errors", Errors, fun (E) -> E end)};
+        error:{type_errors, Errors} ->
+            {error, join_errors("Type errors", Errors, fun (E) -> E end)};
+        error:{badmatch, {error, missing_function}} ->
+            {error, join_errors("Type errors", ["no function: '" ++ FunName ++ "'"],
+                                fun (E) -> E end)};
+        throw:Error ->                          %Don't ask
+            {error, join_errors("Code errors", [Error],
+                                fun (E) -> io_lib:format("~p", [E]) end)}
     end.
 
 get_arg_icode(Funs) ->
     case [ Args || {[_, ?CALL_NAME], _, _, {funcall, _, Args}, _} <- Funs ] of
         [Args] -> Args;
-        []     -> error_missing_call_function()
+        []     -> error({missing_call_function, Funs})
     end.
 
--dialyzer({nowarn_function, error_missing_call_function/0}).
-error_missing_call_function() ->
-    Msg = "Internal error: missing '__call'-function",
-    aeso_errors:throw(aeso_errors:new(internal_error, Msg)).
-
 get_call_type([{contract, _, _, Defs}]) ->
     case [ {lists:last(QFunName), FunType}
           || {letfun, _, {id, _, ?CALL_NAME}, [], _Ret,
@@ -455,14 +467,13 @@ get_call_type([{contract, _, _, Defs}]) ->
                     {app, _,
                         {typed, _, {qid, _, QFunName}, FunType}, _}, _}} <- Defs ] of
         [Call] -> {ok, Call};
-        []     -> error_missing_call_function()
+        []     -> {error, missing_call_function}
     end;
 get_call_type([_ | Contracts]) ->
     %% The __call should be in the final contract
     get_call_type(Contracts).
 
--dialyzer({nowarn_function, get_decode_type/2}).
-get_decode_type(FunName, [{contract, Ann, _, Defs}]) ->
+get_decode_type(FunName, [{contract, _, _, 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,
@@ -471,10 +482,7 @@ get_decode_type(FunName, [{contract, Ann, _, Defs}]) ->
         []            ->
             case FunName of
                 "init" -> {ok, [], {tuple_t, [], []}};
-                 _ ->
-                    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))
+                 _ -> {error, missing_function}
             end
     end;
 get_decode_type(FunName, [_ | Contracts]) ->
@@ -508,14 +516,6 @@ icode_to_term(T = {map, KT, VT}, M) ->
             #{};
         _ -> throw({todo, M})
     end;
-icode_to_term(word, {unop, 'bnot', A}) ->
-    bnot icode_to_term(word, A);
-icode_to_term(word, {binop, 'bor', A, B}) ->
-    icode_to_term(word, A) bor icode_to_term(word, B);
-icode_to_term(word, {binop, 'bsl', A, B}) ->
-    icode_to_term(word, B) bsl icode_to_term(word, A);
-icode_to_term(word, {binop, 'band', A, B}) ->
-    icode_to_term(word, A) band icode_to_term(word, B);
 icode_to_term(typerep, _) ->
     throw({todo, typerep});
 icode_to_term(T, V) ->
@@ -539,9 +539,8 @@ to_bytecode([], _) -> [].
 
 extract_type_info(#{functions := Functions} =_Icode) ->
     ArgTypesOnly = fun(As) -> [ T || {_, T} <- As ] end,
-    Payable = fun(Attrs) -> proplists:get_value(payable, Attrs, false) end,
     TypeInfo = [aeb_aevm_abi:function_type_info(list_to_binary(lists:last(Name)),
-                                            Payable(Attrs), ArgTypesOnly(Args), TypeRep)
+                                            ArgTypesOnly(Args), TypeRep)
                 || {Name, Attrs, Args,_Body, TypeRep} <- Functions,
                    not is_tuple(Name),
                    not lists:member(private, Attrs)
@@ -554,11 +553,9 @@ pp_sophia_code(C, Opts)->  pp(C, Opts, pp_sophia_code, fun(Code) ->
 pp_ast(C, Opts)      ->  pp(C, Opts, pp_ast, fun aeso_ast:pp/1).
 pp_typed_ast(C, Opts)->  pp(C, Opts, pp_typed_ast, fun aeso_ast:pp_typed/1).
 pp_icode(C, Opts)    ->  pp(C, Opts, pp_icode, fun aeso_icode:pp/1).
+pp_assembler(C, Opts)->  pp(C, Opts, pp_assembler, fun aeb_asm:pp/1).
 pp_bytecode(C, Opts) ->  pp(C, Opts, pp_bytecode, fun aeb_disassemble:pp/1).
 
-pp_assembler(aevm, C, Opts) ->  pp(C, Opts, pp_assembler, fun aeb_asm:pp/1);
-pp_assembler(fate, C, Opts) ->  pp(C, Opts, pp_assembler, fun(Asm) -> io:format("~s", [aeb_fate_asm:pp(Asm)]) end).
-
 pp(Code, Options, Option, PPFun) ->
     case proplists:lookup(Option, Options) of
         {Option, true} ->
@@ -567,88 +564,9 @@ pp(Code, Options, Option, PPFun) ->
             ok
     end.
 
-%% -- Byte code validation ---------------------------------------------------
-
--define(protect(Tag, Code), fun() -> try Code catch _:Err1 -> throw({Tag, Err1}) end end()).
-
--spec validate_byte_code(map(), string(), options()) -> ok | {error, [aeso_errors:error()]}.
-validate_byte_code(#{ byte_code := ByteCode, payable := Payable }, Source, Options) ->
-    Fail = fun(Err) -> {error, [aeso_errors:new(data_error, Err)]} end,
-    case proplists:get_value(backend, Options, aevm) of
-        B when B /= fate -> Fail(io_lib:format("Unsupported backend: ~s\n", [B]));
-        fate ->
-            try
-                FCode1 = ?protect(deserialize, aeb_fate_code:strip_init_function(aeb_fate_code:deserialize(ByteCode))),
-                {FCode2, SrcPayable} =
-                    ?protect(compile,
-                             begin
-                               {ok, #{ byte_code := SrcByteCode, payable := SrcPayable }} =
-                                    from_string1(fate, Source, Options),
-                               FCode = aeb_fate_code:deserialize(SrcByteCode),
-                               {aeb_fate_code:strip_init_function(FCode), SrcPayable}
-                             end),
-                case compare_fate_code(FCode1, FCode2) of
-                    ok when SrcPayable /= Payable ->
-                        Not = fun(true) -> ""; (false) -> " not" end,
-                        Fail(io_lib:format("Byte code contract is~s payable, but source code contract is~s.\n",
-                                           [Not(Payable), Not(SrcPayable)]));
-                    ok           -> ok;
-                    {error, Why} -> Fail(io_lib:format("Byte code does not match source code.\n~s", [Why]))
-                end
-            catch
-                throw:{deserialize, _}         -> Fail("Invalid byte code");
-                throw:{compile, {error, Errs}} -> {error, Errs}
-            end
-    end.
-
-compare_fate_code(FCode1, FCode2) ->
-    Funs1 = aeb_fate_code:functions(FCode1),
-    Funs2 = aeb_fate_code:functions(FCode2),
-    Syms1 = aeb_fate_code:symbols(FCode1),
-    Syms2 = aeb_fate_code:symbols(FCode2),
-    FunHashes1 = maps:keys(Funs1),
-    FunHashes2 = maps:keys(Funs2),
-    case FunHashes1 == FunHashes2 of
-        false ->
-            InByteCode   = [ binary_to_list(maps:get(H, Syms1)) || H <- FunHashes1 -- FunHashes2 ],
-            InSourceCode = [ binary_to_list(maps:get(H, Syms2)) || H <- FunHashes2 -- FunHashes1 ],
-            Msg = [ io_lib:format("- Functions in the byte code but not in the source code:\n"
-                                  "    ~s\n", [string:join(InByteCode, ", ")]) || InByteCode /= [] ] ++
-                  [ io_lib:format("- Functions in the source code but not in the byte code:\n"
-                                  "    ~s\n", [string:join(InSourceCode, ", ")]) || InSourceCode /= [] ],
-            {error, Msg};
-        true ->
-            case lists:append([ compare_fate_fun(maps:get(H, Syms1), Fun1, Fun2)
-                                || {{H, Fun1}, {_, Fun2}} <- lists:zip(maps:to_list(Funs1),
-                                                                       maps:to_list(Funs2)) ]) of
-                [] -> ok;
-                Errs -> {error, Errs}
-            end
-    end.
-
-compare_fate_fun(_Name, Fun, Fun) -> [];
-compare_fate_fun(Name, {Attr, Type, _}, {Attr, Type, _}) ->
-    [io_lib:format("- The implementation of the function ~s is different.\n", [Name])];
-compare_fate_fun(Name, {Attr1, Type, _}, {Attr2, Type, _}) ->
-    [io_lib:format("- The attributes of the function ~s differ:\n"
-                   "    Byte code:   ~s\n"
-                   "    Source code: ~s\n",
-                   [Name, string:join([ atom_to_list(A) || A <- Attr1 ], ", "),
-                          string:join([ atom_to_list(A) || A <- Attr2 ], ", ")])];
-compare_fate_fun(Name, {_, Type1, _}, {_, Type2, _}) ->
-    [io_lib:format("- The type of the function ~s differs:\n"
-                   "    Byte code:   ~s\n"
-                   "    Source code: ~s\n",
-                   [Name, pp_fate_sig(Type1), pp_fate_sig(Type2)])].
-
-pp_fate_sig({[Arg], Res}) ->
-    io_lib:format("~s => ~s", [pp_fate_type(Arg), pp_fate_type(Res)]);
-pp_fate_sig({Args, Res}) ->
-    io_lib:format("(~s) => ~s", [string:join([pp_fate_type(Arg) || Arg <- Args], ", "), pp_fate_type(Res)]).
-
-pp_fate_type(T) -> io_lib:format("~w", [T]).
 
 %% -------------------------------------------------------------------
+%% TODO: Tempoary parser hook below...
 
 sophia_type_to_typerep(String) ->
     {ok, Ast} = aeso_parser:type(String),
@@ -657,13 +575,37 @@ sophia_type_to_typerep(String) ->
     catch _:_ -> {error, bad_type}
     end.
 
--spec parse(string(), aeso_compiler:options()) -> none() | aeso_syntax:ast().
 parse(Text, Options) ->
-    parse(Text, sets:new(), Options).
+    %% Try and return something sensible here!
+    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.
 
--spec parse(string(), sets:set(), aeso_compiler:options()) -> none() | aeso_syntax:ast().
-parse(Text, Included, Options) ->
-    aeso_parser:string(Text, Included, Options).
+parse_error(Pos, ErrorString) ->
+    Error = io_lib:format("~s: ~s", [pos_error(Pos), ErrorString]),
+    error({parse_errors, [Error]}).
 
 read_contract(Name) ->
     file:read_file(Name).
+
+pos_error({Line, Pos}) ->
+    io_lib:format("line ~p, column ~p", [Line, Pos]);
+pos_error({no_file, Line, Pos}) ->
+    pos_error({Line, Pos});
+pos_error({File, Line, Pos}) ->
+    io_lib:format("file ~s, line ~p, column ~p", [File, Line, Pos]).

src/aeso_constants.erl

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

src/aeso_errors.erl

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

src/aeso_icode.erl

@@ -13,10 +13,8 @@
          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,
@@ -50,7 +48,6 @@
                   , type_vars => #{ string() => aeb_aevm_data:type() }
                   , constructors => #{ [string()] => integer() }  %% name to tag
                   , options => [any()]
-                  , payable => boolean()
                   }.
 
 pp(Icode) ->
@@ -68,19 +65,16 @@ new(Options) ->
      , types => builtin_types()
      , type_vars => #{}
      , constructors => builtin_constructors()
-     , options => Options
-     , payable => false }.
+     , options => Options}.
 
 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
@@ -109,10 +103,6 @@ new_env() ->
 set_name(Name, Icode) ->
     maps:put(contract_name, Name, Icode).
 
--spec set_payable(boolean(), icode()) -> icode().
-set_payable(Payable, Icode) ->
-    maps:put(payable, Payable, Icode).
-
 -spec set_namespace(aeso_syntax:con() | aeso_syntax:qcon(), icode()) -> icode().
 set_namespace(NS, Icode) -> Icode#{ namespace => NS }.
 
@@ -122,10 +112,6 @@ enter_namespace(NS, Icode = #{ namespace := NS1 }) ->
 enter_namespace(NS, Icode) ->
     Icode#{ namespace => NS }.
 
--spec in_main_contract(icode()) -> boolean().
-in_main_contract(#{ namespace := {con, _, Main}, contract_name := Main }) -> true;
-in_main_contract(_Icode) -> false.
-
 -spec get_namespace(icode()) -> false | aeso_syntax:con() | aeso_syntax:qcon().
 get_namespace(Icode) -> maps:get(namespace, Icode, false).
 

src/aeso_icode_to_asm.erl

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

src/aeso_parse_lib.erl

@@ -9,14 +9,12 @@
 -module(aeso_parse_lib).
 
 -export([parse/2,
-         return/1, fail/0, fail/1, fail/2, map/2, bind/2,
+         return/1, fail/0, fail/1, map/2, bind/2,
          lazy/1, choice/1, choice/2, tok/1, layout/0,
          left/2, right/2, between/3, optional/1,
          many/1, many1/1, sep/2, sep1/2,
          infixl/2, infixr/2]).
 
--export([current_file/0, set_current_file/1]).
-
 %% -- Types ------------------------------------------------------------------
 
 -export_type([parser/1, parser_expr/1, pos/0, token/0, tokens/0]).
@@ -100,10 +98,6 @@ apply_p(X, K) -> K(X).
 -spec lazy(fun(() -> parser(A))) -> parser(A).
 lazy(Delayed) -> ?lazy(Delayed).
 
-%% @doc A parser that always fails at a known location.
--spec fail(pos(), term()) -> parser(none()).
-fail(Pos, Err) -> ?fail({Pos, Err}).
-
 %% @doc A parser that always fails.
 -spec fail(term()) -> parser(none()).
 fail(Err) -> ?fail(Err).
@@ -161,7 +155,7 @@ layout() -> ?layout.
 -spec parse(parser(A), tokens()) -> {ok, A} | {error, term()}.
 parse(P, S) ->
   case parse1(apply_p(P, fun(X) -> {return_plus, X, {fail, no_error}} end), S) of
-    {[], {Pos, Err}} -> {error, {add_current_file(Pos), parse_error, flatten_error(Err)}};
+    {[], {Pos, Err}} -> {error, {Pos, parse_error, flatten_error(Err)}};
     {[A], _}         -> {ok, A};
     {As, _}          -> {error, {{1, 1}, ambiguous_parse, As}}
   end.
@@ -291,7 +285,7 @@ parse1({tok_bind, Map}, Ts, Acc, Err) ->
                     %%            y + y)(4)
                     case maps:get(vclose, Map, '$not_found') of
                         '$not_found' ->
-                            {Acc, unexpected_token_error(Ts, maps:keys(Map), T)};
+                            {Acc, unexpected_token_error(Ts, T)};
                         F ->
                             VClose = {vclose, pos(T)},
                             Ts2    = pop_layout(VClose, Ts#ts{ last = VClose }),
@@ -328,52 +322,12 @@ current_pos(#ts{ tokens   = [T | _] }) -> pos(T);
 current_pos(#ts{ last     = T })       -> end_pos(pos(T)).
 
 -spec mk_error(#ts{}, term()) -> error().
-mk_error(_Ts, {Pos, Err}) ->
-    {Pos, Err};
 mk_error(Ts, Err) ->
     {current_pos(Ts), Err}.
 
 -spec unexpected_token_error(#ts{}, token()) -> error().
 unexpected_token_error(Ts, T) ->
-    unexpected_token_error(Ts, [], T).
-
-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)]).
+    mk_error(Ts, io_lib:format("Unexpected token ~p", [tag(T)])).
 
 %% Get the next token from a token stream. Inserts layout tokens if necessary.
 -spec next_token(#ts{}) -> false | {token(), #ts{}}.
@@ -457,13 +411,3 @@ merge_with(Fun, Map1, Map2) ->
                         end, Map2, maps:to_list(Map1))
     end.
 
-%% Current source file
-current_file() ->
-    get('$current_file').
-
-set_current_file(File) ->
-    put('$current_file', File).
-
-add_current_file({L, C}) -> {current_file(), L, C};
-add_current_file(Pos)    -> Pos.
-

src/aeso_parse_lib.hrl

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

src/aeso_parser.erl

@@ -6,76 +6,37 @@
 
 -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() :: aeso_syntax:ast() | none().
-
--type include_hash() :: {string(), binary()}.
+-type parse_result() :: {ok, aeso_syntax:ast()}
+                      | {error, {aeso_parse_lib:pos(), atom(), term()}}
+                      | {error, {aeso_parse_lib:pos(), atom()}}.
 
 -spec string(string()) -> parse_result().
 string(String) ->
-    string(String, sets:new(), []).
+    string(String, []).
 
 -spec string(string(), aeso_compiler:options()) -> parse_result().
 string(String, Opts) ->
-    case lists:keyfind(src_file, 1, Opts) of
-        {src_file, File} -> string(String, sets:add_element(File, sets:new()), Opts);
-        false -> string(String, sets:new(), Opts)
-    end.
-
--spec string(string(), sets:set(include_hash()), aeso_compiler:options()) -> parse_result().
-string(String, Included, Opts) ->
     case parse_and_scan(file(), String, Opts) of
         {ok, AST} ->
-            case expand_includes(AST, Included, Opts) of
-                {ok, AST1}   -> AST1;
-                {error, Err} -> parse_error(Err)
-            end;
-        {error, Err} ->
-            parse_error(Err)
+            expand_includes(AST, Opts);
+        Err = {error, _} ->
+            Err
     end.
 
 type(String) ->
-    case parse_and_scan(type(), String, []) of
-        {ok, AST}    -> {ok, AST};
-        {error, Err} -> {error, [mk_error(Err)]}
-    end.
+    parse_and_scan(type(), String, []).
 
 parse_and_scan(P, S, Opts) ->
     set_current_file(proplists:get_value(src_file, Opts, no_file)),
     case aeso_scan:scan(S) of
         {ok, Tokens} -> aeso_parse_lib:parse(P, Tokens);
-        {error, {{Input, Pos}, _}} ->
-            {error, {Pos, scan_error, Input}}
+        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, scan_error, Input}) ->
-    mk_p_err(Pos, io_lib:format("Lexical error on input: ~s\n", [Input]));
-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())).
@@ -85,10 +46,8 @@ 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})
-    , pragma()
 
       %% Type declarations  TODO: format annotation for "type bla" vs "type bla()"
     , ?RULE(keyword(type),     id(),                                          {type_decl, _1, _2, []})
@@ -101,35 +60,17 @@ decl() ->
     , ?RULE(keyword(datatype), id(), type_vars(), tok('='), typedef(variant), {type_def, _1, _2, _3, _5})
 
       %% Function declarations
-    , ?RULE(modifiers(), fun_or_entry(), maybe_block(fundef_or_decl()), fun_block(_1, _2, _3))
+    , ?RULE(modifiers(), fun_or_entry(), id(), tok(':'), type(), add_modifiers(_1, _2, {fun_decl, get_ann(_2), _3, _5}))
+    , ?RULE(modifiers(), fun_or_entry(), fundef(),               add_modifiers(_1, _2, set_pos(get_pos(get_ann(_2)), _3)))
     , ?RULE(keyword('let'),    valdef(),                         set_pos(get_pos(_1), _2))
     ])).
 
-fun_block(Mods, Kind, [Decl]) ->
-    add_modifiers(Mods, Kind, set_pos(get_pos(Kind), Decl));
-fun_block(Mods, Kind, Decls) ->
-    {block, get_ann(Kind), [ add_modifiers(Mods, Kind, Decl) || Decl <- Decls ]}.
-
-fundef_or_decl() ->
-    choice([?RULE(id(), tok(':'), type(), {fun_decl, get_ann(_1), _1, _3}),
-            fundef()]).
-
-pragma() ->
-    Op = choice([token(T) || T <- ['<', '=<', '==', '>=', '>']]),
-    ?RULE(tok('@'), id("compiler"), Op, version(), {pragma, get_ann(_1), {compiler, element(1, _3), _4}}).
-
-version() ->
-    ?RULE(token(int), many({tok('.'), token(int)}), mk_version(_1, _2)).
-
-mk_version({int, _, Maj}, Rest) ->
-    [Maj | [N || {_, {int, _, N}} <- Rest]].
-
 fun_or_entry() ->
     choice([?RULE(keyword(function), {function, _1}),
             ?RULE(keyword(entrypoint), {entrypoint, _1})]).
 
 modifiers() ->
-    many(choice([token(stateful), token(payable), token(private), token(public)])).
+    many(choice([token(stateful), token(private), token(public)])).
 
 add_modifiers(Mods, Entry = {entrypoint, _}, Node) ->
     add_modifiers(Mods ++ [Entry], Node);
@@ -172,19 +113,20 @@ letdecl() ->
 letdef() -> choice(valdef(), fundef()).
 
 valdef() ->
-    ?RULE(pattern(), tok('='), body(), {letval, [], _1, _3}).
+    choice(
+        ?RULE(id(),                   tok('='), body(), {letval, [], _1, type_wildcard(), _3}),
+        ?RULE(id(), tok(':'), type(), tok('='), body(), {letval, [], _1, _3, _5})).
 
 fundef() ->
     choice(
-    [ ?RULE(id(), args(),                   tok('='), body(), {letfun, get_ann(_1), _1, _2, type_wildcard(get_ann(_1)), _4})
-    , ?RULE(id(), args(), tok(':'), type(), tok('='), body(), {letfun, get_ann(_1), _1, _2, _4, _6})
+    [ ?RULE(id(), args(),                   tok('='), body(), {letfun, [], _1, _2, type_wildcard(), _4})
+    , ?RULE(id(), args(), tok(':'), type(), tok('='), body(), {letfun, [], _1, _2, _4, _6})
     ]).
 
-args() -> paren_list(pattern()).
-lam_args() -> paren_list(arg()).
+args() -> paren_list(arg()).
 
 arg() -> choice(
-    ?RULE(id(),                   {arg, get_ann(_1), _1, type_wildcard(get_ann(_1))}),
+    ?RULE(id(),                   {arg, get_ann(_1), _1, type_wildcard()}),
     ?RULE(id(), tok(':'), type(), {arg, get_ann(_1), _1, _3})).
 
 %% -- Types ------------------------------------------------------------------
@@ -196,7 +138,7 @@ type() -> ?LAZY_P(type100()).
 type100() -> type200().
 
 type200() ->
-    ?RULE(many({type300(), keyword('=>')}), type300(), fun_t(_1, _2)).
+    ?RULE(many({fun_domain(), keyword('=>')}), type300(), fun_t(_1, _2)).
 
 type300() ->
     ?RULE(sep1(type400(), tok('*')), tuple_t(get_ann(lists:nth(1, _1)), _1)).
@@ -215,15 +157,16 @@ type400() ->
 typeAtom() ->
     ?LAZY_P(choice(
     [ parens(type())
-    , args_t()
     , id(), token(con), token(qcon), token(qid), tvar()
     ])).
 
-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]})
+fun_domain() -> ?LAZY_P(choice(
+    [ ?RULE(tok('('), tok(')'), [])
+      %% Note avoidance of ambiguity: `(int)` can be treated as:
+      %% - literally `int`
+      %% - list of arguments with just one element – int. This approach is dropped.
+    , ?RULE(tok('('), type(), tok(','), sep1(type(), tok(',')), tok(')'), [_2|_4])
+    , ?RULE(type300(), [_1])
     ])).
 
 %% -- Statements -------------------------------------------------------------
@@ -245,7 +188,7 @@ branch() ->
     ?RULE(pattern(), keyword('=>'), body(), {'case', _2, _1, _3}).
 
 pattern() ->
-    ?LET_P(E, expr(), parse_pattern(E)).
+    ?LET_P(E, expr500(), parse_pattern(E)).
 
 %% -- Expressions ------------------------------------------------------------
 
@@ -255,7 +198,7 @@ expr100() ->
     Expr100 = ?LAZY_P(expr100()),
     Expr200 = ?LAZY_P(expr200()),
     choice(
-    [ ?RULE(lam_args(), keyword('=>'), body(), {lam, _2, _1, _3})   %% TODO: better location
+    [ ?RULE(args(), keyword('=>'), body(), {lam, _2, _1, _3})   %% TODO: better location
     , {'if', keyword('if'), parens(Expr100), Expr200, right(tok(else), Expr100)}
     , ?RULE(Expr200, optional(right(tok(':'), type())),
             case _2 of
@@ -287,25 +230,11 @@ exprAtom() ->
         , {bool, keyword(false), false}
         , ?LET_P(Fs, brace_list(?LAZY_P(field_assignment())), record(Fs))
         , {list, [], bracket_list(Expr)}
-        , ?RULE(keyword('['), Expr, token('|'), comma_sep(comprehension_exp()), tok(']'), list_comp_e(_1, _2, _4))
         , ?RULE(tok('['), Expr, binop('..'), Expr, tok(']'), _3(_2, _4))
         , ?RULE(keyword('('), comma_sep(Expr), tok(')'), tuple_e(_1, _2))
         ])
     end).
 
-comprehension_exp() ->
-    ?LAZY_P(choice(
-      [ comprehension_bind()
-      , letdecl()
-      , comprehension_if()
-      ])).
-
-comprehension_if() ->
-    ?RULE(keyword('if'), parens(expr()), {comprehension_if, _1, _2}).
-
-comprehension_bind() ->
-    ?RULE(pattern(), tok('<-'), expr(), {comprehension_bind, _1, _3}).
-
 arg_expr() ->
     ?LAZY_P(
         choice([ ?RULE(id(), tok('='), expr(), {named_arg, [], _1, _3})
@@ -331,7 +260,7 @@ map_key(Key, {ok, {_, Val}}) -> {map_key, Key, Val}.
 
 elim(E, [])                              -> E;
 elim(E, [{proj, Ann, P} | Es])           -> elim({proj, Ann, E, P}, Es);
-elim(E, [{app, _Ann, Args} | Es])        -> elim({app, aeso_syntax:get_ann(E), E, Args}, Es);
+elim(E, [{app, Ann, Args} | Es])         -> elim({app, Ann, E, Args}, Es);
 elim(E, [{rec_upd, Ann, Flds} | Es])     -> elim(record_update(Ann, E, Flds), Es);
 elim(E, [{map_get, Ann, Key} | Es])      -> elim({map_get, Ann, E, Key}, Es);
 elim(E, [{map_get, Ann, Key, Val} | Es]) -> elim({map_get, Ann, E, Key, Val}, Es).
@@ -356,9 +285,7 @@ record(Fs) ->
                         bad_expr_err("Cannot use '@' in map construction", infix({lvalue, FAnn, LV}, {'@', Ann}, Id));
                     ({field, FAnn, LV, _}) ->
                         bad_expr_err("Cannot use nested fields or keys in map construction", {lvalue, FAnn, LV}) end,
-            {map, Ann, lists:map(KV, Fs)};
-        record_or_map_error ->
-            {record_or_map_error, get_ann(hd(Fs)), Fs}
+            {map, Ann, lists:map(KV, Fs)}
     end.
 
 record_or_map(Fields) ->
@@ -370,7 +297,9 @@ record_or_map(Fields) ->
     case lists:usort(lists:map(Kind, Fields)) of
         [proj]    -> record;
         [map_get] -> map;
-        _         -> record_or_map_error %% Defer error until type checking
+        _         ->
+            [{field, Ann, _, _} | _] = Fields,
+            bad_expr_err("Mixed record fields and map keys in", {record, Ann, Fields})
     end.
 
 field_assignment() ->
@@ -425,7 +354,7 @@ token(Tag) ->
 id(Id) ->
     ?LET_P({id, A, X} = Y, id(),
            if X == Id -> Y;
-              true    -> fail({A, "expected '" ++ Id ++ "'"})
+              true    -> fail({A, "expected 'bytes'"})
            end).
 
 id_or_addr() ->
@@ -471,6 +400,12 @@ bracket_list(P) -> brackets(comma_sep(P)).
 -spec pos_ann(ann_line(), ann_col()) -> ann().
 pos_ann(Line, Col) -> [{file, current_file()}, {line, Line}, {col, Col}].
 
+current_file() ->
+    get('$current_file').
+
+set_current_file(File) ->
+    put('$current_file', File).
+
 ann_pos(Ann) ->
     {proplists:get_value(file, Ann),
      proplists:get_value(line, Ann),
@@ -501,8 +436,8 @@ infix(L, Op, R) -> set_ann(format, infix,  {app, get_ann(L), Op, [L, R]}).
 prefixes(Ops, E) -> lists:foldr(fun prefix/2, E, Ops).
 prefix(Op, E)    -> set_ann(format, prefix, {app, get_ann(Op), Op, [E]}).
 
-type_wildcard(Ann) ->
-    {id, [{origin, system} | Ann], "_"}.
+type_wildcard() ->
+    {id, [{origin, system}], "_"}.
 
 block_e(Stmts) ->
     group_ifs(Stmts, []).
@@ -540,21 +475,16 @@ tuple_t(_Ann, [Type]) -> Type;  %% Not a tuple
 tuple_t(Ann, Types)   -> {tuple_t, Ann, Types}.
 
 fun_t(Domains, Type) ->
-    lists:foldr(fun({{args_t, _, Dom}, Ann}, T) -> {fun_t, Ann, [], Dom, T};
-                    ({Dom, Ann}, T)             -> {fun_t, Ann, [], [Dom], T} end,
+    lists:foldr(fun({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}.
 
-list_comp_e(Ann, Expr, Binds) -> {list_comp, Ann, Expr, Binds}.
-
 -spec parse_pattern(aeso_syntax:expr()) -> aeso_parse_lib:parser(aeso_syntax:pat()).
 parse_pattern({app, Ann, Con = {'::', _}, Es}) ->
     {app, Ann, Con, lists:map(fun parse_pattern/1, Es)};
-parse_pattern({app, Ann, {'-', _}, [{int, _, N}]}) ->
-    {int, Ann, -N};
-parse_pattern({app, Ann, Con = {Tag, _, _}, Es}) when Tag == con; Tag == qcon ->
+parse_pattern({app, Ann, Con = {con, _, _}, Es}) ->
     {app, Ann, Con, lists:map(fun parse_pattern/1, Es)};
 parse_pattern({tuple, Ann, Es}) ->
     {tuple, Ann, lists:map(fun parse_pattern/1, Es)};
@@ -562,10 +492,7 @@ parse_pattern({list, Ann, Es}) ->
     {list, Ann, lists:map(fun parse_pattern/1, Es)};
 parse_pattern({record, Ann, Fs}) ->
     {record, Ann, lists:map(fun parse_field_pattern/1, Fs)};
-parse_pattern({typed, Ann, E, Type}) ->
-    {typed, Ann, parse_pattern(E), Type};
 parse_pattern(E = {con, _, _})    -> E;
-parse_pattern(E = {qcon, _, _})   -> E;
 parse_pattern(E = {id, _, _})     -> E;
 parse_pattern(E = {int, _, _})    -> E;
 parse_pattern(E = {bool, _, _})   -> E;
@@ -578,9 +505,14 @@ parse_pattern(E) -> bad_expr_err("Not a valid pattern", E).
 parse_field_pattern({field, Ann, F, E}) ->
     {field, Ann, F, parse_pattern(E)}.
 
+return_error({no_file, L, C}, Err) ->
+    fail(io_lib:format("~p:~p:\n~s", [L, C, Err]));
+return_error({F, L, C}, Err) ->
+    fail(io_lib:format("In ~s at ~p:~p:\n~s", [F, L, C, Err])).
+
 -spec ret_doc_err(ann(), prettypr:document()) -> aeso_parse_lib:parser(none()).
 ret_doc_err(Ann, Doc) ->
-    fail(ann_pos(Ann), prettypr:format(Doc)).
+    return_error(ann_pos(Ann), prettypr:format(Doc)).
 
 -spec bad_expr_err(string(), aeso_syntax:expr()) -> aeso_parse_lib:parser(none()).
 bad_expr_err(Reason, E) ->
@@ -589,37 +521,26 @@ bad_expr_err(Reason, E) ->
                             prettypr:nest(2, aeso_pretty:expr(E))])).
 
 %% -- Helper functions -------------------------------------------------------
+expand_includes(AST, Opts) ->
+    expand_includes(AST, [], 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) ->
+expand_includes([], Acc, _Opts) ->
     {ok, lists:reverse(Acc)};
-expand_includes([{include, Ann, {string, _SAnn, File}} | AST], Included, Acc, Opts) ->
-    case get_include_code(File, Ann, Opts) of
-        {ok, Code} ->
-            Hashed = hash_include(File, Code),
-            case sets:is_element(Hashed, Included) of
-                false ->
+expand_includes([{include, _, S = {string, _, File}} | AST], Acc, Opts) ->
+    case read_file(File, Opts) of
+        {ok, Bin} ->
             Opts1 = lists:keystore(src_file, 1, Opts, {src_file, File}),
-                    Included1 = sets:add_element(Hashed, Included),
-                    case parse_and_scan(file(), Code, Opts1) of
+            case string(binary_to_list(Bin), Opts1) of
                 {ok, AST1} ->
-                            expand_includes(AST1 ++ AST, Included1, Acc, Opts);
+                    expand_includes(AST1 ++ AST, Acc, Opts);
                 Err = {error, _} ->
                     Err
             end;
-                true ->
-                    expand_includes(AST, Included, Acc, Opts)
+        {error, _} ->
+            {error, {get_pos(S), include_error, File}}
     end;
-        Err = {error, _} ->
-            Err
-    end;
-expand_includes([E | AST], Included, Acc, Opts) ->
-    expand_includes(AST, Included, [E | Acc], Opts).
+expand_includes([E | AST], Acc, Opts) ->
+    expand_includes(AST, [E | Acc], Opts).
 
 read_file(File, Opts) ->
     case proplists:get_value(include, Opts, {explicit_files, #{}}) of
@@ -631,51 +552,6 @@ read_file(File, Opts) ->
             case maps:get(binary_to_list(File), Files, not_found) of
                 not_found -> {error, not_found};
                 Src       -> {ok, Src}
-            end;
-        escript ->
-            try
-                Escript        = escript:script_name(),
-                {ok, Sections} = escript:extract(Escript, []),
-                Archive        = proplists:get_value(archive, Sections),
-                FileName       = binary_to_list(filename:join([aesophia, priv, stdlib, File])),
-                case zip:extract(Archive, [{file_list, [FileName]}, memory]) of
-                    {ok, [{_, Src}]} -> {ok, Src};
-                    _                -> {error, not_found}
-                end
-            catch _:_ ->
-                {error, not_found}
             end
     end.
 
-stdlib_options() ->
-    StdLibDir = aeso_stdlib:stdlib_include_path(),
-    case filelib:is_dir(StdLibDir) of
-        true  -> [{include, {file_system, [StdLibDir]}}];
-        false -> [{include, escript}]
-    end.
-
-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

@@ -149,7 +149,6 @@ decl({contract, _, C, Ds}) ->
     block(follow(text("contract"), hsep(name(C), text("="))), decls(Ds));
 decl({namespace, _, C, Ds}) ->
     block(follow(text("namespace"), hsep(name(C), text("="))), decls(Ds));
-decl({pragma, _, Pragma}) -> pragma(Pragma);
 decl({type_decl, _, T, Vars}) -> typedecl(alias_t, T, Vars);
 decl({type_def, _, T, Vars, Def}) ->
     Kind = element(1, Def),
@@ -169,15 +168,7 @@ decl(D = {letfun, Attrs, _, _, _, _}) ->
               false -> "function"
           end,
     hsep(lists:map(Mod, Attrs) ++ [letdecl(Fun, D)]);
-decl({fun_clauses, Ann, Name, Type, Clauses}) ->
-    above([ decl(D) || D <- [{fun_decl, Ann, Name, Type} | Clauses] ]);
-decl(D = {letval, _, _, _}) -> letdecl("let", D);
-decl({block, _, Ds}) ->
-    above([ decl(D) || D <- Ds ]).
-
--spec pragma(aeso_syntax:pragma()) -> doc().
-pragma({compiler, Op, Ver}) ->
-    text("@compiler " ++ atom_to_list(Op) ++ " " ++ string:join([integer_to_list(N) || N <- Ver], ".")).
+decl(D = {letval, _, _, _, _}) -> letdecl("let", D).
 
 -spec expr(aeso_syntax:expr(), options()) -> doc().
 expr(E, Options) ->
@@ -197,10 +188,10 @@ name({tvar, _, Name})  -> text(Name);
 name({typed, _, Name, _}) -> name(Name).
 
 -spec letdecl(string(), aeso_syntax:letbind()) -> doc().
-letdecl(Let, {letval, _, P, E}) ->
-    block_expr(0, hsep([text(Let), expr(P), text("=")]), E);
+letdecl(Let, {letval, _, F, T, E}) ->
+    block_expr(0, hsep([text(Let), typed(name(F), T), text("=")]), E);
 letdecl(Let, {letfun, _, F, Args, T, E}) ->
-    block_expr(0, hsep([text(Let), typed(beside(name(F), expr({tuple, [], Args})), T), text("=")]), E).
+    block_expr(0, hsep([text(Let), typed(beside(name(F), args(Args)), T), text("=")]), E).
 
 -spec args([aeso_syntax:arg()]) -> doc().
 args(Args) ->
@@ -244,16 +235,12 @@ 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), 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, ")"]));
@@ -309,8 +296,6 @@ expr_p(_, {tuple, _, Es}) ->
     tuple(lists:map(fun expr/1, Es));
 expr_p(_, {list, _, Es}) ->
     list(lists:map(fun expr/1, Es));
-expr_p(_, {list_comp, _, E, Binds}) ->
-    list([follow(expr(E), hsep(text("|"), par(punctuate(text(","), lists:map(fun lc_bind/1, Binds)), 0)), 0)]);
 expr_p(_, {record, _, Fs}) ->
     record(lists:map(fun field/1, Fs));
 expr_p(_, {map, Ann, KVs}) ->
@@ -393,13 +378,6 @@ stmt_p({else, Else}) ->
         _ -> block_expr(200, text("else"), Else)
     end.
 
-lc_bind({comprehension_bind, P, E}) ->
-    follow(hsep(expr(P), text("<-")), expr(E));
-lc_bind({comprehension_if, _, E}) ->
-    beside([text("if("), expr(E), text(")")]);
-lc_bind(Let) ->
-    letdecl("let", Let).
-
 -spec bin_prec(aeso_syntax:bin_op()) -> {integer(), integer(), integer()}.
 bin_prec('..')   -> {  0,   0,   0};  %% Always printed inside '[ ]'
 bin_prec('=')    -> {  0,   0,   0};  %% Always printed inside '[ ]'
@@ -463,7 +441,7 @@ elim1(Get={map_get, _, _})    -> elim(Get);
 elim1(Get={map_get, _, _, _}) -> elim(Get).
 
 alt({'case', _, Pat, Body}) ->
-    block_expr(0, hsep(expr(Pat), text("=>")), Body).
+    block_expr(0, hsep(expr_p(500, Pat), text("=>")), Body).
 
 block_expr(_, Header, {block, _, Ss}) ->
     block(Header, statements(Ss));
@@ -473,7 +451,7 @@ block_expr(P, Header, E) ->
 statements(Stmts) ->
     above([ statement(S) || S <- Stmts ]).
 
-statement(S = {letval, _, _, _})       -> letdecl("let", S);
+statement(S = {letval, _, _, _, _})    -> letdecl("let", S);
 statement(S = {letfun, _, _, _, _, _}) -> letdecl("let", S);
 statement(E) -> expr(E).
 

src/aeso_scan.erl

@@ -13,15 +13,14 @@
                         override/2, push/2, pop/1]).
 
 lexer() ->
-    Number   = fun(Digit) -> [Digit, "+(_", Digit, "+)*"] end,
     DIGIT    = "[0-9]",
     HEXDIGIT = "[0-9a-fA-F]",
     LOWER    = "[a-z_]",
     UPPER    = "[A-Z]",
     CON      = [UPPER, "[a-zA-Z0-9_]*"],
-    INT      = Number(DIGIT),
-    HEX      = ["0x", Number(HEXDIGIT)],
-    BYTES    = ["#", Number(HEXDIGIT)],
+    INT      = [DIGIT, "+"],
+    HEX      = ["0x", HEXDIGIT, "+"],
+    BYTES    = ["#", HEXDIGIT, "+"],
     WS       = "[\\000-\\ ]+",
     ID       = [LOWER, "[a-zA-Z0-9_']*"],
     TVAR     = ["'", ID],
@@ -38,7 +37,7 @@ lexer() ->
         , {"[^/*]+|[/*]", skip()} ],
 
     Keywords = ["contract", "include", "let", "switch", "type", "record", "datatype", "if", "elif", "else", "function",
-                "stateful", "payable", "true", "false", "mod", "public", "entrypoint", "private", "indexed", "namespace"],
+                "stateful", "true", "false", "mod", "public", "entrypoint", "private", "indexed", "namespace"],
     KW = string:join(Keywords, "|"),
 
     Rules =
@@ -54,7 +53,7 @@ lexer() ->
         , {CHAR,   token(char,   fun parse_char/1)}
         , {STRING, token(string, fun parse_string/1)}
         , {HEX,    token(hex,    fun parse_hex/1)}
-        , {INT,    token(int,    fun parse_int/1)}
+        , {INT,    token(int,    fun list_to_integer/1)}
         , {BYTES,  token(bytes,  fun parse_bytes/1)}
 
           %% Identifiers (qualified first!)
@@ -96,11 +95,9 @@ parse_char([$', C, $']) -> C.
 
 unescape(Str) -> unescape(Str, []).
 
+%% TODO: numeric escapes
 unescape([$"], Acc) ->
     list_to_binary(lists:reverse(Acc));
-unescape([$\\, $x, D1, D2 | Chars ], Acc) ->
-    C = list_to_integer([D1, D2], 16),
-    unescape(Chars, [C | Acc]);
 unescape([$\\, Code | Chars], Acc) ->
     Ok = fun(C) -> unescape(Chars, [C | Acc]) end,
     case Code of
@@ -118,18 +115,10 @@ unescape([$\\, Code | Chars], Acc) ->
 unescape([C | Chars], Acc) ->
     unescape(Chars, [C | Acc]).
 
-strip_underscores(S) ->
-    lists:filter(fun(C) -> C /= $_ end, S).
+parse_hex("0x" ++ Chars) -> list_to_integer(Chars, 16).
 
-parse_hex("0x" ++ S) ->
-    list_to_integer(strip_underscores(S), 16).
-
-parse_int(S) ->
-    list_to_integer(strip_underscores(S)).
-
-parse_bytes("#" ++ S0) ->
-    S      = strip_underscores(S0),
-    N      = list_to_integer(S, 16),
-    Digits = (length(S) + 1) div 2,
+parse_bytes("#" ++ Chars) ->
+    N      = list_to_integer(Chars, 16),
+    Digits = (length(Chars) + 1) div 2,
     <<N:Digits/unit:8>>.
 

src/aeso_stdlib.erl

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

src/aeso_syntax.erl

@@ -13,7 +13,7 @@
 -export_type([ann_line/0, ann_col/0, ann_origin/0, ann_format/0, ann/0]).
 -export_type([name/0, id/0, con/0, qid/0, qcon/0, tvar/0, op/0]).
 -export_type([bin_op/0, un_op/0]).
--export_type([decl/0, letbind/0, typedef/0, pragma/0]).
+-export_type([decl/0, letbind/0, typedef/0]).
 -export_type([arg/0, field_t/0, constructor_t/0, named_arg_t/0]).
 -export_type([type/0, constant/0, expr/0, arg_expr/0, field/1, stmt/0, alt/0, lvalue/0, elim/0, pat/0]).
 -export_type([ast/0]).
@@ -36,21 +36,14 @@
 
 -type decl() :: {contract, ann(), con(), [decl()]}
               | {namespace, ann(), con(), [decl()]}
-              | {pragma, ann(), pragma()}
               | {type_decl, ann(), id(), [tvar()]}
               | {type_def, ann(), id(), [tvar()], typedef()}
               | {fun_decl, ann(), id(), type()}
-              | {fun_clauses, ann(), id(), type(), [letbind()]}
-              | {block, ann(), [decl()]}
               | letbind().
 
--type compiler_version() :: [non_neg_integer()].
-
--type pragma() :: {compiler, '==' | '<' | '>' | '=<' | '>=', compiler_version()}.
-
 -type letbind()
-    :: {letval, ann(), pat(), expr()}
-     | {letfun, ann(), id(), [pat()], type(), expr()}.
+    :: {letval, ann(), id(), type(), expr()}
+     | {letfun, ann(), id(), [arg()], type(), expr()}.
 
 -type arg() :: {arg, ann(), id(), type()}.
 
@@ -66,7 +59,6 @@
 -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
@@ -100,10 +92,10 @@
      | {proj, ann(), expr(), id()}
      | {tuple, ann(), [expr()]}
      | {list, ann(), [expr()]}
-     | {list_comp, ann(), expr(), [comprehension_exp()]}
      | {typed, ann(), expr(), type()}
-     | {record_or_map(), ann(), [field(expr())]}
-     | {record_or_map(), ann(), expr(), [field(expr())]} %% record/map update
+     | {record, ann(), [field(expr())]}
+     | {record, ann(), expr(), [field(expr())]} %% record update
+     | {map, ann(), expr(), [field(expr())]}    %% map update
      | {map, ann(), [{expr(), expr()}]}
      | {map_get, ann(), expr(), expr()}
      | {map_get, ann(), expr(), expr(), expr()}
@@ -112,12 +104,6 @@
      | id() | qid() | con() | qcon()
      | constant().
 
--type record_or_map() :: record | map | record_or_map_error.
-
--type comprehension_exp() :: [ {comprehension_bind, pat(), 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
@@ -142,7 +128,6 @@
 -type pat() :: {app, ann(), con() | op(), [pat()]}
              | {tuple, ann(), [pat()]}
              | {list, ann(), [pat()]}
-             | {typed, ann(), pat(), type()}
              | {record, ann(), [field(pat())]}
              | constant()
              | con()

src/aeso_syntax_utils.erl

@@ -48,9 +48,8 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
             {type_decl, _, I, _}     -> BindType(I);
             {type_def, _, I, _, D}   -> Plus(BindType(I), Decl(D));
             {fun_decl, _, _, T}      -> Type(T);
-            {letval, _, P, E}        -> Scoped(BindExpr(P), Expr(E));
-            {letfun, _, F, Xs, T, E} -> Sum([BindExpr(F), Type(T), Expr(Xs ++ [E])]);
-            {fun_clauses, _, _, T, Cs} -> Sum([Type(T) | [Decl(C) || C <- Cs]]);
+            {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))]);
             %% typedef()
             {alias_t, T}    -> Type(T);
             {record_t, Fs}  -> Type(Fs);
@@ -72,15 +71,6 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
             {proj, _, E, _}        -> Expr(E);
             {tuple, _, As}         -> Expr(As);
             {list, _, As}          -> Expr(As);
-            {list_comp, _, Y, []}  -> Expr(Y);
-            {list_comp, A, Y, [{comprehension_bind, I, E}|R]} ->
-                Plus(Expr(E), Scoped(BindExpr(I), Expr({list_comp, A, Y, R})));
-            {list_comp, A, Y, [{comprehension_if, _, E}|R]} ->
-                Plus(Expr(E), Expr({list_comp, A, Y, R}));
-            {list_comp, A, Y, [D = {letval, _, Pat, _} | R]} ->
-                Plus(Decl(D), Scoped(BindExpr(Pat), 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]);
@@ -93,7 +83,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, _, Y, T} -> Plus(BindExpr(Y), Type(T));
+            {arg, _, X, T} -> Plus(Expr(X), Type(T));
             %% alt()
             {'case', _, P, E} -> Scoped(BindExpr(P), Expr(E));
             %% elim()
@@ -125,12 +115,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) -> maps:without(Keys, Map) end,
+    Remove  = fun(Keys, Map) -> lists:foldl(fun maps:remove/2, Map, Keys) end,
     Scoped = fun(Xs, Ys) ->
-                Bound  = [E || E <- maps:keys(Xs), IsBound(E)],
+                Bound  = [E || E <- maps:keys(Ys), IsBound(E)],
+                Others = Remove(Bound, Ys),
                 Bound1 = [ {Unbind(Tag), X} || {Tag, X} <- Bound ],
-                Others = Remove(Bound1, Ys),
-                maps:merge(Remove(Bound, Xs), Others)
+                maps:merge(Remove(Bound1, Xs), Others)
             end,
     #alg{ zero   = #{}
         , plus   = fun maps:merge/2

src/aeso_vm_decode.erl

@@ -18,13 +18,8 @@ from_aevm(word, {id, _, "address"},                     N) -> address_literal(ac
 from_aevm(word, {app_t, _, {id, _, "oracle"}, _},       N) -> address_literal(oracle_pubkey, N);
 from_aevm(word, {app_t, _, {id, _, "oracle_query"}, _}, N) -> address_literal(oracle_query_id, N);
 from_aevm(word, {con, _, _Name},                        N) -> address_literal(contract_pubkey, N);
-from_aevm(word, {id, _, "int"}, N0) ->
-    <<N:256/signed>> = <<N0:256>>,
-    if N < 0 -> {app, [{format, prefix}], {'-', []}, [{int, [], -N}]};
-       true  -> {int, [], N} end;
-from_aevm(word, {id, _, "bits"}, N0) ->
-    <<N:256/signed>> = <<N0:256>>,
-    make_bits(N);
+from_aevm(word, {id, _, "int"},     N) -> <<N1:256/signed>> = <<N:256>>, {int, [], N1};
+from_aevm(word, {id, _, "bits"},    N) -> error({todo, bits, N});
 from_aevm(word, {id, _, "bool"},    N) -> {bool, [], N /= 0};
 from_aevm(word, {bytes_t, _, Len}, Val) when Len =< 32 ->
     <<Bytes:Len/unit:8, _/binary>> = <<Val:32/unit:8>>,
@@ -60,7 +55,6 @@ from_aevm({variant, VmCons}, {variant_t, Cons}, {variant, Tag, Args})
     VmTypes = lists:nth(Tag + 1, VmCons),
     ConType = lists:nth(Tag + 1, Cons),
     from_aevm(VmTypes, ConType, Args);
-from_aevm([], {constr_t, _, Con, []}, []) -> Con;
 from_aevm(VmTypes, {constr_t, _, Con, Types}, Args)
         when length(VmTypes) == length(Types),
              length(VmTypes) == length(Args) ->
@@ -76,10 +70,8 @@ from_fate({app_t, _, {id, _, "oracle"}, _}, ?FATE_ORACLE(Bin)) -> {oracle_pubkey
 from_fate({app_t, _, {id, _, "oracle_query"}, _}, ?FATE_ORACLE_Q(Bin)) -> {oracle_query_id, [], Bin};
 from_fate({con, _, _Name},  ?FATE_CONTRACT(Bin)) -> {contract_pubkey, [], Bin};
 from_fate({bytes_t, _, N},  ?FATE_BYTES(Bin)) when byte_size(Bin) == N -> {bytes, [], Bin};
-from_fate({id, _, "bits"},  ?FATE_BITS(N)) -> make_bits(N);
-from_fate({id, _, "int"},     N) when is_integer(N) ->
-    if N < 0 -> {app, [{format, prefix}], {'-', []}, [{int, [], -N}]};
-       true  -> {int, [], N} end;
+from_fate({id, _, "bits"},  ?FATE_BITS(Bin)) -> error({todo, bits, Bin});
+from_fate({id, _, "int"},     N) when is_integer(N) -> {int, [], N};
 from_fate({id, _, "bool"},    B) when is_boolean(B) -> {bool, [], B};
 from_fate({id, _, "string"}, S) when is_binary(S) -> {string, [], S};
 from_fate({app_t, _, {id, _, "list"}, [Type]}, List) when is_list(List) ->
@@ -113,23 +105,9 @@ from_fate({variant_t, Cons}, {variant, Ar, Tag, Args})
             from_fate(ConType, ArgList);
         _ -> throw(cannot_translate_to_sophia)
     end;
-from_fate({constr_t, _, Con, []}, []) -> Con;
 from_fate({constr_t, _, Con, Types}, Args)
         when length(Types) == length(Args) ->
     {app, [], Con, [ from_fate(Type, Arg)
                      || {Type, Arg} <- lists:zip(Types, Args) ]};
 from_fate(_Type, _Data) ->
     throw(cannot_translate_to_sophia).
-
-
-make_bits(N) ->
-    Id = fun(F) -> {qid, [], ["Bits", F]} end,
-    if N < 0 -> make_bits(Id("clear"), Id("all"), 0, bnot N);
-       true  -> make_bits(Id("set"), Id("none"), 0, N) end.
-
-make_bits(_Set, Zero, _I, 0) -> Zero;
-make_bits(Set, Zero, I, N) when 0 == N rem 2 ->
-    make_bits(Set, Zero, I + 1, N div 2);
-make_bits(Set, Zero, I, N) ->
-    {app, [], Set, [make_bits(Set, Zero, I + 1, N div 2), {int, [], I}]}.
-

src/aesophia.app.src

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

test/aeso_abi_tests.erl

@@ -72,58 +72,6 @@ encode_decode_sophia_test() ->
     ok = Check("r", "{x = (\"foo\", 0), y = Red}"),
     ok.
 
-to_sophia_value_neg_test() ->
-    Code = [ "contract Foo =\n"
-             "  entrypoint x(y : int) : string = \"hello\"\n" ],
-
-    {error, [Err1]} = aeso_compiler:to_sophia_value(Code, "x", ok, encode(12)),
-    ?assertEqual("Data error:\nFailed to decode binary as type string\n", aeso_errors:pp(Err1)),
-    {error, [Err2]} = aeso_compiler:to_sophia_value(Code, "x", ok, encode(12), [{backend, fate}]),
-    ?assertEqual("Data error:\nFailed to decode binary as type string\n", aeso_errors:pp(Err2)),
-
-    {error, [Err3]} = aeso_compiler:to_sophia_value(Code, "x", revert, encode(12)),
-    ?assertEqual("Data error:\nCould not interpret the revert message\n", aeso_errors:pp(Err3)),
-    {error, [Err4]} = aeso_compiler:to_sophia_value(Code, "x", revert, encode(12), [{backend, fate}]),
-    ?assertEqual("Data error:\nCould not deserialize the revert message\n", aeso_errors:pp(Err4)),
-    ok.
-
-encode_calldata_neg_test() ->
-    Code = [ "contract Foo =\n"
-             "  entrypoint x(y : int) : string = \"hello\"\n" ],
-
-    ExpErr1 = "Type error at line 5, col 34:\nCannot unify int\n         and bool\n"
-              "when checking the application at line 5, column 34 of\n"
-              "  x : (int) => string\nto arguments\n  true : bool\n",
-    {error, [Err1]} = aeso_compiler:create_calldata(Code, "x", ["true"]),
-    ?assertEqual(ExpErr1, aeso_errors:pp(Err1)),
-    {error, [Err2]} = aeso_compiler:create_calldata(Code, "x", ["true"], [{backend, fate}]),
-    ?assertEqual(ExpErr1, aeso_errors:pp(Err2)),
-
-    ok.
-
-decode_calldata_neg_test() ->
-    Code1 = [ "contract Foo =\n"
-              "  entrypoint x(y : int) : string = \"hello\"\n" ],
-    Code2 = [ "contract Foo =\n"
-              "  entrypoint x(y : string) : int = 42\n" ],
-
-    {ok, CallDataAEVM} = aeso_compiler:create_calldata(Code1, "x", ["42"]),
-    {ok, CallDataFATE} = aeso_compiler:create_calldata(Code1, "x", ["42"], [{backend, fate}]),
-
-    {error, [Err1]} = aeso_compiler:decode_calldata(Code2, "x", CallDataAEVM),
-    ?assertEqual("Data error:\nFailed to decode calldata as type {tuple,[string]}\n", aeso_errors:pp(Err1)),
-    {error, [Err2]} = aeso_compiler:decode_calldata(Code2, "x", <<1,2,3>>, [{backend, fate}]),
-    ?assertEqual("Data error:\nFailed to decode calldata binary\n", aeso_errors:pp(Err2)),
-    {error, [Err3]} = aeso_compiler:decode_calldata(Code2, "x", CallDataFATE, [{backend, fate}]),
-    ?assertEqual("Data error:\nCannot translate FATE value \"*\"\n  to Sophia type (string)\n", aeso_errors:pp(Err3)),
-
-    {error, [Err4]} = aeso_compiler:decode_calldata(Code2, "y", CallDataAEVM),
-    ?assertEqual("Data error at line 1, col 1:\nFunction 'y' is missing in contract\n", aeso_errors:pp(Err4)),
-    {error, [Err5]} = aeso_compiler:decode_calldata(Code2, "y", CallDataFATE, [{backend, fate}]),
-    ?assertEqual("Data error at line 1, col 1:\nFunction 'y' is missing in contract\n", aeso_errors:pp(Err5)),
-    ok.
-
-
 encode_decode_sophia_string(SophiaType, String) ->
     io:format("String ~p~n", [String]),
     Code = [ "contract MakeCall =\n"
@@ -132,11 +80,11 @@ encode_decode_sophia_string(SophiaType, String) ->
            , "  record r = {x : an_alias(int), y : variant}\n"
            , "  datatype variant = Red | Blue(map(string, int))\n"
            , "  entrypoint foo : arg_type => arg_type\n" ],
-    case aeso_compiler:check_call(lists:flatten(Code), "foo", [String], [no_code]) of
+    case aeso_compiler:check_call(lists:flatten(Code), "foo", [String], []) of
         {ok, _, {[Type], _}, [Arg]} ->
             io:format("Type ~p~n", [Type]),
             Data = encode(Arg),
-            case aeso_compiler:to_sophia_value(Code, "foo", ok, Data, [no_code]) of
+            case aeso_compiler:to_sophia_value(Code, "foo", ok, Data) of
                 {ok, Sophia} ->
                     lists:flatten(io_lib:format("~s", [prettypr:format(aeso_pretty:expr(Sophia))]));
                 {error, Err} ->
@@ -204,7 +152,7 @@ oracle_test() ->
         "    Oracle.get_question(o, q)\n",
     {ok, _, {[word, word], {list, string}}, [16#123, 16#456]} =
         aeso_compiler:check_call(Contract, "question", ["ok_111111111111111111111111111111ZrdqRz9",
-                                                        "oq_1111111111111111111111111111113AFEFpt5"], [no_code]),
+                                                        "oq_1111111111111111111111111111113AFEFpt5"], []),
 
     ok.
 
@@ -213,10 +161,8 @@ permissive_literals_fail_test() ->
         "contract OracleTest =\n"
         "  stateful entrypoint haxx(o : oracle(list(string), option(int))) =\n"
         "    Chain.spend(o, 1000000)\n",
-    {error, [Err]} =
+        {error, <<"Type errors\nCannot unify", _/binary>>} =
             aeso_compiler:check_call(Contract, "haxx", ["#123"], []),
-    ?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) ->
@@ -227,8 +173,8 @@ encode_decode_calldata(FunName, Types, Args, RetType) ->
     encode_decode_calldata_(Code, FunName, Args, RetType).
 
 encode_decode_calldata_(Code, FunName, Args, RetVMType) ->
-    {ok, Calldata} = aeso_compiler:create_calldata(Code, FunName, Args, []),
-    {ok, _, {ArgTypes, RetType}, _} = aeso_compiler:check_call(Code, FunName, Args, [{backend, aevm}, no_code]),
+    {ok, Calldata} = aeso_compiler:create_calldata(Code, FunName, Args),
+    {ok, _, {ArgTypes, RetType}, _} = aeso_compiler:check_call(Code, FunName, Args, [{backend, aevm}]),
     ?assertEqual(RetType, RetVMType),
     CalldataType = {tuple, [word, {tuple, ArgTypes}]},
     {ok, {_Hash, ArgTuple}} = aeb_heap:from_binary(CalldataType, Calldata),
@@ -236,7 +182,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,22 +14,20 @@ test_contract(N) ->
     ?assertEqual({ok, DecACI}, aeso_aci:render_aci_json(JSON)).
 
 test_cases(1) ->
-    Contract = <<"payable contract C =\n"
-		 "  payable stateful entrypoint a(i : int) = i+1\n">>,
+    Contract = <<"contract C =\n"
+		 "  entrypoint a(i : int) = i+1\n">>,
     MapACI = #{contract =>
 		   #{name => <<"C">>,
 		     type_defs => [],
-                     payable => true,
 		     functions =>
 			 [#{name => <<"a">>,
 			    arguments =>
 				[#{name => <<"i">>,
 				   type => <<"int">>}],
 			    returns => <<"int">>,
-			    stateful => true,
-                            payable  => true}]}},
-    DecACI = <<"payable contract C =\n"
-	       "  payable entrypoint a : (int) => int\n">>,
+			    stateful => false}]}},
+    DecACI = <<"contract C =\n"
+	       "  entrypoint a : (int) => int\n">>,
     {Contract,MapACI,DecACI};
 
 test_cases(2) ->
@@ -37,7 +35,7 @@ test_cases(2) ->
 		 "  type allan = int\n"
 		 "  entrypoint a(i : allan) = i+1\n">>,
     MapACI = #{contract =>
-                       #{name => <<"C">>, payable => false,
+                       #{name => <<"C">>,
                          type_defs =>
                              [#{name => <<"allan">>,
                                 typedef => <<"int">>,
@@ -48,8 +46,7 @@ test_cases(2) ->
                                        type => <<"C.allan">>}],
                                 name => <<"a">>,
                                 returns => <<"int">>,
-                                stateful => false,
-                                payable  => false}]}},
+                                stateful => false}]}},
     DecACI = <<"contract C =\n"
                "  type allan = int\n"
                "  entrypoint a : (C.allan) => int\n">>,
@@ -67,8 +64,8 @@ test_cases(3) ->
 				   type =>
 				       #{<<"C.bert">> => [<<"string">>]}}],
 			    name => <<"a">>,returns => <<"int">>,
-			    stateful => false, payable  => false}],
-		     name => <<"C">>, payable => false,
+			    stateful => false}],
+		     name => <<"C">>,
                      event => #{variant => [#{<<"SingleEventDefined">> => []}]},
                      state => <<"unit">>,
 		     type_defs =>
@@ -106,20 +103,20 @@ aci_test_contract(Name) ->
     ok.
 
 check_stub(Stub, Options) ->
-    try aeso_parser:string(binary_to_list(Stub), Options) of
-        Ast ->
+    case aeso_parser:string(binary_to_list(Stub), Options) of
+        {ok, Ast} ->
             try
                 %% io:format("AST: ~120p\n", [Ast]),
                 aeso_ast_infer_types:infer(Ast, [])
-            catch throw:{type_errors, TE} ->
+            catch _:{type_errors, TE} ->
                 io:format("Type error:\n~s\n", [TE]),
                 error(TE);
                   _:R ->
                 io:format("Error: ~p\n", [R]),
                 error(R)
-            end
-    catch throw:{error, Errs} ->
-        _ = [ io:format("~s\n", [aeso_errors:pp(E)]) || E <- Errs ],
-        error({parse_errors, Errs})
+            end;
+        {error, E} ->
+            io:format("Error: ~p\n", [E]),
+            error({parse_error, E})
     end.
 

test/aeso_calldata_tests.erl

@@ -29,10 +29,11 @@ calldata_test_() ->
                   true -> ast_exprs(ContractString, Fun, Args, [{backend, fate}]);
                   false -> undefined
               end,
-           ParsedExprs = parse_args(Fun, Args),
-           [ ?assertEqual(ParsedExprs, AevmExprs) || AevmExprs /= undefined ],
-           [ ?assertEqual(ParsedExprs, FateExprs) || FateExprs /= undefined ],
-           ok
+           case FateExprs == undefined orelse AevmExprs == undefined of
+               true -> ok;
+               false ->
+                   ?assertEqual(FateExprs, AevmExprs)
+           end
         end} || {ContractName, Fun, Args} <- compilable_contracts()].
 
 calldata_aci_test_() ->
@@ -52,34 +53,19 @@ calldata_aci_test_() ->
                   true -> ast_exprs(ContractACI, Fun, Args, [{backend, fate}]);
                   false -> undefined
               end,
-           ParsedExprs = parse_args(Fun, Args),
-           [ ?assertEqual(ParsedExprs, AevmExprs) || AevmExprs /= undefined ],
-           [ ?assertEqual(ParsedExprs, FateExprs) || FateExprs /= undefined ],
-           ok
+           case FateExprs == undefined orelse AevmExprs == undefined of
+               true -> ok;
+               false ->
+                   ?assertEqual(FateExprs, AevmExprs)
+           end
         end} || {ContractName, Fun, Args} <- compilable_contracts()].
 
-parse_args(Fun, Args) ->
-    [{contract, _, _, [{letfun, _, _, _, _, {app, _, _, AST}}]}] =
-        aeso_parser:string("contract Temp = function foo() = " ++ Fun ++ "(" ++ string:join(Args, ", ") ++ ")"),
-    strip_ann(AST).
-
-strip_ann(T) when is_tuple(T) ->
-    strip_ann1(setelement(2, T, []));
-strip_ann(X) -> strip_ann1(X).
-
-strip_ann1({map, [], KVs}) ->
-    {map, [], [{strip_ann(K), strip_ann(V)} || {K, V} <- KVs]};
-strip_ann1(T) when is_tuple(T) ->
-    list_to_tuple(strip_ann1(tuple_to_list(T)));
-strip_ann1(L) when is_list(L) ->
-    lists:map(fun strip_ann/1, L);
-strip_ann1(X) -> X.
 
 ast_exprs(ContractString, Fun, Args, Opts) ->
     {ok, Data} = (catch aeso_compiler:create_calldata(ContractString, Fun, Args, Opts)),
     {ok, _Types, Exprs} = (catch aeso_compiler:decode_calldata(ContractString, Fun, Data, Opts)),
     ?assert(is_list(Exprs)),
-    strip_ann(Exprs).
+    Exprs.
 
 check_errors(Expect, ErrorString) ->
     %% This removes the final single \n as well.
@@ -99,9 +85,7 @@ compilable_contracts() ->
      {"maps", "init", []},
      {"funargs", "menot", ["false"]},
      {"funargs", "append", ["[\"false\", \" is\", \" not\", \" true\"]"]},
-     {"funargs", "bitsum", ["Bits.all"]},
-     {"funargs", "bitsum", ["Bits.clear(Bits.clear(Bits.all, 4), 2)"]}, %% Order matters for test
-     {"funargs", "bitsum", ["Bits.set(Bits.set(Bits.none, 4), 2)"]},
+     %% TODO {"funargs", "bitsum", ["Bits.all"]},
      {"funargs", "read", ["{label = \"question 1\", result = 4}"]},
      {"funargs", "sjutton", ["#0011012003100011012003100011012003"]},
      {"funargs", "sextiosju", ["#01020304050607080910111213141516171819202122232425262728293031323334353637383940"
@@ -132,11 +116,10 @@ compilable_contracts() ->
      {"complex_types", "filter_some", ["[Some(11), Some(12), None]"]},
      {"complex_types", "init", ["ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ"]},
      {"__call" "init", []},
-     {"bitcoin_auth", "authorize", ["1", "#0102030405060708090a0b0c0d0e0f101718192021222324252627282930313233343536373839401a1b1c1d1e1f20212223242526272829303132333435363738"]},
+     {"bitcoin_auth", "authorize", ["1", "#0102030405060708090a0b0c0d0e0f101718192021222324252627282930313233343536373839401a1b1c1d1e1f202122232425262728293031323334353637"]},
      {"bitcoin_auth", "to_sign", ["#0102030405060708090a0b0c0d0e0f1017181920212223242526272829303132", "2"]},
      {"stub", "foo", ["42"]},
-     {"stub", "foo", ["-42"]},
-     {"payable", "foo", ["42"]}
+     {"stub", "foo", ["-42"]}
     ].
 
 not_yet_compilable(fate) ->

test/aeso_compiler_tests.erl

@@ -12,14 +12,6 @@
 
 -include_lib("eunit/include/eunit.hrl").
 
-run_test(Test) ->
-    TestFun = list_to_atom(lists:concat([Test, "_test_"])),
-    [ begin
-          io:format("~s\n", [Label]),
-          Fun()
-      end || {Label, Fun} <- ?MODULE:TestFun() ],
-    ok.
-
 %%  Very simply test compile the given contracts. Only basic checks
 %%  are made on the output, just that it is a binary which indicates
 %%  that the compilation worked.
@@ -40,34 +32,16 @@ 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() ->
-           Errors = compile(aevm, ContractName),
-           check_errors(ExpectedErrors, Errors)
+            case compile(aevm, ContractName) of
+                <<"Type errors\n", ErrorString/binary>> ->
+                    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(
@@ -79,25 +53,19 @@ simple_compile_test_() ->
             #{byte_code := Code2} = compile(aevm, "include"),
             ?assertMatch(true, Code1 == Code2)
         end} ] ++
-    [ {"Testing deadcode elimination for " ++ atom_to_list(Backend),
+     [ {"Testing deadcode elimination",
         fun() ->
-           #{ byte_code := NoDeadCode } = compile(Backend, "nodeadcode"),
-           #{ byte_code := DeadCode   } = compile(Backend, "deadcode"),
+            #{ byte_code := NoDeadCode } = compile(aevm, "nodeadcode"),
+            #{ byte_code := DeadCode   } = compile(aevm, "deadcode"),
             SizeNoDeadCode = byte_size(NoDeadCode),
             SizeDeadCode   = byte_size(DeadCode),
-           Delta          = if Backend == aevm -> 40;
-                               Backend == fate -> 20 end,
-           ?assertMatch({_, _, true}, {SizeDeadCode, SizeNoDeadCode, SizeDeadCode + Delta < SizeNoDeadCode}),
+            ?assertMatch({_, _, true}, {SizeDeadCode, SizeNoDeadCode, SizeDeadCode + 40 < SizeNoDeadCode}),
             ok
-       end} || Backend <- [aevm, fate] ] ++
-    [].
+        end} ].
 
-check_errors(no_error, Actual) -> ?assertMatch(#{}, Actual);
-check_errors(Expect, #{}) ->
-    ?assertEqual({error, Expect}, ok);
-check_errors(Expect0, Actual0) ->
-    Expect = lists:sort(Expect0),
-    Actual = [ list_to_binary(string:trim(aeso_errors:pp(Err))) || Err <- Actual0 ],
+check_errors(Expect, ErrorString) ->
+    %% This removes the final single \n as well.
+    Actual = binary:split(<<ErrorString/binary,$\n>>, <<"\n\n">>, [global,trim]),
     case {Expect -- Actual, Actual -- Expect} of
         {[], Extra}   -> ?assertMatch({unexpected, []}, {unexpected, Extra});
         {Missing, []} -> ?assertMatch({missing, []}, {missing, Missing});
@@ -105,15 +73,13 @@ check_errors(Expect0, Actual0) ->
     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 ++ ".aes"}, {backend, Backend} | Options]) of
+    case aeso_compiler:from_string(String, [{src_file, Name}, {backend, Backend} | Options]) of
         {ok, Map}            -> Map;
-        {error, ErrorString} when is_binary(ErrorString) -> ErrorString;
-        {error, Errors}                                  -> Errors
+        {error, ErrorString} -> ErrorString
     end.
 
 %% compilable_contracts() -> [ContractName].
@@ -138,7 +104,6 @@ compilable_contracts() ->
      "test",
      "builtin_bug",
      "builtin_map_get_bug",
-     "lc_record_bug",
      "nodeadcode",
      "deadcode",
      "variant_types",
@@ -152,20 +117,8 @@ compilable_contracts() ->
      "address_chain",
      "namespace_bug",
      "bytes_to_x",
-     "bytes_concat",
      "aens",
-     "tuple_match",
-     "cyclic_include",
-     "stdlib_include",
-     "double_include",
-     "manual_stdlib_include",
-     "list_comp",
-     "payable",
-     "unapplied_builtins",
-     "underscore_number_literals",
-     "qualified_constructor",
-     "let_patterns",
-     "lhs_matching"
+     "tuple_match"
     ].
 
 not_yet_compilable(fate) -> [];
@@ -173,609 +126,232 @@ 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() ->
-    {ok, V} = aeso_compiler:numeric_version(),
-    Version = list_to_binary(string:join([integer_to_list(N) || N <- V], ".")),
-    %% Parse errors
-    [ ?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"
+    [ {"name_clash",
+       [<<"Duplicate definitions of abort at\n"
           "  - (builtin location)\n"
           "  - line 14, column 3">>,
-        <<?Pos(15, 3)
-          "Duplicate definitions of require at\n"
+        <<"Duplicate definitions of require at\n"
           "  - (builtin location)\n"
           "  - line 15, column 3">>,
-        <<?Pos(11, 3)
-          "Duplicate definitions of double_def at\n"
+        <<"Duplicate definitions of double_def at\n"
           "  - line 10, column 3\n"
           "  - line 11, column 3">>,
-        <<?Pos(5, 3)
-          "Duplicate definitions of double_proto at\n"
+        <<"Duplicate definitions of double_proto at\n"
           "  - line 4, column 3\n"
           "  - line 5, column 3">>,
-        <<?Pos(8, 3)
-          "Duplicate definitions of proto_and_def at\n"
+        <<"Duplicate definitions of proto_and_def at\n"
           "  - line 7, column 3\n"
           "  - line 8, column 3">>,
-        <<?Pos(16, 3)
-          "Duplicate definitions of put at\n"
+        <<"Duplicate definitions of put at\n"
           "  - (builtin location)\n"
           "  - line 16, column 3">>,
-        <<?Pos(17, 3)
-          "Duplicate definitions of state at\n"
+        <<"Duplicate definitions of state at\n"
           "  - (builtin location)\n"
-          "  - line 17, column 3">>])
-    , ?TYPE_ERROR(type_errors,
-       [<<?Pos(17, 23)
-          "Unbound variable zz at line 17, column 23">>,
-        <<?Pos(26, 9)
-          "Cannot unify int\n"
+          "  - line 17, column 3">>]}
+    , {"type_errors",
+       [<<"Unbound variable zz at line 17, column 23">>,
+        <<"Cannot unify int\n"
           "         and list(int)\n"
           "when checking the application at line 26, column 9 of\n"
           "  (::) : (int, list(int)) => list(int)\n"
           "to arguments\n"
           "  x : int\n"
           "  x : int">>,
-        <<?Pos(9, 48)
-          "Cannot unify string\n"
+        <<"Cannot unify string\n"
           "         and int\n"
           "when checking the assignment of the field\n"
           "  x : map(string, string) (at line 9, column 48)\n"
           "to the old value __x and the new value\n"
           "  __x {[\"foo\"] @ x = x + 1} : map(string, int)">>,
-        <<?Pos(34, 47)
-          "Cannot unify int\n"
+        <<"Cannot unify int\n"
           "         and string\n"
           "when checking the type of the expression at line 34, column 47\n"
           "  1 : int\n"
           "against the expected type\n"
           "  string">>,
-        <<?Pos(34, 52)
-          "Cannot unify string\n"
+        <<"Cannot unify string\n"
           "         and int\n"
           "when checking the type of the expression at line 34, column 52\n"
           "  \"bla\" : string\n"
           "against the expected type\n"
           "  int">>,
-        <<?Pos(32, 18)
-          "Cannot unify string\n"
+        <<"Cannot unify string\n"
           "         and int\n"
           "when checking the type of the expression at line 32, column 18\n"
           "  \"x\" : string\n"
           "against the expected type\n"
           "  int">>,
-        <<?Pos(11, 58)
-          "Cannot unify string\n"
+        <<"Cannot unify string\n"
           "         and int\n"
           "when checking the type of the expression at line 11, column 58\n"
           "  \"foo\" : string\n"
           "against the expected type\n"
           "  int">>,
-        <<?Pos(38, 13)
-          "Cannot unify int\n"
+        <<"Cannot unify int\n"
           "         and string\n"
           "when comparing the types of the if-branches\n"
           "  - w : int (at line 38, column 13)\n"
           "  - z : string (at line 39, column 10)">>,
-        <<?Pos(22, 40)
-          "Not a record type: string\n"
+        <<"Not a record type: string\n"
           "arising from the projection of the field y (at line 22, column 40)">>,
-        <<?Pos(21, 44)
-          "Not a record type: string\n"
+        <<"Not a record type: string\n"
           "arising from an assignment of the field y (at line 21, column 44)">>,
-        <<?Pos(20, 40)
-          "Not a record type: string\n"
+        <<"Not a record type: string\n"
           "arising from an assignment of the field y (at line 20, column 40)">>,
-        <<?Pos(19, 37)
-          "Not a record type: string\n"
+        <<"Not a record type: string\n"
           "arising from an assignment of the field y (at line 19, column 37)">>,
-        <<?Pos(13, 27)
-          "Ambiguous record type with field y (at line 13, column 27) could be one of\n"
+        <<"Ambiguous record type with field y (at line 13, column 27) could be one of\n"
           "  - r (at line 4, column 10)\n"
           "  - r' (at line 5, column 10)">>,
-        <<?Pos(26, 7)
-          "Repeated name x in pattern\n"
+        <<"Repeated name x in pattern\n"
           "  x :: x (at line 26, column 7)">>,
-        <<?Pos(44, 14)
-          "Repeated names x, y in pattern\n"
-          "  (x : int, y, x : string, y : bool) (at line 44, column 14)">>,
-        <<?Pos(44, 39)
-          "Cannot unify int\n"
-          "         and string\n"
-          "when checking the type of the expression at line 44, column 39\n"
-          "  x : int\n"
-          "against the expected type\n"
-          "  string">>,
-        <<?Pos(44, 72)
-          "Cannot unify int\n"
-          "         and string\n"
-          "when checking the type of the expression at line 44, column 72\n"
-          "  x : int\n"
-          "against the expected type\n"
-          "  string">>,
-        <<?Pos(14, 24)
-          "No record type with fields y, z (at line 14, column 24)">>,
-        <<?Pos(15, 26)
-          "The field z is missing when constructing an element of type r2 (at line 15, column 26)">>,
-        <<?Pos(15, 24)
-          "Record type r2 does not have field y (at line 15, column 24)">>,
-        <<?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">>,
-        <<?Pos(63, 5)
-          "Cannot unify int\n"
-          "         and bool\n"
-          "when checking the type of the expression at line 63, column 5\n"
-          "  id(n) : int\n"
-          "against the expected type\n"
-          "  bool">>])
-    , ?TYPE_ERROR(init_type_error,
-       [<<?Pos(7, 3)
-          "Cannot unify string\n"
+        <<"Repeated argument x to function repeated_arg (at line 44, column 14).">>,
+        <<"Repeated argument y to function repeated_arg (at line 44, column 14).">>,
+        <<"No record type with fields y, z (at line 14, column 24)">>,
+        <<"The field z is missing when constructing an element of type r2 (at line 15, column 26)">>,
+        <<"Record type r2 does not have field y (at line 15, column 24)">>,
+        <<"Let binding at line 47, column 5 must be followed by an expression">>,
+        <<"Let binding at line 50, column 5 must be followed by an expression">>,
+        <<"Let binding at line 54, column 5 must be followed by an expression">>,
+        <<"Let binding at line 58, column 5 must be followed by an expression">>]}
+    , {"init_type_error",
+       [<<"Cannot unify string\n"
           "         and map(int, int)\n"
-          "when checking that 'init' returns a value of type 'state' at line 7, column 3">>])
-    , ?TYPE_ERROR(missing_state_type,
-       [<<?Pos(5, 3)
-          "Cannot unify string\n"
+          "when checking that 'init' returns a value of type 'state' at line 7, column 3">>]}
+    , {"missing_state_type",
+       [<<"Cannot unify string\n"
           "         and unit\n"
-          "when checking that 'init' returns a value of type 'state' at line 5, column 3">>])
-    , ?TYPE_ERROR(missing_fields_in_record_expression,
-       [<<?Pos(7, 42)
-          "The field x is missing when constructing an element of type r('a) (at line 7, column 42)">>,
-        <<?Pos(8, 42)
-          "The field y is missing when constructing an element of type r(int) (at line 8, column 42)">>,
-        <<?Pos(6, 42)
-          "The fields y, z are missing when constructing an element of type r('a) (at line 6, column 42)">>])
-    , ?TYPE_ERROR(namespace_clash,
-       [<<?Pos(4, 10)
-          "The contract Call (at line 4, column 10) has the same name as a namespace at (builtin location)">>])
-    , ?TYPE_ERROR(bad_events,
-        [<<?Pos(9, 25)
-           "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"
+          "when checking that 'init' returns a value of type 'state' at line 5, column 3">>]}
+    , {"missing_fields_in_record_expression",
+       [<<"The field x is missing when constructing an element of type r('a) (at line 7, column 42)">>,
+        <<"The field y is missing when constructing an element of type r(int) (at line 8, column 42)">>,
+        <<"The fields y, z are missing when constructing an element of type r('a) (at line 6, column 42)">>]}
+    , {"namespace_clash",
+       [<<"The contract Call (at line 4, column 10) has the same name as a namespace at (builtin location)">>]}
+    , {"bad_events",
+        [<<"The indexed type string (at line 9, column 25) is not a word type">>,
+         <<"The indexed type alias_string (at line 10, column 25) equals string which is not a word type">>]}
+    , {"bad_events2",
+        [<<"The event constructor BadEvent1 (at line 9, column 7) has too many non-indexed values (max 1)">>,
+         <<"The event constructor BadEvent2 (at line 10, column 7) has too many indexed values (max 3)">>]}
+    , {"type_clash",
+        [<<"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)">>])
-    , ?TYPE_ERROR(bad_include_and_ns,
-        [<<?Pos(2, 11)
-           "Include of 'included.aes' at line 2, column 11\nnot allowed, include only allowed at top level.">>,
-         <<?Pos(3, 13)
-           "Nested namespace not allowed\nNamespace 'Foo' at line 3, column 13 not defined at top level.">>])
-    , ?TYPE_ERROR(bad_address_literals,
-        [<<?Pos(11, 5)
-           "Cannot unify address\n"
+           "  (gas : int, value : int) => map(string, int)">>]}
+    , {"bad_include_and_ns",
+        [<<"Include of 'included.aes' at line 2, column 11\nnot allowed, include only allowed at top level.">>,
+         <<"Nested namespace not allowed\nNamespace 'Foo' at line 3, column 13 not defined at top level.">>]}
+    , {"bad_address_literals",
+        [<<"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"
+           "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"
+           "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"
+           "         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"
+           "         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"
+           "         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"
+           "         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"
+           "         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"
+           "         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"
            "         and oracle(int, bool)\n"
            "when checking the type of the expression at line 11, column 5\n"
            "  ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt : address\n"
            "against the expected type\n"
            "  oracle(int, bool)">>,
-         <<?Pos(9, 5)
-           "Cannot unify address\n"
+         <<"Cannot unify address\n"
            "         and Remote\n"
            "when checking the type of the expression at line 9, column 5\n"
            "  ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt : address\n"
            "against the expected type\n"
            "  Remote">>,
-         <<?Pos(7, 5)
-           "Cannot unify address\n"
+         <<"Cannot unify address\n"
            "         and bytes(32)\n"
            "when checking the type of the expression at line 7, column 5\n"
            "  ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt : address\n"
            "against the expected type\n"
-           "  bytes(32)">>,
-         <<?Pos(14, 5)
-           "Cannot unify oracle('a, 'b)\n"
-           "         and oracle_query(int, bool)\n"
-           "when checking the type of the expression at line 14, column 5\n"
-           "  ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5 :\n"
-           "    oracle('a, 'b)\n"
-           "against the expected type\n"
-           "  oracle_query(int, bool)">>,
-         <<?Pos(16, 5)
-           "Cannot unify oracle('c, 'd)\n"
-           "         and bytes(32)\n"
-           "when checking the type of the expression at line 16, column 5\n"
-           "  ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5 :\n"
-           "    oracle('c, 'd)\n"
-           "against the expected type\n"
-           "  bytes(32)">>,
-         <<?Pos(18, 5)
-           "Cannot unify oracle('e, 'f)\n"
-           "         and Remote\n"
-           "when checking the type of the expression at line 18, column 5\n"
-           "  ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5 :\n"
-           "    oracle('e, 'f)\n"
-           "against the expected type\n"
-           "  Remote">>,
-         <<?Pos(21, 5)
-           "Cannot unify oracle_query('g, 'h)\n"
-           "         and oracle(int, bool)\n"
-           "when checking the type of the expression at line 21, column 5\n"
-           "  oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY :\n"
-           "    oracle_query('g, 'h)\n"
-           "against the expected type\n"
-           "  oracle(int, bool)">>,
-         <<?Pos(23, 5)
-           "Cannot unify oracle_query('i, 'j)\n"
-           "         and bytes(32)\n"
-           "when checking the type of the expression at line 23, column 5\n"
-           "  oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY :\n"
-           "    oracle_query('i, 'j)\n"
-           "against the expected type\n"
-           "  bytes(32)">>,
-         <<?Pos(25, 5)
-           "Cannot unify oracle_query('k, 'l)\n"
-           "         and Remote\n"
-           "when checking the type of the expression at line 25, column 5\n"
-           "  oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY :\n"
-           "    oracle_query('k, 'l)\n"
-           "against the expected type\n"
-           "  Remote">>,
-         <<?Pos(28, 5)
-           "The type address is not a contract type\n"
-           "when checking that the contract literal\n"
-           "  ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ\n"
-           "has the type\n"
-           "  address">>,
-         <<?Pos(30, 5)
-           "The type oracle(int, bool) is not a contract type\n"
-           "when checking that the contract literal\n"
-           "  ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ\n"
-           "has the type\n"
-           "  oracle(int, bool)">>,
-         <<?Pos(32, 5)
-           "The type bytes(32) is not a contract type\n"
-           "when checking that the contract literal\n"
-           "  ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ\n"
-           "has the type\n"
-           "  bytes(32)">>,
-         <<?Pos(34, 5),
-           "The type address is not a contract type\n"
-           "when checking that the call to\n"
-           "  Address.to_contract\n"
-           "has the type\n"
-           "  address">>])
-    , ?TYPE_ERROR(stateful,
-       [<<?Pos(13, 35)
-          "Cannot reference stateful function Chain.spend (at line 13, column 35)\nin the definition of non-stateful function fail1.">>,
-        <<?Pos(14, 35)
-          "Cannot reference stateful function local_spend (at line 14, column 35)\nin the definition of non-stateful function fail2.">>,
-        <<?Pos(16, 15)
-          "Cannot reference stateful function Chain.spend (at line 16, column 15)\nin the definition of non-stateful function fail3.">>,
-        <<?Pos(20, 31)
-          "Cannot reference stateful function Chain.spend (at line 20, column 31)\nin the definition of non-stateful function fail4.">>,
-        <<?Pos(35, 47)
-          "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"
+           "  bytes(32)">>]}
+    , {"stateful",
+       [<<"Cannot reference stateful function Chain.spend (at line 13, column 35)\nin the definition of non-stateful function fail1.">>,
+        <<"Cannot reference stateful function local_spend (at line 14, column 35)\nin the definition of non-stateful function fail2.">>,
+        <<"Cannot reference stateful function Chain.spend (at line 16, column 15)\nin the definition of non-stateful function fail3.">>,
+        <<"Cannot reference stateful function Chain.spend (at line 20, column 31)\nin the definition of non-stateful function fail4.">>,
+        <<"Cannot reference stateful function Chain.spend (at line 35, column 47)\nin the definition of non-stateful function fail5.">>,
+        <<"Cannot pass non-zero value argument 1000 (at line 48, column 57)\nin the definition of non-stateful function fail6.">>,
+        <<"Cannot pass non-zero value argument 1000 (at line 49, column 56)\nin the definition of non-stateful function fail7.">>,
+        <<"Cannot pass non-zero value argument 1000 (at line 52, column 17)\nin the definition of non-stateful function fail8.">>]}
+    , {"bad_init_state_access",
+       [<<"The init function should return the initial state as its result and cannot write the state,\n"
           "but it calls\n"
           "  - set_state (at line 11, column 5), which calls\n"
           "  - roundabout (at line 8, column 38), which calls\n"
           "  - put (at line 7, column 39)">>,
-        <<?Pos(12, 5)
-          "The init function should return the initial state as its result and cannot read the state,\n"
+        <<"The init function should return the initial state as its result and cannot read the state,\n"
           "but it calls\n"
           "  - new_state (at line 12, column 5), which calls\n"
           "  - state (at line 5, column 29)">>,
-        <<?Pos(13, 13)
-          "The init function should return the initial state as its result and cannot read the state,\n"
+        <<"The init function should return the initial state as its result and cannot read the state,\n"
           "but it calls\n"
-          "  - state (at line 13, column 13)">>])
-    , ?TYPE_ERROR(modifier_checks,
-       [<<?Pos(11, 3)
-          "The function all_the_things (at line 11, column 3) cannot be both public and private.">>,
-        <<?Pos(3, 3)
-          "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'.">>,
-        <<?Pos(12, 3)
-          "The entrypoint wha (at line 12, column 3) cannot be private. Use 'function' instead.">>,
-        <<?Pos(6, 3)
-          "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 12, column 25)\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 18, column 37)">>])
-    , ?TYPE_ERROR(wrong_compiler_version,
-        [<<?Pos(1, 1)
-           "Cannot compile with this version of the compiler,\n"
-           "because it does not satisfy the constraint ", Version/binary, " < 1.0">>,
-         <<?Pos(2, 1)
-           "Cannot compile with this version of the compiler,\n"
-           "because it does not satisfy the constraint ", Version/binary, " == 9.9.9">>])
-    , ?TYPE_ERROR(multiple_contracts,
-         [<<?Pos(2, 3)
-            "Only the main contract can contain defined functions or entrypoints.\n"
-            "Fix: replace the definition of 'foo' by a type signature.">>])
-    , ?TYPE_ERROR(contract_as_namespace,
-         [<<?Pos(5, 28)
-            "Invalid call to contract entrypoint 'Foo.foo'.\n"
-            "It must be called as 'c.foo' for some c : Foo.">>])
-    , ?TYPE_ERROR(bad_records,
-        [<<?Pos(3, 16)
-           "Mixed record fields and map keys in\n"
-           "  {x = 0, [0] = 1}">>,
-         <<?Pos(4, 6)
-           "Mixed record fields and map keys in\n"
-           "  r {x = 0, [0] = 1}">>,
-         <<?Pos(5, 6)
-           "Empty record/map update\n"
-           "  r {}">>
-        ])
+          "  - state (at line 13, column 13)">>]}
+    , {"field_parse_error",
+       [<<"line 6, column 1: In field_parse_error at 5:26:\n"
+          "Cannot use nested fields or keys in record construction: p.x\n">>]}
+    , {"modifier_checks",
+       [<<"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.">>,
+        <<"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.">>,
+        <<"Use 'entrypoint' for declaration of foo (at line 6, column 3):\n  entrypoint foo : () => unit">>,
+        <<"Use 'entrypoint' instead of 'function' for public function foo (at line 10, column 3):\n  entrypoint foo() = ()">>,
+        <<"Use 'entrypoint' instead of 'function' for public function foo (at line 6, column 3):\n  entrypoint foo : () => unit">>]}
     ].
-
--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.")
-    ].
-
-validation_test_() ->
-    [{"Validation fail: " ++ C1 ++ " /= " ++ C2,
-      fun() ->
-        Actual = case validate(C1, C2) of
-                    {error, Errs} -> Errs;
-                    ok -> #{}
-                 end,
-        check_errors(Expect, Actual)
-      end} || {C1, C2, Expect} <- validation_fails()] ++
-    [{"Validation of " ++ C,
-      fun() ->
-        ?assertEqual(ok, validate(C, C))
-      end} || C <- compilable_contracts()].
-
-validation_fails() ->
-    [{"deadcode", "nodeadcode",
-      [<<"Data error:\n"
-         "Byte code does not match source code.\n"
-         "- Functions in the source code but not in the byte code:\n"
-         "    .MyList.map2">>]},
-     {"validation_test1", "validation_test2",
-      [<<"Data error:\n"
-         "Byte code does not match source code.\n"
-         "- The implementation of the function code_fail is different.\n"
-         "- The attributes of the function attr_fail differ:\n"
-         "    Byte code:   payable\n"
-         "    Source code: \n"
-         "- The type of the function type_fail differs:\n"
-         "    Byte code:   integer => integer\n"
-         "    Source code: {tvar,0} => {tvar,0}">>]},
-     {"validation_test1", "validation_test3",
-      [<<"Data error:\n"
-         "Byte code contract is not payable, but source code contract is.">>]}].
-
-validate(Contract1, Contract2) ->
-    ByteCode = #{ fate_code := FCode } = compile(fate, Contract1),
-    FCode1   = aeb_fate_code:serialize(aeb_fate_code:strip_init_function(FCode)),
-    Source   = aeso_test_utils:read_contract(Contract2),
-    aeso_compiler:validate_byte_code(ByteCode#{ byte_code := FCode1 }, Source,
-                                     [{backend, fate}, {include, {file_system, [aeso_test_utils:contract_path()]}}]).
-

test/aeso_parser_tests.erl

@@ -4,8 +4,6 @@
 
 -include_lib("eunit/include/eunit.hrl").
 
-id(X) -> X.
-
 simple_contracts_test_() ->
     {foreach,
      fun() -> ok end,
@@ -16,7 +14,7 @@ simple_contracts_test_() ->
                    "  function id(x) = x\n",
             ?assertMatch(
                 [{contract, _, {con, _, "Identity"},
-                    [{letfun, _, {id, _, "id"}, [{id, _, "x"}], {id, _, "_"},
+                    [{letfun, _, {id, _, "id"}, [{arg, _, {id, _, "x"}, {id, _, "_"}}], {id, _, "_"},
                         {id, _, "x"}}]}], parse_string(Text)),
             ok
        end},
@@ -32,7 +30,7 @@ simple_contracts_test_() ->
                     end,
             Parse = fun(S) ->
                     try remove_line_numbers(parse_expr(S))
-                    catch _:_ -> ?assertMatch(ok, id({parse_fail, S})) end
+                    catch _:_ -> ?assertMatch(ok, {parse_fail, S}) end
                 end,
             CheckParens = fun(Expr) ->
                     ?assertEqual(Parse(NoPar(Expr)), Parse(Par(Expr)))
@@ -40,7 +38,8 @@ simple_contracts_test_() ->
             LeftAssoc  = fun(Op) -> CheckParens({{a, Op, b}, Op, c}) end,
             RightAssoc = fun(Op) -> CheckParens({a, Op, {b, Op, c}}) end,
             NonAssoc   = fun(Op) ->
-                            ?assertThrow({error, [_]},
+                            OpAtom = list_to_atom(Op),
+                            ?assertError({error, {_, parse_error, _}},
                                          parse_expr(NoPar({a, Op, {b, Op, c}}))) end,
             Stronger = fun(Op1, Op2) ->
                     CheckParens({{a, Op1, b}, Op2, c}),
@@ -72,28 +71,25 @@ parse_contract(Name) ->
 roundtrip_contract(Name) ->
     round_trip(aeso_test_utils:read_contract(Name)).
 
-parse_string(Text) -> parse_string(Text, []).
-
-parse_string(Text, Opts) ->
-    aeso_parser:string(Text, Opts).
+parse_string(Text) ->
+    case aeso_parser:string(Text) of
+        {ok, Contract} -> Contract;
+        Err -> error(Err)
+    end.
 
 parse_expr(Text) ->
-    [{letval, _, _, Expr}] =
+    [{letval, _, _, _, Expr}] =
         parse_string("let _ = " ++ Text),
     Expr.
 
 round_trip(Text) ->
     Contract  = parse_string(Text),
-    Text1     = prettypr:format(aeso_pretty:decls(strip_stdlib(Contract))),
+    Text1     = prettypr:format(aeso_pretty:decls(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/address_chain.aes

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

test/contracts/address_literals.aes

@@ -11,6 +11,4 @@ contract AddressLiterals =
     oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY
   entrypoint contr() : Remote =
     ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ
-  entrypoint contr_addr() : Remote =
-    Address.to_contract(addr())
 

test/contracts/bad_address_literals.aes

@@ -30,6 +30,4 @@ contract AddressLiterals =
     ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ
   entrypoint contr3() : bytes(32) =
     ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ
-  entrypoint contr4() : address =
-    Address.to_contract(Contract.address)
 

test/contracts/bad_bytes_concat.aes

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

test/contracts/bad_bytes_split.aes

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

test/contracts/bad_records.aes

@@ -1,5 +0,0 @@
-contract BadRecord =
-  entrypoint foo() =
-    let r = {x = 0, [0] = 1}
-    r{x = 0, [0] = 1}
-    r{}

test/contracts/bad_top_level_decl.aes

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

test/contracts/basic_auth.aes

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

test/contracts/bitcoin_auth.aes

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

test/contracts/bytes_concat.aes

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

test/contracts/calling_init_function.aes

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

test/contracts/code_errors/bad_aens_resolve.aes

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

test/contracts/code_errors/complex_compare.aes

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

test/contracts/code_errors/complex_compare_leq.aes

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

test/contracts/code_errors/higher_order_compare.aes

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

test/contracts/code_errors/higher_order_entrypoint.aes

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

test/contracts/code_errors/higher_order_entrypoint_return.aes

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

test/contracts/code_errors/higher_order_map_keys.aes

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

test/contracts/code_errors/higher_order_query_type.aes

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

test/contracts/code_errors/higher_order_response_type.aes

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

test/contracts/code_errors/higher_order_state.aes

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

test/contracts/code_errors/last_declaration_must_be_contract.aes

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

test/contracts/code_errors/missing_definition.aes

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

test/contracts/code_errors/missing_init_function.aes

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

test/contracts/code_errors/parameterised_event.aes

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

test/contracts/code_errors/parameterised_state.aes

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

test/contracts/code_errors/polymorphic_aens_resolve.aes

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

test/contracts/code_errors/polymorphic_compare.aes

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

test/contracts/code_errors/polymorphic_entrypoint.aes

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

test/contracts/code_errors/polymorphic_entrypoint_return.aes

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

test/contracts/code_errors/polymorphic_map_keys.aes

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

test/contracts/code_errors/polymorphic_query_type.aes

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

test/contracts/code_errors/polymorphic_response_type.aes

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

test/contracts/code_errors/unapplied_contract_call.aes

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

test/contracts/code_errors/unapplied_named_arg_builtin.aes

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

test/contracts/complex_types.aes

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

test/contracts/contract_as_namespace.aes

@@ -1,6 +0,0 @@
-contract Foo =
-  entrypoint foo : () => int
-
-contract Fail =
-  entrypoint bad() : int = Foo.foo()
-

test/contracts/cyclic_include.aes

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

test/contracts/cyclic_include_back.aes

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

test/contracts/cyclic_include_forth.aes

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

test/contracts/deadcode.aes

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

test/contracts/double_include.aes

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

test/contracts/factorial.aes

@@ -11,7 +11,7 @@ contract Factorial =
 
   stateful entrypoint set_worker(worker) = put(state{worker = worker})
 
-  entrypoint
-    fac : int => int
-    fac(0) = 1
-    fac(x) = x * state.worker.fac(x - 1)
+  entrypoint fac(x : int) : int =
+    if(x == 0) 1
+    else x * state.worker.fac(x - 1)
+

test/contracts/indent_fail.aes

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

test/contracts/lc_record_bug.aes

@@ -1,4 +0,0 @@
-contract Foo =
-  record r = {x : int}
-  // Crashed in the backend due to missing type annotation on the lc body.
-  entrypoint lc(xs) = [ {x = x} | x <- xs ]

test/contracts/let_patterns.aes

@@ -1,15 +0,0 @@
-contract LetPatterns =
-
-  record r = {x : int, y : int, b : bool}
-
-  entrypoint test() = foo([1, 0], (2, 3), Some(4), {x = 5, y = 6, b = false})
-
-  entrypoint foo(xs : list(int), p : int * int, some : option(int), r : r) =
-    let x :: _  = xs
-    let (a, b)  = p
-    let Some(n) = some
-    let {x = i, y = j} = r
-    x + a + b + n + i + j
-
-  entrypoint lc(xs : list(option(int))) : list(int) =
-    [ x | Some(x) <- xs ]

test/contracts/lhs_matching.aes

@@ -1,22 +0,0 @@
-contract LHSMatching =
-
-  function from_some(Some(x)) = x
-
-  function
-    length : list('a) => int
-    length([])      = 0
-    length(_ :: xs) = 1 + length(xs)
-
-  function
-    append([], ys)      = ys
-    append(x :: xs, ys) = x :: append(xs, ys)
-
-  function local_match(xs : list('a)) =
-    let null([])     = true
-    let null(_ :: _) = false
-    !null(xs)
-
-  entrypoint main() =
-    from_some(Some([0]))
-      ++ append([length([true]), 2, 3], [4, 5, 6])
-      ++ [7 | if (local_match([false]))]

test/contracts/list_comp.aes

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

test/contracts/list_comp_bad_shadow.aes

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

test/contracts/list_comp_if_not_bool.aes

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

test/contracts/list_comp_not_a_list.aes

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

test/contracts/local_poly_fail.aes

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

test/contracts/manual_stdlib_include.aes

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

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

test/contracts/missing_event_type.aes

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

test/contracts/multi_sig.aes

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

test/contracts/multiple_contracts.aes

@@ -1,5 +0,0 @@
-contract ContractOne =
-  entrypoint foo() = "foo"
-
-contract ContractTwo =
-  entrypoint bar() = "bar"

test/contracts/nodeadcode.aes

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

test/contracts/payable.aes

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

test/contracts/qualified_constructor.aes

@@ -1,8 +0,0 @@
-namespace Foo =
-  datatype x = A | B(int)
-
-contract Bar =
-  entrypoint f(a : Foo.x) =
-    switch(a)
-      Foo.A     => 0
-      Foo.B(n)  => n

test/contracts/reason/voting.re

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

test/contracts/reason/voting_test.re

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

test/contracts/stack.aes

@@ -8,9 +8,10 @@ contract Stack =
 
   entrypoint init(ss : list(string)) = { stack = ss, size = length(ss) }
 
-  function
-    length([])      = 0
-    length(_ :: xs) = length(xs) + 1
+  function length(xs) =
+    switch(xs)
+      [] => 0
+      _ :: xs => length(xs) + 1
 
   stateful entrypoint pop() : string =
     switch(state.stack)

test/contracts/stdlib_include.aes

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