Make 'return' a reserved (but invalid) keyword

CHANGELOG.md

@@ -9,71 +9,34 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 ### Removed
 
-## [4.3.0]
+## [4.0.0-rc4] - 2019-09-13
 ### Added
-- Added documentation (moved from `protocol`)
-- `Frac.aes` – library for rational numbers
-- Added some more meaningful error messages
-- Exported several parsing functionalities
- - With option `keep_included` it is possible to see which files were included during the parse
- - There is a function `run_parser` that be used to evaluate any parsing rule
- - Exported parsers: `body`, `type` and `decl`
-### Changed
-- Performance improvements in the standard library
-- Fixed ACI encoder to handle `-` unary operator
-- Fixed including by absolute path
-- Fixed variant type printing in the ACI error messages
-- Fixed pretty printing of combined function clauses
-### Removed
-- `let` definitions are no longer supported in the toplevel of the contract
-- type declarations are no longer supported
-
-## [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.
+### Changed
+### Removed
+
+## [4.0.0-rc3] - 2019-09-12
+### Added
 - `Bytes.concat` and `Bytes.split` are added to be able to
   (de-)construct byte arrays.
 - `[a..b]` language construct, returning the list of numbers between
   `a` and `b` (inclusive). Returns the empty list if `a` > `b`.
