Merge pull request #150 from aeternity/fix_changelog

Fix CHANGELOG

.circleci/config.yml

@@ -0,0 +1,37 @@
+version: 2.1
+
+executors:
+  aebuilder:
+    docker:
+      - image: aeternity/builder
+        user: builder
+    working_directory: ~/aesophia
+
+jobs:
+  build:
+    executor: aebuilder
+    steps:
+      - checkout
+      - restore_cache:
+          keys:
+            - dialyzer-cache-v2-{{ .Branch }}-{{ .Revision }}
+            - dialyzer-cache-v2-{{ .Branch }}-
+            - dialyzer-cache-v2-
+      - run:
+          name: Build
+          command: ./rebar3 compile
+      - run:
+          name: Static Analysis
+          command: ./rebar3 dialyzer
+      - run:
+          name: Eunit
+          command: ./rebar3 eunit
+      - run:
+          name: Common Tests
+          command: ./rebar3 ct
+      - save_cache:
+          key: dialyzer-cache-v2-{{ .Branch }}-{{ .Revision }}
+          paths:
+            - _build/default/rebar3_20.3.8_plt
+      - store_artifacts:
+          path: _build/test/logs

.gitignore

@@ -1,5 +1,5 @@
 .rebar3
-_*
+_[^_]*
 .eunit
 *.o
 *.beam
@@ -16,3 +16,8 @@ _build
 .idea
 *.iml
 rebar3.crashdump
+*.erl~
+*.aes~
+aesophia
+.qcci
+current_counterexample.eqc

CHANGELOG.md

@@ -0,0 +1,164 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+### Added
+### Changed
+### Removed
+
+## [4.0.0-rc3] - 2019-09-12
+### Added
+- `Bytes.concat` and `Bytes.split` are added to be able to
+  (de-)construct byte arrays.
+- `[a..b]` language construct, returning the list of numbers between
+  `a` and `b` (inclusive). Returns the empty list if `a` > `b`.
+- [Standard libraries] (https://github.com/aeternity/protocol/blob/master/contracts/sophia_stdlib.md)
+- Checks that `init` is not called from other functions.
+### Changed
+- Error messages are changed into a uniform format, and more helpful
+  messages have been added.
+- `Crypto.<hash_fun>` and `String.<hash_fun>` for byte arrays now only
+  hash the actual byte array - not the internal ABI format.
+- More strict checks for polymorphic oracles and higher order oracles
+  and entrypoints.
+- `AENS.claim` is updated with a `NameFee` field - to be able to do
+  name auctions within contracts.
+- Fixed a bug in `Bytes.to_str` for AEVM.
+### Removed
+
+## [4.0.0-rc1] - 2019-08-22
+### Added
+- FATE backend - the compiler is able to produce VM code for both `AEVM` and `FATE`. Many
+  of the APIs now take `{backend, aevm | fate}` to decide wich backend to produce artifacts
+  for.
+- New builtin functions `Crypto.ecrecover_secp256k1: (hash, bytes(65)) => option(bytes(20))`
+  and `Crypto.ecverify_secp256k1 : (hash, bytes(20), bytes(65)) => bool` for recovering
+  and verifying an Ethereum address for a message hash and a signature.
+- Sophia supports list comprehensions known from languages like Python, Haskell or Erlang.
+  Example syntax:
+```
+[x + y | x <- [1,2,3,4,5], let k = x*x, if (k > 5), y <- [k, k+1, k+2]]
+// yields [12,13,14,20,21,22,30,31,32]
+```
+- A new contract, and endpoint, modifier `payable` is introduced. Contracts, and enpoints,
+  that shall be able to receive funds should be marked as payable. `Address.is_payable(a)`
+  can be used to check if an (contract) address is payable or not.
+### Changed
+- New syntax for tuple types. Now 0-tuple type is encoded as `unit` instead of `()` and
+  regular tuples are encoded by interspersing inner types with `*`, for instance `int * string`.
+  Parens are not necessary. Note it only affects the types, values remain as their were before,
+  so `(1, "a") : int * string`
+- The `AENS.transfer` and `AENS.revoke` functions have been updated to take a name `string`
+  instead of a name `hash`.
+- Fixed a bug where the `AEVM` backend complained about a missing `init` function when
+  trying to generate calldata from an ACI-generated interface.
+- Compiler now returns the ABI-version in the compiler result map.
+- Renamed `Crypto.ecverify` and `Crypto.ecverify_secp256k1` into `Crypto.verify_sig` and
+  `Crypto.verify_sig_secp256k1` respectively.
+### Removed
+
+## [3.2.0] - 2019-06-28
+### Added
+- New builtin function `require : (bool, string) => ()`. Defined as
+    ```
+    function require(b, err) = if(!b) abort(err)
+    ```
+- New builtin functions
+    ```
+    Bytes.to_str : bytes(_) => string
+    Bytes.to_int : bytes(_) => int
+    ```
+  for converting a byte array to a hex string and interpreting it as a
+  big-endian encoded integer respectively.
+### Changed
+- Public contract functions must now be declared as *entrypoints*:
+  ```
+  contract Example =
+    // Exported
+    entrypoint exported_fun(x) = local_fun(x)
+    // Not exported
+    function local_fun(x) = x
+  ```
+  Functions in namespaces still use `function` (and `private function` for
+  private functions).
+- The return type of `Chain.block_hash(height)` has changed, it used to
+  be `int`, where `0` denoted an incorrect height. New return type is
+  `option(hash)`, where `None` represents an incorrect height.
+- Event name hashes now use BLAKE2b instead of Keccak256.
+- Fixed bugs when defining record types in namespaces.
+- Fixed a bug in include path handling when passing options to the compiler.
+### Removed
+
+## [3.1.0] - 2019-06-03
+### Added
+### Changed
+- Keyword `indexed` is now optional for word typed (`bool`, `int`, `address`,
+  ...) event arguments.
+- State variable pretty printing now produce `'a, 'b, ...` instead of `'1, '2, ...`.
+- ACI is restructured and improved:
+    - `state` and `event` types (if present) now appear at the top level.
+    - Namespaces and remote interfaces are no longer ignored.
+    - All type definitions are included in the interface rendering.
+    - API functions are renamed, new functions are `contract_interface`
+      and `render_aci_json`.
+- Fixed a bug in `create_calldata`/`to_sophia_value` - it can now handle negative
+  literals.
+### Removed
+
+## [3.0.0] - 2019-05-21
+### Added
+- `stateful` annotations are now properly enforced. Functions must be marked stateful
+  in order to update the state or spend tokens.
+- Primitives `Contract.creator`, `Address.is_contract`, `Address.is_oracle`,
+  `Oracle.check` and `Oracle.check_query` has been added to Sophia.
+- A byte array type `bytes(N)` has been added to generalize `hash (== bytes(32))` and
+  `signature (== bytes(64))` and allow for byte arrays of arbitrary fixed length.
+- `Crypto.ecverify_secp256k1` has been added.
+### Changed
+- Address literals (+ Oracle, Oracle query and remote contracts) have been changed
+  from `#<hex>` to address as `ak_<base58check>`, oracle `ok_<base58check>`,
+  oracle query `oq_<base58check>` and remote contract `ct_<base58check>`.
+- The compilation and typechecking of `letfun` (e.g. `let m(f, xs) = map(f, xs)`) was
+  not working properly and has been fixed.
+### Removed
+- `let rec` has been removed from the language, it has never worked.
+- The standalone CLI compiler is served in the repo `aeternity/aesophia_cli` and has
+  been completely removed from `aesophia`.
+
+## [2.1.0] - 2019-04-11
+### Added
+- Stubs (not yet wired up) for compilation to FATE
+- Add functions specific for Calldata decoding
+- Support for `Auth.tx_hash`, not available in AEVM until Fortuna release
+
+### Changed
+- Improvements to the ACI generator
+
+## [2.0.0] - 2019-03-11
+### Added
+- Add `Crypto.ecverify` to the compiler.
+- Add `Crypto.sha3`, `Crypto.blake2`, `Crypto.sha256`, `String.blake2` and
+  `String.sha256` to the compiler.
+- Add the `bits` type for working with bit fields in Sophia.
+- Add Namespaces to Sophia in order to simplify using library contracts, etc.
+- Add a missig type check on the `init` function - detects programmer errors earlier.
+- Add the ACI (Aeternity Contract Interface) generator.
+
+### Changed
+- Use native bit shift operations in builtin functions, reducing gas cost.
+- Improve type checking of `record` fields - generates more understandable error messages.
+- Improved, more coherent, error messages.
+- Simplify calldata creation - instead of passing a compiled contract, simply
+  pass a (stubbed) contract string.
+
+[Unreleased]: https://github.com/aeternity/aesophia/compare/v4.0.0-rc3...HEAD
+[4.0.0-rc3]: https://github.com/aeternity/aesophia/compare/v4.0.0-rc1...v4.0.0-rc3
+[4.0.0-rc1]: https://github.com/aeternity/aesophia/compare/v3.2.0...v4.0.0-rc1
+[3.2.0]: https://github.com/aeternity/aesophia/compare/v3.1.0...v3.2.0
+[3.1.0]: https://github.com/aeternity/aesophia/compare/v3.0.0...v3.1.0
+[3.0.0]: https://github.com/aeternity/aesophia/compare/v2.1.0...v3.0.0
+[2.1.0]: https://github.com/aeternity/aesophia/compare/v2.0.0...v2.1.0
+[2.0.0]: https://github.com/aeternity/aesophia/tag/v2.0.0

README.md

@@ -5,6 +5,21 @@ This is the __sophia__ compiler for the æternity system which compiles contract
 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).
 
 It is an OTP application written in Erlang and is by default included in
-[æternity Epoch](https://github.com/aeternity/epoch). However, it can
+[the æternity node](https://github.com/aeternity/epoch). However, it can
-also be included in other system to compile contracts coded in sophia which
+also be included in other systems to compile contracts coded in sophia which
 can then be loaded into the æternity system.
+
+## 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.
+
+## Interface Modules
+
+The basic modules for interfacing the compiler:
+
+* [aeso_compiler: the Sophia compiler](./docs/aeso_compiler.md)
+* [aeso_aci: the ACI interface](./docs/aeso_aci.md)

docs/aeso_aci.md

@@ -0,0 +1,156 @@
+# aeso_aci
+
+### Module
+
+### aeso_aci
+
+The ACI interface encoder and decoder.
+
+### Description
+
+This module provides an interface to generate and convert between
+Sophia contracts and a suitable JSON encoding of contract
+interface. As yet the interface is very basic.
+
+Encoding this contract:
+
+```
+contract Answers =
+  record state = { a : answers }
+  type answers() = map(string, int)
+
+  stateful function init() = { a = {} }
+  private function the_answer() = 42
+  function new_answer(q : string, a : int) : answers() = { [q] = a }
+```
+
+generates the following JSON structure representing the contract interface:
+
+
+``` json
+{
+  "contract": {
+    "functions": [
+      {
+        "arguments": [],
+        "name": "init",
+        "returns": "Answers.state",
+        "stateful": true
+      },
+      {
+        "arguments": [
+          {
+            "name": "q",
+            "type": "string"
+          },
+          {
+            "name": "a",
+            "type": "int"
+          }
+        ],
+        "name": "new_answer",
+        "returns": {
+          "map": [
+            "string",
+            "int"
+          ]
+        },
+        "stateful": false
+      }
+    ],
+    "name": "Answers",
+    "state": {
+      "record": [
+        {
+          "name": "a",
+          "type": "Answers.answers"
+        }
+      ]
+    },
+    "type_defs": [
+      {
+        "name": "answers",
+        "typedef": {
+          "map": [
+            "string",
+            "int"
+          ]
+        },
+        "vars": []
+      }
+    ]
+  }
+}
+```
+
+When that encoding is decoded the following include definition is generated:
+
+```
+contract Answers =
+  record state = {a : Answers.answers}
+  type answers = map(string, int)
+  function init : () => Answers.state
+  function new_answer : (string, int) => map(string, int)
+```
+
+### Types
+```erlang
+-type aci_type()  :: json | string.
+-type json()      :: jsx:json_term().
+-type json_text() :: binary().
+```
+
+### Exports
+
+#### contract\_interface(aci\_type(), string()) -> {ok, json() | string()} | {error, term()}
+
+Generate the JSON encoding of the interface to a contract. The type definitions
+and non-private functions are included in the JSON string.
+
+#### render\_aci\_json(json() | json\_text()) -> string().
+
+Take a JSON encoding of a contract interface and generate a contract interface
+that can be included in another contract.
+
+### Example run
+
+This is an example of using the ACI generator from an Erlang shell. The file
+called `aci_test.aes` contains the contract in the description from which we
+want to generate files `aci_test.json` which is the JSON encoding of the
+contract interface and `aci_test.include` which is the contract definition to
+be included inside another contract.
+
+``` erlang
+1> {ok,Contract} = file:read_file("aci_test.aes").
+{ok,<<"contract Answers =\n  record state = { a : answers }\n  type answers() = map(string, int)\n\n  stateful function"...>>}
+2> {ok,JsonACI} = aeso_aci:contract_interface(json, Contract).
+{ok,[#{contract =>
+           #{functions =>
+                 [#{arguments => [],name => <<"init">>,
+                    returns => <<"Answers.state">>,stateful => true},
+                  #{arguments =>
+                        [#{name => <<"q">>,type => <<"string">>},
+                         #{name => <<"a">>,type => <<"int">>}],
+                    name => <<"new_answer">>,
+                    returns => #{<<"map">> => [<<"string">>,<<"int">>]},
+                    stateful => false}],
+             name => <<"Answers">>,
+             state =>
+                 #{record =>
+                       [#{name => <<"a">>,type => <<"Answers.answers">>}]},
+             type_defs =>
+                 [#{name => <<"answers">>,
+                    typedef => #{<<"map">> => [<<"string">>,<<"int">>]},
+                    vars => []}]}}]}
+3> file:write_file("aci_test.aci", jsx:encode(JsonACI)).
+ok
+4> {ok,InterfaceStub} = aeso_aci:render_aci_json(JsonACI).
+{ok,<<"contract Answers =\n  record state = {a : Answers.answers}\n  type answers = map(string, int)\n  function init "...>>}
+5> file:write_file("aci_test.include", InterfaceStub).
+ok
+6> jsx:prettify(jsx:encode(JsonACI)).
+<<"[\n  {\n    \"contract\": {\n      \"functions\": [\n        {\n          \"arguments\": [],\n          \"name\": \"init\",\n        "...>>
+```
+
+The final call to `jsx:prettify(jsx:encode(JsonACI))` returns the encoding in a
+more easily readable form. This is what is shown in the description above.

docs/aeso_compiler.md

@@ -0,0 +1,86 @@
+# aeso_compiler
+
+### Module
+
+### aeso_compiler
+
+The Sophia compiler
+
+### Description
+
+This module provides the interface to the standard Sophia compiler. It
+returns the compiled module in a map which can then be loaded.
+
+### Types
+``` erlang
+contract_string() = string() | binary()
+contract_map() = #{bytecode => binary(),
+                   compiler_version => binary(),
+                   contract_souce => string(),
+                   type_info => type_info()}
+type_info()
+errorstring() = binary()
+```
+### Exports
+
+#### file(File)
+#### file(File, Options) -> CompRet
+#### from_string(ContractString, Options) -> CompRet
+
+Types
+
+``` erlang
+ContractString = contract_string()
+Options = [Option]
+CompRet = {ok,ContractMap} | {error,ErrorString}
+ContractMap = contract_map()
+ErrorString = errorstring()
+```
+
+Compile a contract defined in a file or in a string.
+
+The **pp_** options all print to standard output the following:
+
+`pp_sophia_code` - print the input Sophia code.
+
+`pp_ast` - print the AST of the code
+
+`pp_types` - print information about the types
+
+`pp_typed_ast` - print the AST with type information at each node
+
+`pp_icode` - print the internal code structure
+
+`pp_assembler` - print the generated assembler code
+
+`pp_bytecode` - print the bytecode instructions
+
+#### check_call(ContractString, Options) -> CheckRet
+
+Types
+```
+ContractString = string() | binary()
+CheckRet = {ok,string(),{Types,Type | any()},Terms} | {error,Term}
+Types = [Type]
+Type = term()
+```
+Check a call in contract through the `__call` function.
+
+#### sophia_type_to_typerep(String) -> TypeRep
+
+Types
+``` erlang
+ {ok,TypeRep} | {error, badtype}
+```
+
+Get the type representation of a type declaration.
+
+#### version() -> {ok, Version} | {error, term()}
+
+Types
+
+``` erlang
+Version = binary()
+```
+
+Get the current version of the Sophia compiler.

include/aeso_heap.hrl

@@ -1,15 +0,0 @@
-
--record(pmap, {key_t  :: aeso_sophia:type(),
-               val_t  :: aeso_sophia:type(),
-               parent :: none | non_neg_integer(),
-               size   = 0 :: non_neg_integer(),
-               data   :: #{aeso_heap:binary_value() => aeso_heap:binary_value() | tombstone}
-                       | stored}).
-
--record(maps, { maps    = #{} :: #{ non_neg_integer() => #pmap{} }
-              , next_id = 0   :: non_neg_integer() }).
-
--record(heap, { maps   :: #maps{},
-                offset :: aeso_heap:offset(),
-                heap   :: binary() | #{non_neg_integer() => non_neg_integer()} }).
-

priv/stdlib/Func.aes

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

priv/stdlib/List.aes

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

priv/stdlib/ListInternal.aes

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

priv/stdlib/Option.aes

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

priv/stdlib/Pair.aes

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

priv/stdlib/Triple.aes

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

rebar.config

@@ -1,17 +1,24 @@
+%% -*- mode: erlang; indent-tabs-mode: nil -*-
+
 {erl_opts, [debug_info]}.
 
-%% NOTE: When possible deps are referenced by Git ref to ensure consistency between builds.
+{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git", {ref,"a66dc0a"}}}
-{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git",
+       , {getopt, "1.0.1"}
-                            {ref,"99bf097"}}},
+       , {eblake2, "1.0.0"}
-        
+       , {jsx, {git, "https://github.com/talentdeficit/jsx.git",
-        % waiting for https://github.com/jlouis/enacl/pull/40 to be merged
+                     {tag, "2.8.0"}}}
-        {enacl, {git, "https://github.com/aeternity/enacl.git",
-                {ref, "26180f4"}}}
        ]}.
 
-
 {dialyzer, [
             {warnings, [unknown]},
             {plt_apps, all_deps},
             {base_plt_apps, [erts, kernel, stdlib, crypto, mnesia]}
            ]}.
+
+{relx, [{release, {aesophia, "4.0.0-rc3"},
+         [aesophia, aebytecode, getopt]},
+
+        {dev_mode, true},
+        {include_erts, false},
+
+        {extended_start_script, true}]}.

rebar.lock

@@ -1,8 +1,28 @@
+{"1.1.0",
 [{<<"aebytecode">>,
   {git,"https://github.com/aeternity/aebytecode.git",
-       {ref,"99bf097759dedbe7553f87a796bc7e1c7322e64b"}},
+       {ref,"a66dc0a97facdeaad7e5403018ad195d989e4793"}},
   0},
+ {<<"aeserialization">>,
+  {git,"https://github.com/aeternity/aeserialization.git",
+       {ref,"47aaa8f5434b365c50a35bfd1490340b19241991"}},
+  1},
+ {<<"base58">>,
+  {git,"https://github.com/aeternity/erl-base58.git",
+       {ref,"60a335668a60328a29f9731b67c4a0e9e3d50ab6"}},
+  2},
+ {<<"eblake2">>,{pkg,<<"eblake2">>,<<"1.0.0">>},0},
  {<<"enacl">>,
   {git,"https://github.com/aeternity/enacl.git",
        {ref,"26180f42c0b3a450905d2efd8bc7fd5fd9cece75"}},
-  0}].
+  2},
+ {<<"getopt">>,{pkg,<<"getopt">>,<<"1.0.1">>},0},
+ {<<"jsx">>,
+  {git,"https://github.com/talentdeficit/jsx.git",
+       {ref,"3074d4865b3385a050badf7828ad31490d860df5"}},
+  0}]}.
+[
+{pkg_hash,[
+ {<<"eblake2">>, <<"EC8AD20E438AAB3F2E8D5D118C366A0754219195F8A0F536587440F8F9BCF2EF">>},
+ {<<"getopt">>, <<"C73A9FA687B217F2FF79F68A3B637711BB1936E712B521D8CE466B29CBF7808A">>}]}
+].

src/aeso_abi.erl

