CHANGELOG update

Fix stdlib doc

.circleci/config.yml

@@ -8,6 +8,15 @@ executors:
     working_directory: ~/aesophia
 
 jobs:
+  verify_rebar_lock:
+    executor: aebuilder
+    steps:
+      - checkout
+      - run:
+          name: Ensure lock file is up-to-date
+          command: |
+            ./rebar3 upgrade
+            git diff --quiet -- rebar.lock || (echo "rebar.lock is not up-to-date" && exit 1)
   build:
     executor: aebuilder
     steps:
@@ -35,3 +44,10 @@ jobs:
             - _build/default/rebar3_20.3.8_plt
       - store_artifacts:
           path: _build/test/logs
+
+workflows:
+  version: 2
+  build_test:
+    jobs:
+      - build
+      - verify_rebar_lock

.gitignore

@@ -21,3 +21,4 @@ rebar3.crashdump
 aesophia
 .qcci
 current_counterexample.eqc
+test/contracts/test.aes

CHANGELOG.md

@@ -6,9 +6,127 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 ### Added
+- `Option.force_msg`
 ### Changed
 ### Removed
 
+## [6.0.2] 2021-07-05
+### Changed
+- `List.from_to_step` now forbids non-positive step (this change does
+  *not* alter the behavior of the previously deployed contracts)
+- Fixed leaking state between contracts
+
+## [6.0.1] 2021-06-24
+### Changed
+- Fixed a bug in calldata encoding for contracts containing multiple contracts
+- Fixed a missing `include` in the `Frac` standard library
+
+## [6.0.0] 2021-05-26
+### Added
+- Child contracts
+- `Chain.clone`
+- `Chain.create`
+- `Chain.bytecode_hash`
+- Minor support for variadic functions
+- `void` type that represents an empty type
+- `Call.fee` builtin
+### Changed
+- Contract interfaces must be now invocated by `contract interface` keywords
+- `main` keyword to indicate the main contract in case there are child contracts around
+- `List.sum` and `List.product` no longer use `List.foldl`
+### Removed
+
+## [5.0.0] 2021-04-30
+### Added
+- A new and improved [`String` standard library](https://github.com/aeternity/aesophia/blob/master/docs/sophia_stdlib.md#string)
+  has been added. Use it by `include "String.aes"`. It includes functions for
+  turning strings into lists of characters for detailed manipulation. For
+  example:
+  ```
+  include "String.aes"
+  contract C =
+    entrypoint filter_all_a(s: string) : string =
+      String.from_list(List.filter((c : char) => c != 'a', String.to_list(s)))
+  ```
+  will return a list with all `a`'s removed.
+
+  There are also convenience functions `split`, `concat`, `to_upper`,
+  `to_lower`, etc.
+
+  All String functions in FATEv2 operate on unicode code points.
+- Operations for pairing-based cryptography has been added the operations
+  are in the standard library [BLS12_381](https://github.com/aeternity/aesophia/blob/master/docs/sophia_stdlib.md#bls12_381).
+  With these operations it is possible to do Zero Knowledge-proofs, etc.
+  The operations are for the BLS12-381 curve (as the name suggests).
+- Calls to functions in other contracts (i.e. _remote calls_) can now be
+  [`protected`](https://github.com/aeternity/aesophia/blob/master/docs/sophia.md#protected-contract-calls).
+  If a contract call fails for any reason (for instance, the remote contract
+  crashes or runs out of gas, or the entrypoint doesn't exist or has the
+  wrong type) the parent call also fails. To make it possible to recover
+  from failures, contract calls takes a named argument `protected : bool`
+  (default `false`).
+
+  If `protected = true` the result of the contract call is wrapped in an
+  `option`, and `Some(value)` indicates a succesful execution and `None`
+  indicates that the contract call failed. Note: any gas consumed until
+  the failure is still charged, but all side effects in the remote
+  contract are rolled back on failure.
+- A new chain operation [`AENS.update`](https://github.com/aeternity/aesophia/blob/master/docs/sophia.md#aens-interface)
+  is supported.
+- New chain exploring operations `AENS.lookup` and `Oracle.expiry` to
+  look up an AENS record and the expiry of an Oracle respectively, are added.
+- Transaction introspection (`Auth.tx`) has been added. When a Generalized
+  account is authorized, the authorization function needs access to the
+  transaction (and the transaction hash) for the wrapped transaction. The
+  transaction and the transaction hash is available `Auth.tx`, it is only
+  available during authentication if invoked by a normal contract call
+  it returns `None`. Example:
+  ```
+  switch(Auth.tx)
+    None      => abort("Not in Auth context")
+    Some(tx0) =>
+      switch(tx0.tx)
+        Chain.SpendTx(_, amount, _)  => amount > 400
+        Chain.ContractCallTx(_, _)   => true
+        _                            => false
+  ```
+- A debug mode is a added to the compiler. Right now its only use is to
+  turn off hermetization.
+### Changed
+- The function `Chain.block_hash(height)` is now (in FATEv2) defined for
+  the current height - this used to be an error.
+- Standard library: Sort is optimized to do `mergesort` and a `contains`
+  function is added.
+- Improved type errors and explicit errors for some syntax errors (empty code
+  blocks, etc.).
+- Compiler optimization: The ACI is generated alongside bytecode. This means
+  that multiple compiler passes can be avoided.
+- Compiler optimization: Improved parsing (less stack used when transpiled).
+- A bug where constraints were handled out of order fixed.
+- Fixed calldata decoding for singleton records.
+- Improved the documentation w.r.t. signatures, especially stressing the fact that
+  the network ID is a part of what is signed.
+### Removed
+
+## [4.3.0]
+### 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
@@ -53,7 +171,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   (de-)construct byte arrays.
 - `[a..b]` language construct, returning the list of numbers between
   `a` and `b` (inclusive). Returns the empty list if `a` > `b`.
-- [Standard libraries] (https://github.com/aeternity/protocol/blob/master/contracts/sophia_stdlib.md)
+- [Standard libraries](https://github.com/aeternity/aesophia/blob/master/docs/sophia_stdlib.md)
 - Checks that `init` is not called from other functions.
 - FATE backend - the compiler is able to produce VM code for both `AEVM` and `FATE`. Many
   of the APIs now take `{backend, aevm | fate}` to decide wich backend to produce artifacts
@@ -192,10 +310,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Simplify calldata creation - instead of passing a compiled contract, simply
   pass a (stubbed) contract string.
 
-[Unreleased]: https://github.com/aeternity/aesophia/compare/v4.2.0...HEAD
-[4.2.0]: https://github.com/aeternity/aesophia/compare/v4.2.0...v4.1.0
-[4.1.0]: https://github.com/aeternity/aesophia/compare/v4.1.0...v4.0.0
-[4.0.0]: https://github.com/aeternity/aesophia/compare/v4.0.0...v3.2.0
+[Unreleased]: https://github.com/aeternity/aesophia/compare/v6.0.2...HEAD
+[6.0.2]: https://github.com/aeternity/aesophia/compare/v6.0.1...v6.0.2
+[6.0.1]: https://github.com/aeternity/aesophia/compare/v6.0.0...v6.0.1
+[6.0.0]: https://github.com/aeternity/aesophia/compare/v5.0.0...v6.0.0
+[5.0.0]: https://github.com/aeternity/aesophia/compare/v4.3.0...v5.0.0
+[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
 [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,21 +1,26 @@
 # aesophia
 
-This is the __sophia__ compiler for the æternity system which compiles contracts written in __sophia__ code to the æternity VM code.
+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.
 
-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).
+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
 
-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.
+## 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).
 
 ## Versioning
 
-`aesophia` has a version that is only loosely connected to the version of the
-Aeternity node - in principle they will share the major version but not
-minor/patch version. The `aesophia` compiler version MUST be bumped whenever
-there is a change in how byte code is generated, but it MAY also be bumped upon
-API changes etc.
+Versioning should follow the [semantic versioning](https://semver.org/spec/v2.0.0) guidelines. Id est, given a version number MAJOR.MINOR.PATCH, increment the:
+
+- MAJOR version when you make incompatible API changes
+- MINOR version when you add functionality in a backwards compatible manner
+- PATCH version when you make backwards compatible bug fixes
+
 
 ## Interface Modules
 

priv/stdlib/BLS12_381.aes

@@ -0,0 +1,68 @@
+namespace BLS12_381 =
+  type fr    = MCL_BLS12_381.fr
+  type fp    = MCL_BLS12_381.fp
+  record fp2 = { x1 : fp, x2 : fp }
+  record g1  = { x : fp, y : fp, z : fp }
+  record g2  = { x : fp2, y : fp2, z : fp2 }
+  record gt  = { x1 : fp, x2 : fp, x3 : fp, x4 : fp, x5 : fp, x6 : fp,
+                 x7 : fp, x8 : fp, x9 : fp, x10 : fp, x11 : fp, x12 : fp }
+
+  function pairing_check(xs : list(g1), ys : list(g2)) =
+    switch((xs, ys))
+      ([], []) => true
+      (x :: xs, y :: ys) => pairing_check_(pairing(x, y), xs, ys)
+
+  function pairing_check_(acc : gt, xs : list(g1), ys : list(g2)) =
+    switch((xs, ys))
+      ([], []) => gt_is_one(acc)
+      (x :: xs, y :: ys) =>
+        pairing_check_(gt_mul(acc, pairing(x, y)), xs, ys)
+
+  function int_to_fr(x : int) = MCL_BLS12_381.int_to_fr(x)
+  function int_to_fp(x : int) = MCL_BLS12_381.int_to_fp(x)
+  function fr_to_int(x : fr)  = MCL_BLS12_381.fr_to_int(x)
+  function fp_to_int(x : fp)  = MCL_BLS12_381.fp_to_int(x)
+
+  function mk_g1(x : int, y : int, z : int) : g1 =
+    { x = int_to_fp(x), y = int_to_fp(y), z = int_to_fp(z) }
+
+  function mk_g2(x1 : int, x2 : int, y1 : int, y2 : int, z1 : int, z2 : int) : g2 =
+    { x = {x1 = int_to_fp(x1), x2 = int_to_fp(x2)},
+      y = {x1 = int_to_fp(y1), x2 = int_to_fp(y2)},
+      z = {x1 = int_to_fp(z1), x2 = int_to_fp(z2)} }
+
+  function pack_g1(t) = switch(t)
+                          (x, y, z) => {x = x, y = y, z = z} : g1
+  function pack_g2(t) = switch(t)
+                          ((x1, x2), (y1, y2), (z1, z2)) =>
+                            {x = {x1 = x1, x2 = x2}, y = {x1 = y1, x2 = y2}, z = {x1 = z1, x2 = z2}} : g2
+  function pack_gt(t) = switch(t)
+                          (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) =>
+                            {x1 = x1, x2 = x2, x3 = x3, x4 = x4, x5 = x5, x6 = x6,
+                             x7 = x7, x8 = x8, x9 = x9, x10 = x10, x11 = x11, x12 = x12} : gt
+
+  function g1_neg(p : g1)         = pack_g1(MCL_BLS12_381.g1_neg((p.x, p.y, p.z)))
+  function g1_norm(p : g1)        = pack_g1(MCL_BLS12_381.g1_norm((p.x, p.y, p.z)))
+  function g1_valid(p : g1)       = MCL_BLS12_381.g1_valid((p.x, p.y, p.z))
+  function g1_is_zero(p : g1)     = MCL_BLS12_381.g1_is_zero((p.x, p.y, p.z))
+  function g1_add(p : g1, q : g1) = pack_g1(MCL_BLS12_381.g1_add((p.x, p.y, p.z), (q.x, q.y, q.z)))
+  function g1_mul(k : fr, p : g1) = pack_g1(MCL_BLS12_381.g1_mul(k, (p.x, p.y, p.z)))
+
+  function g2_neg(p : g2)         = pack_g2(MCL_BLS12_381.g2_neg(((p.x.x1, p.x.x2), (p.y.x1, p.y.x2), (p.z.x1, p.z.x2))))
+  function g2_norm(p : g2)        = pack_g2(MCL_BLS12_381.g2_norm(((p.x.x1, p.x.x2), (p.y.x1, p.y.x2), (p.z.x1, p.z.x2))))
+  function g2_valid(p : g2)       = MCL_BLS12_381.g2_valid(((p.x.x1, p.x.x2), (p.y.x1, p.y.x2), (p.z.x1, p.z.x2)))
+  function g2_is_zero(p : g2)     = MCL_BLS12_381.g2_is_zero(((p.x.x1, p.x.x2), (p.y.x1, p.y.x2), (p.z.x1, p.z.x2)))
+  function g2_add(p : g2, q : g2) = pack_g2(MCL_BLS12_381.g2_add(((p.x.x1, p.x.x2), (p.y.x1, p.y.x2), (p.z.x1, p.z.x2)),
+                                                                 ((q.x.x1, q.x.x2), (q.y.x1, q.y.x2), (q.z.x1, q.z.x2))))
+  function g2_mul(k : fr, p : g2) = pack_g2(MCL_BLS12_381.g2_mul(k, ((p.x.x1, p.x.x2), (p.y.x1, p.y.x2), (p.z.x1, p.z.x2))))
+
+  function gt_inv(p : gt)              = pack_gt(MCL_BLS12_381.gt_inv((p.x1, p.x2, p.x3, p.x4, p.x5, p.x6, p.x7, p.x8, p.x9, p.x10, p.x11, p.x12)))
+  function gt_add(p : gt, q : gt)      = pack_gt(MCL_BLS12_381.gt_add((p.x1, p.x2, p.x3, p.x4, p.x5, p.x6, p.x7, p.x8, p.x9, p.x10, p.x11, p.x12),
+                                                                      (q.x1, q.x2, q.x3, q.x4, q.x5, q.x6, q.x7, q.x8, q.x9, q.x10, q.x11, q.x12)))
+  function gt_mul(p : gt, q : gt)      = pack_gt(MCL_BLS12_381.gt_mul((p.x1, p.x2, p.x3, p.x4, p.x5, p.x6, p.x7, p.x8, p.x9, p.x10, p.x11, p.x12),
+                                                                      (q.x1, q.x2, q.x3, q.x4, q.x5, q.x6, q.x7, q.x8, q.x9, q.x10, q.x11, q.x12)))
+  function gt_pow(p : gt, k : fr)      = pack_gt(MCL_BLS12_381.gt_pow((p.x1, p.x2, p.x3, p.x4, p.x5, p.x6, p.x7, p.x8, p.x9, p.x10, p.x11, p.x12), k))
+  function gt_is_one(p : gt)           = MCL_BLS12_381.gt_is_one((p.x1, p.x2, p.x3, p.x4, p.x5, p.x6, p.x7, p.x8, p.x9, p.x10, p.x11, p.x12))
+  function pairing(p : g1, q : g2)     = pack_gt(MCL_BLS12_381.pairing((p.x, p.y, p.z), ((q.x.x1, q.x.x2), (q.y.x1, q.y.x2), (q.z.x1, q.z.x2))))
+  function miller_loop(p : g1, q : g2) = pack_gt(MCL_BLS12_381.miller_loop((p.x, p.y, p.z), ((q.x.x1, q.x.x2), (q.y.x1, q.y.x2), (q.z.x1, q.z.x2))))
+  function final_exp(p : gt)           = pack_gt(MCL_BLS12_381.final_exp((p.x1, p.x2, p.x3, p.x4, p.x5, p.x6, p.x7, p.x8, p.x9, p.x10, p.x11, p.x12)))

priv/stdlib/Frac.aes

@@ -0,0 +1,185 @@
+include "String.aes"
+
+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,35 +12,66 @@ 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))
 
-  function curry2(f : ('a, 'b) => 'c) : 'a => ('b => 'c) =
+/** 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) =
     (x) => (y) => f(x, y)
-  function curry3(f : ('a, 'b, 'c) => 'd) : 'a => ('b => ('c => 'd)) =
+  function curry3(f : ('a, 'b, 'c) => 'x) : 'a => ('b => ('c => 'x)) =
     (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)
 
-  function uncurry2(f : 'a => ('b => 'c)) : ('a, 'b) => 'c =
+/** Opposite of curry. Gross
+ */
+  function uncurry2(f : 'a => ('b => 'x)) : ('a, 'b) => 'x =
     (x, y) => f(x)(y)
-  function uncurry3(f : 'a => ('b => ('c => 'd))) : ('a, 'b, 'c) => 'd =
+  function uncurry3(f : 'a => ('b => ('c => 'x))) : ('a, 'b, 'c) => 'x =
     (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)
 
-  function tuplify2(f : ('a, 'b) => 'c) : (('a * 'b)) => 'c =
+/** Turns an arity-n function into a function taking n-tuple
+ */
+  function tuplify2(f : ('a, 'b) => 'x) : (('a * 'b)) => 'x =
     (t) => switch(t)
       (x, y) => f(x, y)
-  function tuplify3(f : ('a, 'b, 'c) => 'd) : 'a * 'b * 'c => 'd =
+  function tuplify3(f : ('a, 'b, 'c) => 'x) : 'a * 'b * 'c => 'x =
     (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)
 
-  function untuplify2(f : 'a * 'b => 'c) : ('a, 'b) => 'c =
+/** Opposite of tuplify
+ */
+  function untuplify2(f : 'a * 'b => 'x) : ('a, 'b) => 'x =
     (x, y) => f((x, y))
-  function untuplify3(f : 'a * 'b * 'c => 'd) : ('a, 'b, 'c) => 'd =
+  function untuplify3(f : 'a * 'b * 'c => 'x) : ('a, 'b, 'c) => 'x =
     (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,22 +15,42 @@ 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 drop_last(l : list('a)) : option(list('a)) = switch(l)
+    [] => None
+    _  => Some(drop_last_unsafe(l))
+
+  function drop_last_unsafe(l : list('a)) : list('a) = switch(l)
+    [_]  => []
+    h::t => h::drop_last_unsafe(t)
+    []   => abort("drop_last_unsafe: list empty")
+
+
+  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)
 
-  function find_indices(p : 'a => bool, l : list('a)) : list(int) = find_indices_(p, l, 0, [])
+/** 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)
                                 , n : int
-                                , acc : list(int)
                                 ) : list(int) = switch(l)
-    []   => reverse(acc)
-    h::t => find_indices_(p, t, n+1, if(p(h)) n::acc else acc)
+    []   => []
+    h::t =>
+     let rest = find_indices_(p, t, n+1)
+     if(p(h)) n::rest else rest
 
   function nth(n : int, l : list('a)) : option('a) =
     switch(l)
@@ -50,41 +70,54 @@ 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]
 
-  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)
+/** 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) =
+    require(s > 0, "List.from_to_step: non-positive step")
+    from_to_step_(a, b - (b-a) mod s, s, [])
+  private function from_to_step_(a : int, b : int, s : int, acc : list(int)) : list(int) =
+    if(b < a) acc
+    else from_to_step_(a, b - s, s, b::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) =
+    if(n<0) abort("insert_at underflow") else replace_at_(n, e, l)
+  private function replace_at_(n : int, e : 'a, l : list('a)) : list('a) =
    switch(l)
      []   => abort("replace_at overflow")
-     h::t => if (n == 0) reverse(e::acc) ++ t
-             else replace_at_(n-1, e, t, h::acc)
+     h::t => if (n == 0) e::t
+             else h::replace_at_(n-1, e, t)
 
-  /* 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) =
-   if (n == 0) reverse(e::acc) ++ l
+    if(n<0) abort("insert_at underflow") else insert_at_(n, e, l)
+  private function insert_at_(n : int, e : 'a, l : list('a)) : list('a) =
+   if (n == 0) e::l
    else switch(l)
      []   => abort("insert_at overflow")
-     h::t => insert_at_(n-1, e, t, h::acc)
+     h::t => h::insert_at_(n-1, e, t)
 
+/** 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) =
     switch(l)
-      []   => reverse(x::acc)
+      []   => [x]
       h::t =>
         if(cmp(x, h)) // x < h
-          reverse(acc) ++ (x::l)
+          x::l
         else
-          insert_by_(cmp, x, t, h::acc)
+          h::insert_by(cmp, x, t)
 
 
   function foldr(cons : ('a, 'b) => 'b, nil : 'b, l : list('a)) : 'b = switch(l)
@@ -102,61 +135,71 @@ namespace List =
        f(e)
        foreach(l', f)
 
-  function reverse(l : list('a)) : list('a) = foldl((lst, el) => el :: lst, [], l)
+  function reverse(l : list('a)) : list('a) = reverse_(l, [])
+  private function reverse_(l : list('a), acc : list('a)) : list('a) = switch(l)
+    [] => acc
+    h::t => reverse_(t, h::acc)
 
-  function map(f : 'a => 'b, l : list('a)) : list('b) = map_(f, l, [])
-  private function map_(f : 'a => 'b, l : list('a), acc : list('b)) : list('b) = switch(l)
-    []   => reverse(acc)
-    h::t => map_(f, t, f(h)::acc)
+  function map(f : 'a => 'b, l : list('a)) : list('b) = switch(l)
+    [] => []
+    h::t => f(h)::map(f, t)
 
+/** Effectively composition of `map` and `flatten`
+ */
   function flat_map(f : 'a => list('b), l : list('a)) : list('b) =
     ListInternal.flat_map(f, l)
 
-  function filter(p : 'a => bool, l : list('a)) : list('a) = filter_(p, l, [])
-  private function filter_(p : 'a => bool, l : list('a), acc : list('a)) : list('a) = switch(l)
-    []   => reverse(acc)
-    h::t => filter_(p, t, if(p(h)) h::acc else acc)
+  function filter(p : 'a => bool, l : list('a)) : list('a) = switch(l)
+    []   => []
+    h::t =>
+      let rest = filter(p, t)
+      if(p(h)) h::rest else rest
 
-  /* Take `n` first elements */
+/** Take up to `n` first elements
+ */
   function take(n : int, l : list('a)) : list('a) =
-    if(n < 0) abort("Take negative number of elements") else take_(n, l, [])
-  private function take_(n : int, l : list('a), acc : list('a)) : list('a) =
-    if(n == 0) reverse(acc)
+    if(n < 0) abort("Take negative number of elements") else take_(n, l)
+  private function take_(n : int, l : list('a)) : list('a) =
+    if(n == 0) []
     else switch(l)
-      []   => reverse(acc)
-      h::t => take_(n-1, t, h::acc)
+      []   => []
+      h::t => h::take_(n-1, t)
 
-  /* Drop `n` first elements */
+/** Drop up to `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
+   if(n < 0) abort("Drop negative number of elements") else drop_(n, l)
+  private function drop_(n : int, l : list('a)) : list('a) =
+   if (n == 0) l
    else switch(l)
       []   => []
-      h::t => drop(n-1, t)
+      h::t => drop_(n-1, t)
 
-  /* Get the longest prefix of a list in which every element matches predicate `p` */
-  function take_while(p : 'a => bool, l : list('a)) : list('a) = take_while_(p, l, [])
-  private function take_while_(p : 'a => bool, l : list('a), acc : list('a)) : list('a) = switch(l)
-    []   => reverse(acc)
-    h::t => if(p(h)) take_while_(p, t, h::acc) else reverse(acc)
+/** 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) = switch(l)
+    []   => []
+    h::t => if(p(h)) h::take_while(p, t) else []
 
-  /* 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` */
-  function partition(p : 'a => bool, l : list('a)) : (list('a) * list('a)) = partition_(p, l, [], [])
-  private function partition_( p : 'a => bool
-                             , l : list('a)
-                             , acc_t : list('a)
-                             , acc_f : list('a)
-                             ) : (list('a) * list('a)) = switch(l)
-    []   => (reverse(acc_t), reverse(acc_f))
-    h::t => if(p(h)) partition_(p, t, h::acc_t, acc_f) else partition_(p, t, acc_t, h::acc_f)
+/** 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)) = switch(l)
+    []   => ([], [])
+    h::t =>
+      let (l, r) = partition(p, t)
+      if(p(h)) (h::l, r) else (l, h::r)
 
-
-  function flatten(ll : list(list('a))) : list('a) = foldr((l1, l2) => l1 ++ l2, [], ll)
+  function flatten(l : list(list('a))) : list('a) = switch(l)
+    []   => []
+    h::t => h ++ flatten(t)
 
   function all(p : 'a => bool, l : list('a)) : bool = switch(l)
     []   => true
@@ -166,49 +209,108 @@ namespace List =
     []   => false
     h::t => if(p(h)) true else any(p, t)
 
-  function sum(l : list(int)) : int = foldl ((a, b) => a + b, 0, l)
+  function sum(l : list(int)) : int = switch(l)
+    []   => 0
+    h::t => h + sum(t)
 
-  function product(l : list(int)) : int = foldl((a, b) => a * b, 1, l)
+  function product(l : list(int)) : int = switch(l)
+    []   => 1
+    h::t => h * sum(t)
 
-
-  /* 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
+/** Zips two list by applying bimapping function on respective elements.
+ * Drops the tail of the longer list.
+ */
+  private function zip_with( f : ('a, 'b) => 'c
                             , l1 : list('a)
                             , l2 : list('b)
-                            , acc : list('c)
                             ) : list('c) = switch ((l1, l2))
-    (h1::t1, h2::t2) => zip_with_(f, t1, t2, f(h1, h2)::acc)
-    _ => reverse(acc)
+    (h1::t1, h2::t2) => f(h1, h2)::zip_with(f, t1, t2)
+    _ => []
 
-  /* Zips two lists into list of pairs. Drops longer tail. */
+/** Zips two lists into list of pairs.
+ * Drops the tail of the longer list.
+ */
   function zip(l1 : list('a), l2 : list('b)) : list('a * 'b) = zip_with((a, b) => (a, b), l1, l2)
 
-  function unzip(l : list('a * 'b)) : list('a) * list('b) = unzip_(l, [], [])
-  private function unzip_( l     : list('a * 'b)
-                         , acc_l : list('a)
-                         , acc_r : list('b)
-                         ) : (list('a) * list('b)) = switch(l)
-    []               => (reverse(acc_l), reverse(acc_r))
-    (left, right)::t => unzip_(t, left::acc_l, right::acc_r)
+  function unzip(l : list('a * 'b)) : (list('a) * list('b)) = switch(l)
+    []          => ([], [])
+    (h1, h2)::t =>
+      let (t1, t2) = unzip(t)
+      (h1::t1, h2::t2)
 
 
-  // TODO: Improve?
-  function sort(lesser_cmp : ('a, 'a) => bool, l : list('a)) : list('a) = switch(l)
+  /** 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
+
+
+  /** 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) = switch(l)
     []   => []
-    h::t => switch (partition((x) => lesser_cmp(x, h), t))
-      (lesser, bigger) => sort(lesser_cmp, lesser) ++ h::sort(lesser_cmp, bigger)
-
-
-  function intersperse(delim : 'a, l : list('a)) : list('a) = intersperse_(delim, l, [])
-  private function intersperse_(delim : 'a, l : list('a), acc : list('a)) : list('a) = switch(l)
-    []   => reverse(acc)
-    [e]  => reverse(e::acc)
-    h::t => intersperse_(delim, t, delim::h::acc)
-
-
-  function enumerate(l : list('a)) : list(int * 'a) = enumerate_(l, 0, [])
-  private function enumerate_(l : list('a), n : int, acc : list(int * 'a)) : list(int * 'a) = switch(l)
-    []   => reverse(acc)
-    h::t => enumerate_(t, n + 1, (n, h)::acc)
+    [e]  => [e]
+    h::t => h::delim::intersperse(delim, t)
 
+/** 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) : list(int * 'a) = switch(l)
+    []   => []
+    h::t => (n, h)::enumerate_(t, n + 1)

priv/stdlib/Option.aes

@@ -10,14 +10,29 @@ 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)
 
-  function force(o : option('a)) : 'a = default(abort("Forced None value"), o)
+/** Assume it is `Some`
+ */
+  function force(o : option('a)) : 'a = switch(o)
+    None    => abort("Forced None value")
+    Some(x) => x
+
+/** Assume it is `Some` with custom error message
+ */
+  function force_msg(o : option('a), err : string) : 'a = switch(o)
+    None    => abort(err)
+    Some(x) => x
+
+  function contains(e : 'a, o : option('a)) = o == Some(e)
 
   function on_elem(o : option('a), f : 'a => unit) : unit = match((), f, o)
 
@@ -40,10 +55,14 @@ 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)
@@ -53,24 +72,33 @@ namespace Option =
     None => []
     Some(x) => [x]
 
-  function filter_options(l : list(option('a))) : list('a) = filter_options_(l, [])
-  private function filter_options_(l : list (option('a)), acc : list('a)) : list('a) = switch(l)
-    []         => List.reverse(acc)
-    None::t    => filter_options_(t, acc)
-    Some(x)::t => filter_options_(t, x::acc)
+/** Turns list of options into a list of elements that are under `Some`s.
+ * Safe.
+ */
+  function filter_options(l : list(option('a))) : list('a) = switch(l)
+    []         => []
+    None::t    => filter_options(t)
+    Some(x)::t => x::filter_options(t)
 
-  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)
+/** 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)) = switch(l)
+    []         => Some([])
+    None::_    => None
+    Some(x)::t => switch(seq_options(t))
+      None => None
+      Some(st) => Some(x::st)
 
 
+/** 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)
     Some(x)::_ => Some(x)
-

priv/stdlib/Pair.aes

@@ -6,12 +6,18 @@ 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/String.aes

@@ -0,0 +1,117 @@
+include "List.aes"
+namespace String =
+  // Computes the SHA3/Keccak hash of the string
+  function sha3(s : string) : hash    = StringInternal.sha3(s)
+  // Computes the SHA256 hash of the string.
+  function sha256(s : string) : hash  = StringInternal.sha256(s)
+  // Computes the Blake2B hash of the string.
+  function blake2b(s : string) : hash = StringInternal.blake2b(s)
+
+  // The length of a string - equivalent to List.lenght(to_list(s))
+  function length(s : string) : int = StringInternal.length(s)
+  // Concatenates `s1` and `s2`.
+  function concat(s1 : string, s2 : string) : string = StringInternal.concat(s1, s2)
+  // Concatenates a list of strings.
+  function
+    concats : (list(string)) => string
+    concats([])      = ""
+    concats(s :: ss) = List.foldl(StringInternal.concat, s, ss)
+
+  // Converts a `string` to a list of `char` - the code points are normalized, but
+  // composite characters are possibly converted to multiple `char`s.
+  function from_list(cs : list(char)) : string = StringInternal.from_list(cs)
+  // Converts a list of characters into a normalized UTF-8 string.
+  function to_list(s : string) : list(char) = StringInternal.to_list(s)
+
+  // Converts a string to lowercase.
+  function to_lower(s : string) = StringInternal.to_lower(s)
+  // Converts a string to uppercase.
+  function to_upper(s : string) = StringInternal.to_upper(s)
+
+  // Splits a string at (zero-based) index `ix`.
+  function split(i : int, s : string) : string * string =
+    let cs = StringInternal.to_list(s)
+    (StringInternal.from_list(List.take(i, cs)), StringInternal.from_list(List.drop(i, cs)))
+
+  // Returns the character/codepoint at (zero-based) index `ix`.
+  function at(ix : int, s : string) =
+    switch(List.drop(ix, StringInternal.to_list(s)))
+      []     => None
+      x :: _ => Some(x)
+
+  // Searches for `pat` in `str`, returning `Some(ix)` if `pat` is a substring
+  // of `str` starting at position `ix`, otherwise returns `None`.
+  function contains(str : string, substr : string) : option(int) =
+    if(substr == "") Some(0)
+    else
+      contains_(0, StringInternal.to_list(str), StringInternal.to_list(substr))
+
+  // Splits `s` into tokens, `pat` is the divider of tokens.
+  function tokens(s : string, pat : string) =
+    require(pat != "", "String.tokens: empty pattern")
+    tokens_(StringInternal.to_list(pat), StringInternal.to_list(s), [])
+
+  // Converts a decimal ("123", "-253") or a hexadecimal ("0xa2f", "-0xBBB") string
+  // into an integer. If the string doesn't contain a valid number `None` is returned.
+  function to_int(s : string) : option(int) =
+    let s = StringInternal.to_list(s)
+    switch(is_prefix(['-'], s))
+      None    => to_int_pos(s)
+      Some(s) => switch(to_int_pos(s))
+                   None => None
+                   Some(x) => Some(-x)
+
+  // Private helper functions below
+  private function to_int_pos(s : list(char)) =
+    switch(is_prefix(['0', 'x'], s))
+      None =>
+        to_int_(s, ch_to_int_10, 0, 10)
+      Some(s) =>
+        to_int_(s, ch_to_int_16, 0, 16)
+
+  private function
+    tokens_(_, [], acc) = [StringInternal.from_list(List.reverse(acc))]
+    tokens_(pat, str, acc) =
+      switch(is_prefix(pat, str))
+        Some(str') =>
+          StringInternal.from_list(List.reverse(acc)) :: tokens_(pat, str', [])
+        None =>
+          let c :: cs = str
+          tokens_(pat, cs, c :: acc)
+
+  private function
+    contains_(_, [], _) = None
+    contains_(ix, str, substr) =
+      switch(is_prefix(substr, str))
+        None =>
+          let _ :: str = str
+          contains_(ix + 1, str, substr)
+        Some(_) =>
+          Some(ix)
+
+  private function
+    is_prefix([], ys) = Some(ys)
+    is_prefix(_, [])  = None
+    is_prefix(x :: xs, y :: ys) =
+      if(x == y) is_prefix(xs, ys)
+      else       None
+
+  private function
+    to_int_([], _, x, _) = Some(x)
+    to_int_(i :: is, value, x, b) =
+      switch(value(i))
+        None => None
+        Some(i) => to_int_(is, value, x * b + i, b)
+
+  private function ch_to_int_10(c) =
+    let c = Char.to_int(c)
+    if(c >= 48 && c =< 57) Some(c - 48)
+    else None
+
+  private function ch_to_int_16(c) =
+    let c = Char.to_int(c)
+    if(c >= 48 && c =< 57)    Some(c - 48)
+    elif(c >= 65 && c =< 70)  Some(c - 55)
+    elif(c >= 97 && c =< 102) Some(c - 87)
+    else None
+

priv/stdlib/Triple.aes

@@ -10,15 +10,23 @@ 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
@@ -29,9 +37,13 @@ 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,"05dfd7f"}}}
        , {getopt, "1.0.1"}
        , {eblake2, "1.0.0"}
        , {jsx, {git, "https://github.com/talentdeficit/jsx.git",
@@ -15,7 +15,7 @@
             {base_plt_apps, [erts, kernel, stdlib, crypto, mnesia]}
            ]}.
 
-{relx, [{release, {aesophia, "4.2.0"},
+{relx, [{release, {aesophia, "6.0.2"},
          [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,"05dfd7ffc7fb1e07ecc0b1e516da571f56d7dc8f"}},
   0},
  {<<"aeserialization">>,
   {git,"https://github.com/aeternity/aeserialization.git",

src/aeso_aci.erl

@@ -14,15 +14,21 @@
         , contract_interface/2
         , contract_interface/3
 
+        , from_typed_ast/2
+
         , render_aci_json/1
 
         , json_encode_expr/1
         , json_encode_type/1]).
 
+-include("aeso_utils.hrl").
+
 -type aci_type()  :: json | string.
 -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) ->
@@ -64,20 +70,20 @@ do_contract_interface(Type, Contract, Options) when is_binary(Contract) ->
 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]),
-        %% io:format("~p\n", [TypedAst]),
-        JArray = [ encode_contract(C) || C <- TypedAst ],
-
-        case Type of
-            json   -> {ok, JArray};
-            string -> do_render_aci_json(JArray)
-        end
+        {TypedAst, _} = aeso_ast_infer_types:infer(Ast, [dont_unfold | Options]),
+        from_typed_ast(Type, TypedAst)
     catch
         throw:{error, Errors} -> {error, Errors}
     end.
 
-encode_contract(Contract = {contract, _, {con, _, Name}, _}) ->
+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 = {Head, _, {con, _, Name}, _}) when ?IS_CONTRACT_HEAD(Head) ->
     C0 = #{name => encode_name(Name)},
 
     Tdefs0 = [ encode_typedef(T) || T <- sort_decls(contract_types(Contract)) ],
@@ -101,7 +107,7 @@ encode_contract(Contract = {contract, _, {con, _, Name}, _}) ->
                || F <- sort_decls(contract_funcs(Contract)),
                   is_entrypoint(F) ],
 
-    #{contract => C3#{functions => Fdefs, payable => is_payable(Contract)}};
+    #{contract => C3#{kind => Head, functions => Fdefs, payable => is_payable(Contract)}};
 encode_contract(Namespace = {namespace, _, {con, _, Name}, _}) ->
     Tdefs = [ encode_typedef(T) || T <- sort_decls(contract_types(Namespace)) ],
     #{namespace => #{name => encode_name(Name),
@@ -194,6 +200,8 @@ 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),
@@ -224,13 +232,19 @@ do_render_aci_json(Json) ->
     {ok, list_to_binary(string:join(DecodedContracts, "\n"))}.
 
 decode_contract(#{contract := #{name := Name,
+                                kind := Kind,
                                 payable := Payable,
                                 type_defs := Ts0,
                                 functions := Fs} = C}) ->
     MkTDef = fun(N, T) -> #{name => N, vars => [], typedef => T} end,
     Ts = [ MkTDef(<<"state">>, maps:get(state, C)) || maps:is_key(state, C) ] ++
          [ MkTDef(<<"event">>, maps:get(event, C)) || maps:is_key(event, C) ] ++ Ts0,
-    [payable(Payable), "contract ", io_lib:format("~s", [Name])," =\n",
+    [payable(Payable), case Kind of
+                           contract_main -> "main contract ";
+                           contract_child -> "contract ";
+                           contract_interface -> "contract interface "
+                       end,
+     io_lib:format("~s", [Name])," =\n",
      decode_tdefs(Ts), decode_funcs(Fs)];
 decode_contract(#{namespace := #{name := Name, type_defs := Ts}}) when Ts /= [] ->
     ["namespace ", io_lib:format("~s", [Name])," =\n",
@@ -324,10 +338,10 @@ payable(false) -> "".
 
 %% #contract{Ann, Con, [Declarations]}.
 
-contract_funcs({C, _, _, Decls}) when C == contract; C == namespace ->
+contract_funcs({C, _, _, Decls}) when ?IS_CONTRACT_HEAD(C); C == namespace ->
     [ D || D <- Decls, is_fun(D)].
 
-contract_types({C, _, _, Decls}) when C == contract; C == namespace ->
+contract_types({C, _, _, Decls}) when ?IS_CONTRACT_HEAD(C); C == namespace ->
     [ D || D <- Decls, is_type(D) ].
 
 is_fun({letfun, _, _, _, _, _}) -> true;

src/aeso_ast_to_fcode.erl

@@ -12,6 +12,8 @@
 -export([ast_to_fcode/2, format_fexpr/1]).
 -export_type([fcode/0, fexpr/0, fun_def/0]).
 
+-include("aeso_utils.hrl").
+
 %% -- Type definitions -------------------------------------------------------
 
 -type option() :: term().
@@ -36,7 +38,14 @@
               bits_intersection | bits_union | bits_difference |
               contract_to_address | address_to_contract | crypto_verify_sig | crypto_verify_sig_secp256k1 |
               crypto_sha3 | crypto_sha256 | crypto_blake2b |
-              crypto_ecverify_secp256k1 | crypto_ecrecover_secp256k1.
+              crypto_ecverify_secp256k1 | crypto_ecrecover_secp256k1 |
+              mcl_bls12_381_g1_neg | mcl_bls12_381_g1_norm | mcl_bls12_381_g1_valid |
+              mcl_bls12_381_g1_is_zero | mcl_bls12_381_g1_add | mcl_bls12_381_g1_mul |
+              mcl_bls12_381_g2_neg | mcl_bls12_381_g2_norm | mcl_bls12_381_g2_valid |
+              mcl_bls12_381_g2_is_zero | mcl_bls12_381_g2_add | mcl_bls12_381_g2_mul |
+              mcl_bls12_381_gt_inv | mcl_bls12_381_gt_add | mcl_bls12_381_gt_mul | mcl_bls12_381_gt_pow |
+              mcl_bls12_381_gt_is_one | mcl_bls12_381_pairing | mcl_bls12_381_miller_loop | mcl_bls12_381_final_exp |
+              mcl_bls12_381_int_to_fr | mcl_bls12_381_int_to_fp | mcl_bls12_381_fr_to_int | mcl_bls12_381_fp_to_int.
 
 -type flit() :: {int, integer()}
               | {string, binary()}
@@ -46,6 +55,7 @@
               | {oracle_pubkey, binary()}
               | {oracle_query_id, binary()}
               | {bool, false | true}
+              | {contract_code, string()} %% for CREATE, by name
               | {typerep, ftype()}.
 
 -type fexpr() :: {lit, flit()}
@@ -129,24 +139,27 @@
 -type type_env() :: #{ sophia_name() => type_def() }.
 -type fun_env()  :: #{ sophia_name() => {fun_name(), non_neg_integer()} }.
 -type con_env()  :: #{ sophia_name() => con_tag() }.
--type builtins() :: #{ sophia_name() => {builtin(), non_neg_integer() | none} }.
+-type child_con_env() :: #{sophia_name() => fcode()}.
+-type builtins() :: #{ sophia_name() => {builtin(), non_neg_integer() | none | variable} }.
 
--type context() :: {main_contract, string()}
+-type context() :: {contract_def, string()}
                  | {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(),
+                  child_con_env := child_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() }
+               }.
 
 -define(HASH_BYTES, 32).
 
@@ -154,33 +167,74 @@
 
 %% Main entrypoint. Takes typed syntax produced by aeso_ast_infer_types:infer/1,2
 %% and produces Fate intermediate code.
--spec ast_to_fcode(aeso_syntax:ast(), [option()]) -> fcode().
+-spec ast_to_fcode(aeso_syntax:ast(), [option()]) -> {env(), fcode()}.
 ast_to_fcode(Code, Options) ->
-    Verbose = lists:member(pp_fcode, Options),
     init_fresh_names(),
-    FCode1 = to_fcode(init_env(Options), Code),
+    {Env1, FCode1} = to_fcode(init_env(Options), Code),
+    FCode2 = optimize(FCode1, Options),
+    Env2 = Env1#{ child_con_env :=
+                      maps:map(
+                        fun (_, FC) -> optimize(FC, Options) end,
+                        maps:get(child_con_env, Env1)
+                       )},
+    clear_fresh_names(),
+    {Env2, FCode2}.
+
+optimize(FCode1, Options) ->
+    Verbose = lists:member(pp_fcode, Options),
     [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(),
     FCode3.
 
 %% -- Environment ------------------------------------------------------------
 
 -spec init_env([option()]) -> env().
 init_env(Options) ->
+    ChainTxArities = [3, 0, 0, 0, 0, 0, 1, 1, 1, 2, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 2, 0],
     #{ type_env  => init_type_env(),
        fun_env   => #{},
        builtins  => builtins(),
+       child_con_env => #{},
        con_env   => #{["None"]        => #con_tag{ tag = 0, arities = [0, 1] },
                       ["Some"]        => #con_tag{ tag = 1, arities = [0, 1] },
                       ["RelativeTTL"] => #con_tag{ tag = 0, arities = [1, 1] },
-                      ["FixedTTL"]    => #con_tag{ tag = 1, arities = [1, 1] }
+                      ["FixedTTL"]    => #con_tag{ tag = 1, arities = [1, 1] },
+                      ["AENS", "AccountPt"]  => #con_tag{ tag = 0, arities = [1, 1, 1, 1] },
+                      ["AENS", "OraclePt"]   => #con_tag{ tag = 1, arities = [1, 1, 1, 1] },
+                      ["AENS", "ContractPt"] => #con_tag{ tag = 2, arities = [1, 1, 1, 1] },
+                      ["AENS", "ChannelPt"]  => #con_tag{ tag = 3, arities = [1, 1, 1, 1] },
+                      ["AENS", "Name"]       => #con_tag{ tag = 0, arities = [3] },
+                      ["Chain", "GAMetaTx"]               => #con_tag{ tag = 0, arities = [2] },
+                      ["Chain", "PayingForTx"]            => #con_tag{ tag = 0, arities = [2] },
+                      ["Chain", "SpendTx"]                => #con_tag{ tag = 0, arities = ChainTxArities },
+                      ["Chain", "OracleRegisterTx"]       => #con_tag{ tag = 1, arities = ChainTxArities },
+                      ["Chain", "OracleQueryTx"]          => #con_tag{ tag = 2, arities = ChainTxArities },
+                      ["Chain", "OracleResponseTx"]       => #con_tag{ tag = 3, arities = ChainTxArities },
+                      ["Chain", "OracleExtendTx"]         => #con_tag{ tag = 4, arities = ChainTxArities },
+                      ["Chain", "NamePreclaimTx"]         => #con_tag{ tag = 5, arities = ChainTxArities },
+                      ["Chain", "NameClaimTx"]            => #con_tag{ tag = 6, arities = ChainTxArities },
+                      ["Chain", "NameUpdateTx"]           => #con_tag{ tag = 7, arities = ChainTxArities },
+                      ["Chain", "NameRevokeTx"]           => #con_tag{ tag = 8, arities = ChainTxArities },
+                      ["Chain", "NameTransferTx"]         => #con_tag{ tag = 9, arities = ChainTxArities },
+                      ["Chain", "ChannelCreateTx"]        => #con_tag{ tag = 10, arities = ChainTxArities },
+                      ["Chain", "ChannelDepositTx"]       => #con_tag{ tag = 11, arities = ChainTxArities },
+                      ["Chain", "ChannelWithdrawTx"]      => #con_tag{ tag = 12, arities = ChainTxArities },
+                      ["Chain", "ChannelForceProgressTx"] => #con_tag{ tag = 13, arities = ChainTxArities },
+                      ["Chain", "ChannelCloseMutualTx"]   => #con_tag{ tag = 14, arities = ChainTxArities },
+                      ["Chain", "ChannelCloseSoloTx"]     => #con_tag{ tag = 15, arities = ChainTxArities },
+                      ["Chain", "ChannelSlashTx"]         => #con_tag{ tag = 16, arities = ChainTxArities },
+                      ["Chain", "ChannelSettleTx"]        => #con_tag{ tag = 17, arities = ChainTxArities },
+                      ["Chain", "ChannelSnapshotSoloTx"]  => #con_tag{ tag = 18, arities = ChainTxArities },
+                      ["Chain", "ContractCreateTx"]       => #con_tag{ tag = 19, arities = ChainTxArities },
+                      ["Chain", "ContractCallTx"]         => #con_tag{ tag = 20, arities = ChainTxArities },
+                      ["Chain", "GAAttachTx"]             => #con_tag{ tag = 21, arities = ChainTxArities }
                      },
        options   => Options,
-       functions => #{} }.
+       functions => #{}
+    }.
 
 -spec builtins() -> builtins().
 builtins() ->
@@ -190,22 +244,29 @@ builtins() ->
     Scopes = [{[],           [{"abort", 1}, {"require", 2}]},
               {["Chain"],    [{"spend", 2}, {"balance", 1}, {"block_hash", 1}, {"coinbase", none},
                               {"timestamp", none}, {"block_height", none}, {"difficulty", none},
-                              {"gas_limit", none}]},
+                              {"gas_limit", none}, {"bytecode_hash", 1}, {"create", variable}, {"clone", variable}]},
               {["Contract"], [{"address", none}, {"balance", none}, {"creator", none}]},
-              {["Call"],     [{"origin", none}, {"caller", none}, {"value", none}, {"gas_price", none},
+              {["Call"],     [{"origin", none}, {"caller", none}, {"value", none}, {"gas_price", none}, {"fee", none},
                               {"gas_left", 0}]},
-              {["Oracle"],   [{"register", 4}, {"query_fee", 1}, {"query", 5}, {"get_question", 2},
+              {["Oracle"],   [{"register", 4}, {"expiry", 1}, {"query_fee", 1}, {"query", 5}, {"get_question", 2},
                               {"respond", 4}, {"extend", 3}, {"get_answer", 2},
                               {"check", 1}, {"check_query", 2}]},
               {["AENS"],     [{"resolve", 2}, {"preclaim", 3}, {"claim", 5}, {"transfer", 4},
-                              {"revoke", 3}]},
+                              {"revoke", 3}, {"update", 6}, {"lookup", 1}]},
               {["Map"],      [{"from_list", 1}, {"to_list", 1}, {"lookup", 2},
                               {"lookup_default", 3}, {"delete", 2}, {"member", 2}, {"size", 1}]},
               {["Crypto"],   [{"verify_sig", 3}, {"verify_sig_secp256k1", 3},
                               {"ecverify_secp256k1", 3}, {"ecrecover_secp256k1", 2},
                               {"sha3", 1}, {"sha256", 1}, {"blake2b", 1}]},
-              {["Auth"],     [{"tx_hash", none}]},
-              {["String"],   [{"length", 1}, {"concat", 2}, {"sha3", 1}, {"sha256", 1}, {"blake2b", 1}]},
+              {["MCL_BLS12_381"], [{"g1_neg", 1}, {"g1_norm", 1}, {"g1_valid", 1}, {"g1_is_zero", 1}, {"g1_add", 2}, {"g1_mul", 2},
+                                   {"g2_neg", 1}, {"g2_norm", 1}, {"g2_valid", 1}, {"g2_is_zero", 1}, {"g2_add", 2}, {"g2_mul", 2},
+                                   {"gt_inv", 1}, {"gt_add", 2}, {"gt_mul", 2}, {"gt_pow", 2}, {"gt_is_one", 1},
+                                   {"pairing", 2}, {"miller_loop", 2}, {"final_exp", 1},
+                                   {"int_to_fr", 1}, {"int_to_fp", 1}, {"fr_to_int", 1}, {"fp_to_int", 1}]},
+              {["StringInternal"], [{"length", 1}, {"concat", 2}, {"to_list", 1}, {"from_list", 1},
+                                    {"sha3", 1}, {"sha256", 1}, {"blake2b", 1}, {"to_lower", 1}, {"to_upper", 1}]},
+              {["Char"],     [{"to_int", 1}, {"from_int", 1}]},
+              {["Auth"],     [{"tx_hash", none}, {"tx", none}]},
               {["Bits"],     [{"set", 2}, {"clear", 2}, {"test", 2}, {"sum", 1}, {"intersection", 2},
                               {"union", 2}, {"difference", 2}, {"none", none}, {"all", none}]},
               {["Bytes"],    [{"to_int", 1}, {"to_str", 1}, {"concat", 2}, {"split", 1}]},
@@ -224,20 +285,32 @@ state_layout(Env) -> maps:get(state_layout, Env, {reg, 1}).
 
 -spec init_type_env() -> type_env().
 init_type_env() ->
-    #{ ["int"]          => ?type(integer),
-       ["bool"]         => ?type(boolean),
-       ["bits"]         => ?type(bits),
-       ["char"]         => ?type(integer),
-       ["string"]       => ?type(string),
-       ["address"]      => ?type(address),
-       ["hash"]         => ?type(hash),
-       ["signature"]    => ?type(signature),
-       ["oracle"]       => ?type(Q, R, {oracle, Q, R}),
-       ["oracle_query"] => ?type(_, _, oracle_query),
-       ["list"]         => ?type(T, {list, T}),
-       ["map"]          => ?type(K, V, {map, K, V}),
-       ["option"]       => ?type(T, {variant, [[], [T]]}),
-       ["Chain", "ttl"] => ?type({variant, [[integer], [integer]]})
+    BaseTx = {variant, [[address, integer, string], [], [], [], [], [], [string],
+                        [hash], [hash], [address, hash], [address],
+                        [address, integer], [address, integer], [address],
+                        [address], [address], [address], [address], [address],
+                        [integer], [address, integer], []]},
+    #{ ["int"]             => ?type(integer),
+       ["bool"]            => ?type(boolean),
+       ["bits"]            => ?type(bits),
+       ["char"]            => ?type(integer),
+       ["string"]          => ?type(string),
+       ["address"]         => ?type(address),
+       ["hash"]            => ?type(hash),
+       ["signature"]       => ?type(signature),
+       ["oracle"]          => ?type(Q, R, {oracle, Q, R}),
+       ["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]]}),
+       ["Chain", "ttl"]    => ?type({variant, [[integer], [integer]]}),
+       ["AENS", "pointee"] => ?type({variant, [[address], [address], [address], [address]]}),
+       ["AENS", "name"]    => ?type({variant, [[address, {variant, [[integer], [integer]]}, {map, string, {variant, [[address], [address], [address], [address]]}}]]}),
+       ["Chain", "ga_meta_tx"]    => ?type({variant, [[address, integer]]}),
+       ["Chain", "paying_for_tx"] => ?type({variant, [[address, integer]]}),
+       ["Chain", "base_tx"]       => ?type(BaseTx),
+       ["MCL_BLS12_381", "fr"]  => ?type({bytes, 32}),
+       ["MCL_BLS12_381", "fp"]  => ?type({bytes, 48})
      }.
 
 is_no_code(Env) ->
@@ -251,31 +324,45 @@ get_option(Opt, Env, Default) ->
 
 %% -- Compilation ------------------------------------------------------------
 
--spec to_fcode(env(), aeso_syntax:ast()) -> fcode().
-to_fcode(Env, [{contract, Attrs, MainCon = {con, _, Main}, Decls}]) ->
-    #{ builtins := Builtins } = Env,
-    MainEnv = Env#{ context  => {main_contract, Main},
-                    builtins => Builtins#{[Main, "state"]          => {get_state, none},
-                                          [Main, "put"]            => {set_state, 1},
-                                          [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),
-    #{ contract_name => Main,
-       state_type    => StateType,
-       state_layout  => StateLayout,
-       event_type    => EventType,
-       payable       => Payable,
-       functions     => add_init_function(Env1, MainCon, StateType,
-                        add_event_function(Env1, EventType, Funs)) };
-to_fcode(_Env, [NotContract]) ->
-    fcode_error({last_declaration_must_be_contract, NotContract});
-to_fcode(Env, [{contract, _, {con, _, Con}, Decls} | Code]) ->
-    Env1 = decls_to_fcode(Env#{ context => {abstract_contract, Con} }, Decls),
-    to_fcode(Env1, Code);
+-spec to_fcode(env(), aeso_syntax:ast()) -> {env(), fcode()}.
+to_fcode(Env, [{Contract, Attrs, Con = {con, _, Name}, Decls}|Rest])
+  when ?IS_CONTRACT_HEAD(Contract) ->
+    case Contract =:= contract_interface of
+        false ->
+            #{ builtins := Builtins } = Env,
+            ConEnv = maps:remove(state_layout,
+                     Env#{ context  => {contract_def, Name},
+                           builtins => Builtins#{[Name, "state"]          => {get_state, none},
+                                                 [Name, "put"]            => {set_state, 1},
+                                                 [Name, "Chain", "event"] => {chain_event, 1}} }),
+            #{ functions := PrevFuns } = ConEnv,
+            #{ functions := Funs } = Env1 =
+                decls_to_fcode(ConEnv, Decls),
+            StateType   = lookup_type(Env1, [Name, "state"], [], {tuple, []}),
+            EventType   = lookup_type(Env1, [Name, "event"], [], none),
+            StateLayout = state_layout(Env1),
+            Payable     = proplists:get_value(payable, Attrs, false),
+            ConFcode = #{ contract_name => Name,
+                          state_type    => StateType,
+                          state_layout  => StateLayout,
+                          event_type    => EventType,
+                          payable       => Payable,
+                          functions     => add_init_function(
+                                             Env1, Con, StateType,
+                                             add_event_function(Env1, EventType, Funs)) },
+            case Contract of
+                contract_main -> [] = Rest, {Env1, ConFcode};
+                contract_child ->
+                    Env2 = add_child_con(Env1, Name, ConFcode),
+                    Env3 = Env2#{ functions := PrevFuns },
+                    to_fcode(Env3, Rest)
+            end;
+        true ->
+            Env1 = decls_to_fcode(Env#{ context => {abstract_contract, Name} }, Decls),
+            to_fcode(Env1, Rest)
+    end;
+to_fcode(_Env, [NotMain = {NotMainHead, _ ,_ , _}]) when NotMainHead =/= contract_def ->
+    fcode_error({last_declaration_must_be_contract_def, NotMain});
 to_fcode(Env, [{namespace, _, {con, _, Con}, Decls} | Code]) ->
     Env1 = decls_to_fcode(Env#{ context => {namespace, Con} }, Decls),
     to_fcode(Env1, Code).
@@ -285,14 +372,11 @@ decls_to_fcode(Env, Decls) ->
     %% First compute mapping from Sophia names to fun_names and add it to the
     %% environment.
     Env1 = add_fun_env(Env, Decls),
-    lists:foldl(fun(D, E) ->
-                    R = decl_to_fcode(E, D),
-                    R
+    lists:foldl(fun(D, E) -> decl_to_fcode(E, D)
                 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, _}) ->
+decl_to_fcode(Env = #{context := {contract_def, _}}, {fun_decl, _, Id, _}) ->
     case is_no_code(Env) of
         false -> fcode_error({missing_definition, Id});
         true  -> Env
@@ -355,7 +439,7 @@ typedef_to_fcode(Env, Id = {id, _, Name}, Xs, Def) ->
     Env3 = compute_state_layout(Env2, Name, FDef),
     bind_type(Env3, Q, FDef).
 
-compute_state_layout(Env = #{ context := {main_contract, _} }, "state", Type) ->
+compute_state_layout(Env = #{ context := {contract_def, _} }, "state", Type) ->
     NoLayout = get_option(no_flatten_state, Env),
     Layout =
         case Type([]) of
@@ -381,7 +465,7 @@ compute_state_layout(R, [H | T]) ->
 compute_state_layout(R, _) ->
     {R + 1, {reg, R}}.
 
-check_state_and_event_types(#{ context := {main_contract, _} }, Id, [_ | _]) ->
+check_state_and_event_types(#{ context := {contract_def, _} }, Id, [_ | _]) ->
     case Id of
         {id, _, "state"} -> fcode_error({parameterized_state, Id});
         {id, _, "event"} -> fcode_error({parameterized_event, Id});
@@ -406,12 +490,18 @@ type_to_fcode(Env, Sub, {record_t, Fields}) ->
     type_to_fcode(Env, Sub, {tuple_t, [], lists:map(FieldType, Fields)});
 type_to_fcode(_Env, _Sub, {bytes_t, _, N}) ->
     {bytes, N};
+type_to_fcode(_Env, _Sub, {tvar, Ann, "void"}) ->
+    fcode_error({found_void, Ann});
 type_to_fcode(_Env, Sub, {tvar, _, X}) ->
     maps:get(X, Sub, {tvar, X});
+type_to_fcode(_Env, _Sub, {fun_t, Ann, _, var_args, _}) ->
+    fcode_error({var_args_not_set, {id, Ann, "a very suspicious function"}});
 type_to_fcode(Env, Sub, {fun_t, _, Named, Args, Res}) ->
     FNamed = [type_to_fcode(Env, Sub, Arg) || {named_arg_t, _, _, Arg, _} <- Named],
     FArgs  = [type_to_fcode(Env, Sub, Arg) || Arg <- Args],
     {function, FNamed ++ FArgs, type_to_fcode(Env, Sub, Res)};
+type_to_fcode(Env, Sub, {if_t, _, _, _, Else}) ->
+    type_to_fcode(Env, Sub, Else);  %% Hacky: this is only for remote calls, in which case we want the unprotected type
 type_to_fcode(_Env, _Sub, Type) ->
     error({todo, Type}).
 
@@ -621,14 +711,31 @@ expr_to_fcode(Env, _Type, {app, _Ann, {Op, _}, [A]}) when is_atom(Op) ->
     end;
 
 %% Function calls
-expr_to_fcode(Env, _Type, {app, _, Fun = {typed, _, _, {fun_t, _, NamedArgsT, _, _}}, Args}) ->
+expr_to_fcode(Env, Type, {app, _, Fun = {typed, _, FunE, {fun_t, _, NamedArgsT, ArgsT, _}}, Args}) ->
     Args1 = get_named_args(NamedArgsT, Args),
     FArgs = [expr_to_fcode(Env, Arg) || Arg <- Args1],
     case expr_to_fcode(Env, Fun) of
         {builtin_u, B, _Ar, TypeArgs}     -> builtin_to_fcode(state_layout(Env), B, FArgs ++ TypeArgs);
+        {builtin_u, chain_clone, _Ar}     ->
+            case ArgsT of
+                var_args -> fcode_error({var_args_not_set, FunE});
+                _ ->
+                    %% Here we little cheat on the typechecker, but this inconsistency
+                    %% is to be solved in `aeso_fcode_to_fate:type_to_scode/1`
+                    FInitArgsT = aeb_fate_data:make_typerep([type_to_fcode(Env, T) || T <- ArgsT]),
+                    builtin_to_fcode(state_layout(Env), chain_clone, [{lit, FInitArgsT}|FArgs])
+            end;
+        {builtin_u, chain_create, _Ar}     ->
+            case {ArgsT, Type} of
+                {var_args, _} -> fcode_error({var_args_not_set, FunE});
+                {_, {con, _, Contract}} ->
+                    FInitArgsT = aeb_fate_data:make_typerep([type_to_fcode(Env, T) || T <- ArgsT]),
+                    builtin_to_fcode(state_layout(Env), chain_create, [{lit, {contract_code, Contract}}, {lit, FInitArgsT}|FArgs]);
+                {_, _} -> fcode_error({not_a_contract_type, Type})
+            end;
         {builtin_u, B, _Ar}               -> builtin_to_fcode(state_layout(Env), B, FArgs);
         {def_u, F, _Ar}                   -> {def, F, FArgs};
-        {remote_u, ArgsT, RetT, Ct, RFun} -> {remote, ArgsT, RetT, Ct, RFun, FArgs};
+        {remote_u, RArgsT, RRetT, Ct, RFun} -> {remote, RArgsT, RRetT, Ct, RFun, FArgs};
         FFun ->
             %% FFun is a closure, with first component the function name and
             %% second component the environment
@@ -986,12 +1093,21 @@ stmts_to_fcode(Env, [Expr | Stmts]) ->
 
 op_builtins() ->
     [map_from_list, map_to_list, map_delete, map_member, map_size,
-     string_length, string_concat, string_sha3, string_sha256, string_blake2b,
+     stringinternal_length, stringinternal_concat, stringinternal_to_list, stringinternal_from_list,
+     stringinternal_sha3, stringinternal_sha256, stringinternal_blake2b,
+     char_to_int, char_from_int, stringinternal_to_lower, stringinternal_to_upper,
      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
+     crypto_ecverify_secp256k1, crypto_ecrecover_secp256k1,
+     mcl_bls12_381_g1_neg, mcl_bls12_381_g1_norm, mcl_bls12_381_g1_valid,
+     mcl_bls12_381_g1_is_zero, mcl_bls12_381_g1_add, mcl_bls12_381_g1_mul,
+     mcl_bls12_381_g2_neg, mcl_bls12_381_g2_norm, mcl_bls12_381_g2_valid,
+     mcl_bls12_381_g2_is_zero, mcl_bls12_381_g2_add, mcl_bls12_381_g2_mul,
+     mcl_bls12_381_gt_inv, mcl_bls12_381_gt_add, mcl_bls12_381_gt_mul, mcl_bls12_381_gt_pow,
+     mcl_bls12_381_gt_is_one, mcl_bls12_381_pairing, mcl_bls12_381_miller_loop, mcl_bls12_381_final_exp,
+     mcl_bls12_381_int_to_fr, mcl_bls12_381_int_to_fp, mcl_bls12_381_fr_to_int, mcl_bls12_381_fp_to_int
     ].
 
 set_state({reg, R}, Val) ->
@@ -1152,8 +1268,8 @@ lambda_lift_expr(Layout, UExpr) when element(1, UExpr) == def_u; element(1, UExp
 lambda_lift_expr(Layout, {remote_u, ArgsT, RetT, Ct, F}) ->
     FVs  = free_vars(Ct),
     Ct1  = lambda_lift_expr(Layout, Ct),
-    GasAndValueArgs = 2,
-    Xs   = [ lists:concat(["arg", I]) || I <- lists:seq(1, length(ArgsT) + GasAndValueArgs) ],
+    NamedArgCount = 3,
+    Xs   = [ lists:concat(["arg", I]) || I <- lists:seq(1, length(ArgsT) + NamedArgCount) ],
     Args = [{var, X} || X <- Xs],
     make_closure(FVs, Xs, {remote, ArgsT, RetT, Ct1, F, Args});
 lambda_lift_expr(Layout, Expr) ->
@@ -1548,6 +1664,10 @@ bind_constructors(Env = #{ con_env := ConEnv }, NewCons) ->
 
 %% -- Names --
 
+-spec add_child_con(env(), sophia_name(), fcode()) -> env().
+add_child_con(Env = #{child_con_env := CEnv}, Name, Fcode) ->
+    Env#{ child_con_env := CEnv#{Name => Fcode} }.
+
 -spec add_fun_env(env(), [aeso_syntax:decl()]) -> env().
 add_fun_env(Env = #{ context := {abstract_contract, _} }, _) -> Env;  %% no functions from abstract contracts
 add_fun_env(Env = #{ fun_env := FunEnv }, Decls) ->
@@ -1562,7 +1682,7 @@ add_fun_env(Env = #{ fun_env := FunEnv }, Decls) ->
 make_fun_name(#{ context := Context }, Ann, Name) ->
     Entrypoint = proplists:get_value(entrypoint, Ann, false),
     case Context of
-        {main_contract, Main} ->
+        {contract_def, Main} ->
             if Entrypoint     -> {entrypoint, list_to_binary(Name)};
                true           -> {local_fun, [Main, Name]}
             end;
@@ -1574,7 +1694,7 @@ make_fun_name(#{ context := Context }, Ann, Name) ->
 current_namespace(#{ context := Cxt }) ->
     case Cxt of
         {abstract_contract, Con} -> Con;
-        {main_contract, Con}     -> Con;
+        {contract_def, Con}     -> Con;
         {namespace, NS}          -> NS
     end.
 
@@ -1921,8 +2041,11 @@ internal_error(Error) ->
 %% -- Pretty printing --------------------------------------------------------
 
 format_fcode(#{ functions := Funs }) ->
-    prettypr:format(pp_above(
-        [ pp_fun(Name, Def) || {Name, Def} <- maps:to_list(Funs) ])).
+    prettypr:format(format_funs(Funs)).
+
+format_funs(Funs) ->
+    pp_above(
+      [ pp_fun(Name, Def) || {Name, Def} <- maps:to_list(Funs) ]).
 
 format_fexpr(E) ->
     prettypr:format(pp_fexpr(E)).
@@ -2039,7 +2162,9 @@ 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_fexpr({switch, Split}) -> pp_split(Split);
+pp_fexpr({contract_code, Contract}) ->
+    pp_beside(pp_text("contract "), pp_text(Contract)).
 
 pp_call(Fun, Args) ->
     pp_beside(Fun, pp_fexpr({tuple, Args})).

src/aeso_ast_to_icode.erl

@@ -14,12 +14,13 @@
 
 -include_lib("aebytecode/include/aeb_opcodes.hrl").
 -include("aeso_icode.hrl").
+-include("aeso_utils.hrl").
 
 -spec convert_typed(aeso_syntax:ast(), list()) -> aeso_icode:icode().
 convert_typed(TypedTree, Options) ->
     {Payable, Name} =
         case lists:last(TypedTree) of
-            {contract, Attrs, {con, _, Con}, _} ->
+            {Contr, Attrs, {con, _, Con}, _} when ?IS_CONTRACT_HEAD(Contr) ->
                 {proplists:get_value(payable, Attrs, false), Con};
             Decl ->
                 gen_error({last_declaration_must_be_contract, Decl})
@@ -29,7 +30,8 @@ convert_typed(TypedTree, Options) ->
     Icode    = code(TypedTree, NewIcode, Options),
     deadcode_elimination(Icode).
 
-code([{contract, _Attribs, Con, Code}|Rest], Icode, Options) ->
+code([{Contract, _Attribs, Con, Code}|Rest], Icode, Options)
+  when ?IS_CONTRACT_HEAD(Contract) ->
     NewIcode = contract_to_icode(Code, aeso_icode:set_namespace(Con, Icode)),
     code(Rest, NewIcode, Options);
 code([{namespace, _Ann, Name, Code}|Rest], Icode, Options) ->
@@ -469,6 +471,7 @@ is_builtin_fun({qid, _, ["AENS", "preclaim"]}, _Icode)                       ->
 is_builtin_fun({qid, _, ["AENS", "claim"]}, _Icode)                          -> true;
 is_builtin_fun({qid, _, ["AENS", "transfer"]}, _Icode)                       -> true;
 is_builtin_fun({qid, _, ["AENS", "revoke"]}, _Icode)                         -> true;
+is_builtin_fun({qid, _, ["AENS", "update"]}, _Icode)                         -> true;
 is_builtin_fun({qid, _, ["Map", "lookup"]}, _Icode)                          -> true;
 is_builtin_fun({qid, _, ["Map", "lookup_default"]}, _Icode)                  -> true;
 is_builtin_fun({qid, _, ["Map", "member"]}, _Icode)                          -> true;
@@ -624,6 +627,12 @@ builtin_code(_, {qid, _, ["AENS", "revoke"]}, Args, _, _, Icode) ->
               [ast_body(Addr, Icode), ast_body(Name, Icode), ast_body(Sign, Icode)],
               [word, word, sign_t()], {tuple, []});
 
+builtin_code(_, {qid, _, ["AENS", "update"]}, Args, _, _, Icode) ->
+    {Sign, [Addr, Name, TTL, ClientTTL, Pointers]} = get_signature_arg(Args),
+    prim_call(?PRIM_CALL_AENS_UPDATE, #integer{value = 0},
+              [ast_body(Addr, Icode), ast_body(Name, Icode), ast_body(TTL, Icode), ast_body(ClientTTL, Icode), ast_body(Pointers, Icode), ast_body(Sign, Icode)],
+              [word, string, word, word, word, sign_t()], {tuple, []});
+
 %% -- Maps
 %% -- lookup functions
 builtin_code(_, {qid, _, ["Map", "lookup"]}, [Key, Map], _, _, Icode) ->
@@ -927,11 +936,16 @@ ast_typerep1({variant_t, Cons}, Icode) ->
     {variant, [ begin
                   {constr_t, _, _, Args} = Con,
                   [ ast_typerep1(Arg, Icode) || Arg <- Args ]
-                end || Con <- Cons ]}.
+                end || Con <- Cons ]};
+ast_typerep1({if_t, _, _, _, Else}, Icode) ->
+    ast_typerep1(Else, Icode). %% protected remote calls are not in AEVM
 
 ttl_t(Icode) ->
     ast_typerep({qid, [], ["Chain", "ttl"]}, Icode).
 
+%% pointee_t(Icode) ->
+%%     ast_typerep({qid, [], ["AENS", "pointee"]}, Icode).
+
 sign_t() -> bytes_t(64).
 bytes_t(Len) when Len =< 32 -> word;
 bytes_t(Len)                -> {tuple, lists:duplicate((31 + Len) div 32, word)}.

src/aeso_code_errors.erl

@@ -10,9 +10,9 @@
 
 -export([format/1, pos/1]).
 
-format({last_declaration_must_be_contract, Decl = {namespace, _, {con, _, C}, _}}) ->
-    Msg = io_lib:format("Expected a contract as the last declaration instead of the namespace '~s'\n",
-                        [C]),
+format({last_declaration_must_be_main_contract, Decl = {Kind, _, {con, _, C}, _}}) ->
+    Msg = io_lib:format("Expected a main contract as the last declaration instead of the ~p '~s'\n",
+                        [Kind, C]),
     mk_err(pos(Decl), Msg);
 format({missing_init_function, Con}) ->
     Msg = io_lib:format("Missing init function for the contract '~s'.\n", [pp_expr(Con)]),
@@ -87,6 +87,12 @@ format({higher_order_state, {type_def, Ann, _, _, State}}) ->
     Msg = io_lib:format("Invalid state type\n~s\n", [pp_type(2, State)]),
     Cxt = "The state cannot contain functions in the AEVM. Use FATE if you need this.\n",
     mk_err(pos(Ann), Msg, Cxt);
+format({var_args_not_set, Expr}) ->
+    mk_err( pos(Expr), "Could not deduce type of variable arguments list"
+          , "When compiling " ++ pp_expr(Expr)
+          );
+format({found_void, Ann}) ->
+    mk_err(pos(Ann), "Found a void-typed value.", "`void` is a restricted, uninhabited type. Did you mean `unit`?");
 
 format(Err) ->
     mk_err(aeso_errors:pos(0, 0), io_lib:format("Unknown error: ~p\n", [Err])).

src/aeso_compiler.erl

@@ -28,6 +28,7 @@
 
 -include_lib("aebytecode/include/aeb_opcodes.hrl").
 -include("aeso_icode.hrl").
+-include("aeso_utils.hrl").
 
 
 -type option() :: pp_sophia_code
@@ -38,10 +39,13 @@
                 | pp_assembler
                 | pp_bytecode
                 | no_code
+                | keep_included
+                | debug_mode
                 | {backend, aevm | fate}
                 | {include, {file_system, [string()]} |
                             {explicit_files, #{string() => binary()}}}
-                | {src_file, string()}.
+                | {src_file, string()}
+                | {aci, aeso_aci:aci_type()}.
 -type options() :: [option()].
 
 -export_type([ option/0
@@ -115,7 +119,8 @@ from_string(Backend, ContractString, Options) ->
     end.
 
 from_string1(aevm, ContractString, Options) ->
-    #{icode := Icode} = string_to_code(ContractString, Options),
+    #{ icode := Icode
+     , folded_typed_ast := FoldedTypedAst } = string_to_code(ContractString, Options),
     TypeInfo  = extract_type_info(Icode),
     Assembler = assemble(Icode, Options),
     pp_assembler(aevm, Assembler, Options),
@@ -123,47 +128,65 @@ from_string1(aevm, ContractString, Options) ->
     ByteCode = << << B:8 >> || B <- ByteCodeList >>,
     pp_bytecode(ByteCode, Options),
     {ok, Version} = version(),
-    {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)
-          }};
+    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)};
 from_string1(fate, ContractString, Options) ->
-    #{fcode := FCode} = string_to_code(ContractString, Options),
-    FateCode = aeso_fcode_to_fate:compile(FCode, Options),
+    #{ fcode := FCode
+     , fcode_env := #{child_con_env := ChildContracts}
+     , folded_typed_ast := FoldedTypedAst } = string_to_code(ContractString, Options),
+    FateCode = aeso_fcode_to_fate:compile(ChildContracts, FCode, Options),
     pp_assembler(fate, FateCode, Options),
     ByteCode = aeb_fate_code:serialize(FateCode, []),
     {ok, Version} = version(),
-    {ok, #{byte_code => ByteCode,
-           compiler_version => Version,
-           contract_source => ContractString,
-           type_info => [],
-           fate_code => FateCode,
-           abi_version => aeb_fate_abi:abi_version(),
-           payable => maps:get(payable, FCode)
-          }}.
+    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.
 
 -spec string_to_code(string(), options()) -> map().
 string_to_code(ContractString, Options) ->
     Ast = parse(ContractString, Options),
     pp_sophia_code(Ast, Options),
     pp_ast(Ast, Options),
-    {TypeEnv, TypedAst} = aeso_ast_infer_types:infer(Ast, [return_env | Options]),
-    pp_typed_ast(TypedAst, Options),
+    {TypeEnv, FoldedTypedAst, UnfoldedTypedAst} = aeso_ast_infer_types:infer(Ast, [return_env | Options]),
+    pp_typed_ast(UnfoldedTypedAst, Options),
     case proplists:get_value(backend, Options, aevm) of
         aevm ->
-            Icode = ast_to_icode(TypedAst, Options),
+            Icode = ast_to_icode(UnfoldedTypedAst, Options),
             pp_icode(Icode, Options),
-            #{ icode => Icode,
-               typed_ast => TypedAst,
-               type_env  => TypeEnv};
+            #{ icode => Icode
+             , unfolded_typed_ast => UnfoldedTypedAst
+             , folded_typed_ast => FoldedTypedAst
+             , type_env  => TypeEnv
+             , ast => Ast };
         fate ->
-            Fcode = aeso_ast_to_fcode:ast_to_fcode(TypedAst, Options),
-            #{ fcode => Fcode,
-               typed_ast => TypedAst,
-               type_env  => TypeEnv}
+            {Env, Fcode} = aeso_ast_to_fcode:ast_to_fcode(UnfoldedTypedAst, [{original_src, ContractString}|Options]),
+            #{ fcode => Fcode
+             , fcode_env => Env
+             , unfolded_typed_ast => UnfoldedTypedAst
+             , folded_typed_ast => FoldedTypedAst
+             , type_env  => TypeEnv
+             , ast => Ast }
     end.
 
 -define(CALL_NAME,   "__call").
@@ -198,9 +221,9 @@ check_call1(ContractString0, FunName, Args, Options) ->
         case proplists:get_value(backend, Options, aevm) of
             aevm ->
                 %% First check the contract without the __call function
-                #{} = string_to_code(ContractString0, Options),
-                ContractString = insert_call_function(ContractString0, ?CALL_NAME, FunName, Args, Options),
-                #{typed_ast := TypedAst,
+                #{ast := Ast} = string_to_code(ContractString0, Options),
+                ContractString = insert_call_function(Ast, ContractString0, ?CALL_NAME, FunName, Args),
+                #{unfolded_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 ],
@@ -220,13 +243,15 @@ check_call1(ContractString0, FunName, Args, Options) ->
                 {ok, FunName, {ArgVMTypes, RetVMType1}, ArgTerms};
             fate ->
                 %% First check the contract without the __call function
-                #{fcode := OrgFcode} = string_to_code(ContractString0, Options),
-                FateCode = aeso_fcode_to_fate:compile(OrgFcode, []),
+                #{ fcode := OrgFcode
+                 , fcode_env := #{child_con_env := ChildContracts}
+                 , ast := Ast } = string_to_code(ContractString0, Options),
+                FateCode = aeso_fcode_to_fate:compile(ChildContracts, 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(ContractString0, CallName, FunName, Args, Options),
+                ContractString = insert_call_function(Ast, ContractString0, CallName, FunName, Args),
                 #{fcode := Fcode} = string_to_code(ContractString, Options),
                 CallArgs = arguments_of_body(CallName, FunName, Fcode),
                 {ok, FunName, CallArgs}
@@ -252,9 +277,8 @@ first_none_match(CallName, Hashes, [Char|Chars]) ->
     end.
 
 %% Add the __call function to a contract.
--spec insert_call_function(string(), string(), string(), [string()], options()) -> string().
-insert_call_function(Code, Call, FunName, Args, Options) ->
-    Ast = parse(Code, Options),
+-spec insert_call_function(aeso_syntax:ast(), string(), string(), string(), [string()]) -> string().
+insert_call_function(Ast, Code, Call, FunName, Args) ->
     Ind = last_contract_indent(Ast),
     lists:flatten(
         [ Code,
@@ -310,7 +334,7 @@ to_sophia_value(ContractString, FunName, ok, Data, Options0) ->
     Options = [no_code | Options0],
     try
         Code = string_to_code(ContractString, Options),
-        #{ typed_ast := TypedAst, type_env  := TypeEnv} = Code,
+        #{ unfolded_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]),
 
@@ -336,12 +360,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(Type)),
+                        Type1 = prettypr:format(aeso_pretty:type(Type0)),
                         Msg = io_lib:format("Cannot translate FATE value ~p\n  of Sophia type ~s\n",
                                             [aeb_fate_encoding:deserialize(Data), Type1]),
                         {error, [aeso_errors:new(data_error, Msg)]};
                       _:_ ->
-                        Type1 = prettypr:format(aeso_pretty:type(Type)),
+                        Type1 = prettypr:format(aeso_pretty:type(Type0)),
                         Msg = io_lib:format("Failed to decode binary as type ~s\n", [Type1]),
                         {error, [aeso_errors:new(data_error, Msg)]}
                end
@@ -386,7 +410,7 @@ decode_calldata(ContractString, FunName, Calldata, Options0) ->
     Options = [no_code | Options0],
     try
         Code = string_to_code(ContractString, Options),
-        #{ typed_ast := TypedAst, type_env  := TypeEnv} = Code,
+        #{ unfolded_typed_ast := TypedAst, type_env  := TypeEnv} = Code,
 
         {ok, Args, _} = get_decode_type(FunName, TypedAst),
         GetType       = fun({typed, _, _, T}) -> T; (T) -> T end,
@@ -448,7 +472,7 @@ error_missing_call_function() ->
     Msg = "Internal error: missing '__call'-function",
     aeso_errors:throw(aeso_errors:new(internal_error, Msg)).
 
-get_call_type([{contract, _, _, Defs}]) ->
+get_call_type([{Contract, _, _, Defs}]) when ?IS_CONTRACT_HEAD(Contract) ->
     case [ {lists:last(QFunName), FunType}
           || {letfun, _, {id, _, ?CALL_NAME}, [], _Ret,
                 {typed, _,
@@ -462,7 +486,7 @@ get_call_type([_ | Contracts]) ->
     get_call_type(Contracts).
 
 -dialyzer({nowarn_function, get_decode_type/2}).
-get_decode_type(FunName, [{contract, Ann, _, Defs}]) ->
+get_decode_type(FunName, [{Contract, Ann, _, Defs}]) when ?IS_CONTRACT_HEAD(Contract) ->
     GetType = fun({letfun, _, {id, _, Name}, Args, Ret, _})               when Name == FunName -> [{Args, Ret}];
                  ({fun_decl, _, {id, _, Name}, {fun_t, _, _, Args, Ret}}) when Name == FunName -> [{Args, Ret}];
                  (_) -> [] end,
@@ -650,8 +674,9 @@ 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) ->
-    {ok, Ast} = aeso_parser:type(String),
+    Ast = aeso_parser:run_parser(aeso_parser:type(), String),
     try aeso_ast_to_icode:ast_typerep(Ast) of
         Type -> {ok, Type}
     catch _:_ -> {error, bad_type}

src/aeso_fcode_to_fate.erl

@@ -9,7 +9,7 @@
 %%%-------------------------------------------------------------------
 -module(aeso_fcode_to_fate).
 
--export([compile/2, term_to_fate/1]).
+-export([compile/2, compile/3, term_to_fate/1, term_to_fate/2]).
 
 -ifdef(TEST).
 -export([optimize_fun/4, to_basic_blocks/1]).
@@ -45,7 +45,7 @@
 -define(s(N), {store, N}).
 -define(void, {var, 9999}).
 
--record(env, { contract, vars = [], locals = [], current_function, tailpos = true }).
+-record(env, { contract, vars = [], locals = [], current_function, tailpos = true, child_contracts = #{}, options = []}).
 
 %% -- Debugging --------------------------------------------------------------
 
@@ -70,9 +70,11 @@ code_error(Err) ->
 
 %% @doc Main entry point.
 compile(FCode, Options) ->
+    compile(#{}, FCode, Options).
+compile(ChildContracts, FCode, Options) ->
     #{ contract_name := ContractName,
        functions     := Functions } = FCode,
-    SFuns  = functions_to_scode(ContractName, Functions, Options),
+    SFuns  = functions_to_scode(ChildContracts, ContractName, Functions, Options),
     SFuns1 = optimize_scode(SFuns, Options),
     FateCode = to_basic_blocks(SFuns1),
     ?debug(compile, Options, "~s\n", [aeb_fate_asm:pp(FateCode)]),
@@ -85,19 +87,20 @@ make_function_name(event)              -> <<"Chain.event">>;
 make_function_name({entrypoint, Name}) -> Name;
 make_function_name({local_fun, Xs})    -> list_to_binary("." ++ string:join(Xs, ".")).
 
-functions_to_scode(ContractName, Functions, Options) ->
+functions_to_scode(ChildContracts, ContractName, Functions, Options) ->
     FunNames = maps:keys(Functions),
     maps:from_list(
-        [ {make_function_name(Name), function_to_scode(ContractName, FunNames, Name, Attrs, Args, Body, Type, Options)}
+        [ {make_function_name(Name), function_to_scode(ChildContracts, ContractName, FunNames, Name, Attrs, Args, Body, Type, Options)}
         || {Name, #{args   := Args,
                     body   := Body,
                     attrs  := Attrs,
                     return := Type}} <- maps:to_list(Functions)]).
 
-function_to_scode(ContractName, Functions, Name, Attrs0, Args, Body, ResType, _Options) ->
+function_to_scode(ChildContracts, ContractName, Functions, Name, Attrs0, Args, Body, ResType, Options) ->
     {ArgTypes, ResType1} = typesig_to_scode(Args, ResType),
     Attrs = Attrs0 -- [stateful], %% Only track private and payable from here.
-    SCode = to_scode(init_env(ContractName, Functions, Name, Args), Body),
+    Env = init_env(ChildContracts, ContractName, Functions, Name, Args, Options),
+    SCode = to_scode(Env, Body),
     {Attrs, {ArgTypes, ResType1}, SCode}.
 
 -define(tvars, '$tvars').
@@ -133,7 +136,9 @@ type_to_scode({tvar, X}) ->
             put(?tvars, {I + 1, Vars#{ X => I }}),
             {tvar, I};
         J -> {tvar, J}
-    end.
+    end;
+type_to_scode(L) when is_list(L) -> {tuple, types_to_scode(L)}.
+
 
 types_to_scode(Ts) -> lists:map(fun type_to_scode/1, Ts).
 
@@ -142,11 +147,13 @@ types_to_scode(Ts) -> lists:map(fun type_to_scode/1, Ts).
 
 %% -- Environment functions --
 
-init_env(ContractName, FunNames, Name, Args) ->
+init_env(ChildContracts, ContractName, FunNames, Name, Args, Options) ->
     #env{ vars      = [ {X, {arg, I}} || {I, {X, _}} <- with_ixs(Args) ],
           contract  = ContractName,
+          child_contracts = ChildContracts,
           locals    = FunNames,
           current_function = Name,
+          options = Options,
           tailpos   = true }.
 
 next_var(#env{ vars = Vars }) ->
@@ -169,7 +176,7 @@ lookup_var(#env{vars = Vars}, X) ->
 
 %% -- The compiler --
 
-lit_to_fate(L) ->
+lit_to_fate(Env, L) ->
     case L of
         {int, N}             -> aeb_fate_data:make_integer(N);
         {string, S}          -> aeb_fate_data:make_string(S);
@@ -179,63 +186,80 @@ lit_to_fate(L) ->
         {contract_pubkey, K} -> aeb_fate_data:make_contract(K);
         {oracle_pubkey, K}   -> aeb_fate_data:make_oracle(K);
         {oracle_query_id, H} -> aeb_fate_data:make_oracle_query(H);
+        {contract_code, C}   ->
+            Options = Env#env.options,
+            FCode    = maps:get(C, Env#env.child_contracts),
+            FateCode = compile(Env#env.child_contracts, FCode, Options),
+            ByteCode = aeb_fate_code:serialize(FateCode, []),
+            {ok, Version} = aeso_compiler:version(),
+            OriginalSourceCode = proplists:get_value(original_src, Options, ""),
+            Code = #{byte_code => ByteCode,
+                     compiler_version => Version,
+                     source_hash => crypto:hash(sha256, OriginalSourceCode ++ [0] ++ C),
+                     type_info => [],
+                     abi_version => aeb_fate_abi:abi_version(),
+                     payable => maps:get(payable, FCode)
+                   },
+            Serialized = aeser_contract_code:serialize(Code),
+            aeb_fate_data:make_contract_bytearray(Serialized);
         {typerep, T}         -> aeb_fate_data:make_typerep(type_to_scode(T))
      end.
 
-term_to_fate(E) -> term_to_fate(#{}, E).
+term_to_fate(E) -> term_to_fate(#env{}, #{}, E).
+term_to_fate(GlobEnv, E) -> term_to_fate(GlobEnv, #{}, E).
 
-term_to_fate(_Env, {lit, L}) ->
-    lit_to_fate(L);
+term_to_fate(GlobEnv, _Env, {lit, L}) ->
+    lit_to_fate(GlobEnv, L);
 %% negative literals are parsed as 0 - N
-term_to_fate(_Env, {op, '-', [{lit, {int, 0}}, {lit, {int, N}}]}) ->
+term_to_fate(_GlobEnv, _Env, {op, '-', [{lit, {int, 0}}, {lit, {int, N}}]}) ->
     aeb_fate_data:make_integer(-N);
-term_to_fate(_Env, nil) ->
+term_to_fate(_GlobEnv, _Env, nil) ->
     aeb_fate_data:make_list([]);
-term_to_fate(Env, {op, '::', [Hd, Tl]}) ->
+term_to_fate(GlobEnv, Env, {op, '::', [Hd, Tl]}) ->
     %% The Tl will translate into a list, because FATE lists are just lists
-    [term_to_fate(Env, Hd) | term_to_fate(Env, Tl)];
-term_to_fate(Env, {tuple, As}) ->
-    aeb_fate_data:make_tuple(list_to_tuple([ term_to_fate(Env, A) || A<-As]));
-term_to_fate(Env, {con, Ar, I, As}) ->
-    FateAs = [ term_to_fate(Env, A) || A <- As ],
+    [term_to_fate(GlobEnv, Env, Hd) | term_to_fate(GlobEnv, Env, Tl)];
+term_to_fate(GlobEnv, Env, {tuple, As}) ->
+    aeb_fate_data:make_tuple(list_to_tuple([ term_to_fate(GlobEnv, Env, A) || A<-As]));
+term_to_fate(GlobEnv, Env, {con, Ar, I, As}) ->
+    FateAs = [ term_to_fate(GlobEnv, Env, A) || A <- As ],
     aeb_fate_data:make_variant(Ar, I, list_to_tuple(FateAs));
-term_to_fate(_Env, {builtin, bits_all, []}) ->
+term_to_fate(_GlobEnv, _Env, {builtin, bits_all, []}) ->
     aeb_fate_data:make_bits(-1);
-term_to_fate(_Env, {builtin, bits_none, []}) ->
+term_to_fate(_GlobEnv, _Env, {builtin, bits_none, []}) ->
     aeb_fate_data:make_bits(0);
-term_to_fate(_Env, {op, bits_set, [B, I]}) ->
-    {bits, N} = term_to_fate(B),
-    J         = term_to_fate(I),
+term_to_fate(GlobEnv, _Env, {op, bits_set, [B, I]}) ->
+    {bits, N} = term_to_fate(GlobEnv, B),
+    J         = term_to_fate(GlobEnv, I),
     {bits, N bor (1 bsl J)};
-term_to_fate(_Env, {op, bits_clear, [B, I]}) ->
-    {bits, N} = term_to_fate(B),
-    J         = term_to_fate(I),
+term_to_fate(GlobEnv, _Env, {op, bits_clear, [B, I]}) ->
+    {bits, N} = term_to_fate(GlobEnv, B),
+    J         = term_to_fate(GlobEnv, I),
     {bits, N band bnot (1 bsl J)};
-term_to_fate(Env, {'let', X, E, Body}) ->
-    Env1 = Env#{ X => term_to_fate(Env, E) },
-    term_to_fate(Env1, Body);
-term_to_fate(Env, {var, X}) ->
+term_to_fate(GlobEnv, Env, {'let', X, E, Body}) ->
+    Env1 = Env#{ X => term_to_fate(GlobEnv, Env, E) },
+    term_to_fate(GlobEnv, Env1, Body);
+term_to_fate(_GlobEnv, Env, {var, X}) ->
     case maps:get(X, Env, undefined) of
         undefined -> throw(not_a_fate_value);
         V         -> V
     end;
-term_to_fate(_Env, {builtin, map_empty, []}) ->
+term_to_fate(_GlobEnv, _Env, {builtin, map_empty, []}) ->
     aeb_fate_data:make_map(#{});
-term_to_fate(Env, {op, map_set, [M, K, V]}) ->
-    Map = term_to_fate(Env, M),
-    Map#{term_to_fate(Env, K) => term_to_fate(Env, V)};
-term_to_fate(_Env, _) ->
+term_to_fate(GlobEnv, Env, {op, map_set, [M, K, V]}) ->
+    Map = term_to_fate(GlobEnv, Env, M),
+    Map#{term_to_fate(GlobEnv, Env, K) => term_to_fate(GlobEnv, Env, V)};
+term_to_fate(_GlobEnv, _Env, _) ->
     throw(not_a_fate_value).
 
 to_scode(Env, T) ->
-    try term_to_fate(T) of
+    try term_to_fate(Env, T) of
         V -> [push(?i(V))]
     catch throw:not_a_fate_value ->
         to_scode1(Env, T)
     end.
 
-to_scode1(_Env, {lit, L}) ->
-    [push(?i(lit_to_fate(L)))];
+to_scode1(Env, {lit, L}) ->
+    [push(?i(lit_to_fate(Env, L)))];
 
 to_scode1(_Env, nil) ->
     [aeb_fate_ops:nil(?a)];
@@ -302,18 +326,27 @@ to_scode1(Env, {funcall, Fun, Args}) ->
 to_scode1(Env, {builtin, B, Args}) ->
     builtin_to_scode(Env, B, Args);
 
-to_scode1(Env, {remote, ArgsT, RetT, Ct, Fun, [Gas, Value | Args]}) ->
+to_scode1(Env, {remote, ArgsT, RetT, Ct, Fun, [Gas, Value, Protected | Args]}) ->
     Lbl = make_function_id(Fun),
     {ArgTypes, RetType0} = typesig_to_scode([{"_", T} || T <- ArgsT], RetT),
     ArgType = ?i(aeb_fate_data:make_typerep({tuple, ArgTypes})),
     RetType = ?i(aeb_fate_data:make_typerep(RetType0)),
-    case Gas of
-        {builtin, call_gas_left, _} ->
-            Call = aeb_fate_ops:call_r(?a, Lbl, ArgType, RetType, ?a),
-            call_to_scode(Env, Call, [Ct, Value | Args]);
+    case Protected of
+        {lit, {bool, false}} ->
+            case Gas of
+                {builtin, call_gas_left, _} ->
+                    Call = aeb_fate_ops:call_r(?a, Lbl, ArgType, RetType, ?a),
+                    call_to_scode(Env, Call, [Ct, Value | Args]);
+                _ ->
+                    Call = aeb_fate_ops:call_gr(?a, Lbl, ArgType, RetType, ?a, ?a),
+                    call_to_scode(Env, Call, [Ct, Value, Gas | Args])
+            end;
+        {lit, {bool, true}} ->
+            Call = aeb_fate_ops:call_pgr(?a, Lbl, ArgType, RetType, ?a, ?a, ?i(true)),
+            call_to_scode(Env, Call, [Ct, Value, Gas | Args]);
         _ ->
-            Call = aeb_fate_ops:call_gr(?a, Lbl, ArgType, RetType, ?a, ?a),
-            call_to_scode(Env, Call, [Ct, Value, Gas | Args])
+            Call = aeb_fate_ops:call_pgr(?a, Lbl, ArgType, RetType, ?a, ?a, ?a),
+            call_to_scode(Env, Call, [Ct, Value, Gas, Protected | Args])
     end;
 
 to_scode1(_Env, {get_state, Reg}) ->
@@ -494,10 +527,14 @@ builtin_to_scode(_Env, call_value, []) ->
     [aeb_fate_ops:call_value(?a)];
 builtin_to_scode(_Env, call_gas_price, []) ->
     [aeb_fate_ops:gasprice(?a)];
+builtin_to_scode(_Env, call_fee, []) ->
+    [aeb_fate_ops:fee(?a)];
 builtin_to_scode(_Env, call_gas_left, []) ->
     [aeb_fate_ops:gas(?a)];
 builtin_to_scode(Env, oracle_register, [_Sign,_Account,_QFee,_TTL,_QType,_RType] = Args) ->
     call_to_scode(Env, aeb_fate_ops:oracle_register(?a, ?a, ?a, ?a, ?a, ?a, ?a), Args);
+builtin_to_scode(Env, oracle_expiry, [_Oracle] = Args) ->
+    call_to_scode(Env, aeb_fate_ops:oracle_expiry(?a, ?a), Args);
 builtin_to_scode(Env, oracle_query_fee, [_Oracle] = Args) ->
     call_to_scode(Env, aeb_fate_ops:oracle_query_fee(?a, ?a), Args);
 builtin_to_scode(Env, oracle_query, [_Oracle, _Question, _QFee, _QTTL, _RTTL, _QType, _RType] = Args) ->
@@ -536,8 +573,35 @@ builtin_to_scode(Env, aens_transfer, [_Sign, _From, _To, _Name] = Args) ->
 builtin_to_scode(Env, aens_revoke, [_Sign, _Account, _Name] = Args) ->
     call_to_scode(Env, [aeb_fate_ops:aens_revoke(?a, ?a, ?a),
                         tuple(0)], Args);
+builtin_to_scode(Env, aens_update, [_Sign, _Account, _NameString, _TTL, _ClientTTL, _Pointers] = Args) ->
+    call_to_scode(Env, [aeb_fate_ops:aens_update(?a, ?a, ?a, ?a, ?a, ?a),
+                        tuple(0)], Args);
+builtin_to_scode(Env, aens_lookup, [_Name] = Args) ->
+    call_to_scode(Env, aeb_fate_ops:aens_lookup(?a, ?a), Args);
 builtin_to_scode(_Env, auth_tx_hash, []) ->
-    [aeb_fate_ops:auth_tx_hash(?a)].
+    [aeb_fate_ops:auth_tx_hash(?a)];
+builtin_to_scode(_Env, auth_tx, []) ->
+    [aeb_fate_ops:auth_tx(?a)];
+builtin_to_scode(Env, chain_bytecode_hash, [_Addr] = Args) ->
+    call_to_scode(Env, aeb_fate_ops:bytecode_hash(?a, ?a), Args);
+builtin_to_scode(Env, chain_clone,
+                 [InitArgsT, GasCap, Value, Prot, Contract | InitArgs]) ->
+    case GasCap of
+        {builtin, call_gas_left, _} ->
+            call_to_scode(Env, aeb_fate_ops:clone(?a, ?a, ?a, ?a),
+                          [Contract, InitArgsT, Value, Prot | InitArgs]
+                         );
+        _ ->
+            call_to_scode(Env, aeb_fate_ops:clone_g(?a, ?a, ?a, ?a, ?a),
+                          [Contract, InitArgsT, Value, GasCap, Prot | InitArgs]
+                         )
+    end;
+
+builtin_to_scode(Env, chain_create,
+                 [ Code, InitArgsT, Value | InitArgs]) ->
+    call_to_scode(Env, aeb_fate_ops:create(?a, ?a, ?a),
+                  [Code, InitArgsT, Value | InitArgs]
+                 ).
 
 %% -- Operators --
 
@@ -564,8 +628,14 @@ op_to_scode(map_to_list)       -> aeb_fate_ops:map_to_list(?a, ?a);
 op_to_scode(map_delete)        -> aeb_fate_ops:map_delete(?a, ?a, ?a);
 op_to_scode(map_member)        -> aeb_fate_ops:map_member(?a, ?a, ?a);
 op_to_scode(map_size)          -> aeb_fate_ops:map_size_(?a, ?a);
-op_to_scode(string_length)     -> aeb_fate_ops:str_length(?a, ?a);
-op_to_scode(string_concat)     -> aeb_fate_ops:str_join(?a, ?a, ?a);
+op_to_scode(stringinternal_length)    -> aeb_fate_ops:str_length(?a, ?a);
+op_to_scode(stringinternal_concat)    -> aeb_fate_ops:str_join(?a, ?a, ?a);
+op_to_scode(stringinternal_to_list)   -> aeb_fate_ops:str_to_list(?a, ?a);
+op_to_scode(stringinternal_from_list) -> aeb_fate_ops:str_from_list(?a, ?a);
+op_to_scode(stringinternal_to_lower)  -> aeb_fate_ops:str_to_lower(?a, ?a);
+op_to_scode(stringinternal_to_upper)  -> aeb_fate_ops:str_to_upper(?a, ?a);
+op_to_scode(char_to_int)       -> aeb_fate_ops:char_to_int(?a, ?a);
+op_to_scode(char_from_int)     -> aeb_fate_ops:char_from_int(?a, ?a);
 op_to_scode(bits_set)          -> aeb_fate_ops:bits_set(?a, ?a, ?a);
 op_to_scode(bits_clear)        -> aeb_fate_ops:bits_clear(?a, ?a, ?a);
 op_to_scode(bits_test)         -> aeb_fate_ops:bits_test(?a, ?a, ?a);
@@ -584,9 +654,33 @@ op_to_scode(crypto_ecrecover_secp256k1)  -> aeb_fate_ops:ecrecover_secp256k1(?a,
 op_to_scode(crypto_sha3)                 -> aeb_fate_ops:sha3(?a, ?a);
 op_to_scode(crypto_sha256)               -> aeb_fate_ops:sha256(?a, ?a);
 op_to_scode(crypto_blake2b)              -> aeb_fate_ops:blake2b(?a, ?a);
-op_to_scode(string_sha3)                 -> aeb_fate_ops:sha3(?a, ?a);
-op_to_scode(string_sha256)               -> aeb_fate_ops:sha256(?a, ?a);
-op_to_scode(string_blake2b)              -> aeb_fate_ops:blake2b(?a, ?a).
+op_to_scode(stringinternal_sha3)         -> aeb_fate_ops:sha3(?a, ?a);
+op_to_scode(stringinternal_sha256)       -> aeb_fate_ops:sha256(?a, ?a);
+op_to_scode(stringinternal_blake2b)      -> aeb_fate_ops:blake2b(?a, ?a);
+op_to_scode(mcl_bls12_381_g1_neg)        -> aeb_fate_ops:bls12_381_g1_neg(?a, ?a);
+op_to_scode(mcl_bls12_381_g1_norm)       -> aeb_fate_ops:bls12_381_g1_norm(?a, ?a);
+op_to_scode(mcl_bls12_381_g1_valid)      -> aeb_fate_ops:bls12_381_g1_valid(?a, ?a);
+op_to_scode(mcl_bls12_381_g1_is_zero)    -> aeb_fate_ops:bls12_381_g1_is_zero(?a, ?a);
+op_to_scode(mcl_bls12_381_g1_add)        -> aeb_fate_ops:bls12_381_g1_add(?a, ?a, ?a);
+op_to_scode(mcl_bls12_381_g1_mul)        -> aeb_fate_ops:bls12_381_g1_mul(?a, ?a, ?a);
+op_to_scode(mcl_bls12_381_g2_neg)        -> aeb_fate_ops:bls12_381_g2_neg(?a, ?a);
+op_to_scode(mcl_bls12_381_g2_norm)       -> aeb_fate_ops:bls12_381_g2_norm(?a, ?a);
+op_to_scode(mcl_bls12_381_g2_valid)      -> aeb_fate_ops:bls12_381_g2_valid(?a, ?a);
+op_to_scode(mcl_bls12_381_g2_is_zero)    -> aeb_fate_ops:bls12_381_g2_is_zero(?a, ?a);
+op_to_scode(mcl_bls12_381_g2_add)        -> aeb_fate_ops:bls12_381_g2_add(?a, ?a, ?a);
+op_to_scode(mcl_bls12_381_g2_mul)        -> aeb_fate_ops:bls12_381_g2_mul(?a, ?a, ?a);
+op_to_scode(mcl_bls12_381_gt_inv)        -> aeb_fate_ops:bls12_381_gt_inv(?a, ?a);
+op_to_scode(mcl_bls12_381_gt_add)        -> aeb_fate_ops:bls12_381_gt_add(?a, ?a, ?a);
+op_to_scode(mcl_bls12_381_gt_mul)        -> aeb_fate_ops:bls12_381_gt_mul(?a, ?a, ?a);
+op_to_scode(mcl_bls12_381_gt_pow)        -> aeb_fate_ops:bls12_381_gt_pow(?a, ?a, ?a);
+op_to_scode(mcl_bls12_381_gt_is_one)     -> aeb_fate_ops:bls12_381_gt_is_one(?a, ?a);
+op_to_scode(mcl_bls12_381_pairing)       -> aeb_fate_ops:bls12_381_pairing(?a, ?a, ?a);
+op_to_scode(mcl_bls12_381_miller_loop)   -> aeb_fate_ops:bls12_381_miller_loop(?a, ?a, ?a);
+op_to_scode(mcl_bls12_381_final_exp)     -> aeb_fate_ops:bls12_381_final_exp(?a, ?a);
+op_to_scode(mcl_bls12_381_int_to_fr)     -> aeb_fate_ops:bls12_381_int_to_fr(?a, ?a);
+op_to_scode(mcl_bls12_381_int_to_fp)     -> aeb_fate_ops:bls12_381_int_to_fp(?a, ?a);
+op_to_scode(mcl_bls12_381_fr_to_int)     -> aeb_fate_ops:bls12_381_fr_to_int(?a, ?a);
+op_to_scode(mcl_bls12_381_fp_to_int)     -> aeb_fate_ops:bls12_381_fp_to_int(?a, ?a).
 
 %% PUSH and STORE ?a are the same, so we use STORE to make optimizations
 %% easier, and specialize to PUSH (which is cheaper) at the end.
@@ -734,6 +828,7 @@ attributes(I) ->
         {'CALL', A}                           -> Impure(?a, [A]);
         {'CALL_R', A, _, B, C, D}             -> Impure(?a, [A, B, C, D]);
         {'CALL_GR', A, _, B, C, D, E}         -> Impure(?a, [A, B, C, D, E]);
+        {'CALL_PGR', A, _, B, C, D, E, F}     -> Impure(?a, [A, B, C, D, E, F]);
         {'CALL_T', A}                         -> Impure(pc, [A]);
         {'CALL_VALUE', A}                     -> Pure(A, []);
         {'JUMP', _}                           -> Impure(pc, []);
@@ -815,6 +910,7 @@ attributes(I) ->
         {'CONTRACT_TO_ADDRESS', A, B}         -> Pure(A, [B]);
         {'ADDRESS_TO_CONTRACT', A, B}         -> Pure(A, [B]);
         {'AUTH_TX_HASH', A}                   -> Pure(A, []);
+        {'AUTH_TX', A}                        -> Pure(A, []);
         {'BYTES_TO_INT', A, B}                -> Pure(A, [B]);
         {'BYTES_TO_STR', A, B}                -> Pure(A, [B]);
         {'BYTES_CONCAT', A, B, C}             -> Pure(A, [B, C]);
@@ -831,6 +927,7 @@ attributes(I) ->
         {'ORIGIN', A}                         -> Pure(A, []);
         {'CALLER', A}                         -> Pure(A, []);
         {'GASPRICE', A}                       -> Pure(A, []);
+        {'FEE', A}                            -> Pure(A, []);
         {'BLOCKHASH', A, B}                   -> Pure(A, [B]);
         {'BENEFICIARY', A}                    -> Pure(A, []);
         {'TIMESTAMP', A}                      -> Pure(A, []);
@@ -853,12 +950,48 @@ attributes(I) ->
         {'ORACLE_GET_ANSWER', A, B, C, D, E}  -> Pure(A, [B, C, D, E]);
         {'ORACLE_GET_QUESTION', A, B, C, D, E}-> Pure(A, [B, C, D, E]);
         {'ORACLE_QUERY_FEE', A, B}            -> Pure(A, [B]);
-        {'AENS_RESOLVE', A, B, C, D}          -> Pure(A, [B, C, D]);
+        {'ORACLE_EXPIRY', A, B}               -> Impure(A, [B]);
+        {'AENS_RESOLVE', A, B, C, D}          -> Impure(A, [B, C, D]);
         {'AENS_PRECLAIM', A, B, C}            -> Impure(none, [A, B, C]);
         {'AENS_CLAIM', A, B, C, D, E}         -> Impure(none, [A, B, C, D, E]);
-        'AENS_UPDATE'                         -> Impure(none, []);%% TODO
+        {'AENS_UPDATE', A, B, C, D, E, F}     -> Impure(none, [A, B, C, D, E, F]);
         {'AENS_TRANSFER', A, B, C, D}         -> Impure(none, [A, B, C, D]);
         {'AENS_REVOKE', A, B, C}              -> Impure(none, [A, B, C]);
+        {'AENS_LOOKUP', A, B}                 -> Impure(A, [B]);
+        {'BLS12_381_G1_NEG', A, B}            -> Pure(A, [B]);
+        {'BLS12_381_G1_NORM', A, B}           -> Pure(A, [B]);
+        {'BLS12_381_G1_VALID', A, B}          -> Pure(A, [B]);
+        {'BLS12_381_G1_IS_ZERO', A, B}        -> Pure(A, [B]);
+        {'BLS12_381_G1_ADD', A, B, C}         -> Pure(A, [B, C]);
+        {'BLS12_381_G1_MUL', A, B, C}         -> Pure(A, [B, C]);
+        {'BLS12_381_G2_NEG', A, B}            -> Pure(A, [B]);
+        {'BLS12_381_G2_NORM', A, B}           -> Pure(A, [B]);
+        {'BLS12_381_G2_VALID', A, B}          -> Pure(A, [B]);
+        {'BLS12_381_G2_IS_ZERO', A, B}        -> Pure(A, [B]);
+        {'BLS12_381_G2_ADD', A, B, C}         -> Pure(A, [B, C]);
+        {'BLS12_381_G2_MUL', A, B, C}         -> Pure(A, [B, C]);
+        {'BLS12_381_GT_INV', A, B}            -> Pure(A, [B]);
+        {'BLS12_381_GT_ADD', A, B, C}         -> Pure(A, [B, C]);
+        {'BLS12_381_GT_MUL', A, B, C}         -> Pure(A, [B, C]);
+        {'BLS12_381_GT_POW', A, B, C}         -> Pure(A, [B, C]);
+        {'BLS12_381_GT_IS_ONE', A, B}         -> Pure(A, [B]);
+        {'BLS12_381_PAIRING', A, B, C}        -> Pure(A, [B, C]);
+        {'BLS12_381_MILLER_LOOP', A, B, C}    -> Pure(A, [B, C]);
+        {'BLS12_381_FINAL_EXP', A, B}         -> Pure(A, [B]);
+        {'BLS12_381_INT_TO_FR', A, B}         -> Pure(A, [B]);
+        {'BLS12_381_INT_TO_FP', A, B}         -> Pure(A, [B]);
+        {'BLS12_381_FR_TO_INT', A, B}         -> Pure(A, [B]);
+        {'BLS12_381_FP_TO_INT', A, B}         -> Pure(A, [B]);
+        {'STR_TO_LIST', A, B}                 -> Pure(A, [B]);
+        {'STR_FROM_LIST', A, B}               -> Pure(A, [B]);
+        {'STR_TO_UPPER', A, B}                -> Pure(A, [B]);
+        {'STR_TO_LOWER', A, B}                -> Pure(A, [B]);
+        {'CHAR_TO_INT', A, B}                 -> Pure(A, [B]);
+        {'CHAR_FROM_INT', A, B}               -> Pure(A, [B]);
+        {'CREATE', A, B, C}                   -> Impure(?a, [A, B, C]);
+        {'CLONE', A, B, C, D}                 -> Impure(?a, [A, B, C, D]);
+        {'CLONE_G', A, B, C, D, E}            -> Impure(?a, [A, B, C, D, E]);
+        {'BYTECODE_HASH', A, B}               -> Impure(A, [B]);
         {'ABORT', A}                          -> Impure(pc, A);
         {'EXIT', A}                           -> Impure(pc, A);
         'NOP'                                 -> Pure(none, [])
@@ -1611,6 +1744,10 @@ split_calls(Ref, [], Acc, Blocks) ->
 split_calls(Ref, [I | Code], Acc, Blocks) when element(1, I) == 'CALL';
                                                element(1, I) == 'CALL_R';
                                                element(1, I) == 'CALL_GR';
+                                               element(1, I) == 'CALL_PGR';
+                                               element(1, I) == 'CREATE';
+                                               element(1, I) == 'CLONE';
+                                               element(1, I) == 'CLONE_G';
                                                element(1, I) == 'jumpif' ->
     split_calls(make_ref(), Code, [], [{Ref, lists:reverse([I | Acc])} | Blocks]);
 split_calls(Ref, [{'ABORT', _} = I | _Code], Acc, Blocks) ->

src/aeso_icode.erl

@@ -73,28 +73,33 @@ new(Options) ->
 
 builtin_types() ->
     Word = fun([]) -> word end,
-    #{ "bool"         => Word
-     , "int"          => Word
-     , "char"         => Word
-     , "bits"         => Word
-     , "string"       => fun([]) -> string end
-     , "address"      => Word
-     , "hash"         => Word
-     , "unit"         => fun([]) -> {tuple, []} end
-     , "signature"    => fun([]) -> {tuple, [word, word]} end
-     , "oracle"       => fun([_, _]) -> word end
-     , "oracle_query" => fun([_, _]) -> word end
-     , "list"         => fun([A]) -> {list, A} end
-     , "option"       => fun([A]) -> {variant, [[], [A]]} end
-     , "map"          => fun([K, V]) -> map_typerep(K, V) end
-     , ["Chain", "ttl"] => fun([]) -> {variant, [[word], [word]]} end
+    #{ "bool"              => Word
+     , "int"               => Word
+     , "char"              => Word
+     , "bits"              => Word
+     , "string"            => fun([]) -> string end
+     , "address"           => Word
+     , "hash"              => Word
+     , "unit"              => fun([]) -> {tuple, []} end
+     , "signature"         => fun([]) -> {tuple, [word, word]} end
+     , "oracle"            => fun([_, _]) -> word end
+     , "oracle_query"      => fun([_, _]) -> word end
+     , "list"              => fun([A]) -> {list, A} end
+     , "option"            => fun([A]) -> {variant, [[], [A]]} end
+     , "map"               => fun([K, V]) -> map_typerep(K, V) end
+     , ["Chain", "ttl"]    => fun([]) -> {variant, [[word], [word]]} end
+     , ["AENS", "pointee"] => fun([]) -> {variant, [[word], [word], [word]]} end
      }.
 
 builtin_constructors() ->
-    #{ ["RelativeTTL"] => 0
-     , ["FixedTTL"]    => 1
-     , ["None"]        => 0
-     , ["Some"]        => 1 }.
+    #{ ["RelativeTTL"]     => 0
+     , ["FixedTTL"]        => 1
+     , ["None"]            => 0
+     , ["Some"]            => 1
+     , ["AccountPointee"]  => 0
+     , ["OraclePointee"]   => 1
+     , ["ContractPointee"] => 2
+     }.
 
 map_typerep(K, V) ->
     {map, K, V}.
@@ -146,4 +151,3 @@ get_constructor_tag(Name, #{constructors := Constructors}) ->
         undefined -> error({undefined_constructor, Name});
         Tag       -> Tag
     end.
-

src/aeso_parse_lib.erl

@@ -74,25 +74,31 @@
                     %%   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(apply_p(Q, K), R) end,
-                                             apply_p(P, K), Ps);
+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(?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)         -> K(X);
+apply_p(?return(X), K)         -> ?BOUNCE(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) -> K(X).
+apply_p(X, K) -> ?BOUNCE(K(X)).
 
 %% -- Primitive combinators --------------------------------------------------
 
@@ -160,7 +166,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(apply_p(P, fun(X) -> {return_plus, X, {fail, no_error}} end), S) of
+  case parse1(trampoline(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}}
@@ -241,7 +247,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(F(T), G(T)) end end, Map1, Map2)};
+    {tok_bind, merge_with(fun(F, G) -> fun(T) -> choice1(trampoline(F(T)), trampoline(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)};
@@ -255,7 +261,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(F(N), G(N)) end, choice1(P, Q)};
+    {layout, fun(N) -> choice1(trampoline(F(N)), trampoline(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)}.
 
@@ -278,6 +284,8 @@ 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} ->

src/aeso_parser.erl

@@ -3,20 +3,33 @@
 %%% 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,
-         type/1]).
+         decl/0,
+         type/0,
+         body/0,
+         maybe_block/1,
+         run_parser/2,
+         run_parser/3]).
 
 -include("aeso_parse_lib.hrl").
 -import(aeso_parse_lib, [current_file/0, set_current_file/1]).
 
--type parse_result() :: aeso_syntax:ast() | none().
+-type parse_result() :: aeso_syntax:ast() | {aeso_syntax:ast(), sets:set(include_hash())} | 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(), []).
@@ -30,21 +43,17 @@ string(String, Opts) ->
 
 -spec string(string(), sets:set(include_hash()), aeso_compiler:options()) -> parse_result().
 string(String, Included, Opts) ->
-    case parse_and_scan(file(), String, Opts) of
-        {ok, AST} ->
-            case expand_includes(AST, Included, Opts) of
-                {ok, AST1}   -> AST1;
-                {error, Err} -> parse_error(Err)
-            end;
-        {error, Err} ->
-            parse_error(Err)
+    AST = run_parser(file(), String, Opts),
+    case expand_includes(AST, Included, Opts) of
+        {ok, AST1}   -> AST1;
+        {error, Err} -> parse_error(Err)
     end.
 
-type(String) ->
-    case parse_and_scan(type(), String, []) of
-        {ok, AST}    -> {ok, AST};
-        {error, Err} -> {error, [mk_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)).
 
 parse_and_scan(P, S, Opts) ->
     set_current_file(proplists:get_value(src_file, Opts, no_file)),
@@ -84,8 +93,20 @@ decl() ->
     ?LAZY_P(
     choice(
       %% Contract declaration
-    [ ?RULE(keyword(contract),  con(), tok('='), maybe_block(decl()), {contract, _1, _2, _4})
-    , ?RULE(token(payable),     keyword(contract), con(), tok('='), maybe_block(decl()), add_modifiers([_1], {contract, _2, _3, _5}))
+    [ ?RULE(token(main), keyword(contract),
+            con(), tok('='), maybe_block(decl()), {contract_main, _2, _3, _5})
+    , ?RULE(keyword(contract),
+            con(), tok('='), maybe_block(decl()), {contract_child, _1, _2, _4})
+    , ?RULE(keyword(contract), token(interface),
+            con(), tok('='), maybe_block(decl()), {contract_interface, _1, _3, _5})
+    , ?RULE(token(payable), token(main), keyword(contract),
+            con(), tok('='), maybe_block(decl()), add_modifiers([_1], {contract_main, _3, _4, _6}))
+    , ?RULE(token(payable), keyword(contract),
+            con(), tok('='), maybe_block(decl()), add_modifiers([_1], {contract_child, _2, _3, _5}))
+    , ?RULE(token(payable), keyword(contract), token(interface),
+            con(), tok('='), maybe_block(decl()), add_modifiers([_1], {contract_interface, _2, _4, _6}))
+
+
     , ?RULE(keyword(namespace), con(), tok('='), maybe_block(decl()), {namespace, _1, _2, _4})
     , ?RULE(keyword(include),   str(), {include, get_ann(_1), _2})
     , pragma()
@@ -102,7 +123,7 @@ decl() ->
 
       %% 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(keyword('let'), valdef(), set_pos(get_pos(_1), _2))
     ])).
 
 fun_block(Mods, Kind, [Decl]) ->
@@ -596,8 +617,13 @@ expand_includes(AST, Included, Opts) ->
              || File <- lists:usort(auto_imports(AST)) ] ++ AST,
     expand_includes(AST1, Included, [], Opts).
 
-expand_includes([], _Included, Acc, _Opts) ->
-    {ok, lists:reverse(Acc)};
+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([{include, Ann, {string, _SAnn, File}} | AST], Included, Acc, Opts) ->
     case get_include_code(File, Ann, Opts) of
         {ok, Code} ->
@@ -656,8 +682,14 @@ stdlib_options() ->
 
 get_include_code(File, Ann, Opts) ->
     case {read_file(File, Opts), read_file(File, stdlib_options())} of
-        {{ok, _}, {ok,_ }} ->
-            fail(ann_pos(Ann), "Illegal redefinition of standard library " ++ File);
+        {{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, Bin}} ->
             {ok, binary_to_list(Bin)};
         {{ok, Bin}, _} ->

src/aeso_pretty.erl

@@ -13,6 +13,8 @@
 
 -export_type([options/0]).
 
+-include("aeso_utils.hrl").
+
 -type doc() :: prettypr:document().
 -type options() :: [{indent, non_neg_integer()} | show_generated].
 
@@ -131,6 +133,10 @@ typed(A, Type) ->
         false -> follow(hsep(A, text(":")), type(Type))
     end.
 
+contract_head(contract_main)      -> text("main contract");
+contract_head(contract_child)     -> text("contract");
+contract_head(contract_interface) -> text("contract interface").
+
 %% -- Exports ----------------------------------------------------------------
 
 -spec decls([aeso_syntax:decl()], options()) -> doc().
@@ -145,8 +151,12 @@ decl(D, Options) ->
     with_options(Options, fun() -> decl(D) end).
 
 -spec decl(aeso_syntax:decl()) -> doc().
-decl({contract, _, C, Ds}) ->
-    block(follow(text("contract"), hsep(name(C), text("="))), decls(Ds));
+decl({Con, Attrs, C, Ds}) when ?IS_CONTRACT_HEAD(Con) ->
+    Mod = fun({Mod, true}) when Mod == payable ->
+                  text(atom_to_list(Mod));
+             (_) -> empty() end,
+    block(follow( hsep(lists:map(Mod, Attrs) ++ [contract_head(Con)])
+                , 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);
@@ -155,13 +165,16 @@ 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(Fun, typed(name(F), T));
+    hsep(lists:map(Mod, Ann) ++ [Fun, typed(name(F), T)]);
 decl(D = {letfun, Attrs, _, _, _, _}) ->
-    Mod = fun({Mod, true}) when Mod == private; Mod == stateful ->
+    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, Attrs, false) of
@@ -257,6 +270,8 @@ type({args_t, _, Args}) ->
 type({bytes_t, _, any}) -> text("bytes(_)");
 type({bytes_t, _, Len}) ->
     text(lists:concat(["bytes(", Len, ")"]));
+type({if_t, _, Id, Then, Else}) ->
+    beside(text("if"), args_type([Id, Then, Else]));
 type({named_arg_t, _, Name, Type, _Default}) ->
     %% Drop the default value
     %% follow(hsep(typed(name(Name), Type), text("=")), expr(Default));
@@ -283,12 +298,9 @@ tuple_type(Factors) ->
       , text(")")
       ]).
 
--spec arg_expr(aeso_syntax:arg_expr()) -> doc().
-arg_expr({named_arg, _, Name, E}) ->
-    follow(hsep(expr(Name), text("=")), expr(E));
-arg_expr(E) -> expr(E).
-
--spec expr_p(integer(), aeso_syntax:expr()) -> doc().
+-spec expr_p(integer(), aeso_syntax:arg_expr()) -> doc().
+expr_p(P, {named_arg, _, Name, E}) ->
+    paren(P > 100, follow(hsep(expr(Name), text("=")), expr(E)));
 expr_p(P, {lam, _, Args, E}) ->
     paren(P > 100, follow(hsep(args(Args), text("=>")), expr_p(100, E)));
 expr_p(P, If = {'if', Ann, Cond, Then, Else}) ->
@@ -364,13 +376,19 @@ 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}) -> term(binary_to_list(S));
+expr_p(_, {string, _, S}) ->
+    text(io_lib:format("\"~s\"", [binary_to_list(S)]));
 expr_p(_, {char, _, C}) ->
     case C of
         $' -> text("'\\''");
         $" -> text("'\"'");
-        _  -> S = lists:flatten(io_lib:format("~p", [[C]])),
-              text("'" ++ tl(lists:droplast(S)) ++ "'")
+        _ when C < 16#80 ->
+            S = lists:flatten(io_lib:format("~p", [[C]])),
+            text("'" ++ tl(lists:droplast(S)) ++ "'");
+        _  ->
+            S = lists:flatten(
+                  io_lib:format("'~ts'", [list_to_binary(aeso_scan:utf8_encode([C]))])),
+            text(S)
     end;
 %% -- Names
 expr_p(_, E = {id, _, _})   -> name(E);
@@ -442,7 +460,7 @@ prefix(P, Op, A) ->
 app(P, F, Args) ->
     paren(P > 900,
     beside(expr_p(900, F),
-           tuple(lists:map(fun arg_expr/1, Args)))).
+           tuple(lists:map(fun expr/1, Args)))).
 
 field({field, _, LV, E}) ->
     follow(hsep(lvalue(LV), text("=")), expr(E));
@@ -486,6 +504,3 @@ 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

@@ -7,7 +7,7 @@
 %%%-------------------------------------------------------------------
 -module(aeso_scan).
 
--export([scan/1]).
+-export([scan/1, utf8_encode/1]).
 
 -import(aeso_scan_lib, [token/1, token/2, symbol/0, skip/0,
                         override/2, push/2, pop/1]).
@@ -28,7 +28,13 @@ lexer() ->
     QID      = ["(", CON, "\\.)+", ID],
     QCON     = ["(", CON, "\\.)+", CON],
     OP       = "[=!<>+\\-*/:&|?~@^]+",
-    CHAR     = "'([^'\\\\]|(\\\\.))'",
+    %% Five cases for a character
+    %%  * 1 7-bit ascii, not \ or '
+    %%  * 2-4 8-bit values (UTF8)
+    %%  * \ followed by a known modifier [aernrtv]
+    %%  * \xhh
+    %%  * \x{hhh...}
+    CHAR     = "'(([\\x00-\\x26\\x28-\\x5b\\x5d-\\x7f])|([\\x00-\\xff][\\x80-\\xff]{1,3})|(\\\\[befnrtv'\\\\])|(\\\\x[0-9a-fA-F]{2,2})|(\\\\x\\{[0-9a-fA-F]*\\}))'",
     STRING   = "\"([^\"\\\\]|(\\\\.))*\"",
 
     CommentStart = {"/\\*", push(comment, skip())},
@@ -38,7 +44,9 @@ 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",
+                "interface", "main"
+               ],
     KW = string:join(Keywords, "|"),
 
     Rules =
@@ -77,34 +85,34 @@ scan(String) ->
 %% -- Helpers ----------------------------------------------------------------
 
 parse_string([$" | Chars]) ->
-    unescape(Chars).
+    unicode:characters_to_nfc_binary(unescape(Chars)).
 
-parse_char([$', $\\, Code, $']) ->
-    case Code of
-        $'  -> $';
-        $\\ -> $\\;
-        $b  -> $\b;
-        $e  -> $\e;
-        $f  -> $\f;
-        $n  -> $\n;
-        $r  -> $\r;
-        $t  -> $\t;
-        $v  -> $\v;
-        _   -> {error, "Bad control sequence: \\" ++ [Code]}
-    end;
-parse_char([$', C, $']) -> C.
+parse_char([$' | Chars]) ->
+    case unicode:characters_to_nfc_list(unescape($', Chars, [])) of
+        [Char] -> Char;
+        _Bad   -> {error, "Bad character literal: '" ++ Chars}
+    end.
 
-unescape(Str) -> unescape(Str, []).
+utf8_encode(Cs) ->
+    binary_to_list(unicode:characters_to_binary(Cs)).
 
-unescape([$"], Acc) ->
+unescape(Str) -> unescape($", Str, []).
+
+unescape(Delim, [Delim], Acc) ->
     list_to_binary(lists:reverse(Acc));
-unescape([$\\, $x, D1, D2 | Chars ], Acc) ->
+unescape(Delim, [$\\, $x, ${ | Chars ], Acc) ->
+    {Ds, [_ | Cs]} = lists:splitwith(fun($}) -> false ; (_) -> true end, Chars),
+    C = list_to_integer(Ds, 16),
+    Utf8Cs = binary_to_list(unicode:characters_to_binary([C])),
+    unescape(Delim, Cs, [Utf8Cs | Acc]);
+unescape(Delim, [$\\, $x, D1, D2 | Chars ], Acc) ->
     C = list_to_integer([D1, D2], 16),
-    unescape(Chars, [C | Acc]);
-unescape([$\\, Code | Chars], Acc) ->
-    Ok = fun(C) -> unescape(Chars, [C | Acc]) end,
+    Utf8Cs = binary_to_list(unicode:characters_to_binary([C])),
+    unescape(Delim, Chars, [Utf8Cs | Acc]);
+unescape(Delim, [$\\, Code | Chars], Acc) ->
+    Ok = fun(C) -> unescape(Delim, Chars, [C | Acc]) end,
     case Code of
-        $"  -> Ok($");
+        Delim -> Ok(Delim);
         $\\ -> Ok($\\);
         $b  -> Ok($\b);
         $e  -> Ok($\e);
@@ -115,8 +123,8 @@ unescape([$\\, Code | Chars], Acc) ->
         $v  -> Ok($\v);
         _   -> error("Bad control sequence: \\" ++ [Code])  %% TODO
     end;
-unescape([C | Chars], Acc) ->
-    unescape(Chars, [C | Acc]).
+unescape(Delim, [C | Chars], Acc) ->
+    unescape(Delim, Chars, [C | Acc]).
 
 strip_underscores(S) ->
     lists:filter(fun(C) -> C /= $_ end, S).

src/aeso_syntax.erl

@@ -25,7 +25,8 @@
 -type ann_origin() :: system | user.
 -type ann_format() :: '?:' | hex | infix | prefix | elif.
 
--type ann() :: [{line, ann_line()} | {col, ann_col()} | {format, ann_format()} | {origin, ann_origin()} | stateful | private].
+-type ann() :: [ {line, ann_line()} | {col, ann_col()} | {format, ann_format()} | {origin, ann_origin()}
+               | stateful | private | payable | main | interface].
 
 -type name() :: string().
 -type id()   :: {id,   ann(), name()}.
@@ -34,23 +35,31 @@
 -type qcon() :: {qcon, ann(), [name()]}.
 -type tvar() :: {tvar, ann(), name()}.
 
--type decl() :: {contract, ann(), con(), [decl()]}
+-type decl() :: {contract_main, ann(), con(), [decl()]}
+              | {contract_child, ann(), con(), [decl()]}
+              | {contract_interface, ann(), con(), [decl()]}
               | {namespace, ann(), con(), [decl()]}
               | {pragma, ann(), pragma()}
-              | {type_decl, ann(), id(), [tvar()]}
+              | {type_decl, ann(), id(), [tvar()]} % Only for error msgs
               | {type_def, ann(), id(), [tvar()], typedef()}
-              | {fun_decl, ann(), id(), type()}
-              | {fun_clauses, ann(), id(), type(), [letbind()]}
+              | {fun_clauses, ann(), id(), type(), [letfun() | fundecl()]}
               | {block, ann(), [decl()]}
-              | letbind().
+              | 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()}.
+
 -type letbind()
-    :: {letval, ann(), pat(), expr()}
-     | {letfun, ann(), id(), [pat()], type(), expr()}.
+    :: letfun()
+     | letval().
 
 -type arg() :: {arg, ann(), id(), type()}.
 

src/aeso_syntax_utils.erl

@@ -45,7 +45,6 @@ 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));

src/aeso_utils.hrl

@@ -0,0 +1,6 @@
+-define(IS_CONTRACT_HEAD(X),
+        (X =:= contract_main orelse
+         X =:= contract_interface orelse
+         X =:= contract_child
+        )
+       ).

src/aeso_vm_decode.erl

@@ -95,6 +95,8 @@ 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)}

src/aesophia.app.src

@@ -1,6 +1,6 @@
 {application, aesophia,
- [{description, "Contract Language for aeternity"},
-  {vsn, "4.2.0"},
+ [{description, "Compiler for Aeternity Sophia language"},
+  {vsn, "6.0.2"},
   {registered, []},
   {applications,
    [kernel,

test/aeso_abi_tests.erl

@@ -190,7 +190,7 @@ parameterized_contract(ExtraCode, FunName, Types) ->
     lists:flatten(
         ["contract Remote =\n"
          "  entrypoint bla : () => unit\n\n"
-         "contract Dummy =\n",
+         "main contract Dummy =\n",
          ExtraCode, "\n",
          "  type an_alias('a) = string * 'a\n"
          "  record r = {x : an_alias(int), y : variant}\n"

test/aeso_aci_tests.erl

@@ -11,7 +11,10 @@ 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)).
+    ?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).
 
 test_cases(1) ->
     Contract = <<"payable contract C =\n"
@@ -19,7 +22,8 @@ test_cases(1) ->
     MapACI = #{contract =>
 		   #{name => <<"C">>,
 		     type_defs => [],
-                     payable => true,
+         payable => true,
+         kind => contract_main,
 		     functions =>
 			 [#{name => <<"a">>,
 			    arguments =>
@@ -28,63 +32,64 @@ test_cases(1) ->
 			    returns => <<"int">>,
 			    stateful => true,
                             payable  => true}]}},
-    DecACI = <<"payable contract C =\n"
+    DecACI = <<"payable main contract C =\n"
 	       "  payable entrypoint a : (int) => int\n">>,
     {Contract,MapACI,DecACI};
 
 test_cases(2) ->
-    Contract = <<"contract C =\n"
+    Contract = <<"main contract C =\n"
 		 "  type allan = int\n"
 		 "  entrypoint a(i : allan) = i+1\n">>,
     MapACI = #{contract =>
-                       #{name => <<"C">>, payable => false,
-                         type_defs =>
-                             [#{name => <<"allan">>,
-                                typedef => <<"int">>,
-                                vars => []}],
-			 functions =>
-                             [#{arguments =>
-                                    [#{name => <<"i">>,
-                                       type => <<"C.allan">>}],
-                                name => <<"a">>,
-                                returns => <<"int">>,
-                                stateful => false,
-                                payable  => false}]}},
-    DecACI = <<"contract C =\n"
+                   #{name => <<"C">>, payable => false,
+                     kind => contract_main,
+                     type_defs =>
+                         [#{name => <<"allan">>,
+                            typedef => <<"int">>,
+                            vars => []}],
+                     functions =>
+                         [#{arguments =>
+                                [#{name => <<"i">>,
+                                   type => <<"C.allan">>}],
+                            name => <<"a">>,
+                            returns => <<"int">>,
+                            stateful => false,
+                            payable  => false}]}},
+    DecACI = <<"main contract C =\n"
                "  type allan = int\n"
                "  entrypoint a : (C.allan) => int\n">>,
     {Contract,MapACI,DecACI};
 test_cases(3) ->
-    Contract = <<"contract C =\n"
+    Contract = <<"main contract C =\n"
                  "  type state = unit\n"
                  "  datatype event = SingleEventDefined\n"
-		 "  datatype bert('a) = Bin('a)\n"
-		 "  entrypoint a(i : bert(string)) = 1\n">>,
+                 "  datatype bert('a) = Bin('a)\n"
+                 "  entrypoint a(i : bert(string)) = 1\n">>,
     MapACI = #{contract =>
 		   #{functions =>
-			 [#{arguments =>
-				[#{name => <<"i">>,
-				   type =>
-				       #{<<"C.bert">> => [<<"string">>]}}],
-			    name => <<"a">>,returns => <<"int">>,
-			    stateful => false, payable  => false}],
-		     name => <<"C">>, payable => false,
-                     event => #{variant => [#{<<"SingleEventDefined">> => []}]},
-                     state => <<"unit">>,
+             [#{arguments =>
+                    [#{name => <<"i">>,
+                       type =>
+                           #{<<"C.bert">> => [<<"string">>]}}],
+                name => <<"a">>,returns => <<"int">>,
+                stateful => false, payable  => false}],
+		     name => <<"C">>, payable => false, kind => contract_main,
+         event => #{variant => [#{<<"SingleEventDefined">> => []}]},
+         state => <<"unit">>,
 		     type_defs =>
-			 [#{name => <<"bert">>,
-			    typedef =>
-				#{variant =>
-				      [#{<<"Bin">> => [<<"'a">>]}]},
-			    vars => [#{name => <<"'a">>}]}]}},
-    DecACI = <<"contract C =\n"
+             [#{name => <<"bert">>,
+                typedef =>
+                    #{variant =>
+                          [#{<<"Bin">> => [<<"'a">>]}]},
+                vars => [#{name => <<"'a">>}]}]}},
+    DecACI = <<"main 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}.
 
-%% Rounttrip
+%% Roundtrip
 aci_test_() ->
     [{"Testing ACI generation for " ++ ContractName,
       fun() -> aci_test_contract(ContractName) end}
@@ -94,16 +99,28 @@ all_contracts() -> aeso_compiler_tests:compilable_contracts().
 
 aci_test_contract(Name) ->
     String = aeso_test_utils:read_contract(Name),
-    Opts   = [{include, {file_system, [aeso_test_utils:contract_path()]}}],
-    {ok, JSON} = aeso_aci:contract_interface(json, String, Opts),
+    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()]}}],
+    JSON = case aeso_aci:contract_interface(json, String, Opts) of
+               {ok, J} -> J;
+               {error, ErrorStringJ} when is_binary(ErrorStringJ) -> error(ErrorStringJ);
+               {error, ErrorJ} -> aeso_compiler_tests:print_and_throw(ErrorJ)
+           end,
+    case aeso_compiler:from_string(String, [{aci, json}, {backend, fate} | Opts]) of
+        {ok, #{aci := JSON1}} ->
+            ?assertEqual(JSON, JSON1),
+            io:format("JSON:\n~p\n", [JSON]),
+            {ok, ContractStub} = aeso_aci:render_aci_json(JSON),
 
-    io:format("JSON:\n~p\n", [JSON]),
-    {ok, ContractStub} = aeso_aci:render_aci_json(JSON),
+            io:format("STUB:\n~s\n", [ContractStub]),
+            check_stub(ContractStub, [{src_file, Name}]),
 
-    io:format("STUB:\n~s\n", [ContractStub]),
-    check_stub(ContractStub, [{src_file, Name}]),
-
-    ok.
+            ok;
+        {error, ErrorString} when is_binary(ErrorString) -> error(ErrorString);
+        {error, Error} -> aeso_compiler_tests:print_and_throw(Error)
+    end.
 
 check_stub(Stub, Options) ->
     try aeso_parser:string(binary_to_list(Stub), Options) of
@@ -122,4 +139,3 @@ check_stub(Stub, Options) ->
         _ = [ io:format("~s\n", [aeso_errors:pp(E)]) || E <- Errs ],
         error({parse_errors, Errs})
     end.
-

test/aeso_calldata_tests.erl

@@ -59,8 +59,8 @@ calldata_aci_test_() ->
         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, ", ") ++ ")"),
+    [{contract_main, _, _, [{letfun, _, _, _, _, {app, _, _, AST}}]}] =
+        aeso_parser:string("main contract Temp = function foo() = " ++ Fun ++ "(" ++ string:join(Args, ", ") ++ ")"),
     strip_ann(AST).
 
 strip_ann(T) when is_tuple(T) ->
@@ -113,6 +113,7 @@ 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", []},
@@ -142,4 +143,4 @@ compilable_contracts() ->
 not_yet_compilable(fate) ->
     [];
 not_yet_compilable(aevm) ->
-    [].
+    ["funargs", "strings"].

test/aeso_compiler_tests.erl

@@ -34,12 +34,10 @@ simple_compile_test_() ->
                #{fate_code := Code} when Backend == fate ->
                    Code1 = aeb_fate_code:deserialize(aeb_fate_code:serialize(Code)),
                    ?assertMatch({X, X}, {Code1, Code});
-               ErrBin ->
-                   io:format("\n~s", [ErrBin]),
-                   error(ErrBin)
+               Error -> io:format("\n\n~p\n\n", [Error]), print_and_throw(Error)
            end
        end} || ContractName <- compilable_contracts(), Backend <- [aevm, fate],
-               not lists:member(ContractName, not_yet_compilable(Backend))] ++
+               not lists:member(ContractName, not_compilable_on(Backend))] ++
     [ {"Test file not found error",
        fun() ->
            {error, Errors} = aeso_compiler:file("does_not_exist.aes"),
@@ -92,6 +90,23 @@ simple_compile_test_() ->
        end} || Backend <- [aevm, fate] ] ++
     [].
 
+%% Check if all modules in the standard library compile
+stdlib_test_() ->
+    {ok, Files} = file:list_dir(aeso_stdlib:stdlib_include_path()),
+    [ { "Testing " ++ File ++ " from the stdlib",
+      fun() ->
+          String = "include \"" ++ File ++ "\"\nmain contract Test =\n  entrypoint f(x) = x",
+          Options = [{src_file, File}, {backend, fate}],
+          case aeso_compiler:from_string(String, Options) of
+              {ok, #{fate_code := Code}} ->
+                  Code1 = aeb_fate_code:deserialize(aeb_fate_code:serialize(Code)),
+                  ?assertMatch({X, X}, {Code1, Code});
+              {error, Error} -> io:format("\n\n~p\n\n", [Error]), print_and_throw(Error)
+          end
+      end} || File <- Files,
+              lists:suffix(".aes", File)
+    ].
+
 check_errors(no_error, Actual) -> ?assertMatch(#{}, Actual);
 check_errors(Expect, #{}) ->
     ?assertEqual({error, Expect}, ok);
@@ -110,7 +125,15 @@ compile(Backend, Name) ->
 
 compile(Backend, Name, Options) ->
     String = aeso_test_utils:read_contract(Name),
-    case aeso_compiler:from_string(String, [{src_file, Name ++ ".aes"}, {backend, Backend} | Options]) of
+    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
         {ok, Map}                                        -> Map;
         {error, ErrorString} when is_binary(ErrorString) -> ErrorString;
         {error, Errors}                                  -> Errors
@@ -146,6 +169,7 @@ compilable_contracts() ->
      "events",
      "include",
      "basic_auth",
+     "basic_auth_tx",
      "bitcoin_auth",
      "address_literals",
      "bytes_equality",
@@ -154,6 +178,7 @@ compilable_contracts() ->
      "bytes_to_x",
      "bytes_concat",
      "aens",
+     "aens_update",
      "tuple_match",
      "cyclic_include",
      "stdlib_include",
@@ -163,13 +188,26 @@ compilable_contracts() ->
      "payable",
      "unapplied_builtins",
      "underscore_number_literals",
+     "pairing_crypto",
      "qualified_constructor",
      "let_patterns",
-     "lhs_matching"
+     "lhs_matching",
+     "more_strings",
+     "protected_call",
+     "hermetization_turnoff",
+     "multiple_contracts",
+     "clone",
+     "clone_simple",
+     "create",
+     "child_contract_init_bug",
+     "test" % Custom general-purpose test file. Keep it last on the list.
     ].
 
-not_yet_compilable(fate) -> [];
-not_yet_compilable(aevm) -> [].
+not_compilable_on(fate) -> [];
+not_compilable_on(aevm) -> compilable_contracts().
+
+debug_mode_contracts() ->
+    ["hermetization_turnoff"].
 
 %% Contracts that should produce type errors
 
@@ -371,15 +409,19 @@ failing_contracts() ->
         [<<?Pos(12, 42)
            "Cannot unify int\n"
            "         and string\n"
-           "when checking the record projection at line 12, column 42\n"
-           "  r.foo : (gas : int, value : int) => Remote.themap\n"
+           "when checking the type of the expression at line 12, column 42\n"
+           "  r.foo() : map(int, string)\n"
            "against the expected type\n"
-           "  (gas : int, value : int) => map(string, int)">>])
-    , ?TYPE_ERROR(bad_include_and_ns,
-        [<<?Pos(2, 11)
-           "Include of 'included.aes' at line 2, column 11\nnot allowed, include only allowed at top level.">>,
-         <<?Pos(3, 13)
-           "Nested namespace not allowed\nNamespace 'Foo' at line 3, column 13 not defined at top level.">>])
+           "  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_address_literals,
         [<<?Pos(11, 5)
            "Cannot unify address\n"
@@ -535,11 +577,15 @@ failing_contracts() ->
          "Cannot unify int\n         and string\nwhen checking the type of the pattern at line 2, column 53\n  x : int\nagainst the expected type\n  string">>
       ])
     , ?TYPE_ERROR(map_as_map_key,
-       [<<?Pos(5, 25)
+       [<<?Pos(5, 47)
          "Invalid key type\n"
          "  map(int, int)\n"
          "Map keys cannot contain other maps.">>,
-        <<?Pos(6, 25)
+        <<?Pos(6, 31)
+         "Invalid key type\n"
+         "  list(map(int, int))\n"
+         "Map keys cannot contain other maps.">>,
+        <<?Pos(6, 31)
          "Invalid key type\n"
          "  lm\n"
          "Map keys cannot contain other maps.">>])
@@ -604,14 +650,52 @@ failing_contracts() ->
          <<?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,
+    , ?TYPE_ERROR(interface_with_defs,
          [<<?Pos(2, 3)
-            "Only the main contract can contain defined functions or entrypoints.\n"
+            "Contract interfaces cannot 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"
@@ -623,6 +707,80 @@ failing_contracts() ->
            "Empty record/map update\n"
            "  r {}">>
         ])
+    , ?TYPE_ERROR(bad_protected_call,
+        [<<?Pos(6, 22)
+           "Invalid 'protected' argument\n"
+           "  (0 : int) == (1 : int) : bool\n"
+           "It must be either 'true' or 'false'.">>
+        ])
+    , ?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'">>])
+    , ?TYPE_ERROR(factories_type_errors,
+                  [<<?Pos(10,18)
+                    "Chain.clone requires `ref` named argument of contract type.">>,
+                   <<?Pos(11,18)
+                     "Cannot unify (gas : int, value : int, protected : bool) => if(protected, option(void), void)\n         and (gas : int, value : int, protected : bool, int, bool) => 'b\n"
+                     "when checking contract construction of type\n  (gas : int, value : int, protected : bool) =>\n    if(protected, option(void), void) (at line 11, column 18)\nagainst the expected type\n  (gas : int, value : int, protected : bool, int, bool) => 'b">>,
+                   <<?Pos(12,37)
+                     "Cannot unify int\n         and bool\n"
+                     "when checking named argument\n  gas : int\nagainst inferred type\n  bool">>,
+                   <<?Pos(13,18),
+                     "Kaboom is not implemented.\n"
+                     "when resolving arguments of variadic function\n  Chain.create">>,
+                   <<?Pos(18,18)
+                     "Cannot unify (gas : int, value : int, protected : bool, int, bool) => if(protected, option(void), void)\n         and (gas : int, value : int, protected : bool) => 'a\n"
+                     "when checking contract construction of type\n  (gas : int, value : int, protected : bool, int, bool) =>\n    if(protected, option(void), void) (at line 18, column 18)\nagainst the expected type\n  (gas : int, value : int, protected : bool) => 'a">>,
+                   <<?Pos(19,42),
+                     "Named argument protected (at line 19, column 42) is not one of the expected named arguments\n  - value : int">>,
+                   <<?Pos(20,42),
+                     "Cannot unify int\n         and bool\n"
+                     "when checking named argument\n  value : int\nagainst inferred type\n  bool">>
+                  ])
+    , ?TYPE_ERROR(ambiguous_main,
+                  [<<?Pos(1,1)
+                    "Could not deduce the main contract. You can point it out manually with the `main` keyword.">>
+                  ])
+    , ?TYPE_ERROR(no_main_contract,
+                  [<<?Pos(0,0)
+                     "No contract defined.">>
+                  ])
+    , ?TYPE_ERROR(multiple_main_contracts,
+                   [<<?Pos(1,6)
+                      "Only one main contract can be defined.">>
+                   ])
     ].
 
 -define(Path(File), "code_errors/" ??File).
@@ -636,9 +794,7 @@ failing_contracts() ->
                        {fate, ?Msg(File, Line, Col, ErrFATE)}]}).
 
 failing_code_gen_contracts() ->
-    [ ?SAME(last_declaration_must_be_contract, 1, 1,
-            "Expected a contract as the last declaration instead of the namespace 'LastDeclarationIsNotAContract'")
-    , ?SAME(missing_definition, 2, 14,
+    [ ?SAME(missing_definition, 2, 14,
             "Missing definition of function 'foo'.")
     , ?AEVM(polymorphic_entrypoint, 2, 17,
             "The argument\n"
@@ -736,6 +892,8 @@ failing_code_gen_contracts() ->
             "Invalid state type\n"
             "  {f : (int) => int}\n"
             "The state cannot contain functions in the AEVM. Use FATE if you need this.")
+    , ?FATE(child_with_decls, 2, 14,
+            "Missing definition of function 'f'.")
     ].
 
 validation_test_() ->
@@ -773,9 +931,26 @@ validation_fails() ->
          "Byte code contract is not payable, but source code contract is.">>]}].
 
 validate(Contract1, Contract2) ->
-    ByteCode = #{ fate_code := FCode } = compile(fate, Contract1),
-    FCode1   = aeb_fate_code:serialize(aeb_fate_code:strip_init_function(FCode)),
-    Source   = aeso_test_utils:read_contract(Contract2),
-    aeso_compiler:validate_byte_code(ByteCode#{ byte_code := FCode1 }, Source,
-                                     [{backend, fate}, {include, {file_system, [aeso_test_utils:contract_path()]}}]).
+    case compile(fate, Contract1) of
+        ByteCode = #{ fate_code := FCode } ->
+            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()]}}]);
+        Error -> print_and_throw(Error)
+    end.
 
+print_and_throw(Err) ->
+    case Err of
+        ErrBin when is_binary(ErrBin) ->
+            io:format("\n~s", [ErrBin]),
+            error(ErrBin);
+        Errors ->
+            io:format("Compilation error:\n~s", [string:join([aeso_errors:pp(E) || E <- Errors], "\n\n")]),
+            error(compilation_error)
+    end.

test/aeso_parser_tests.erl

@@ -12,10 +12,10 @@ simple_contracts_test_() ->
      fun(_) -> ok end,
      [{"Parse a contract with an identity function.",
        fun() ->
-            Text = "contract Identity =\n"
+            Text = "main contract Identity =\n"
                    "  function id(x) = x\n",
             ?assertMatch(
-                [{contract, _, {con, _, "Identity"},
+                [{contract_main, _, {con, _, "Identity"},
                     [{letfun, _, {id, _, "id"}, [{id, _, "x"}], {id, _, "_"},
                         {id, _, "x"}}]}], parse_string(Text)),
             ok
@@ -63,7 +63,8 @@ simple_contracts_test_() ->
      %% Parse tests of example contracts
      [ {lists:concat(["Parse the ", Contract, " contract."]),
         fun() -> roundtrip_contract(Contract) end}
-        || Contract <- [counter, voting, all_syntax, '05_greeter', aeproof, multi_sig, simple_storage, fundme, dutch_auction] ]
+        || Contract <- [counter, voting, all_syntax, '05_greeter', aeproof,
+                        multi_sig, simple_storage, fundme, dutch_auction, utf8] ]
     }.
 
 parse_contract(Name) ->
@@ -85,7 +86,7 @@ parse_expr(Text) ->
 round_trip(Text) ->
     Contract  = parse_string(Text),
     Text1     = prettypr:format(aeso_pretty:decls(strip_stdlib(Contract))),
-    Contract1 = parse_string(Text1),
+    Contract1 = parse_string(aeso_scan:utf8_encode(Text1)),
     NoSrcLoc  = remove_line_numbers(Contract),
     NoSrcLoc1 = remove_line_numbers(Contract1),
     ?assertMatch(NoSrcLoc, diff(NoSrcLoc, NoSrcLoc1)).

test/contracts/05_greeter.aes

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

test/contracts/__call.aes

@@ -1,5 +1,5 @@
 
 contract Identity =
-  function main (x:int) = x
+  function main_fun (x:int) = x
 
   function __call() = 12

test/contracts/address_chain.aes

@@ -1,5 +1,5 @@
-contract Remote =
-  entrypoint main : (int) => unit
+contract interface Remote =
+  entrypoint main_fun : (int) => unit
 
 contract AddrChain =
   type o_type = oracle(string, map(string, int))

test/contracts/address_literals.aes

@@ -1,5 +1,5 @@
 
-contract Remote =
+contract interface Remote =
   entrypoint foo : () => unit
 
 contract AddressLiterals =

test/contracts/aens.aes

@@ -33,7 +33,22 @@ contract AENSTest =
                                 sign : signature) : unit =
     AENS.claim(addr, name, salt, name_fee, signature = sign)
 
-  // TODO: update() -- how to handle pointers?
+
+  stateful entrypoint update(owner      : address,
+                             name       : string,
+                             ttl        : option(Chain.ttl),
+                             client_ttl : option(int),
+                             pointers   : option(map(string, AENS.pointee))) : unit =
+    AENS.update(owner, name, ttl, client_ttl, pointers)
+
+  stateful entrypoint signedUpdate(owner      : address,
+                                   name       : string,
+                                   ttl        : option(Chain.ttl),
+                                   client_ttl : option(int),
+                                   pointers   : option(map(string, AENS.pointee)),
+                                   sign       : signature) : unit =
+    AENS.update(owner, name, ttl, client_ttl, pointers, signature = sign)
+
 
   stateful entrypoint transfer(owner     : address,
                              new_owner : address,

test/contracts/aens_update.aes

@@ -0,0 +1,17 @@
+contract AENSUpdate =
+  stateful entrypoint update_name(owner : address, name : string) =
+    let p1 : AENS.pointee = AENS.AccountPt(Call.caller)
+    let p2 : AENS.pointee = AENS.OraclePt(Call.caller)
+    let p3 : AENS.pointee = AENS.ContractPt(Call.caller)
+    let p4 : AENS.pointee = AENS.ChannelPt(Call.caller)
+    AENS.update(owner, name, None, None,
+                Some({ ["account_pubkey"] = p1, ["oracle_pubkey"] = p2,
+                       ["contract_pubkey"] = p3, ["misc"] = p4 }))
+
+  entrypoint get_ttl(name : string) =
+    switch(AENS.lookup(name))
+     Some(AENS.Name(_, FixedTTL(ttl), _)) => ttl
+
+  entrypoint expiry(o : oracle(int, int)) : int =
+    Oracle.expiry(o)
+

test/contracts/all_syntax.aes

@@ -1,44 +1,82 @@
 // 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
     */
-  function foo : _
+  stateful function foo : _
+  entrypoint bar : int => (int * 'a)
+
 
 contract AllSyntax =
 
-  type typeDecl = int
-  type paramTypeDecl('a, 'b) = (('a, 'b) => 'b) => list('a) => 'b => 'b
+  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)
 
-  record nestedRecord = { x : int }
-  record recordType = { z : nestedRecord, y : int }
-  datatype variantType('a) = None | Some('a)
+  type state = shakespeare(int)
 
-  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)
+  entrypoint init() = {
+    johann = 1000,
+    wolfgang = -10,
 
-  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 :: _) => ()
+/* TODO: This does not compile because of bug in the parser tester.
+    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)
+                                 ])),
+*/
+    von = (2 + 2, 0, List.sum([1,2,3,4])),
+    goethe = () }
 
-  let hash : address = #01ab0fff11
-  let b = false
-  let qcon = Mod.Con
-  let str = "blabla\nfoo"
-  let chr = '"'
+  function f() =
+     let kp = "nietzsche"
+     // let p = "Пушкин" // TODO: this also doesn't do right round_trip...
+     let k(x : bytes(8)) : bytes(8) = Bytes.to_int(#fedcba9876543210)
 
+     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 sh : shakespeare(shakespeare(int)) =
+       {wolfgang = state}
+     sh{wolfgang.wolfgang = sh.wolfgang} // comment

test/contracts/ambiguous_main.aes

@@ -0,0 +1,5 @@
+contract C =
+  entrypoint f() = 123
+
+contract D =
+  entrypoint f() = 123

test/contracts/bad_address_literals.aes

@@ -1,5 +1,5 @@
 
-contract Remote =
+contract interface Remote =
   entrypoint foo : () => unit
 
 contract AddressLiterals =

test/contracts/bad_arity.aes

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

test/contracts/bad_function_block.aes

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

test/contracts/bad_number_of_args.aes

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

@@ -0,0 +1,6 @@
+contract interface Remote =
+  entrypoint id : int => int
+
+contract ProtectedCall =
+  entrypoint bad(r : Remote) =
+    r.id(protected = 0 == 1, 18)

test/contracts/bad_state.aes

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

test/contracts/bad_top_level_decl.aes

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

test/contracts/bad_unnamed_map_update_default.aes

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

test/contracts/basic_auth_tx.aes

@@ -0,0 +1,74 @@
+// namespace Chain =
+//   record tx = { paying_for : option(Chain.paying_for_tx)
+//               , ga_metas : list(Chain.ga_meta_tx)
+//               , actor : address
+//               , fee   : int
+//               , ttl   : int
+//               , tx    : Chain.base_tx }
+
+//   datatype ga_meta_tx = GAMetaTx(address, int)
+//   datatype paying_for_tx = PayingForTx(address, int)
+//   datatype base_tx = SpendTx(address, int, string)
+//                    | OracleRegisterTx | OracleQueryTx | OracleResponseTx | OracleExtendTx
+//                    | NamePreclaimTx | NameClaimTx(hash) | NameUpdateTx(string)
+//                    | NameRevokeTx(hash) | NameTransferTx(address, string)
+//                    | ChannelCreateTx(address) | ChannelDepositTx(address, int) | ChannelWithdrawTx(address, int) |
+//                    | ChannelForceProgressTx(address) | ChannelCloseMutualTx(address) | ChannelCloseSoloTx(address)
+//                    | ChannelSlashTx(address) | ChannelSettleTx(address) | ChannelSnapshotSoloTx(address)
+//                    | ContractCreateTx(int) | ContractCallTx(address, int)
+//                    | GAAttachTx
+
+
+// Contract replicating "normal" Aeternity authentication
+contract BasicAuthTx =
+  record state = { nonce : int, owner : address }
+  datatype foo = Bar | Baz()
+
+  entrypoint init() = { nonce = 1, owner = Call.caller }
+
+  stateful entrypoint authorize(n : int, s : signature) : bool =
+    require(n >= state.nonce, "Nonce too low")
+    require(n =< state.nonce, "Nonce too high")
+    put(state{ nonce = n + 1 })
+    switch(Auth.tx_hash)
+      None          => abort("Not in Auth context")
+      Some(tx_hash) =>
+        let Some(tx0) = Auth.tx
+        let x : option(Chain.paying_for_tx) = tx0.paying_for
+        let x : list(Chain.ga_meta_tx) = tx0.ga_metas
+        let x : int = tx0.fee + tx0.ttl
+        let x : address = tx0.actor
+        let x : Chain.tx = { tx = Chain.NamePreclaimTx, paying_for = None, ga_metas = [],
+                             fee = 123, ttl = 0, actor = Call.caller }
+        switch(tx0.tx)
+          Chain.SpendTx(receiver, amount, payload) => verify(tx_hash, n, s)
+          Chain.OracleRegisterTx                   => false
+          Chain.OracleQueryTx                      => false
+          Chain.OracleResponseTx                   => false
+          Chain.OracleExtendTx                     => false
+          Chain.NamePreclaimTx                     => false
+          Chain.NameClaimTx(name)                  => false
+          Chain.NameUpdateTx(name)                 => false
+          Chain.NameRevokeTx(name)                 => false
+          Chain.NameTransferTx(to, name)           => false
+          Chain.ChannelCreateTx(other_party)       => false
+          Chain.ChannelDepositTx(channel, amount)  => false
+          Chain.ChannelWithdrawTx(channel, amount) => false
+          Chain.ChannelForceProgressTx(channel)    => false
+          Chain.ChannelCloseMutualTx(channel)      => false
+          Chain.ChannelCloseSoloTx(channel)        => false
+          Chain.ChannelSlashTx(channel)            => false
+          Chain.ChannelSettleTx(channel)           => false
+          Chain.ChannelSnapshotSoloTx(channel)     => false
+          Chain.ContractCreateTx(amount)           => false
+          Chain.ContractCallTx(ct_address, amount) => false
+          Chain.GAAttachTx                         => false
+
+  function verify(tx_hash, n, s) =
+    Crypto.verify_sig(to_sign(tx_hash, n), state.owner, s)
+
+  entrypoint to_sign(h : hash, n : int) =
+    Crypto.blake2b((h, n))
+
+  entrypoint weird_string() : string =
+    "\x19Weird String\x42\nMore\n"

test/contracts/bytes_to_x.aes

@@ -1,4 +1,4 @@
-
+include "String.aes"
 contract BytesToX =
 
   entrypoint to_int(b : bytes(42)) : int = Bytes.to_int(b)

test/contracts/channel_on_chain_contract_oracle.aes

@@ -17,7 +17,7 @@ contract ChannelOnChainContractOracle =
       bets     = {}
       }
 
-  public stateful function place_bet(answer: string) = 
+  public stateful function place_bet(answer: string) =
     switch(Map.lookup(answer, state.bets))
       None =>
         put(state{ bets = state.bets{[answer] = Call.caller}})
@@ -25,6 +25,9 @@ contract ChannelOnChainContractOracle =
       Some(_value) =>
         "bet_already_taken"
 
+  public function expiry() =
+    Oracle.expiry(state.oracle)
+
   public function query_fee() =
     Oracle.query_fee(state.oracle)
 
@@ -35,7 +38,7 @@ contract ChannelOnChainContractOracle =
     switch(Oracle.get_answer(state.oracle, q))
       None         =>
         "no response"
-      Some(result) => 
+      Some(result) =>
         if(state.question == Oracle.get_question(state.oracle, q))
             switch(Map.lookup(result, state.bets))
               None         =>

test/contracts/child_contract_init_bug.aes

@@ -0,0 +1,8 @@
+contract Identity =
+  record state = {foo: int, bar: string}
+  entrypoint init() = {foo = 0, bar = ""}
+
+main contract IdentityService =
+  stateful entrypoint createNewIdentity() : Identity =
+    put(())
+    Chain.create()

test/contracts/clone.aes

@@ -0,0 +1,28 @@
+
+contract interface HigherOrderState =
+  entrypoint init : () => void
+  entrypoint apply : int => int
+  stateful entrypoint inc : int => unit
+
+contract interface LowerDisorderAnarchy =
+  entrypoint init : (int) => void
+
+
+main contract C =
+  // both `s` and `l` should be of type `HigherOrderState` in this test
+  stateful entrypoint run_clone(s : HigherOrderState, l : LowerDisorderAnarchy) : HigherOrderState =
+    let s1 = Chain.clone(ref=s)
+    let Some(s2) = Chain.clone(ref=s, protected=true)
+    let None = Chain.clone(ref=s, protected=true, gas=1)
+    let None = Chain.clone(ref=l, protected=true, 123) // since it should be HigherOrderState underneath
+    let s3 = Chain.clone(ref=s1)
+    require(s1.apply(2137) == 2137, "APPLY_S1_0")
+    require(s2.apply(2137) == 2137, "APPLY_S2_0")
+    require(s3.apply(2137) == 2137, "APPLY_S3_0")
+    s1.inc(1)
+    s2.inc(1)
+    s1.inc(1)
+    require(s1.apply(2137) == 2139, "APPLY_S1_2")
+    require(s2.apply(2137) == 2138, "APPLY_S2_1")
+    require(s3.apply(2137) == 2137, "APPLY_S3_0")
+    s1

test/contracts/clone_simple.aes

@@ -0,0 +1,7 @@
+contract interface I =
+  entrypoint init : () => void
+
+contract C =
+  stateful entrypoint f(i : I) =
+    let Some(c1) = Chain.clone(ref=i, protected = true)
+    2

test/contracts/code_errors/bad_aens_resolve.aes

@@ -5,5 +5,5 @@ contract BadAENSresolve =
   function fail() : t(int) =
     AENS.resolve("foo.aet", "whatever")
 
-  entrypoint main() = ()
+  entrypoint main_fun() = ()
 

test/contracts/code_errors/child_with_decls.aes

@@ -0,0 +1,5 @@
+contract C =
+  entrypoint f : () => unit
+
+main contract M =
+  entrypoint f() = 123

test/contracts/code_errors/higher_order_map_keys.aes

@@ -3,4 +3,4 @@ contract MapAsMapKey =
 
   function foo(m) : t(int => int) = {[m] = 0}
 
-  entrypoint main() = ()
+  entrypoint main_fun() = ()

test/contracts/code_errors/higher_order_query_type.aes

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

test/contracts/code_errors/higher_order_response_type.aes

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

test/contracts/code_errors/last_declaration_must_be_contract.aes

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

test/contracts/code_errors/missing_definition.aes

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

test/contracts/code_errors/polymorphic_aens_resolve.aes

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

test/contracts/code_errors/polymorphic_map_keys.aes

@@ -3,4 +3,4 @@ contract MapAsMapKey =
 
   function foo(m) : t('a) = {[m] = 0}
 
-  entrypoint main() = ()
+  entrypoint main_fun() = ()

test/contracts/code_errors/polymorphic_query_type.aes

@@ -2,4 +2,4 @@ contract PolymorphicQueryType =
   stateful function is_oracle(o) =
     Oracle.check(o)
 
-  entrypoint main() = ()
+  entrypoint main_fun() = ()

test/contracts/code_errors/polymorphic_response_type.aes

@@ -2,4 +2,4 @@ contract PolymorphicResponseType =
   function is_oracle(o : oracle(string, 'r)) =
     Oracle.check(o)
 
-  entrypoint main(o : oracle(string, int)) = is_oracle(o)
+  entrypoint main_fun(o : oracle(string, int)) = is_oracle(o)

test/contracts/code_errors/unapplied_contract_call.aes

@@ -1,4 +1,4 @@
-contract Remote =
+contract interface Remote =
   entrypoint foo : int => int
 
 contract UnappliedContractCall =

test/contracts/code_errors/unapplied_named_arg_builtin.aes

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

test/contracts/complex_types.aes

@@ -1,5 +1,5 @@
 
-contract Remote =
+contract interface Remote =
   entrypoint up_to       : (int)               => list(int)
   entrypoint sum         : (list(int))         => int
   entrypoint some_string : ()                  => string

test/contracts/contract_as_namespace.aes

@@ -1,4 +1,4 @@
-contract Foo =
+contract interface Foo =
   entrypoint foo : () => int
 
 contract Fail =

test/contracts/create.aes

@@ -0,0 +1,28 @@
+contract IntegerAdder =
+  entrypoint init() = ()
+  entrypoint addIntegers(x, y) = x + y
+
+contract IntegerAdderHolder =
+  type state = IntegerAdder
+  stateful entrypoint init() = Chain.create() : IntegerAdder
+  entrypoint get() = state
+
+contract IntegerAdderFactory =
+  entrypoint init() = ()
+  stateful entrypoint new() =
+    let i = Chain.create() : IntegerAdderHolder
+    i.get()
+
+payable contract ValueAdder =
+  entrypoint init() = ()
+  stateful entrypoint addValue(x) =
+    let integerAdderFactory = Chain.create()
+    let adder = integerAdderFactory.new()
+    adder.addIntegers(x, Contract.balance)
+
+main contract EnterpriseContract =
+  entrypoint init() = ()
+  stateful payable entrypoint increaseByThree(x) =
+    require(Call.value >= 3, "Price for addition = 3AEtto, insufficient funds")
+    let threeAdder = Chain.create(value = 3)
+    threeAdder.addValue(x)

test/contracts/empty_typedecl.aes

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

test/contracts/environment.aes

@@ -1,6 +1,6 @@
 
 // Testing primitives for accessing the block chain environment
-contract Interface =
+contract interface Interface =
   entrypoint contract_address : () => address
   entrypoint call_origin      : () => address
   entrypoint call_caller      : () => address
@@ -44,6 +44,9 @@ contract Environment =
   // Gas price
   entrypoint call_gas_price() : int = Call.gas_price
 
+  // Fee
+  entrypoint call_fee() : int = Call.fee
+
   // -- Information about the chain ---
 
   // Account balances

test/contracts/events.aes

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

test/contracts/factorial.aes

@@ -1,6 +1,6 @@
 // An implementation of the factorial function where each recursive
 // call is to another contract. Not the cheapest way to compute factorial.
-contract FactorialServer =
+contract interface FactorialServer =
   entrypoint fac : (int) => int
 
 contract Factorial =

test/contracts/factories_type_errors.aes

@@ -0,0 +1,24 @@
+contract interface Kaboom =
+  entrypoint init : () => void
+
+contract Bakoom =
+  type state = int
+  entrypoint init(x, b) = if(b) x else 0
+
+main contract Test =
+  stateful entrypoint test(k : Kaboom) =
+    let k_bad1 = Chain.clone() : Kaboom
+    let k_bad2 = Chain.clone(ref=k, 123, true)
+    let k_bad3 = Chain.clone(ref=k, gas=true)
+    let k_bad4 = Chain.create() : Kaboom
+    let k_gud1 = Chain.clone(ref=k)
+    let Some(k_gud2) = Chain.clone(ref=k, protected=true)
+    let Some(k_gud3) = Chain.clone(ref=k, value=10, protected=true, gas=123)
+
+    let b_bad1 = Chain.create() : Bakoom
+    let b_bad2 = Chain.create(123, true, protected=true) : Bakoom
+    let b_bad3 = Chain.create(123, true, value=true) : Bakoom
+    let b_gud1 = Chain.create(123, true) : Bakoom
+    let b_gud2 = Chain.create(123, true, value=100) : Bakoom
+
+    b_gud1

test/contracts/funargs.aes

@@ -1,4 +1,4 @@
-
+include "String.aes"
 contract FunctionArguments =
 
   entrypoint sum(n : int, m: int) =
@@ -45,3 +45,8 @@ 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

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

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

test/contracts/identity.aes

@@ -1,3 +1,2 @@
-
-contract Identity =
-  entrypoint main (x:int) = x
+main contract Identity =
+  entrypoint main_fun (x:int) = x

test/contracts/interface_with_defs.aes

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

test/contracts/lhs_matching.aes

@@ -16,7 +16,7 @@ contract LHSMatching =
     let null(_ :: _) = false
     !null(xs)
 
-  entrypoint main() =
+  entrypoint main_fun() =
     from_some(Some([0]))
       ++ append([length([true]), 2, 3], [4, 5, 6])
       ++ [7 | if (local_match([false]))]

test/contracts/missing_event_type.aes

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

test/contracts/more_strings.aes

@@ -0,0 +1,14 @@
+include "String.aes"
+contract StringX =
+  entrypoint test() =
+    let s1 = "a string"
+    let s2 = "another string"
+    let s  = String.concat(s1, s2)
+    String.sha256(s)
+    String.length(s1)
+    String.from_list(String.to_list(s))
+    String.split(4, s1)
+    String.at(2, s2)
+    String.tokens(s, ",")
+    String.to_upper(s1)
+    String.to_lower(s2)

test/contracts/multi_sig.aes

@@ -15,7 +15,7 @@ contract MultiSig =
       | OwnerRemoved (address)          // of { .removedOwner : Address }
       | ReqChanged   (int)             // of { .newReq : int }
 
-    let maxOwners : int = 250
+    function 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 +1,7 @@
-contract ContractOne =
-  entrypoint foo() = "foo"
+contract Child =
+  entrypoint
+        add2 : int => int
+        add2(x) = x + 2
 
-contract ContractTwo =
-  entrypoint bar() = "bar"
+main contract Main =
+  entrypoint add4(x, c : Child) = c.add2(x) + 2

test/contracts/multiple_main_contracts.aes

@@ -0,0 +1,5 @@
+main contract C =
+  entrypoint f() = 123
+
+main contract D =
+  entrypoint f() = 123

test/contracts/no_main_contract.aes

@@ -0,0 +1,2 @@
+contract interface C =
+  entrypoint f : () => unit

test/contracts/non_functional_entrypoint.aes

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

test/contracts/not_toplevel_contract.aes

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

test/contracts/not_toplevel_include.aes

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

test/contracts/not_toplevel_namespace.aes

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

test/contracts/pairing_crypto.aes

@@ -0,0 +1,30 @@
+include "BLS12_381.aes"
+
+contract GrothVerify =
+  type fr = BLS12_381.fr
+  type g1 = BLS12_381.g1
+  type g2 = BLS12_381.g2
+
+  record proof = { a : g1, b : g2, c : g1 }
+  record verify_key = { a : g1, b : g2, c : g2, d : g2, ic : list(g1) }
+
+  record state = { vk : verify_key }
+
+  entrypoint init(vk0 : verify_key) = {vk = vk0}
+
+  entrypoint verify_proof(p : proof, input : list(fr)) =
+    let vk = state.vk
+    let vk_x = calc_vk_x(vk.ic, input)
+
+    BLS12_381.pairing_check([BLS12_381.g1_neg(p.a), vk.a, vk_x, p.c],
+                            [p.b, vk.b, vk.c, vk.d])
+
+  function calc_vk_x(ics : list(g1), xs : list(fr)) =
+    switch(ics)
+      (ic :: ics) => calc_vk_x_(ic, ics, xs)
+
+  function calc_vk_x_(vk_x : g1, ics : list(g1), xs : list(fr)) =
+    switch((ics, xs))
+      ([], []) => vk_x
+      (ic :: ics, x :: xs) => calc_vk_x_(BLS12_381.g1_add(vk_x, BLS12_381.g1_mul(x, ic)), ics, xs)
+

test/contracts/protected_call.aes

@@ -0,0 +1,14 @@
+contract interface Remote =
+  entrypoint id : int => int
+
+contract ProtectedCall =
+
+  function higher_order(r : Remote) =
+    r.id
+
+  entrypoint test_ok(r : Remote) =
+    let f = higher_order(r)
+    let Some(n) = r.id(protected = true, 10)
+    let Some(m) = f(protected = true, 5)
+    n + m + r.id(protected = false, 100) + f(1)
+