-- [Standard libraries](https://github.com/aeternity/aesophia/blob/master/docs/sophia_stdlib.md)
+- [Standard libraries] (https://github.com/aeternity/protocol/blob/master/contracts/sophia_stdlib.md)
 - Checks that `init` is not called from other functions.
+### Changed
+- Error messages are changed into a uniform format, and more helpful
+  messages have been added.
+- `Crypto.<hash_fun>` and `String.<hash_fun>` for byte arrays now only
+  hash the actual byte array - not the internal ABI format.
+- More strict checks for polymorphic oracles and higher order oracles
+  and entrypoints.
+- `AENS.claim` is updated with a `NameFee` field - to be able to do
+  name auctions within contracts.
+- Fixed a bug in `Bytes.to_str` for AEVM.
+### Removed
+
+## [4.0.0-rc1] - 2019-08-22
+### Added
 - FATE backend - the compiler is able to produce VM code for both `AEVM` and `FATE`. Many
   of the APIs now take `{backend, aevm | fate}` to decide wich backend to produce artifacts
   for.
@@ -90,20 +53,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   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,
@@ -211,11 +160,10 @@ 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.3.0...HEAD
-[4.3.0]: https://github.com/aeternity/aesophia/compare/v4.2.0...v4.3.0
-[4.2.0]: https://github.com/aeternity/aesophia/compare/v4.1.0...v4.2.0
-[4.1.0]: https://github.com/aeternity/aesophia/compare/v4.0.0...v4.1.0
-[4.0.0]: https://github.com/aeternity/aesophia/compare/v3.2.0...v4.0.0
+[Unreleased]: https://github.com/aeternity/aesophia/compare/v4.0.0-rc4...HEAD
+[4.0.0-rc4]: https://github.com/aeternity/aesophia/compare/v4.0.0-rc3...v4.0.0-rc4
+[4.0.0-rc3]: https://github.com/aeternity/aesophia/compare/v4.0.0-rc1...v4.0.0-rc3
+[4.0.0-rc1]: https://github.com/aeternity/aesophia/compare/v3.2.0...v4.0.0-rc1
 [3.2.0]: https://github.com/aeternity/aesophia/compare/v3.1.0...v3.2.0
 [3.1.0]: https://github.com/aeternity/aesophia/compare/v3.0.0...v3.1.0
 [3.0.0]: https://github.com/aeternity/aesophia/compare/v2.1.0...v3.0.0

README.md

@@ -1,17 +1,13 @@
 # aesophia
 
-This is the __sophia__ compiler for the æternity system which compiles contracts written in __sophia__ to [FATE](https://github.com/aeternity/protocol/blob/master/contracts/fate.md) instructions.
+This is the __sophia__ compiler for the æternity system which compiles contracts written in __sophia__ code to the æternity VM code.
 
-The compiler is currently being used three places
- - [The command line compiler](https://github.com/aeternity/aesophia_cli)
- - [The HTTP compiler](https://github.com/aeternity/aesophia_http)
- - In [Aeternity node](https://github.com/aeternity/aeternity) tests
+For more information about æternity smart contracts and the sophia language see [Smart Contracts](https://github.com/aeternity/protocol/blob/master/contracts/contracts.md) and the [Sophia Language](https://github.com/aeternity/protocol/blob/master/contracts/sophia.md).
 
-## Documentation
-
-* [Smart Contracts on aeternity Blockchain](https://github.com/aeternity/protocol/blob/master/contracts/contracts.md).
-* [Sophia Documentation](docs/sophia.md).
-* [Sophia Standard Library](docs/sophia_stdlib.md).
+It is an OTP application written in Erlang and is by default included in
+[the æternity node](https://github.com/aeternity/epoch). However, it can
+also be included in other systems to compile contracts coded in sophia which
+can then be loaded into the æternity system.
 
 ## Versioning
 

priv/stdlib/Frac.aes

@@ -1,183 +0,0 @@
-namespace Frac =
-
-  private function gcd(a : int, b : int) =
-    if (b == 0) a else gcd(b, a mod b)
-
-  private function abs_int(a : int) = if (a < 0) -a else a
-
-  datatype frac = Pos(int, int) | Zero | Neg(int, int)
-
-/** Checks if the internal representation is correct.
-  * Numerator and denominator must be positive.
-  * Exposed for debug purposes
-  */
-  function is_sane(f : frac) : bool = switch(f)
-    Pos(n, d) => n > 0 && d > 0
-    Zero => true
-    Neg(n, d) => n > 0 && d > 0
-
-  function num(f : frac) : int = switch(f)
-    Pos(n, _) => n
-    Neg(n, _) => -n
-    Zero      => 0
-
-  function den(f : frac) : int = switch(f)
-    Pos(_, d) => d
-    Neg(_, d) => d
-    Zero      => 1
-
-  function to_pair(f : frac) : int * int = switch(f)
-    Pos(n, d) => (n, d)
-    Neg(n, d) => (-n, d)
-    Zero      => (0, 1)
-
-  function sign(f : frac) : int = switch(f)
-    Pos(_, _) => 1
-    Neg(_, _) => -1
-    Zero      => 0
-
-  function to_str(f : frac) : string = switch(f)
-    Pos(n, d) => String.concat(Int.to_str(n), if (d == 1) "" else String.concat("/", Int.to_str(d)))
-    Neg(n, d) => String.concat("-", to_str(Pos(n, d)))
-    Zero      => "0"
-
-/** Reduce fraction to normal form
- */
-  function simplify(f : frac) : frac =
-    switch(f)
-      Neg(n, d) =>
-        let cd = gcd(n, d)
-        Neg(n / cd, d / cd)
-      Zero  => Zero
-      Pos(n, d)  =>
-        let cd = gcd(n, d)
-        Pos(n / cd, d / cd)
-
-/** Integer to rational division
- */
-  function make_frac(n : int, d : int) : frac =
-    if (d == 0) abort("Zero denominator")
-    elif (n == 0) Zero
-    elif ((n < 0) == (d < 0)) simplify(Pos(abs_int(n), abs_int(d)))
-    else simplify(Neg(abs_int(n), abs_int(d)))
-
-  function one() : frac = Pos(1, 1)
-  function zero() : frac = Zero
-
-  function eq(a : frac, b : frac) : bool =
-    let (na, da) = to_pair(a)
-    let (nb, db) = to_pair(b)
-    (na == nb && da == db) || na * db == nb * da // they are more likely to be normalized
-
-  function neq(a : frac, b : frac) : bool =
-    let (na, da) = to_pair(a)
-    let (nb, db) = to_pair(b)
-    (na != nb || da != db) && na * db != nb * da
-
-  function geq(a : frac, b : frac) : bool = num(a) * den(b) >= num(b) * den(a)
-
-  function leq(a : frac, b : frac) : bool = num(a) * den(b) =< num(b) * den(a)
-
-  function gt(a : frac, b : frac) : bool = num(a) * den(b) > num(b) * den(a)
-
-  function lt(a : frac, b : frac) : bool = num(a) * den(b) < num(b) * den(a)
-
-  function min(a : frac, b : frac) : frac = if (leq(a, b)) a else b 
-
-  function max(a : frac, b : frac) : frac = if (geq(a, b)) a else b 
-
-  function abs(f : frac) : frac = switch(f)
-    Pos(n, d) => Pos(n, d)
-    Zero      => Zero
-    Neg(n, d) => Pos(n, d)
-
-  function from_int(n : int) : frac =
-    if   (n > 0) Pos(n, 1)
-    elif (n < 0) Neg(-n, 1)
-    else Zero
-
-  function floor(f : frac) : int = switch(f)
-    Pos(n, d) => n / d
-    Zero      => 0
-    Neg(n, d) => -(n + d - 1) / d
-
-  function ceil(f : frac) : int = switch(f)
-    Pos(n, d) => (n + d - 1) / d
-    Zero      => 0
-    Neg(n, d) => -n / d
-  
-  function round_to_zero(f : frac) : int = switch(f)
-    Pos(n, d) => n / d
-    Zero      => 0
-    Neg(n, d) => -n / d
-
-  function round_from_zero(f : frac) : int = switch(f)
-    Pos(n, d) => (n + d - 1) / d
-    Zero      => 0
-    Neg(n, d) => -(n + d - 1) / d
-
-/** Round towards nearest integer. If two integers are in the same
- * distance, choose the even one.
- */
-  function round(f : frac) : int =
-    let fl = floor(f)
-    let cl = ceil(f)
-    let dif_fl = abs(sub(f, from_int(fl)))
-    let dif_cl = abs(sub(f, from_int(cl)))
-    if   (gt(dif_fl, dif_cl)) cl
-    elif (gt(dif_cl, dif_fl)) fl
-    elif (fl mod 2 == 0) fl
-    else cl
-
-  function add(a : frac, b : frac) : frac =
-    let (na, da) = to_pair(a)
-    let (nb, db) = to_pair(b)
-    if   (da == db) make_frac(na + nb, da)
-    else make_frac(na * db + nb * da, da * db)
-
-  function neg(a : frac) : frac = switch(a)
-    Neg(n, d) => Pos(n, d)
-    Zero      => Zero
-    Pos(n, d) => Neg(n, d)
-
-  function sub(a : frac, b : frac) : frac = add(a, neg(b))
-
-  function inv(a : frac) : frac = switch(a)
-    Neg(n, d) => Neg(d, n)
-    Zero      => abort("Inversion of zero")
-    Pos(n, d) => Pos(d, n)
-
-  function mul(a : frac, b : frac) : frac = make_frac(num(a) * num(b), den(a) * den(b))
-
-  function div(a : frac, b : frac) : frac = switch(b)
-    Neg(n, d) => mul(a, Neg(d, n))
-    Zero      => abort("Division by zero")
-    Pos(n, d) => mul(a, Pos(d, n))
-
-/** `b` to the power of `e`
- */
-  function int_exp(b : frac, e : int) : frac =
-    if (sign(b) == 0 && e == 0) abort("Zero to the zero exponentation")
-    elif (e < 0) inv(int_exp_(b, -e))
-    else int_exp_(b, e)
-  private function int_exp_(b : frac, e : int) =
-      if (e == 0) from_int(1)
-      elif (e == 1) b
-      else
-        let half = int_exp_(b, e / 2)
-        if (e mod 2 == 1) mul(mul(half, half), b)
-        else mul(half, half)
-
-/** Reduces the fraction's in-memory size by dividing its components by two until the
- * the error is bigger than `loss` value
- */
-  function optimize(f : frac, loss : frac) : frac =
-    require(geq(loss, Zero), "negative loss optimize")
-    let s = sign(f)
-    mul(from_int(s), run_optimize(abs(f), abs(f), loss))
-  private function run_optimize(orig : frac, f : frac, loss : frac) : frac =
-    let (n, d) = to_pair(f)
-    let t = make_frac((n+1)/2, (d+1)/2)
-    if(gt(abs(sub(t, orig)), loss)) f
-    elif (eq(t, f)) f
-    else run_optimize(orig, t, loss)

priv/stdlib/Func.aes

@@ -12,66 +12,35 @@ namespace Func =
 
   function rapply(x : 'a, f : 'a => 'b) : 'b = f(x)
 
-/** The Z combinator - replacement for local and anonymous recursion.
-  */
+  /* The Z combinator - replacement for local and anonymous recursion.
+   */
   function recur(f : ('arg => 'res, 'arg) => 'res) : 'arg => 'res =
     (x) => f(recur(f), x)
 
-/** n-times composition with itself
- */
   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))
 
-/** Turns an ugly, bad and disgusting arity-n function into
- * a beautiful and sweet function taking the first argument
- * and returning a function watiting for the remaining ones
- * in the same manner
- */
-  function curry2(f : ('a, 'b) => 'x) : 'a => ('b => 'x) =
+  function curry2(f : ('a, 'b) => 'c) : 'a => ('b => 'c) =
     (x) => (y) => f(x, y)
-  function curry3(f : ('a, 'b, 'c) => 'x) : 'a => ('b => ('c => 'x)) =
+  function curry3(f : ('a, 'b, 'c) => 'd) : 'a => ('b => ('c => 'd)) =
     (x) => (y) => (z) => f(x, y, z)
-  function curry4(f : ('a, 'b, 'c, 'd) => 'x) : 'a => ('b => ('c => ('d => 'x))) =
-    (x) => (y) => (z) => (w) => f(x, y, z, w)
-  function curry5(f : ('a, 'b, 'c, 'd, 'e) => 'x) : 'a => ('b => ('c => ('d => ('e => 'x)))) =
-    (x) => (y) => (z) => (w) => (q) => f(x, y, z, w, q)
 
-/** Opposite of curry. Gross
- */
-  function uncurry2(f : 'a => ('b => 'x)) : ('a, 'b) => 'x =
+  function uncurry2(f : 'a => ('b => 'c)) : ('a, 'b) => 'c =
     (x, y) => f(x)(y)
-  function uncurry3(f : 'a => ('b => ('c => 'x))) : ('a, 'b, 'c) => 'x =
+  function uncurry3(f : 'a => ('b => ('c => 'd))) : ('a, 'b, 'c) => 'd =
     (x, y, z) => f(x)(y)(z)
-  function uncurry4(f : 'a => ('b => ('c => ('d => 'x)))) : ('a, 'b, 'c, 'd) => 'x =
-    (x, y, z, w) => f(x)(y)(z)(w)
-  function uncurry5(f : 'a => ('b => ('c => ('d => ('e => 'x))))) : ('a, 'b, 'c, 'd, 'e) => 'x =
-    (x, y, z, w, q) => f(x)(y)(z)(w)(q)
 
-/** Turns an arity-n function into a function taking n-tuple
- */
-  function tuplify2(f : ('a, 'b) => 'x) : (('a * 'b)) => 'x =
+  function tuplify2(f : ('a, 'b) => 'c) : (('a * 'b)) => 'c =
     (t) => switch(t)
       (x, y) => f(x, y)
-  function tuplify3(f : ('a, 'b, 'c) => 'x) : 'a * 'b * 'c => 'x =
+  function tuplify3(f : ('a, 'b, 'c) => 'd) : 'a * 'b * 'c => 'd =
     (t) => switch(t)
       (x, y, z) => f(x, y, z)
-  function tuplify4(f : ('a, 'b, 'c, 'd) => 'x) : 'a * 'b * 'c * 'd => 'x =
-    (t) => switch(t)
-      (x, y, z, w) => f(x, y, z, w)
-  function tuplify5(f : ('a, 'b, 'c, 'd, 'e) => 'x) : 'a * 'b * 'c * 'd * 'e => 'x =
-    (t) => switch(t)
-      (x, y, z, w, q) => f(x, y, z, w, q)
 
-/** Opposite of tuplify
- */
-  function untuplify2(f : 'a * 'b => 'x) : ('a, 'b) => 'x =
+  function untuplify2(f : 'a * 'b => 'c) : ('a, 'b) => 'c =
     (x, y) => f((x, y))
-  function untuplify3(f : 'a * 'b * 'c => 'x) : ('a, 'b, 'c) => 'x =
+  function untuplify3(f : 'a * 'b * 'c => 'd) : ('a, 'b, 'c) => 'd =
     (x, y, z) => f((x, y, z))
-  function untuplify4(f : 'a * 'b * 'c * 'd => 'x) : ('a, 'b, 'c, 'd) => 'x =
-    (x, y, z, w) => f((x, y, z, w))
-  function untuplify5(f : 'a * 'b * 'c * 'd * 'e => 'x) : ('a, 'b, 'c, 'd, 'e) => 'x =
-    (x, y, z, w, q) => f((x, y, z, w, q))

priv/stdlib/List.aes

@@ -15,23 +15,14 @@ namespace List =
     _::t => Some(t)
 
   function last(l : list('a)) : option('a) = switch(l)
-    []   => None
-    [x]  => Some(x)
+    []  => None
+    [x] => Some(x)
     _::t => last(t)
 
-  function contains(e : 'a, l : list('a)) = switch(l)
-    []   => false
-    h::t => h == e || contains(e, t)
-
-/** Finds first element of `l` fulfilling predicate `p` as `Some` or `None`
- * if no such element exists.
- */
   function find(p : 'a => bool, l : list('a)) : option('a) = switch(l)
     []   => None
     h::t => if(p(h)) Some(h) else find(p, t)
 
-/** Returns list of all indices of elements from `l` that fulfill the predicate `p`.
- */
   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)
@@ -59,22 +50,14 @@ namespace List =
     _::t => length_(t, acc + 1)
 
 
-/** Creates an ascending sequence of all integer numbers
- * between `a` and `b` (including `a` and `b`)
- */
   function from_to(a : int, b : int) : list(int) = [a..b]
 
-/** Creates an ascending sequence of integer numbers betweeen
- * `a` and `b` jumping by given `step`. Includes `a` and takes
- * `b` only if `(b - a) mod step == 0`. `step` should be bigger than 0.
- */
   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
- */
+  /* 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) =
@@ -83,8 +66,7 @@ namespace List =
      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
- */
+  /* 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) =
@@ -93,9 +75,6 @@ namespace List =
      []   => abort("insert_at overflow")
      h::t => insert_at_(n-1, e, t, h::acc)
 
-/** Assuming that cmp represents `<` comparison, inserts `x` before
- * the first element in the list `l` which is greater than it
- */
   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) =
@@ -130,8 +109,6 @@ namespace List =
     []   => reverse(acc)
     h::t => map_(f, t, f(h)::acc)
 
-/** Effectively composition of `map` and `flatten`
- */
   function flat_map(f : 'a => list('b), l : list('a)) : list('b) =
     ListInternal.flat_map(f, l)
 
@@ -140,8 +117,7 @@ namespace List =
     []   => reverse(acc)
     h::t => filter_(p, t, if(p(h)) h::acc else acc)
 
-/** Take `n` first elements
- */
+  /* 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) =
@@ -150,8 +126,7 @@ namespace List =
       []   => reverse(acc)
       h::t => take_(n-1, t, h::acc)
 
-/** Drop `n` first elements
- */
+  /* 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
@@ -159,23 +134,18 @@ namespace List =
       []   => []
       h::t => drop(n-1, t)
 
-/** Get the longest prefix of a list in which every element
- * matches predicate `p`
- */
+  /* 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
- */
+  /* 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`
- */
+  /* 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)
@@ -185,8 +155,7 @@ namespace List =
     []   => (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)
 
-/** Flattens list of lists into a single list
- */
+
   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)
@@ -202,9 +171,7 @@ namespace List =
   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.
- */
+  /* 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)
@@ -214,8 +181,7 @@ namespace List =
     (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.
- */
+  /* 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, [], [])
@@ -227,70 +193,13 @@ namespace List =
     (left, right)::t => unzip_(t, left::acc_l, right::acc_r)
 
 
-  /** Merges two sorted lists using `lt` comparator
-   */
-  function
-    merge : (('a, 'a) => bool, list('a), list('a)) => list('a)
-    merge(lt, x::xs, y::ys) =
-      if(lt(x, y)) x::merge(lt, xs, y::ys)
-      else y::merge(lt, x::xs, ys)
-    merge(_, [], ys) = ys
-    merge(_, xs, []) = xs
+  // 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)
 
 
-  /** Mergesort inspired by
-   * https://hackage.haskell.org/package/base-4.14.1.0/docs/src/Data.OldList.html#sort
-   */
-  function
-    sort : (('a, 'a) => bool, list('a)) => list('a)
-    sort(_, []) = []
-    sort(lt, l) =
-      merge_all(lt, monotonic_subs(lt, l))
-
-  /** Splits list into compound increasing sublists
-   */
-  private function
-    monotonic_subs : (('a, 'a) => bool, list('a)) => list(list('a))
-    monotonic_subs(lt, x::y::rest) =
-      if(lt(y, x)) desc(lt, y, [x], rest)
-      else asc(lt, y, [x], rest)
-    monotonic_subs(_, l) = [l]
-
-  /** Extracts the longest descending prefix and proceeds with monotonic split
-   */
-  private function
-    desc : (('a, 'a) => bool, 'a, list('a), list('a)) => list(list('a))
-    desc(lt, x, acc, h::t) =
-      if(lt(x, h)) (x::acc) :: monotonic_subs(lt, h::t)
-      else desc(lt, h, x::acc, t)
-    desc(_, x, acc, []) = [x::acc]
-
-  /** Extracts the longest ascending prefix and proceeds with monotonic split
-   */
-  private function
-    asc : (('a, 'a) => bool, 'a, list('a), list('a)) => list(list('a))
-    asc(lt, x, acc, h::t) =
-      if(lt(h, x)) List.reverse(x::acc) :: monotonic_subs(lt, h::t)
-      else asc(lt, h, x::acc, t)
-    asc(_, x, acc, []) = [List.reverse(x::acc)]
-
-  /** Merges list of sorted lists
-   */
-  private function
-    merge_all : (('a, 'a) => bool, list(list('a))) => list('a)
-    merge_all(_, [part]) = part
-    merge_all(lt, parts) = merge_all(lt, merge_pairs(lt, parts))
-
-  /** Single round of `merge_all` – pairs of lists in a list of list
-   */
-  private function
-    merge_pairs : (('a, 'a) => bool, list(list('a))) => list(list('a))
-    merge_pairs(lt, x::y::rest) = merge(lt, x, y) :: merge_pairs(lt, rest)
-    merge_pairs(_, l) = l
-
-
-/** Puts `delim` between every two members of the list
- */
   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)
@@ -298,8 +207,6 @@ namespace List =
     h::t => intersperse_(delim, t, delim::h::acc)
 
 
-/** Effectively a zip with an infinite sequence of natural numbers
- */
   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)

priv/stdlib/Option.aes

@@ -10,23 +10,14 @@ namespace Option =
     None => false
     Some(_) => true
 
-/** Catamorphism on `option`. Also known as inlined pattern matching.
- */
+
   function match(n : 'b, s : 'a => 'b, o : option('a)) : 'b = switch(o)
     None => n
     Some(x) => s(x)
 
-/** Escape option providing default if `None`
- */
   function default(def : 'a, o : option('a)) : 'a = match(def, (x) => x, o)
 
-/** Assume it is `Some`
- */
-  function force(o : option('a)) : 'a = switch(o)
-    None    => abort("Forced None value")
-    Some(x) => x
-
-  function contains(e : 'a, o : option('a)) = o == Some(e)
+  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)
 
@@ -49,14 +40,10 @@ namespace Option =
     (Some(x1), Some(x2), Some(x3)) => Some(f(x1, x2, x3))
     _ => None
 
-/** Like `map`, but the function is in `option`
- */
   function app_over(f : option ('a => 'b), o : option('a)) : option('b) = switch((f, o))
     (Some(ff), Some(xx)) => Some(ff(xx))
     _ => None
 
-/** Monadic bind
- */
   function flat_map(f : 'a => option('b), o : option('a)) : option('b) = switch(o)
     None => None
     Some(x) => f(x)
@@ -66,31 +53,22 @@ namespace Option =
     None => []
     Some(x) => [x]
 
-/** Turns list of options into a list of elements that are under `Some`s.
- * Safe.
- */
   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)
 
-/** Just like `filter_options` but requires all elements to be `Some` and returns
- * None if any of them is not
- */
   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)
 
-/** Choose `Some` out of two if possible
- */
+
   function choose(o1 : option('a), o2 : option('a)) : option('a) =
     if(is_some(o1)) o1 else o2
 
-/** Choose `Some` from list of options if possible
- */
   function choose_first(l : list(option('a))) : option('a) = switch(l)
     [] => None
     None::t    => choose_first(t)

priv/stdlib/Pair.aes

@@ -6,18 +6,12 @@ namespace Pair =
   function snd(t : ('a * 'b)) : 'b = switch(t)
     (_, y) => y
 
-/** Map over first
- */
   function map1(f : 'a => 'c, t : ('a * 'b)) : ('c * 'b) = switch(t)
     (x, y) => (f(x), y)
 
-/** Map over second
- */
   function map2(f : 'b => 'c, t : ('a * 'b)) : ('a * 'c) = switch(t)
     (x, y) => (x, f(y))
 
-/** Map over both
- */
   function bimap(f : 'a => 'c, g : 'b => 'd, t : ('a * 'b)) : ('c * 'd) = switch(t)
     (x, y) => (f(x), g(y))
 

priv/stdlib/Triple.aes

@@ -10,23 +10,15 @@ namespace Triple =
     (_, _, z) => z
 
 
-/** Map over first
- */
   function map1(f : 'a => 'm, t : ('a * 'b * 'c)) : ('m * 'b * 'c) = switch(t)
     (x, y, z) => (f(x), y, z)
 
-/** Map over second
- */
   function map2(f : 'b => 'm, t : ('a * 'b * 'c)) : ('a * 'm * 'c) = switch(t)
     (x, y, z) => (x, f(y), z)
 
-/** Map over third
- */
   function map3(f : 'c => 'm, t : ('a * 'b * 'c)) : ('a * 'b * 'm) = switch(t)
     (x, y, z) => (x, y, f(z))
 
-/** Map over all elements
- */
   function trimap( f : 'a => 'x
                  , g : 'b => 'y
                  , h : 'c => 'z
@@ -37,13 +29,9 @@ namespace Triple =
   function swap(t : ('a * 'b * 'c)) : ('c * 'b * 'a) = switch(t)
     (x, y, z) => (z, y, x)
 
-/** Right rotation
- */
   function rotr(t : ('a * 'b * 'c)) : ('c * 'a * 'b) = switch(t)
     (x, y, z) => (z, x, y)
 
-/** Left rotation
- */
   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,"a66dc0a"}}}
        , {getopt, "1.0.1"}
        , {eblake2, "1.0.0"}
        , {jsx, {git, "https://github.com/talentdeficit/jsx.git",
@@ -15,7 +15,7 @@
             {base_plt_apps, [erts, kernel, stdlib, crypto, mnesia]}
            ]}.
 
-{relx, [{release, {aesophia, "4.3.0"},
+{relx, [{release, {aesophia, "4.0.0-rc4"},
          [aesophia, aebytecode, getopt]},
 
         {dev_mode, true},

rebar.lock

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

src/aeso_aci.erl

@@ -14,8 +14,6 @@
         , contract_interface/2
         , contract_interface/3
 
-        , from_typed_ast/2
-
         , render_aci_json/1
 
         , json_encode_expr/1
@@ -25,8 +23,6 @@
 -type json()      :: jsx:json_term().
 -type json_text() :: binary().
 
--export_type([aci_type/0]).
-
 %% External API
 -spec file(aci_type(), string()) -> {ok, json() | string()} | {error, term()}.
 file(Type, File) ->
@@ -69,20 +65,18 @@ do_contract_interface(Type, ContractString, Options) ->
     try
         Ast = aeso_compiler:parse(ContractString, Options),
         %% io:format("~p\n", [Ast]),
-        {TypedAst, _} = aeso_ast_infer_types:infer(Ast, [dont_unfold | Options]),
+        TypedAst = aeso_ast_infer_types:infer(Ast, [dont_unfold]),
         %% io:format("~p\n", [TypedAst]),
-        from_typed_ast(Type, TypedAst)
+        JArray = [ encode_contract(C) || C <- TypedAst ],
+
+        case Type of
+            json   -> {ok, JArray};
+            string -> do_render_aci_json(JArray)
+        end
     catch
         throw:{error, Errors} -> {error, Errors}
     end.
 
-from_typed_ast(Type, TypedAst) ->
-    JArray = [ encode_contract(C) || C <- TypedAst ],
-    case Type of
-        json   -> {ok, JArray};
-        string -> do_render_aci_json(JArray)
-    end.
-
 encode_contract(Contract = {contract, _, {con, _, Name}, _}) ->
     C0 = #{name => encode_name(Name)},
 
@@ -135,7 +129,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)}.
 
@@ -200,8 +194,6 @@ encode_expr({bytes, _, B})  ->
 encode_expr({Lit, _, L}) when Lit == oracle_pubkey; Lit == oracle_query_id;
                               Lit == contract_pubkey; Lit == account_pubkey ->
     aeser_api_encoder:encode(Lit, L);
-encode_expr({app, _, {'-', _}, [{int, _, N}]}) ->
-  encode_expr({int, [], -N});
 encode_expr({app, _, F, As}) ->
     Ef = encode_expr(F),
     Eas = encode_exprs(As),

src/aeso_ast_infer_types.erl

@@ -12,11 +12,7 @@
 
 -module(aeso_ast_infer_types).
 
--export([ infer/1
-        , infer/2
-        , unfold_types_in_type/3
-        , pp_type/2
-        ]).
+-export([infer/1, infer/2, unfold_types_in_type/3]).
 
 -type utype() :: {fun_t, aeso_syntax:ann(), named_args_t(), [utype()], utype()}
                | {app_t, aeso_syntax:ann(), utype(), [utype()]}
@@ -64,8 +60,7 @@
 
 -record(is_contract_constraint,
     { contract_t :: utype(),
-      context    :: {contract_literal, aeso_syntax:expr()} |
-                    {address_to_contract, aeso_syntax:ann()}
+      context    :: aeso_syntax:expr()  %% The address literal
     }).
 
 -type field_constraint() :: #field_constraint{} | #record_create_constraint{} | #is_contract_constraint{}.
@@ -88,7 +83,7 @@
 -type qname() :: [string()].
 -type typesig() :: {type_sig, aeso_syntax:ann(), type_constraints(), [aeso_syntax:named_arg_t()], [type()], type()}.
 
--type type_constraints() :: none | bytes_concat | bytes_split | address_to_contract.
+-type type_constraints() :: none | bytes_concat | bytes_split.
 
 -type fun_info()  :: {aeso_syntax:ann(), typesig() | type()}.
 -type type_info() :: {aeso_syntax:ann(), typedef()}.
@@ -115,7 +110,7 @@
     , in_pattern = false              :: boolean()
     , stateful   = false              :: boolean()
     , current_function = none         :: none | aeso_syntax:id()
-    , what       = top                :: top | namespace | contract | main_contract
+    , what       = top                :: top | namespace | contract
     }).
 
 -type env() :: #env{}.
@@ -180,13 +175,12 @@ bind_fun(X, Type, Env) ->
     end.
 
 -spec force_bind_fun(name(), type() | typesig(), env()) -> env().
-force_bind_fun(X, Type, Env = #env{ what = What }) ->
+force_bind_fun(X, Type, Env) ->
     Ann    = aeso_syntax:get_ann(Type),
     NoCode = get_option(no_code, false),
-    Entry = if X == "init", What == main_contract, not NoCode ->
-                    {reserved_init, Ann, Type};
-               What == contract -> {contract_fun, Ann, Type};
-               true -> {Ann, Type}
+    Entry = case X == "init" andalso Env#env.what == contract andalso not NoCode of
+                true  -> {reserved_init, Ann, Type};
+                false -> {Ann, Type}
             end,
     on_current_scope(Env, fun(Scope = #scope{ funs = Funs }) ->
                             Scope#scope{ funs = [{X, Entry} | Funs] }
@@ -312,9 +306,6 @@ lookup_env1(#env{ namespace = Current, scopes = Scopes }, Kind, Ann, QName) ->
                 {reserved_init, Ann1, Type} ->
                     type_error({cannot_call_init_function, Ann}),
                     {QName, {Ann1, Type}};  %% Return the type to avoid an extra not-in-scope error
-                {contract_fun, Ann1, Type} ->
-                    type_error({contract_treated_as_namespace, Ann, QName}),
-                    {QName, {Ann1, Type}};
                 {Ann1, _} = E ->
                     %% Check that it's not private (or we can see private funs)
                     case not is_private(Ann1) orelse AllowPrivate of
@@ -528,7 +519,6 @@ global_env() ->
     %% Conversion
     IntScope     = #scope{ funs = MkDefs([{"to_str", Fun1(Int,     String)}]) },
     AddressScope = #scope{ funs = MkDefs([{"to_str", Fun1(Address, String)},
-                                          {"to_contract", FunC(address_to_contract, [Address], A)},
                                           {"is_oracle", Fun1(Address, Bool)},
                                           {"is_contract", Fun1(Address, Bool)},
                                           {"is_payable", Fun1(Address, Bool)}]) },
@@ -553,21 +543,17 @@ global_env() ->
 option_t(As, T) -> {app_t, As, {id, As, "option"}, [T]}.
 map_t(As, K, V) -> {app_t, As, {id, As, "map"}, [K, V]}.
 
--spec infer(aeso_syntax:ast()) -> {aeso_syntax:ast(), aeso_syntax:ast()} | {env(), aeso_syntax:ast(), aeso_syntax:ast()}.
+-spec infer(aeso_syntax:ast()) -> aeso_syntax:ast() | {env(), aeso_syntax:ast()}.
 infer(Contracts) ->
     infer(Contracts, []).
 
--type option() :: return_env | dont_unfold | no_code | debug_mode | term().
+-type option() :: return_env | dont_unfold | no_code | term().
 
 -spec init_env(list(option())) -> env().
 init_env(_Options) -> global_env().
 
 -spec infer(aeso_syntax:ast(), list(option())) ->
-  {aeso_syntax:ast(), aeso_syntax:ast()} | {env(), aeso_syntax:ast(), aeso_syntax:ast()}.
-infer([], Options) ->
-    create_type_errors(),
-    type_error({no_decls, proplists:get_value(src_file, Options, no_file)}),
-    destroy_and_report_type_errors(init_env(Options));
+    aeso_syntax:ast() | {env(), aeso_syntax:ast()}.
 infer(Contracts, Options) ->
     ets_init(), %% Init the ETS table state
     try
@@ -576,15 +562,15 @@ infer(Contracts, Options) ->
         ets_new(type_vars, [set]),
         check_modifiers(Env, Contracts),
         {Env1, Decls} = infer1(Env, Contracts, [], Options),
-        {Env2, DeclsFolded, DeclsUnfolded} =
+        {Env2, Decls2} =
             case proplists:get_value(dont_unfold, Options, false) of
-                true  -> {Env1, Decls, Decls};
+                true  -> {Env1, Decls};
                 false -> E = on_scopes(Env1, fun(Scope) -> unfold_record_types(Env1, Scope) end),
-                         {E, Decls, unfold_record_types(E, Decls)}
+                         {E, unfold_record_types(E, Decls)}
             end,
         case proplists:get_value(return_env, Options, false) of
-            false -> {DeclsFolded, DeclsUnfolded};
-            true  -> {Env2, DeclsFolded, DeclsUnfolded}
+            false -> Decls2;
+            true  -> {Env2, Decls2}
         end
     after
         clean_up_ets()
@@ -596,8 +582,7 @@ infer1(Env, [], Acc, _Options) -> {Env, lists:reverse(Acc)};
 infer1(Env, [{contract, Ann, ConName, Code} | Rest], Acc, Options) ->
     %% do type inference on each contract independently.
     check_scope_name_clash(Env, contract, ConName),
-    What = if Rest == [] -> main_contract; true -> contract end,
-    {Env1, Code1} = infer_contract_top(push_scope(contract, ConName, Env), What, Code, Options),
+    {Env1, Code1} = infer_contract_top(push_scope(contract, ConName, Env), contract, Code, Options),
     Contract1 = {contract, Ann, ConName, Code1},
     Env2 = pop_scope(Env1),
     Env3 = bind_contract(Contract1, Env2),
@@ -606,10 +591,7 @@ infer1(Env, [{namespace, Ann, Name, Code} | Rest], Acc, Options) ->
     check_scope_name_clash(Env, namespace, Name),
     {Env1, Code1} = infer_contract_top(push_scope(namespace, Name, Env), namespace, Code, Options),
     Namespace1 = {namespace, Ann, Name, Code1},
-    infer1(pop_scope(Env1), Rest, [Namespace1 | Acc], Options);
-infer1(Env, [{pragma, _, _} | Rest], Acc, Options) ->
-    %% Pragmas are checked in check_modifiers
-    infer1(Env, Rest, Acc, Options).
+    infer1(pop_scope(Env1), Rest, [Namespace1 | Acc], Options).
 
 check_scope_name_clash(Env, Kind, Name) ->
     case get_scope(Env, qname(Name)) of
@@ -620,31 +602,21 @@ check_scope_name_clash(Env, Kind, Name) ->
             destroy_and_report_type_errors(Env)
     end.
 
--spec infer_contract_top(env(), main_contract | contract | namespace, [aeso_syntax:decl()], list(option())) ->
+-spec infer_contract_top(env(), contract | namespace, [aeso_syntax:decl()], list(option())) ->
     {env(), [aeso_syntax:decl()]}.
-infer_contract_top(Env, Kind, Defs0, Options) ->
-    create_type_errors(),
+infer_contract_top(Env, Kind, Defs0, _Options) ->
     Defs = desugar(Defs0),
-    destroy_and_report_type_errors(Env),
-    infer_contract(Env, Kind, Defs, Options).
+    infer_contract(Env, Kind, Defs).
 
 %% infer_contract takes a proplist mapping global names to types, and
 %% a list of definitions.
--spec infer_contract(env(), main_contract | contract | namespace, [aeso_syntax:decl()], list(option())) -> {env(), [aeso_syntax:decl()]}.
-infer_contract(Env0, What, Defs0, Options) ->
-    create_type_errors(),
-    Defs01 = process_blocks(Defs0),
-    Defs = case lists:member(debug_mode, Options) of
-               true  -> expose_internals(Defs01, What);
-               false -> Defs01
-           end,
-    destroy_and_report_type_errors(Env0),
+-spec infer_contract(env(), contract | namespace, [aeso_syntax:decl()]) -> {env(), [aeso_syntax:decl()]}.
+infer_contract(Env0, What, Defs) ->
     Env  = Env0#env{ what = What },
-    Kind = fun({type_def, _, _, _, _})    -> type;
-              ({letfun, _, _, _, _, _})   -> function;
-              ({fun_clauses, _, _, _, _}) -> function;
-              ({fun_decl, _, _, _})       -> prototype;
-              (_)                         -> unexpected
+    Kind = fun({type_def, _, _, _, _})  -> type;
+              ({letfun, _, _, _, _, _}) -> function;
+              ({fun_decl, _, _, _})     -> prototype;
+              (_)                       -> unexpected
            end,
     Get = fun(K) -> [ Def || Def <- Defs, Kind(Def) == K ] end,
     {Env1, TypeDefs} = check_typedefs(Env, Get(type)),
@@ -652,19 +624,16 @@ infer_contract(Env0, What, Defs0, Options) ->
     check_unexpected(Get(unexpected)),
     Env2 =
         case What of
-            namespace     -> Env1;
-            contract      -> Env1;
-            main_contract -> bind_state(Env1)   %% bind state and put
+            namespace -> Env1;
+            contract  -> bind_state(Env1)   %% bind state and put
         end,
     {ProtoSigs, Decls} = lists:unzip([ check_fundecl(Env1, Decl) || Decl <- Get(prototype) ]),
     Env3      = bind_funs(ProtoSigs, Env2),
     Functions = Get(function),
     %% Check for duplicates in Functions (we turn it into a map below)
-    FunBind   = fun({letfun, Ann, {id, _, Fun}, _, _, _})   -> {Fun, {tuple_t, Ann, []}};
-                   ({fun_clauses, Ann, {id, _, Fun}, _, _}) -> {Fun, {tuple_t, Ann, []}} end,
-    FunName   = fun(Def) -> {Name, _} = FunBind(Def), Name end,
-    _         = bind_funs(lists:map(FunBind, Functions), #env{}),
-    FunMap    = maps:from_list([ {FunName(Def), Def} || Def <- Functions ]),
+    _         = bind_funs([{Fun, {tuple_t, Ann, []}} || {letfun, Ann, {id, _, Fun}, _, _, _} <- Functions],
+                          #env{}),
+    FunMap    = maps:from_list([ {Fun, Def} || Def = {letfun, _, {id, _, Fun}, _, _, _} <- Functions ]),
     check_reserved_entrypoints(FunMap),
     DepGraph  = maps:map(fun(_, Def) -> aeso_syntax_utils:used_ids(Def) end, FunMap),
     SCCs      = aeso_utils:scc(DepGraph),
@@ -675,49 +644,6 @@ infer_contract(Env0, What, Defs0, Options) ->
     destroy_and_report_type_errors(Env4),
     {Env4, TypeDefs ++ Decls ++ Defs1}.
 
-%% Restructure blocks into multi-clause fundefs (`fun_clauses`).
--spec process_blocks([aeso_syntax:decl()]) -> [aeso_syntax:decl()].
-process_blocks(Decls) ->
-    lists:flatmap(
-      fun({block, Ann, Ds}) -> process_block(Ann, Ds);
-         (Decl)             -> [Decl] end, Decls).
-
--spec process_block(aeso_syntax:ann(), [aeso_syntax:decl()]) -> [aeso_syntax:decl()].
-process_block(_, []) -> [];
-process_block(_, [Decl]) -> [Decl];
-process_block(_Ann, [Decl | Decls]) ->
-    IsThis = fun(Name) -> fun({letfun, _, {id, _, Name1}, _, _, _}) -> Name == Name1;
-                             (_) -> false end end,
-    case Decl of
-        {fun_decl, Ann1, Id = {id, _, Name}, Type} ->
-            {Clauses, Rest} = lists:splitwith(IsThis(Name), Decls),
-            [type_error({mismatched_decl_in_funblock, Name, D1}) || D1 <- Rest],
-            [{fun_clauses, Ann1, Id, Type, Clauses}];
-        {letfun, Ann1, Id = {id, _, Name}, _, _, _} ->
-            {Clauses, Rest} = lists:splitwith(IsThis(Name), [Decl | Decls]),
-            [type_error({mismatched_decl_in_funblock, Name, D1}) || D1 <- Rest],
-            [{fun_clauses, Ann1, Id, {id, [{origin, system} | Ann1], "_"}, Clauses}]
-    end.
-
-%% Turns private stuff into public stuff
-expose_internals(Defs, What) ->
-    [ begin
-          Ann = element(2, Def),
-          NewAnn = case What of
-                       namespace -> [A ||A <- Ann, A /= {private, true}, A /= private];
-                       main_contract -> [{entrypoint, true}|Ann];  % minor duplication
-                       contract -> Ann
-                   end,
-          Def1 = setelement(2, Def, NewAnn),
-          case Def1 of  % fix inner clauses
-              {fun_clauses, Ans, Id, T, Clauses} ->
-                  {fun_clauses, Ans, Id, T, expose_internals(Clauses, What)};
-              _ -> Def1
-          end
-      end
-     || Def <- Defs
-    ].
-
 -spec check_typedefs(env(), [aeso_syntax:decl()]) -> {env(), [aeso_syntax:decl()]}.
 check_typedefs(Env = #env{ namespace = Ns }, Defs) ->
     create_type_errors(),
@@ -778,46 +704,19 @@ check_unexpected(Xs) ->
 
 check_modifiers(Env, Contracts) ->
     create_type_errors(),
-    check_modifiers_(Env, Contracts),
+    [ case C of
+          {contract, _, Con, Decls}  ->
+              check_modifiers1(contract, Decls),
+              case {lists:keymember(letfun, 1, Decls),
+                    [ D || D <- Decls, aeso_syntax:get_ann(entrypoint, D, false) ]} of
+                  {true, []} -> type_error({contract_has_no_entrypoints, Con});
+                  _          -> ok
+              end;
+          {namespace, _, _, Decls} -> check_modifiers1(namespace, Decls);
+          Decl -> type_error({bad_top_level_decl, Decl})
+      end || C <- Contracts ],
     destroy_and_report_type_errors(Env).
 
-check_modifiers_(Env, [{contract, _, Con, Decls} | Rest]) ->
-    IsMain = Rest == [],
-    check_modifiers1(contract, Decls),
-    case {lists:keymember(letfun, 1, Decls),
-            [ D || D <- Decls, aeso_syntax:get_ann(entrypoint, D, false) ]} of
-        {true, []} -> type_error({contract_has_no_entrypoints, Con});
-        _ when not IsMain ->
-            case [ {Ann, Id} || {letfun, Ann, Id, _, _, _} <- Decls ] of
-                [{Ann, Id} | _] -> type_error({definition_in_non_main_contract, Ann, Id});
-                [] -> ok
-            end;
-        _ -> ok
-    end,
-    check_modifiers_(Env, Rest);
-check_modifiers_(Env, [{namespace, _, _, Decls} | Rest]) ->
-    check_modifiers1(namespace, Decls),
-    check_modifiers_(Env, Rest);
-check_modifiers_(Env, [{pragma, Ann, Pragma} | Rest]) ->
-    check_pragma(Env, Ann, Pragma),
-    check_modifiers_(Env, Rest);
-check_modifiers_(Env, [Decl | Rest]) ->
-    type_error({bad_top_level_decl, Decl}),
-    check_modifiers_(Env, Rest);
-check_modifiers_(_Env, []) -> ok.
-
--spec check_pragma(env(), aeso_syntax:ann(), aeso_syntax:pragma()) -> ok.
-check_pragma(_Env, Ann, {compiler, Op, Ver}) ->
-    case aeso_compiler:numeric_version() of
-        {error, Err}  -> type_error({failed_to_get_compiler_version, Err});
-        {ok, Version} ->
-            Strip = fun(V) -> lists:reverse(lists:dropwhile(fun(X) -> X == 0 end, lists:reverse(V))) end,
-            case apply(erlang, Op, [Strip(Version), Strip(Ver)]) of
-                true  -> ok;
-                false -> type_error({compiler_version_mismatch, Ann, Version, Op, Ver})
-            end
-    end.
-
 -spec check_modifiers1(contract | namespace, [aeso_syntax:decl()] | aeso_syntax:decl()) -> ok.
 check_modifiers1(What, Decls) when is_list(Decls) ->
     _ = [ check_modifiers1(What, Decl) || Decl <- Decls ],
@@ -850,9 +749,9 @@ check_type(Env, T) ->
 check_type(Env, T = {tvar, _, _}, Arity) ->
     [ type_error({higher_kinded_typevar, T}) || Arity /= 0 ],
     check_tvar(Env, T);
-check_type(_Env, X = {id, Ann, "_"}, Arity) ->
+check_type(_Env, X = {id, _, "_"}, Arity) ->
     ensure_base_type(X, Arity),
-    fresh_uvar(Ann);
+    X;
 check_type(Env, X = {Tag, _, _}, Arity) when Tag == con; Tag == qcon; Tag == id; Tag == qid ->
     case lookup_type(Env, X) of
         {Q, {_, Def}} ->
@@ -1023,9 +922,8 @@ typesig_to_fun_t({type_sig, Ann, _Constr, Named, Args, Res}) ->
 
 infer_letrec(Env, Defs) ->
     create_constraints(),
-    Funs = lists:map(fun({letfun, _, {id, Ann, Name}, _, _, _})   -> {Name, fresh_uvar(Ann)};
-                        ({fun_clauses, _, {id, Ann, Name}, _, _}) -> {Name, fresh_uvar(Ann)}
-                     end, Defs),
+    Funs = [{Name, fresh_uvar(A)}
+                 || {letfun, _, {id, A, Name}, _, _, _} <- Defs],
     ExtendEnv = bind_funs(Funs, Env),
     Inferred =
         [ begin
@@ -1044,51 +942,26 @@ infer_letrec(Env, Defs) ->
     [print_typesig(S) || S <- TypeSigs],
     {TypeSigs, NewDefs}.
 
-infer_letfun(Env, {fun_clauses, Ann, Fun = {id, _, Name}, Type, Clauses}) ->
-    Type1 = check_type(Env, Type),
-    {NameSigs, Clauses1} = lists:unzip([ infer_letfun1(Env, Clause) || Clause <- Clauses ]),
-    {_, Sigs = [Sig | _]} = lists:unzip(NameSigs),
-    _ = [ begin
-            ClauseT = typesig_to_fun_t(ClauseSig),
-            unify(Env, ClauseT, Type1, {check_typesig, Name, ClauseT, Type1})
-          end || ClauseSig <- Sigs ],
-    {{Name, Sig}, desugar_clauses(Ann, Fun, Sig, Clauses1)};
-infer_letfun(Env, LetFun = {letfun, Ann, Fun, _, _, _}) ->
-    {{Name, Sig}, Clause} = infer_letfun1(Env, LetFun),
-    {{Name, Sig}, desugar_clauses(Ann, Fun, Sig, [Clause])}.
-
-infer_letfun1(Env0, {letfun, Attrib, Fun = {id, NameAttrib, Name}, Args, What, Body}) ->
+infer_letfun(Env0, {letfun, Attrib, Fun = {id, NameAttrib, Name}, Args, What, Body}) ->
     Env = Env0#env{ stateful = aeso_syntax:get_ann(stateful, Attrib, false),
                     current_function = Fun },
-    {NewEnv, {typed, _, {tuple, _, TypedArgs}, {tuple_t, _, ArgTypes}}} = infer_pattern(Env, {tuple, [{origin, system} | NameAttrib], Args}),
+    check_unique_arg_names(Fun, Args),
+    ArgTypes  = [{ArgName, check_type(Env, arg_type(ArgAnn, T))} || {arg, ArgAnn, ArgName, T} <- Args],
     ExpectedType = check_type(Env, arg_type(NameAttrib, What)),
-    NewBody={typed, _, _, ResultType} = check_expr(NewEnv, Body, ExpectedType),
+    NewBody={typed, _, _, ResultType} = check_expr(bind_vars(ArgTypes, Env), Body, ExpectedType),
+    NewArgs = [{arg, A1, {id, A2, ArgName}, T}
+               || {{_, T}, {arg, A1, {id, A2, ArgName}, _}} <- lists:zip(ArgTypes, Args)],
     NamedArgs = [],
-    TypeSig = {type_sig, Attrib, none, NamedArgs, ArgTypes, ResultType},
+    TypeSig = {type_sig, Attrib, none, NamedArgs, [T || {arg, _, _, T} <- NewArgs], ResultType},
     {{Name, TypeSig},
-     {letfun, Attrib, {id, NameAttrib, Name}, TypedArgs, ResultType, NewBody}}.
+     {letfun, Attrib, {id, NameAttrib, Name}, NewArgs, ResultType, NewBody}}.
 
-desugar_clauses(Ann, Fun, {type_sig, _, _, _, ArgTypes, RetType}, Clauses) ->
-    NeedDesugar =
-        case Clauses of
-            [{letfun, _, _, As, _, _}] -> lists:any(fun({typed, _, {id, _, _}, _}) -> false; (_) -> true end, As);
-            _                          -> true
-        end,
-    case NeedDesugar of
-        false -> [Clause] = Clauses, Clause;
-        true  ->
-            NoAnn = [{origin, system}],
-            Args = [ {typed, NoAnn, {id, NoAnn, "x#" ++ integer_to_list(I)}, Type}
-                     || {I, Type} <- indexed(1, ArgTypes) ],
-            Tuple = fun([X]) -> X;
-                       (As) -> {typed, NoAnn, {tuple, NoAnn, As}, {tuple_t, NoAnn, ArgTypes}}
-                    end,
-            {letfun, Ann, Fun, Args, RetType,
-             {typed, NoAnn,
-              {switch, NoAnn, Tuple(Args),
-                [ {'case', AnnC, Tuple(ArgsC), Body}
-                || {letfun, AnnC, _, ArgsC, _, Body} <- Clauses ]}, RetType}}
-    end.
+check_unique_arg_names(Fun, Args) ->
+    Name = fun({arg, _, {id, _, X}, _}) -> X end,
+    Names = lists:map(Name, Args),
+    Dups = lists:usort(Names -- lists:usort(Names)),
+    [ type_error({repeated_arg, Fun, Arg}) || Arg <- Dups ],
+    ok.
 
 print_typesig({Name, TypeSig}) ->
     ?PRINT_TYPES("Inferred ~s : ~s\n", [Name, pp(TypeSig)]).
@@ -1181,9 +1054,9 @@ get_call_chains(Graph, Visited, Queue, Stop, Acc) ->
     end.
 
 check_expr(Env, Expr, Type) ->
-    {typed, Ann, Expr1, Type1} = infer_expr(Env, Expr),
+    E = {typed, _, _, Type1} = infer_expr(Env, Expr),
     unify(Env, Type1, Type, {check_expr, Expr, Type1, Type}),
-    {typed, Ann, Expr1, Type}.  %% Keep the user-given type
+    E.
 
 infer_expr(_Env, Body={bool, As, _}) ->
     {typed, As, Body, {id, As, "bool"}};
@@ -1208,7 +1081,7 @@ infer_expr(_Env, Body={oracle_query_id, As, _}) ->
 infer_expr(_Env, Body={contract_pubkey, As, _}) ->
     Con = fresh_uvar(As),
     constrain([#is_contract_constraint{ contract_t = Con,
-                                        context    = {contract_literal, Body} }]),
+                                        context    = Body }]),
     {typed, As, Body, Con};
 infer_expr(_Env, Body={id, As, "_"}) ->
     {typed, As, Body, fresh_uvar(As)};
@@ -1227,20 +1100,21 @@ infer_expr(Env, {list, As, Elems}) ->
     NewElems = [check_expr(Env, X, ElemType) || X <- Elems],
     {typed, As, {list, As, NewElems}, {app_t, As, {id, As, "list"}, [ElemType]}};
 infer_expr(Env, {list_comp, As, Yield, []}) ->
-    {typed, _, _, Type} = TypedYield = infer_expr(Env, Yield),
+    {typed, _, TypedYield, Type} = infer_expr(Env, Yield),
     {typed, As, {list_comp, As, TypedYield, []}, {app_t, As, {id, As, "list"}, [Type]}};
-infer_expr(Env, {list_comp, As, Yield, [{comprehension_bind, Pat, BExpr}|Rest]}) ->
+infer_expr(Env, {list_comp, As, Yield, [{comprehension_bind, Arg, BExpr}|Rest]}) ->
+    BindVarType = fresh_uvar(As),
     TypedBind = {typed, As2, _, TypeBExpr} = infer_expr(Env, BExpr),
-    {NewE, TypedPat = {typed, _, _, PatType}} = infer_pattern(Env, Pat),
     unify( Env
          , TypeBExpr
-         , {app_t, As, {id, As, "list"}, [PatType]}
-         , {list_comp, TypedBind, TypeBExpr, {app_t, As2, {id, As, "list"}, [PatType]}}),
+         , {app_t, As, {id, As, "list"}, [BindVarType]}
+         , {list_comp, TypedBind, TypeBExpr, {app_t, As2, {id, As, "list"}, [BindVarType]}}),
+    NewE = bind_var(Arg, BindVarType, Env),
     {typed, _, {list_comp, _, TypedYield, TypedRest}, ResType} =
         infer_expr(NewE, {list_comp, As, Yield, Rest}),
     { typed
     , As
-    , {list_comp, As, TypedYield, [{comprehension_bind, TypedPat, TypedBind}|TypedRest]}
+    , {list_comp, As, TypedYield, [{comprehension_bind, {typed, Arg, BindVarType}, TypedBind}|TypedRest]}
     , ResType};
 infer_expr(Env, {list_comp, AttrsL, Yield, [{comprehension_if, AttrsIF, Cond}|Rest]}) ->
     NewCond = check_expr(Env, Cond, {id, AttrsIF, "bool"}),
@@ -1250,8 +1124,8 @@ infer_expr(Env, {list_comp, AttrsL, Yield, [{comprehension_if, AttrsIF, Cond}|Re
     , AttrsL
     , {list_comp, AttrsL, TypedYield, [{comprehension_if, AttrsIF, NewCond}|TypedRest]}
     , ResType};
-infer_expr(Env, {list_comp, AsLC, Yield, [{letval, AsLV, Pattern, E}|Rest]}) ->
-    NewE = {typed, _, _, PatType} = infer_expr(Env, E),
+infer_expr(Env, {list_comp, AsLC, Yield, [{letval, AsLV, Pattern, Type, E}|Rest]}) ->
+    NewE = {typed, _, _, PatType} = infer_expr(Env, {typed, AsLV, E, arg_type(AsLV, Type)}),
     BlockType = fresh_uvar(AsLV),
     {'case', _, NewPattern, NewRest} =
         infer_case( Env
@@ -1263,7 +1137,7 @@ infer_expr(Env, {list_comp, AsLC, Yield, [{letval, AsLV, Pattern, E}|Rest]}) ->
     {typed, _, {list_comp, _, TypedYield, TypedRest}, ResType} = NewRest,
     { typed
     , AsLC
-    , {list_comp, AsLC, TypedYield, [{letval, AsLV, NewPattern, NewE}|TypedRest]}
+    , {list_comp, AsLC, TypedYield, [{letval, AsLV, NewPattern, Type, NewE}|TypedRest]}
     , ResType
     };
 infer_expr(Env, {list_comp, AsLC, Yield, [Def={letfun, AsLF, _, _, _, _}|Rest]}) ->
@@ -1378,16 +1252,6 @@ infer_expr(Env, {block, Attrs, Stmts}) ->
     BlockType = fresh_uvar(Attrs),
     NewStmts = infer_block(Env, Attrs, Stmts, BlockType),
     {typed, Attrs, {block, Attrs, NewStmts}, BlockType};
-infer_expr(_Env, {record_or_map_error, Attrs, Fields}) ->
-    type_error({mixed_record_and_map, {record, Attrs, Fields}}),
-    Type = fresh_uvar(Attrs),
-    {typed, Attrs, {record, Attrs, []}, Type};
-infer_expr(Env, {record_or_map_error, Attrs, Expr, []}) ->
-    type_error({empty_record_or_map_update, {record, Attrs, Expr, []}}),
-    infer_expr(Env, Expr);
-infer_expr(Env, {record_or_map_error, Attrs, Expr, Fields}) ->
-    type_error({mixed_record_and_map, {record, Attrs, Expr, Fields}}),
-    infer_expr(Env, Expr);
 infer_expr(Env, {lam, Attrs, Args, Body}) ->
     ArgTypes = [fresh_uvar(As) || {arg, As, _, _} <- Args],
     ArgPatterns = [{typed, As, Pat, check_type(Env, T)} || {arg, As, Pat, T} <- Args],
@@ -1396,7 +1260,7 @@ infer_expr(Env, {lam, Attrs, Args, Body}) ->
         infer_case(Env, Attrs, {tuple, Attrs, ArgPatterns}, {tuple_t, Attrs, ArgTypes}, Body, ResultType),
     NewArgs = [{arg, As, NewPat, NewT} || {typed, As, NewPat, NewT} <- NewArgPatterns],
     {typed, Attrs, {lam, Attrs, NewArgs, NewBody}, {fun_t, Attrs, [], ArgTypes, ResultType}};
-infer_expr(Env, Let = {letval, Attrs, _, _}) ->
+infer_expr(Env, Let = {letval, Attrs, _, _, _}) ->
     type_error({missing_body_for_let, Attrs}),
     infer_expr(Env, {block, Attrs, [Let, abort_expr(Attrs, "missing body")]});
 infer_expr(Env, Let = {letfun, Attrs, _, _, _, _}) ->
@@ -1459,20 +1323,16 @@ infer_op(Env, As, Op, Args, InferOp) ->
     unify(Env, ArgTypes, OperandTypes, {infer_app, Op, Args, Inferred, ArgTypes}),
     {typed, As, {app, As, Op, TypedArgs}, ResultType}.
 
-infer_pattern(Env, Pattern) ->
+infer_case(Env, Attrs, Pattern, ExprType, Branch, SwitchType) ->
     Vars = free_vars(Pattern),
     Names = [N || {id, _, N} <- Vars, N /= "_"],
     case Names -- lists:usort(Names) of
         [] -> ok;
         Nonlinear -> type_error({non_linear_pattern, Pattern, lists:usort(Nonlinear)})
     end,
-    NewEnv = bind_vars([{Var, fresh_uvar(Ann1)} || Var = {id, Ann1, _} <- Vars], Env#env{ in_pattern = true }),
-    NewPattern = infer_expr(NewEnv, Pattern),
-    {NewEnv#env{ in_pattern = Env#env.in_pattern }, NewPattern}.
-
-infer_case(Env, Attrs, Pattern, ExprType, Branch, SwitchType) ->
-    {NewEnv, NewPattern = {typed, _, _, PatType}} = infer_pattern(Env, Pattern),
-    NewBranch  = check_expr(NewEnv#env{ in_pattern = false }, Branch, SwitchType),
+    NewEnv = bind_vars([{Var, fresh_uvar(Ann)} || Var = {id, Ann, _} <- Vars], Env#env{ in_pattern = true }),
+    NewPattern = {typed, _, _, PatType} = infer_expr(NewEnv, Pattern),
+    NewBranch  = check_expr(NewEnv, Branch, SwitchType),
     unify(Env, PatType, ExprType, {case_pat, Pattern, PatType, ExprType}),
     {'case', Attrs, NewPattern, NewBranch}.
 
@@ -1486,11 +1346,11 @@ infer_block(Env, Attrs, [Def={letfun, Ann, _, _, _, _}|Rest], BlockType) ->
     FunT = typesig_to_fun_t(TypeSig),
     NewE = bind_var({id, Ann, Name}, FunT, Env),
     [LetFun|infer_block(NewE, Attrs, Rest, BlockType)];
-infer_block(Env, _, [{letval, Attrs, Pattern, E}|Rest], BlockType) ->
-    NewE = {typed, _, _, PatType} = infer_expr(Env, E),
+infer_block(Env, _, [{letval, Attrs, Pattern, Type, E}|Rest], BlockType) ->
+    NewE = {typed, _, _, PatType} = infer_expr(Env, {typed, Attrs, E, arg_type(aeso_syntax:get_ann(Pattern), Type)}),
     {'case', _, NewPattern, {typed, _, {block, _, NewRest}, _}} =
         infer_case(Env, Attrs, Pattern, PatType, {block, Attrs, Rest}, BlockType),
-    [{letval, Attrs, NewPattern, NewE}|NewRest];
+    [{letval, Attrs, NewPattern, Type, NewE}|NewRest];
 infer_block(Env, Attrs, [E|Rest], BlockType) ->
     [infer_expr(Env, E)|infer_block(Env, Attrs, Rest, BlockType)].
 
@@ -1532,13 +1392,18 @@ infer_prefix({IntOp,As}) when IntOp =:= '-' ->
 abort_expr(Ann, Str) ->
     {app, Ann, {id, Ann, "abort"}, [{string, Ann, Str}]}.
 
-free_vars({int, _, _})    -> [];
-free_vars({char, _, _})   -> [];
-free_vars({string, _, _}) -> [];
-free_vars({bool, _, _})   -> [];
-free_vars(Id={id, _, _})  -> [Id];
-free_vars({con, _, _})    -> [];
-free_vars({qcon, _, _})   -> [];
+free_vars({int, _, _}) ->
+    [];
+free_vars({char, _, _}) ->
+    [];
+free_vars({string, _, _}) ->
+    [];
+free_vars({bool, _, _}) ->
+    [];
+free_vars(Id={id, _, _}) ->
+    [Id];
+free_vars({con, _, _}) ->
+    [];
 free_vars({tuple, _, Cpts}) ->
     free_vars(Cpts);
 free_vars({list, _, Elems}) ->
@@ -1547,8 +1412,6 @@ free_vars({app, _, {'::', _}, Args}) ->
     free_vars(Args);
 free_vars({app, _, {con, _, _}, Args}) ->
     free_vars(Args);
-free_vars({app, _, {qcon, _, _}, Args}) ->
-    free_vars(Args);
 free_vars({record, _, Fields}) ->
     free_vars([E || {field, _, _, E} <- Fields]);
 free_vars({typed, _, A, _}) ->
@@ -1557,15 +1420,6 @@ free_vars(L) when is_list(L) ->
     [V || Elem <- L,
           V <- free_vars(Elem)].
 
-next_count() ->
-    V = case get(counter) of
-            undefined ->
-                0;
-            X -> X
-        end,
-    put(counter, V + 1),
-    V.
-
 %% Clean up all the ets tables (in case of an exception)
 
 ets_tables() ->
@@ -1611,18 +1465,6 @@ ets_tab2list(Name) ->
     TabId = ets_tabid(Name),
     ets:tab2list(TabId).
 
-ets_insert_ordered(_, []) -> true;
-ets_insert_ordered(Name, [H|T]) ->
-    ets_insert_ordered(Name, H),
-    ets_insert_ordered(Name, T);
-ets_insert_ordered(Name, Object) ->
-    Count = next_count(),
-    TabId = ets_tabid(Name),
-    ets:insert(TabId, {Count, Object}).
-
-ets_tab2list_ordered(Name) ->
-    [E || {_, E} <- ets_tab2list(Name)].
-
 %% Options
 
 create_options(Options) ->
@@ -1658,17 +1500,17 @@ destroy_and_report_unsolved_constraints(Env) ->
 %% -- Named argument constraints --
 
 create_named_argument_constraints() ->
-    ets_new(named_argument_constraints, [ordered_set]).
+    ets_new(named_argument_constraints, [bag]).
 
 destroy_named_argument_constraints() ->
     ets_delete(named_argument_constraints).
 
 get_named_argument_constraints() ->
-    ets_tab2list_ordered(named_argument_constraints).
+    ets_tab2list(named_argument_constraints).
 
 -spec add_named_argument_constraint(named_argument_constraint()) -> ok.
 add_named_argument_constraint(Constraint) ->
-    ets_insert_ordered(named_argument_constraints, Constraint),
+    ets_insert(named_argument_constraints, Constraint),
     ok.
 
 solve_named_argument_constraints(Env) ->
@@ -1707,14 +1549,14 @@ destroy_and_report_unsolved_named_argument_constraints(Env) ->
                          | {add_bytes, aeso_syntax:ann(), concat | split, utype(), utype(), utype()}.
 
 create_bytes_constraints() ->
-    ets_new(bytes_constraints, [ordered_set]).
+    ets_new(bytes_constraints, [bag]).
 
 get_bytes_constraints() ->
-    ets_tab2list_ordered(bytes_constraints).
+    ets_tab2list(bytes_constraints).
 
 -spec add_bytes_constraint(byte_constraint()) -> true.
 add_bytes_constraint(Constraint) ->
-    ets_insert_ordered(bytes_constraints, Constraint).
+    ets_insert(bytes_constraints, Constraint).
 
 solve_bytes_constraints(Env) ->
     [ solve_bytes_constraint(Env, C) || C <- get_bytes_constraints() ],
@@ -1768,18 +1610,18 @@ check_bytes_constraint(Env, {add_bytes, Ann, Fun, A0, B0, C0}) ->
 
 create_field_constraints() ->
     %% A relation from uvars to constraints
-    ets_new(field_constraints, [ordered_set]).
+    ets_new(field_constraints, [bag]).
 
 destroy_field_constraints() ->
     ets_delete(field_constraints).
 
 -spec constrain([field_constraint()]) -> true.
 constrain(FieldConstraints) ->
-    ets_insert_ordered(field_constraints, FieldConstraints).
+    ets_insert(field_constraints, FieldConstraints).
 
 -spec get_field_constraints() -> [field_constraint()].
 get_field_constraints() ->
-    ets_tab2list_ordered(field_constraints).
+    ets_tab2list(field_constraints).
 
 solve_field_constraints(Env) ->
     FieldCs =
@@ -1811,11 +1653,11 @@ check_record_create_constraints(Env, [C | Cs]) ->
 
 check_is_contract_constraints(_Env, []) -> ok;
 check_is_contract_constraints(Env, [C | Cs]) ->
-    #is_contract_constraint{ contract_t = Type, context = Cxt } = C,
+    #is_contract_constraint{ contract_t = Type, context = Lit } = C,
     Type1 = unfold_types_in_type(Env, instantiate(Type)),
     case lookup_type(Env, record_type_name(Type1)) of
         {_, {_Ann, {[], {contract_t, _}}}} -> ok;
-        _ -> type_error({not_a_contract_type, Type1, Cxt})
+        _ -> type_error({not_a_contract_type, Type1, Lit})
     end,
     check_is_contract_constraints(Env, Cs).
 
@@ -1905,7 +1747,7 @@ solve_known_record_types(Env, Constraints) ->
                              C
                      end;
                 _ ->
-                    type_error({not_a_record_type, instantiate(RecType), When}),
+                    type_error({not_a_record_type, RecType, When}),
                     not_solved
              end
          end
@@ -2128,8 +1970,7 @@ unify1(_Env, {qcon, _, Name}, {qcon, _, Name}, _When) ->
     true;
 unify1(_Env, {bytes_t, _, Len}, {bytes_t, _, Len}, _When) ->
     true;
-unify1(Env, {fun_t, _, Named1, Args1, Result1}, {fun_t, _, Named2, Args2, Result2}, When)
-    when length(Args1) == length(Args2) ->
+unify1(Env, {fun_t, _, Named1, Args1, Result1}, {fun_t, _, Named2, Args2, Result2}, When) ->
     unify(Env, Named1, Named2, When) andalso
     unify(Env, Args1, Args2, When) andalso unify(Env, Result1, Result2, When);
 unify1(Env, {app_t, _, {Tag, _, F}, Args1}, {app_t, _, {Tag, _, F}, Args2}, When)
@@ -2237,9 +2078,6 @@ freshen_type_sig(Ann, TypeSig = {type_sig, _, Constr, _, _, _}) ->
     FunT.
 
 apply_typesig_constraint(_Ann, none, _FunT) -> ok;
-apply_typesig_constraint(Ann, address_to_contract, {fun_t, _, [], [_], Type}) ->
-    constrain([#is_contract_constraint{ contract_t = Type,
-                                        context    = {address_to_contract, Ann}}]);
 apply_typesig_constraint(Ann, bytes_concat, {fun_t, _, [], [A, B], C}) ->
     add_bytes_constraint({add_bytes, Ann, concat, A, B, C});
 apply_typesig_constraint(Ann, bytes_split, {fun_t, _, [], [C], {tuple_t, _, [A, B]}}) ->
@@ -2318,30 +2156,6 @@ mk_t_err(Pos, Msg) ->
 mk_t_err(Pos, Msg, Ctxt) ->
     aeso_errors:new(type_error, Pos, lists:flatten(Msg), lists:flatten(Ctxt)).
 
-mk_error({no_decls, File}) ->
-    Pos = aeso_errors:pos(File, 0, 0),
-    mk_t_err(Pos, "Empty contract\n");
-mk_error({mismatched_decl_in_funblock, Name, Decl}) ->
-    Msg = io_lib:format("Mismatch in the function block. Expected implementation/type declaration of ~s function\n", [Name]),
-    mk_t_err(pos(Decl), Msg);
-mk_error({higher_kinded_typevar, T}) ->
-    Msg = io_lib:format("Type ~s is a higher kinded type variable\n"
-                        "(takes another type as an argument)\n", [pp(instantiate(T))]
-                       ),
-    mk_t_err(pos(T), Msg);
-mk_error({wrong_type_arguments, X, ArityGiven, ArityReal}) ->
-    Msg = io_lib:format("Arity for ~s doesn't match. Expected ~p, got ~p\n"
-                       , [pp(instantiate(X)), ArityReal, ArityGiven]
-                       ),
-    mk_t_err(pos(X), Msg);
-mk_error({unnamed_map_update_with_default, Upd}) ->
-    Msg = "Invalid map update with default\n",
-    mk_t_err(pos(Upd), Msg);
-mk_error({fundecl_must_have_funtype, _Ann, Id, Type}) ->
-    Msg = io_lib:format("~s at ~s was declared with an invalid type ~s.\n"
-                       "Entrypoints and functions must have functional types"
-                       , [pp(Id), pp_loc(Id), pp(instantiate(Type))]),
-    mk_t_err(pos(Id), Msg);
 mk_error({cannot_unify, A, B, When}) ->
     Msg = io_lib:format("Cannot unify ~s\n         and ~s\n",
                         [pp(instantiate(A)), pp(instantiate(B))]),
@@ -2362,28 +2176,12 @@ mk_error({not_a_record_type, Type, Why}) ->
     Msg = io_lib:format("~s\n", [pp_type("Not a record type: ", Type)]),
     {Pos, Ctxt} = pp_why_record(Why),
     mk_t_err(Pos, Msg, Ctxt);
-mk_error({not_a_contract_type, Type, Cxt}) ->
-    Msg =
-        case Type of
-            {tvar, _, _} ->
-                "Unresolved contract type\n";
-            _ ->
-                io_lib:format("The type ~s is not a contract type\n", [pp_type("", Type)])
-        end,
-    {Pos, Cxt1} =
-        case Cxt of
-            {contract_literal, Lit} ->
-                {pos(Lit),
-                 io_lib:format("when checking that the contract literal\n~s\n"
-                               "has the type\n~s\n",
-                               [pp_expr("  ", Lit), pp_type("  ", Type)])};
-            {address_to_contract, Ann} ->
-                {pos(Ann),
-                 io_lib:format("when checking that the call to\n  Address.to_contract\n"
-                               "has the type\n~s\n",
-                               [pp_type("  ", Type)])}
-        end,
-    mk_t_err(Pos, Msg, Cxt1);
+mk_error({not_a_contract_type, Type, Lit}) ->
+    Msg = io_lib:format("The type ~s is not a contract type\n"
+                        "when checking that the contract literal at ~s\n~s\n"
+                        "has the type\n~s\n",
+                        [pp_type("", Type), pp_loc(Lit), pp_expr("  ", Lit), pp_type("  ", Type)]),
+    mk_t_err(pos(Lit), Msg);
 mk_error({non_linear_pattern, Pattern, Nonlinear}) ->
     Msg = io_lib:format("Repeated name~s ~s in pattern\n~s (at ~s)\n",
                         [plural("", "s", Nonlinear), string:join(Nonlinear, ", "),
@@ -2424,6 +2222,14 @@ mk_error({indexed_type_must_be_word, Type, Type1}) ->
     Msg = io_lib:format("The indexed type ~s (at ~s) equals ~s which is not a word type\n",
                         [pp_type("", Type), pp_loc(Type), pp_type("", Type1)]),
     mk_t_err(pos(Type), Msg);
+mk_error({payload_type_must_be_string, Type, Type}) ->
+    Msg = io_lib:format("The payload type ~s (at ~s) should be string\n",
+                        [pp_type("", Type), pp_loc(Type)]),
+    mk_t_err(pos(Type), Msg);
+mk_error({payload_type_must_be_string, Type, Type1}) ->
+    Msg = io_lib:format("The payload type ~s (at ~s) equals ~s but it should be string\n",
+                        [pp_type("", Type), pp_loc(Type), pp_type("", Type1)]),
+    mk_t_err(pos(Type), Msg);
 mk_error({event_0_to_3_indexed_values, Constr}) ->
     Msg = io_lib:format("The event constructor ~s (at ~s) has too many indexed values (max 3)\n",
                         [name(Constr), pp_loc(Constr)]),
@@ -2467,21 +2273,13 @@ mk_error({include, _, {string, Pos, Name}}) ->
                         [binary_to_list(Name), pp_loc(Pos)]),
     mk_t_err(pos(Pos), Msg);
 mk_error({namespace, _Pos, {con, Pos, Name}, _Def}) ->
-    Msg = io_lib:format("Nested namespaces are not allowed\nNamespace '~s' at ~s not defined at top level.\n",
-                        [Name, pp_loc(Pos)]),
-    mk_t_err(pos(Pos), Msg);
-mk_error({contract, _Pos, {con, Pos, Name}, _Def}) ->
-    Msg = io_lib:format("Nested contracts are not allowed\nContract '~s' at ~s not defined at top level.\n",
-                        [Name, pp_loc(Pos)]),
-    mk_t_err(pos(Pos), Msg);
-mk_error({type_decl, _, {id, Pos, Name}, _}) ->
-    Msg = io_lib:format("Empty type declarations are not supported\nType ~s at ~s lacks a definition\n",
-                        [Name, pp_loc(Pos)]),
-    mk_t_err(pos(Pos), Msg);
-mk_error({letval, _Pos, {id, Pos, Name}, _Def}) ->
-    Msg = io_lib:format("Toplevel \"let\" definitions are not supported\nValue ~s at ~s could be replaced by 0-argument function\n",
+    Msg = io_lib:format("Nested namespace not allowed\nNamespace '~s' at ~s not defined at top level.\n",
                         [Name, pp_loc(Pos)]),
     mk_t_err(pos(Pos), Msg);
+mk_error({repeated_arg, Fun, Arg}) ->
+    Msg = io_lib:format("Repeated argument ~s to function ~s (at ~s).\n",
+                        [Arg, pp(Fun), pp_loc(Fun)]),
+    mk_t_err(pos(Fun), Msg);
 mk_error({stateful_not_allowed, Id, Fun}) ->
     Msg = io_lib:format("Cannot reference stateful function ~s (at ~s)\nin the definition of non-stateful function ~s.\n",
                         [pp(Id), pp_loc(Id), pp(Fun)]),
@@ -2545,10 +2343,6 @@ mk_error({contract_has_no_entrypoints, Con}) ->
                         "contract functions must be declared with the 'entrypoint' keyword instead of\n"
                         "'function'.\n", [pp_expr("", Con), pp_loc(Con)]),
     mk_t_err(pos(Con), Msg);
-mk_error({definition_in_non_main_contract, Ann, {id, _, Id}}) ->
-    Msg = "Only the main contract can contain defined functions or entrypoints.\n",
-    Cxt = io_lib:format("Fix: replace the definition of '~s' by a type signature.\n", [Id]),
-    mk_t_err(pos(Ann), Msg, Cxt);
 mk_error({unbound_type, Type}) ->
     Msg = io_lib:format("Unbound type ~s (at ~s).\n", [pp_type("", Type), pp_loc(Type)]),
     mk_t_err(pos(Type), Msg);
@@ -2564,10 +2358,6 @@ mk_error({cannot_call_init_function, Ann}) ->
     Msg = "The 'init' function is called exclusively by the create contract transaction\n"
           "and cannot be called from the contract code.\n",
     mk_t_err(pos(Ann), Msg);
-mk_error({contract_treated_as_namespace, Ann, [Con, Fun] = QName}) ->
-    Msg = io_lib:format("Invalid call to contract entrypoint '~s'.\n", [string:join(QName, ".")]),
-    Cxt = io_lib:format("It must be called as 'c.~s' for some c : ~s.\n", [Fun, Con]),
-    mk_t_err(pos(Ann), Msg, Cxt);
 mk_error({bad_top_level_decl, Decl}) ->
     What = case element(1, Decl) of
                letval -> "function or entrypoint";
@@ -2592,26 +2382,6 @@ mk_error({unsolved_bytes_constraint, Ann, split, A, B, C}) ->
                         [ pp_type("  - ", C), pp_loc(C), pp_type("  - ", A), pp_loc(A),
                           pp_type("  - ", B), pp_loc(B)]),
     mk_t_err(pos(Ann), Msg);
-mk_error({failed_to_get_compiler_version, Err}) ->
-    Msg = io_lib:format("Failed to get compiler version. Error:\n  ~p\n", [Err]),
-    mk_t_err(pos(0, 0), Msg);
-mk_error({compiler_version_mismatch, Ann, Version, Op, Bound}) ->
-    PrintV = fun(V) -> string:join([integer_to_list(N) || N <- V], ".") end,
-    Msg = io_lib:format("Cannot compile with this version of the compiler,\n"
-                        "because it does not satisfy the constraint"
-                        " ~s ~s ~s\n", [PrintV(Version), Op, PrintV(Bound)]),
-    mk_t_err(pos(Ann), Msg);
-mk_error({empty_record_or_map_update, Expr}) ->
-    Msg = io_lib:format("Empty record/map update\n~s",
-                        [pp_expr("  ", Expr)]),
-    mk_t_err(pos(Expr), Msg);
-mk_error({mixed_record_and_map, Expr}) ->
-    Msg = io_lib:format("Mixed record fields and map keys in\n~s",
-                        [pp_expr("  ", Expr)]),
-    mk_t_err(pos(Expr), Msg);
-mk_error({conflicting_updates_for_field, Upd, Key}) ->
-    Msg = io_lib:format("Conflicting updates for field '~s'\n", [Key]),
-    mk_t_err(pos(Upd), Msg);
 mk_error(Err) ->
     Msg = io_lib:format("Unknown error: ~p\n", [Err]),
     mk_t_err(pos(0, 0), Msg).
@@ -2834,7 +2604,7 @@ desugar_updates([Upd | Updates]) ->
     {More, Updates1}       = updates_key(Key, Updates),
     %% Check conflicts
     case length([ [] || [] <- [Rest | More] ]) of
-        N when N > 1 -> type_error({conflicting_updates_for_field, Upd, Key});
+        N when N > 1 -> error({conflicting_updates_for_field, Upd, Key});
         _ -> ok
     end,
     [MakeField(lists:append([Rest | More])) | desugar_updates(Updates1)].
@@ -2889,7 +2659,3 @@ updates_key(Name, Updates) ->
     Updates1 = [ Upd  || {Upd, false, _} <- Xs ],
     More     = [ Rest || {_, true, Rest} <- Xs ],
     {More, Updates1}.
-
-indexed(I, Xs) ->
-    lists:zip(lists:seq(I, I + length(Xs) - 1), Xs).
-

src/aeso_ast_to_fcode.erl

@@ -24,8 +24,6 @@
 -type var_name() :: string().
 -type sophia_name() :: [string()].
 
--type state_reg() :: pos_integer().
-
 -type builtin() :: atom().
 
 -type op() :: '+' | '-' | '*' | '/' | mod | '^' | '++' | '::' |
@@ -34,7 +32,7 @@
               map_delete | map_member | map_size | string_length |
               string_concat | bits_set | bits_clear | bits_test | bits_sum |
               bits_intersection | bits_union | bits_difference |
-              contract_to_address | address_to_contract | crypto_verify_sig | crypto_verify_sig_secp256k1 |
+              contract_to_address | crypto_verify_sig | crypto_verify_sig_secp256k1 |
               crypto_sha3 | crypto_sha256 | crypto_blake2b |
               crypto_ecverify_secp256k1 | crypto_ecrecover_secp256k1.
 
@@ -63,8 +61,6 @@
                | {funcall, fexpr(), [fexpr()]}  %% Call to unknown function
                | {closure, fun_name(), fexpr()}
                | {switch, fsplit()}
-               | {set_state, state_reg(), fexpr()}
-               | {get_state, state_reg()}
                %% The following (unapplied top-level functions/builtins and
                %% lambdas) are generated by the fcode compiler, but translated
                %% to closures by the lambda lifter.
@@ -113,7 +109,6 @@
 
 -type fcode() :: #{ contract_name := string(),
                     state_type    := ftype(),
-                    state_layout  := state_layout(),
                     event_type    := ftype() | none,
                     functions     := #{ fun_name() => fun_def() },
                     payable       := boolean() }.
@@ -135,18 +130,15 @@
                  | {namespace, string()}
                  | {abstract_contract, string()}.
 
--type state_layout() :: {tuple, [state_layout()]} | {reg, state_reg()}.
-
--type env() :: #{ type_env     := type_env(),
-                  fun_env      := fun_env(),
-                  con_env      := con_env(),
-                  event_type   => aeso_syntax:typedef(),
-                  builtins     := builtins(),
-                  options      := [option()],
-                  state_layout => state_layout(),
-                  context      => context(),
-                  vars         => [var_name()],
-                  functions    := #{ fun_name() => fun_def() } }.
+-type env() :: #{ type_env   := type_env(),
+                  fun_env    := fun_env(),
+                  con_env    := con_env(),
+                  event_type => aeso_syntax:typedef(),
+                  builtins   := builtins(),
+                  options    := [option()],
+                  context    => context(),
+                  vars       => [var_name()],
+                  functions  := #{ fun_name() => fun_def() } }.
 
 -define(HASH_BYTES, 32).
 
@@ -157,14 +149,12 @@
 -spec ast_to_fcode(aeso_syntax:ast(), [option()]) -> fcode().
 ast_to_fcode(Code, Options) ->
     Verbose = lists:member(pp_fcode, Options),
-    init_fresh_names(),
     FCode1 = to_fcode(init_env(Options), Code),
     [io:format("-- Before lambda lifting --\n~s\n\n", [format_fcode(FCode1)]) || Verbose],
-    FCode2 = optimize_fcode(FCode1),
-    [ io:format("-- After optimization --\n~s\n\n", [format_fcode(FCode2)]) || Verbose, FCode2 /= FCode1 ],
-    FCode3 = lambda_lift(FCode2),
-    [ io:format("-- After lambda lifting --\n~s\n\n", [format_fcode(FCode3)]) || Verbose, FCode3 /= FCode2 ],
-    clear_fresh_names(),
+    FCode2 = lambda_lift(FCode1),
+    [ io:format("-- After lambda lifting --\n~s\n\n", [format_fcode(FCode2)]) || Verbose, FCode2 /= FCode1 ],
+    FCode3 = optimize_fcode(FCode2),
+    [ io:format("-- After optimization --\n~s\n\n", [format_fcode(FCode3)]) || Verbose, FCode3 /= FCode2 ],
     FCode3.
 
 %% -- Environment ------------------------------------------------------------
@@ -210,14 +200,12 @@ builtins() ->
                               {"union", 2}, {"difference", 2}, {"none", none}, {"all", none}]},
               {["Bytes"],    [{"to_int", 1}, {"to_str", 1}, {"concat", 2}, {"split", 1}]},
               {["Int"],      [{"to_str", 1}]},
-              {["Address"],  [{"to_str", 1}, {"to_contract", 1}, {"is_oracle", 1}, {"is_contract", 1}, {"is_payable", 1}]}
+              {["Address"],  [{"to_str", 1}, {"is_oracle", 1}, {"is_contract", 1}, {"is_payable", 1}]}
              ],
     maps:from_list([ {NS ++ [Fun], {MkName(NS, Fun), Arity}}
                      || {NS, Funs} <- Scopes,
                         {Fun, Arity} <- Funs ]).
 
-state_layout(Env) -> maps:get(state_layout, Env, {reg, 1}).
-
 -define(type(T),       fun([])     -> T end).
 -define(type(X, T),    fun([X])    -> T end).
 -define(type(X, Y, T), fun([X, Y]) -> T end).
@@ -233,7 +221,7 @@ init_type_env() ->
        ["hash"]         => ?type(hash),
        ["signature"]    => ?type(signature),
        ["oracle"]       => ?type(Q, R, {oracle, Q, R}),
-       ["oracle_query"] => ?type(_, _, oracle_query),
+       ["oracle_query"] => ?type(_, _, oracle_query),    %% TODO: not in Fate
        ["list"]         => ?type(T, {list, T}),
        ["map"]          => ?type(K, V, {map, K, V}),
        ["option"]       => ?type(T, {variant, [[], [T]]}),
@@ -241,13 +229,7 @@ init_type_env() ->
      }.
 
 is_no_code(Env) ->
-    get_option(no_code, Env).
-
-get_option(Opt, Env) ->
-    get_option(Opt, Env, false).
-
-get_option(Opt, Env, Default) ->
-    proplists:get_value(Opt, maps:get(options, Env, []), Default).
+    proplists:get_value(no_code, maps:get(options, Env, []), false).
 
 %% -- Compilation ------------------------------------------------------------
 
@@ -260,13 +242,11 @@ to_fcode(Env, [{contract, Attrs, MainCon = {con, _, Main}, Decls}]) ->
                                           [Main, "Chain", "event"] => {chain_event, 1}} },
     #{ functions := Funs } = Env1 =
         decls_to_fcode(MainEnv, Decls),
-    StateType   = lookup_type(Env1, [Main, "state"], [], {tuple, []}),
-    EventType   = lookup_type(Env1, [Main, "event"], [], none),
-    StateLayout = state_layout(Env1),
-    Payable     = proplists:get_value(payable, Attrs, false),
+    StateType = lookup_type(Env1, [Main, "state"], [], {tuple, []}),
+    EventType = lookup_type(Env1, [Main, "event"], [], none),
+    Payable   = proplists:get_value(payable, Attrs, false),
     #{ contract_name => Main,
        state_type    => StateType,
-       state_layout  => StateLayout,
        event_type    => EventType,
        payable       => Payable,
        functions     => add_init_function(Env1, MainCon, StateType,
@@ -286,11 +266,14 @@ decls_to_fcode(Env, Decls) ->
     %% environment.
     Env1 = add_fun_env(Env, Decls),
     lists:foldl(fun(D, E) ->
+                    init_fresh_names(),
                     R = decl_to_fcode(E, D),
+                    clear_fresh_names(),
                     R
                 end, Env1, Decls).
 
 -spec decl_to_fcode(env(), aeso_syntax:decl()) -> env().
+decl_to_fcode(Env, {type_decl, _, _, _}) -> Env;
 decl_to_fcode(Env = #{context := {main_contract, _}}, {fun_decl, _, Id, _}) ->
     case is_no_code(Env) of
         false -> fcode_error({missing_definition, Id});
@@ -321,15 +304,14 @@ typedef_to_fcode(Env, Id = {id, _, Name}, Xs, Def) ->
     FDef = fun(Args) when length(Args) == length(Xs) ->
                 Sub = maps:from_list(lists:zip([X || {tvar, _, X} <- Xs], Args)),
                 case Def of
-                    {record_t, Fields} ->
-                        {tuple, [type_to_fcode(Env, Sub, T) || {field_t, _, _, T} <- Fields]};
+                    {record_t, Fields} -> {todo, Xs, Args, record_t, Fields};
                     {variant_t, Cons}  ->
                         FCons = [ begin
                                       {constr_t, _, _, Ts} = Con,
                                       [type_to_fcode(Env, Sub, T) || T <- Ts]
                                   end || Con <- Cons ],
                         {variant, FCons};
-                    {alias_t, Type}    -> type_to_fcode(Env, Sub, Type)
+                    {alias_t, Type}    -> {todo, Xs, Args, alias_t, Type}
                 end;
               (Args) -> internal_error({type_arity_mismatch, Name, length(Args), length(Xs)})
            end,
@@ -351,34 +333,7 @@ typedef_to_fcode(Env, Id = {id, _, Name}, Xs, Def) ->
              "event" -> Env1#{ event_type => Def };
              _       -> Env1
            end,
-    Env3 = compute_state_layout(Env2, Name, FDef),
-    bind_type(Env3, Q, FDef).
-
-compute_state_layout(Env = #{ context := {main_contract, _} }, "state", Type) ->
-    NoLayout = get_option(no_flatten_state, Env),
-    Layout =
-        case Type([]) of
-            _ when NoLayout -> {reg, 1};
-            T ->
-                {_, L} = compute_state_layout(1, T),
-                L
-        end,
-    Env#{ state_layout => Layout };
-compute_state_layout(Env, _, _) -> Env.
-
-compute_state_layout(R, {tuple, [T]}) ->
-    compute_state_layout(R, T);
-compute_state_layout(R, {tuple, Ts}) ->
-    {R1, Ls} = compute_state_layout(R, Ts),
-    {R1, {tuple, Ls}};
-compute_state_layout(R, []) ->
-    {R, []};
-compute_state_layout(R, [H | T]) ->
-    {R1, H1} = compute_state_layout(R, H),
-    {R2, T1} = compute_state_layout(R1, T),
-    {R2, [H1 | T1]};
-compute_state_layout(R, _) ->
-    {R + 1, {reg, R}}.
+    bind_type(Env2, Q, FDef).
 
 check_state_and_event_types(#{ context := {main_contract, _} }, Id, [_ | _]) ->
     case Id of
@@ -414,12 +369,9 @@ type_to_fcode(Env, Sub, {fun_t, _, Named, Args, Res}) ->
 type_to_fcode(_Env, _Sub, Type) ->
     error({todo, Type}).
 
--spec args_to_fcode(env(), [aeso_syntax:pat()]) -> [{var_name(), ftype()}].
+-spec args_to_fcode(env(), [aeso_syntax:arg()]) -> [{var_name(), ftype()}].
 args_to_fcode(Env, Args) ->
-    [ case Arg of
-          {id, _, Name} -> {Name, type_to_fcode(Env, Type)};
-          _ -> internal_error({bad_arg, Arg})   %% Pattern matching has been moved to the rhs at this point
-      end || {typed, _, Arg, Type} <- Args ].
+    [ {Name, type_to_fcode(Env, Type)} || {arg, _, {id, _, Name}, Type} <- Args ].
 
 -define(make_let(X, Expr, Body),
         make_let(Expr, fun(X) -> Body end)).
@@ -434,13 +386,6 @@ make_let(Expr, Body) ->
             {'let', X, Expr, Body({var, X})}
     end.
 
-let_bind(X, {var, Y}, Body) -> rename([{X, Y}], Body);
-let_bind(X, Expr, Body)     -> {'let', X, Expr, Body}.
-
-let_bind(Binds, Body) ->
-    lists:foldr(fun({X, E}, Rest) -> let_bind(X, E, Rest) end,
-                Body, Binds).
-
 -spec expr_to_fcode(env(), aeso_syntax:expr()) -> fexpr().
 expr_to_fcode(Env, {typed, _, Expr, Type}) ->
     expr_to_fcode(Env, Type, Expr);
@@ -501,7 +446,7 @@ expr_to_fcode(Env, _Type, {app, _, {typed, _, {C, _, _} = Con, _}, Args}) when C
 
 %% Tuples
 expr_to_fcode(Env, _Type, {tuple, _, Es}) ->
-    make_tuple([expr_to_fcode(Env, E) || E <- Es]);
+    {tuple, [expr_to_fcode(Env, E) || E <- Es]};
 
 %% Records
 expr_to_fcode(Env, Type, {proj, _Ann, Rec = {typed, _, _, RecType}, {id, _, X}}) ->
@@ -513,28 +458,18 @@ expr_to_fcode(Env, Type, {proj, _Ann, Rec = {typed, _, _, RecType}, {id, _, X}})
             FArgs = [type_to_fcode(Env, Arg) || Arg <- Args],
             {remote_u, FArgs, type_to_fcode(Env, Ret), expr_to_fcode(Env, Rec),
                        {entrypoint, list_to_binary(X)}};
-        {record_t, [_]} -> expr_to_fcode(Env, Rec); %% Singleton record
         {record_t, _} ->
             {proj, expr_to_fcode(Env, Rec), field_index(Rec, X)}
     end;
 
-expr_to_fcode(Env, {record_t, [FieldT]}, {record, _Ann, [_] = Fields}) ->
-    {set, E} = field_value(FieldT, Fields),
-    expr_to_fcode(Env, E);
 expr_to_fcode(Env, {record_t, FieldTypes}, {record, _Ann, Fields}) ->
     FVal = fun(F) ->
              %% All fields are present and no updates
              {set, E} = field_value(F, Fields),
              expr_to_fcode(Env, E)
            end,
-    make_tuple(lists:map(FVal, FieldTypes));
+    {tuple, lists:map(FVal, FieldTypes)};
 
-expr_to_fcode(Env, {record_t, [FieldT]}, {record, _Ann, Rec, Fields}) ->
-    case field_value(FieldT, Fields) of
-        false       -> expr_to_fcode(Env, Rec);
-        {set, E}    -> expr_to_fcode(Env, E);
-        {upd, Z, E} -> {'let', Z, expr_to_fcode(Env, Rec), expr_to_fcode(bind_var(Env, Z), E)}
-    end;
 expr_to_fcode(Env, {record_t, FieldTypes}, {record, _Ann, Rec, Fields}) ->
     X    = fresh_name(),
     Proj = fun(I) -> {proj, {var, X}, I - 1} end,
@@ -566,12 +501,9 @@ expr_to_fcode(Env, _Type, {app, _, {'..', _}, [A, B]}) ->
 
 expr_to_fcode(Env, _Type, {list_comp, _, Yield, []}) ->
     {op, '::', [expr_to_fcode(Env, Yield), nil]};
-expr_to_fcode(Env, _Type, {list_comp, As, Yield, [{comprehension_bind, Pat = {typed, _, _, PatType}, BindExpr}|Rest]}) ->
-    Arg  = fresh_name(),
+expr_to_fcode(Env, _Type, {list_comp, As, Yield, [{comprehension_bind, {typed, {id, _, Arg}, _}, BindExpr}|Rest]}) ->
     Env1 = bind_var(Env, Arg),
-    Bind = {lam, [Arg], expr_to_fcode(Env1, {switch, As, {typed, As, {id, As, Arg}, PatType},
-                                                [{'case', As, Pat, {list_comp, As, Yield, Rest}},
-                                                 {'case', As, {id, As, "_"}, {list, As, []}}]})},
+    Bind = {lam, [Arg], expr_to_fcode(Env1, {list_comp, As, Yield, Rest})},
     {def_u, FlatMap, _} = resolve_fun(Env, ["ListInternal", "flat_map"]),
     {def, FlatMap, [Bind, expr_to_fcode(Env, BindExpr)]};
 expr_to_fcode(Env, Type, {list_comp, As, Yield, [{comprehension_if, _, Cond}|Rest]}) ->
@@ -579,7 +511,7 @@ expr_to_fcode(Env, Type, {list_comp, As, Yield, [{comprehension_if, _, Cond}|Res
             expr_to_fcode(Env, Type, {list_comp, As, Yield, Rest}),
             nil
            );
-expr_to_fcode(Env, Type, {list_comp, As, Yield, [LV = {letval, _, _, _}|Rest]}) ->
+expr_to_fcode(Env, Type, {list_comp, As, Yield, [LV = {letval, _, _, _, _}|Rest]}) ->
     expr_to_fcode(Env, Type, {block, As, [LV, {list_comp, As, Yield, Rest}]});
 expr_to_fcode(Env, Type, {list_comp, As, Yield, [LF = {letfun, _, _, _, _, _}|Rest]}) ->
     expr_to_fcode(Env, Type, {block, As, [LF, {list_comp, As, Yield, Rest}]});
@@ -624,8 +556,8 @@ expr_to_fcode(Env, _Type, {app, _, Fun = {typed, _, _, {fun_t, _, NamedArgsT, _,
     Args1 = get_named_args(NamedArgsT, Args),
     FArgs = [expr_to_fcode(Env, Arg) || Arg <- Args1],
     case expr_to_fcode(Env, Fun) of
-        {builtin_u, B, _Ar, TypeArgs}     -> builtin_to_fcode(state_layout(Env), B, FArgs ++ TypeArgs);
-        {builtin_u, B, _Ar}               -> builtin_to_fcode(state_layout(Env), B, FArgs);
+        {builtin_u, B, _Ar, TypeArgs}     -> builtin_to_fcode(B, FArgs ++ TypeArgs);
+        {builtin_u, B, _Ar}               -> builtin_to_fcode(B, FArgs);
         {def_u, F, _Ar}                   -> {def, F, FArgs};
         {remote_u, ArgsT, RetT, Ct, RFun} -> {remote, ArgsT, RetT, Ct, RFun, FArgs};
         FFun ->
@@ -689,13 +621,6 @@ make_if(Cond, Then, Else) ->
     X = fresh_name(),
     {'let', X, Cond, make_if({var, X}, Then, Else)}.
 
--spec make_tuple([fexpr()]) -> fexpr().
-make_tuple([E]) -> E;
-make_tuple(Es) -> {tuple, Es}.
-
--spec strip_singleton_tuples(ftype()) -> ftype().
-strip_singleton_tuples({tuple, [T]}) -> strip_singleton_tuples(T);
-strip_singleton_tuples(T) -> T.
 
 get_oracle_type(oracle_register,     {fun_t, _, _, _, OType})       -> OType;
 get_oracle_type(oracle_query,        {fun_t, _, _, [OType | _], _}) -> OType;
@@ -724,7 +649,7 @@ validate_aens_resolve_type(Ann, {app_t, _, _, [Type]}, {variant, [[], [FType]]})
 
 ensure_first_order_entrypoint(Ann, Id = {id, _, Name}, Args, Ret, FArgs, FRet) ->
     [ ensure_first_order(FT, {invalid_entrypoint, higher_order, Ann1, Id, {argument, X, T}})
-      || {{typed, Ann1, X, T}, {_, FT}} <- lists:zip(Args, FArgs) ],
+      || {{arg, Ann1, X, T}, {_, FT}} <- lists:zip(Args, FArgs) ],
     [ ensure_first_order(FRet, {invalid_entrypoint, higher_order, Ann, Id, {result, Ret}})
       || Name /= "init" ],  %% init can return higher-order values, since they're written to the store
                             %% rather than being returned.
@@ -783,13 +708,10 @@ split_tree(Env, Vars, Alts = [{'case', Pats, Body} | _]) ->
             {nosplit, rename(Ren, Body)};
         I when is_integer(I) ->
             {Vars0, [{X, Type} | Vars1]} = lists:split(I - 1, Vars),
-            Type1 = strip_singleton_tuples(Type),
             SAlts = merge_alts(I, X, [ split_alt(I, A) || A <- Alts ]),
-            MakeCase = fun({var, Z}, Split) -> {'case', {var, "_"}, rename_split([{Z, X}], Split)};
-                          (SPat, Split)     -> {'case', SPat, Split} end,
-            Cases = [ MakeCase(SPat, split_tree(Env, Vars0 ++ split_vars(SPat, Type1) ++ Vars1, FAlts))
+            Cases = [ {'case', SPat, split_tree(Env, Vars0 ++ split_vars(SPat, Type) ++ Vars1, FAlts)}
                       || {SPat, FAlts} <- SAlts ],
-            {split, Type1, X, Cases}
+            {split, Type, X, Cases}
     end.
 
 -spec merge_alts(integer(), var_name(), [{fsplit_pat(), falt()}]) -> [{fsplit_pat(), [falt()]}].
@@ -912,7 +834,7 @@ pat_to_fcode(Env, _Type, {app, _, {typed, _, {C, _, _} = Con, _}, Pats}) when C
     #con_tag{tag = I, arities = As} = lookup_con(Env, Con),
     {con, As, I, [pat_to_fcode(Env, Pat) || Pat <- Pats]};
 pat_to_fcode(Env, _Type, {tuple, _, Pats}) ->
-    make_tuple([ pat_to_fcode(Env, Pat) || Pat <- Pats ]);
+    {tuple, [ pat_to_fcode(Env, Pat) || Pat <- Pats ]};
 pat_to_fcode(_Env, _Type, {bool, _, B})   -> {bool, B};
 pat_to_fcode(_Env, _Type, {int, _, N})    -> {int, N};
 pat_to_fcode(_Env, _Type, {char, _, N})   -> {int, N};
@@ -930,8 +852,8 @@ pat_to_fcode(Env, {record_t, Fields}, {record, _, FieldPats}) ->
                         {set, Pat} -> Pat
                         %% {upd, _, _} is impossible in patterns
                     end end,
-    make_tuple([pat_to_fcode(Env, FieldPat(Field))
-                || Field <- Fields]);
+    {tuple, [pat_to_fcode(Env, FieldPat(Field))
+             || Field <- Fields]};
 
 pat_to_fcode(_Env, Type, Pat) ->
     error({todo, Pat, ':', Type}).
@@ -965,16 +887,10 @@ decision_tree_to_fcode({'if', A, Then, Else}) ->
 %% -- Statements --
 
 -spec stmts_to_fcode(env(), [aeso_syntax:stmt()]) -> fexpr().
-stmts_to_fcode(Env, [{letval, _, {typed, _, {id, _, X}, _}, Expr} | Stmts]) ->
+stmts_to_fcode(Env, [{letval, _, {typed, _, {id, _, X}, _}, _, Expr} | Stmts]) ->
     {'let', X, expr_to_fcode(Env, Expr), stmts_to_fcode(bind_var(Env, X), Stmts)};
-stmts_to_fcode(Env, [{letval, Ann, Pat, Expr} | Stmts]) ->
-    expr_to_fcode(Env, {switch, Ann, Expr, [{'case', Ann, Pat, {block, Ann, Stmts}}]});
 stmts_to_fcode(Env, [{letfun, Ann, {id, _, X}, Args, _Type, Expr} | Stmts]) ->
-    LamArgs = [ case Arg of
-                    {typed, Ann1, Id, T} -> {arg, Ann1, Id, T};
-                    _ -> internal_error({bad_arg, Arg})   %% pattern matching has been desugared
-                end || Arg <- Args ],
-    {'let', X, expr_to_fcode(Env, {lam, Ann, LamArgs, Expr}),
+    {'let', X, expr_to_fcode(Env, {lam, Ann, Args, Expr}),
                stmts_to_fcode(bind_var(Env, X), Stmts)};
 stmts_to_fcode(Env, [Expr]) ->
     expr_to_fcode(Env, Expr);
@@ -988,45 +904,27 @@ op_builtins() ->
      string_length, string_concat, string_sha3, string_sha256, string_blake2b,
      bits_set, bits_clear, bits_test, bits_sum, bits_intersection, bits_union,
      bits_difference, int_to_str, address_to_str, crypto_verify_sig,
-     address_to_contract,
      crypto_verify_sig_secp256k1, crypto_sha3, crypto_sha256, crypto_blake2b,
      crypto_ecverify_secp256k1, crypto_ecrecover_secp256k1
     ].
 
-set_state({reg, R}, Val) ->
-    {set_state, R, Val};
-set_state({tuple, Ls}, Val) ->
-    ?make_let(X, Val,
-    lists:foldr(fun({I, L}, Code) ->
-                    {'let', "_", set_state(L, {proj, X, I - 1}), Code}
-                end, {tuple, []}, indexed(Ls))).
-
-get_state({reg, R}) ->
-    {get_state, R};
-get_state({tuple, Ls}) ->
-    {tuple, [get_state(L) || L <- Ls]}.
-
-builtin_to_fcode(Layout, set_state, [Val]) ->
-    set_state(Layout, Val);
-builtin_to_fcode(Layout, get_state, []) ->
-    get_state(Layout);
-builtin_to_fcode(_Layout, require, [Cond, Msg]) ->
+builtin_to_fcode(require, [Cond, Msg]) ->
     make_if(Cond, {tuple, []}, {builtin, abort, [Msg]});
-builtin_to_fcode(_Layout, chain_event, [Event]) ->
+builtin_to_fcode(chain_event, [Event]) ->
     {def, event, [Event]};
-builtin_to_fcode(_Layout, map_delete, [Key, Map]) ->
+builtin_to_fcode(map_delete, [Key, Map]) ->
     {op, map_delete, [Map, Key]};
-builtin_to_fcode(_Layout, map_member, [Key, Map]) ->
+builtin_to_fcode(map_member, [Key, Map]) ->
     {op, map_member, [Map, Key]};
-builtin_to_fcode(_Layout, map_lookup, [Key0, Map0]) ->
+builtin_to_fcode(map_lookup, [Key0, Map0]) ->
     ?make_let(Key, Key0,
     ?make_let(Map, Map0,
      make_if({op, map_member, [Map, Key]},
              {con, [0, 1], 1, [{op, map_get, [Map, Key]}]},
              {con, [0, 1], 0, []})));
-builtin_to_fcode(_Layout, map_lookup_default, [Key, Map, Def]) ->
+builtin_to_fcode(map_lookup_default, [Key, Map, Def]) ->
     {op, map_get_d, [Map, Key, Def]};
-builtin_to_fcode(_Layout, Builtin, Args) ->
+builtin_to_fcode(Builtin, Args) ->
     case lists:member(Builtin, op_builtins()) of
         true  -> {op, Builtin, Args};
         false -> {builtin, Builtin, Args}
@@ -1041,9 +939,8 @@ add_init_function(Env, Main, StateType, Funs0) ->
             Funs     = add_default_init_function(Env, Main, StateType, Funs0),
             InitName = {entrypoint, <<"init">>},
             InitFun  = #{ body := InitBody} = maps:get(InitName, Funs),
-            Funs1 = Funs#{ InitName => InitFun#{ return => {tuple, []},
-                                                 body   => builtin_to_fcode(state_layout(Env), set_state, [InitBody]) } },
-            Funs1
+            Funs#{ InitName => InitFun#{ return => {tuple, []},
+                                         body   => {builtin, set_state, [InitBody]} } }
     end.
 
 add_default_init_function(_Env, Main, StateType, Funs) ->
@@ -1094,10 +991,12 @@ event_function(_Env = #{event_type := {variant_t, EventCons}}, EventType = {vari
 %% the top-level and replace it with a closure.
 
 -spec lambda_lift(fcode()) -> fcode().
-lambda_lift(FCode = #{ functions := Funs, state_layout := StateLayout }) ->
+lambda_lift(FCode = #{ functions := Funs }) ->
+    init_fresh_names(),
     init_lambda_funs(),
-    Funs1   = maps:map(fun(_, Body) -> lambda_lift_fun(StateLayout, Body) end, Funs),
+    Funs1   = maps:map(fun lambda_lift_fun/2, Funs),
     NewFuns = get_lambda_funs(),
+    clear_fresh_names(),
     FCode#{ functions := maps:merge(Funs1, NewFuns) }.
 
 -define(lambda_key, '%lambdalifted').
@@ -1110,8 +1009,8 @@ add_lambda_fun(Def) ->
     put(?lambda_key, Funs#{ Name => Def }),
     Name.
 
-lambda_lift_fun(Layout, Def = #{ body := Body }) ->
-    Def#{ body := lambda_lift_expr(Layout, Body) }.
+lambda_lift_fun(_, Def = #{ body := Body }) ->
+    Def#{ body := lambda_lift_expr(Body) }.
 
 lifted_fun([Z], Xs, Body) ->
     #{ attrs  => [private],
@@ -1132,10 +1031,10 @@ make_closure(FVs, Xs, Body) ->
     Tup = fun([Y]) -> Y; (Ys) -> {tuple, Ys} end,
     {closure, Fun, Tup([{var, Y} || Y <- FVs])}.
 
-lambda_lift_expr(Layout, {lam, Xs, Body}) ->
+lambda_lift_expr({lam, Xs, Body}) ->
     FVs   = free_vars({lam, Xs, Body}),
-    make_closure(FVs, Xs, lambda_lift_expr(Layout, Body));
-lambda_lift_expr(Layout, UExpr) when element(1, UExpr) == def_u; element(1, UExpr) == builtin_u ->
+    make_closure(FVs, Xs, lambda_lift_expr(Body));
+lambda_lift_expr(UExpr) when element(1, UExpr) == def_u; element(1, UExpr) == builtin_u ->
     [Tag, F, Ar | _] = tuple_to_list(UExpr),
     ExtraArgs = case UExpr of
                     {builtin_u, _, _, TypeArgs} -> TypeArgs;
@@ -1144,42 +1043,40 @@ lambda_lift_expr(Layout, UExpr) when element(1, UExpr) == def_u; element(1, UExp
     Xs   = [ lists:concat(["arg", I]) || I <- lists:seq(1, Ar) ],
     Args = [{var, X} || X <- Xs] ++ ExtraArgs,
     Body = case Tag of
-               builtin_u -> builtin_to_fcode(Layout, F, Args);
+               builtin_u -> builtin_to_fcode(F, Args);
                def_u     -> {def, F, Args}
            end,
     make_closure([], Xs, Body);
-lambda_lift_expr(Layout, {remote_u, ArgsT, RetT, Ct, F}) ->
+lambda_lift_expr({remote_u, ArgsT, RetT, Ct, F}) ->
     FVs  = free_vars(Ct),
-    Ct1  = lambda_lift_expr(Layout, Ct),
+    Ct1  = lambda_lift_expr(Ct),
     GasAndValueArgs = 2,
     Xs   = [ lists:concat(["arg", I]) || I <- lists:seq(1, length(ArgsT) + GasAndValueArgs) ],
     Args = [{var, X} || X <- Xs],
     make_closure(FVs, Xs, {remote, ArgsT, RetT, Ct1, F, Args});
-lambda_lift_expr(Layout, Expr) ->
+lambda_lift_expr(Expr) ->
     case Expr of
         {lit, _}               -> Expr;
         nil                    -> Expr;
         {var, _}               -> Expr;
         {closure, _, _}        -> Expr;
-        {def, D, As}           -> {def, D, lambda_lift_exprs(Layout, As)};
-        {builtin, B, As}       -> {builtin, B, lambda_lift_exprs(Layout, As)};
-        {remote, ArgsT, RetT, Ct, F, As} -> {remote, ArgsT, RetT, lambda_lift_expr(Layout, Ct), F, lambda_lift_exprs(Layout, As)};
-        {con, Ar, C, As}       -> {con, Ar, C, lambda_lift_exprs(Layout, As)};
-        {tuple, As}            -> {tuple, lambda_lift_exprs(Layout, As)};
-        {proj, A, I}           -> {proj, lambda_lift_expr(Layout, A), I};
-        {set_proj, A, I, B}    -> {set_proj, lambda_lift_expr(Layout, A), I, lambda_lift_expr(Layout, B)};
-        {op, Op, As}           -> {op, Op, lambda_lift_exprs(Layout, As)};
-        {'let', X, A, B}       -> {'let', X, lambda_lift_expr(Layout, A), lambda_lift_expr(Layout, B)};
-        {funcall, A, Bs}       -> {funcall, lambda_lift_expr(Layout, A), lambda_lift_exprs(Layout, Bs)};
-        {set_state, R, A}      -> {set_state, R, lambda_lift_expr(Layout, A)};
-        {get_state, _}         -> Expr;
-        {switch, S}            -> {switch, lambda_lift_expr(Layout, S)};
-        {split, Type, X, Alts} -> {split, Type, X, lambda_lift_exprs(Layout, Alts)};
-        {nosplit, A}           -> {nosplit, lambda_lift_expr(Layout, A)};
-        {'case', P, S}         -> {'case', P, lambda_lift_expr(Layout, S)}
+        {def, D, As}           -> {def, D, lambda_lift_exprs(As)};
+        {builtin, B, As}       -> {builtin, B, lambda_lift_exprs(As)};
+        {remote, ArgsT, RetT, Ct, F, As} -> {remote, ArgsT, RetT, lambda_lift_expr(Ct), F, lambda_lift_exprs(As)};
+        {con, Ar, C, As}       -> {con, Ar, C, lambda_lift_exprs(As)};
+        {tuple, As}            -> {tuple, lambda_lift_exprs(As)};
+        {proj, A, I}           -> {proj, lambda_lift_expr(A), I};
+        {set_proj, A, I, B}    -> {set_proj, lambda_lift_expr(A), I, lambda_lift_expr(B)};
+        {op, Op, As}           -> {op, Op, lambda_lift_exprs(As)};
+        {'let', X, A, B}       -> {'let', X, lambda_lift_expr(A), lambda_lift_expr(B)};
+        {funcall, A, Bs}       -> {funcall, lambda_lift_expr(A), lambda_lift_exprs(Bs)};
+        {switch, S}            -> {switch, lambda_lift_expr(S)};
+        {split, Type, X, Alts} -> {split, Type, X, lambda_lift_exprs(Alts)};
+        {nosplit, A}           -> {nosplit, lambda_lift_expr(A)};
+        {'case', P, S}         -> {'case', P, lambda_lift_expr(S)}
     end.
 
-lambda_lift_exprs(Layout, As) -> [lambda_lift_expr(Layout, A) || A <- As].
+lambda_lift_exprs(As) -> [lambda_lift_expr(A) || A <- As].
 
 %% -- Optimisations ----------------------------------------------------------
 
@@ -1197,12 +1094,7 @@ optimize_fcode(Code = #{ functions := Funs }) ->
 -spec optimize_fun(fcode(), fun_name(), fun_def()) -> fun_def().
 optimize_fun(Fcode, Fun, Def = #{ body := Body }) ->
     %% io:format("Optimizing ~p =\n~s\n", [_Fun, prettypr:format(pp_fexpr(_Body))]),
-    Def#{ body := drop_unused_lets(
-                  simplifier(
-                  let_floating(
-                  bind_subexpressions(
-                  inline_local_functions(
-                  inliner(Fcode, Fun, Body)))))) }.
+    Def#{ body := inliner(Fcode, Fun, Body) }.
 
 %% --- Inlining ---
 
@@ -1218,276 +1110,6 @@ should_inline(_Fcode, _Fun1) -> false == list_to_atom("true").  %% Dialyzer
 
 inline(_Fcode, Fun, Args) -> {def, Fun, Args}. %% TODO
 
-%% --- Bind subexpressions ---
-
--define(make_lets(Xs, Es, Body), make_lets(Es, fun(Xs) -> Body end)).
-
-bind_subexpressions(Expr) ->
-    bottom_up(fun bind_subexpressions/2, Expr).
-
-bind_subexpressions(_, {tuple, Es}) ->
-    ?make_lets(Xs, Es, {tuple, Xs});
-bind_subexpressions(_, {set_proj, A, I, B}) ->
-    ?make_lets([X, Y], [A, B], {set_proj, X, I, Y});
-bind_subexpressions(_, E) -> E.
-
-make_lets(Es, Body) -> make_lets(Es, [], Body).
-
-make_lets([], Xs, Body)       -> Body(lists:reverse(Xs));
-make_lets([{var, _} = E | Es], Xs, Body) ->
-    make_lets(Es, [E | Xs], Body);
-make_lets([{lit, _} = E | Es], Xs, Body) ->
-    make_lets(Es, [E | Xs], Body);
-make_lets([E | Es], Xs, Body) ->
-    ?make_let(X, E, make_lets(Es, [X | Xs], Body)).
-
-%% --- Inline local functions ---
-
-inline_local_functions(Expr) ->
-    bottom_up(fun inline_local_functions/2, Expr).
-
-inline_local_functions(Env, {funcall, {proj, {var, Y}, 0}, [{proj, {var, Y}, 1} | Args]} = Expr) ->
-    %% TODO: Don't always inline local funs?
-    case maps:get(Y, Env, free) of
-        {lam, Xs, Body} -> let_bind(lists:zip(Xs, Args), Body);
-        _               -> Expr
-    end;
-inline_local_functions(_, Expr) -> Expr.
-
-%% --- Let-floating ---
-
-let_floating(Expr) -> bottom_up(fun let_float/2, Expr).
-
-let_float(_, {'let', X, E, Body}) ->
-    pull_out_let({'let', X, {here, E}, Body});
-let_float(_, {proj, E, I}) ->
-    pull_out_let({proj, {here, E}, I});
-let_float(_, {set_proj, E, I, V}) ->
-    pull_out_let({set_proj, {here, E}, I, {here, V}});
-let_float(_, {op, Op, Es}) ->
-    {Lets, Es1} = pull_out_let([{here, E} || E <- Es]),
-    let_bind(Lets, {op, Op, Es1});
-let_float(_, E) -> E.
-
-pull_out_let(Expr) when is_tuple(Expr) ->
-    {Lets, Es} = pull_out_let(tuple_to_list(Expr)),
-    Inner = list_to_tuple(Es),
-    let_bind(Lets, Inner);
-pull_out_let(Es) when is_list(Es) ->
-    case lists:splitwith(fun({here, _}) -> false; (_) -> true end, Es) of
-        {Es0, [{here, E} | Es1]} ->
-            case let_view(E) of
-                {[], _}    ->
-                    {Lets, Es2} = pull_out_let(Es1),
-                    {Lets, Es0 ++ [E] ++ Es2};
-                {Lets, E1} ->
-                    {Lets1, Es2} = pull_out_let(Es1),
-                    {Lets ++ Lets1, Es0 ++ [E1] ++ Es2}
-            end;
-        {_, []} -> {[], Es}
-    end.
-
-%% Also renames the variables to fresh names
-let_view(E) -> let_view(E, [], []).
-
-let_view({'let', X, E, Rest}, Ren, Lets) ->
-    Z = fresh_name(),
-    let_view(Rest, [{X, Z} | Ren], [{Z, rename(Ren, E)} | Lets]);
-let_view(E, Ren, Lets) ->
-    {lists:reverse(Lets), rename(Ren, E)}.
-
-%% --- Simplification ---
-
--spec simplifier(fexpr()) -> fexpr().
-simplifier(Expr) ->
-    bottom_up(fun simplify/2, Expr).
-
--spec simplify(#{var_name() => fexpr()}, fexpr()) -> fexpr().
-
-%% (e₀, .., en).i ->
-%% let _ = e₀ in .. let x = ei in .. let _ = en in x
-simplify(_Env, {proj, {tuple, Es}, I}) ->
-    It  = lists:nth(I + 1, Es),
-    X   = fresh_name(),
-    Dup = safe_to_duplicate(It),
-    Val = if Dup -> It; true -> {var, X} end,
-    lists:foldr(
-      fun({J, E}, Rest) when I == J ->
-            case Dup of
-                true  -> Rest;
-                false -> {'let', X, E, Rest}
-            end;
-         ({_, E}, Rest) ->
-            case read_only(E) of
-                true  -> Rest;
-                false -> {'let', "_", E, Rest}
-            end
-        end, Val, indexed(Es));
-
-%% let x = e in .. x.i ..
-simplify(Env, {proj, {var, X}, I} = Expr) ->
-    case simpl_proj(Env, I, {var, X}) of
-        false -> Expr;
-        E     -> E
-    end;
-
-simplify(Env, {switch, Split}) ->
-    case simpl_switch(Env, [], Split) of
-        nomatch -> {builtin, abort, [{lit, {string, <<"Incomplete patterns">>}}]};
-        stuck   -> {switch, Split};
-        Expr    -> Expr
-    end;
-
-simplify(_, E) ->
-    E.
-
-simpl_proj(Env, I, Expr) ->
-    IfSafe = fun(E) -> case safe_to_duplicate(E) of
-                         true -> E;
-                         false -> false
-                       end end,
-    case Expr of
-        false                 -> false;
-        {var, X}              -> simpl_proj(Env, I, maps:get(X, Env, false));
-        {tuple, Es}           -> IfSafe(lists:nth(I + 1, Es));
-        {set_proj, _, I, Val} -> IfSafe(Val);
-        {set_proj, E, _, _}   -> simpl_proj(Env, I, E);
-        {proj, E, J}          -> simpl_proj(Env, I, simpl_proj(Env, J, E));
-        _                     -> false
-    end.
-
-get_catchalls(Alts) ->
-    [ C || C = {'case', {var, _}, _} <- Alts ].
-
-%% The scode compiler can't handle multiple catch-alls, so we need to nest them
-%% inside each other. Instead of
-%%    _ => switch(x) ..
-%%    _ => e
-%% we do
-%%    _ => switch(x)
-%%           ..
-%%           _ => e
-add_catchalls(Alts, []) -> Alts;
-add_catchalls(Alts, Catchalls) ->
-    case lists:splitwith(fun({'case', {var, _}, _}) -> false; (_) -> true end,
-                         Alts) of
-        {Alts1, [C]} -> Alts1 ++ [nest_catchalls([C | Catchalls])];
-        {_, []}      -> Alts  ++ [nest_catchalls(Catchalls)]
-        %% NOTE: relies on catchalls always being at the end
-    end.
-
-nest_catchalls([C = {'case', {var, _}, {nosplit, _}} | _]) -> C;
-nest_catchalls([{'case', P = {var, _}, {split, Type, X, Alts}} | Catchalls]) ->
-    {'case', P, {split, Type, X, add_catchalls(Alts, Catchalls)}}.
-
-simpl_switch(_Env, _, {nosplit, E}) -> E;
-simpl_switch(Env, Catchalls, {split, Type, X, Alts}) ->
-    Alts1 = add_catchalls(Alts, Catchalls),
-    Stuck = {switch, {split, Type, X, Alts1}},
-    case constructor_form(Env, {var, X}) of
-        false -> Stuck;
-        E     ->
-            case simpl_case(Env, E, Alts1) of
-                stuck -> Stuck;
-                Res   -> Res
-            end
-    end.
-
-simpl_case(_, _, []) -> nomatch;
-simpl_case(Env, E, [{'case', Pat, Body} | Alts]) ->
-    case match_pat(Pat, E) of
-        false -> simpl_case(Env, E, Alts);
-        Binds ->
-            Env1 = maps:merge(Env, maps:from_list(Binds)),
-            case simpl_switch(Env1, get_catchalls(Alts), Body) of
-                nomatch -> simpl_case(Env, E, Alts);
-                stuck   -> stuck;
-                Body1   -> let_bind(Binds, Body1)
-            end
-    end.
-
--spec match_pat(fsplit_pat(), fexpr()) -> false | [{var_name(), fexpr()}].
-match_pat({tuple, Xs}, {tuple, Es})         -> lists:zip(Xs, Es);
-match_pat({con, _, C, Xs}, {con, _, C, Es}) -> lists:zip(Xs, Es);
-match_pat(L, {lit, L})                      -> [];
-match_pat(nil, nil)                         -> [];
-match_pat({'::', X, Y}, {op, '::', [A, B]}) -> [{X, A}, {Y, B}];
-match_pat({var, X}, E)                      -> [{X, E}];
-match_pat(_, _)                             -> false.
-
-constructor_form(Env, Expr) ->
-    case Expr of
-        {var, X} ->
-            case maps:get(X, Env, free) of
-                free -> false;
-                E    -> constructor_form(Env, E)    %% TODO: shadowing?
-            end;
-        {set_proj, E, I, V} ->
-            case constructor_form(Env, E) of
-                {tuple, Es} -> {tuple, setnth(I + 1, V, Es)};
-                _           -> false
-            end;
-        {proj, E, I} ->
-            case constructor_form(Env, E) of
-                {tuple, Es} -> constructor_form(Env, lists:nth(I + 1, Es));
-                _           -> false
-            end;
-        {con, _, _, _} -> Expr;
-        {tuple, _}     -> Expr;
-        {lit, _}       -> Expr;
-        nil            -> Expr;
-        {op, '::', _}  -> Expr;
-        _              -> false
-    end.
-
-%% --- Drop unused lets ---
-
-drop_unused_lets(Expr) -> bottom_up(fun drop_unused_lets/2, Expr).
-
-drop_unused_lets(_, {'let', X, E, Body} = Expr) ->
-    case {read_only(E), not lists:member(X, free_vars(Body))} of
-        {true, true}  -> Body;
-        {false, true} -> {'let', "_", E, Body};
-        _             -> Expr
-    end;
-drop_unused_lets(_, Expr) -> Expr.
-
-%% -- Static analysis --------------------------------------------------------
-
-safe_to_duplicate({lit, _})    -> true;
-safe_to_duplicate({var, _})    -> true;
-safe_to_duplicate(nil)         -> true;
-safe_to_duplicate({tuple, []}) -> true;
-safe_to_duplicate(_)           -> false.
-
--spec read_only(fexpr() | fsplit() | fcase() | [fexpr()] | [fcase()]) -> boolean().
-read_only({lit, _})                -> true;
-read_only({var, _})                -> true;
-read_only(nil)                     -> true;
-read_only({con, _, _, Es})         -> read_only(Es);
-read_only({tuple, Es})             -> read_only(Es);
-read_only({proj, E, _})            -> read_only(E);
-read_only({set_proj, A, _, B})     -> read_only([A, B]);
-read_only({op, _, Es})             -> read_only(Es);
-read_only({get_state, _})          -> true;
-read_only({set_state, _, _})       -> false;
-read_only({def_u, _, _})           -> true;
-read_only({remote_u, _, _, _, _})  -> true;
-read_only({builtin_u, _, _})       -> true;
-read_only({builtin_u, _, _, _})    -> true;
-read_only({lam, _, _})             -> true;
-read_only({def, _, _})             -> false; %% TODO: purity analysis
-read_only({remote, _, _, _, _, _}) -> false;
-read_only({builtin, _, _})         -> false; %% TODO: some builtins are
-read_only({switch, Split})         -> read_only(Split);
-read_only({split, _, _, Cases})    -> read_only(Cases);
-read_only({nosplit, E})            -> read_only(E);
-read_only({'case', _, Split})      -> read_only(Split);
-read_only({'let', _, A, B})        -> read_only([A, B]);
-read_only({funcall, _, _})         -> false;
-read_only({closure, _, _})         -> internal_error(no_closures_here);
-read_only(Es) when is_list(Es)     -> lists:all(fun read_only/1, Es).
-
 %% --- Deadcode elimination ---
 
 -spec eliminate_dead_code(fcode()) -> fcode().
@@ -1609,10 +1231,10 @@ resolve_var(#{ vars := Vars } = Env, [X]) ->
     end;
 resolve_var(Env, Q) -> resolve_fun(Env, Q).
 
-resolve_fun(#{ fun_env := Funs, builtins := Builtin } = Env, Q) ->
+resolve_fun(#{ fun_env := Funs, builtins := Builtin }, Q) ->
     case {maps:get(Q, Funs, not_found), maps:get(Q, Builtin, not_found)} of
         {not_found, not_found} -> internal_error({unbound_variable, Q});
-        {_, {B, none}}         -> builtin_to_fcode(state_layout(Env), B, []);
+        {_, {B, none}}         -> {builtin, B, []};
         {_, {B, Ar}}           -> {builtin_u, B, Ar};
         {{Fun, Ar}, _}         -> {def_u, Fun, Ar}
     end.
@@ -1647,14 +1269,14 @@ pat_vars({con, _, _, Ps})     -> pat_vars(Ps);
 pat_vars(Ps) when is_list(Ps) -> [X || P <- Ps, X <- pat_vars(P)].
 
 -spec fsplit_pat_vars(fsplit_pat()) -> [var_name()].
-fsplit_pat_vars({var, X})        -> [X || X /= "_"];
-fsplit_pat_vars({bool, _})       -> [];
-fsplit_pat_vars({int, _})        -> [];
-fsplit_pat_vars({string, _})     -> [];
-fsplit_pat_vars(nil)             -> [];
-fsplit_pat_vars({'::', P, Q})    -> [P, Q];
-fsplit_pat_vars({tuple, Ps})     -> Ps;
-fsplit_pat_vars({con, _, _, Ps}) -> Ps.
+fsplit_pat_vars({var, X})            -> [X || X /= "_"];
+fsplit_pat_vars({bool, _})           -> [];
+fsplit_pat_vars({int, _})            -> [];
+fsplit_pat_vars({string, _})         -> [];
+fsplit_pat_vars(nil)                 -> [];
+fsplit_pat_vars({'::', P, Q})        -> [P, Q];
+fsplit_pat_vars({tuple, Ps})         -> Ps;
+fsplit_pat_vars({con, _, _, Ps})     -> Ps.
 
 free_vars(Xs) when is_list(Xs) ->
     lists:umerge([ free_vars(X) || X <- Xs ]);
@@ -1677,8 +1299,6 @@ free_vars(Expr) ->
         {op, _, As}          -> free_vars(As);
         {'let', X, A, B}     -> free_vars([A, {lam, [X], B}]);
         {funcall, A, Bs}     -> free_vars([A | Bs]);
-        {set_state, _, A}    -> free_vars(A);
-        {get_state, _}       -> [];
         {lam, Xs, B}         -> free_vars(B) -- lists:sort(Xs);
         {closure, _, A}      -> free_vars(A);
         {switch, A}          -> free_vars(A);
@@ -1708,8 +1328,6 @@ used_defs(Expr) ->
         {op, _, As}          -> used_defs(As);
         {'let', _, A, B}     -> used_defs([A, B]);
         {funcall, A, Bs}     -> used_defs([A | Bs]);
-        {set_state, _, A}    -> used_defs(A);
-        {get_state, _}       -> [];
         {lam, _, B}          -> used_defs(B);
         {closure, F, A}      -> lists:umerge([F], used_defs(A));
         {switch, A}          -> used_defs(A);
@@ -1718,50 +1336,6 @@ used_defs(Expr) ->
         {'case', _, A}       -> used_defs(A)
     end.
 
-bottom_up(F, Expr) -> bottom_up(F, #{}, Expr).
-
-bottom_up(F, Env, Expr) ->
-    F(Env, case Expr of
-        {lit, _}                         -> Expr;
-        nil                              -> Expr;
-        {var, _}                         -> Expr;
-        {def, D, Es}                     -> {def, D, [bottom_up(F, Env, E) || E <- Es]};
-        {def_u, _, _}                    -> Expr;
-        {builtin, B, Es}                 -> {builtin, B, [bottom_up(F, Env, E) || E <- Es]};
-        {builtin_u, _, _}                -> Expr;
-        {builtin_u, _, _, _}             -> Expr;
-        {remote, ArgsT, RetT, Ct, Fun, Es} -> {remote,   ArgsT, RetT, bottom_up(F, Env, Ct), Fun, [bottom_up(F, Env, E) || E <- Es]};
-        {remote_u, ArgsT, RetT, Ct, Fun}   -> {remote_u, ArgsT, RetT, bottom_up(F, Env, Ct), Fun};
-        {con, Ar, I, Es}                 -> {con, Ar, I, [bottom_up(F, Env, E) || E <- Es]};
-        {tuple, Es}                      -> {tuple, [bottom_up(F, Env, E) || E <- Es]};
-        {proj, E, I}                     -> {proj, bottom_up(F, Env, E), I};
-        {set_proj, R, I, E}              -> {set_proj, bottom_up(F, Env, R), I, bottom_up(F, Env, E)};
-        {op, Op, Es}                     -> {op, Op, [bottom_up(F, Env, E) || E <- Es]};
-        {funcall, Fun, Es}               -> {funcall, bottom_up(F, Env, Fun), [bottom_up(F, Env, E) || E <- Es]};
-        {set_state, R, E}                -> {set_state, R, bottom_up(F, Env, E)};
-        {get_state, _}                   -> Expr;
-        {closure, F, CEnv}               -> {closure, F, bottom_up(F, Env, CEnv)};
-        {switch, Split}                  -> {switch, bottom_up(F, Env, Split)};
-        {lam, Xs, B}                     -> {lam, Xs, bottom_up(F, Env, B)};
-        {'let', X, E, Body}              ->
-            E1 = bottom_up(F, Env, E),
-            %% Always freshen user variables to avoid shadowing issues.
-            ShouldFreshen = fun(Y = "%" ++ _) -> maps:is_key(Y, Env);
-                               (_)            -> true end,
-            case ShouldFreshen(X) of
-                true ->
-                    Z = fresh_name(),
-                    Env1 = Env#{ Z => E1 },
-                    {'let', Z, E1, bottom_up(F, Env1, rename([{X, Z}], Body))};
-                false ->
-                    Env1 = Env#{ X => E1 },
-                    {'let', X, E1, bottom_up(F, Env1, Body)}
-            end;
-        {split, Type, X, Cases}          -> {split, Type, X, [bottom_up(F, Env, Case) || Case <- Cases]};
-        {nosplit, E}                     -> {nosplit, bottom_up(F, Env, E)};
-        {'case', Pat, Split}             -> {'case', Pat, bottom_up(F, Env, Split)}
-    end).
-
 get_named_args(NamedArgsT, Args) ->
     IsNamed = fun({named_arg, _, _, _}) -> true;
                  (_) -> false end,
@@ -1796,8 +1370,6 @@ rename(Ren, Expr) ->
         {set_proj, R, I, E}   -> {set_proj, rename(Ren, R), I, rename(Ren, E)};
         {op, Op, Es}          -> {op, Op, [rename(Ren, E) || E <- Es]};
         {funcall, Fun, Es}    -> {funcall, rename(Ren, Fun), [rename(Ren, E) || E <- Es]};
-        {set_state, R, E}     -> {set_state, R, rename(Ren, E)};
-        {get_state, _}        -> Expr;
         {closure, F, Env}     -> {closure, F, rename(Ren, Env)};
         {switch, Split}       -> {switch, rename_split(Ren, Split)};
         {lam, Xs, B} ->
@@ -1904,10 +1476,6 @@ get_attributes(Ann) ->
 indexed(Xs) ->
     lists:zip(lists:seq(1, length(Xs)), Xs).
 
-setnth(I, X, Xs) ->
-    {Ys, [_ | Zs]} = lists:split(I - 1, Xs),
-    Ys ++ [X] ++ Zs.
-
 -dialyzer({nowarn_function, [fcode_error/1, internal_error/1]}).
 
 fcode_error(Error) ->
@@ -2010,18 +1578,9 @@ pp_fexpr({op, Op, [A] = Args}) ->
     end;
 pp_fexpr({op, Op, As}) ->
     pp_beside(pp_text(Op), pp_fexpr({tuple, As}));
-pp_fexpr({'let', _, _, _} = Expr) ->
-    Lets = fun Lets({'let', Y, C, D}) ->
-                        {Ls, E} = Lets(D),
-                        {[{Y, C} | Ls], E};
-               Lets(E) -> {[], E} end,
-    {Ls, Body} = Lets(Expr),
-    pp_parens(
-      pp_par(
-        [ pp_beside([ pp_text("let "),
-                      pp_above([ pp_par([pp_text(X), pp_text("="), prettypr:nest(2, pp_fexpr(A))]) || {X, A} <- Ls ]),
-                      pp_text(" in ") ]),
-          pp_fexpr(Body) ]));
+pp_fexpr({'let', X, A, B}) ->
+    pp_par([pp_beside([pp_text("let "), pp_text(X), pp_text(" = "), pp_fexpr(A), pp_text(" in")]),
+            pp_fexpr(B)]);
 pp_fexpr({builtin_u, B, N}) ->
     pp_beside([pp_text(B), pp_text("/"), pp_text(N)]);
 pp_fexpr({builtin_u, B, N, TypeArgs}) ->
@@ -2034,10 +1593,6 @@ pp_fexpr({remote, ArgsT, RetT, Ct, Fun, As}) ->
     pp_call(pp_parens(pp_beside([pp_fexpr(Ct), pp_text("."), pp_fun_name(Fun), pp_text(" : "), pp_ftype({function, ArgsT, RetT})])), As);
 pp_fexpr({funcall, Fun, As}) ->
     pp_call(pp_fexpr(Fun), As);
-pp_fexpr({set_state, R, A}) ->
-    pp_call(pp_text("set_state"), [{lit, {int, R}}, A]);
-pp_fexpr({get_state, R}) ->
-    pp_call(pp_text("get_state"), [{lit, {int, R}}]);
 pp_fexpr({switch, Split}) -> pp_split(Split).
 
 pp_call(Fun, Args) ->
@@ -2053,7 +1608,7 @@ pp_ftype({tvar, X}) -> pp_text(X);
 pp_ftype({bytes, N}) -> pp_call(pp_text("bytes"), [{lit, {int, N}}]);
 pp_ftype({oracle, Q, R}) -> pp_call_t("oracle", [Q, R]);
 pp_ftype({tuple, Ts}) ->
-    pp_parens(pp_par(pp_punctuate(pp_text(" *"), [pp_ftype(T) || T <- Ts])));
+    pp_parens(pp_par(pp_punctuate(pp_text(","), [pp_ftype(T) || T <- Ts])));
 pp_ftype({list, T}) ->
     pp_call_t("list", [T]);
 pp_ftype({function, Args, Res}) ->

src/aeso_ast_to_icode.erl

@@ -131,7 +131,7 @@ contract_to_icode([Decl | Code], Icode) ->
 ast_id({id, _, Id}) -> Id;
 ast_id({qid, _, Id}) -> Id.
 
-ast_args([{typed, _, Name, Type}|Rest], Acc, Icode) ->
+ast_args([{arg, _, Name, Type}|Rest], Acc, Icode) ->
     ast_args(Rest, [{ast_id(Name), ast_typerep1(Type, Icode)}| Acc], Icode);
 ast_args([], Acc, _Icode) -> lists:reverse(Acc).
 
@@ -318,23 +318,19 @@ ast_body({app, As, Fun, Args}, Icode) ->
     end;
 ast_body({list_comp, _, Yield, []}, Icode) ->
     #list{elems = [ast_body(Yield, Icode)]};
-ast_body({list_comp, As, Yield, [{comprehension_bind, {typed, _, Pat, ArgType}, BindExpr}|Rest]}, Icode) ->
-    Arg  = "%lc",
-    Body = {switch, As, {typed, As, {id, As, Arg}, ArgType},
-                [{'case', As, Pat, {list_comp, As, Yield, Rest}},
-                 {'case', As, {id, As, "_"}, {list, As, []}}]},
+ast_body({list_comp, As, Yield, [{comprehension_bind, {typed, Arg, ArgType}, BindExpr}|Rest]}, Icode) ->
     #funcall
         { function = #var_ref{ name = ["ListInternal", "flat_map"] }
         , args =
-              [ #lambda{ args=[#arg{name = Arg, type = ast_type(ArgType, Icode)}]
-                       , body = ast_body(Body, Icode)
+              [ #lambda{ args=[#arg{name = ast_id(Arg), type = ast_type(ArgType, Icode)}]
+                       , body = ast_body({list_comp, As, Yield, Rest}, Icode)
                        }
               , ast_body(BindExpr, Icode)
               ]
         };
 ast_body({list_comp, As, Yield, [{comprehension_if, AsIF, Cond}|Rest]}, Icode) ->
     ast_body({'if', AsIF, Cond, {list_comp, As, Yield, Rest}, {list, As, []}}, Icode);
-ast_body({list_comp, As, Yield, [LV = {letval, _, _, _}|Rest]}, Icode) ->
+ast_body({list_comp, As, Yield, [LV = {letval, _, _, _, _}|Rest]}, Icode) ->
     ast_body({block, As, [LV, {list_comp, As, Yield, Rest}]}, Icode);
 ast_body({list_comp, As, Yield, [LF = {letfun, _, _, _, _, _}|Rest]}, Icode) ->
     ast_body({block, As, [LF, {list_comp, As, Yield, Rest}]}, Icode);
@@ -348,16 +344,14 @@ ast_body({switch,_,A,Cases}, Icode) ->
     #switch{expr=ast_body(A, Icode),
             cases=[{ast_body(Pat, Icode),ast_body(Body, Icode)}
               || {'case',_,Pat,Body} <- Cases]};
-ast_body({block, As, [{letval, _, Pat, E} | Rest]}, Icode) ->
+ast_body({block, As, [{letval, _, Pat, _, E} | Rest]}, Icode) ->
     E1    = ast_body(E, Icode),
     Pat1  = ast_body(Pat, Icode),
     Rest1 = ast_body({block, As, Rest}, Icode),
     #switch{expr  = E1,
             cases = [{Pat1, Rest1}]};
 ast_body({block, As, [{letfun, Ann, F, Args, _Type, Expr} | Rest]}, Icode) ->
-    ToArg   = fun({typed, Ann1, Id, T}) -> {arg, Ann1, Id, T} end,    %% Pattern matching has been desugared
-    LamArgs = lists:map(ToArg, Args),
-    ast_body({block, As, [{letval, Ann, F, {lam, Ann, LamArgs, Expr}} | Rest]}, Icode);
+    ast_body({block, As, [{letval, Ann, F, unused, {lam, Ann, Args, Expr}} | Rest]}, Icode);
 ast_body({block,_,[]}, _Icode) ->
     #tuple{cpts=[]};
 ast_body({block,_,[E]}, Icode) ->
@@ -500,7 +494,6 @@ is_builtin_fun({qid, _, ["Address", "to_str"]}, _Icode)                      ->
 is_builtin_fun({qid, _, ["Address", "is_oracle"]}, _Icode)                   -> true;
 is_builtin_fun({qid, _, ["Address", "is_contract"]}, _Icode)                 -> true;
 is_builtin_fun({qid, _, ["Address", "is_payable"]}, _Icode)                  -> true;
-is_builtin_fun({qid, _, ["Address", "to_contract"]}, _Icode)                 -> true;
 is_builtin_fun({qid, _, ["Bytes", "to_int"]}, _Icode)                        -> true;
 is_builtin_fun({qid, _, ["Bytes", "to_str"]}, _Icode)                        -> true;
 is_builtin_fun({qid, _, ["Bytes", "concat"]}, _Icode)                        -> true;
@@ -720,8 +713,6 @@ builtin_code(_, {qid, _, ["Address", "is_contract"]}, [Addr], _, _, Icode) ->
 builtin_code(_, {qid, _, ["Address", "is_payable"]}, [Addr], _, _, Icode) ->
     prim_call(?PRIM_CALL_ADDR_IS_PAYABLE, #integer{value = 0},
               [ast_body(Addr, Icode)], [word], word);
-builtin_code(_, {qid, _, ["Address", "to_contract"]}, [Addr], _, _, Icode) ->
-    ast_body(Addr, Icode);
 
 builtin_code(_, {qid, _, ["Bytes", "to_int"]}, [Bytes], _, _, Icode) ->
     {typed, _, _, {bytes_t, _, N}} = Bytes,
@@ -806,10 +797,10 @@ check_entrypoint_type(Ann, Name, Args, Ret) ->
                     true  -> ok
                 end end,
     [ CheckFirstOrder(T, {invalid_entrypoint, higher_order, Ann1, Name, {argument, X, T}})
-      || {typed, Ann1, X, T} <- Args ],
+      || {arg, Ann1, X, T} <- Args ],
     CheckFirstOrder(Ret, {invalid_entrypoint, higher_order, Ann, Name, {result, Ret}}),
     [ CheckMonomorphic(T, {invalid_entrypoint, polymorphic, Ann1, Name, {argument, X, T}})
-      || {typed, Ann1, X, T} <- Args ],
+      || {arg, Ann1, X, T} <- Args ],
     CheckMonomorphic(Ret, {invalid_entrypoint, polymorphic, Ann, Name, {result, Ret}}).
 
 check_oracle_type(Ann, Type = ?oracle_t(QType, RType)) ->

src/aeso_compiler.erl

@@ -2,7 +2,7 @@
 %%% @author Happi (Erik Stenman)
 %%% @copyright (C) 2017, Aeternity Anstalt
 %%% @doc
-%%%     Compiler from Aeterinty Sophia language to both AEVM and FATE VM.
+%%%     Compiler from Aeterinty Sophia language to the Aeternity VM, aevm.
 %%% @end
 %%% Created : 12 Dec 2017
 %%%-------------------------------------------------------------------
@@ -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").
@@ -38,13 +36,10 @@
                 | pp_assembler
                 | pp_bytecode
                 | no_code
-                | keep_included
-                | debug_mode
                 | {backend, aevm | fate}
                 | {include, {file_system, [string()]} |
                             {explicit_files, #{string() => binary()}}}
-                | {src_file, string()}
-                | {aci, aeso_aci:aci_type()}.
+                | {src_file, string()}.
 -type options() :: [option()].
 
 -export_type([ option/0
@@ -70,17 +65,6 @@ 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()]}.
 file(Filename) ->
     file(Filename, []).
@@ -118,8 +102,7 @@ from_string(Backend, ContractString, Options) ->
     end.
 
 from_string1(aevm, ContractString, Options) ->
-    #{ icode := Icode
-     , folded_typed_ast := FoldedTypedAst } = string_to_code(ContractString, Options),
+    #{icode := Icode} = string_to_code(ContractString, Options),
     TypeInfo  = extract_type_info(Icode),
     Assembler = assemble(Icode, Options),
     pp_assembler(aevm, Assembler, Options),
@@ -127,63 +110,47 @@ from_string1(aevm, ContractString, Options) ->
     ByteCode = << << B:8 >> || B <- ByteCodeList >>,
     pp_bytecode(ByteCode, Options),
     {ok, Version} = version(),
-    Res = #{byte_code => ByteCode,
-            compiler_version => Version,
-            contract_source => ContractString,
-            type_info => TypeInfo,
-            abi_version => aeb_aevm_abi:abi_version(),
-            payable => maps:get(payable, Icode)
-           },
-    {ok, maybe_generate_aci(Res, FoldedTypedAst, Options)};
+    {ok, #{byte_code => ByteCode,
+           compiler_version => Version,
+           contract_source => ContractString,
+           type_info => TypeInfo,
+           abi_version => aeb_aevm_abi:abi_version(),
+           payable => maps:get(payable, Icode)
+          }};
 from_string1(fate, ContractString, Options) ->
-    #{ fcode := FCode
-     , folded_typed_ast := FoldedTypedAst } = string_to_code(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(),
-    Res = #{byte_code => ByteCode,
-            compiler_version => Version,
-            contract_source => ContractString,
-            type_info => [],
-            fate_code => FateCode,
-            abi_version => aeb_fate_abi:abi_version(),
-            payable => maps:get(payable, FCode)
-           },
-    {ok, maybe_generate_aci(Res, FoldedTypedAst, Options)}.
-
-maybe_generate_aci(Result, FoldedTypedAst, Options) ->
-    case proplists:get_value(aci, Options) of
-        undefined ->
-            Result;
-        Type ->
-            {ok, Aci} = aeso_aci:from_typed_ast(Type, FoldedTypedAst),
-            maps:put(aci, Aci, Result)
-    end.
+    {ok, #{byte_code => ByteCode,
+           compiler_version => Version,
+           contract_source => ContractString,
+           type_info => [],
+           fate_code => FateCode,
+           abi_version => aeb_fate_abi:abi_version(),
+           payable => maps:get(payable, FCode)
+          }}.
 
 -spec string_to_code(string(), options()) -> map().
 string_to_code(ContractString, Options) ->
     Ast = parse(ContractString, Options),
     pp_sophia_code(Ast, Options),
     pp_ast(Ast, Options),
-    {TypeEnv, FoldedTypedAst, UnfoldedTypedAst} = aeso_ast_infer_types:infer(Ast, [return_env | Options]),
-    pp_typed_ast(UnfoldedTypedAst, Options),
+    {TypeEnv, TypedAst} = aeso_ast_infer_types:infer(Ast, [return_env | Options]),
+    pp_typed_ast(TypedAst, Options),
     case proplists:get_value(backend, Options, aevm) of
         aevm ->
-            Icode = ast_to_icode(UnfoldedTypedAst, Options),
+            Icode = ast_to_icode(TypedAst, Options),
             pp_icode(Icode, Options),
-            #{ icode => Icode
-             , unfolded_typed_ast => UnfoldedTypedAst
-             , folded_typed_ast => FoldedTypedAst
-             , type_env  => TypeEnv
-             , ast => Ast };
+            #{ icode => Icode,
+               typed_ast => TypedAst,
+               type_env  => TypeEnv};
         fate ->
-            Fcode = aeso_ast_to_fcode:ast_to_fcode(UnfoldedTypedAst, Options),
-            #{ fcode => Fcode
-             , unfolded_typed_ast => UnfoldedTypedAst
-             , folded_typed_ast => FoldedTypedAst
-             , type_env  => TypeEnv
-             , ast => Ast }
+            Fcode = aeso_ast_to_fcode:ast_to_fcode(TypedAst, Options),
+            #{ fcode => Fcode,
+               typed_ast => TypedAst,
+               type_env  => TypeEnv}
     end.
 
 -define(CALL_NAME,   "__call").
@@ -218,9 +185,9 @@ check_call1(ContractString0, FunName, Args, Options) ->
         case proplists:get_value(backend, Options, aevm) of
             aevm ->
                 %% First check the contract without the __call function
-                #{ast := Ast} = string_to_code(ContractString0, Options),
-                ContractString = insert_call_function(Ast, ContractString0, ?CALL_NAME, FunName, Args),
-                #{unfolded_typed_ast := TypedAst,
+                #{} = string_to_code(ContractString0, Options),
+                ContractString = insert_call_function(ContractString0, ?CALL_NAME, FunName, Args, Options),
+                #{typed_ast := TypedAst,
                   icode     := Icode} = string_to_code(ContractString, Options),
                 {ok, {FunName, {fun_t, _, _, ArgTypes, RetType}}} = get_call_type(TypedAst),
                 ArgVMTypes = [ aeso_ast_to_icode:ast_typerep(T, Icode) || T <- ArgTypes ],
@@ -240,14 +207,13 @@ check_call1(ContractString0, FunName, Args, Options) ->
                 {ok, FunName, {ArgVMTypes, RetVMType1}, ArgTerms};
             fate ->
                 %% First check the contract without the __call function
-                #{ fcode := OrgFcode
-                 , ast := Ast } = string_to_code(ContractString0, Options),
+                #{fcode := OrgFcode} = string_to_code(ContractString0, Options),
                 FateCode = aeso_fcode_to_fate:compile(OrgFcode, []),
                 %% collect all hashes and compute the first name without hash collision to
                 SymbolHashes = maps:keys(aeb_fate_code:symbols(FateCode)),
                 CallName = first_none_match(?CALL_NAME, SymbolHashes,
                                             lists:seq($1, $9) ++ lists:seq($A, $Z) ++ lists:seq($a, $z)),
-                ContractString = insert_call_function(Ast, ContractString0, CallName, FunName, Args),
+                ContractString = insert_call_function(ContractString0, CallName, FunName, Args, Options),
                 #{fcode := Fcode} = string_to_code(ContractString, Options),
                 CallArgs = arguments_of_body(CallName, FunName, Fcode),
                 {ok, FunName, CallArgs}
@@ -273,8 +239,9 @@ first_none_match(CallName, Hashes, [Char|Chars]) ->
     end.
 
 %% Add the __call function to a contract.
--spec insert_call_function(aeso_syntax:ast(), string(), string(), string(), [string()]) -> string().
-insert_call_function(Ast, Code, Call, FunName, Args) ->
+-spec insert_call_function(string(), string(), string(), [string()], options()) -> string().
+insert_call_function(Code, Call, FunName, Args, Options) ->
+    Ast = parse(Code, Options),
     Ind = last_contract_indent(Ast),
     lists:flatten(
         [ Code,
@@ -330,7 +297,7 @@ to_sophia_value(ContractString, FunName, ok, Data, Options0) ->
     Options = [no_code | Options0],
     try
         Code = string_to_code(ContractString, Options),
-        #{ unfolded_typed_ast := TypedAst, type_env  := TypeEnv} = Code,
+        #{ typed_ast := TypedAst, type_env  := TypeEnv} = Code,
         {ok, _, Type0} = get_decode_type(FunName, TypedAst),
         Type   = aeso_ast_infer_types:unfold_types_in_type(TypeEnv, Type0, [unfold_record_types, unfold_variant_types]),
 
@@ -356,12 +323,12 @@ to_sophia_value(ContractString, FunName, ok, Data, Options0) ->
                 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(Type0)),
+                        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(Type0)),
+                        Type1 = prettypr:format(aeso_pretty:type(Type)),
                         Msg = io_lib:format("Failed to decode binary as type ~s\n", [Type1]),
                         {error, [aeso_errors:new(data_error, Msg)]}
                end
@@ -406,11 +373,11 @@ decode_calldata(ContractString, FunName, Calldata, Options0) ->
     Options = [no_code | Options0],
     try
         Code = string_to_code(ContractString, Options),
-        #{ unfolded_typed_ast := TypedAst, type_env  := TypeEnv} = Code,
+        #{ 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]),
@@ -528,14 +495,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) ->
@@ -587,92 +546,10 @@ 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]).
-
 %% -------------------------------------------------------------------
 
--spec sophia_type_to_typerep(string()) -> {error, bad_type} | {ok, aeb_aevm_data:type()}.
 sophia_type_to_typerep(String) ->
-    Ast = aeso_parser:run_parser(aeso_parser:type(), String),
+    {ok, Ast} = aeso_parser:type(String),
     try aeso_ast_to_icode:ast_typerep(Ast) of
         Type -> {ok, Type}
     catch _:_ -> {error, bad_type}

src/aeso_parse_lib.erl

@@ -74,31 +74,25 @@
                     %%   first argument. I.e. no backtracking to the second argument if the first
                     %%   fails.
 
-trampoline({bounce, Cont}) when is_function(Cont, 0) ->
-    trampoline(Cont());
-trampoline(Res) ->
-    Res.
--define(BOUNCE(X), {bounce, fun() -> X end}).
-
 %% Apply a parser to its continuation. This compiles a parser to its low-level representation.
 -spec apply_p(parser(A), fun((A) -> parser1(B))) -> parser1(B).
 apply_p(?lazy(F), K)           -> apply_p(F(), K);
 apply_p(?fail(Err), _)         -> {fail, Err};
-apply_p(?choice([P | Ps]), K)  -> lists:foldl(fun(Q, R) -> choice1(trampoline(apply_p(Q, K)), R) end,
-                                              trampoline(apply_p(P, K)), Ps);
+apply_p(?choice([P | Ps]), K)  -> lists:foldl(fun(Q, R) -> choice1(apply_p(Q, K), R) end,
+                                             apply_p(P, K), Ps);
 apply_p(?bind(P, F), K)        -> apply_p(P, fun(X) -> apply_p(F(X), K) end);
 apply_p(?right(P, Q), K)       -> apply_p(P, fun(_) -> apply_p(Q, K) end);
 apply_p(?left(P, Q), K)        -> apply_p(P, fun(X) -> apply_p(Q, fun(_) -> K(X) end) end);
 apply_p(?map(F, P), K)         -> apply_p(P, fun(X) -> K(F(X)) end);
 apply_p(?layout, K)            -> {layout, K, {fail, {expected, layout_block}}};
 apply_p(?tok(Atom), K)         -> {tok_bind, #{Atom => K}};
-apply_p(?return(X), K)         -> ?BOUNCE(K(X));
+apply_p(?return(X), K)         -> K(X);
 apply_p([P | Q], K)            -> apply_p(P, fun(H) -> apply_p(Q, fun(T) -> K([H | T]) end) end);
 apply_p(T, K) when is_tuple(T) -> apply_p(tuple_to_list(T), fun(Xs) -> K(list_to_tuple(Xs)) end);
 apply_p(M, K) when is_map(M) ->
     {Keys, Ps} = lists:unzip(maps:to_list(M)),
     apply_p(Ps, fun(Vals) -> K(maps:from_list(lists:zip(Keys, Vals))) end);
-apply_p(X, K) -> ?BOUNCE(K(X)).
+apply_p(X, K) -> K(X).
 
 %% -- Primitive combinators --------------------------------------------------
 
@@ -166,7 +160,7 @@ layout() -> ?layout.
 %% @doc Parse a sequence of tokens using a parser. Fails if the parse is ambiguous.
 -spec parse(parser(A), tokens()) -> {ok, A} | {error, term()}.
 parse(P, S) ->
-  case parse1(trampoline(apply_p(P, fun(X) -> {return_plus, X, {fail, no_error}} end)), S) of
+  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)}};
     {[A], _}         -> {ok, A};
     {As, _}          -> {error, {{1, 1}, ambiguous_parse, As}}
@@ -247,7 +241,7 @@ col(T)  when is_tuple(T) -> element(2, pos(T)).
 
 %% If both parsers want the next token we grab it and merge the continuations.
 choice1({tok_bind, Map1}, {tok_bind, Map2}) ->
-    {tok_bind, merge_with(fun(F, G) -> fun(T) -> choice1(trampoline(F(T)), trampoline(G(T))) end end, Map1, Map2)};
+    {tok_bind, merge_with(fun(F, G) -> fun(T) -> choice1(F(T), G(T)) end end, Map1, Map2)};
 
 %% If both parsers fail we combine the error messages. If only one fails we discard it.
 choice1({fail, E1}, {fail, E2})             -> {fail, add_error(E1, E2)};
@@ -261,7 +255,7 @@ choice1(P, {return_plus, X, Q})             -> {return_plus, X, choice1(P, Q)};
 %% If both sides want a layout block we combine them. If only one side wants a layout block we
 %% will commit to a layout block is there is one.
 choice1({layout, F, P}, {layout, G, Q})     ->
-    {layout, fun(N) -> choice1(trampoline(F(N)), trampoline(G(N))) end, choice1(P, Q)};
+    {layout, fun(N) -> choice1(F(N), G(N)) end, choice1(P, Q)};
 choice1({layout, F, P}, Q)                  -> {layout, F, choice1(P, Q)};
 choice1(P, {layout, G, Q})                  -> {layout, G, choice1(P, Q)}.
 
@@ -284,8 +278,6 @@ parse1(P, S) ->
 %% The main work horse. Returns a list of possible parses and an error message in case parsing
 %% fails.
 -spec parse1(parser1(A), #ts{}, [A], term()) -> {[A], error()}.
-parse1({bounce, F}, Ts, Acc, Err) ->
-    parse1(F(), Ts, Acc, Err);
 parse1({tok_bind, Map}, Ts, Acc, Err) ->
     case next_token(Ts) of
         {T, Ts1} ->
@@ -363,6 +355,7 @@ unexpected_token_error(Ts, Expect, T) ->
               {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)]);
+              {return, _} -> " [Polite reminder that Sophia is not JavaScript]";
               _ -> ""
           end,
     mk_error(Ts, io_lib:format("Unexpected ~s.~s", [describe(T), Fix])).

src/aeso_parser.erl

@@ -3,33 +3,20 @@
 %%% Description :
 %%% Created     : 1 Mar 2018 by Ulf Norell
 -module(aeso_parser).
--compile({no_auto_import,[map_get/2]}).
 
 -export([string/1,
          string/2,
          string/3,
-         auto_imports/1,
          hash_include/2,
-         decl/0,
-         type/0,
-         body/0,
-         maybe_block/1,
-         run_parser/2,
-         run_parser/3]).
+         type/1]).
 
 -include("aeso_parse_lib.hrl").
 -import(aeso_parse_lib, [current_file/0, set_current_file/1]).
 
--type parse_result() :: aeso_syntax:ast() | {aeso_syntax:ast(), sets:set(include_hash())} | none().
+-type parse_result() :: aeso_syntax:ast() | none().
 
 -type include_hash() :: {string(), binary()}.
 
-
-escape_errors({ok, Ok}) ->
-    Ok;
-escape_errors({error, Err}) ->
-    parse_error(Err).
-
 -spec string(string()) -> parse_result().
 string(String) ->
     string(String, sets:new(), []).
@@ -43,24 +30,27 @@ string(String, Opts) ->
 
 -spec string(string(), sets:set(include_hash()), aeso_compiler:options()) -> parse_result().
 string(String, Included, Opts) ->
-    AST = run_parser(file(), String, Opts),
-    case expand_includes(AST, Included, Opts) of
-        {ok, AST1}   -> AST1;
-        {error, Err} -> parse_error(Err)
+    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)
     end.
 
-
-run_parser(P, Inp) ->
-    escape_errors(parse_and_scan(P, Inp, [])).
-run_parser(P, Inp, Opts) ->
-    escape_errors(parse_and_scan(P, Inp, Opts)).
+type(String) ->
+    case parse_and_scan(type(), String, []) of
+        {ok, AST}    -> {ok, AST};
+        {error, Err} -> {error, [mk_error(Err)]}
+    end.
 
 parse_and_scan(P, S, Opts) ->
     set_current_file(proplists:get_value(src_file, Opts, no_file)),
     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}).
@@ -70,8 +60,8 @@ parse_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, ScanE}) when ScanE == scan_error; ScanE == scan_error_no_state ->
+    mk_p_err(Pos, "Scan error\n");
 mk_error({Pos, parse_error, Err}) ->
     Msg = io_lib:format("~s\n", [Err]),
     mk_p_err(Pos, Msg);
@@ -97,7 +87,6 @@ decl() ->
     , ?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, []})
@@ -110,31 +99,13 @@ 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(keyword('let'), valdef(), set_pos(get_pos(_1), _2))
+    , ?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}),
+    choice([?RULE(keyword(function), {function, _1}),
             ?RULE(keyword(entrypoint), {entrypoint, _1})]).
 
 modifiers() ->
@@ -181,19 +152,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 ------------------------------------------------------------------
@@ -254,7 +226,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 ------------------------------------------------------------
 
@@ -264,7 +236,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
@@ -313,7 +285,7 @@ comprehension_if() ->
     ?RULE(keyword('if'), parens(expr()), {comprehension_if, _1, _2}).
 
 comprehension_bind() ->
-    ?RULE(pattern(), tok('<-'), expr(), {comprehension_bind, _1, _3}).
+    ?RULE(id(), tok('<-'), expr(), {comprehension_bind, _1, _3}).
 
 arg_expr() ->
     ?LAZY_P(
@@ -365,9 +337,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) ->
@@ -379,7 +349,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() ->
@@ -434,7 +406,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() ->
@@ -510,8 +482,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, []).
@@ -561,9 +533,7 @@ 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)};
@@ -571,10 +541,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;
@@ -605,13 +572,8 @@ expand_includes(AST, Included, Opts) ->
              || File <- lists:usort(auto_imports(AST)) ] ++ AST,
     expand_includes(AST1, Included, [], Opts).
 
-expand_includes([], Included, Acc, Opts) ->
-    case lists:member(keep_included, Opts) of
-        false ->
-            {ok, lists:reverse(Acc)};
-        true ->
-            {ok, {lists:reverse(Acc), Included}}
-    end;
+expand_includes([], _Included, 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} ->
@@ -645,39 +607,16 @@ 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.
+    [{include, {file_system, [aeso_stdlib:stdlib_include_path()]}}].
 
 get_include_code(File, Ann, Opts) ->
     case {read_file(File, Opts), read_file(File, stdlib_options())} of
-        {{ok, Bin}, {ok, _}} ->
-            case filename:basename(File) == File of
-                true -> { error
-                        , fail( ann_pos(Ann)
-                              , "Illegal redefinition of standard library " ++ binary_to_list(File))};
-                %% If a path is provided then the stdlib takes lower priority
-                false -> {ok, binary_to_list(Bin)}
-            end;
+        {{ok, _}, {ok,_ }} ->
+            fail(ann_pos(Ann), "Illegal redefinition of standard library " ++ File);
         {_, {ok, Bin}} ->
             {ok, binary_to_list(Bin)};
         {{ok, Bin}, _} ->

src/aeso_pretty.erl

@@ -145,30 +145,22 @@ decl(D, Options) ->
     with_options(Options, fun() -> decl(D) end).
 
 -spec decl(aeso_syntax:decl()) -> doc().
-decl({contract, Attrs, C, Ds}) ->
-    Mod = fun({Mod, true}) when Mod == payable ->
-                  text(atom_to_list(Mod));
-             (_) -> empty() end,
-    block(follow( hsep(lists:map(Mod, Attrs) ++ [text("contract")])
-                , hsep(name(C), text("="))), decls(Ds));
+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),
     equals(typedecl(Kind, T, Vars), typedef(Def));
 decl({fun_decl, Ann, F, T}) ->
-    Mod = fun({Mod, true}) when Mod == private; Mod == stateful; Mod == payable ->
-                  text(atom_to_list(Mod));
-             (_) -> empty() end,
     Fun = case aeso_syntax:get_ann(entrypoint, Ann, false) of
             true  -> text("entrypoint");
             false -> text("function")
           end,
-    hsep(lists:map(Mod, Ann) ++ [Fun, typed(name(F), T)]);
+    hsep(Fun, typed(name(F), T));
 decl(D = {letfun, Attrs, _, _, _, _}) ->
-    Mod = fun({Mod, true}) when Mod == private; Mod == stateful; Mod == payable ->
+    Mod = fun({Mod, true}) when Mod == private; Mod == stateful ->
                             text(atom_to_list(Mod));
              (_) -> empty() end,
     Fun = case aeso_syntax:get_ann(entrypoint, Attrs, false) of
@@ -176,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) ->
@@ -204,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) ->
@@ -316,8 +300,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}) ->
@@ -371,8 +353,7 @@ expr_p(_, {Type, _, Bin})
          Type == oracle_query_id ->
     text(binary_to_list(aeser_api_encoder:encode(Type, Bin)));
 expr_p(_, {string, _, <<>>}) -> text("\"\"");
-expr_p(_, {string, _, S}) ->
-    text(io_lib:format("\"~s\"", [binary_to_list(S)]));
+expr_p(_, {string, _, S}) -> term(binary_to_list(S));
 expr_p(_, {char, _, C}) ->
     case C of
         $' -> text("'\\''");
@@ -401,13 +382,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 '[ ]'
@@ -471,7 +445,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));
@@ -481,7 +455,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).
 