@@ -1,239 +0,0 @@
-%%%-------------------------------------------------------------------
-%%% @copyright (C) 2017, Aeternity Anstalt
-%%% @doc
-%%%     Encode and decode data and function calls according to
-%%%     Sophia-AEVM-ABI.
-%%% @end
-%%% Created : 25 Jan 2018
-%%%
-%%%-------------------------------------------------------------------
--module(aeso_abi).
--define(HASH_SIZE, 32).
-
--export([ old_create_calldata/3
-        , create_calldata/5
-        , check_calldata/2
-        , function_type_info/3
-        , function_type_hash/3
-        , arg_typerep_from_function/2
-        , type_hash_from_function_name/2
-        , typereps_from_type_hash/2
-        , function_name_from_type_hash/2
-        , get_function_hash_from_calldata/1
-        ]).
-
--type hash() :: <<_:256>>. %% 256 = ?HASH_SIZE * 8.
--type function_name() :: binary(). %% String
--type typerep() :: aeso_sophia:type().
--type function_type_info() :: { FunctionHash :: hash()
-                              , FunctionName :: function_name()
-                              , ArgType      :: aeso_sophia:heap() %% binary typerep
-                              , OutType      :: aeso_sophia:heap() %% binary typerep
-                              }.
--type type_info() :: [function_type_info()].
-
-%%%===================================================================
-%%% API
-%%%===================================================================
-
-%%%===================================================================
-%%% Handle calldata
-
-create_calldata(Contract, FunName, Args, ArgTypes, RetType) ->
-    case get_type_info_and_hash(Contract, FunName) of
-        {ok, TypeInfo, TypeHashInt} ->
-            Data = aeso_heap:to_binary({TypeHashInt, list_to_tuple(Args)}),
-            case check_calldata(Data, TypeInfo) of
-                {ok, CallDataType, OutType} ->
-                    case check_given_type(FunName, ArgTypes, RetType, CallDataType, OutType) of
-                        ok ->
-                            {ok, Data, CallDataType, OutType};
-                        {error, _} = Err ->
-                            Err
-                    end;
-                {error,_What} = Err -> Err
-            end;
-        {error, _} = Err -> Err
-    end.
-
-get_type_info_and_hash(#{type_info := TypeInfo}, FunName) ->
-    FunBin = list_to_binary(FunName),
-    case type_hash_from_function_name(FunBin, TypeInfo) of
-        {ok, <<TypeHashInt:?HASH_SIZE/unit:8>>} -> {ok, TypeInfo, TypeHashInt};
-        {ok, _}                   -> {error, bad_type_hash};
-        {error, _} = Err          -> Err
-    end.
-
-%% Check that the given type matches the type from the metadata.
-check_given_type(FunName, GivenArgs, GivenRet, CalldataType, ExpectRet) ->
-    {tuple, [word, {tuple, ExpectArgs}]} = CalldataType,
-    ReturnOk = if FunName == "init" -> true;
-                  GivenRet == any   -> true;
-                  true              -> GivenRet == ExpectRet
-               end,
-    ArgsOk   = ExpectArgs == GivenArgs,
-    case ReturnOk andalso ArgsOk of
-        true -> ok;
-        false when FunName == "init" ->
-            {error, {init_args_mismatch,
-                        {given,    GivenArgs},
-                        {expected, ExpectArgs}}};
-        false ->
-            {error, {call_type_mismatch,
-                        {given,    GivenArgs,  '=>', GivenRet},
-                        {expected, ExpectArgs, '=>', ExpectRet}}}
-    end.
-
--spec check_calldata(aeso_sophia:heap(), type_info()) ->
-                        {'ok', typerep()} | {'error', atom()}.
-check_calldata(CallData, TypeInfo) ->
-    %% The first element of the CallData should be the function name
-    case get_function_hash_from_calldata(CallData) of
-        {ok, Hash} ->
-            case typereps_from_type_hash(Hash, TypeInfo) of
-                {ok, ArgType, OutType} ->
-                    try aeso_heap:from_binary({tuple, [word, ArgType]}, CallData) of
-                        {ok, _Something} ->
-                            {ok, {tuple, [word, ArgType]}, OutType};
-                        {error, _} ->
-                            {error, bad_call_data}
-                    catch
-                        _T:_E ->
-                            {error, bad_call_data}
-                    end;
-                {error, _} ->
-                    {error, unknown_function}
-            end;
-        {error, _What} ->
-            {error, bad_call_data}
-    end.
-
--spec get_function_hash_from_calldata(CallData::binary()) ->
-                                             {ok, binary()} | {error, term()}.
-get_function_hash_from_calldata(CallData) ->
-    case aeso_heap:from_binary({tuple, [word]}, CallData) of
-        {ok, {HashInt}} -> {ok, <<HashInt:?HASH_SIZE/unit:8>>};
-        {error, _} = Error -> Error
-    end.
-
-%%%===================================================================
-%%% Handle type info from contract meta data
-
--spec function_type_info(function_name(), [typerep()], typerep()) ->
-                            function_type_info().
-function_type_info(Name, Args, OutType) ->
-    ArgType = {tuple, [T || {_, T} <- Args]},
-    { function_type_hash(Name, ArgType, OutType)
-    , Name
-    , aeso_heap:to_binary(ArgType)
-    , aeso_heap:to_binary(OutType)
-    }.
-
--spec function_type_hash(function_name(), typerep(), typerep()) -> hash().
-function_type_hash(Name, ArgType, OutType) when is_binary(Name) ->
-    Bin =  iolist_to_binary([ Name
-                            , aeso_heap:to_binary(ArgType)
-                            , aeso_heap:to_binary(OutType)
-                            ]),
-    %% Calculate a 256 bit digest BLAKE2b hash value of a binary
-    {ok, Hash} = enacl:generichash(?HASH_SIZE, Bin),
-    Hash.
-
--spec arg_typerep_from_function(function_name(), type_info()) ->
-           {'ok', typerep()} | {'error', 'bad_type_data' | 'unknown_function'}.
-arg_typerep_from_function(Function, TypeInfo) ->
-    case lists:keyfind(Function, 2, TypeInfo) of
-        {_TypeHash, Function, ArgTypeBin,_OutTypeBin} ->
-            case aeso_heap:from_binary(typerep, ArgTypeBin) of
-                {ok, ArgType} -> {ok, ArgType};
-                {error,_} -> {error, bad_type_data}
-            end;
-        false ->
-            {error, unknown_function}
-    end.
-
--spec typereps_from_type_hash(hash(), type_info()) ->
-           {'ok', typerep()} | {'error', 'bad_type_data' | 'unknown_function'}.
-typereps_from_type_hash(TypeHash, TypeInfo) ->
-    case lists:keyfind(TypeHash, 1, TypeInfo) of
-        {TypeHash,_Function, ArgTypeBin, OutTypeBin} ->
-            case {aeso_heap:from_binary(typerep, ArgTypeBin),
-                  aeso_heap:from_binary(typerep, OutTypeBin)} of
-                {{ok, ArgType}, {ok, OutType}} -> {ok, ArgType, OutType};
-                {_, _} -> {error, bad_type_data}
-            end;
-        false ->
-            {error, unknown_function}
-    end.
-
--spec function_name_from_type_hash(hash(), type_info()) ->
-                                          {'ok', function_name()}
-                                        | {'error', 'unknown_function'}.
-function_name_from_type_hash(TypeHash, TypeInfo) ->
-    case lists:keyfind(TypeHash, 1, TypeInfo) of
-        {TypeHash, Function,_ArgTypeBin,_OutTypeBin} ->
-            {ok, Function};
-        false ->
-            {error, unknown_function}
-    end.
-
--spec type_hash_from_function_name(function_name(), type_info()) ->
-                                          {'ok', hash()}
-                                        | {'error', 'unknown_function'}.
-type_hash_from_function_name(Name, TypeInfo) ->
-    case lists:keyfind(Name, 2, TypeInfo) of
-        {TypeHash, Name,_ArgTypeBin,_OutTypeBin} ->
-            {ok, TypeHash};
-        false ->
-            {error, unknown_function}
-    end.
-
-%% -- Old calldata creation. Kept for backwards compatibility. ---------------
-
-old_create_calldata(Contract, Function, Argument) when is_map(Contract) ->
-    case aeso_constants:string(Argument) of
-        {ok, {tuple, _, _} = Tuple} ->
-            old_encode_call(Contract, Function, Tuple);
-        {ok, {unit, _} = Tuple} ->
-            old_encode_call(Contract, Function, Tuple);
-        {ok, ParsedArgument} ->
-            %% The Sophia compiler does not parse a singleton tuple (42) as a tuple,
-            %% Wrap it in a tuple.
-            old_encode_call(Contract, Function, {tuple, [], [ParsedArgument]});
-        {error, _} ->
-            {error, argument_syntax_error}
-    end.
-
-%% Call takes one arument.
-%% Use a tuple to pass multiple arguments.
-old_encode_call(Contract, Function, ArgumentAst) ->
-    Argument = old_ast_to_erlang(ArgumentAst),
-    case get_type_info_and_hash(Contract, Function) of
-        {ok, TypeInfo, TypeHashInt} ->
-            Data = aeso_heap:to_binary({TypeHashInt, Argument}),
-            case check_calldata(Data, TypeInfo) of
-                {ok, CallDataType, OutType} ->
-                    {ok, Data, CallDataType, OutType};
-                {error, _} = Err ->
-                    Err
-            end;
-        {error, _} = Err -> Err
-    end.
-
-old_ast_to_erlang({int, _, N}) -> N;
-old_ast_to_erlang({hash, _, <<N:?HASH_SIZE/unit:8>>}) -> N;
-old_ast_to_erlang({hash, _, <<Hi:256, Lo:256>>}) -> {Hi, Lo};    %% signature
-old_ast_to_erlang({bool, _, true}) -> 1;
-old_ast_to_erlang({bool, _, false}) -> 0;
-old_ast_to_erlang({string, _, Bin}) -> Bin;
-old_ast_to_erlang({unit, _}) -> {};
-old_ast_to_erlang({con, _, "None"}) -> none;
-old_ast_to_erlang({app, _, {con, _, "Some"}, [A]}) -> {some, old_ast_to_erlang(A)};
-old_ast_to_erlang({tuple, _, Elems}) ->
-    list_to_tuple(lists:map(fun old_ast_to_erlang/1, Elems));
-old_ast_to_erlang({list, _, Elems}) ->
-    lists:map(fun old_ast_to_erlang/1, Elems);
-old_ast_to_erlang({map, _, Elems}) ->
-    maps:from_list([ {old_ast_to_erlang(element(1, Elem)), old_ast_to_erlang(element(2, Elem))}
-                        || Elem <- Elems ]).
-

src/aeso_aci.erl

@@ -0,0 +1,355 @@
+%%%-------------------------------------------------------------------
+%%% @author Robert Virding
+%%% @copyright (C) 2019, Aeternity Anstalt
+%%% @doc
+%%%     ACI interface
+%%% @end
+%%% Created : 12 Jan 2019
+%%%-------------------------------------------------------------------
+
+-module(aeso_aci).
+
+-export([ file/2
+        , file/3
+        , contract_interface/2
+        , contract_interface/3
+
+        , render_aci_json/1
+
+        , json_encode_expr/1
+        , json_encode_type/1]).
+
+-type aci_type()  :: json | string.
+-type json()      :: jsx:json_term().
+-type json_text() :: binary().
+
+%% External API
+-spec file(aci_type(), string()) -> {ok, json() | string()} | {error, term()}.
+file(Type, File) ->
+    file(Type, File, []).
+
+file(Type, File, Options0) ->
+    Options = aeso_compiler:add_include_path(File, Options0),
+    case file:read_file(File) of
+        {ok, BinCode} ->
+            do_contract_interface(Type, binary_to_list(BinCode), Options);
+        {error, _} = Err -> Err
+    end.
+
+-spec contract_interface(aci_type(), string()) ->
+    {ok, json() | string()} | {error, term()}.
+contract_interface(Type, ContractString) ->
+    contract_interface(Type, ContractString, []).
+
+-spec contract_interface(aci_type(), string(), [term()]) ->
+    {ok, json() | string()} | {error, term()}.
+contract_interface(Type, ContractString, CompilerOpts) ->
+    do_contract_interface(Type, ContractString, CompilerOpts).
+
+-spec render_aci_json(json() | json_text()) -> {ok, binary()}.
+render_aci_json(Json) ->
+    do_render_aci_json(Json).
+
+-spec json_encode_expr(aeso_syntax:expr()) -> json().
+json_encode_expr(Expr) ->
+    encode_expr(Expr).
+
+-spec json_encode_type(aeso_syntax:type()) -> json().
+json_encode_type(Type) ->
+    encode_type(Type).
+
+%% Internal functions
+do_contract_interface(Type, Contract, Options) when is_binary(Contract) ->
+    do_contract_interface(Type, binary_to_list(Contract), Options);
+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
+    catch
+        throw:{error, Errors} -> {error, Errors}
+    end.
+
+encode_contract(Contract = {contract, _, {con, _, Name}, _}) ->
+    C0 = #{name => encode_name(Name)},
+
+    Tdefs0 = [ encode_typedef(T) || T <- sort_decls(contract_types(Contract)) ],
+    FilterT = fun(N) -> fun(#{name := N1}) -> N == N1 end end,
+    {Es, Tdefs1} = lists:partition(FilterT(<<"event">>), Tdefs0),
+    {Ss, Tdefs}  = lists:partition(FilterT(<<"state">>), Tdefs1),
+
+    C1 = C0#{type_defs => Tdefs},
+
+    C2 = case Es of
+             []                 -> C1;
+             [#{typedef := ET}] -> C1#{event => ET}
+         end,
+
+    C3 = case Ss of
+             []                 -> C2;
+             [#{typedef := ST}] -> C2#{state => ST}
+         end,
+
+    Fdefs  = [ encode_function(F)
+               || F <- sort_decls(contract_funcs(Contract)),
+                  is_entrypoint(F) ],
+
+    #{contract => C3#{functions => Fdefs, payable => is_payable(Contract)}};
+encode_contract(Namespace = {namespace, _, {con, _, Name}, _}) ->
+    Tdefs = [ encode_typedef(T) || T <- sort_decls(contract_types(Namespace)) ],
+    #{namespace => #{name => encode_name(Name),
+                     type_defs => Tdefs}}.
+
+%%  Encode a function definition. Currently we are only interested in
+%%  the interface and type.
+encode_function(FDef = {letfun, _, {id, _, Name}, Args, Type, _}) ->
+    #{name      => encode_name(Name),
+      arguments => encode_args(Args),
+      returns   => encode_type(Type),
+      stateful  => is_stateful(FDef),
+      payable   => is_payable(FDef)};
+encode_function(FDecl = {fun_decl, _, {id, _, Name}, {fun_t, _, _, Args, Type}}) ->
+    #{name      => encode_name(Name),
+      arguments => encode_anon_args(Args),
+      returns   => encode_type(Type),
+      stateful  => is_stateful(FDecl),
+      payable   => is_payable(FDecl)}.
+
+encode_anon_args(Types) ->
+    Anons = [ list_to_binary("_" ++ integer_to_list(X)) || X <- lists:seq(1, length(Types))],
+    [ #{name => V, type => encode_type(T)}
+      || {V, T} <- lists:zip(Anons, Types) ].
+
+encode_args(Args) -> [ encode_arg(A) || A <- Args ].
+
+encode_arg({arg, _, Id, T}) ->
+    #{name => encode_type(Id),
+      type => encode_type(T)}.
+
+encode_typedef(Type) ->
+    Name = typedef_name(Type),
+    Vars = typedef_vars(Type),
+    Def  = typedef_def(Type),
+    #{name    => encode_name(Name),
+      vars    => encode_tvars(Vars),
+      typedef => encode_type(Def)}.
+
+encode_tvars(Vars) ->
+    [ #{name => encode_type(V)} || V <- Vars ].
+
+%% Encode type
+encode_type({tvar, _, N})         -> encode_name(N);
+encode_type({id, _, N})           -> encode_name(N);
+encode_type({con, _, N})          -> encode_name(N);
+encode_type({qid, _, Ns})         -> encode_name(lists:join(".", Ns));
+encode_type({qcon, _, Ns})        -> encode_name(lists:join(".", Ns));
+encode_type({tuple_t, _, As})     -> #{tuple => encode_types(As)};
+encode_type({bytes_t, _, Len})    -> #{bytes => Len};
+encode_type({record_t, Fs})       -> #{record => encode_type_fields(Fs)};
+encode_type({app_t, _, Id, Fs})   -> #{encode_type(Id) => encode_types(Fs)};
+encode_type({variant_t, Cs})      -> #{variant => encode_types(Cs)};
+encode_type({constr_t, _, C, As}) -> #{encode_type(C) => encode_types(As)};
+encode_type({alias_t, Type})      -> encode_type(Type);
+encode_type({fun_t, _, _, As, T}) -> #{function =>
+                                         #{arguments => encode_types(As),
+                                           returns => encode_type(T)}}.
+
+encode_types(Ts) -> [ encode_type(T) || T <- Ts ].
+
+encode_type_fields(Fs) -> [ encode_type_field(F) || F <- Fs ].
+
+encode_type_field({field_t, _, Id, T}) ->
+    #{name => encode_type(Id),
+      type => encode_type(T)}.
+
+encode_name(Name) when is_list(Name) ->
+    list_to_binary(Name);
+encode_name(Name) when is_binary(Name) ->
+    Name.
+
+%% Encode Expr
+encode_exprs(Es) -> [ encode_expr(E) || E <- Es ].
+
+encode_expr({id, _, N})     -> encode_name(N);
+encode_expr({con, _, N})    -> encode_name(N);
+encode_expr({qid, _, Ns})   -> encode_name(lists:join(".", Ns));
+encode_expr({qcon, _, Ns})  -> encode_name(lists:join(".", Ns));
+encode_expr({typed, _, E})  -> encode_expr(E);
+encode_expr({bool, _, B})   -> B;
+encode_expr({int, _, V})    -> V;
+encode_expr({string, _, S}) -> S;
+encode_expr({tuple, _, As}) -> encode_exprs(As);
+encode_expr({list, _, As})  -> encode_exprs(As);
+encode_expr({bytes, _, B})  ->
+    Digits = byte_size(B),
+    <<N:Digits/unit:8>> = B,
+    list_to_binary(lists:flatten(io_lib:format("#~*.16.0b", [Digits*2, N])));
+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, _, F, As}) ->
+    Ef = encode_expr(F),
+    Eas = encode_exprs(As),
+    #{Ef => Eas};
+encode_expr({record, _, Flds}) -> maps:from_list(encode_fields(Flds));
+encode_expr({map, _, KVs})     -> [ [encode_expr(K), encode_expr(V)] || {K, V} <- KVs ];
+encode_expr({Op,_Ann}) ->
+    error({encode_expr_todo, Op}).
+
+encode_fields(Flds) -> [ encode_field(F) || F <- Flds ].
+
+encode_field({field, _, [{proj, _, {id, _, Fld}}], Val}) ->
+    {encode_name(Fld), encode_expr(Val)}.
+
+do_render_aci_json(Json) ->
+    Contracts =
+        case Json of
+            JArray when is_list(JArray)  -> JArray;
+            JObject when is_map(JObject) -> [JObject];
+            JText when is_binary(JText)  ->
+                case jsx:decode(Json, [{labels, atom}, return_maps]) of
+                    JArray when is_list(JArray)  -> JArray;
+                    JObject when is_map(JObject) -> [JObject];
+                    _                            -> error(bad_aci_json)
+                end
+        end,
+    DecodedContracts = [ decode_contract(C) || C <- Contracts ],
+    {ok, list_to_binary(string:join(DecodedContracts, "\n"))}.
+
+decode_contract(#{contract := #{name := Name,
+                                payable := Payable,
+                                type_defs := Ts0,
+                                functions := Fs} = C}) ->
+    MkTDef = fun(N, T) -> #{name => N, vars => [], typedef => T} end,
+    Ts = [ MkTDef(<<"state">>, maps:get(state, C)) || maps:is_key(state, C) ] ++
+         [ MkTDef(<<"event">>, maps:get(event, C)) || maps:is_key(event, C) ] ++ Ts0,
+    [payable(Payable), "contract ", io_lib:format("~s", [Name])," =\n",
+     decode_tdefs(Ts), decode_funcs(Fs)];
+decode_contract(#{namespace := #{name := Name, type_defs := Ts}}) when Ts /= [] ->
+    ["namespace ", io_lib:format("~s", [Name])," =\n",
+     decode_tdefs(Ts)];
+decode_contract(_) -> [].
+
+decode_funcs(Fs) -> [ decode_func(F) || F <- Fs ].
+
+%% decode_func(#{name := init}) -> [];
+decode_func(#{name := Name, payable := Payable, arguments := As, returns := T}) ->
+    ["  ", payable(Payable), "entrypoint ", io_lib:format("~s", [Name]), " : ",
+     decode_args(As), " => ", decode_type(T), $\n].
+
+decode_args(As) ->
+    Das = [ decode_arg(A) || A <- As ],
+    [$(,lists:join(", ", Das),$)].
+
+decode_arg(#{type := T}) -> decode_type(T).
+
+decode_types(Ets) ->
+    [ decode_type(Et) || Et <- Ets ].
+
+decode_type(#{tuple := Ets}) ->
+    Ts = decode_types(Ets),
+    case Ts of
+        [] -> ["unit"];
+        _ -> [$(,lists:join(" * ", Ts),$)]
+    end;
+decode_type(#{record := Efs}) ->
+    Fs = decode_fields(Efs),
+    [${,lists:join(",", Fs),$}];
+decode_type(#{list := [Et]}) ->
+    T = decode_type(Et),
+    ["list",$(,T,$)];
+decode_type(#{map := Ets}) ->
+    Ts = decode_types(Ets),
+    ["map",$(,lists:join(",", Ts),$)];
+decode_type(#{bytes := Len}) ->
+    ["bytes(", integer_to_list(Len), ")"];
+decode_type(#{variant := Ets}) ->
+    Ts = decode_types(Ets),
+    lists:join(" | ", Ts);
+decode_type(#{function := #{arguments := Args, returns := R}}) ->
+    [decode_type(#{tuple => Args}), " => ", decode_type(R)];
+decode_type(Econs) when is_map(Econs) ->	%General constructor
+    [{Ec,Ets}] = maps:to_list(Econs),
+    AppName = decode_name(Ec),
+    AppArgs = decode_types(Ets),
+    case AppArgs of
+        [] -> [AppName];
+        _  -> [AppName,$(,lists:join(", ", AppArgs),$)]
+    end;
+decode_type(T) ->				%Just raw names.
+    decode_name(T).
+
+decode_name(En) when is_atom(En)   -> erlang:atom_to_list(En);
+decode_name(En) when is_binary(En) -> binary_to_list(En).
+
+decode_fields(Efs) ->
+    [ decode_field(Ef) || Ef <- Efs ].
+
+decode_field(#{name := En, type := Et}) ->
+    Name = decode_name(En),
+    Type = decode_type(Et),
+    [Name," : ",Type].
+
+%% decode_tdefs(Json) -> [TypeString].
+%%  Here we are only interested in the type definitions and ignore the
+%%  aliases. We find them as they always have variants.
+
+decode_tdefs(Ts) -> [ decode_tdef(T) || T <- Ts ].
+
+decode_tdef(#{name := Name, vars := Vs, typedef := T}) ->
+    TypeDef = decode_type(T),
+    DefType = decode_deftype(T),
+    ["  ", DefType, " ", decode_name(Name), decode_tvars(Vs), " = ", TypeDef, $\n].
+
+decode_deftype(#{record := _Efs}) -> "record";
+decode_deftype(#{variant := _})   -> "datatype";
+decode_deftype(_T)                      -> "type".
+
+decode_tvars([]) -> [];  %No tvars, no parentheses
+decode_tvars(Vs) ->
+    Dvs = [ decode_tvar(V) || V <- Vs ],
+    [$(,lists:join(", ", Dvs),$)].
+
+decode_tvar(#{name := N}) -> io_lib:format("~s", [N]).
+
+payable(true)  -> "payable ";
+payable(false) -> "".
+
+%% #contract{Ann, Con, [Declarations]}.
+
+contract_funcs({C, _, _, Decls}) when C == contract; C == namespace ->
+    [ D || D <- Decls, is_fun(D)].
+
+contract_types({C, _, _, Decls}) when C == contract; C == namespace ->
+    [ D || D <- Decls, is_type(D) ].
+
+is_fun({letfun, _, _, _, _, _}) -> true;
+is_fun({fun_decl, _, _, _})     -> true;
+is_fun(_)                       -> false.
+
+is_type({type_def, _, _, _, _}) -> true;
+is_type(_)                      -> false.
+
+sort_decls(Ds) ->
+    Sort = fun (D1, D2) ->
+                   aeso_syntax:get_ann(line, D1, 0) =<
+                       aeso_syntax:get_ann(line, D2, 0)
+           end,
+    lists:sort(Sort, Ds).
+
+is_entrypoint(Node) -> aeso_syntax:get_ann(entrypoint, Node, false).
+is_stateful(Node) -> aeso_syntax:get_ann(stateful, Node, false).
+is_payable(Node) -> aeso_syntax:get_ann(payable, Node, false).
+
+typedef_name({type_def, _, {id, _, Name}, _, _}) -> Name.
+
+typedef_vars({type_def, _, _, Vars, _}) -> Vars.
+
+typedef_def({type_def, _, _, _, Def}) -> Def.

src/aeso_ast.erl

@@ -17,11 +17,11 @@ line({symbol, Line, _}) -> Line.
 symbol_name({symbol, _, Name}) -> Name.
 
 pp(Ast) ->
-    %% TODO: Actually do *Pretty* printing.
+    String = prettypr:format(aeso_pretty:decls(Ast, [])),
-    io:format("~p~n", [Ast]).
+    io:format("Ast:\n~s\n", [String]).
 
 pp_typed(TypedAst) ->
+    %% io:format("Typed tree:\n~p\n",[TypedAst]),
     String = prettypr:format(aeso_pretty:decls(TypedAst, [show_generated])),
-    %%io:format("Typed tree:\n~p\n",[TypedAst]),
+    io:format("Type ast:\n~s\n",[String]).
-    io:format("Type info:\n~s\n",[String]).
 

src/aeso_builtins.erl

@@ -10,6 +10,7 @@
 -module(aeso_builtins).
 
 -export([ builtin_function/1
+        , bytes_to_raw_string/2
         , check_event_type/1
         , used_builtins/1 ]).
 
@@ -38,12 +39,15 @@ builtin_deps1({map_upd, Type})            -> [{map_get, Type}, map_put];
 builtin_deps1({map_upd_default, Type})    -> [{map_lookup_default, Type}, map_put];
 builtin_deps1(map_from_list)              -> [map_put];
 builtin_deps1(str_equal)                  -> [str_equal_p];
-builtin_deps1(string_concat)              -> [string_concat_inner1, string_concat_inner2];
+builtin_deps1(string_concat)              -> [string_concat_inner1, string_copy, string_shift_copy];
-builtin_deps1(int_to_str)                 -> [int_to_str_, int_digits];
+builtin_deps1(int_to_str)                 -> [{baseX_int, 10}];
-builtin_deps1(addr_to_str)                -> [base58_int, string_concat];
+builtin_deps1(addr_to_str)                -> [{baseX_int, 58}];
-builtin_deps1(base58_int)                 -> [base58_int_encode, base58_int_pad, string_reverse, string_concat];
+builtin_deps1({baseX_int, X})             -> [{baseX_int_pad, X}];
-builtin_deps1(base58_int_encode)          -> [base58_int_encode_, base58_tab];
+builtin_deps1({baseX_int_pad, X})         -> [{baseX_int_encode, X}];
+builtin_deps1({baseX_int_encode, X})      -> [{baseX_int_encode_, X}, {baseX_tab, X}, {baseX_digits, X}];
+builtin_deps1({bytes_to_str, _})          -> [bytes_to_str_worker, bytes_to_str_worker_x];
 builtin_deps1(string_reverse)             -> [string_reverse_];
+builtin_deps1(require)                    -> [abort];
 builtin_deps1(_)                          -> [].
 
 dep_closure(Deps) ->
@@ -59,12 +63,14 @@ v(X) when is_list(X) -> #var_ref{name = X}.
 option_none()  -> {tuple, [{integer, 0}]}.
 option_some(X) -> {tuple, [{integer, 1}, X]}.
 
+-define(HASH_BYTES, 32).
+
 -define(call(Fun, Args), #funcall{ function = #var_ref{ name = {builtin, Fun} }, args = Args }).
 -define(I(X), {integer, X}).
 -define(V(X), v(X)).
 -define(A(Op), aeb_opcodes:mnemonic(Op)).
 -define(LET(Var, Expr, Body), {switch, Expr, [{v(Var), Body}]}).
--define(DEREF(Var, Ptr, Body), {switch, v(Ptr), [{{tuple, [v(Var)]}, Body}]}).
+-define(DEREF(Var, Ptr, Body), {switch, operand(Ptr), [{{tuple, [v(Var)]}, Body}]}).
 -define(NXT(Ptr), op('+', Ptr, 32)).
 -define(NEG(A), op('/', A, {unop, '-', {integer, 1}})).
 -define(BYTE(Ix, Word), op('byte', Ix, Word)).
@@ -80,21 +86,22 @@ option_some(X) -> {tuple, [{integer, 1}, X]}.
 -define(EXP(A, B), op('^', A, B)).
 -define(AND(A, B), op('&&', A, B)).
 
--define(BSL(X, B), ?MUL(X, ?EXP(2, ?MUL(B, 8)))).
+%% Bit shift operations takes their arguments backwards!?
--define(BSR(X, B), ?DIV(X, ?EXP(2, ?MUL(B, 8)))).
+-define(BSL(X, B), op('bsl', ?MUL(B, 8), X)).
+-define(BSR(X, B), op('bsr', ?MUL(B, 8), X)).
+
+op(Op, A, B) -> simpl({binop, Op, operand(A), operand(B)}).
+
+%% We generate a lot of B * 8 for integer B from BSL and BSR.
+simpl({binop, '*', {integer, A}, {integer, B}}) when A >= 0, B >= 0, A * B < 1 bsl 256 ->
+    {integer, A * B};
+simpl(Op) -> Op.
 
-op(Op, A, B) -> {binop, Op, operand(A), operand(B)}.
 
 operand(A) when is_atom(A) -> v(A);
 operand(I) when is_integer(I) -> {integer, I};
 operand(T) -> T.
 
-str_to_icode(String) when is_list(String) ->
-    str_to_icode(list_to_binary(String));
-str_to_icode(BinStr) ->
-    Cpts = [size(BinStr) | aeso_memory:binary_to_words(BinStr)],
-    #tuple{ cpts = [ #integer{value = X} || X <- Cpts ] }.
-
 check_event_type(Icode) ->
     case maps:get(event_type, Icode) of
         {variant_t, Cons} ->
@@ -104,194 +111,240 @@ check_event_type(Icode) ->
     end.
 
 check_event_type(Evts, Icode) ->
-    [ check_event_type(Name, T, Icode)
+    [ check_event_type(Name, Ix, T, Icode)
-      || {constr_t, _, {con, _, Name}, Types} <- Evts, T <- Types ].
+      || {constr_t, Ann, {con, _, Name}, Types} <- Evts,
+         {Ix, T} <- lists:zip(aeso_syntax:get_ann(indices, Ann), Types) ].
 
-check_event_type(EvtName, Type, Icode) ->
+check_event_type(EvtName, Ix, Type, Icode) ->
-    io:format("~p: ~p??\n", [EvtName, Type]),
-    io:format("=> ~p\n", [aeso_ast_to_icode:ast_typerep(Type, Icode)]),
     VMType =
         try
            aeso_ast_to_icode:ast_typerep(Type, Icode)
         catch _:_ ->
             error({EvtName, could_not_resolve_type, Type})
         end,
-    case aeso_syntax:get_ann(indexed, Type, false) of
+    case {Ix, VMType, Type} of
-        true when VMType == word    -> ok;
+        {indexed, word, _}      -> ok;
-        false when VMType == string -> ok;
+        {notindexed, string, _} -> ok;
-        true  -> error({EvtName, indexed_field_should_be_word, is, VMType});
+        {notindexed, _, {bytes_t, _, N}} when N > 32 -> ok;
-        false -> error({EvtName, payload_should_be_string, is, VMType})
+        {indexed, _, _}         -> error({EvtName, indexed_field_should_be_word, is, VMType});
+        {notindexed, _, _}      -> error({EvtName, payload_should_be_string, is, VMType})
+    end.
+
+bfun(B, {IArgs, IExpr, IRet}) ->
+    {{builtin, B}, [private], IArgs, IExpr, IRet}.
+
+builtin_function(BF) ->
+    case BF of
+        {event, EventT}            -> bfun(BF, builtin_event(EventT));
+        abort                      -> bfun(BF, builtin_abort());
+        block_hash                 -> bfun(BF, builtin_block_hash());
+        require                    -> bfun(BF, builtin_require());
+        {map_lookup, Type}         -> bfun(BF, builtin_map_lookup(Type));
+        map_put                    -> bfun(BF, builtin_map_put());
+        map_delete                 -> bfun(BF, builtin_map_delete());
+        map_size                   -> bfun(BF, builtin_map_size());
+        {map_get, Type}            -> bfun(BF, builtin_map_get(Type));
+        {map_lookup_default, Type} -> bfun(BF, builtin_map_lookup_default(Type));
+        map_member                 -> bfun(BF, builtin_map_member());
+        {map_upd, Type}            -> bfun(BF, builtin_map_upd(Type));
+        {map_upd_default, Type}    -> bfun(BF, builtin_map_upd_default(Type));
+        map_from_list              -> bfun(BF, builtin_map_from_list());
+        list_concat                -> bfun(BF, builtin_list_concat());
+        string_length              -> bfun(BF, builtin_string_length());
+        string_concat              -> bfun(BF, builtin_string_concat());
+        string_concat_inner1       -> bfun(BF, builtin_string_concat_inner1());
+        string_copy                -> bfun(BF, builtin_string_copy());
+        string_shift_copy          -> bfun(BF, builtin_string_shift_copy());
+        str_equal_p                -> bfun(BF, builtin_str_equal_p());
+        str_equal                  -> bfun(BF, builtin_str_equal());
+        popcount                   -> bfun(BF, builtin_popcount());
+        int_to_str                 -> bfun(BF, builtin_int_to_str());
+        addr_to_str                -> bfun(BF, builtin_addr_to_str());
+        {baseX_int, X}             -> bfun(BF, builtin_baseX_int(X));
+        {baseX_digits, X}          -> bfun(BF, builtin_baseX_digits(X));
+        {baseX_tab, X}             -> bfun(BF, builtin_baseX_tab(X));
+        {baseX_int_pad, X}         -> bfun(BF, builtin_baseX_int_pad(X));
+        {baseX_int_encode, X}      -> bfun(BF, builtin_baseX_int_encode(X));
+        {baseX_int_encode_, X}     -> bfun(BF, builtin_baseX_int_encode_(X));
+        {bytes_to_int, N}          -> bfun(BF, builtin_bytes_to_int(N));
+        {bytes_to_str, N}          -> bfun(BF, builtin_bytes_to_str(N));
+        {bytes_concat, A, B}       -> bfun(BF, builtin_bytes_concat(A, B));
+        {bytes_split, A, B}        -> bfun(BF, builtin_bytes_split(A, B));
+        bytes_to_str_worker        -> bfun(BF, builtin_bytes_to_str_worker());
+        bytes_to_str_worker_x      -> bfun(BF, builtin_bytes_to_str_worker_x());
+        string_reverse             -> bfun(BF, builtin_string_reverse());
+        string_reverse_            -> bfun(BF, builtin_string_reverse_())
     end.
 
 %% Event primitive (dependent on Event type)
 %%
 %% We need to switch on the event and prepare the correct #event for icode_to_asm
 %% NOTE: we assume all errors are already checked!
-builtin_function(Builtin = {event, EventT}) ->
+builtin_event(EventT) ->
     A         = fun(X) -> aeb_opcodes:mnemonic(X) end,
     VIx       = fun(Ix) -> v(lists:concat(["v", Ix])) end,
     ArgPats   = fun(Ts) -> [ VIx(Ix) || Ix <- lists:seq(0, length(Ts) - 1) ] end,
-    IsIndexed = fun(T) -> aeso_syntax:get_ann(indexed, T, false) end,
     Payload = %% Should put data ptr, length on stack.
-        fun([]) ->  {inline_asm, [A(?PUSH1), 0, A(?PUSH1), 0]};
+        fun([])            -> {inline_asm, [A(?PUSH1), 0, A(?PUSH1), 0]};
-           ([V]) -> {seq, [V, {inline_asm, [A(?DUP1), A(?MLOAD),                  %% length, ptr
+           ([{{id, _, "string"}, V}]) ->
-                                            A(?SWAP1), A(?PUSH1), 32, A(?ADD)]}]} %% ptr+32, length
+                {seq, [V, {inline_asm, [A(?DUP1), A(?MLOAD),  %% length, ptr
+                       A(?SWAP1), A(?PUSH1), 32, A(?ADD)]}]}; %% ptr+32, length
+           ([{{bytes_t, _, N}, V}]) -> {seq, [V, {integer, N}, {inline_asm, A(?SWAP1)}]}
         end,
+    Ix =
+        fun({bytes_t, _, N}, V) when N < 32 -> ?BSR(V, 32 - N);
+           (_, V) -> V end,
     Clause =
-        fun(_Tag, {con, _, Con}, Types) ->
+        fun(_Tag, {con, _, Con}, IxTypes) ->
-            Indexed   = [ Var || {Var, Type} <- lists:zip(ArgPats(Types), Types),
+            Types     = [ T || {_Ix, T} <- IxTypes ],
-                                 IsIndexed(Type) ],
+            Indexed   = [ Ix(Type, Var) || {Var, {indexed, Type}} <- lists:zip(ArgPats(Types), IxTypes) ],
-            EvtIndex  = {unop, 'sha3', str_to_icode(Con)},
+            Data      = [ {Type, Var} || {Var, {notindexed, Type}} <- lists:zip(ArgPats(Types), IxTypes) ],
-            {event, lists:reverse(Indexed) ++ [EvtIndex], Payload(ArgPats(Types) -- Indexed)}
+            {ok, <<EvtIndexN:256>>} = eblake2:blake2b(?HASH_BYTES, list_to_binary(Con)),
+            EvtIndex  = {integer, EvtIndexN},
+            {event, lists:reverse(Indexed) ++ [EvtIndex], Payload(Data)}
         end,
     Pat = fun(Tag, Types) -> {tuple, [{integer, Tag} | ArgPats(Types)]} end,
 
     {variant_t, Cons} = EventT,
     Tags              = lists:seq(0, length(Cons) - 1),
 
-    {{builtin, Builtin}, [private],
+    {[{"e", event}],
-        [{"e", event}],
+     {switch, v(e),
-        {switch, v(e),
+         [{Pat(Tag, Types), Clause(Tag, Con, lists:zip(aeso_syntax:get_ann(indices, Ann), Types))}
-            [{Pat(Tag, Types), Clause(Tag, Con, Types)}
+          || {Tag, {constr_t, Ann, Con, Types}} <- lists:zip(Tags, Cons) ]},
-             || {Tag, {constr_t, _, Con, Types}} <- lists:zip(Tags, Cons) ]},
+     {tuple, []}}.
-        {tuple, []}};
 
 %% Abort primitive.
-builtin_function(abort) ->
+builtin_abort() ->
     A = fun(X) -> aeb_opcodes:mnemonic(X) end,
-    {{builtin, abort}, [private],
+    {[{"s", string}],
-     [{"s", string}],
      {inline_asm, [A(?PUSH1),0,  %% Push a dummy 0 for the first arg
                    A(?REVERT)]}, %% Stack: 0,Ptr
-     {tuple,[]}};
+     {tuple,[]}}.
+
+builtin_block_hash() ->
+    {[{"height", word}],
+     ?LET(hash, #prim_block_hash{ height = ?V(height)},
+          {ifte, ?EQ(hash, 0), option_none(), option_some(?V(hash))}),
+     aeso_icode:option_typerep(word)}.
+
+builtin_require() ->
+    {[{"c", word}, {"msg", string}],
+     {ifte, ?V(c), {tuple, []}, ?call(abort, [?V(msg)])},
+     {tuple, []}}.
 
 %% Map primitives
-builtin_function(Builtin = {map_lookup, Type}) ->
+builtin_map_lookup(Type) ->
     Ret = aeso_icode:option_typerep(Type),
-    {{builtin, Builtin}, [private],
+    {[{"m", word}, {"k", word}],
-        [{"m", word}, {"k", word}],
+     prim_call(?PRIM_CALL_MAP_GET, #integer{value = 0},
-            prim_call(?PRIM_CALL_MAP_GET, #integer{value = 0},
+               [#var_ref{name = "m"}, #var_ref{name = "k"}],
-                      [#var_ref{name = "m"}, #var_ref{name = "k"}],
+               [word, word], Ret),
-                      [word, word], Ret),
+     Ret}.
-     Ret};
 
-builtin_function(Builtin = map_put) ->
+builtin_map_put() ->
     %% We don't need the types for put.
-    {{builtin, Builtin}, [private],
+    {[{"m", word}, {"k", word}, {"v", word}],
-        [{"m", word}, {"k", word}, {"v", word}],
+     prim_call(?PRIM_CALL_MAP_PUT, #integer{value = 0},
-        prim_call(?PRIM_CALL_MAP_PUT, #integer{value = 0},
+               [v(m), v(k), v(v)], [word, word, word], word),
-                  [v(m), v(k), v(v)],
+     word}.
-                  [word, word, word], word),
-     word};
 
-builtin_function(Builtin = map_delete) ->
+builtin_map_delete() ->
-    {{builtin, Builtin}, [private],
+    {[{"m", word}, {"k", word}],
-        [{"m", word}, {"k", word}],
+     prim_call(?PRIM_CALL_MAP_DELETE, #integer{value = 0},
-        prim_call(?PRIM_CALL_MAP_DELETE, #integer{value = 0},
+               [v(m), v(k)], [word, word], word),
-                  [v(m), v(k)],
+     word}.
-                  [word, word], word),
-     word};
 
-builtin_function(Builtin = map_size) ->
+builtin_map_size() ->
-    Name = {builtin, Builtin},
+    {[{"m", word}],
-    {Name, [private], [{"m", word}],
+     prim_call(?PRIM_CALL_MAP_SIZE, #integer{value = 0},
-        prim_call(?PRIM_CALL_MAP_SIZE, #integer{value = 0},
+               [v(m)], [word], word),
-                  [v(m)], [word], word),
+     word}.
-        word};
 
 %% Map builtins
-builtin_function(Builtin = {map_get, Type}) ->
+builtin_map_get(Type) ->
     %% function map_get(m, k) =
     %%   switch(map_lookup(m, k))
     %%     Some(v) => v
-    {{builtin, Builtin}, [private],
+    {[{"m", word}, {"k", word}],
-        [{"m", word}, {"k", word}],
+     {switch, ?call({map_lookup, Type}, [v(m), v(k)]), [{option_some(v(v)), v(v)}]},
-            {switch, ?call({map_lookup, Type}, [v(m), v(k)]),
+     Type}.
-                [{option_some(v(v)), v(v)}]},
-     Type};
 
-builtin_function(Builtin = {map_lookup_default, Type}) ->
+builtin_map_lookup_default(Type) ->
     %% function map_lookup_default(m, k, default) =
     %%   switch(map_lookup(m, k))
     %%     None    => default
     %%     Some(v) => v
-    {{builtin, Builtin}, [private],
+    {[{"m", word}, {"k", word}, {"default", Type}],
-        [{"m", word}, {"k", word}, {"default", Type}],
+     {switch, ?call({map_lookup, Type}, [v(m), v(k)]),
-            {switch, ?call({map_lookup, Type}, [v(m), v(k)]),
+         [{option_none(),     v(default)},
-                [{option_none(),     v(default)},
+          {option_some(v(v)), v(v)}]},
-                 {option_some(v(v)), v(v)}]},
+     Type}.
-     Type};
 
-builtin_function(Builtin = map_member) ->
+builtin_map_member() ->
     %% function map_member(m, k) : bool =
     %%   switch(Map.lookup(m, k))
     %%     None => false
     %%     _    => true
-    {{builtin, Builtin}, [private],
+    {[{"m", word}, {"k", word}],
-        [{"m", word}, {"k", word}],
+     {switch, ?call({map_lookup, word}, [v(m), v(k)]),
-            {switch, ?call({map_lookup, word}, [v(m), v(k)]),
+         [{option_none(), {integer, 0}},
-                [{option_none(), {integer, 0}},
+          {{var_ref, "_"}, {integer, 1}}]},
-                 {{var_ref, "_"}, {integer, 1}}]},
+     word}.
-     word};
 
-builtin_function(Builtin = {map_upd, Type}) ->
+builtin_map_upd(Type) ->
     %% function map_upd(map, key, fun) =
     %%   map_put(map, key, fun(map_get(map, key)))
-    {{builtin, Builtin}, [private],
+    {[{"map", word}, {"key", word}, {"valfun", word}],
-     [{"map", word}, {"key", word}, {"valfun", word}],
      ?call(map_put,
         [v(map), v(key),
          #funcall{ function = v(valfun),
                    args     = [?call({map_get, Type}, [v(map), v(key)])] }]),
-     word};
+     word}.
 
-builtin_function(Builtin = {map_upd_default, Type}) ->
+builtin_map_upd_default(Type) ->
     %% function map_upd(map, key, val, fun) =
     %%   map_put(map, key, fun(map_lookup_default(map, key, val)))
-    {{builtin, Builtin}, [private],
+    {[{"map", word}, {"key", word}, {"val", word}, {"valfun", word}],
-     [{"map", word}, {"key", word}, {"val", word}, {"valfun", word}],
      ?call(map_put,
         [v(map), v(key),
          #funcall{ function = v(valfun),
                    args     = [?call({map_lookup_default, Type}, [v(map), v(key), v(val)])] }]),
-     word};
+     word}.
 
-builtin_function(Builtin = map_from_list) ->
+builtin_map_from_list() ->
     %% function map_from_list(xs, acc) =
     %%   switch(xs)
     %%     [] => acc
     %%     (k, v) :: xs => map_from_list(xs, acc { [k] = v })
-    {{builtin, Builtin}, [private],
+    {[{"xs", {list, {tuple, [word, word]}}}, {"acc", word}],
-     [{"xs", {list, {tuple, [word, word]}}}, {"acc", word}],
      {switch, v(xs),
         [{{list, []}, v(acc)},
          {{binop, '::', {tuple, [v(k), v(v)]}, v(ys)},
           ?call(map_from_list,
             [v(ys), ?call(map_put, [v(acc), v(k), v(v)])])}]},
-     word};
+     word}.
 
 %% list_concat
 %%
 %% Concatenates two lists.
-builtin_function(list_concat) ->
+builtin_list_concat() ->
-    {{builtin, list_concat}, [private],
+    {[{"l1", {list, word}}, {"l2", {list, word}}],
-     [{"l1", {list, word}}, {"l2", {list, word}}],
      {switch, v(l1),
         [{{list, []}, v(l2)},
          {{binop, '::', v(hd), v(tl)},
           {binop, '::', v(hd), ?call(list_concat, [v(tl), v(l2)])}}
         ]
      },
-     word};
+     word}.
 
-builtin_function(string_length) ->
+builtin_string_length() ->
     %% function length(str) =
     %%   switch(str)
     %%      {n} -> n  // (ab)use the representation
-    {{builtin, string_length}, [private],
+    {[{"s", string}],
-        [{"s", string}],
+     ?DEREF(n, s, ?V(n)),
-        ?DEREF(n, s, ?V(n)),
+     word}.
-     word};
 
 %% str_concat - concatenate two strings
 %%
@@ -299,212 +352,333 @@ builtin_function(string_length) ->
 %% top of the Heap and the address to it is returned. The tricky bit is when
 %% the words from the second string has to be shifted to fit next to the first
 %% string.
-builtin_function(string_concat) ->
+builtin_string_concat() ->
-    {{builtin, string_concat}, [private],
+    {[{"s1", string}, {"s2", string}],
-     [{"s1", string}, {"s2", string}],
      ?DEREF(n1, s1,
      ?DEREF(n2, s2,
-        {ifte, ?EQ(n2, 0),
+        {ifte, ?EQ(n1, 0),
-            ?V(s1), %% Second string is empty return first string
+            ?V(s2), %% First string is empty return second string
-            ?LET(ret, {inline_asm, [?A(?MSIZE)]},
+            {ifte, ?EQ(n2, 0),
-                {seq, [?ADD(n1, n2), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]}, %% Store total len
+                ?V(s1), %% Second string is empty return first string
-                       ?call(string_concat_inner1, [?V(n1), ?NXT(s1), ?V(n2), ?NXT(s2)]),
+                ?LET(ret, {inline_asm, [?A(?MSIZE)]},
-                       {inline_asm, [?A(?POP)]}, %% Discard fun ret val
+                    {seq, [?ADD(n1, n2), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]}, %% Store total len
-                       ?V(ret)                   %% Put the actual return value
+                           ?call(string_concat_inner1, [?V(n1), ?NXT(s1), ?V(n2), ?NXT(s2)]),
-                      ]})}
+                           {inline_asm, [?A(?POP)]}, %% Discard fun ret val
+                           ?V(ret)                   %% Put the actual return value
+                          ]})}
+        }
      )),
-     word};
+     word}.
 
-builtin_function(string_concat_inner1) ->
+builtin_string_concat_inner1() ->
     %% Copy all whole words from the first string, and set up for word fusion
     %% Special case when the length of the first string is divisible by 32.
-    {{builtin, string_concat_inner1}, [private],
+    {[{"n1", word}, {"p1", pointer}, {"n2", word}, {"p2", pointer}],
-     [{"n1", word}, {"p1", pointer}, {"n2", word}, {"p2", pointer}],
+     ?LET(w1, ?call(string_copy, [?V(n1), ?V(p1)]),
-     ?DEREF(w1, p1,
+        ?LET(nx, ?MOD(n1, 32),
-        {ifte, ?GT(n1, 32),
+        {ifte, ?EQ(nx, 0),
-            {seq, [?V(w1), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
+            ?LET(w2, ?call(string_copy, [?V(n2), ?V(p2)]),
-                   ?call(string_concat_inner1, [?SUB(n1, 32), ?NXT(p1), ?V(n2), ?V(p2)])]},
+                {seq, [?V(w2), {inline_asm, [?A(?MSIZE), ?A(?MSTORE), ?A(?MSIZE)]}]}),
-            {ifte, ?EQ(n1, 0),
+            ?call(string_shift_copy, [?V(nx), ?V(w1), ?V(n2), ?V(p2)])
-                ?call(string_concat_inner2, [?I(32), ?I(0), ?V(n2), ?V(p2)]),
+        })),
-                ?call(string_concat_inner2, [?SUB(32, n1), ?V(w1), ?V(n2), ?V(p2)])}
+     word}.
+
+builtin_string_copy() ->
+    {[{"n", word}, {"p", pointer}],
+     ?DEREF(w, p,
+        {ifte, ?GT(n, 31),
+            {seq, [?V(w), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
+                   ?call(string_copy, [?SUB(n, 32), ?NXT(p)])]},
+            ?V(w)
         }),
-     word};
+     word}.
 
-builtin_function(string_concat_inner2) ->
+builtin_string_shift_copy() ->
-    %% Current "work in progess" word 'x', has 'o' bytes that are "free" - fill them from
+    {[{"off", word}, {"dst", word}, {"n", word}, {"p", pointer}],
-    %% words of the second string.
+     ?DEREF(w, p,
-    {{builtin, string_concat_inner2}, [private],
+        {seq, [?ADD(dst, ?BSR(w, off)), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
-     [{"o", word}, {"x", word}, {"n2", word}, {"p2", pointer}],
+               {ifte, ?GT(n, ?SUB(32, off)),
-     {ifte, ?LT(n2, 1),
+                    ?call(string_shift_copy, [?V(off), ?BSL(w, ?SUB(32, off)), ?SUB(n, 32), ?NXT(p)]),
-        {seq, [?V(x), {inline_asm, [?A(?MSIZE), ?A(?MSTORE), ?A(?MSIZE)]}]}, %% Use MSIZE as dummy return value
+                    {inline_asm, [?A(?MSIZE)]}}]
-        ?DEREF(w2, p2,
+        }),
-            {ifte, ?GT(n2, o),
+     word}.
-                {seq, [?ADD(x, ?BSR(w2, ?SUB(32, o))),
-                       {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
-                       ?call(string_concat_inner2,
-                             [?V(o), ?BSL(w2, o), ?SUB(n2, 32), ?NXT(p2)])
-                      ]},
-                {seq, [?ADD(x, ?BSR(w2, ?SUB(32, o))),
-                       {inline_asm, [?A(?MSIZE), ?A(?MSTORE), ?A(?MSIZE)]}]} %% Use MSIZE as dummy return value
-            })
-     },
-     word};
 
-builtin_function(str_equal_p) ->
+builtin_str_equal_p() ->
     %% function str_equal_p(n, p1, p2) =
     %%   if(n =< 0) true
     %%   else
     %%      let w1 = *p1
     %%      let w2 = *p2
     %%      w1 == w2 && str_equal_p(n - 32, p1 + 32, p2 + 32)
-    {{builtin, str_equal_p}, [private],
+    {[{"n", word}, {"p1", pointer}, {"p2", pointer}],
-        [{"n", word}, {"p1", pointer}, {"p2", pointer}],
+     {ifte, ?LT(n, 1),
-        {ifte, ?LT(n, 1),
+         ?I(1),
-            ?I(1),
+         ?DEREF(w1, p1,
-            ?DEREF(w1, p1,
+         ?DEREF(w2, p2,
-            ?DEREF(w2, p2,
+             ?AND(?EQ(w1, w2),
-                ?AND(?EQ(w1, w2),
+                  ?call(str_equal_p, [?SUB(n, 32), ?NXT(p1), ?NXT(p2)]))))},
-                     ?call(str_equal_p, [?SUB(n, 32), ?NXT(p1), ?NXT(p2)]))))},
+     word}.
-     word};
 
-builtin_function(str_equal) ->
+builtin_str_equal() ->
     %% function str_equal(s1, s2) =
     %%   let n1 = length(s1)
     %%   let n2 = length(s2)
     %%   n1 == n2 && str_equal_p(n1, s1 + 32, s2 + 32)
-    {{builtin, str_equal}, [private],
+    {[{"s1", string}, {"s2", string}],
-        [{"s1", string}, {"s2", string}],
+     ?DEREF(n1, s1,
-        ?DEREF(n1, s1,
+     ?DEREF(n2, s2,
-        ?DEREF(n2, s2,
+         ?AND(?EQ(n1, n2), ?call(str_equal_p, [?V(n1), ?NXT(s1), ?NXT(s2)]))
-            ?AND(?EQ(n1, n2), ?call(str_equal_p, [?V(n1), ?NXT(s1), ?NXT(s2)]))
+     )),
-        )),
+     word}.
-        word};
 
-builtin_function(int_to_str) ->
+%% Count the number of 1s in a bit field.
-    {{builtin, int_to_str}, [private],
+builtin_popcount() ->
-        [{"i0", word}],
+    %% function popcount(bits, acc) =
-        {switch, {ifte, ?LT(i0, 0),
+    %%   if (bits == 0) acc
-                    {tuple, [?I(2), ?NEG(i0), ?BSL(45, 31)]},
+    %%   else popcount(bits bsr 1, acc + bits band 1)
-                    {tuple, [?I(1), ?V(i0), ?I(0)]}},
+    {[{"bits", word}, {"acc", word}],
-        [{{tuple, [v(off), v(i), v(x)]},
+     {ifte, ?EQ(bits, 0),
-        ?LET(ret, {inline_asm, [?A(?MSIZE)]},
+        ?V(acc),
-        ?LET(n,   ?call(int_digits, [?DIV(i, 10), ?I(0)]),
+        ?call(popcount, [op('bsr', 1, bits), ?ADD(acc, op('band', bits, 1))])
-        ?LET(fac, ?EXP(10, n),
+     }, word}.
-            {seq, [?ADD(n, off), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]}, %% Store str len
-                   ?call(int_to_str_,
-                        [?MOD(i, fac), ?ADD(x, ?BSL(?ADD(48, ?DIV(i, fac)), ?SUB(32, off))), ?DIV(fac, 10), ?V(off)]),
-                   {inline_asm, [?A(?POP)]}, ?V(ret)]}
-        )))}]},
-        word};
 
-builtin_function(int_to_str_) ->
+builtin_int_to_str() ->
-    {{builtin, int_to_str_}, [private],
+    {[{"i", word}], ?call({baseX_int, 10}, [?V(i)]), word}.
-        [{"x", word}, {"y", word}, {"fac", word}, {"n", word}],
-        {ifte, ?EQ(fac, 0),
-            {seq, [?V(y), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]}, ?V(n)]},
-            {ifte, ?EQ(?MOD(n, 32), 0),
-                 %% We've filled a word, write it and start on new word
-                 {seq, [?V(y), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
-                        ?call(int_to_str_,
-                              [?MOD(x, fac), ?BSL(?ADD(48, ?DIV(x, fac)), 31),
-                               ?DIV(fac, 10), ?I(1)])]},
-                 ?call(int_to_str_,
-                       [?MOD(x, fac), ?ADD(y, ?BSL(?ADD(48, ?DIV(x, fac)), ?SUB(31, n))),
-                        ?DIV(fac, 10), ?ADD(n, 1)])}
-        },
-        word};
 
-builtin_function(int_digits) ->
+builtin_baseX_tab(_X = 10) ->
-    {{builtin, int_digits}, [private],
+    {[{"ix", word}], ?ADD($0, ix), word};
-        [{"x", word}, {"n", word}],
+builtin_baseX_tab(_X = 58) ->
-        {ifte, ?EQ(x, 0), ?V(n), ?call(int_digits, [?DIV(x, 10), ?ADD(n, 1)])},
+    <<Fst32:256>> = <<"123456789ABCDEFGHJKLMNPQRSTUVWXY">>,
-        word};
+    <<Lst26:256>> = <<"Zabcdefghijkmnopqrstuvwxyz", 0:48>>,
+    {[{"ix", word}],
+     {ifte, ?LT(ix, 32),
+         ?BYTE(ix, Fst32),
+         ?BYTE(?SUB(ix, 32), Lst26)
+     },
+     word}.
 
-builtin_function(base58_tab) ->
+builtin_baseX_int(X) ->
-    Fst32 = 22252025330403739761829862310514590177935513752035045390683118730099851483225,
+    {[{"w", word}],
-    Lst26 = 40880219588527126470443504235291962205031881694701834176631306799289575931904,
+     ?LET(ret, {inline_asm, [?A(?MSIZE)]},
-    {{builtin, base58_tab}, [private],
+        {seq, [?call({baseX_int_pad, X}, [?V(w), ?I(0), ?I(0)]), {inline_asm, [?A(?POP)]}, ?V(ret)]}),
-        [{"ix", word}],
+     word}.
-        {ifte, ?LT(ix, 32),
-            ?BYTE(ix, Fst32),
-            ?BYTE(?SUB(ix, 32), Lst26)
-        }, word};
 
-builtin_function(base58_int) ->
+builtin_baseX_int_pad(X = 10) ->
-    {{builtin, base58_int}, [private],
+    {[{"src", word}, {"ix", word}, {"dst", word}],
-        [{"w", word}],
+     {ifte, ?LT(src, 0),
-        ?LET(str0, ?call(base58_int_encode, [?V(w)]),
+        ?call({baseX_int_encode, X}, [?NEG(src), ?I(1), ?BSL($-, 31)]),
-        ?LET(str1, ?call(base58_int_pad, [?V(w), ?I(0), ?I(0)]),
+        ?call({baseX_int_encode, X}, [?V(src), ?V(ix), ?V(dst)])},
-        ?LET(str2, ?call(string_concat, [?V(str0), ?V(str1)]),
+     word};
-            ?call(string_reverse, [?V(str2)])
+builtin_baseX_int_pad(X = 16) ->
-        ))),
+    {[{"src", word}, {"ix", word}, {"dst", word}],
-        word};
+        ?call({baseX_int_encode, X}, [?V(src), ?V(ix), ?V(dst)]),
+     word};
+builtin_baseX_int_pad(X = 58) ->
+    {[{"src", word}, {"ix", word}, {"dst", word}],
+     {ifte, ?GT(?ADD(?DIV(ix, 31), ?BYTE(ix, src)), 0),
+         ?call({baseX_int_encode, X}, [?V(src), ?V(ix), ?V(dst)]),
+         ?call({baseX_int_pad, X}, [?V(src), ?ADD(ix, 1), ?ADD(dst, ?BSL($1, ?SUB(31, ix)))])},
+     word}.
 
-builtin_function(string_reverse) ->
+builtin_baseX_int_encode(X) ->
-    {{builtin, string_reverse}, [private],
+    {[{"src", word}, {"ix", word}, {"dst", word}],
-        [{"s", string}],
+     ?LET(n, ?call({baseX_digits, X}, [?V(src), ?I(0)]),
-        ?DEREF(n, s,
+        {seq, [?ADD(n, ?ADD(ix, 1)), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
-        ?LET(ret, {inline_asm, [?A(?MSIZE)]},
+               ?call({baseX_int_encode_, X}, [?V(src), ?V(dst), ?EXP(X, n), ?V(ix)])]}),
-            {seq, [?V(n), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
+     word}.
-                   ?call(string_reverse_, [?NXT(s), ?I(0), ?I(31), ?SUB(?V(n), 1)]),
-                   {inline_asm, [?A(?POP)]}, ?V(ret)]})),
-        word};
 
-builtin_function(string_reverse_) ->
+builtin_baseX_int_encode_(X) ->
-    {{builtin, string_reverse_}, [private],
+    {[{"src", word}, {"dst", word}, {"fac", word}, {"ix", word}],
-        [{"p", pointer}, {"x", word}, {"i1", word}, {"i2", word}],
+     {ifte, ?EQ(fac, 0),
-        {ifte, ?LT(i2, 0),
+         {seq, [?V(dst), {inline_asm, [?A(?MSIZE), ?A(?MSTORE), ?A(?MSIZE)]}]},
-            {seq, [?V(x), {inline_asm, [?A(?MSIZE), ?A(?MSTORE), ?A(?MSIZE)]}]},
+         {ifte, ?EQ(ix, 32),
-            ?LET(p1, ?ADD(p, ?MUL(?DIV(i2, 32), 32)),
+              %% We've filled a word, write it and start on new word
-            ?DEREF(w, p1,
+              {seq, [?V(dst), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
-            ?LET(b, ?BYTE(?MOD(i2, 32), w),
+                     ?call({baseX_int_encode_, X}, [?V(src), ?I(0), ?V(fac), ?I(0)])]},
-            {ifte, ?LT(i1, 0),
+              ?call({baseX_int_encode_, X},
-                {seq, [?V(x), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
+                    [?MOD(src, fac), ?ADD(dst, ?BSL(?call({baseX_tab, X}, [?DIV(src, fac)]), ?SUB(31, ix))),
-                       ?call(string_reverse_,
+                     ?DIV(fac, X), ?ADD(ix, 1)])}
-                             [?V(p), ?BSL(b, 31), ?I(30), ?SUB(i2, 1)])]},
+     },
-                ?call(string_reverse_,
+     word}.
-                      [?V(p), ?ADD(x, ?BSL(b, i1)), ?SUB(i1, 1), ?SUB(i2, 1)])})))},
-        word};
 
-builtin_function(base58_int_pad) ->
+builtin_baseX_digits(X) ->
-    {{builtin, base58_int_pad}, [private],
+    {[{"x0", word}, {"dgts", word}],
-        [{"w", word}, {"i", word}, {"x", word}],
+     ?LET(x1, ?DIV(x0, X),
-        {ifte, ?GT(?BYTE(i, w), 0),
+        {ifte, ?EQ(x1, 0), ?V(dgts), ?call({baseX_digits, X}, [?V(x1), ?ADD(dgts, 1)])}),
-            {seq, [?V(i), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
+     word}.
-                   ?V(x), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
-                   {inline_asm, [?A(?PUSH1), 64, ?A(?MSIZE), ?A(?SUB)]}]},
-            ?call(base58_int_pad, [?V(w), ?ADD(i, 1),
-                                   ?ADD(x, ?BSL(49, ?SUB(31, i)))])},
-        word};
 
-builtin_function(base58_int_encode) ->
+builtin_bytes_to_int(32) ->
-    {{builtin, base58_int_encode}, [private],
+    {[{"w", word}], ?V(w), word};
-        [{"w", word}],
+builtin_bytes_to_int(N) when N < 32 ->
-        ?LET(ret, {inline_asm, [?A(?MSIZE), ?A(?PUSH1), 0, ?A(?MSIZE), ?A(?MSTORE)]}, %% write placeholder
+    {[{"w", word}], ?BSR(w, 32 - N), word};
-        ?LET(n, ?call(base58_int_encode_, [?V(w), ?I(0), ?I(0), ?I(31)]),
+builtin_bytes_to_int(N) when N > 32 ->
-            {seq, [?V(ret), {inline_asm, [?A(?DUP2), ?A(?SWAP1), ?A(?MSTORE)]},
+    LastFullWord = N div 32 - 1,
-                   ?V(ret)]})),
+    Body = case N rem 32 of
-        word};
+                0 -> ?DEREF(n, ?ADD(b, LastFullWord * 32), ?V(n));
+                R ->
+                    ?DEREF(hi, ?ADD(b, LastFullWord * 32),
+                    ?DEREF(lo, ?ADD(b, (LastFullWord + 1) * 32),
+                    ?ADD(?BSR(lo, 32 - R), ?BSL(hi, R))))
+           end,
+    {[{"b", pointer}], Body, word}.
 
-builtin_function(base58_int_encode_) ->
+%% Two versions of this helper function, worker for sections not even 16 bytes long
-    {{builtin, base58_int_encode_}, [private],
+%% and worker_x for the full sized chunks.
-        [{"w", word}, {"x", word}, {"n", word}, {"i", word}],
+builtin_bytes_to_str_worker_x() ->
-        {ifte, ?EQ(w, 0),
+    <<Tab:256>> = <<"0123456789ABCDEF________________">>,
-            {seq, [?V(x), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]}, ?V(n)]},
+    {[{"w", word}, {"offs", word}, {"acc", word}],
-            {ifte, ?LT(i, 0),
+     {ifte, ?EQ(offs, 16), {seq, [?V(acc), {inline_asm, [?A(?MSIZE), ?A(?MSTORE), ?A(?MSIZE)]}]},
-                {seq, [?V(x), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
+         ?LET(b,  ?BYTE(offs, w),
-                       ?call(base58_int_encode_,
+         ?LET(lo, ?BYTE(?MOD(b, 16), Tab),
-                             [?DIV(w, 58), ?BSL(?call(base58_tab, [?MOD(w, 58)]), 31),
+         ?LET(hi, ?BYTE(op('bsr', 4 , b), Tab),
-                              ?ADD(n, 1), ?I(30)])]},
+         ?call(bytes_to_str_worker_x, [?V(w), ?ADD(offs, 1), ?ADD(?BSL(acc, 2), ?ADD(?BSL(hi, 1), lo))]))))
-                ?call(base58_int_encode_,
+     },
-                    [?DIV(w, 58), ?ADD(x, ?BSL(?call(base58_tab, [?MOD(w, 58)]), i)),
+     word}.
-                     ?ADD(n, 1), ?SUB(i, 1)])}},
-        word};
 
+builtin_bytes_to_str_worker() ->
+    <<Tab:256>> = <<"0123456789ABCDEF________________">>,
+    {[{"w", word}, {"offs", word}, {"acc", word}, {"stop", word}],
+     {ifte, ?EQ(stop, offs), {seq, [?BSL(acc, ?MUL(2, ?SUB(16, offs))), {inline_asm, [?A(?MSIZE), ?A(?MSTORE), ?A(?MSIZE)]}]},
+         ?LET(b,  ?BYTE(offs, w),
+         ?LET(lo, ?BYTE(?MOD(b, 16), Tab),
+         ?LET(hi, ?BYTE(op('bsr', 4 , b), Tab),
+         ?call(bytes_to_str_worker, [?V(w), ?ADD(offs, 1), ?ADD(?BSL(acc, 2), ?ADD(?BSL(hi, 1), lo)), ?V(stop)]))))
+     },
+     word}.
 
-builtin_function(addr_to_str) ->
+builtin_bytes_to_str_body(Var, N) when N < 16 ->
-    {{builtin, addr_to_str}, [private],
+    [?call(bytes_to_str_worker, [?V(Var), ?I(0), ?I(0), ?I(N)])];
-        [{"a", word}],
+builtin_bytes_to_str_body(Var, 16) ->
-        ?call(base58_int, [?V(a)]),
+    [?call(bytes_to_str_worker_x, [?V(Var), ?I(0), ?I(0)])];
-        word}.
+builtin_bytes_to_str_body(Var, N) when N < 32 ->
+    builtin_bytes_to_str_body(Var, 16) ++ [{inline_asm, [?A(?POP)]}] ++
+    [?call(bytes_to_str_worker, [?BSL(Var, 16), ?I(0), ?I(0), ?I(N - 16)])];
+builtin_bytes_to_str_body(Var, 32) ->
+    builtin_bytes_to_str_body(Var, 16) ++ [{inline_asm, [?A(?POP)]}] ++
+    [?call(bytes_to_str_worker_x, [?BSL(Var, 16), ?I(0), ?I(0)])];
+builtin_bytes_to_str_body(Var, N) when N > 32 ->
+    WholeWords = ((N + 31) div 32) - 1,
+    lists:append(
+    [ [?DEREF(w, ?ADD(Var, 32 * I), {seq, builtin_bytes_to_str_body(w, 32)}), {inline_asm, [?A(?POP)]}]
+      || I <- lists:seq(0, WholeWords - 1) ]) ++
+    [ ?DEREF(w, ?ADD(Var, 32 * WholeWords), {seq, builtin_bytes_to_str_body(w, N - WholeWords * 32)}) ].
+
+builtin_bytes_to_str(N) when N =< 32 ->
+    {[{"w", word}],
+     ?LET(ret, {inline_asm, [?A(?MSIZE)]},
+     {seq, [?I(N * 2), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]}] ++
+            builtin_bytes_to_str_body(w, N) ++
+            [{inline_asm, [?A(?POP)]}, ?V(ret)]}),
+     string};
+builtin_bytes_to_str(N) when N > 32 ->
+    {[{"p", pointer}],
+     ?LET(ret, {inline_asm, [?A(?MSIZE)]},
+     {seq, [?I(N * 2), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]}] ++
+            builtin_bytes_to_str_body(p, N) ++
+            [{inline_asm, [?A(?POP)]}, ?V(ret)]}),
+     string}.
+
+builtin_string_reverse() ->
+    {[{"s", string}],
+     ?DEREF(n, s,
+     ?LET(ret, {inline_asm, [?A(?MSIZE)]},
+         {seq, [?V(n), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
+                ?call(string_reverse_, [?NXT(s), ?I(0), ?I(31), ?SUB(?V(n), 1)]),
+                {inline_asm, [?A(?POP)]}, ?V(ret)]})),
+     word}.
+
+builtin_string_reverse_() ->
+    {[{"p", pointer}, {"x", word}, {"i1", word}, {"i2", word}],
+     {ifte, ?LT(i2, 0),
+         {seq, [?V(x), {inline_asm, [?A(?MSIZE), ?A(?MSTORE), ?A(?MSIZE)]}]},
+         ?LET(p1, ?ADD(p, ?MUL(?DIV(i2, 32), 32)),
+         ?DEREF(w, p1,
+         ?LET(b, ?BYTE(?MOD(i2, 32), w),
+         {ifte, ?LT(i1, 0),
+             {seq, [?V(x), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
+                    ?call(string_reverse_,
+                          [?V(p), ?BSL(b, 31), ?I(30), ?SUB(i2, 1)])]},
+             ?call(string_reverse_,
+                   [?V(p), ?ADD(x, ?BSL(b, i1)), ?SUB(i1, 1), ?SUB(i2, 1)])})))},
+     word}.
+
+builtin_addr_to_str() ->
+    {[{"a", word}], ?call({baseX_int, 58}, [?V(a)]), word}.
+
+%% At most one word
+%% | ..... | ========= | ........ |
+%%    Offs ^ ^- Len -^   TotalLen ^
+bytes_slice(Offs, Len, TotalLen, Bytes) when TotalLen =< 32 ->
+    %% Bytes are packed into a single word
+    Masked =
+        case Offs of
+            0 -> Bytes;
+            _ -> ?MOD(Bytes, 1 bsl ((32 - Offs) * 8))
+        end,
+    Unpadded =
+        case 32 - (Offs + Len) of
+            0 -> Masked;
+            N -> ?BSR(Masked, N)
+        end,
+    case Len of
+        32 -> Unpadded;
+        _  -> ?BSL(Unpadded, 32 - Len)
+    end;
+bytes_slice(Offs, Len, TotalLen, Bytes) when TotalLen > 32 ->
+    %% Bytes is a pointer to memory. The VM can read at non-aligned addresses.
+    %% Might read one word more than necessary.
+    Word = op('!', Offs, Bytes),
+    case Len == 32 of
+        true -> Word;
+        _    -> ?BSL(?BSR(Word, 32 - Len), 32 - Len)
+    end.
+
+builtin_bytes_concat(A, B) ->
+    Type     = fun(N) when N =< 32 -> word; (_) -> pointer end,
+    MkBytes  = fun([W]) -> W;
+                  (Ws)  -> {tuple, Ws} end,
+    Words    = fun(N) -> (N + 31) div 32 end,
+    WordsRes = Words(A + B),
+    Word = fun(I) when 32 * (I + 1) =< A -> bytes_slice(I * 32, 32, A, ?V(a));
+              (I) when 32 * I < A ->
+                   Len = A rem 32,
+                   Hi  = bytes_slice(32 * I, Len, A, ?V(a)),
+                   Lo  = bytes_slice(0, min(32 - Len, B), B, ?V(b)),
+                   ?ADD(Hi, ?BSR(Lo, Len));
+              (I) ->
+                   Offs = 32 * I - A,
+                   Len  = min(32, B - Offs),
+                   bytes_slice(Offs, Len, B, ?V(b))
+           end,
+    Body =
+        case {A, B} of
+            {0, _} -> ?V(b);
+            {_, 0} -> ?V(a);
+            _      -> MkBytes([ Word(I) || I <- lists:seq(0, WordsRes - 1) ])
+        end,
+    {[{"a", Type(A)}, {"b", Type(B)}], Body, Type(A + B)}.
+
+builtin_bytes_split(A, B) ->
+    Type    = fun(N) when N =< 32 -> word; (_) -> pointer end,
+    MkBytes = fun([W]) -> W;
+                 (Ws)  -> {tuple, Ws} end,
+    Word    = fun(I, Max) ->
+                bytes_slice(I, min(32, Max - I), A + B, ?V(c))
+              end,
+    Body =
+        case {A, B} of
+            {0, _} -> [?I(0), ?V(c)];
+            {_, 0} -> [?V(c), ?I(0)];
+            _      -> [MkBytes([ Word(I, A)     || I <- lists:seq(0, A - 1, 32) ]),
+                       MkBytes([ Word(I, A + B) || I <- lists:seq(A, A + B - 1, 32) ])]
+        end,
+    {[{"c", Type(A + B)}], {tuple, Body}, {tuple, [Type(A), Type(B)]}}.
+
+bytes_to_raw_string(N, Term) when N =< 32 ->
+    {tuple, [?I(N), Term]};
+bytes_to_raw_string(N, Term) when N > 32 ->
+    Elem  = fun(I) -> #binop{op = '!', left = ?I(32 * I), right = ?V(bin)}
+            end,
+    Words = (N + 31) div 32,
+    ?LET(bin, Term, {tuple, [?I(N) | [Elem(I) || I <- lists:seq(0, Words - 1)]]}).
 

src/aeso_code_errors.erl

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

src/aeso_compiler.erl

@@ -11,141 +11,467 @@
 -export([ file/1
         , file/2
         , from_string/2
-        , check_call/2
+        , check_call/4
-        , create_calldata/3
+        , create_calldata/3  %% deprecated
+        , create_calldata/4
         , version/0
         , sophia_type_to_typerep/1
+        , to_sophia_value/4  %% deprecated, need a backend
+        , to_sophia_value/5
+        , decode_calldata/3  %% deprecated
+        , decode_calldata/4
+        , parse/2
+        , add_include_path/2
         ]).
 
 -include_lib("aebytecode/include/aeb_opcodes.hrl").
 -include("aeso_icode.hrl").
 
 
--type option() :: pp_sophia_code | pp_ast | pp_icode | pp_assembler |
+-type option() :: pp_sophia_code
-                  pp_bytecode.
+                | pp_ast
+                | pp_types
+                | pp_typed_ast
+                | pp_icode
+                | pp_assembler
+                | pp_bytecode
+                | no_code
+                | {backend, aevm | fate}
+                | {include, {file_system, [string()]} |
+                            {explicit_files, #{string() => binary()}}}
+                | {src_file, string()}.
 -type options() :: [option()].
 
 -export_type([ option/0
              , options/0
              ]).
 
--define(COMPILER_VERSION_1, 1).
+-spec version() -> {ok, binary()} | {error, term()}.
--define(COMPILER_VERSION_2, 2).
-
--define(COMPILER_VERSION, ?COMPILER_VERSION_2).
-
--spec version() -> pos_integer().
 version() ->
-    ?COMPILER_VERSION.
+    case lists:keyfind(aesophia, 1, application:loaded_applications()) of
+        false ->
+            case application:load(aesophia) of
+                ok ->
+                    case application:get_key(aesophia, vsn) of
+                        {ok, VsnString} ->
+                            {ok, list_to_binary(VsnString)};
+                        undefined ->
+                            {error, failed_to_load_aesophia}
+                    end;
+                Err = {error, _} ->
+                    Err
+            end;
+        {_App, _Des, VsnString} ->
+            {ok, list_to_binary(VsnString)}
+    end.
 
--spec file(string()) -> map().
+-spec file(string()) -> {ok, map()} | {error, [aeso_errors:error()]}.
 file(Filename) ->
     file(Filename, []).
 
--spec file(string(), options()) -> map().
+-spec file(string(), options()) -> {ok, map()} | {error, [aeso_errors:error()]}.
-file(Filename, Options) ->
+file(File, Options0) ->
-    C = read_contract(Filename),
+    Options = add_include_path(File, Options0),
-    from_string(C, Options).
+    case read_contract(File) of
+        {ok, Bin} -> from_string(Bin, [{src_file, File} | Options]);
+        {error, Error} ->
+            Msg = lists:flatten([File,": ",file:format_error(Error)]),
+            {error, [aeso_errors:new(file_error, Msg)]}
+    end.
 
--spec from_string(string(), options()) -> map().
+add_include_path(File, Options) ->
-from_string(ContractString, Options) ->
+    case lists:keymember(include, 1, Options) of
-    Ast = parse(ContractString, Options),
+        true  -> Options;
-    ok = pp_sophia_code(Ast, Options),
+        false ->
-    ok = pp_ast(Ast, Options),
+            Dir = filename:dirname(File),
-    TypedAst = aeso_ast_infer_types:infer(Ast, Options),
+            {ok, Cwd} = file:get_cwd(),
-    %% pp_types is handled inside aeso_ast_infer_types.
+            [{include, {file_system, [Cwd, Dir]}} | Options]
-    ok = pp_typed_ast(TypedAst, Options),
+    end.
-    ICode = to_icode(TypedAst, Options),
+
-    TypeInfo = extract_type_info(ICode),
+-spec from_string(binary() | string(), options()) -> {ok, map()} | {error, [aeso_errors:error()]}.
-    ok = pp_icode(ICode, Options),
+from_string(Contract, Options) ->
-    Assembler =  assemble(ICode, Options),
+    from_string(proplists:get_value(backend, Options, aevm), Contract, Options).
-    ok = pp_assembler(Assembler, Options),
+
+from_string(Backend, ContractBin, Options) when is_binary(ContractBin) ->
+    from_string(Backend, binary_to_list(ContractBin), Options);
+from_string(Backend, ContractString, Options) ->
+    try
+        from_string1(Backend, ContractString, Options)
+    catch
+        throw:{error, Errors} -> {error, Errors}
+    end.
+
+from_string1(aevm, ContractString, Options) ->
+    #{icode := Icode} = string_to_code(ContractString, Options),
+    TypeInfo  = extract_type_info(Icode),
+    Assembler = assemble(Icode, Options),
+    pp_assembler(aevm, Assembler, Options),
     ByteCodeList = to_bytecode(Assembler, Options),
     ByteCode = << << B:8 >> || B <- ByteCodeList >>,
-    ok = pp_bytecode(ByteCode, Options),
+    pp_bytecode(ByteCode, Options),
-    #{byte_code => ByteCode, type_info => TypeInfo,
+    {ok, Version} = version(),
-      contract_source => ContractString,
+    {ok, #{byte_code => ByteCode,
-      compiler_version => version()}.
+           compiler_version => Version,
+           contract_source => ContractString,
+           type_info => TypeInfo,
+           abi_version => aeb_aevm_abi:abi_version(),
+           payable => maps:get(payable, Icode)
+          }};
+from_string1(fate, ContractString, Options) ->
+    #{fcode := FCode} = string_to_code(ContractString, Options),
+    FateCode = aeso_fcode_to_fate:compile(FCode, Options),
+    pp_assembler(fate, FateCode, Options),
+    ByteCode = aeb_fate_code:serialize(FateCode, []),
+    {ok, Version} = version(),
+    {ok, #{byte_code => ByteCode,
+           compiler_version => Version,
+           contract_source => ContractString,
+           type_info => [],
+           fate_code => FateCode,
+           abi_version => aeb_fate_abi:abi_version(),
+           payable => maps:get(payable, FCode)
+          }}.
 
--define(CALL_NAME, "__call").
+-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),
+    case proplists:get_value(backend, Options, aevm) of
+        aevm ->
+            Icode = ast_to_icode(TypedAst, Options),
+            pp_icode(Icode, Options),
+            #{ icode => Icode,
+               typed_ast => TypedAst,
+               type_env  => TypeEnv};
+        fate ->
+            Fcode = aeso_ast_to_fcode:ast_to_fcode(TypedAst, Options),
+            #{ fcode => Fcode,
+               typed_ast => TypedAst,
+               type_env  => TypeEnv}
+    end.
+
+-define(CALL_NAME,   "__call").
+-define(DECODE_NAME, "__decode").
 
 %% Takes a string containing a contract with a declaration/prototype of a
-%% function (foo, say) and a function __call() = foo(args) calling this
+%% function (foo, say) and adds function __call() = foo(args) calling this
 %% function. Returns the name of the called functions, typereps and Erlang
 %% terms for the arguments.
--spec check_call(string(), options()) -> {ok, string(), {[Type], Type | any}, [term()]} | {error, term()}
+%% NOTE: Special treatment for "init" since it might be implicit and has
+%%       a special return type (typerep, T)
+-spec check_call(string(), string(), [string()], options()) -> {ok, string(), {[Type], Type}, [term()]}
+                                                                   | {ok, string(), [term()]}
+                                                                   | {error, [aeso_errors:error()]}
     when Type :: term().
-check_call(ContractString, Options) ->
+check_call(Source, "init" = FunName, Args, Options) ->
-    Ast = parse(ContractString, Options),
+    case check_call1(Source, FunName, Args, Options) of
-    ok = pp_sophia_code(Ast, Options),
+        Err = {error, _} when Args == [] ->
-    ok = pp_ast(Ast, Options),
+            %% Try with default init-function
-    TypedAst = aeso_ast_infer_types:infer(Ast, [permissive_address_literals]),
+            case check_call1(insert_init_function(Source, Options), FunName, Args, Options) of
-    {ok, {FunName, {fun_t, _, _, ArgTypes, RetType}}} = get_call_type(TypedAst),
+                {error, _} -> Err; %% The first error is most likely better...
-    ok = pp_typed_ast(TypedAst, Options),
+                Res        -> Res
-    Icode = to_icode(TypedAst, Options),
+            end;
-    ArgVMTypes = [ aeso_ast_to_icode:ast_typerep(T, Icode) || T <- ArgTypes ],
+        Res ->
-    RetVMType  = case RetType of
+            Res
-                    {id, _, "_"} -> any;
-                    _            -> aeso_ast_to_icode:ast_typerep(RetType, Icode)
-                end,
-    ok = pp_icode(Icode, Options),
-    #{ functions := Funs } = Icode,
-    ArgIcode = get_arg_icode(Funs),
-    try [ icode_to_term(T, Arg) || {T, Arg} <- lists:zip(ArgVMTypes, ArgIcode) ] of
-        ArgTerms ->
-            {ok, FunName, {ArgVMTypes, RetVMType}, ArgTerms}
-    catch throw:Err ->
-        {error, Err}
-    end.
-
--spec create_calldata(map(), string(), string()) ->
-                             {ok, aeso_sophia:heap(), aeso_sophia:type(), aeso_sophia:type()}
-                                 | {error, argument_syntax_error}.
-create_calldata(Contract, "", CallCode) when is_map(Contract) ->
-    case check_call(CallCode, []) of
-        {ok, FunName, {ArgTypes, RetType}, Args} ->
-            aeso_abi:create_calldata(Contract, FunName, Args, ArgTypes, RetType);
-        {error, _} = Err -> Err
     end;
-create_calldata(Contract, Function, Argument) when is_map(Contract) ->
+check_call(Source, FunName, Args, Options) ->
-    %% Slightly hacky shortcut to let you get away without writing the full
+    check_call1(Source, FunName, Args, Options).
-    %% call contract code.
+
-    %% Function should be "foo : type", and
+check_call1(ContractString0, FunName, Args, Options) ->
-    %% Argument should be "Arg1, Arg2, .., ArgN" (no parens)
+    try
-    case string:lexemes(Function, ": ") of
+        case proplists:get_value(backend, Options, aevm) of
-                     %% If function is a single word fallback to old calldata generation
+            aevm ->
-        [FunName] -> aeso_abi:old_create_calldata(Contract, FunName, Argument);
+                %% First check the contract without the __call function
-        [FunName | _] ->
+                #{} = string_to_code(ContractString0, Options),
-            Args    = lists:map(fun($\n) -> 32; (X) -> X end, Argument),    %% newline to space
+                ContractString = insert_call_function(ContractString0, ?CALL_NAME, FunName, Args, Options),
-            CallContract = lists:flatten(
+                #{typed_ast := TypedAst,
-                [ "contract Call =\n"
+                  icode     := Icode} = string_to_code(ContractString, Options),
-                , "  function ", Function, "\n"
+                {ok, {FunName, {fun_t, _, _, ArgTypes, RetType}}} = get_call_type(TypedAst),
-                , "  function __call() = ", FunName, "(", Args, ")"
+                ArgVMTypes = [ aeso_ast_to_icode:ast_typerep(T, Icode) || T <- ArgTypes ],
-                ]),
+                RetVMType  = case RetType of
-            create_calldata(Contract, "", CallContract)
+                                 {id, _, "_"} -> any;
+                                 _            -> aeso_ast_to_icode:ast_typerep(RetType, Icode)
+                             end,
+                #{ functions := Funs } = Icode,
+                ArgIcode = get_arg_icode(Funs),
+                ArgTerms = [ icode_to_term(T, Arg) ||
+                               {T, Arg} <- lists:zip(ArgVMTypes, ArgIcode) ],
+                RetVMType1 =
+                    case FunName of
+                        "init" -> {tuple, [typerep, RetVMType]};
+                        _ -> RetVMType
+                    end,
+                {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, []),
+                %% 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),
+                #{fcode := Fcode} = string_to_code(ContractString, Options),
+                CallArgs = arguments_of_body(CallName, FunName, Fcode),
+                {ok, FunName, CallArgs}
+        end
+    catch
+        throw:{error, Errors} -> {error, Errors}
     end.
 
+arguments_of_body(CallName, _FunName, Fcode) ->
+    #{body := Body} = maps:get({entrypoint, list_to_binary(CallName)}, maps:get(functions, Fcode)),
+    {def, _FName, Args} = Body,
+    %% FName is either {entrypoint, list_to_binary(FunName)} or 'init'
+    [ aeso_fcode_to_fate:term_to_fate(A) || A <- Args ].
+
+first_none_match(_CallName, _Hashes, []) ->
+    error(unable_to_find_unique_call_name);
+first_none_match(CallName, Hashes, [Char|Chars]) ->
+    case not lists:member(aeb_fate_code:symbol_identifier(list_to_binary(CallName)), Hashes) of
+        true ->
+            CallName;
+        false ->
+            first_none_match(?CALL_NAME++[Char], Hashes, 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),
+    Ind = last_contract_indent(Ast),
+    lists:flatten(
+        [ Code,
+          "\n\n",
+          lists:duplicate(Ind, " "),
+          "stateful entrypoint ", Call, "() = ", FunName, "(", string:join(Args, ","), ")\n"
+        ]).
+
+-spec insert_init_function(string(), options()) -> string().
+insert_init_function(Code, Options) ->
+    Ast = parse(Code, Options),
+    Ind = last_contract_indent(Ast),
+    lists:flatten(
+        [ Code,
+          "\n\n",
+          lists:duplicate(Ind, " "), "entrypoint init() = ()\n"
+        ]).
+
+last_contract_indent(Decls) ->
+    case lists:last(Decls) of
+        {_, _, _, [Decl | _]} -> aeso_syntax:get_ann(col, Decl, 1) - 1;
+        _                     -> 0
+    end.
+
+-spec to_sophia_value(string(), string(), ok | error | revert, aeb_aevm_data:data()) ->
+        {ok, aeso_syntax:expr()} | {error, [aeso_errors:error()]}.
+to_sophia_value(ContractString, Fun, ResType, Data) ->
+    to_sophia_value(ContractString, Fun, ResType, Data, [{backend, aevm}]).
+
+-spec to_sophia_value(string(), string(), ok | error | revert, binary(), options()) ->
+        {ok, aeso_syntax:expr()} | {error, [aeso_errors:error()]}.
+to_sophia_value(_, _, error, Err, _Options) ->
+    {ok, {app, [], {id, [], "error"}, [{string, [], Err}]}};
+to_sophia_value(_, _, revert, Data, Options) ->
+    case proplists:get_value(backend, Options, aevm) of
+        aevm ->
+            case aeb_heap:from_binary(string, Data) of
+                {ok, Err} ->
+                    {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}};
+                {error, _} ->
+                    Msg = "Could not interpret the revert message\n",
+                    {error, [aeso_errors:new(data_error, Msg)]}
+            end;
+        fate ->
+            try aeb_fate_encoding:deserialize(Data) of
+                Err -> {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}}
+            catch _:_ ->
+                Msg = "Could not deserialize the revert message\n",
+                {error, [aeso_errors:new(data_error, Msg)]}
+            end
+    end;
+to_sophia_value(ContractString, FunName, ok, Data, Options0) ->
+    Options = [no_code | Options0],
+    try
+        Code = string_to_code(ContractString, Options),
+        #{ typed_ast := TypedAst, type_env  := TypeEnv} = Code,
+        {ok, _, Type0} = get_decode_type(FunName, TypedAst),
+        Type   = aeso_ast_infer_types:unfold_types_in_type(TypeEnv, Type0, [unfold_record_types, unfold_variant_types]),
+
+        case proplists:get_value(backend, Options, aevm) of
+            aevm ->
+                Icode  = maps:get(icode, Code),
+                VmType = aeso_ast_to_icode:ast_typerep(Type, Icode),
+                case aeb_heap:from_binary(VmType, Data) of
+                    {ok, VmValue} ->
+                        try
+                            {ok, aeso_vm_decode:from_aevm(VmType, Type, VmValue)}
+                        catch throw:cannot_translate_to_sophia ->
+                            Type0Str = prettypr:format(aeso_pretty:type(Type0)),
+                            Msg = io_lib:format("Cannot translate VM value ~p\n  of type ~p\n  to Sophia type ~s\n",
+                                                [Data, VmType, Type0Str]),
+                            {error, [aeso_errors:new(data_error, Msg)]}
+                        end;
+                    {error, _Err} ->
+                        Msg = io_lib:format("Failed to decode binary as type ~p\n", [VmType]),
+                        {error, [aeso_errors:new(data_error, Msg)]}
+                end;
+            fate ->
+                try
+                    {ok, aeso_vm_decode:from_fate(Type, aeb_fate_encoding:deserialize(Data))}
+                catch throw:cannot_translate_to_sophia ->
+                        Type1 = prettypr:format(aeso_pretty:type(Type)),
+                        Msg = io_lib:format("Cannot translate FATE value ~p\n  of Sophia type ~s\n",
+                                            [aeb_fate_encoding:deserialize(Data), Type1]),
+                        {error, [aeso_errors:new(data_error, Msg)]};
+                      _:_ ->
+                        Type1 = prettypr:format(aeso_pretty:type(Type)),
+                        Msg = io_lib:format("Failed to decode binary as type ~s\n", [Type1]),
+                        {error, [aeso_errors:new(data_error, Msg)]}
+               end
+        end
+    catch
+        throw:{error, Errors} -> {error, Errors}
+    end.
+
+
+-spec create_calldata(string(), string(), [string()]) ->
+                             {ok, binary(), aeb_aevm_data:type(), aeb_aevm_data:type()}
+                             | {error, [aeso_errors:error()]}.
+create_calldata(Code, Fun, Args) ->
+    create_calldata(Code, Fun, Args, [{backend, aevm}]).
+
+-spec create_calldata(string(), string(), [string()], [{atom(), any()}]) ->
+                             {ok, binary()} | {error, [aeso_errors:error()]}.
+create_calldata(Code, Fun, Args, Options0) ->
+    Options = [no_code | Options0],
+    case proplists:get_value(backend, Options, aevm) of
+        aevm ->
+            case check_call(Code, Fun, Args, Options) of
+                {ok, FunName, {ArgTypes, RetType}, VMArgs} ->
+                    aeb_aevm_abi:create_calldata(FunName, VMArgs, ArgTypes, RetType);
+                {error, _} = Err -> Err
+            end;
+        fate ->
+            case check_call(Code, Fun, Args, Options) of
+                {ok, FunName, FateArgs} ->
+                    aeb_fate_abi:create_calldata(FunName, FateArgs);
+                {error, _} = Err -> Err
+            end
+    end.
+
+-spec decode_calldata(string(), string(), binary()) ->
+                             {ok, [aeso_syntax:type()], [aeso_syntax:expr()]}
+                             | {error, [aeso_errors:error()]}.
+decode_calldata(ContractString, FunName, Calldata) ->
+    decode_calldata(ContractString, FunName, Calldata, [{backend, aevm}]).
+
+decode_calldata(ContractString, FunName, Calldata, Options0) ->
+    Options = [no_code | Options0],
+    try
+        Code = string_to_code(ContractString, Options),
+        #{ typed_ast := TypedAst, type_env  := TypeEnv} = Code,
+
+        {ok, Args, _} = get_decode_type(FunName, TypedAst),
+        DropArg       = fun({arg, _, _, T}) -> T; (T) -> T end,
+        ArgTypes      = lists:map(DropArg, Args),
+        Type0         = {tuple_t, [], ArgTypes},
+        %% user defined data types such as variants needed to match against
+        Type          = aeso_ast_infer_types:unfold_types_in_type(TypeEnv, Type0, [unfold_record_types, unfold_variant_types]),
+        case proplists:get_value(backend, Options, aevm) of
+            aevm ->
+                Icode  = maps:get(icode, Code),
+                VmType = aeso_ast_to_icode:ast_typerep(Type, Icode),
+                case aeb_heap:from_binary({tuple, [word, VmType]}, Calldata) of
+                    {ok, {_, VmValue}} ->
+                        try
+                            {tuple, [], Values} = aeso_vm_decode:from_aevm(VmType, Type, VmValue),
+                            %% Values are Sophia expressions in AST format
+                            {ok, ArgTypes, Values}
+                        catch throw:cannot_translate_to_sophia ->
+                            Type0Str = prettypr:format(aeso_pretty:type(Type0)),
+                            Msg = io_lib:format("Cannot translate VM value ~p\n  of type ~p\n  to Sophia type ~s\n",
+                                                [VmValue, VmType, Type0Str]),
+                            {error, [aeso_errors:new(data_error, Msg)]}
+                        end;
+                    {error, _Err} ->
+                        Msg = io_lib:format("Failed to decode calldata as type ~p\n", [VmType]),
+                        {error, [aeso_errors:new(data_error, Msg)]}
+                end;
+            fate ->
+                case aeb_fate_abi:decode_calldata(FunName, Calldata) of
+                    {ok, FateArgs} ->
+                        try
+                            {tuple_t, [], ArgTypes1} = Type,
+                            AstArgs = [ aeso_vm_decode:from_fate(ArgType, FateArg)
+                                        || {ArgType, FateArg} <- lists:zip(ArgTypes1, FateArgs)],
+                            {ok, ArgTypes, AstArgs}
+                        catch throw:cannot_translate_to_sophia ->
+                                Type0Str = prettypr:format(aeso_pretty:type(Type0)),
+                                Msg = io_lib:format("Cannot translate FATE value ~p\n  to Sophia type ~s\n",
+                                                    [FateArgs, Type0Str]),
+                                {error, [aeso_errors:new(data_error, Msg)]}
+                        end;
+                    {error, _} ->
+                        Msg = io_lib:format("Failed to decode calldata binary\n", []),
+                        {error, [aeso_errors:new(data_error, Msg)]}
+                end
+        end
+    catch
+        throw:{error, Errors} -> {error, Errors}
+    end.
 
 get_arg_icode(Funs) ->