@@ -494,3 +468,6 @@ get_elifs(If = {'if', Ann, Cond, Then, Else}, Elifs) ->
     end;
 get_elifs(Else, Elifs) -> {lists:reverse(Elifs), {else, Else}}.
 
+fmt(Fmt, Args) -> text(lists:flatten(io_lib:format(Fmt, Args))).
+term(X) -> fmt("~p", [X]).
+

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,8 @@ 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", "payable", "true", "false", "mod", "public", "entrypoint", "private", "indexed", "namespace",
+                "return"],
     KW = string:join(Keywords, "|"),
 
     Rules =
@@ -54,7 +54,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!)
@@ -118,18 +118,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_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,27 +36,14 @@
 
 -type decl() :: {contract, ann(), con(), [decl()]}
               | {namespace, ann(), con(), [decl()]}
-              | {pragma, ann(), pragma()}
-              | {type_decl, ann(), id(), [tvar()]} % Only for error msgs
+              | {type_decl, ann(), id(), [tvar()]}
               | {type_def, ann(), id(), [tvar()], typedef()}
-              | {fun_clauses, ann(), id(), type(), [letfun() | fundecl()]}
-              | {block, ann(), [decl()]}
-              | fundecl()
-              | letfun()
-              | letval(). % Only for error msgs
-
--type compiler_version() :: [non_neg_integer()].
-
--type pragma() :: {compiler, '==' | '<' | '>' | '=<' | '>=', compiler_version()}.
-
-
--type letval()  :: {letval, ann(), pat(), expr()}.
--type letfun()  :: {letfun, ann(), id(), [pat()], type(), expr()}.
--type fundecl() :: {fun_decl, ann(), id(), type()}.
+              | {fun_decl, ann(), id(), type()}
+              | letbind().
 
 -type letbind()
-    :: letfun()
-     | letval().
+    :: {letval, ann(), id(), type(), expr()}
+     | {letfun, ann(), id(), [arg()], type(), expr()}.
 
 -type arg() :: {arg, ann(), id(), type()}.
 
@@ -108,8 +95,9 @@
      | {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()}
@@ -118,9 +106,7 @@
      | id() | qid() | con() | qcon()
      | constant().
 
--type record_or_map() :: record | map | record_or_map_error.
-
--type comprehension_exp() :: [ {comprehension_bind, pat(), expr()}
+-type comprehension_exp() :: [ {comprehension_bind, id(), expr()}
                              | {comprehension_if, ann(), expr()}
                              | letbind() ].
 
@@ -148,7 +134,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

@@ -45,11 +45,11 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
             %% decl()
             {contract, _, _, Ds}     -> Decl(Ds);
             {namespace, _, _, Ds}    -> Decl(Ds);
+            {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));
+            {letval, _, F, T, E}     -> Sum([BindExpr(F), Type(T), 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]]);
             %% typedef()
             {alias_t, T}    -> Type(T);
             {record_t, Fs}  -> Type(Fs);
@@ -76,8 +76,8 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
                 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 = {letval, _, F, _, _} | R]} ->
+                Plus(Decl(D), Scoped(BindExpr(F), Expr({list_comp, A, Y, R})));
             {list_comp, A, Y, [D = {letfun, _, F, _, _, _} | R]} ->
                 Plus(Decl(D), Scoped(BindExpr(F), Expr({list_comp, A, Y, R})));
             {typed, _, E, T}       -> Plus(Expr(E), Type(T));