-    [Args] = [ Args || {?CALL_NAME, _, _, {funcall, _, Args}, _} <- Funs ],
+    case [ Args || {[_, ?CALL_NAME], _, _, {funcall, _, Args}, _} <- Funs ] of
-    Args.
+        [Args] -> Args;
+        []     -> error_missing_call_function()
+    end.
+
+-dialyzer({nowarn_function, error_missing_call_function/0}).
+error_missing_call_function() ->
+    Msg = "Internal error: missing '__call'-function",
+    aeso_errors:throw(aeso_errors:new(internal_error, Msg)).
 
 get_call_type([{contract, _, _, Defs}]) ->
-    case [ {FunName, FunType}
+    case [ {lists:last(QFunName), FunType}
           || {letfun, _, {id, _, ?CALL_NAME}, [], _Ret,
                 {typed, _,
                     {app, _,
-                        {typed, _, {id, _, FunName}, FunType}, _}, _}} <- Defs ] of
+                        {typed, _, {qid, _, QFunName}, FunType}, _}, _}} <- Defs ] of
         [Call] -> {ok, Call};
-        []     -> {error, missing_call_function}
+        []     -> error_missing_call_function()
     end;
 get_call_type([_ | Contracts]) ->
     %% The __call should be in the final contract
     get_call_type(Contracts).
 
+-dialyzer({nowarn_function, get_decode_type/2}).
+get_decode_type(FunName, [{contract, Ann, _, Defs}]) ->
+    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,
+    case lists:flatmap(GetType, Defs) of
+        [{Args, Ret}] -> {ok, Args, Ret};
+        []            ->
+            case FunName of
+                "init" -> {ok, [], {tuple_t, [], []}};
+                 _ ->
+                    Msg = io_lib:format("Function '~s' is missing in contract\n", [FunName]),
+                    Pos = aeso_code_errors:pos(Ann),
+                    aeso_errors:throw(aeso_errors:new(data_error, Pos, Msg))
+            end
+    end;
+get_decode_type(FunName, [_ | Contracts]) ->
+    %% The __decode should be in the final contract
+    get_decode_type(FunName, Contracts).
+
 %% Translate an icode value (error if not value) to an Erlang term that can be
-%% consumed by aeso_heap:to_binary().
+%% consumed by aeb_heap:to_binary().
 icode_to_term(word, {integer, N}) -> N;
+icode_to_term(word, {unop, '-', {integer, N}}) -> -N;
 icode_to_term(string, {tuple, [{integer, Len} | Words]}) ->
     <<Str:Len/binary, _/binary>> = << <<W:256>> || {integer, W} <- Words >>,
     Str;
@@ -177,10 +503,7 @@ icode_to_term(T, V) ->
 icodes_to_terms(Ts, Vs) ->
     [ icode_to_term(T, V) || {T, V} <- lists:zip(Ts, Vs) ].
 
-parse(C,_Options) ->
+ast_to_icode(TypedAst, Options) ->
-    parse_string(C).
-
-to_icode(TypedAst, Options) ->
     aeso_ast_to_icode:convert_typed(TypedAst, Options).
 
 assemble(Icode, Options) ->