src/aeso_vm_decode.erl

@@ -18,14 +18,9 @@ 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, _, "bool"}, N) -> {bool, [], N /= 0};
+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>>,
     {bytes, [], <<Bytes:Len/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) ->
@@ -95,8 +87,6 @@ from_fate({tuple_t, _, Types}, ?FATE_TUPLE(Val))
         when length(Types) == tuple_size(Val) ->
     {tuple, [], [from_fate(Type, X)
                  || {Type, X} <- lists:zip(Types, tuple_to_list(Val))]};
-from_fate({record_t, [{field_t, _, FName, FType}]}, Val) ->
-    {record, [], [{field, [], [{proj, [], FName}], from_fate(FType, Val)}]};
 from_fate({record_t, Fields}, ?FATE_TUPLE(Val))
         when length(Fields) == tuple_size(Val) ->
     {record, [], [ {field, [], [{proj, [], FName}], from_fate(FType, X)}
@@ -115,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.3.0"},
+  {vsn, "4.0.0-rc4"},
   {registered, []},
   {applications,
    [kernel,

test/aeso_abi_tests.erl

@@ -62,7 +62,7 @@ encode_decode_sophia_test() ->
                                 Other -> Other
                               end end,
     ok = Check("int", "42"),
-    ok = Check("int", "- 42"),
+    ok = Check("int", "-42"),
     ok = Check("bool", "true"),
     ok = Check("bool", "false"),
     ok = Check("string", "\"Hello\""),

test/aeso_aci_tests.erl

@@ -11,10 +11,7 @@ test_contract(N) ->
     {Contract,MapACI,DecACI} = test_cases(N),
     {ok,JSON} = aeso_aci:contract_interface(json, Contract),
     ?assertEqual([MapACI], JSON),
-    ?assertEqual({ok, DecACI}, aeso_aci:render_aci_json(JSON)),
-    %% Check if the compiler provides correct aci
-    {ok,#{aci := JSON2}} = aeso_compiler:from_string(Contract, [{aci, json}]),
-    ?assertEqual(JSON, JSON2).
+    ?assertEqual({ok, DecACI}, aeso_aci:render_aci_json(JSON)).
 
 test_cases(1) ->
     Contract = <<"payable contract C =\n"
@@ -83,11 +80,11 @@ test_cases(3) ->
     DecACI = <<"contract C =\n"
                "  type state = unit\n"
                "  datatype event = SingleEventDefined\n"
-               "  datatype bert('a) = Bin('a)\n"
-               "  entrypoint a : (C.bert(string)) => int\n">>,
+	       "  datatype bert('a) = Bin('a)\n"
+	       "  entrypoint a : (C.bert(string)) => int\n">>,
     {Contract,MapACI,DecACI}.
 
-%% Roundtrip
+%% Rounttrip
 aci_test_() ->
     [{"Testing ACI generation for " ++ ContractName,
       fun() -> aci_test_contract(ContractName) end}
@@ -97,13 +94,8 @@ all_contracts() -> aeso_compiler_tests:compilable_contracts().
 
 aci_test_contract(Name) ->
     String = aeso_test_utils:read_contract(Name),
-    Opts   = case lists:member(Name, aeso_compiler_tests:debug_mode_contracts()) of
-                 true  -> [debug_mode];
-                 false -> []
-             end ++ [{include, {file_system, [aeso_test_utils:contract_path()]}}],
+    Opts   = [{include, {file_system, [aeso_test_utils:contract_path()]}}],
     {ok, JSON} = aeso_aci:contract_interface(json, String, Opts),
-    {ok, #{aci := JSON1}} = aeso_compiler:from_string(String, [{aci, json}, {backend, fate} | Opts]),
-    ?assertEqual(JSON, JSON1),
 
     io:format("JSON:\n~p\n", [JSON]),
     {ok, ContractStub} = aeso_aci:render_aci_json(JSON),
@@ -114,7 +106,7 @@ aci_test_contract(Name) ->
     ok.
 
 check_stub(Stub, Options) ->
-    try aeso_parser:string(binary_to_list(Stub), Options) of
+    case aeso_parser:string(binary_to_list(Stub), Options) of
         Ast ->
             try
                 %% io:format("AST: ~120p\n", [Ast]),
@@ -125,8 +117,9 @@ check_stub(Stub, Options) ->
                   _: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"
@@ -113,7 +97,6 @@ compilable_contracts() ->
      {"funargs", "traffic_light", ["Pantone(12)"]},
      {"funargs", "tuples", ["()"]},
      %% TODO {"funargs", "due", ["FixedTTL(1020)"]},
-     {"funargs", "singleton_rec", ["{x = 1000}"]},
      {"variant_types", "init", []},
      {"basic_auth", "init", []},
      {"address_literals", "init", []},

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.
@@ -39,7 +31,7 @@ simple_compile_test_() ->
                    error(ErrBin)
            end
        end} || ContractName <- compilable_contracts(), Backend <- [aevm, fate],
-               not lists:member(ContractName, not_compilable_on(Backend))] ++
+               not lists:member(ContractName, not_yet_compilable(Backend))] ++
     [ {"Test file not found error",
        fun() ->
            {error, Errors} = aeso_compiler:file("does_not_exist.aes"),
@@ -110,15 +102,7 @@ compile(Backend, Name) ->
 
 compile(Backend, Name, Options) ->
     String = aeso_test_utils:read_contract(Name),
-    Options1 =
-        case lists:member(Name, debug_mode_contracts()) of
-            true  -> [debug_mode];
-            false -> []
-        end ++
-        [ {src_file, Name ++ ".aes"}, {backend, Backend}
-        , {include, {file_system, [aeso_test_utils:contract_path()]}}
-        ] ++ Options,
-    case aeso_compiler:from_string(String, Options1) of
+    case aeso_compiler:from_string(String, [{src_file, Name ++ ".aes"}, {backend, Backend} | Options]) of
         {ok, Map}                                        -> Map;
         {error, ErrorString} when is_binary(ErrorString) -> ErrorString;
         {error, Errors}                                  -> Errors
@@ -146,7 +130,6 @@ compilable_contracts() ->
      "test",
      "builtin_bug",
      "builtin_map_get_bug",
-     "lc_record_bug",
      "nodeadcode",
      "deadcode",
      "variant_types",
@@ -169,23 +152,11 @@ compilable_contracts() ->
      "manual_stdlib_include",
      "list_comp",
      "payable",
-     "unapplied_builtins",
-     "underscore_number_literals",
-     "qualified_constructor",
-     "let_patterns",
-     "lhs_matching",
-     "hermetization_turnoff"
+     "unapplied_builtins"
     ].
 
-not_compilable_on(fate) -> [];
-not_compilable_on(aevm) ->
-    ["stdlib_include",
-     "manual_stdlib_include",
-     "hermetization_turnoff"
-    ].
-
-debug_mode_contracts() ->
-    ["hermetization_turnoff"].
+not_yet_compilable(fate) -> [];
+not_yet_compilable(aevm) -> [].
 
 %% Contracts that should produce type errors
 
@@ -204,8 +175,6 @@ debug_mode_contracts() ->
 -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)
@@ -316,22 +285,9 @@ failing_contracts() ->
           "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">>,
+          "Repeated argument x to function repeated_arg (at line 44, column 14).">>,
+        <<?Pos(44, 14)
+          "Repeated argument y to function repeated_arg (at line 44, column 14).">>,
         <<?Pos(14, 24)
           "No record type with fields y, z (at line 14, column 24)">>,
         <<?Pos(15, 26)
@@ -391,17 +347,79 @@ failing_contracts() ->
            "  r.foo : (gas : int, value : int) => Remote.themap\n"
            "against the expected type\n"
            "  (gas : int, value : int) => map(string, int)">>])
-    , ?TYPE_ERROR(not_toplevel_include,
-                  [<<?Pos(2, 11)
-                     "Include of 'included.aes' at line 2, column 11\nnot allowed, include only allowed at top level.">>])
-    , ?TYPE_ERROR(not_toplevel_namespace,
-                  [<<?Pos(2, 13)
-                     "Nested namespaces are not allowed\nNamespace 'Foo' at line 2, column 13 not defined at top level.">>])
-    , ?TYPE_ERROR(not_toplevel_contract,
-        [<<?Pos(2, 12)
-           "Nested contracts are not allowed\nContract 'Con' at line 2, column 12 not defined at top level.">>])
+    , ?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)
+        [<<?Pos(32, 5)
+           "The type bytes(32) is not a contract type\n"
+           "when checking that the contract literal at line 32, column 5\n"
+           "  ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ\n"
+           "has the type\n"
+           "  bytes(32)">>,
+         <<?Pos(30, 5)
+           "The type oracle(int, bool) is not a contract type\n"
+           "when checking that the contract literal at line 30, column 5\n"
+           "  ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ\n"
+           "has the type\n"
+           "  oracle(int, bool)">>,
+         <<?Pos(28, 5)
+           "The type address is not a contract type\n"
+           "when checking that the contract literal at line 28, column 5\n"
+           "  ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ\n"
+           "has the type\n"
+           "  address">>,
+         <<?Pos(25, 5)
+           "Cannot unify oracle_query('a, 'b)\n"
+           "         and Remote\n"
+           "when checking the type of the expression at line 25, column 5\n"
+           "  oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY :\n"
+           "    oracle_query('a, 'b)\n"
+           "against the expected type\n"
+           "  Remote">>,
+         <<?Pos(23, 5)
+           "Cannot unify oracle_query('c, 'd)\n"
+           "         and bytes(32)\n"
+           "when checking the type of the expression at line 23, column 5\n"
+           "  oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY :\n"
+           "    oracle_query('c, 'd)\n"
+           "against the expected type\n"
+           "  bytes(32)">>,
+         <<?Pos(21, 5)
+           "Cannot unify oracle_query('e, 'f)\n"
+           "         and oracle(int, bool)\n"
+           "when checking the type of the expression at line 21, column 5\n"
+           "  oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY :\n"
+           "    oracle_query('e, 'f)\n"
+           "against the expected type\n"
+           "  oracle(int, bool)">>,
+         <<?Pos(18, 5)
+           "Cannot unify oracle('g, 'h)\n"
+           "         and Remote\n"
+           "when checking the type of the expression at line 18, column 5\n"
+           "  ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5 :\n"
+           "    oracle('g, 'h)\n"
+           "against the expected type\n"
+           "  Remote">>,
+         <<?Pos(16, 5)
+           "Cannot unify oracle('i, 'j)\n"
+           "         and bytes(32)\n"
+           "when checking the type of the expression at line 16, column 5\n"
+           "  ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5 :\n"
+           "    oracle('i, 'j)\n"
+           "against the expected type\n"
+           "  bytes(32)">>,
+         <<?Pos(14, 5)
+           "Cannot unify oracle('k, 'l)\n"
+           "         and oracle_query(int, bool)\n"
+           "when checking the type of the expression at line 14, column 5\n"
+           "  ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5 :\n"
+           "    oracle('k, 'l)\n"
+           "against the expected type\n"
+           "  oracle_query(int, bool)">>,
+         <<?Pos(11, 5)
            "Cannot unify address\n"
            "         and oracle(int, bool)\n"
            "when checking the type of the expression at line 11, column 5\n"
@@ -421,79 +439,7 @@ failing_contracts() ->
            "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">>])