@@ -194,7 +517,10 @@ to_bytecode([Op|Rest], Options) ->
 to_bytecode([], _) -> [].
 
 extract_type_info(#{functions := Functions} =_Icode) ->
-    TypeInfo = [aeso_abi:function_type_info(list_to_binary(Name), Args, TypeRep)
+    ArgTypesOnly = fun(As) -> [ T || {_, T} <- As ] end,
+    Payable = fun(Attrs) -> proplists:get_value(payable, Attrs, false) end,
+    TypeInfo = [aeb_aevm_abi:function_type_info(list_to_binary(lists:last(Name)),
+                                            Payable(Attrs), ArgTypesOnly(Args), TypeRep)
                 || {Name, Attrs, Args,_Body, TypeRep} <- Functions,
                    not is_tuple(Name),
                    not lists:member(private, Attrs)
@@ -207,9 +533,11 @@ pp_sophia_code(C, Opts)->  pp(C, Opts, pp_sophia_code, fun(Code) ->
 pp_ast(C, Opts)      ->  pp(C, Opts, pp_ast, fun aeso_ast:pp/1).
 pp_typed_ast(C, Opts)->  pp(C, Opts, pp_typed_ast, fun aeso_ast:pp_typed/1).
 pp_icode(C, Opts)    ->  pp(C, Opts, pp_icode, fun aeso_icode:pp/1).
-pp_assembler(C, Opts)->  pp(C, Opts, pp_assembler, fun aeb_asm:pp/1).
 pp_bytecode(C, Opts) ->  pp(C, Opts, pp_bytecode, fun aeb_disassemble:pp/1).
 
+pp_assembler(aevm, C, Opts) ->  pp(C, Opts, pp_assembler, fun aeb_asm:pp/1);
+pp_assembler(fate, C, Opts) ->  pp(C, Opts, pp_assembler, fun(Asm) -> io:format("~s", [aeb_fate_asm:pp(Asm)]) end).
+
 pp(Code, Options, Option, PPFun) ->
     case proplists:lookup(Option, Options) of
         {Option, true} ->
@@ -218,9 +546,7 @@ pp(Code, Options, Option, PPFun) ->
             ok
     end.
 
-
 %% -------------------------------------------------------------------
-%% TODO: Tempoary parser hook below...
 
 sophia_type_to_typerep(String) ->
     {ok, Ast} = aeso_parser:type(String),
@@ -229,31 +555,13 @@ sophia_type_to_typerep(String) ->
     catch _:_ -> {error, bad_type}
     end.
 
-parse_string(Text) ->
+-spec parse(string(), aeso_compiler:options()) -> none() | aeso_syntax:ast().
-    %% Try and return something sensible here!
+parse(Text, Options) ->
-    case aeso_parser:string(Text) of
+    parse(Text, sets:new(), Options).
-        %% Yay, it worked!
-        {ok, Contract} -> Contract;
-        %% Scan errors.
-        {error, {Pos, scan_error}} ->
-            parse_error(Pos, "scan error");
-        {error, {Pos, scan_error_no_state}} ->
-            parse_error(Pos, "scan error");
-        %% Parse errors.
-        {error, {Pos, parse_error, Error}} ->
-            parse_error(Pos, Error);
-        {error, {Pos, ambiguous_parse, As}} ->
-            ErrorString = io_lib:format("Ambiguous ~p", [As]),
-            parse_error(Pos, ErrorString)
-    end.
 
-parse_error({Line,Pos}, ErrorString) ->
+-spec parse(string(), sets:set(), aeso_compiler:options()) -> none() | aeso_syntax:ast().
-    Error = io_lib:format("line ~p, column ~p: ~s", [Line,Pos,ErrorString]),
+parse(Text, Included, Options) ->
-    error({parse_errors,[Error]}).
+    aeso_parser:string(Text, Included, Options).
 
 read_contract(Name) ->
-    {ok, Bin} = file:read_file(filename:join(contract_path(), lists:concat([Name, ".aes"]))),
+    file:read_file(Name).
-    binary_to_list(Bin).
-
-contract_path() ->
-    "apps/aesophia/test/contracts".

src/aeso_constants.erl

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

src/aeso_errors.erl

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

src/aeso_heap.erl

@@ -1,301 +0,0 @@
--module(aeso_heap).
-
--export([ to_binary/1
-        , to_binary/2
-        , from_heap/3
-        , from_binary/2
-        , from_binary/3
-        , maps_with_next_id/1
-        , set_next_id/2
-        , heap_fragment/3
-        , heap_value/3
-        , heap_value/4
-        , heap_value_pointer/1
-        , heap_value_maps/1
-        , heap_value_offset/1
-        , heap_value_heap/1
-        , heap_fragment_maps/1
-        , heap_fragment_offset/1
-        , heap_fragment_heap/1
-        ]).
-
--export_type([binary_value/0, heap_value/0, offset/0, heap_fragment/0]).
-
--include("aeso_icode.hrl").
--include_lib("aesophia/include/aeso_heap.hrl").
-
--type word()            :: non_neg_integer().
--type pointer()         :: word().
--opaque heap_fragment() :: #heap{}.
--type offset()          :: non_neg_integer().
--type binary_value()    :: binary().
--type heap_value()      :: {pointer(), heap_fragment()}.
-
-
--spec maps_with_next_id(heap_fragment()) -> #maps{}.
-%% Create just a maps value, don't keep rest of Heap
-maps_with_next_id(#heap{maps = #maps{next_id = N}}) ->
-    #maps{ next_id = N }.
-
--spec set_next_id(heap_fragment(), non_neg_integer()) -> heap_fragment().
-set_next_id(Heap, N) -> 
-    Heap#heap{ maps = Heap#heap.maps#maps{ next_id = N } }.
-
-%% -- data type heap_fragment
-
--spec heap_fragment(binary() | #{non_neg_integer() => non_neg_integer()}) -> heap_fragment().
-heap_fragment(Heap) ->
-    heap_fragment(#maps{ next_id = 0 }, 0, Heap).
-
--spec heap_fragment(#maps{}, offset(), 
-                    binary() | #{non_neg_integer() => non_neg_integer()}) -> heap_fragment().
-heap_fragment(Maps, Offset, Heap) ->
-    #heap{maps = Maps, offset = Offset, heap = Heap}.
-
--spec heap_fragment_maps(heap_fragment()) -> #maps{}.
-heap_fragment_maps(#heap{maps = Maps}) ->
-    Maps.
-
--spec heap_fragment_offset(heap_fragment()) -> offset().
-heap_fragment_offset(#heap{offset = Offs}) ->
-    Offs.
-
--spec heap_fragment_heap(heap_fragment()) -> binary() | #{non_neg_integer() => non_neg_integer()}.
-heap_fragment_heap(#heap{heap = Heap}) ->
-    Heap.
-
-
-%% -- data type heap_value
-
--spec heap_value(#maps{}, pointer(), 
-                 binary() | #{non_neg_integer() => non_neg_integer()}) -> heap_value().
-heap_value(Maps, Ptr, Heap) ->
-    heap_value(Maps, Ptr, Heap, 0).
-
--spec heap_value(#maps{}, pointer(), 
-                 binary() | #{non_neg_integer() => non_neg_integer()}, offset()) -> heap_value().
-heap_value(Maps, Ptr, Heap, Offs) ->
-    {Ptr, heap_fragment(Maps, Offs, Heap)}.
-
--spec heap_value_pointer(heap_value()) -> pointer().
-heap_value_pointer({Ptr, _}) -> Ptr.
-
--spec heap_value_maps(heap_value()) -> #maps{}.
-heap_value_maps({_, Heap}) -> Heap#heap.maps.
-
--spec heap_value_offset(heap_value()) -> offset().
-heap_value_offset({_, Heap}) -> Heap#heap.offset.
-
--spec heap_value_heap(heap_value()) -> 
-                             binary() | #{non_neg_integer() => non_neg_integer()}.
-heap_value_heap({_, Heap}) -> Heap#heap.heap.
-    
-%% -- Value to binary --------------------------------------------------------
-
--spec to_binary(aeso_sophia:data()) -> aeso_sophia:heap().
-%% Encode the data as a heap where the first word is the value (for unboxed
-%% types) or a pointer to the value (for boxed types).
-to_binary(Data) ->
-    to_binary(Data, 0).
-
-to_binary(Data, BaseAddress) ->
-    {Address, Memory} = to_binary1(Data, BaseAddress + 32),
-    R = <<Address:256, Memory/binary>>,
-    R.
-
-
-%% Allocate the data in memory, from the given address.  Return a pair
-%% of memory contents from that address and the value representing the
-%% data.
-to_binary1(Data,_Address) when is_integer(Data) ->
-    {Data,<<>>};
-to_binary1(Data, Address) when is_binary(Data) ->
-    %% a string
-    Words = aeso_memory:binary_to_words(Data),
-    {Address,<<(size(Data)):256, << <<W:256>> || W <- Words>>/binary>>};
-to_binary1(none, Address)            -> to_binary1({variant, 0, []}, Address);
-to_binary1({some, Value}, Address)   -> to_binary1({variant, 1, [Value]}, Address);
-to_binary1(word, Address)            -> to_binary1({?TYPEREP_WORD_TAG}, Address);
-to_binary1(string, Address)          -> to_binary1({?TYPEREP_STRING_TAG}, Address);
-to_binary1(typerep, Address)         -> to_binary1({?TYPEREP_TYPEREP_TAG}, Address);
-to_binary1(function, Address)        -> to_binary1({?TYPEREP_FUN_TAG}, Address);
-to_binary1({list, T}, Address)       -> to_binary1({?TYPEREP_LIST_TAG, T}, Address);
-to_binary1({option, T}, Address)     -> to_binary1({variant, [[], [T]]}, Address);
-to_binary1({tuple, Ts}, Address)     -> to_binary1({?TYPEREP_TUPLE_TAG, Ts}, Address);
-to_binary1({variant, Cons}, Address) -> to_binary1({?TYPEREP_VARIANT_TAG, Cons}, Address);
-to_binary1({map, K, V}, Address)     -> to_binary1({?TYPEREP_MAP_TAG, K, V}, Address);
-to_binary1({variant, Tag, Args}, Address) ->
-    to_binary1(list_to_tuple([Tag | Args]), Address);
-to_binary1(Map, Address) when is_map(Map) ->
-    Size = maps:size(Map),
-    %% Sort according to binary ordering
-    KVs = lists:sort([ {to_binary(K), to_binary(V)} || {K, V} <- maps:to_list(Map) ]),
-    {Address, <<Size:256, << <<(byte_size(K)):256, K/binary,
-                               (byte_size(V)):256, V/binary>> || {K, V} <- KVs >>/binary >>};
-to_binary1({}, _Address) ->
-    {0, <<>>};
-to_binary1(Data, Address) when is_tuple(Data) ->
-    {Elems,Memory} = to_binaries(tuple_to_list(Data),Address+32*size(Data)),
-    ElemsBin = << <<W:256>> || W <- Elems>>,
-    {Address,<< ElemsBin/binary, Memory/binary >>};
-to_binary1([],_Address) ->
-    <<Nil:256>> = <<(-1):256>>,
-    {Nil,<<>>};
-to_binary1([H|T],Address) ->
-    to_binary1({H,T},Address).
-
-
-to_binaries([],_Address) ->
-    {[],<<>>};
-to_binaries([H|T],Address) ->
-    {HRep,HMem} = to_binary1(H,Address),
-    {TRep,TMem} = to_binaries(T,Address+size(HMem)),
-    {[HRep|TRep],<<HMem/binary, TMem/binary>>}.
-
-%% Interpret a return value (a binary) using a type rep.
-
--spec from_heap(Type :: ?Type(), Heap :: binary(), Ptr :: integer()) ->
-        {ok, term()} | {error, term()}.
-from_heap(Type, Heap, Ptr) ->
-    try {ok, from_binary(#{}, Type, Heap, Ptr)}
-    catch _:Err ->
-        %% io:format("** Error: from_heap failed with ~p\n  ~p\n", [Err, erlang:get_stacktrace()]),
-        {error, Err}
-    end.
-
-%% Base address is the address of the first word of the given heap.
--spec from_binary(T :: ?Type(),
-                  Heap :: binary(),
-                  BaseAddr :: non_neg_integer()) ->
-        {ok, term()} | {error, term()}.
-from_binary(T, Heap = <<V:256, _/binary>>, BaseAddr) ->
-    from_heap(T, <<0:BaseAddr/unit:8, Heap/binary>>, V);
-from_binary(_, Bin, _BaseAddr) ->
-    {error, {binary_too_short, Bin}}.
-
--spec from_binary(?Type(), binary()) -> {ok, term()} | {error, term()}.
-from_binary(T, Heap) ->
-    from_binary(T, Heap, 0).
-
-from_binary(_, word, _, V) ->
-    V;
-from_binary(_, signed_word, _, V) ->
-    <<N:256/signed>> = <<V:256>>,
-    N;
-from_binary(_, bool, _, V) ->
-    case V of
-        0 -> false;
-        1 -> true
-    end;
-from_binary(_, string, Heap, V) ->
-    StringSize = heap_word(Heap,V),
-    BitAddr = 8*(V+32),
-    <<_:BitAddr,Bytes:StringSize/binary,_/binary>> = Heap,
-    Bytes;
-from_binary(_, {tuple, []}, _, _) ->
-    {};
-from_binary(Visited, {tuple,Cpts}, Heap, V) ->
-    check_circular_refs(Visited, V),
-    NewVisited = Visited#{V => true},
-    ElementNums = lists:seq(0, length(Cpts)-1),
-    TypesAndPointers = lists:zip(Cpts, ElementNums),
-    ElementAddress = fun(Index) -> V + 32 * Index end,
-    Element = fun(Index) ->
-                      heap_word(Heap, ElementAddress(Index))
-              end,
-    Convert = fun(Type, Index) ->
-                from_binary(NewVisited, Type, Heap, Element(Index))
-              end,
-    Elements = [Convert(T, I) || {T,I} <- TypesAndPointers],
-    list_to_tuple(Elements);
-from_binary(Visited, {list, Elem}, Heap, V) ->
-    <<Nil:256>> = <<(-1):256>>,
-    if V==Nil ->
-          [];
-       true ->
-          {H,T} = from_binary(Visited, {tuple,[Elem,{list,Elem}]},Heap,V),
-          [H|T]
-    end;
-from_binary(Visited, {option, A}, Heap, V) ->
-    from_binary(Visited, {variant_t, [{none, []}, {some, [A]}]}, Heap, V);
-from_binary(Visited, {variant, Cons}, Heap, V) ->
-    Tag      = heap_word(Heap, V),
-    Args     = lists:nth(Tag + 1, Cons),
-    Visited1 = Visited#{V => true},
-    {variant, Tag, tuple_to_list(from_binary(Visited1, {tuple, Args}, Heap, V + 32))};
-from_binary(Visited, {variant_t, TCons}, Heap, V) ->   %% Tagged variants
-    {Tags, Cons} = lists:unzip(TCons),
-    {variant, I, Args} = from_binary(Visited, {variant, Cons}, Heap, V),
-    Tag = lists:nth(I + 1, Tags),
-    case Args of
-        []  -> Tag;
-        _   -> list_to_tuple([Tag | Args])
-    end;
-from_binary(_Visited, {map, A, B}, Heap, Ptr) ->
-    %% FORMAT: [Size] [KeySize] Key [ValSize] Val .. [KeySize] Key [ValSize] Val
-    Size = heap_word(Heap, Ptr),
-    map_binary_to_value(A, B, Size, Heap, Ptr + 32);
-from_binary(Visited, typerep, Heap, V) ->
-    check_circular_refs(Visited, V),
-    Tag = heap_word(Heap, V),
-    Arg1 = fun(T, I) -> from_binary(Visited#{V => true}, T, Heap, heap_word(Heap, V + 32 * I)) end,
-    Arg  = fun(T) -> Arg1(T, 1) end,
-    case Tag of
-        ?TYPEREP_WORD_TAG    -> word;
-        ?TYPEREP_STRING_TAG  -> string;
-        ?TYPEREP_TYPEREP_TAG -> typerep;
-        ?TYPEREP_LIST_TAG    -> {list,    Arg(typerep)};
-        ?TYPEREP_TUPLE_TAG   -> {tuple,   Arg({list, typerep})};
-        ?TYPEREP_VARIANT_TAG -> {variant, Arg({list, {list, typerep}})};
-        ?TYPEREP_MAP_TAG     -> {map,     Arg(typerep), Arg1(typerep, 2)};
-        ?TYPEREP_FUN_TAG     -> function
-    end.
-
-map_binary_to_value(KeyType, ValType, N, Bin, Ptr) ->
-    %% Avoid looping on bogus sizes
-    MaxN = byte_size(Bin) div 64,
-    Heap = heap_fragment(Bin),
-    map_from_binary({value, KeyType, ValType}, min(N, MaxN), Heap, Ptr, #{}).
-
-map_from_binary(_, 0, _, _, Map) -> Map;
-map_from_binary({value, KeyType, ValType} = Output, I, Heap, Ptr, Map) ->
-    KeySize = get_word(Heap, Ptr),
-    KeyPtr  = Ptr + 32,
-    KeyBin  = get_chunk(Heap, KeyPtr, KeySize),
-    ValSize = get_word(Heap, KeyPtr + KeySize),
-    ValPtr  = KeyPtr + KeySize + 32,
-    ValBin  = get_chunk(Heap, ValPtr, ValSize),
-    %% Keys and values are self contained binaries
-    {ok, Key} = from_binary(KeyType, KeyBin),
-    {ok, Val} = from_binary(ValType, ValBin),
-    map_from_binary(Output, I - 1, Heap, ValPtr + ValSize,  Map#{Key => Val}).
-
-check_circular_refs(Visited, V) ->
-    case maps:is_key(V, Visited) of
-        true ->  exit(circular_references);
-        false -> ok
-    end.
-
-heap_word(Heap, Addr) when is_binary(Heap) ->
-    BitSize = 8*Addr,
-    <<_:BitSize,W:256,_/binary>> = Heap,
-    W;
-heap_word(Heap, Addr) when is_map(Heap) ->
-    0 = Addr rem 32, %% Check that it's word aligned.
-    maps:get(Addr, Heap, 0).
-
-get_word(#heap{offset = Offs, heap = Mem}, Addr) when Addr >= Offs ->
-    get_word(Mem, Addr - Offs);
-get_word(Mem, Addr) when is_binary(Mem) ->
-    <<_:Addr/unit:8, Word:256, _/binary>> = Mem,
-    Word.
-
-get_chunk(#heap{offset = Offs, heap = Mem}, Addr, Bytes) when Addr >= Offs ->
-    get_chunk(Mem, Addr - Offs, Bytes);
-get_chunk(Mem, Addr, Bytes) when is_binary(Mem) ->
-    <<_:Addr/unit:8, Chunk:Bytes/binary, _/binary>> = Mem,
-    Chunk.
-
-
-
-

src/aeso_icode.erl

@@ -9,19 +9,32 @@
 %%%-------------------------------------------------------------------
 -module(aeso_icode).
 
--export([new/1, pp/1, set_name/2, set_functions/2, map_typerep/2, option_typerep/1, get_constructor_tag/2]).
+-export([new/1,
+         pp/1,
+         set_name/2,
+         set_namespace/2,
+         set_payable/2,
+         enter_namespace/2,
+         get_namespace/1,
+         in_main_contract/1,
+         qualify/2,
+         set_functions/2,
+         map_typerep/2,
+         option_typerep/1,
+         get_constructor_tag/2]).
+
 -export_type([icode/0]).
 
 -include("aeso_icode.hrl").
 
--type type_def() :: fun(([aeso_sophia:type()]) -> aeso_sophia:type()).
+-type type_def() :: fun(([aeb_aevm_data:type()]) -> aeb_aevm_data:type()).
 
 -type bindings() :: any().
 -type fun_dec() :: { string()
                    , [modifier()]
                    , arg_list()
                    , expr()
-                   , aeso_sophia:type()}.
+                   , aeb_aevm_data:type()}.
 
 -type modifier() :: private | stateful.
 
@@ -29,13 +42,15 @@
 
 -type icode() :: #{ contract_name => string()
                   , functions => [fun_dec()]
+                  , namespace => aeso_syntax:con() | aeso_syntax:qcon()
                   , env => [bindings()]
-                  , state_type => aeso_sophia:type()
+                  , state_type => aeb_aevm_data:type()
-                  , event_type => aeso_sophia:type()
+                  , event_type => aeb_aevm_data:type()
                   , types => #{ type_name() => type_def() }
-                  , type_vars => #{ string() => aeso_sophia:type() }
+                  , type_vars => #{ string() => aeb_aevm_data:type() }
-                  , constructors => #{ string() => integer() }  %% name to tag
+                  , constructors => #{ [string()] => integer() }  %% name to tag
                   , options => [any()]
+                  , payable => boolean()
                   }.
 
 pp(Icode) ->
@@ -53,15 +68,19 @@ new(Options) ->
      , types => builtin_types()
      , type_vars => #{}
      , constructors => builtin_constructors()
-     , options => Options}.
+     , options => Options
+     , payable => false }.
 
 builtin_types() ->
     Word = fun([]) -> word end,
     #{ "bool"         => Word
      , "int"          => Word
+     , "char"         => Word
+     , "bits"         => Word
      , "string"       => fun([]) -> string end
      , "address"      => Word
      , "hash"         => Word
+     , "unit"         => fun([]) -> {tuple, []} end
      , "signature"    => fun([]) -> {tuple, [word, word]} end
      , "oracle"       => fun([_, _]) -> word end
      , "oracle_query" => fun([_, _]) -> word end
@@ -72,10 +91,10 @@ builtin_types() ->
      }.
 
 builtin_constructors() ->
-    #{ "RelativeTTL" => 0
+    #{ ["RelativeTTL"] => 0
-     , "FixedTTL"    => 1
+     , ["FixedTTL"]    => 1
-     , "None"        => 0
+     , ["None"]        => 0
-     , "Some"        => 1 }.
+     , ["Some"]        => 1 }.
 
 map_typerep(K, V) ->
     {map, K, V}.
@@ -90,11 +109,38 @@ new_env() ->
 set_name(Name, Icode) ->
     maps:put(contract_name, Name, Icode).
 
+-spec set_payable(boolean(), icode()) -> icode().
+set_payable(Payable, Icode) ->
+    maps:put(payable, Payable, Icode).
+
+-spec set_namespace(aeso_syntax:con() | aeso_syntax:qcon(), icode()) -> icode().
+set_namespace(NS, Icode) -> Icode#{ namespace => NS }.
+
+-spec enter_namespace(aeso_syntax:con(), icode()) -> icode().
+enter_namespace(NS, Icode = #{ namespace := NS1 }) ->
+    Icode#{ namespace => aeso_syntax:qualify(NS1, NS) };
+enter_namespace(NS, Icode) ->
+    Icode#{ namespace => NS }.
+
+-spec in_main_contract(icode()) -> boolean().
+in_main_contract(#{ namespace := {con, _, Main}, contract_name := Main }) -> true;
+in_main_contract(_Icode) -> false.
+
+-spec get_namespace(icode()) -> false | aeso_syntax:con() | aeso_syntax:qcon().
+get_namespace(Icode) -> maps:get(namespace, Icode, false).
+
+-spec qualify(aeso_syntax:id() | aeso_syntax:con(), icode()) -> aeso_syntax:id() | aeso_syntax:qid() | aeso_syntax:con() | aeso_syntax:qcon().
+qualify(X, Icode) ->
+    case get_namespace(Icode) of
+        false -> X;
+        NS    -> aeso_syntax:qualify(NS, X)
+    end.
+
 -spec set_functions([fun_dec()], icode()) -> icode().
 set_functions(NewFuns, Icode) ->
     maps:put(functions, NewFuns, Icode).
 
--spec get_constructor_tag(string(), icode()) -> integer().
+-spec get_constructor_tag([string()], icode()) -> integer().
 get_constructor_tag(Name, #{constructors := Constructors}) ->
     case maps:get(Name, Constructors, undefined) of
         undefined -> error({undefined_constructor, Name});

src/aeso_icode.hrl

@@ -1,14 +1,5 @@
 
--define(Type(), aeso_sophia:type()).
+-include_lib("aebytecode/include/aeb_typerep_def.hrl").
-
--define(TYPEREP_WORD_TAG,   0).
--define(TYPEREP_STRING_TAG, 1).
--define(TYPEREP_LIST_TAG,   2).
--define(TYPEREP_TUPLE_TAG,  3).
--define(TYPEREP_VARIANT_TAG, 4).
--define(TYPEREP_TYPEREP_TAG, 5).
--define(TYPEREP_MAP_TAG,     6).
--define(TYPEREP_FUN_TAG,     7).
 
 -record(arg, {name::string(), type::?Type()}).
 
@@ -20,7 +11,7 @@
                  , args :: arg_list()
                  , body :: expr()}).
 
--record(var_ref, { name :: string() | {builtin, atom() | tuple()}}).
+-record(var_ref, { name :: string() | list(string()) | {builtin, atom() | tuple()}}).
 
 -record(prim_call_contract,
     { gas      :: expr()

src/aeso_icode_to_asm.erl

@@ -17,7 +17,7 @@
 i(Code) -> aeb_opcodes:mnemonic(Code).
 
 %% We don't track purity or statefulness in the type checker yet.
-is_stateful({FName, _, _, _, _}) -> FName /= "init".
+is_stateful({FName, _, _, _, _}) -> lists:last(FName) /= "init".
 
 is_public({_Name, Attrs, _Args, _Body, _Type}) -> not lists:member(private, Attrs).
 
@@ -27,7 +27,7 @@ convert(#{ contract_name := _ContractName
               },
         _Options) ->
     %% Create a function dispatcher
-    DispatchFun = {"_main", [], [{"arg", "_"}],
+    DispatchFun = {"%main", [], [{"arg", "_"}],
                    {switch, {var_ref, "arg"},
                     [{{tuple, [fun_hash(Fun),
                                {tuple, make_args(Args)}]},
@@ -44,7 +44,7 @@ convert(#{ contract_name := _ContractName
     %% taken from the stack
     StopLabel = make_ref(),
     StatefulStopLabel = make_ref(),
-    MainFunction = lookup_fun(Funs, "_main"),
+    MainFunction = lookup_fun(Funs, "%main"),
 
     StateTypeValue = aeso_ast_to_icode:type_value(StateType),
 
@@ -105,7 +105,7 @@ make_args(Args) ->
 
 fun_hash({FName, _, Args, _, TypeRep}) ->
     ArgType = {tuple, [T || {_, T} <- Args]},
-    <<Hash:256>> = aeso_abi:function_type_hash(list_to_binary(FName), ArgType, TypeRep),
+    <<Hash:256>> = aeb_aevm_abi:function_type_hash(list_to_binary(lists:last(FName)), ArgType, TypeRep),
     {integer, Hash}.
 
 %% Expects two return addresses below N elements on the stack. Picks the top
@@ -343,6 +343,8 @@ assemble_expr(Funs, Stack, _Tail, #prim_put{ state = State }) ->
 %% Environment primitives
 assemble_expr(_Funs, _Stack, _Tail, prim_contract_address) ->
     [i(?ADDRESS)];
+assemble_expr(_Funs, _Stack, _Tail, prim_contract_creator) ->
+    [i(?CREATOR)];
 assemble_expr(_Funs, _Stack, _Tail, prim_call_origin) ->
     [i(?ORIGIN)];
 assemble_expr(_Funs, _Stack, _Tail, prim_caller) ->
@@ -562,6 +564,8 @@ assemble_infix('^')    -> i(?EXP);
 assemble_infix('bor')  -> i(?OR);
 assemble_infix('band') -> i(?AND);
 assemble_infix('bxor') -> i(?XOR);
+assemble_infix('bsl')  -> i(?SHL);
+assemble_infix('bsr')  -> i(?SHR);
 assemble_infix('<')    -> i(?SLT);    %% comparisons are SIGNED
 assemble_infix('>')    -> i(?SGT);
 assemble_infix('==')   -> i(?EQ);

src/aeso_memory.erl

@@ -1,19 +0,0 @@
-%%%-------------------------------------------------------------------
-%%% @copyright (C) 2018, Aeternity Anstalt
-%%% @doc
-%%%      Memory speifics that compiler and VM need to agree upon
-%%% @end
-%%% Created : 19 Dec 2018
-%%%-------------------------------------------------------------------
-
--module(aeso_memory).
-
--export([binary_to_words/1]).
-
-binary_to_words(<<>>) ->
-    [];
-binary_to_words(<<N:256,Bin/binary>>) ->
-    [N|binary_to_words(Bin)];
-binary_to_words(Bin) ->
-    binary_to_words(<<Bin/binary,0>>).
-

src/aeso_parse_lib.erl

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

src/aeso_parse_lib.hrl

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

src/aeso_parser.erl

@@ -5,28 +5,75 @@
 -module(aeso_parser).
 
 -export([string/1,
+         string/2,
+         string/3,
+         hash_include/2,
          type/1]).
 
 -include("aeso_parse_lib.hrl").
+-import(aeso_parse_lib, [current_file/0, set_current_file/1]).
 
--spec string(string()) ->
+-type parse_result() :: aeso_syntax:ast() | none().
-                    {ok, aeso_syntax:ast()}
+
-                        | {error, {aeso_parse_lib:pos(),
+-type include_hash() :: {string(), binary()}.
-                                   atom(),
+
-                                   term()}}
+-spec string(string()) -> parse_result().
-                        | {error, {aeso_parse_lib:pos(),
-                                   atom()}}.
 string(String) ->
-  parse_and_scan(file(), String).
+    string(String, sets:new(), []).
+
+-spec string(string(), aeso_compiler:options()) -> parse_result().
+string(String, Opts) ->
+    case lists:keyfind(src_file, 1, Opts) of
+        {src_file, File} -> string(String, sets:add_element(File, sets:new()), Opts);
+        false -> string(String, sets:new(), Opts)
+    end.
+
+-spec string(string(), sets:set(include_hash()), aeso_compiler:options()) -> parse_result().
+string(String, Included, Opts) ->
+    case parse_and_scan(file(), String, Opts) of
+        {ok, AST} ->
+            case expand_includes(AST, Included, Opts) of
+                {ok, AST1}   -> AST1;
+                {error, Err} -> parse_error(Err)
+            end;
+        {error, Err} ->
+            parse_error(Err)
+    end.
 
 type(String) ->
-  parse_and_scan(type(), String).
+    case parse_and_scan(type(), String, []) of
+        {ok, AST}    -> {ok, AST};
+        {error, Err} -> {error, [mk_error(Err)]}
+    end.
 
-parse_and_scan(P, S) ->
+parse_and_scan(P, S, Opts) ->
-  case aeso_scan:scan(S) of
+    set_current_file(proplists:get_value(src_file, Opts, no_file)),
-    {ok, Tokens} -> aeso_parse_lib:parse(P, Tokens);
+    case aeso_scan:scan(S) of
-    Error        -> Error
+        {ok, Tokens} -> aeso_parse_lib:parse(P, Tokens);
-  end.
+        Error        -> Error
+    end.
+
+-dialyzer({nowarn_function, parse_error/1}).
+parse_error(Err) ->
+    aeso_errors:throw(mk_error(Err)).
+
+mk_p_err(Pos, Msg) ->
+    aeso_errors:new(parse_error, mk_pos(Pos), lists:flatten(Msg)).
+
+mk_error({Pos, ScanE}) when ScanE == scan_error; ScanE == scan_error_no_state ->
+    mk_p_err(Pos, "Scan error\n");
+mk_error({Pos, parse_error, Err}) ->
+    Msg = io_lib:format("~s\n", [Err]),
+    mk_p_err(Pos, Msg);
+mk_error({Pos, ambiguous_parse, As}) ->
+    Msg = io_lib:format("Ambiguous parse result: ~p\n", [As]),
+    mk_p_err(Pos, Msg);
+mk_error({Pos, include_error, File}) ->
+    Msg = io_lib:format("Couldn't find include file '~s'\n", [File]),
+    mk_p_err(Pos, Msg).
+
+mk_pos({Line, Col})       -> aeso_errors:pos(Line, Col);
+mk_pos({File, Line, Col}) -> aeso_errors:pos(File, Line, Col).
 
 %% -- Parsing rules ----------------------------------------------------------
 
@@ -36,7 +83,10 @@ decl() ->
     ?LAZY_P(
     choice(
       %% Contract declaration
-    [ ?RULE(keyword(contract), con(), tok('='), maybe_block(decl()), {contract, _1, _2, _4})
+    [ ?RULE(keyword(contract),  con(), tok('='), maybe_block(decl()), {contract, _1, _2, _4})
+    , ?RULE(token(payable),     keyword(contract), con(), tok('='), maybe_block(decl()), add_modifiers([_1], {contract, _2, _3, _5}))
+    , ?RULE(keyword(namespace), con(), tok('='), maybe_block(decl()), {namespace, _1, _2, _4})
+    , ?RULE(keyword(include),   str(), {include, get_ann(_1), _2})
 
       %% Type declarations  TODO: format annotation for "type bla" vs "type bla()"
     , ?RULE(keyword(type),     id(),                                          {type_decl, _1, _2, []})
@@ -49,17 +99,31 @@ decl() ->
     , ?RULE(keyword(datatype), id(), type_vars(), tok('='), typedef(variant), {type_def, _1, _2, _3, _5})
 
       %% Function declarations
-    , ?RULE(modifiers(), keyword(function), id(), tok(':'), type(), add_modifiers(_1, {fun_decl, _2, _3, _5}))
+    , ?RULE(modifiers(), fun_or_entry(), id(), tok(':'), type(), add_modifiers(_1, _2, {fun_decl, get_ann(_2), _3, _5}))
-    , ?RULE(modifiers(), keyword(function), fundef(),               add_modifiers(_1, set_pos(get_pos(_2), _3)))
+    , ?RULE(modifiers(), fun_or_entry(), fundef(),               add_modifiers(_1, _2, set_pos(get_pos(get_ann(_2)), _3)))
-    , ?RULE(keyword('let'),    valdef(),                            set_pos(get_pos(_1), _2))
+    , ?RULE(keyword('let'),    valdef(),                         set_pos(get_pos(_1), _2))
     ])).
 
-modifiers() ->
+fun_or_entry() ->
-    many(choice([token(stateful), token(public), token(private), token(internal)])).
+    choice([?RULE(keyword(function), {function, _1}),
+            ?RULE(keyword(entrypoint), {entrypoint, _1})]).
 
-add_modifiers(Mods, Node) ->
+modifiers() ->
-    lists:foldl(fun({Mod, _}, X) -> set_ann(Mod, true, X) end,
+    many(choice([token(stateful), token(payable), token(private), token(public)])).
-                Node, Mods).
+
+add_modifiers(Mods, Entry = {entrypoint, _}, Node) ->
+    add_modifiers(Mods ++ [Entry], Node);
+add_modifiers(Mods, {function, _}, Node) ->
+    add_modifiers(Mods, Node).
+
+add_modifiers([], Node) -> Node;
+add_modifiers(Mods = [Tok | _], Node) ->
+    %% Set the position to the position of the first modifier. This is
+    %% important for code transformation tools (like what we do in
+    %% create_calldata) to be able to get the indentation of the declaration.
+    set_pos(get_pos(Tok),
+        lists:foldl(fun({Mod, _}, X) -> set_ann(Mod, true, X) end,
+                    Node, Mods)).
 
 %% -- Type declarations ------------------------------------------------------
 
@@ -71,7 +135,7 @@ constructors() ->
     sep1(constructor(), tok('|')).
 
 constructor() ->    %% TODO: format for Con() vs Con
-    choice(?RULE(con(),              {constr_t, get_ann(_1), _1, []}),
+    choice(?RULE(con(),             {constr_t, get_ann(_1), _1, []}),
            ?RULE(con(), con_args(), {constr_t, get_ann(_1), _1, _2})).
 
 con_args()   -> paren_list(con_arg()).
@@ -83,9 +147,7 @@ con_arg()    -> choice(type(), ?RULE(keyword(indexed), type(), set_ann(indexed,
 %% -- Let declarations -------------------------------------------------------
 
 letdecl() ->
-    choice(
+    ?RULE(keyword('let'), letdef(), set_pos(get_pos(_1), _2)).
-        ?RULE(keyword('let'), letdef(),                             set_pos(get_pos(_1), _2)),
-        ?RULE(keyword('let'), tok(rec), sep1(letdef(), tok('and')), {letrec, _1, _3})).
 
 letdef() -> choice(valdef(), fundef()).
 
@@ -115,24 +177,35 @@ type() -> ?LAZY_P(type100()).
 type100() -> type200().
 
 type200() ->
-    ?RULE(many({fun_domain(), keyword('=>')}), type300(), fun_t(_1, _2)).
+    ?RULE(many({type300(), keyword('=>')}), type300(), fun_t(_1, _2)).
 
-type300() -> type400().
+type300() ->
+    ?RULE(sep1(type400(), tok('*')), tuple_t(get_ann(lists:nth(1, _1)), _1)).
 
 type400() ->
-    ?RULE(typeAtom(), optional(type_args()),
+    choice(
+    [?RULE(typeAtom(), optional(type_args()),
           case _2 of
             none       -> _1;
             {ok, Args} -> {app_t, get_ann(_1), _1, Args}
-          end).
+          end),
+     ?RULE(id("bytes"), parens(token(int)),
+           {bytes_t, get_ann(_1), element(3, _2)})
+    ]).
 
 typeAtom() ->
     ?LAZY_P(choice(
-    [ id(), token(con), token(qcon), token(qid), tvar()
+    [ parens(type())
-    , ?RULE(keyword('('), comma_sep(type()), tok(')'), tuple_t(_1, _2))
+    , args_t()
+    , id(), token(con), token(qcon), token(qid), tvar()
     ])).
 
-fun_domain() -> ?RULE(?LAZY_P(type300()), fun_domain(_1)).
+args_t() ->
+    ?LAZY_P(choice(
+    [ ?RULE(tok('('), tok(')'), {args_t, get_ann(_1), []})
+      %% Singleton case handled separately
+    , ?RULE(tok('('), type(), tok(','), sep1(type(), tok(',')), tok(')'), {args_t, get_ann(_1), [_2|_4]})
+    ])).
 
 %% -- Statements -------------------------------------------------------------
 
@@ -176,30 +249,44 @@ expr200() -> infixr(expr300(), binop('||')).
 expr300() -> infixr(expr400(), binop('&&')).
 expr400() -> infix(expr500(),  binop(['<', '>', '=<', '>=', '==', '!='])).
 expr500() -> infixr(expr600(), binop(['::', '++'])).
-expr600() -> infixl(expr650(), binop(['+', '-', 'bor', 'bxor', 'bsr', 'bsl'])).
+expr600() -> infixl(expr650(), binop(['+', '-'])).
 expr650() -> ?RULE(many(token('-')), expr700(), prefixes(_1, _2)).
-expr700() -> infixl(expr750(), binop(['*', '/', mod, 'band'])).
+expr700() -> infixl(expr750(), binop(['*', '/', mod])).
 expr750() -> infixl(expr800(), binop(['^'])).
-expr800() -> ?RULE(many(choice(token('!'), token('bnot'))), expr900(), prefixes(_1, _2)).
+expr800() -> ?RULE(many(token('!')), expr900(), prefixes(_1, _2)).
 expr900() -> ?RULE(exprAtom(), many(elim()), elim(_1, _2)).
 
 exprAtom() ->
     ?LAZY_P(begin
         Expr = ?LAZY_P(expr()),
         choice(
-        [ id(), con(), token(qid), token(qcon)
+        [ id_or_addr(), con(), token(qid), token(qcon)
-        , token(hash), token(string), token(char)
+        , token(bytes), token(string), token(char)
         , token(int)
         , ?RULE(token(hex), set_ann(format, hex, setelement(1, _1, int)))
         , {bool, keyword(true), true}
         , {bool, keyword(false), false}
-        , ?RULE(brace_list(?LAZY_P(field_assignment())), record(_1))
+        , ?LET_P(Fs, brace_list(?LAZY_P(field_assignment())), record(Fs))
         , {list, [], bracket_list(Expr)}
+        , ?RULE(keyword('['), Expr, token('|'), comma_sep(comprehension_exp()), tok(']'), list_comp_e(_1, _2, _4))
         , ?RULE(tok('['), Expr, binop('..'), Expr, tok(']'), _3(_2, _4))
         , ?RULE(keyword('('), comma_sep(Expr), tok(')'), tuple_e(_1, _2))
         ])
     end).
 
+comprehension_exp() ->
+    ?LAZY_P(choice(
+      [ comprehension_bind()
+      , letdecl()
+      , comprehension_if()
+      ])).
+
+comprehension_if() ->
+    ?RULE(keyword('if'), parens(expr()), {comprehension_if, _1, _2}).
+
+comprehension_bind() ->
+    ?RULE(id(), tok('<-'), expr(), {comprehension_bind, _1, _3}).
+
 arg_expr() ->
     ?LAZY_P(
         choice([ ?RULE(id(), tok('='), expr(), {named_arg, [], _1, _3})
@@ -236,14 +323,20 @@ record_update(Ann, E, Flds) ->
 record([]) -> {map, [], []};
 record(Fs) ->
     case record_or_map(Fs) of
-        record -> {record, get_ann(hd(Fs)), Fs};
+        record ->
+            Fld = fun({field, _, [_], _} = F) -> F;
+                     ({field, Ann, LV, Id, _}) ->
+                         bad_expr_err("Cannot use '@' in record construction", infix({lvalue, Ann, LV}, {'@', Ann}, Id));
+                     ({field, Ann, LV, _}) ->
+                         bad_expr_err("Cannot use nested fields or keys in record construction", {lvalue, Ann, LV}) end,
+            {record, get_ann(hd(Fs)), lists:map(Fld, Fs)};
         map    ->
             Ann = get_ann(hd(Fs ++ [{empty, []}])), %% TODO: source location for empty maps
             KV = fun({field, _, [{map_get, _, Key}], Val}) -> {Key, Val};
-                    ({field, _, LV, Id, _}) ->
+                    ({field, FAnn, LV, Id, _}) ->
-                        bad_expr_err("Cannot use '@' in map construction", infix(LV, {op, Ann, '@'}, Id));
+                        bad_expr_err("Cannot use '@' in map construction", infix({lvalue, FAnn, LV}, {'@', Ann}, Id));
-                    ({field, _, LV, _}) ->
+                    ({field, FAnn, LV, _}) ->
-                        bad_expr_err("Cannot use nested fields or keys in map construction", LV) end,
+                        bad_expr_err("Cannot use nested fields or keys in map construction", {lvalue, FAnn, LV}) end,
             {map, Ann, lists:map(KV, Fs)}
     end.
 
@@ -301,6 +394,7 @@ binop(Ops) ->
 con()      -> token(con).
 id()       -> token(id).
 tvar()     -> token(tvar).
+str()      -> token(string).
 
 token(Tag) ->
     ?RULE(tok(Tag),
@@ -309,6 +403,26 @@ token(Tag) ->
         {Tok, {Line, Col}, Val} -> {Tok, pos_ann(Line, Col), Val}
     end).
 
+id(Id) ->
+    ?LET_P({id, A, X} = Y, id(),
+           if X == Id -> Y;
+              true    -> fail({A, "expected 'bytes'"})
+           end).
+
+id_or_addr() ->
+    ?RULE(id(), parse_addr_literal(_1)).
+
+parse_addr_literal(Id = {id, Ann, Name}) ->
+    case lists:member(lists:sublist(Name, 3), ["ak_", "ok_", "oq_", "ct_"]) of
+        false -> Id;
+        true  ->
+            try aeser_api_encoder:decode(list_to_binary(Name)) of
+                {Type, Bin} -> {Type, Ann, Bin}
+            catch _:_ ->
+                Id
+            end
+    end.
+
 %% -- Helpers ----------------------------------------------------------------
 
 keyword(K) -> ann(tok(K)).
@@ -336,10 +450,11 @@ bracket_list(P) -> brackets(comma_sep(P)).
 -type ann_col()  :: aeso_syntax:ann_col().
 
 -spec pos_ann(ann_line(), ann_col()) -> ann().
-pos_ann(Line, Col) -> [{line, Line}, {col, Col}].
+pos_ann(Line, Col) -> [{file, current_file()}, {line, Line}, {col, Col}].
 
 ann_pos(Ann) ->
-    {proplists:get_value(line, Ann),
+    {proplists:get_value(file, Ann),
+     proplists:get_value(line, Ann),
      proplists:get_value(col, Ann)}.
 
 get_ann(Ann) when is_list(Ann) -> Ann;
@@ -357,10 +472,10 @@ set_ann(Key, Val, Node) ->
     setelement(2, Node, lists:keystore(Key, 1, Ann, {Key, Val})).
 
 get_pos(Node) ->
-    {get_ann(line, Node), get_ann(col, Node)}.
+    {current_file(), get_ann(line, Node), get_ann(col, Node)}.
 
-set_pos({L, C}, Node) ->
+set_pos({F, L, C}, Node) ->
-    set_ann(line, L, set_ann(col, C, Node)).
+    set_ann(file, F, set_ann(line, L, set_ann(col, C, Node))).
 
 infix(L, Op, R) -> set_ann(format, infix,  {app, get_ann(L), Op, [L, R]}).
 
@@ -393,7 +508,7 @@ build_if(Ann, Cond, Then, [{elif, Ann1, Cond1, Then1} | Elses]) ->
 build_if(Ann, Cond, Then, [{else, _Ann, Else}]) ->
     {'if', Ann, Cond, Then, Else};
 build_if(Ann, Cond, Then, []) ->
-    {'if', Ann, Cond, Then, {unit, [{origin, system}]}}.
+    {'if', Ann, Cond, Then, {tuple, [{origin, system}], []}}.
 
 else_branches([Elif = {elif, _, _, _} | Stmts], Acc) ->
     else_branches(Stmts, [Elif | Acc]);
@@ -406,16 +521,14 @@ tuple_t(_Ann, [Type]) -> Type;  %% Not a tuple
 tuple_t(Ann, Types)   -> {tuple_t, Ann, Types}.
 
 fun_t(Domains, Type) ->
-    lists:foldr(fun({Dom, Ann}, T) -> {fun_t, Ann, [], Dom, T} end,
+    lists:foldr(fun({{args_t, _, Dom}, Ann}, T) -> {fun_t, Ann, [], Dom, T};
+                    ({Dom, Ann}, T)             -> {fun_t, Ann, [], [Dom], T} end,
                 Type, Domains).
 
-tuple_e(Ann, [])      -> {unit, Ann};
 tuple_e(_Ann, [Expr]) -> Expr;  %% Not a tuple
 tuple_e(Ann, Exprs)   -> {tuple, Ann, Exprs}.
 
-%% TODO: not nice
+list_comp_e(Ann, Expr, Binds) -> {list_comp, Ann, Expr, Binds}.
-fun_domain({tuple_t, _, Args}) -> Args;
-fun_domain(T)                  -> [T].
 
 -spec parse_pattern(aeso_syntax:expr()) -> aeso_parse_lib:parser(aeso_syntax:pat()).
 parse_pattern({app, Ann, Con = {'::', _}, Es}) ->
@@ -430,10 +543,9 @@ parse_pattern({record, Ann, Fs}) ->
     {record, Ann, lists:map(fun parse_field_pattern/1, Fs)};
 parse_pattern(E = {con, _, _})    -> E;
 parse_pattern(E = {id, _, _})     -> E;
-parse_pattern(E = {unit, _})      -> E;
 parse_pattern(E = {int, _, _})    -> E;
 parse_pattern(E = {bool, _, _})   -> E;
-parse_pattern(E = {hash, _, _})   -> E;
+parse_pattern(E = {bytes, _, _})  -> E;
 parse_pattern(E = {string, _, _}) -> E;
 parse_pattern(E = {char, _, _})   -> E;
 parse_pattern(E) -> bad_expr_err("Not a valid pattern", E).
@@ -442,16 +554,87 @@ parse_pattern(E) -> bad_expr_err("Not a valid pattern", E).
 parse_field_pattern({field, Ann, F, E}) ->
     {field, Ann, F, parse_pattern(E)}.
 
-return_error({L, C}, Err) ->
+-spec ret_doc_err(ann(), prettypr:document()) -> aeso_parse_lib:parser(none()).
-    fail(io_lib:format("~p:~p:\n~s", [L, C, Err])).
-
--spec ret_doc_err(ann(), prettypr:document()) -> no_return().
 ret_doc_err(Ann, Doc) ->
-    return_error(ann_pos(Ann), prettypr:format(Doc)).
+    fail(ann_pos(Ann), prettypr:format(Doc)).
 
--spec bad_expr_err(string(), aeso_syntax:expr()) -> no_return().
+-spec bad_expr_err(string(), aeso_syntax:expr()) -> aeso_parse_lib:parser(none()).
 bad_expr_err(Reason, E) ->
   ret_doc_err(get_ann(E),
               prettypr:sep([prettypr:text(Reason ++ ":"),
                             prettypr:nest(2, aeso_pretty:expr(E))])).
 
+%% -- Helper functions -------------------------------------------------------
+
+expand_includes(AST, Included, Opts) ->
+    Ann  = [{origin, system}],
+    AST1 = [ {include, Ann, {string, Ann, File}}
+             || File <- lists:usort(auto_imports(AST)) ] ++ AST,
+    expand_includes(AST1, Included, [], Opts).
+
+expand_includes([], _Included, Acc, _Opts) ->
+    {ok, lists:reverse(Acc)};
+expand_includes([{include, Ann, {string, _SAnn, File}} | AST], Included, Acc, Opts) ->
+    case get_include_code(File, Ann, Opts) of
+        {ok, Code} ->
+            Hashed = hash_include(File, Code),
+            case sets:is_element(Hashed, Included) of
+                false ->
+                    Opts1 = lists:keystore(src_file, 1, Opts, {src_file, File}),
+                    Included1 = sets:add_element(Hashed, Included),
+                    case parse_and_scan(file(), Code, Opts1) of
+                        {ok, AST1} ->
+                            expand_includes(AST1 ++ AST, Included1, Acc, Opts);
+                        Err = {error, _} ->
+                            Err
+                    end;
+                true ->
+                    expand_includes(AST, Included, Acc, Opts)
+            end;
+        Err = {error, _} ->
+            Err
+    end;
+expand_includes([E | AST], Included, Acc, Opts) ->
+    expand_includes(AST, Included, [E | Acc], Opts).
+
+read_file(File, Opts) ->
+    case proplists:get_value(include, Opts, {explicit_files, #{}}) of
+        {file_system, Paths} ->
+            CandidateNames = [ filename:join(Dir, File) || Dir <- Paths ],
+            lists:foldr(fun(F, {error, _}) -> file:read_file(F);
+                           (_F, OK) -> OK end, {error, not_found}, CandidateNames);
+        {explicit_files, Files} ->
+            case maps:get(binary_to_list(File), Files, not_found) of
+                not_found -> {error, not_found};
+                Src       -> {ok, Src}
+            end
+    end.
+
+stdlib_options() ->
+    [{include, {file_system, [aeso_stdlib:stdlib_include_path()]}}].
+
+get_include_code(File, Ann, Opts) ->
+    case {read_file(File, Opts), read_file(File, stdlib_options())} of
+        {{ok, _}, {ok,_ }} ->
+            fail(ann_pos(Ann), "Illegal redefinition of standard library " ++ File);
+        {_, {ok, Bin}} ->
+            {ok, binary_to_list(Bin)};
+        {{ok, Bin}, _} ->
+            {ok, binary_to_list(Bin)};
+        {_, _} ->
+            {error, {ann_pos(Ann), include_error, File}}
+    end.
+
+-spec hash_include(string() | binary(), string()) -> include_hash().
+hash_include(File, Code) when is_binary(File) ->
+    hash_include(binary_to_list(File), Code);
+hash_include(File, Code) when is_list(File) ->
+    {filename:basename(File), crypto:hash(sha256, Code)}.
+
+auto_imports({comprehension_bind, _, _}) -> [<<"ListInternal.aes">>];
+auto_imports({'..', _})                  -> [<<"ListInternal.aes">>];
+auto_imports(L) when is_list(L) ->
+    lists:flatmap(fun auto_imports/1, L);
+auto_imports(T) when is_tuple(T) ->
+    auto_imports(tuple_to_list(T));
+auto_imports(_) -> [].

src/aeso_pretty.erl

@@ -147,19 +147,28 @@ decl(D, Options) ->
 -spec decl(aeso_syntax:decl()) -> doc().
 decl({contract, _, C, Ds}) ->
     block(follow(text("contract"), hsep(name(C), text("="))), decls(Ds));
+decl({namespace, _, C, Ds}) ->
+    block(follow(text("namespace"), hsep(name(C), text("="))), decls(Ds));
 decl({type_decl, _, T, Vars}) -> typedecl(alias_t, T, Vars);
 decl({type_def, _, T, Vars, Def}) ->
     Kind = element(1, Def),
     equals(typedecl(Kind, T, Vars), typedef(Def));
-decl({fun_decl, _, F, T}) ->
+decl({fun_decl, Ann, F, T}) ->
-    hsep(text("function"), typed(name(F), T));
+    Fun = case aeso_syntax:get_ann(entrypoint, Ann, false) of
+            true  -> text("entrypoint");
+            false -> text("function")
+          end,
+    hsep(Fun, typed(name(F), T));
 decl(D = {letfun, Attrs, _, _, _, _}) ->
-    Mod = fun({Mod, true}) when Mod == private; Mod == internal; Mod == public; Mod == stateful ->
+    Mod = fun({Mod, true}) when Mod == private; Mod == stateful ->
                             text(atom_to_list(Mod));
              (_) -> empty() end,
-    hsep(lists:map(Mod, Attrs) ++ [letdecl("function", D)]);
+    Fun = case aeso_syntax:get_ann(entrypoint, Attrs, false) of
-decl(D = {letval, _, _, _, _})    -> letdecl("let", D);
+              true  -> "entrypoint";
-decl(D = {letrec, _, _})          -> letdecl("let", D).
+              false -> "function"
+          end,
+    hsep(lists:map(Mod, Attrs) ++ [letdecl(Fun, D)]);
+decl(D = {letval, _, _, _, _}) -> letdecl("let", D).
 
 -spec expr(aeso_syntax:expr(), options()) -> doc().
 expr(E, Options) ->
@@ -170,7 +179,7 @@ expr(E) -> expr_p(0, E).
 
 %% -- Not exported -----------------------------------------------------------
 
--spec name(aeso_syntax:id() | aeso_syntax:con() | aeso_syntax:tvar()) -> doc().
+-spec name(aeso_syntax:id() | aeso_syntax:qid() | aeso_syntax:con() | aeso_syntax:qcon() | aeso_syntax:tvar()) -> doc().
 name({id, _,   Name})  -> text(Name);
 name({con, _,  Name})  -> text(Name);
 name({qid, _,  Names}) -> text(string:join(Names, "."));
@@ -182,9 +191,7 @@ name({typed, _, Name, _}) -> name(Name).
 letdecl(Let, {letval, _, F, T, E}) ->
     block_expr(0, hsep([text(Let), typed(name(F), T), text("=")]), E);
 letdecl(Let, {letfun, _, F, Args, T, E}) ->
-    block_expr(0, hsep([text(Let), typed(beside(name(F), args(Args)), T), text("=")]), E);
+    block_expr(0, hsep([text(Let), typed(beside(name(F), args(Args)), T), text("=")]), E).
-letdecl(Let, {letrec, _, [D | Ds]}) ->
-    hsep(text(Let), above([ letdecl("rec", D) | [ letdecl("and", D1) || D1 <- Ds ] ])).
 
 -spec args([aeso_syntax:arg()]) -> doc().
 args(Args) ->
@@ -215,7 +222,7 @@ typedef({variant_t, Constructors}) ->
 
 -spec constructor_t(aeso_syntax:constructor_t()) -> doc().
 constructor_t({constr_t, _, C, []}) -> name(C);
-constructor_t({constr_t, _, C, Args}) -> beside(name(C), tuple_type(Args)).
+constructor_t({constr_t, _, C, Args}) -> beside(name(C), args_type(Args)).
 
 -spec field_t(aeso_syntax:field_t()) -> doc().
 field_t({field_t, _, Name, Type}) ->
@@ -227,15 +234,24 @@ type(Type, Options) ->
 
 -spec type(aeso_syntax:type()) -> doc().
 type({fun_t, _, Named, Args, Ret}) ->
+    follow(hsep(args_type(Named ++ Args), text("=>")), type(Ret));
+type({type_sig, _, Named, Args, Ret}) ->
     follow(hsep(tuple_type(Named ++ Args), text("=>")), type(Ret));
 type({app_t, _, Type, []}) ->
     type(Type);
 type({app_t, _, Type, Args}) ->
-    beside(type(Type), tuple_type(Args));
+    beside(type(Type), args_type(Args));
 type({tuple_t, _, Args}) ->
     tuple_type(Args);
-type({named_arg_t, _, Name, Type, Default}) ->
+type({args_t, _, Args}) ->
-    follow(hsep(typed(name(Name), Type), text("=")), expr(Default));
+    args_type(Args);
+type({bytes_t, _, any}) -> text("bytes(_)");
+type({bytes_t, _, Len}) ->
+    text(lists:concat(["bytes(", Len, ")"]));
+type({named_arg_t, _, Name, Type, _Default}) ->
+    %% Drop the default value
+    %% follow(hsep(typed(name(Name), Type), text("=")), expr(Default));
+    typed(name(Name), Type);
 
 type(R = {record_t, _}) -> typedef(R);
 type(T = {id, _, _})   -> name(T);
@@ -244,10 +260,20 @@ type(T = {con, _, _})  -> name(T);
 type(T = {qcon, _, _}) -> name(T);
 type(T = {tvar, _, _}) -> name(T).
 
--spec tuple_type([aeso_syntax:type()]) -> doc().
+-spec args_type([aeso_syntax:type()]) -> doc().
-tuple_type(Args) ->
+args_type(Args) ->
     tuple(lists:map(fun type/1, Args)).
 
+-spec tuple_type([aeso_syntax:type()]) -> doc().
+tuple_type([]) ->
+    text("unit");
+tuple_type(Factors) ->
+    beside(
+      [ text("(")
+      , par(punctuate(text(" *"), lists:map(fun type/1, Factors)), 0)
+      , text(")")
+      ]).
+
 -spec arg_expr(aeso_syntax:arg_expr()) -> doc().
 arg_expr({named_arg, _, Name, E}) ->
     follow(hsep(expr(Name), text("=")), expr(E));
@@ -303,6 +329,8 @@ expr_p(P, E = {app, _, F = {Op, _}, Args}) when is_atom(Op) ->
         {prefix, [A]}   -> prefix(P, Op, A);
         _               -> app(P, F, Args)
     end;
+expr_p(_, {app, _, C={Tag, _, _}, []}) when Tag == con; Tag == qcon ->
+    expr_p(0, C);
 expr_p(P, {app, _, F, Args}) ->
     app(P, F, Args);
 %% -- Constants
@@ -313,8 +341,18 @@ expr_p(_, E = {int, _, N}) ->
            end,
     text(S);
 expr_p(_, {bool, _, B}) -> text(atom_to_list(B));
-expr_p(_, {hash, _, <<N:256>>}) -> text("#" ++ integer_to_list(N, 16));
+expr_p(_, {bytes, _, Bin}) ->
-expr_p(_, {unit, _}) -> text("()");
+    Digits = byte_size(Bin),
+    <<N:Digits/unit:8>> = Bin,
+    text(lists:flatten(io_lib:format("#~*.16.0b", [Digits*2, N])));
+expr_p(_, {hash, _, <<N:512>>}) -> text("#" ++ integer_to_list(N, 16));
+expr_p(_, {Type, _, Bin})
+    when Type == account_pubkey;
+         Type == contract_pubkey;
+         Type == oracle_pubkey;
+         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(_, {char, _, C}) ->
     case C of
@@ -347,6 +385,7 @@ stmt_p({else, Else}) ->
 -spec bin_prec(aeso_syntax:bin_op()) -> {integer(), integer(), integer()}.
 bin_prec('..')   -> {  0,   0,   0};  %% Always printed inside '[ ]'
 bin_prec('=')    -> {  0,   0,   0};  %% Always printed inside '[ ]'
+bin_prec('@')    -> {  0,   0,   0};  %% Only in error messages
 bin_prec('||')   -> {200, 300, 200};
 bin_prec('&&')   -> {300, 400, 300};
 bin_prec('<')    -> {400, 500, 500};
@@ -359,20 +398,14 @@ bin_prec('++')   -> {500, 600, 500};
 bin_prec('::')   -> {500, 600, 500};
 bin_prec('+')    -> {600, 600, 650};
 bin_prec('-')    -> {600, 600, 650};
-bin_prec('bor')  -> {600, 600, 650};
-bin_prec('bxor') -> {600, 600, 650};
-bin_prec('bsl')  -> {600, 600, 650};
-bin_prec('bsr')  -> {600, 600, 650};
 bin_prec('*')    -> {700, 700, 750};
 bin_prec('/')    -> {700, 700, 750};
 bin_prec(mod)    -> {700, 700, 750};
-bin_prec('band') -> {700, 700, 750};
 bin_prec('^')    -> {750, 750, 800}.
 
 -spec un_prec(aeso_syntax:un_op()) -> {integer(), integer()}.
 un_prec('-')    -> {650, 650};
-un_prec('!')    -> {800, 800};
+un_prec('!')    -> {800, 800}.
-un_prec('bnot') -> {800, 800}.
 
 equals(Ann, A, B) ->
     {app, [{format, infix} | Ann], {'=', Ann}, [A, B]}.
@@ -424,7 +457,6 @@ statements(Stmts) ->
 
 statement(S = {letval, _, _, _, _})    -> letdecl("let", S);
 statement(S = {letfun, _, _, _, _, _}) -> letdecl("let", S);
-statement(S = {letrec, _, _})          -> letdecl("let", S);
 statement(E) -> expr(E).
 
 get_elifs(Expr) -> get_elifs(Expr, []).

src/aeso_scan.erl

@@ -20,7 +20,7 @@ lexer() ->
     CON      = [UPPER, "[a-zA-Z0-9_]*"],
     INT      = [DIGIT, "+"],
     HEX      = ["0x", HEXDIGIT, "+"],
-    HASH     = ["#", HEXDIGIT, "+"],
+    BYTES    = ["#", HEXDIGIT, "+"],
     WS       = "[\\000-\\ ]+",
     ID       = [LOWER, "[a-zA-Z0-9_']*"],
     TVAR     = ["'", ID],
@@ -36,9 +36,8 @@ lexer() ->
         , {"\\*/",        pop(skip())}
         , {"[^/*]+|[/*]", skip()} ],
 
-    Keywords = ["contract", "import", "let", "rec", "switch", "type", "record", "datatype", "if", "elif", "else", "function",
+    Keywords = ["contract", "include", "let", "switch", "type", "record", "datatype", "if", "elif", "else", "function",
-                "stateful", "true", "false", "and", "mod", "public", "private", "indexed", "internal",
+                "stateful", "payable", "true", "false", "mod", "public", "entrypoint", "private", "indexed", "namespace"],
-                "band", "bor", "bxor", "bsl", "bsr", "bnot"],
     KW = string:join(Keywords, "|"),
 
     Rules =
@@ -55,7 +54,7 @@ lexer() ->
         , {STRING, token(string, fun parse_string/1)}
         , {HEX,    token(hex,    fun parse_hex/1)}
         , {INT,    token(int,    fun list_to_integer/1)}
-        , {HASH,   token(hash,   fun parse_hash/1)}
+        , {BYTES,  token(bytes,  fun parse_bytes/1)}
 
           %% Identifiers (qualified first!)
         , {QID,   token(qid,  fun(S) -> string:tokens(S, ".") end)}
@@ -118,10 +117,8 @@ unescape([C | Chars], Acc) ->
 
 parse_hex("0x" ++ Chars) -> list_to_integer(Chars, 16).
 
-parse_hash("#" ++ Chars) ->
+parse_bytes("#" ++ Chars) ->
-    N = list_to_integer(Chars, 16),
+    N      = list_to_integer(Chars, 16),
-    case length(Chars) > 64 of  %% 64 hex digits = 32 bytes
+    Digits = (length(Chars) + 1) div 2,
-        true  -> <<N:64/unit:8>>;   %% signature
+    <<N:Digits/unit:8>>.
-        false -> <<N:32/unit:8>>    %% address
-    end.
 

src/aeso_sophia.erl

@@ -1,30 +0,0 @@
--module(aeso_sophia).
-
--export_type([data/0,
-              type/0,
-              heap/0]).
-
--type type() :: word | signed_word | string | typerep | function
-              | {list,   type()}
-              | {option, type()}
-              | {tuple, [type()]}
-              | {variant, [[type()]]}.
-
-
--type data() :: none
-              | {some,   data()}
-              | {option, data()}
-              | word
-              | string
-              | {list,   data()}
-              | {tuple, [data()]}
-              | {variant, integer(), [data()]}
-              | integer()
-              | binary()
-              | [data()]
-              | {}
-              | {data()}
-              | {data(), data()}.
-
--type heap() :: binary().
-

src/aeso_stdlib.erl

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

src/aeso_syntax.erl

@@ -8,14 +8,14 @@
 
 -module(aeso_syntax).
 
--export([get_ann/1, get_ann/2, get_ann/3, set_ann/2]).
+-export([get_ann/1, get_ann/2, get_ann/3, set_ann/2, qualify/2]).
 
 -export_type([ann_line/0, ann_col/0, ann_origin/0, ann_format/0, ann/0]).
 -export_type([name/0, id/0, con/0, qid/0, qcon/0, tvar/0, op/0]).
 -export_type([bin_op/0, un_op/0]).
 -export_type([decl/0, letbind/0, typedef/0]).
--export_type([arg/0, field_t/0, constructor_t/0]).
+-export_type([arg/0, field_t/0, constructor_t/0, named_arg_t/0]).
--export_type([type/0, constant/0, expr/0, arg_expr/0, field/1, stmt/0, alt/0, lvalue/0, pat/0]).
+-export_type([type/0, constant/0, expr/0, arg_expr/0, field/1, stmt/0, alt/0, lvalue/0, elim/0, pat/0]).
 -export_type([ast/0]).
 
 -type ast() :: [decl()].
@@ -25,7 +25,7 @@
 -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()}].
+-type ann() :: [{line, ann_line()} | {col, ann_col()} | {format, ann_format()} | {origin, ann_origin()} | stateful | private].
 
 -type name() :: string().
 -type id()   :: {id,   ann(), name()}.
@@ -35,6 +35,7 @@
 -type tvar() :: {tvar, ann(), name()}.
 
 -type decl() :: {contract, ann(), con(), [decl()]}
+              | {namespace, ann(), con(), [decl()]}
               | {type_decl, ann(), id(), [tvar()]}
               | {type_def, ann(), id(), [tvar()], typedef()}
               | {fun_decl, ann(), id(), type()}
@@ -42,8 +43,7 @@
 
 -type letbind()
     :: {letval, ann(), id(), type(), expr()}
-     | {letfun, ann(), id(), [arg()], type(), expr()}
+     | {letfun, ann(), id(), [arg()], type(), expr()}.
-     | {letrec, ann(), [letbind()]}.
 
 -type arg() :: {arg, ann(), id(), type()}.
 
@@ -59,6 +59,8 @@
 -type type() :: {fun_t, ann(), [named_arg_t()], [type()], type()}
               | {app_t, ann(), type(), [type()]}
               | {tuple_t, ann(), [type()]}
+              | {args_t, ann(), [type()]}   %% old tuple syntax, old for error messages
+              | {bytes_t, ann(), integer() | any}
               | id()  | qid()
               | con() | qcon()  %% contracts
               | tvar().
@@ -68,17 +70,20 @@
 -type constant()
     :: {int, ann(), integer()}
      | {bool, ann(), true | false}
-     | {hash, ann(), binary()}
+     | {bytes, ann(), binary()}
-     | {unit, ann()}
+     | {account_pubkey, ann(), binary()}
+     | {contract_pubkey, ann(), binary()}
+     | {oracle_pubkey, ann(), binary()}
+     | {oracle_query_id, ann(), binary()}
      | {string, ann(), binary()}
      | {char, ann(), integer()}.
 
 -type op() :: bin_op() | un_op().
 
--type bin_op() :: '+' | '-' | '*' | '/' | mod | '^' | 'band' | 'bor' | 'bsl' | 'bsr' | 'bxor'
+-type bin_op() :: '+' | '-' | '*' | '/' | mod | '^'
                 | '++' | '::' | '<' | '>' | '=<' | '>=' | '==' | '!='
                 | '||' | '&&' | '..'.
--type un_op() :: '-' | '!' | 'bnot'.
+-type un_op() :: '-' | '!'.
 
 -type expr()
     :: {lam, ann(), [arg()], expr()}
@@ -88,6 +93,7 @@
      | {proj, ann(), expr(), id()}
      | {tuple, ann(), [expr()]}
      | {list, ann(), [expr()]}
+     | {list_comp, ann(), expr(), [comprehension_exp()]}
      | {typed, ann(), expr(), type()}
      | {record, ann(), [field(expr())]}
      | {record, ann(), expr(), [field(expr())]} %% record update
@@ -100,6 +106,10 @@
      | id() | qid() | con() | qcon()
      | constant().
 
+-type comprehension_exp() :: [ {comprehension_bind, id(), expr()}
+                             | {comprehension_if, ann(), expr()}
+                             | letbind() ].
+
 -type arg_expr() :: expr() | {named_arg, ann(), id(), expr()}.
 
 %% When lvalue is a projection this is sugar for accessing fields in nested
@@ -140,3 +150,7 @@ get_ann(Key, Node) ->
 
 get_ann(Key, Node, Default) ->
     proplists:get_value(Key, get_ann(Node), Default).
+
+qualify({con, Ann, N}, X)             -> qualify({qcon, Ann, [N]}, X);
+qualify({qcon, _, NS}, {con, Ann, C}) -> {qcon, Ann, NS ++ [C]};
+qualify({qcon, _, NS}, {id, Ann, X})  -> {qid, Ann, NS ++ [X]}.

src/aeso_syntax_utils.erl

@@ -6,89 +6,151 @@
 %%%-------------------------------------------------------------------
 -module(aeso_syntax_utils).
 
--export([used_ids/1, used_types/1]).
+-export([used_ids/1, used_types/2, used/1]).
 
-%% Var set combinators
+-record(alg, {zero, plus, scoped}).
-none()           -> [].
-one(X)           -> [X].
-union_map(F, Xs) -> lists:umerge(lists:map(F, Xs)).
-minus(Xs, Ys)    -> Xs -- Ys.
 
-%% Compute names used by a definition or expression.
+-type alg(A) :: #alg{ zero   :: A
-used_ids(Es) when is_list(Es) ->
+                    , plus   :: fun((A, A) -> A)
-    union_map(fun used_ids/1, Es);
+                    , scoped :: fun((A, A) -> A) }.
-used_ids({bind, A, B}) ->
-    minus(used_ids(B), used_ids(A));
-%% Declarations
-used_ids({contract, _, _, Decls})    -> used_ids(Decls);
-used_ids({type_decl, _, _, _})       -> none();
-used_ids({type_def, _, _, _, _})     -> none();
-used_ids({fun_decl, _, _, _})        -> none();
-used_ids({letval, _, _, _, E})       -> used_ids(E);
-used_ids({letfun, _, _, Args, _, E}) -> used_ids({bind, Args, E});
-used_ids({letrec, _, Decls})         -> used_ids(Decls);
-%% Args
-used_ids({arg, _, X, _}) -> used_ids(X);
-used_ids({named_arg, _, _, E}) -> used_ids(E);
-%% Constants
-used_ids({int, _, _})    -> none();
-used_ids({bool, _, _})   -> none();
-used_ids({hash, _, _})   -> none();
-used_ids({unit, _})      -> none();
-used_ids({string, _, _}) -> none();
-used_ids({char, _, _})   -> none();
-%% Expressions
-used_ids({lam, _, Args, E})  -> used_ids({bind, Args, E});
-used_ids({'if', _, A, B, C}) -> used_ids([A, B, C]);
-used_ids({switch, _, E, Bs}) -> used_ids([E, Bs]);
-used_ids({app, _, E, Es})    -> used_ids([E | Es]);
-used_ids({proj, _, E, _})    -> used_ids(E);
-used_ids({tuple, _, Es})     -> used_ids(Es);
-used_ids({list, _, Es})      -> used_ids(Es);
-used_ids({typed, _, E, _})   -> used_ids(E);
-used_ids({record, _, Fs})    -> used_ids(Fs);
-used_ids({record, _, E, Fs}) -> used_ids([E, Fs]);
-used_ids({map, _, E, Fs})    -> used_ids([E, Fs]);
-used_ids({map, _, KVs})      -> used_ids([ [K, V] || {K, V} <- KVs ]);
-used_ids({map_get, _, M, K}) -> used_ids([M, K]);
-used_ids({map_get, _, M, K, V}) -> used_ids([M, K, V]);
-used_ids({block, _, Ss})     -> used_ids_s(Ss);
-used_ids({Op, _}) when is_atom(Op) -> none();
-used_ids({id, _, X})   -> [X];
-used_ids({qid, _, _})  -> none();
-used_ids({con, _, _})  -> none();
-used_ids({qcon, _, _}) -> none();
-%% Switch branches
-used_ids({'case', _, P, E}) -> used_ids({bind, P, E});
-%% Fields
-used_ids({field, _, LV, E})    -> used_ids([LV, E]);
-used_ids({field, _, LV, X, E}) -> used_ids([LV, {bind, X, E}]);
-used_ids({proj, _, _})         -> none();
-used_ids({map_get, _, E})      -> used_ids(E).
 
-%% Statements
+-type kind() :: decl | type | bind_type | expr | bind_expr.
-used_ids_s([])       -> none();
-used_ids_s([S | Ss]) ->
-    used_ids([S, {bind, bound_ids(S), {block, [], Ss}}]).
 
-bound_ids({letval, _, X, _, _})    -> one(X);
+-spec fold(alg(A), fun((kind(), _) -> A), kind(), E | [E]) -> A
-bound_ids({letfun, _, X, _, _, _}) -> one(X);
+    when E :: aeso_syntax:decl()
-bound_ids({letrec, _, Decls})      -> union_map(fun bound_ids/1, Decls);
+            | aeso_syntax:typedef()
-bound_ids(_)                       -> none().
+            | aeso_syntax:field_t()
+            | aeso_syntax:constructor_t()
+            | aeso_syntax:type()
+            | aeso_syntax:expr()
+            | aeso_syntax:pat()
+            | aeso_syntax:arg()
+            | aeso_syntax:alt()
+            | aeso_syntax:elim()
+            | aeso_syntax:arg_expr()
+            | aeso_syntax:field(aeso_syntax:expr())
+            | aeso_syntax:stmt().
+fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
+    Sum  = fun(Xs) -> lists:foldl(Plus, Zero, Xs) end,
+    Same = fun(A) -> fold(Alg, Fun, K, A) end,
+    Decl = fun(D) -> fold(Alg, Fun, decl, D) end,
+    Type = fun(T) -> fold(Alg, Fun, type, T) end,
+    Expr = fun(E) -> fold(Alg, Fun, expr, E) end,
+    BindExpr = fun(P) -> fold(Alg, Fun, bind_expr, P) end,
+    BindType = fun(T) -> fold(Alg, Fun, bind_type, T) end,
+    Top = Fun(K, X),
+    Rec = case X of
+            %% lists (bound things in head scope over tail)
+            [A | As]                 -> Scoped(Same(A), Same(As));
+            %% 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, _, F, T, E}     -> Sum([BindExpr(F), Type(T), Expr(E)]);
+            {letfun, _, F, Xs, T, E} -> Sum([BindExpr(F), Type(T), Expr(Xs ++ [E])]);
+            %% typedef()
+            {alias_t, T}    -> Type(T);
+            {record_t, Fs}  -> Type(Fs);
+            {variant_t, Cs} -> Type(Cs);
+            %% field_t() and constructor_t()
+            {field_t, _, _, T}   -> Type(T);
+            {constr_t, _, _, Ts} -> Type(Ts);
+            %% type()
+            {fun_t, _, Named, Args, Ret} -> Type([Named, Args, Ret]);
+            {app_t, _, T, Ts}            -> Type([T | Ts]);
+            {tuple_t, _, Ts}             -> Type(Ts);
+            %% named_arg_t()
+            {named_arg_t, _, _, T, E} -> Plus(Type(T), Expr(E));
+            %% expr()
+            {lam, _, Args, E}      -> Scoped(BindExpr(Args), Expr(E));
+            {'if', _, A, B, C}     -> Expr([A, B, C]);
+            {switch, _, E, Alts}   -> Expr([E, Alts]);
+            {app, _, A, As}        -> Expr([A | As]);
+            {proj, _, E, _}        -> Expr(E);
+            {tuple, _, As}         -> Expr(As);
+            {list, _, As}          -> Expr(As);
+            {list_comp, _, Y, []}  -> Expr(Y);
+            {list_comp, A, Y, [{comprehension_bind, I, E}|R]} ->
+                Plus(Expr(E), Scoped(BindExpr(I), Expr({list_comp, A, Y, R})));
+            {list_comp, A, Y, [{comprehension_if, _, E}|R]} ->
+                Plus(Expr(E), Expr({list_comp, A, Y, R}));
+            {list_comp, A, Y, [D = {letval, _, F, _, _} | R]} ->
+                Plus(Decl(D), Scoped(BindExpr(F), Expr({list_comp, A, Y, R})));
+            {list_comp, A, Y, [D = {letfun, _, F, _, _, _} | R]} ->
+                Plus(Decl(D), Scoped(BindExpr(F), Expr({list_comp, A, Y, R})));
+            {typed, _, E, T}       -> Plus(Expr(E), Type(T));
+            {record, _, Fs}        -> Expr(Fs);
+            {record, _, E, Fs}     -> Expr([E | Fs]);
+            {map, _, E, Fs}        -> Expr([E | Fs]);
+            {map, _, KVs}          -> Sum([Expr([Key, Val]) || {Key, Val} <- KVs]);
+            {map_get, _, A, B}     -> Expr([A, B]);
+            {map_get, _, A, B, C}  -> Expr([A, B, C]);
+            {block, _, Ss}         -> Expr(Ss);
+            %% field()
+            {field, _, LV, E}    -> Expr([LV, E]);
+            {field, _, LV, _, E} -> Expr([LV, E]);
+            %% arg()
+            {arg, _, Y, T} -> Plus(BindExpr(Y), Type(T));
+            %% alt()
+            {'case', _, P, E} -> Scoped(BindExpr(P), Expr(E));
+            %% elim()
+            {proj, _, _}    -> Zero;
+            {map_get, _, E} -> Expr(E);
+            %% arg_expr()
+            {named_arg, _, _, E} -> Expr(E);
+            _ -> Alg#alg.zero
+          end,
+    (Alg#alg.plus)(Top, Rec).
+
+%% Name dependencies
+
+used_ids(E) ->
+    [ X || {{term, [X]}, _} <- used(E) ].
+
+used_types([Top] = _CurrentNS, T) ->
+    F = fun({{type, [X]}, _}) -> [X];
+           ({{type, [Top1, X]}, _}) when Top1 == Top -> [X];
+           (_) -> []
+        end,
+    lists:flatmap(F, used(T)).
+
+-type entity() :: {term, [string()]}
+                | {type, [string()]}
+                | {namespace, [string()]}.
+
+-spec entity_alg() -> alg(#{entity() => aeso_syntax:ann()}).
+entity_alg() ->
+    IsBound = fun({K, _}) -> lists:member(K, [bound_term, bound_type]) end,
+    Unbind  = fun(bound_term) -> term; (bound_type) -> type end,
+    Remove  = fun(Keys, Map) -> maps:without(Keys, Map) end,
+    Scoped = fun(Xs, Ys) ->
+                Bound  = [E || E <- maps:keys(Xs), IsBound(E)],
+                Bound1 = [ {Unbind(Tag), X} || {Tag, X} <- Bound ],
+                Others = Remove(Bound1, Ys),
+                maps:merge(Remove(Bound, Xs), Others)
+            end,
+    #alg{ zero   = #{}
+        , plus   = fun maps:merge/2
+        , scoped = Scoped }.
+
+-spec used(_) -> [{entity(), aeso_syntax:ann()}].
+used(D) ->
+    Kind = fun(expr)      -> term;
+              (bind_expr) -> bound_term;
+              (type)      -> type;
+              (bind_type) -> bound_type
+           end,
+    NS = fun(Xs) -> {namespace, lists:droplast(Xs)} end,
+    NotBound = fun({{Tag, _}, _}) -> not lists:member(Tag, [bound_term, bound_type]) end,
+    Xs =
+        maps:to_list(fold(entity_alg(),
+            fun(K, {id,   Ann, X})  -> #{{Kind(K), [X]} => Ann};
+               (K, {qid,  Ann, Xs}) -> #{{Kind(K), Xs}  => Ann, NS(Xs) => Ann};
+               (K, {con,  Ann, X})  -> #{{Kind(K), [X]} => Ann};
+               (K, {qcon, Ann, Xs}) -> #{{Kind(K), Xs}  => Ann, NS(Xs) => Ann};
+               (_, _)             -> #{}
+            end, decl, D)),
+    lists:filter(NotBound, Xs).
 
-used_types(Ts) when is_list(Ts)    -> union_map(fun used_types/1, Ts);
-used_types({type_def, _, _, _, T}) -> used_types(T);
-used_types({alias_t, T})           -> used_types(T);
-used_types({record_t, Fs})         -> used_types(Fs);
-used_types({variant_t, Cs})        -> used_types(Cs);
-used_types({field_t, _, _, T})     -> used_types(T);
-used_types({constr_t, _, _, Ts})   -> used_types(Ts);
-used_types({fun_t, _, Named, Args, T}) -> used_types([T | Named ++ Args]);
-used_types({named_arg_t, _, _, T, _}) -> used_types(T);
-used_types({app_t, _, T, Ts})      -> used_types([T | Ts]);
-used_types({tuple_t, _, Ts})       -> used_types(Ts);
-used_types({id, _, X})             -> one(X);
-used_types({qid, _, _})            -> none();
-used_types({con, _, _})            -> none();
-used_types({qcon, _, _})           -> none();
-used_types({tvar, _, _})           -> none().

src/aeso_vm_decode.erl

@@ -0,0 +1,113 @@
+%%%-------------------------------------------------------------------
+%%% @copyright (C) 2017, Aeternity Anstalt
+%%% @doc Decoding aevm and fate data to AST
+%%%
+%%% @end
+%%%-------------------------------------------------------------------
+
+-module(aeso_vm_decode).
+
+-export([ from_aevm/3, from_fate/2 ]).
+
+-include_lib("aebytecode/include/aeb_fate_data.hrl").
+
+address_literal(Type, N) -> {Type, [], <<N:256>>}.
+
+-spec from_aevm(aeb_aevm_data:type(), aeso_syntax:type(), aeb_aevm_data:data()) -> aeso_syntax:expr().
+from_aevm(word, {id, _, "address"},                     N) -> address_literal(account_pubkey, N);
+from_aevm(word, {app_t, _, {id, _, "oracle"}, _},       N) -> address_literal(oracle_pubkey, N);
+from_aevm(word, {app_t, _, {id, _, "oracle_query"}, _}, N) -> address_literal(oracle_query_id, N);
+from_aevm(word, {con, _, _Name},                        N) -> address_literal(contract_pubkey, N);
+from_aevm(word, {id, _, "int"},     N) -> <<N1:256/signed>> = <<N:256>>, {int, [], N1};
+from_aevm(word, {id, _, "bits"},    N) -> error({todo, bits, N});
+from_aevm(word, {id, _, "bool"},    N) -> {bool, [], N /= 0};
+from_aevm(word, {bytes_t, _, Len}, Val) when Len =< 32 ->
+    <<Bytes:Len/unit:8, _/binary>> = <<Val:32/unit:8>>,
+    {bytes, [], <<Bytes:Len/unit:8>>};
+from_aevm({tuple, _}, {bytes_t, _, Len}, Val) ->
+    {bytes, [], binary:part(<< <<W:32/unit:8>> || W <- tuple_to_list(Val) >>, 0, Len)};
+from_aevm(string, {id, _, "string"}, S) -> {string, [], S};
+from_aevm({list, VmType}, {app_t, _, {id, _, "list"}, [Type]}, List) ->
+    {list, [], [from_aevm(VmType, Type, X) || X <- List]};
+from_aevm({variant, [[], [VmType]]}, {app_t, _, {id, _, "option"}, [Type]}, Val) ->
+    case Val of
+        {variant, 0, []}  -> {con, [], "None"};
+        {variant, 1, [X]} -> {app, [], {con, [], "Some"}, [from_aevm(VmType, Type, X)]}
+    end;
+from_aevm({tuple, VmTypes}, {tuple_t, _, Types}, Val)
+        when length(VmTypes) == length(Types),
+             length(VmTypes) == tuple_size(Val) ->
+    {tuple, [], [from_aevm(VmType, Type, X)
+                 || {VmType, Type, X} <- lists:zip3(VmTypes, Types, tuple_to_list(Val))]};
+from_aevm({tuple, VmTypes}, {record_t, Fields}, Val)
+        when length(VmTypes) == length(Fields),
+             length(VmTypes) == tuple_size(Val) ->
+    {record, [], [ {field, [], [{proj, [], FName}], from_aevm(VmType, FType, X)}
+                   || {VmType, {field_t, _, FName, FType}, X} <- lists:zip3(VmTypes, Fields, tuple_to_list(Val)) ]};
+from_aevm({map, VmKeyType, VmValType}, {app_t, _, {id, _, "map"}, [KeyType, ValType]}, Map)
+        when is_map(Map) ->
+    {map, [], [ {from_aevm(VmKeyType, KeyType, Key),
+                 from_aevm(VmValType, ValType, Val)}
+                || {Key, Val} <- maps:to_list(Map) ]};
+from_aevm({variant, VmCons}, {variant_t, Cons}, {variant, Tag, Args})
+        when length(VmCons) == length(Cons),
+             length(VmCons) > Tag ->
+    VmTypes = lists:nth(Tag + 1, VmCons),
+    ConType = lists:nth(Tag + 1, Cons),
+    from_aevm(VmTypes, ConType, Args);
+from_aevm(VmTypes, {constr_t, _, Con, Types}, Args)
+        when length(VmTypes) == length(Types),
+             length(VmTypes) == length(Args) ->
+    {app, [], Con, [ from_aevm(VmType, Type, Arg)
+                     || {VmType, Type, Arg} <- lists:zip3(VmTypes, Types, Args) ]};
+from_aevm(_VmType, _Type, _Data) ->
+    throw(cannot_translate_to_sophia).
+
+
+-spec from_fate(aeso_syntax:type(), aeb_fate_data:fate_type()) -> aeso_syntax:expr().
+from_fate({id, _, "address"}, ?FATE_ADDRESS(Bin)) -> {account_pubkey, [], Bin};
+from_fate({app_t, _, {id, _, "oracle"}, _}, ?FATE_ORACLE(Bin)) -> {oracle_pubkey, [], Bin};
+from_fate({app_t, _, {id, _, "oracle_query"}, _}, ?FATE_ORACLE_Q(Bin)) -> {oracle_query_id, [], Bin};
+from_fate({con, _, _Name},  ?FATE_CONTRACT(Bin)) -> {contract_pubkey, [], Bin};
+from_fate({bytes_t, _, N},  ?FATE_BYTES(Bin)) when byte_size(Bin) == N -> {bytes, [], Bin};
+from_fate({id, _, "bits"},  ?FATE_BITS(Bin)) -> error({todo, bits, Bin});
+from_fate({id, _, "int"},     N) when is_integer(N) -> {int, [], N};
+from_fate({id, _, "bool"},    B) when is_boolean(B) -> {bool, [], B};
+from_fate({id, _, "string"}, S) when is_binary(S) -> {string, [], S};
+from_fate({app_t, _, {id, _, "list"}, [Type]}, List) when is_list(List) ->
+    {list, [], [from_fate(Type, X) || X <- List]};
+from_fate({app_t, _, {id, _, "option"}, [Type]}, Val) ->
+    case Val of
+        {variant, [0, 1], 0, {}}  -> {con, [], "None"};
+        {variant, [0, 1], 1, {X}} -> {app, [], {con, [], "Some"}, [from_fate(Type, X)]}
+    end;
+from_fate({tuple_t, _, []}, ?FATE_UNIT) ->
+     {tuple, [], []};
+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, Fields}, ?FATE_TUPLE(Val))
+        when length(Fields) == tuple_size(Val) ->
+    {record, [], [ {field, [], [{proj, [], FName}], from_fate(FType, X)}
+                   || {{field_t, _, FName, FType}, X} <- lists:zip(Fields, tuple_to_list(Val)) ]};
+from_fate({app_t, _, {id, _, "map"}, [KeyType, ValType]}, Map)
+        when is_map(Map) ->
+    {map, [], [ {from_fate(KeyType, Key),
+                 from_fate(ValType, Val)}
+                || {Key, Val} <- maps:to_list(Map) ]};
+from_fate({variant_t, Cons}, {variant, Ar, Tag, Args})
+        when length(Cons) > Tag ->
+    ConType = lists:nth(Tag + 1, Cons),
+    Arity = lists:nth(Tag + 1, Ar),
+    case tuple_to_list(Args) of
+        ArgList when length(ArgList) == Arity ->
+            from_fate(ConType, ArgList);
+        _ -> throw(cannot_translate_to_sophia)
+    end;
+from_fate({constr_t, _, Con, Types}, Args)
+        when length(Types) == length(Args) ->
+    {app, [], Con, [ from_fate(Type, Arg)
+                     || {Type, Arg} <- lists:zip(Types, Args) ]};
+from_fate(_Type, _Data) ->
+    throw(cannot_translate_to_sophia).

src/aesophia.app.src

@@ -1,13 +1,15 @@
 {application, aesophia,
- [{description, "Contract Language for Aethernity"},
+ [{description, "Contract Language for aeternity"},
-  {vsn, "1.2.0"},
+  {vsn, "4.0.0-rc3"},
   {registered, []},
   {applications,
    [kernel,
     stdlib,
-    enacl,
+    jsx,
     syntax_tools,
-    aebytecode
+    getopt,
+    aebytecode,
+    eblake2
    ]},
   {env,[]},
   {modules, []},

test/aeso_abi_tests.erl

@@ -1,9 +1,12 @@
 -module(aeso_abi_tests).
 
 -include_lib("eunit/include/eunit.hrl").
--compile(export_all).
+-compile([export_all, nowarn_export_all]).
 
 -define(SANDBOX(Code), sandbox(fun() -> Code end)).
+-define(DUMMY_HASH_WORD, 16#123).
+-define(DUMMY_HASH, <<0:30/unit:8, 127, 119>>). %% 16#123
+-define(DUMMY_HASH_LIT, "#0000000000000000000000000000000000000000000000000000000000000123").
 
 sandbox(Code) ->
     Parent = self(),
@@ -19,8 +22,8 @@ sandbox(Code) ->
 
 malicious_from_binary_test() ->
     CircularList = from_words([32, 1, 32]), %% Xs = 1 :: Xs
-    {ok, {error, circular_references}}   = ?SANDBOX(aeso_heap:from_binary({list, word}, CircularList)),
+    {ok, {error, circular_references}}   = ?SANDBOX(aeb_heap:from_binary({list, word}, CircularList)),
-    {ok, {error, {binary_too_short, _}}} = ?SANDBOX(aeso_heap:from_binary(word, <<1, 2, 3, 4>>)),
+    {ok, {error, {binary_too_short, _}}} = ?SANDBOX(aeb_heap:from_binary(word, <<1, 2, 3, 4>>)),
     ok.
 
 from_words(Ws) ->
@@ -54,35 +57,198 @@ encode_decode_test() ->
     ok.
 
 encode_decode_sophia_test() ->
-    {42} = encode_decode_sophia_string("int", "42"),
+    Check = fun(Type, Str) -> case {encode_decode_sophia_string(Type, Str), Str} of
-    {1} = encode_decode_sophia_string("bool", "true"),
+                                {X, X} -> ok;
-    {0} = encode_decode_sophia_string("bool", "false"),
+                                Other -> Other
-    {<<"Hello">>} = encode_decode_sophia_string("string", "\"Hello\""),
+                              end end,
-    {<<"Hello">>, [1,2,3], {variant, 1, [1]}} =
+    ok = Check("int", "42"),
-        encode_decode_sophia_string(
+    ok = Check("int", "-42"),
-          "(string, list(int), option(bool))",
+    ok = Check("bool", "true"),
-          "\"Hello\", [1,2,3], Some(true)"),
+    ok = Check("bool", "false"),
+    ok = Check("string", "\"Hello\""),
+    ok = Check("string * list(int) * option(bool)",
+               "(\"Hello\", [1, 2, 3], Some(true))"),
+    ok = Check("variant", "Blue({[\"x\"] = 1})"),
+    ok = Check("r", "{x = (\"foo\", 0), y = Red}"),
     ok.
 
+to_sophia_value_neg_test() ->
+    Code = [ "contract Foo =\n"
+             "  entrypoint x(y : int) : string = \"hello\"\n" ],
+
+    {error, [Err1]} = aeso_compiler:to_sophia_value(Code, "x", ok, encode(12)),
+    ?assertEqual("Data error:\nFailed to decode binary as type string\n", aeso_errors:pp(Err1)),
+    {error, [Err2]} = aeso_compiler:to_sophia_value(Code, "x", ok, encode(12), [{backend, fate}]),
+    ?assertEqual("Data error:\nFailed to decode binary as type string\n", aeso_errors:pp(Err2)),
+
+    {error, [Err3]} = aeso_compiler:to_sophia_value(Code, "x", revert, encode(12)),
+    ?assertEqual("Data error:\nCould not interpret the revert message\n", aeso_errors:pp(Err3)),
+    {error, [Err4]} = aeso_compiler:to_sophia_value(Code, "x", revert, encode(12), [{backend, fate}]),
+    ?assertEqual("Data error:\nCould not deserialize the revert message\n", aeso_errors:pp(Err4)),
+    ok.
+
+encode_calldata_neg_test() ->
+    Code = [ "contract Foo =\n"
+             "  entrypoint x(y : int) : string = \"hello\"\n" ],
+
+    ExpErr1 = "Type error at line 5, col 34:\nCannot unify int\n         and bool\n"
+              "when checking the application at line 5, column 34 of\n"
+              "  x : (int) => string\nto arguments\n  true : bool\n",
+    {error, [Err1]} = aeso_compiler:create_calldata(Code, "x", ["true"]),
+    ?assertEqual(ExpErr1, aeso_errors:pp(Err1)),
+    {error, [Err2]} = aeso_compiler:create_calldata(Code, "x", ["true"], [{backend, fate}]),
+    ?assertEqual(ExpErr1, aeso_errors:pp(Err2)),
+
+    ok.
+
+decode_calldata_neg_test() ->
+    Code1 = [ "contract Foo =\n"
+              "  entrypoint x(y : int) : string = \"hello\"\n" ],
+    Code2 = [ "contract Foo =\n"
+              "  entrypoint x(y : string) : int = 42\n" ],
+
+    {ok, CallDataAEVM} = aeso_compiler:create_calldata(Code1, "x", ["42"]),
+    {ok, CallDataFATE} = aeso_compiler:create_calldata(Code1, "x", ["42"], [{backend, fate}]),
+
+    {error, [Err1]} = aeso_compiler:decode_calldata(Code2, "x", CallDataAEVM),
+    ?assertEqual("Data error:\nFailed to decode calldata as type {tuple,[string]}\n", aeso_errors:pp(Err1)),
+    {error, [Err2]} = aeso_compiler:decode_calldata(Code2, "x", <<1,2,3>>, [{backend, fate}]),
+    ?assertEqual("Data error:\nFailed to decode calldata binary\n", aeso_errors:pp(Err2)),
+    {error, [Err3]} = aeso_compiler:decode_calldata(Code2, "x", CallDataFATE, [{backend, fate}]),
+    ?assertEqual("Data error:\nCannot translate FATE value \"*\"\n  to Sophia type (string)\n", aeso_errors:pp(Err3)),
+
+    {error, [Err4]} = aeso_compiler:decode_calldata(Code2, "y", CallDataAEVM),
+    ?assertEqual("Data error at line 1, col 1:\nFunction 'y' is missing in contract\n", aeso_errors:pp(Err4)),
+    {error, [Err5]} = aeso_compiler:decode_calldata(Code2, "y", CallDataFATE, [{backend, fate}]),
+    ?assertEqual("Data error at line 1, col 1:\nFunction 'y' is missing in contract\n", aeso_errors:pp(Err5)),
+    ok.
+
+
 encode_decode_sophia_string(SophiaType, String) ->
     io:format("String ~p~n", [String]),
-    Code = [ "contract Call =\n"
+    Code = [ "contract MakeCall =\n"
-           , "  function foo : ", SophiaType, " => _\n"
+           , "  type arg_type = ", SophiaType, "\n"
-           , "  function __call() = foo(", String, ")\n" ],
+           , "  type an_alias('a) = string * 'a\n"
-    {ok, _, {Types, _}, Args} = aeso_compiler:check_call(lists:flatten(Code), []),
+           , "  record r = {x : an_alias(int), y : variant}\n"
-    Arg  = list_to_tuple(Args),
+           , "  datatype variant = Red | Blue(map(string, int))\n"
-    Type = {tuple, Types},
+           , "  entrypoint foo : arg_type => arg_type\n" ],
-    io:format("Type ~p~n", [Type]),
+    case aeso_compiler:check_call(lists:flatten(Code), "foo", [String], [no_code]) of
-    Data = encode(Arg),
+        {ok, _, {[Type], _}, [Arg]} ->
-    decode(Type, Data).
+            io:format("Type ~p~n", [Type]),
+            Data = encode(Arg),
+            case aeso_compiler:to_sophia_value(Code, "foo", ok, Data, [no_code]) of
+                {ok, Sophia} ->
+                    lists:flatten(io_lib:format("~s", [prettypr:format(aeso_pretty:expr(Sophia))]));
+                {error, Err} ->
+                    io:format("~s\n", [Err]),
+                    {error, Err}
+            end;
+        {error, Err} ->
+            io:format("~s\n", [Err]),
+            {error, Err}
+    end.
+
+calldata_test() ->
+    [42, <<"foobar">>] = encode_decode_calldata("foo", ["int", "string"], ["42", "\"foobar\""]),
+    Map = #{ <<"a">> => 4 },
+    [{variant, 1, [Map]}, {{<<"b">>, 5}, {variant, 0, []}}] =
+        encode_decode_calldata("foo", ["variant", "r"], ["Blue({[\"a\"] = 4})", "{x = (\"b\", 5), y = Red}"]),
+    [?DUMMY_HASH_WORD, 16#456] = encode_decode_calldata("foo", ["bytes(32)", "address"],
+                                                        [?DUMMY_HASH_LIT, "ak_1111111111111111111111111111113AFEFpt5"]),
+    [?DUMMY_HASH_WORD, ?DUMMY_HASH_WORD] =
+        encode_decode_calldata("foo", ["bytes(32)", "hash"], [?DUMMY_HASH_LIT, ?DUMMY_HASH_LIT]),
+
+    [119, {0, 0}] = encode_decode_calldata("foo", ["int", "signature"], ["119", [$# | lists:duplicate(128, $0)]]),
+
+    [16#456] = encode_decode_calldata("foo", ["Remote"], ["ct_1111111111111111111111111111113AFEFpt5"]),
+
+    ok.
+
+calldata_init_test() ->
+    encode_decode_calldata("init", ["int"], ["42"], {tuple, [typerep, word]}),
+
+    Code = parameterized_contract("foo", ["int"]),
+    encode_decode_calldata_(Code, "init", [], {tuple, [typerep, {tuple, []}]}).
+
+calldata_indent_test() ->
+    Test = fun(Extra) ->
+            Code = parameterized_contract(Extra, "foo", ["int"]),
+            encode_decode_calldata_(Code, "foo", ["42"], word)
+           end,
+    Test("  stateful entrypoint bla() = ()"),
+    Test("  type x = int"),
+    Test("  stateful entrypoint bla(x : int) =\n"
+         "    x + 1"),
+    Test("  stateful entrypoint bla(x : int) : int =\n"
+         "    x + 1"),
+    ok.
+
+parameterized_contract(FunName, Types) ->
+    parameterized_contract([], FunName, Types).
+
+parameterized_contract(ExtraCode, FunName, Types) ->
+    lists:flatten(
+        ["contract Remote =\n"
+         "  entrypoint bla : () => unit\n\n"
+         "contract Dummy =\n",
+         ExtraCode, "\n",
+         "  type an_alias('a) = string * 'a\n"
+         "  record r = {x : an_alias(int), y : variant}\n"
+         "  datatype variant = Red | Blue(map(string, int))\n"
+         "  entrypoint ", FunName, " : (", string:join(Types, ", "), ") => int\n" ]).
+
+oracle_test() ->
+    Contract =
+        "contract OracleTest =\n"
+        "  entrypoint question(o, q : oracle_query(list(string), option(int))) =\n"
+        "    Oracle.get_question(o, q)\n",
+    {ok, _, {[word, word], {list, string}}, [16#123, 16#456]} =
+        aeso_compiler:check_call(Contract, "question", ["ok_111111111111111111111111111111ZrdqRz9",
+                                                        "oq_1111111111111111111111111111113AFEFpt5"], [no_code]),
+
+    ok.
+
+permissive_literals_fail_test() ->
+    Contract =
+        "contract OracleTest =\n"
+        "  stateful entrypoint haxx(o : oracle(list(string), option(int))) =\n"
+        "    Chain.spend(o, 1000000)\n",
+    {error, [Err]} =
+        aeso_compiler:check_call(Contract, "haxx", ["#123"], []),
+    ?assertMatch("Type error at line 3, col 5:\nCannot unify" ++ _, aeso_errors:pp(Err)),
+    ?assertEqual(type_error, aeso_errors:type(Err)),
+    ok.
+
+encode_decode_calldata(FunName, Types, Args) ->
+    encode_decode_calldata(FunName, Types, Args, word).
+
+encode_decode_calldata(FunName, Types, Args, RetType) ->
+    Code = parameterized_contract(FunName, Types),
+    encode_decode_calldata_(Code, FunName, Args, RetType).
+
+encode_decode_calldata_(Code, FunName, Args, RetVMType) ->
+    {ok, Calldata} = aeso_compiler:create_calldata(Code, FunName, Args, []),
+    {ok, _, {ArgTypes, RetType}, _} = aeso_compiler:check_call(Code, FunName, Args, [{backend, aevm}, no_code]),
+    ?assertEqual(RetType, RetVMType),
+    CalldataType = {tuple, [word, {tuple, ArgTypes}]},
+    {ok, {_Hash, ArgTuple}} = aeb_heap:from_binary(CalldataType, Calldata),
+    case FunName of
+        "init" ->
+            ok;
+        _ ->
+            {ok, _ArgTypes, ValueASTs} = aeso_compiler:decode_calldata(Code, FunName, Calldata, []),
+            Values = [ prettypr:format(aeso_pretty:expr(V)) || V <- ValueASTs ],
+            ?assertMatch({X, X}, {Args, Values})
+    end,
+    tuple_to_list(ArgTuple).
 
 encode_decode(T, D) ->
     ?assertEqual(D, decode(T, encode(D))),
     D.
 
 encode(D) ->
-    aeso_heap:to_binary(D).
+    aeb_heap:to_binary(D).
 
 decode(T,B) ->
-    {ok, D} = aeso_heap:from_binary(T, B),
+    {ok, D} = aeb_heap:from_binary(T, B),
     D.

test/aeso_aci_tests.erl

@@ -0,0 +1,125 @@
+-module(aeso_aci_tests).
+
+-include_lib("eunit/include/eunit.hrl").
+
+simple_aci_test_() ->
+    [{"Test contract " ++ integer_to_list(N),
+      fun() -> test_contract(N) end}
+     || N <- [1, 2, 3]].
+
+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)).
+
+test_cases(1) ->
+    Contract = <<"payable contract C =\n"
+		 "  payable stateful entrypoint a(i : int) = i+1\n">>,
+    MapACI = #{contract =>
+		   #{name => <<"C">>,
+		     type_defs => [],
+                     payable => true,
+		     functions =>
+			 [#{name => <<"a">>,
+			    arguments =>
+				[#{name => <<"i">>,
+				   type => <<"int">>}],
+			    returns => <<"int">>,
+			    stateful => true,
+                            payable  => true}]}},
+    DecACI = <<"payable contract C =\n"
+	       "  payable entrypoint a : (int) => int\n">>,
+    {Contract,MapACI,DecACI};
+
+test_cases(2) ->
+    Contract = <<"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"
+               "  type allan = int\n"
+               "  entrypoint a : (C.allan) => int\n">>,
+    {Contract,MapACI,DecACI};
+test_cases(3) ->
+    Contract = <<"contract C =\n"
+                 "  type state = unit\n"
+                 "  datatype event = SingleEventDefined\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">>,
+		     type_defs =>
+			 [#{name => <<"bert">>,
+			    typedef =>
+				#{variant =>
+				      [#{<<"Bin">> => [<<"'a">>]}]},
+			    vars => [#{name => <<"'a">>}]}]}},
+    DecACI = <<"contract C =\n"
+               "  type state = unit\n"
+               "  datatype event = SingleEventDefined\n"
+	       "  datatype bert('a) = Bin('a)\n"
+	       "  entrypoint a : (C.bert(string)) => int\n">>,
+    {Contract,MapACI,DecACI}.
+
+%% Rounttrip
+aci_test_() ->
+    [{"Testing ACI generation for " ++ ContractName,
+      fun() -> aci_test_contract(ContractName) end}
+     || ContractName <- all_contracts()].
+
+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),
+
+    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}]),
+
+    ok.
+
+check_stub(Stub, Options) ->
+    case aeso_parser:string(binary_to_list(Stub), Options) of
+        Ast ->
+            try
+                %% io:format("AST: ~120p\n", [Ast]),
+                aeso_ast_infer_types:infer(Ast, [])
+            catch throw:{type_errors, TE} ->
+                io:format("Type error:\n~s\n", [TE]),
+                error(TE);
+                  _:R ->
+                io:format("Error: ~p\n", [R]),
+                error(R)
+            end;
+        {error, E} ->
+            io:format("Error: ~p\n", [E]),
+            error({parse_error, E})
+    end.
+

test/aeso_calldata_tests.erl

@@ -0,0 +1,129 @@
+%%% -*- erlang-indent-level:4; indent-tabs-mode: nil -*-
+%%%-------------------------------------------------------------------
+%%% @copyright (C) 2019, Aeternity Anstalt
+%%% @doc Test Sophia language compiler.
+%%%
+%%% @end
+%%%-------------------------------------------------------------------
+
+-module(aeso_calldata_tests).
+
+-compile([export_all, nowarn_export_all]).
+
+-include_lib("eunit/include/eunit.hrl").
+
+%%  Very simply test compile the given contracts. Only basic checks
+%%  are made on the output, just that it is a binary which indicates
+%%  that the compilation worked.
+calldata_test_() ->
+     [ {"Testing " ++ ContractName ++ " contract calling " ++ Fun,
+        fun() ->
+           ContractString = aeso_test_utils:read_contract(ContractName),
+           AevmExprs =
+              case not lists:member(ContractName, not_yet_compilable(aevm)) of
+                  true -> ast_exprs(ContractString, Fun, Args, [{backend, aevm}]);
+                  false -> undefined
+              end,
+           FateExprs =
+              case not lists:member(ContractName, not_yet_compilable(fate)) of
+                  true -> ast_exprs(ContractString, Fun, Args, [{backend, fate}]);
+                  false -> undefined
+              end,
+           case FateExprs == undefined orelse AevmExprs == undefined of
+               true -> ok;
+               false ->
+                   ?assertEqual(FateExprs, AevmExprs)
+           end
+        end} || {ContractName, Fun, Args} <- compilable_contracts()].
+
+calldata_aci_test_() ->
+     [ {"Testing " ++ ContractName ++ " contract calling " ++ Fun,
+        fun() ->
+           ContractString       = aeso_test_utils:read_contract(ContractName),
+           {ok, ContractACIBin} = aeso_aci:contract_interface(string, ContractString),
+           ContractACI = binary_to_list(ContractACIBin),
+           io:format("ACI:\n~s\n", [ContractACIBin]),
+           AevmExprs =
+              case not lists:member(ContractName, not_yet_compilable(aevm)) of
+                  true -> ast_exprs(ContractACI, Fun, Args, [{backend, aevm}]);
+                  false -> undefined
+              end,
+           FateExprs =
+              case not lists:member(ContractName, not_yet_compilable(fate)) of
+                  true -> ast_exprs(ContractACI, Fun, Args, [{backend, fate}]);
+                  false -> undefined
+              end,
+           case FateExprs == undefined orelse AevmExprs == undefined of
+               true -> ok;
+               false ->
+                   ?assertEqual(FateExprs, AevmExprs)
+           end
+        end} || {ContractName, Fun, Args} <- compilable_contracts()].
+
+
+ast_exprs(ContractString, Fun, Args, Opts) ->
+    {ok, Data} = (catch aeso_compiler:create_calldata(ContractString, Fun, Args, Opts)),
+    {ok, _Types, Exprs} = (catch aeso_compiler:decode_calldata(ContractString, Fun, Data, Opts)),
+    ?assert(is_list(Exprs)),
+    Exprs.
+
+check_errors(Expect, ErrorString) ->
+    %% This removes the final single \n as well.
+    Actual = binary:split(<<ErrorString/binary,$\n>>, <<"\n\n">>, [global,trim]),
+    case {Expect -- Actual, Actual -- Expect} of
+        {[], Extra}   -> ?assertMatch({unexpected, []}, {unexpected, Extra});
+        {Missing, []} -> ?assertMatch({missing, []}, {missing, Missing});
+        {Missing, Extra} -> ?assertEqual(Missing, Extra)
+    end.
+
+%% compilable_contracts() -> [ContractName].
+%%  The currently compilable contracts.
+
+compilable_contracts() ->
+    [
+     {"identity", "init", []},
+     {"maps", "init", []},
+     {"funargs", "menot", ["false"]},
+     {"funargs", "append", ["[\"false\", \" is\", \" not\", \" true\"]"]},
+     %% TODO {"funargs", "bitsum", ["Bits.all"]},
+     {"funargs", "read", ["{label = \"question 1\", result = 4}"]},
+     {"funargs", "sjutton", ["#0011012003100011012003100011012003"]},
+     {"funargs", "sextiosju", ["#01020304050607080910111213141516171819202122232425262728293031323334353637383940"
+                               "414243444546474849505152535455565758596061626364656667"]},
+     {"funargs", "trettiotva", ["#0102030405060708091011121314151617181920212223242526272829303132"]},
+     {"funargs", "find_oracle", ["ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5"]},
+     {"funargs", "find_query", ["oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY"]},
+     {"funargs", "traffic_light", ["Green"]},
+     {"funargs", "traffic_light", ["Pantone(12)"]},
+     {"funargs", "tuples", ["()"]},
+     %% TODO {"funargs", "due", ["FixedTTL(1020)"]},
+     {"variant_types", "init", []},
+     {"basic_auth", "init", []},
+     {"address_literals", "init", []},
+     {"bytes_equality", "init", []},
+     {"address_chain", "init", []},
+     {"counter", "init",
+      ["-3334353637383940202122232425262728293031323334353637"]},
+     {"dutch_auction", "init",
+      ["ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt", "200000", "1000"]},
+     {"maps", "fromlist_i",
+      ["[(1, {x = 1, y = 2}), (2, {x = 3, y = 4}), (3, {x = 4, y = 4})]"]},
+     {"maps", "get_i", ["1", "{}"]},
+     {"maps", "get_i", ["1", "{[1] = {x = 3, y = 4}}"]},
+     {"maps", "get_i", ["1", "{[1] = {x = 3, y = 4}, [2] = {x = 4, y = 5}}"]},
+     {"maps", "get_i", ["1", "{[1] = {x = 3, y = 4}, [2] = {x = 4, y = 5}, [3] = {x = 5, y = 6}}"]},
+     {"strings", "str_concat", ["\"test\"","\"me\""]},
+     {"complex_types", "filter_some", ["[Some(11), Some(12), None]"]},
+     {"complex_types", "init", ["ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ"]},
+     {"__call" "init", []},
+     {"bitcoin_auth", "authorize", ["1", "#0102030405060708090a0b0c0d0e0f101718192021222324252627282930313233343536373839401a1b1c1d1e1f20212223242526272829303132333435363738"]},
+     {"bitcoin_auth", "to_sign", ["#0102030405060708090a0b0c0d0e0f1017181920212223242526272829303132", "2"]},
+     {"stub", "foo", ["42"]},
+     {"stub", "foo", ["-42"]},
+     {"payable", "foo", ["42"]}
+    ].
+
+not_yet_compilable(fate) ->
+    [];
+not_yet_compilable(aevm) ->
+    [].

test/aeso_compiler_tests.erl

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

test/aeso_eunit_SUITE.erl

@@ -12,9 +12,11 @@ groups() ->
                  , aeso_parser_tests
                  , aeso_compiler_tests
                  , aeso_abi_tests
+		 , aeso_aci_tests
                  ]}].
 
 aeso_scan_tests(_Config)   -> ok = eunit:test(aeso_scan_tests).
 aeso_parser_tests(_Config) -> ok = eunit:test(aeso_parser_tests).
 aeso_compiler_tests(_Config) -> ok = eunit:test(aeso_compiler_tests).
 aeso_abi_tests(_Config) -> ok = eunit:test(aeso_abi_tests).
+aeso_aci_tests(_Config) -> ok = eunit:test(aeso_aci_tests).

test/aeso_parser_tests.erl

@@ -39,7 +39,7 @@ simple_contracts_test_() ->
             RightAssoc = fun(Op) -> CheckParens({a, Op, {b, Op, c}}) end,
             NonAssoc   = fun(Op) ->
                             OpAtom = list_to_atom(Op),
-                            ?assertError({error, {_, parse_error, _}},
+                            ?assertThrow({error, [_]},
                                          parse_expr(NoPar({a, Op, {b, Op, c}}))) end,
             Stronger = fun(Op1, Op2) ->
                     CheckParens({{a, Op1, b}, Op2, c}),
@@ -62,7 +62,7 @@ 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, withdrawal, fundme, dutch_auction] ]
+        || Contract <- [counter, voting, all_syntax, '05_greeter', aeproof, multi_sig, simple_storage, fundme, dutch_auction] ]
     }.
 
 parse_contract(Name) ->
@@ -71,11 +71,10 @@ parse_contract(Name) ->
 roundtrip_contract(Name) ->
     round_trip(aeso_test_utils:read_contract(Name)).
 
-parse_string(Text) ->
+parse_string(Text) -> parse_string(Text, []).
-    case aeso_parser:string(Text) of
+
-        {ok, Contract} -> Contract;
+parse_string(Text, Opts) ->
-        Err -> error(Err)
+    aeso_parser:string(Text, Opts).
-    end.
 
 parse_expr(Text) ->
     [{letval, _, _, _, Expr}] =
@@ -84,12 +83,16 @@ parse_expr(Text) ->
 
 round_trip(Text) ->
     Contract  = parse_string(Text),
-    Text1     = prettypr:format(aeso_pretty:decls(Contract)),
+    Text1     = prettypr:format(aeso_pretty:decls(strip_stdlib(Contract))),
     Contract1 = parse_string(Text1),
     NoSrcLoc  = remove_line_numbers(Contract),
     NoSrcLoc1 = remove_line_numbers(Contract1),
     ?assertMatch(NoSrcLoc, diff(NoSrcLoc, NoSrcLoc1)).
 
+strip_stdlib([{namespace, _, {con, _, "ListInternal"}, _} | Decls]) ->
+    strip_stdlib(Decls);
+strip_stdlib(Decls) -> Decls.
+
 remove_line_numbers({line, _L}) -> {line, 0};
 remove_line_numbers({col,  _C}) -> {col, 0};
 remove_line_numbers([H|T]) ->

test/aeso_scan_tests.erl

@@ -41,14 +41,14 @@ all_tokens() ->
     %% Operators
     lists:map(Lit, ['=', '==', '!=', '>', '<', '>=', '=<', '-', '+', '++', '*', '/', mod, ':', '::', '->', '=>', '||', '&&', '!']) ++
     %% Keywords
-    lists:map(Lit, [contract, type, 'let', switch, rec, 'and']) ++
+    lists:map(Lit, [contract, type, 'let', switch]) ++
     %% Comment token (not an actual token), just for tests
     [{comment, 0, "// *Comment!\"\n"},
      {comment, 0, "/* bla /* bla bla */*/"}] ++
     %% Literals
     [ Lit(true), Lit(false)
     , Tok(id, "foo"), Tok(id, "_"), Tok(con, "Foo")
-    , Tok(hash, Hash)
+    , Tok(bytes, Hash)
     , Tok(int, 1234567890), Tok(hex, 9876543210)
     , Tok(string, <<"bla\"\\\b\e\f\n\r\t\vbla">>)
     ].
@@ -78,7 +78,7 @@ show_token({param, _, P}) -> "@" ++ P;
 show_token({string, _, S}) -> fmt(binary_to_list(S));
 show_token({int, _, N}) -> fmt(N);
 show_token({hex, _, N}) -> fmt("0x~.16b", N);
-show_token({hash, _, <<N:256>>}) -> fmt("#~.16b", N);
+show_token({bytes, _, <<N:256>>}) -> fmt("#~64.16.0b", N);
 show_token({comment, _, S}) -> S;
 show_token({_, _, _}) -> "TODO".
 

test/contract_tests.erl

@@ -1,28 +0,0 @@
--module(contract_tests).
-
--include_lib("eunit/include/eunit.hrl").
-
-make_cmd() -> "make -C " ++ aeso_test_utils:contract_path().
-
-contracts_test_() ->
-    {setup,
-     fun()  -> os:cmd(make_cmd()) end,
-     fun(_) -> os:cmd(make_cmd() ++ " clean") end,
-     [ {"Testing the " ++ Contract ++ " contract",
-        fun() ->
-          ?assertCmdOutput(Expected, filename:join(aeso_test_utils:contract_path(), Contract ++ "_test"))
-        end} || {Contract, Expected} <- contracts() ]}.
-
-contracts() ->
-    [].
-  %% [{"voting",
-  %%   "Delegate before vote\n"
-  %%   "Cake: 1\n"
-  %%   "Beer: 2\n"
-  %%   "Winner: Beer\n"
-  %%   "Delegate after vote\n"
-  %%   "Cake: 1\n"
-  %%   "Beer: 2\n"
-  %%   "Winner: Beer\n"
-  %% }].
-

test/contracts/__call.aes

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

test/contracts/abort_test.aes

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

test/contracts/abort_test_int.aes

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

test/contracts/address_chain.aes

@@ -0,0 +1,36 @@
+contract Remote =
+  entrypoint main : (int) => unit
+
+contract AddrChain =
+  type o_type = oracle(string, map(string, int))
+  type oq_type = oracle_query(string, map(string, int))
+
+  entrypoint is_o(a : address) =
+    Address.is_oracle(a)
+
+  entrypoint is_c(a : address) =
+    Address.is_contract(a)
+
+//   entrypoint get_o(a : address) : option(o_type) =
+//     Address.get_oracle(a)
+
+//   entrypoint get_c(a : address) : option(Remote) =
+//     Address.get_contract(a)
+
+  entrypoint check_o(o : o_type) =
+    Oracle.check(o)
+
+  entrypoint check_oq(o : o_type, oq : oq_type) =
+    Oracle.check_query(o, oq)
+
+//   entrypoint h_to_i(h : hash) : int =
+//     Hash.to_int(h)
+
+//   entrypoint a_to_i(a : address) : int =
+//     Address.to_int(a) mod 10 ^ 16
+
+  entrypoint c_creator() : address =
+    Contract.creator
+
+  entrypoint is_payable(a : address) : bool =
+    Address.is_payable(a)

test/contracts/address_literals.aes

@@ -0,0 +1,14 @@
+
+contract Remote =
+  entrypoint foo : () => unit
+
+contract AddressLiterals =
+  entrypoint addr() : address =
+    ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt
+  entrypoint oracle() : oracle(int, bool) =
+    ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5
+  entrypoint query() : oracle_query(int, bool) =
+    oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY
+  entrypoint contr() : Remote =
+    ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ
+

test/contracts/aens.aes

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

test/contracts/aeproof.aes

@@ -104,10 +104,10 @@ contract AEProof =
                      proofsByOwner : map(address, array(uint)) }
 
     function notarize(document:string, comment:string, ipfsHash:hash) =
-        let _ = require(aetoken.balanceOf(caller()) > 0)
+        let _ = require(aetoken.balanceOf(caller()) > 0, "false")
         let proofHash: uint = calculateHash(document)
         let proof : proof = Map.get_(proofHash, state().proofs)
-        let _ = require(proof.owner == #0)
+        let _ = require(proof.owner == #0, "false")
         let proof' : proof = proof { owner = caller()
                                    , timestamp = block().timestamp
                                    , proofBlock = block().height
@@ -124,12 +124,12 @@ contract AEProof =
     function getProof(document) : proof =
         let calcHash = calculateHash(document)
         let proof = Map.get_(calcHash, state().proofs)
-        let _ = require(proof.owner != #0)
+        let _ = require(proof.owner != #0, "false")
         proof
 
     function getProofByHash(hash: uint) : proof =
         let proof = Map.get_(hash, state().proofs)
-        let _ = require(proof.owner != #0)
+        let _ = require(proof.owner != #0, "false")
         proof
 
 
@@ -141,5 +141,3 @@ contract AEProof =
     function getProofsByOwner(owner: address): array(uint) =
         Map.get(owner, state())
 
-    function require(x : bool) : unit = if(x) () else abort("false")
-

test/contracts/all_syntax.aes

@@ -24,7 +24,7 @@ contract AllSyntax =
         if(valWithType(Map.empty) == None)
           print(42 mod 10 * 5 / 3)
 
-  function funWithType(x : int, y) : (int, list(int)) = (x, 0 :: [y] ++ [])
+  function funWithType(x : int, y) : int * list(int) = (x, 0 :: [y] ++ [])
   function funNoType() =
     let foo = (x, y : bool) =>
                 if (! (y && x =< 0x0b || true)) [x]
@@ -36,13 +36,6 @@ contract AllSyntax =
       (x, [y, z]) => bar({x = z, y = -y + - -z * (-1)})
       (x, y :: _) => ()
 
-  function bitOperations(x, y) = bnot (0xff00 band x bsl 4 bxor 0xa5a5a5 bsr 4 bor y)
-
-  function mutual() =
-    let rec recFun(x : int) = mutFun(x)
-        and mutFun(x) = if(x =< 0) 1 else x * recFun(x - 1)
-    recFun(0)
-
   let hash : address = #01ab0fff11
   let b = false
   let qcon = Mod.Con

test/contracts/bad_address_literals.aes

@@ -0,0 +1,33 @@
+
+contract Remote =
+  entrypoint foo : () => unit
+
+contract AddressLiterals =
+  entrypoint addr1() : bytes(32) =
+    ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt
+  entrypoint addr2() : Remote =
+    ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt
+  entrypoint addr3() : oracle(int, bool) =
+    ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt
+
+  entrypoint oracle1() : oracle_query(int, bool) =
+    ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5
+  entrypoint oracle2() : bytes(32) =
+    ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5
+  entrypoint oracle3() : Remote =
+    ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5
+
+  entrypoint query1() : oracle(int, bool) =
+    oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY
+  entrypoint query2() : bytes(32) =
+    oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY
+  entrypoint query3() : Remote =
+    oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY
+
+  entrypoint contr1() : address =
+    ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ
+  entrypoint contr2() : oracle(int, bool) =
+    ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ
+  entrypoint contr3() : bytes(32) =
+    ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ
+

test/contracts/bad_bytes_concat.aes

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

test/contracts/bad_bytes_split.aes

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

test/contracts/bad_events.aes

@@ -0,0 +1,23 @@
+contract Events =
+  type alias_int = int
+  type alias_address = address
+  type alias_string = string
+
+  datatype event =
+      Event1(indexed alias_int, indexed int, string)
+    | Event2(alias_string, indexed alias_address)
+    | BadEvent1(indexed string)
+    | BadEvent2(indexed alias_string)
+
+  entrypoint f1(x : int, y : string) =
+    Chain.event(Event1(x, x+1, y))
+
+  entrypoint f2(s : string) =
+    Chain.event(Event2(s, Call.caller))
+
+  entrypoint f3(x : int) =
+    Chain.event(Event1(x, x + 2, Int.to_str(x + 7)))
+
+  entrypoint i2s(i : int) = Int.to_str(i)
+  entrypoint a2s(a : address) = Address.to_str(a)
+

test/contracts/bad_events2.aes

@@ -0,0 +1,23 @@
+contract Events =
+  type alias_int = int
+  type alias_address = address
+  type alias_string = string
+
+  datatype event =
+      Event1(indexed alias_int, indexed int, string)
+    | Event2(alias_string, indexed alias_address)
+    | BadEvent1(string, string)
+    | BadEvent2(indexed int, indexed int, indexed int, indexed address)
+
+  entrypoint f1(x : int, y : string) =
+    Chain.event(Event1(x, x+1, y))
+
+  entrypoint f2(s : string) =
+    Chain.event(Event2(s, Call.caller))
+
+  entrypoint f3(x : int) =
+    Chain.event(Event1(x, x + 2, Int.to_str(x + 7)))
+
+  entrypoint i2s(i : int) = Int.to_str(i)
+  entrypoint a2s(a : address) = Address.to_str(a)
+

test/contracts/bad_include_and_ns.aes

@@ -0,0 +1,6 @@
+contract Bad =
+  include "included.aes"
+  namespace Foo =
+    function foo() = 42
+
+  entrypoint foo() = 43

test/contracts/bad_init_state_access.aes

@@ -0,0 +1,13 @@
+contract BadInit =
+
+  type state = int
+
+  entrypoint new_state(n) = state + n
+
+  stateful entrypoint roundabout(n) = put(n)
+  stateful entrypoint set_state(n) = roundabout(n)
+
+  stateful entrypoint init() =
+    set_state(4)
+    new_state(0)
+    state + state

test/contracts/bad_top_level_decl.aes

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

test/contracts/basic_auth.aes

@@ -0,0 +1,17 @@
+// Contract replicating "normal" Aeternity authentication
+contract BasicAuth =
+  record state = { nonce : int, owner : address }
+
+  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) => Crypto.verify_sig(to_sign(tx_hash, n), state.owner, s)
+
+  entrypoint to_sign(h : hash, n : int) =
+    Crypto.blake2b((h, n))
+

test/contracts/bitcoin_auth.aes

@@ -0,0 +1,16 @@
+contract BitcoinAuth =
+  record state = { nonce : int, owner : bytes(20) }
+
+  entrypoint init(owner' : bytes(20)) = { nonce = 1, owner = owner' }
+
+  stateful entrypoint authorize(n : int, s : bytes(65)) : bool =
+    require(n >= state.nonce, "Nonce too low")
+    require(n =< state.nonce, "Nonce too high")
+    put(state{ nonce = n + 1 })
+    switch(Auth.tx_hash)
+      None          => abort("Not in Auth context")
+      Some(tx_hash) => Crypto.ecverify_secp256k1(to_sign(tx_hash, n), state.owner, s)
+
+  entrypoint to_sign(h : hash, n : int) : hash =
+    Crypto.blake2b((h, n))
+

test/contracts/builtin_bug.aes

@@ -5,8 +5,8 @@ contract BuiltinBug =
 
   record state = {proofs : map(address, list(string))}
 
-  public function init() = {proofs = {}}
+  entrypoint init() = {proofs = {}}
 
-  public stateful function createProof(hash : string) =
+  stateful entrypoint createProof(hash : string) =
     put( state{ proofs[Call.caller] = hash :: state.proofs[Call.caller] } )
 

test/contracts/builtin_map_get_bug.aes

@@ -1,12 +1,8 @@
 contract TestContract =
-  record state = { 
+  record state = {_allowed : map(address, map(address, int))}
-    _allowed          : map(address, map(address, int))}
 
-  public stateful function init() = {
+  entrypoint init() = {_allowed = {}}
-    _allowed = {}}
-
-  public stateful function approve(spender: address, value: int) : bool = 
 
+  stateful entrypoint approve(spender: address, value: int) : bool =
     put(state{_allowed[Call.caller][spender] = value})
-
     true

test/contracts/bytes_concat.aes

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

test/contracts/bytes_equality.aes

@@ -0,0 +1,18 @@
+
+contract BytesEquality =
+
+  entrypoint eq16(a : bytes(16), b) = a == b
+  entrypoint ne16(a : bytes(16), b) = a != b
+
+  entrypoint eq32(a : bytes(32), b) = a == b
+  entrypoint ne32(a : bytes(32), b) = a != b
+
+  entrypoint eq47(a : bytes(47), b) = a == b
+  entrypoint ne47(a : bytes(47), b) = a != b
+
+  entrypoint eq64(a : bytes(64), b) = a == b
+  entrypoint ne64(a : bytes(64), b) = a != b
+
+  entrypoint eq65(a : bytes(65), b) = a == b
+  entrypoint ne65(a : bytes(65), b) = a != b
+

test/contracts/bytes_to_x.aes

@@ -0,0 +1,8 @@
+
+contract BytesToX =
+
+  entrypoint to_int(b : bytes(42)) : int = Bytes.to_int(b)
+  entrypoint to_str(b : bytes(12)) : string =
+    String.concat(Bytes.to_str(b), Bytes.to_str(#ffff))
+  entrypoint to_str_big(b : bytes(65)) : string =
+    Bytes.to_str(b)

test/contracts/calling_init_function.aes

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

test/contracts/chain.aes

@@ -1,6 +1,6 @@
 // Test more advanced chain interactions
 
-contract Chain =
+contract ChainTest =
 
   record state = { last_bf : address }
 
@@ -10,4 +10,4 @@ contract Chain =
   function miner() = Chain.coinbase
 
   function save_coinbase() =
-    put(state{last_bf = Chain.coinbase})
+    put(state{last_bf = Chain.coinbase})

test/contracts/code_errors/bad_aens_resolve.aes

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

test/contracts/code_errors/complex_compare.aes

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

test/contracts/code_errors/complex_compare_leq.aes

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

test/contracts/code_errors/higher_order_compare.aes

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

test/contracts/code_errors/higher_order_entrypoint.aes

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

test/contracts/code_errors/higher_order_entrypoint_return.aes

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

test/contracts/code_errors/higher_order_map_keys.aes

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

test/contracts/code_errors/higher_order_query_type.aes

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

test/contracts/code_errors/higher_order_response_type.aes

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

test/contracts/code_errors/higher_order_state.aes

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

test/contracts/code_errors/last_declaration_must_be_contract.aes

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

test/contracts/code_errors/missing_definition.aes

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

test/contracts/code_errors/missing_init_function.aes

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

test/contracts/code_errors/parameterised_event.aes

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

test/contracts/code_errors/parameterised_state.aes

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

test/contracts/code_errors/polymorphic_aens_resolve.aes

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

test/contracts/code_errors/polymorphic_compare.aes

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

test/contracts/code_errors/polymorphic_entrypoint.aes

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

test/contracts/code_errors/polymorphic_entrypoint_return.aes

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

test/contracts/code_errors/polymorphic_map_keys.aes

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

test/contracts/code_errors/polymorphic_query_type.aes

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

test/contracts/code_errors/polymorphic_response_type.aes

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

test/contracts/code_errors/unapplied_contract_call.aes

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