+           "  bytes(32)">>])
     , ?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.">>,
@@ -603,7 +549,7 @@ failing_contracts() ->
             "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"
+            "  - 'e  (at line 13, column 5)\n"
             "  - bytes(20)  (at line 12, column 29)">>,
           <<?Pos(16, 5)
             "Failed to resolve byte array lengths in call to Bytes.split with argument of type\n"
@@ -616,106 +562,7 @@ failing_contracts() ->
             "  - '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(toplevel_let,
-                  [<<?Pos(2, 7)
-                     "Toplevel \"let\" definitions are not supported\n"
-                     "Value this_is_illegal at line 2, column 7 could be replaced by 0-argument function">>])
-    , ?TYPE_ERROR(empty_typedecl,
-                  [<<?Pos(2, 8)
-                     "Empty type declarations are not supported\n"
-                     "Type t at line 2, column 8 lacks a definition">>])
-    , ?TYPE_ERROR(higher_kinded_type,
-                  [<<?Pos(2, 35)
-                     "Type 'm is a higher kinded type variable\n"
-                     "(takes another type as an argument)">>])
-    , ?TYPE_ERROR(bad_arity,
-                  [<<?Pos(3, 20)
-                     "Arity for id doesn't match. Expected 1, got 0">>,
-                   <<?Pos(3, 25)
-                     "Cannot unify int\n"
-                     "         and id\n"
-                     "when checking the type of the expression at line 3, column 25\n"
-                     "  123 : int\n"
-                     "against the expected type\n"
-                     "  id">>,
-                   <<?Pos(4, 20)
-                     "Arity for id doesn't match. Expected 1, got 2">>,
-                   <<?Pos(4, 35)
-                     "Cannot unify int\n"
-                     "         and id(int, int)\n"
-                     "when checking the type of the expression at line 4, column 35\n"
-                     "  123 : int\n"
-                     "against the expected type\n"
-                     "  id(int, int)">>])
-    , ?TYPE_ERROR(bad_unnamed_map_update_default,
-                  [<<?Pos(4, 17)
-                     "Invalid map update with default">>])
-    , ?TYPE_ERROR(non_functional_entrypoint,
-                  [<<?Pos(2, 14)
-                     "f at line 2, column 14 was declared with an invalid type int.\n"
-                     "Entrypoints and functions must have functional types">>])
-    , ?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 {}">>
-        ])
-    , ?TYPE_ERROR(bad_function_block,
-                  [<<?Pos(4, 5)
-                     "Mismatch in the function block. Expected implementation/type declaration of g function">>,
-                   <<?Pos(5, 5)
-                     "Mismatch in the function block. Expected implementation/type declaration of g function">>
-                  ])
-    , ?TYPE_ERROR(just_an_empty_file,
-                  [<<?Pos(0, 0)
-                     "Empty contract">>
-                  ])
-    , ?TYPE_ERROR(bad_number_of_args,
-                  [<<?Pos(3, 39)
-                     "Cannot unify () => unit\n"
-                     "         and (int) => 'a\n",
-                     "when checking the application at line 3, column 39 of\n"
-                     "  f : () => unit\n"
-                     "to arguments\n"
-                     "  1 : int">>,
-                   <<?Pos(4, 20)
-                     "Cannot unify (int, string) => 'e\n"
-                     "         and (int) => 'd\n"
-                     "when checking the application at line 4, column 20 of\n"
-                     "  g : (int, string) => 'e\n"
-                     "to arguments\n"
-                     "  1 : int">>,
-                   <<?Pos(5, 20)
-                     "Cannot unify (int, string) => 'c\n"
-                     "         and (string) => 'b\n"
-                     "when checking the application at line 5, column 20 of\n"
-                     "  g : (int, string) => 'c\nto arguments\n"
-                     "  \"Litwo, ojczyzno moja\" : string">>
-                  ])
-    , ?TYPE_ERROR(bad_state,
-                  [<<?Pos(4, 16)
-                     "Conflicting updates for field 'foo'">>])
+            "  - 'a  (at line 19, column 5)">>])
     ].
 
 -define(Path(File), "code_errors/" ??File).
@@ -831,49 +678,3 @@ failing_code_gen_contracts() ->
             "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,
-      case lists:member(Contract2, debug_mode_contracts()) of
-          true  -> [debug_mode];
-          false -> []
-      end ++
-      [{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,6 +38,7 @@ 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) ->
+                            OpAtom = list_to_atom(Op),
                             ?assertThrow({error, [_]},
                                          parse_expr(NoPar({a, Op, {b, Op, c}}))) end,
             Stronger = fun(Op1, Op2) ->
@@ -78,7 +77,7 @@ parse_string(Text, Opts) ->
     aeso_parser:string(Text, Opts).
 
 parse_expr(Text) ->
-    [{letval, _, _, Expr}] =
+    [{letval, _, _, _, Expr}] =
         parse_string("let _ = " ++ Text),
     Expr.
 

test/contracts/05_greeter.aes

@@ -58,7 +58,8 @@ contract Greeter =
 
     let state = { greeting = "Hello" }
 
-    function setGreeting(greeting: string) =
+    let setGreeting =
+        (greeting: string) =>
             state{ greeting = greeting }
 
 

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/all_syntax.aes

@@ -1,78 +1,44 @@
 // Try to cover all syntactic constructs.
-@compiler > 0
-@compiler =< 10.1.1.1.1.1.2.3.4
 
+contract AllSyntaxType =
+  type typeDecl /* bla */
+  type paramTypeDecl('a, 'b)
 
-namespace Ns =
-  datatype d('a) = D | S(int) | M('a, list('a), int)
-  private function fff() = 123
-
-  stateful entrypoint
-    f (1, x) = (_) => x
-
-payable contract AllSyntaxType =
   /** Multi-
     * line
     * comment
     */
-  stateful function foo : _
-  entrypoint bar : int => (int * 'a)
-
+  function foo : _
 
 contract AllSyntax =
 
-  datatype mickiewicz = Adam | Mickiewicz
-  record goethe('a, 'b) = {
-    johann : int,
-    wolfgang : 'a,
-    von : 'a * 'b * int,
-    goethe : unit
-    }
-  type dante = Ns.d(int)
-  type shakespeare('a) = goethe('a, 'a)
+  type typeDecl = int
+  type paramTypeDecl('a, 'b) = (('a, 'b) => 'b) => list('a) => 'b => 'b
 
-  type state = shakespeare(int)
+  record nestedRecord = { x : int }
+  record recordType = { z : nestedRecord, y : int }
+  datatype variantType('a) = None | Some('a)
 
-  entrypoint init() = {
-    johann = 1000,
-    wolfgang = -10,
-    von = (2 + 2, 0, List.sum([x | k <- [1,2,3]
-                                 , let l = k + 1
-                                 , if(l < 10)
-                                 , let f(x) = x + 100
-                                 , Adam <- [Adam, Mickiewicz]
-                                 , let x = f(l)
-                                 ])),
-    goethe = () }
+  let valWithType : map(int, int) => option(int) = (m) => Map.get(m, 42)
+  let valNoType =
+        if(valWithType(Map.empty) == None)
+          print(42 mod 10 * 5 / 3)
 
-  function f() =
-     let kp = "nietzsche"
-     let p = "Пушкин"
-     let k(x : bytes(8)) : bytes(8) = Bytes.to_int(#fedcba9876543210)
+  function funWithType(x : int, y) : int * list(int) = (x, 0 :: [y] ++ [])
+  function funNoType() =
+    let foo = (x, y : bool) =>
+                if (! (y && x =< 0x0b || true)) [x]
+                else [11..20]
+    let setY(r : recordType) : unit = r{ y = 5 }
+    let setX(r : recordType, x : int) : recordType = r { z.x = x }  // nested record update
+    let getY(r) = switch(r) {y = y} => y
+    switch (funWithType(1, -2))
+      (x, [y, z]) => bar({x = z, y = -y + - -z * (-1)})
+      (x, y :: _) => ()
 
-     let f : () => address = () => ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt
-     if(Bits.test(Bits.all, 10))
-       abort("ohno")
-     if(true && false)
-       require(true, "ohyes")
-     elif(false || 2 == 2)
-       ()
-     else
-       ()
-     if(true) f(1,2)((1,2))
-     else switch(1::[1,2,3])
-       [] => 1
-       a::b => 123
-       1::2::3 => 123123
-       [2,3,4] => 1
-       _ => 13
-       1::[2] => 2138
-     put(state{johann = 1})
-     
-     let m = {["foo"] = 19, /*hey wanna talk about inlined comments?*/ ["bar"] = 42}
-     let n = {}
-     m{ ["x" = 0] @ z = z + state.johann }
+  let hash : address = #01ab0fff11
+  let b = false
+  let qcon = Mod.Con
+  let str = "blabla\nfoo"
+  let chr = '"'
 
-     let sh : shakespeare(shakespeare(int)) =
-       {wolfgang = state}
-     sh{wolfgang.wolfgang = sh.wolfgang} // comment

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_arity.aes

@@ -1,4 +0,0 @@
-contract C =
-  type id('a) = 'a
-  entrypoint f() : id = 123
-  entrypoint g() : id(int, int) = 123

test/contracts/bad_function_block.aes

@@ -1,5 +0,0 @@
-contract C =
-  function
-    g(1) = 2
-    f(2) = 3
-    h(1) = 123

test/contracts/bad_include_and_ns.aes

@@ -1,4 +1,5 @@
-contract BadCon =
+contract Bad =
+  include "included.aes"
   namespace Foo =
     function foo() = 42
 

test/contracts/bad_number_of_args.aes

@@ -1,6 +0,0 @@
-contract Test =
-  entrypoint f() = ()
-  entrypoint g(x : int, y : string) = f(1)
-  entrypoint h() = g(1)
-  entrypoint i() = g("Litwo, ojczyzno moja")
-  

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_state.aes

@@ -1,5 +0,0 @@
-contract C =
-  record state = { foo : int }
-  entrypoint init(i : int) =
-    state{ foo = i,
-           foo = 42 }

test/contracts/bad_unnamed_map_update_default.aes

@@ -1,5 +0,0 @@
-contract C =
-  entrypoint f() =
-    let z = 123
-    {}{ [1 = 0] = z + 1 }
-    2

test/contracts/contract_as_namespace.aes

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

test/contracts/empty_typedecl.aes

@@ -1,3 +0,0 @@
-contract C =
-  type t
-  entrypoint f() = 123

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/funargs.aes

@@ -45,8 +45,3 @@ contract FunctionArguments =
 
   entrypoint due(t : Chain.ttl) =
      true
-
-  record singleton_r = { x : int }
-
-  entrypoint singleton_rec(r : singleton_r) =
-    r.x

test/contracts/hermetization_turnoff.aes

@@ -1,11 +0,0 @@
-namespace M =
-  function mf() = mg()
-  function mg() = mf()
-
-namespace N =
-  function nf() = ng() + M.mf() + M.mg()
-  private function ng() = nf() + M.mf() + M.mg()
-
-contract C =
-  entrypoint f() = N.ng() + N.nf() + g()
-  function g() = N.ng() + N.nf() + f()

test/contracts/higher_kinded_type.aes

@@ -1,3 +0,0 @@
-contract IWantToBelieve =
-  type stateT('s, 'm, 'a) = 's => 'm('a * 's)
-  entrypoint s() = 123

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/multi_sig.aes

@@ -15,7 +15,7 @@ contract MultiSig =
       | OwnerRemoved (address)          // of { .removedOwner : Address }
       | ReqChanged   (int)             // of { .newReq : int }
 
-    function maxOwners() : int = 250
+    let maxOwners : int = 250
 
     record state = { nRequired    : int
                  , nOwners      : int
@@ -68,7 +68,7 @@ contract MultiSig =
       switch(check_pending(callhash()))
         CheckFail(state') => { state = state' }
         CheckOk(state') =>
-            if(state.nOwners >= maxOwners()) () /* TODO */
+            if(state.nOwners >= maxOwners) () /* TODO */
             else
               let nOwners' = state'.nOwners + 1
               { state = state' { owners    = Map.insert(nOwners', newOwner, state'.owners)

test/contracts/multiple_contracts.aes

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

test/contracts/non_functional_entrypoint.aes

@@ -1,5 +0,0 @@
-contract C1 =
-  entrypoint f : int
-
-contract C =
-  entrypoint f() = 123

test/contracts/not_toplevel_contract.aes

@@ -1,6 +0,0 @@
-namespace BadNs =
-  contract Con =
-    entrypoint e : () => int
-
-contract Con =
-  entrypoint foo() = 43

test/contracts/not_toplevel_include.aes

@@ -1,5 +0,0 @@
-namespace BadNs =
-  include "included.aes"
-
-contract Con =
-  entrypoint foo() = 43

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/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/toplevel_let.aes

@@ -1,3 +0,0 @@
-contract C =
-  let this_is_illegal = 2/0
-  entrypoint this_is_legal() = 2/0

test/contracts/underscore_number_literals.aes

@@ -1,13 +0,0 @@
-
-contract UnderscoreNumberLiterals =
-
-  entrypoint ints() : list(int) =
-    [ 1_999_000_000,
-      19_99_00_00_00,
-      0xfff_FFF_010 ]
-
-  entrypoint bytes() : list(bytes(4)) =
-    [ #abcd_ef_00,
-      #01_02_03_04,
-      #aaaa_FFFF ]
-

test/contracts/validation_test1.aes

@@ -1,4 +0,0 @@
-contract ValidationTest =
-  payable entrypoint attr_fail() = ()
-  entrypoint type_fail(x : int) = x
-  entrypoint code_fail(x) = x + 1

test/contracts/validation_test2.aes

@@ -1,4 +0,0 @@
-contract ValidationTest =
-  entrypoint attr_fail() = ()
-  entrypoint type_fail(x) = x
-  entrypoint code_fail(x) = x - 1

test/contracts/validation_test3.aes

@@ -1,4 +0,0 @@
-payable contract ValidationTest =
-  payable entrypoint attr_fail() = ()
-  entrypoint type_fail(x : int) = x
-  entrypoint code_fail(x) = x + 1

test/contracts/voting.aes

@@ -1,3 +1,16 @@
+
+/* Contract type */
+contract VotingType =
+  type state
+  function init            : list(string) => state
+
+  function giveRightToVote : address => unit
+  function delegate        : address => unit
+  function vote            : int => unit
+  function winnerName      : unit => string
+  function currentTally    : unit => list(string * int)
+
+/* Contract implementation */
 contract Voting =
 
   // Types

test/contracts/wrong_compiler_version.aes

@@ -1,7 +0,0 @@
-@compiler < 1.0
-@compiler == 9.9.9
-@compiler >= 0.1
-@compiler =< 100.0.1
-
-contract Fail =
-  entrypoint foo() = ()