Merge branch 'master' into quickcheck-ci

No script needed if we make sure extra_src_dirs has different name than "eqc"

Obsolete QuickCheck property

.circleci/config.yml

@@ -19,16 +19,16 @@ jobs:
             - dialyzer-cache-v2-
       - run:
           name: Build
-          command: ./rebar3 compile
+          command: rebar3 compile
       - run:
           name: Static Analysis
-          command: ./rebar3 dialyzer
+          command: rebar3 dialyzer
       - run:
           name: Eunit
-          command: ./rebar3 eunit
+          command: rebar3 eunit
       - run:
           name: Common Tests
-          command: ./rebar3 ct
+          command: rebar3 ct
       - save_cache:
           key: dialyzer-cache-v2-{{ .Branch }}-{{ .Revision }}
           paths:

.eqc_ci

@@ -0,0 +1,3 @@
+{build, "rebar3 as eqc compile"}.
+{test_root, "."}.
+{test_path, "_build/eqc/lib/aesophia/quickcheck"}.   %% here are the properties

.gitignore

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

CHANGELOG.md

@@ -1,146 +0,0 @@
-# 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
-- Standard library support. `ListInternal` can be included implicitly if list comprehensions are used.
-- Added the `[a..b]` language construct, returning the list of numbers between
-  `a` and `b` (inclusive). Returns the empty list if `a` > `b`.
-### Changed
-### 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-rc1...HEAD
-[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

@@ -9,17 +9,8 @@ It is an OTP application written in Erlang and is by default included in
 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

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

@@ -15,7 +15,7 @@ returns the compiled module in a map which can then be loaded.
 ``` erlang
 contract_string() = string() | binary()
 contract_map() = #{bytecode => binary(),
-                   compiler_version => binary(),
+                   compiler_version => string(),
                    contract_souce => string(),
                    type_info => type_info()}
 type_info()
@@ -75,12 +75,12 @@ Types
 
 Get the type representation of a type declaration.
 
-#### version() -> {ok, Version} | {error, term()}
+#### version() -> Version
 
 Types
 
 ``` erlang
-Version = binary()
+Version = integer()
 ```
 
 Get the current version of the Sophia compiler.

include/aeso_heap.hrl

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

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

priv/stdlib/List.aes

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

priv/stdlib/ListInternal.aes

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

priv/stdlib/Option.aes

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

priv/stdlib/Pair.aes

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

priv/stdlib/Triple.aes

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

quickcheck/aeso_heap_eqc.erl

@@ -0,0 +1,109 @@
+%%% File        : aeso_heap_eqc.erl
+%%% Author      : Ulf Norell
+%%% Description :
+%%% Created     : 28 May 2018 by Ulf Norell
+-module(aeso_heap_eqc).
+
+-compile([export_all, nowarn_export_all]).
+-include_lib("eqc/include/eqc.hrl").
+
+-define(SANDBOX(Code), sandbox(fun() -> Code end)).
+
+sandbox(Code) ->
+    Parent = self(),
+    Tag    = make_ref(),
+    {Pid, Ref} = spawn_monitor(fun() -> Parent ! {Tag, Code()} end),
+    receive
+        {Tag, Res} -> erlang:demonitor(Ref, [flush]), {ok, Res};
+        {'DOWN', Ref, process, Pid, Reason} -> {error, Reason}
+    after 100 ->
+        exit(Pid, kill),
+        {error, loop}
+    end.
+
+prop_from_binary() ->
+    ?FORALL({T, Bin}, {type(), blob()},
+    begin
+    Tag = fun(X) when is_atom(X) -> X; (X) when is_tuple(X) -> element(1, X) end,
+    case ?SANDBOX(aeso_heap:from_binary(T, Bin)) of
+        {ok, Res} -> collect({Tag(T), element(1, Res)}, true);
+        Err       -> equals(Err, {ok, '_'})
+    end end).
+
+type() -> ?LET(Depth, choose(0, 2), type(Depth, true)).
+type(Depth, TypeRep) ->
+    oneof(
+    [ elements([word, string] ++ [typerep || TypeRep]) ] ++
+    [ ?LETSHRINK([T], [type(Depth - 1, TypeRep)], {list, T})       || Depth > 0 ] ++
+    [ ?LETSHRINK([T], [type(Depth - 1, TypeRep)], {option, T})     || Depth > 0 ] ++
+    [ ?LETSHRINK(Ts,  list(type(Depth - 1, TypeRep)), {tuple, Ts}) || Depth > 0 ] ++
+    [ ?LETSHRINK([K, V], vector(2, type(Depth - 1, TypeRep)), {map, K, V}) || Depth > 0 ] ++
+    []
+    ).
+
+blob() ->
+    ?LET(Blobs, list(oneof([ ?LET(Ws, words(), return(from_words(Ws)))
+                           , binary() ])),
+    return(list_to_binary(Blobs))).
+
+words() -> list(word()).
+word() ->
+    frequency(
+    [ {4, ?LET(N, nat(), 32 * N)}
+    , {1, choose(0, 320)}
+    , {2, -1}
+    , {2, elements(["foo", "zzzzz"])} ]).
+
+from_words(Ws) ->
+    << <<(from_word(W))/binary>> || W <- Ws >>.
+
+from_word(W) when is_integer(W) ->
+    <<W:256>>;
+from_word(S) when is_list(S) ->
+    Len = length(S),
+    Bin = <<(list_to_binary(S))/binary, 0:(32 - Len)/unit:8>>,
+    <<Len:256, Bin/binary>>.
+
+typerep() -> ?LET(Depth, choose(0, 2),
+             ?LET(T, type(Depth, true), return(typerep(T)))).
+
+typerep(word)          -> word;
+typerep(string)        -> string;
+typerep(typerep)       -> typerep;
+typerep({tuple, Ts})   -> {tuple, typerep(Ts)};
+typerep({list, T})     -> {list, typerep(T)};
+typerep({variant, Cs}) -> {variant, typerep(Cs)};
+typerep({option, T})   -> {variant, [[], [typerep(T)]]};
+typerep({map, K, V})   -> {list, typerep({tuple, [K, V]})};
+typerep([])            -> [];
+typerep([T | Ts])      -> [typerep(T) | typerep(Ts)].
+
+value(word) ->
+    <<N:256>> = <<(-1):256>>,
+    choose(0, N);
+value(string) ->
+    ?LET(N, choose(0, 128), binary(N));
+value(typerep) ->
+    typerep();
+value({list, T}) ->
+    list(value(T));
+value({option, T}) ->
+    weighted_default({1, none}, {3, {some, value(T)}});
+value({tuple, Ts}) ->
+    ?LET(Vs, [ value(T) || T <- Ts ], list_to_tuple(Vs));
+value({map, K, V}) ->
+    map(value(K), value(V));
+value({variant, Cs}) ->
+    ?LET(I, choose(0, length(Cs) - 1),
+    {variant, I, [ value(T) || T <- lists:nth(I + 1, Cs) ]}).
+
+typed_val() ->
+    ?LET(T, type(), ?LET(V, value(T), return({T, V}))).
+
+prop_roundtrip() ->
+    ?FORALL(T, type(),
+    ?FORALL(V, value(T),
+    ?FORALL(B, choose(0, 4),
+    equals(aeso_heap:from_binary(T, aeso_heap:to_binary(V, B * 32), B * 32),
+           {ok, V})))).
+

quickcheck/aeso_utils_eqc.erl

@@ -0,0 +1,59 @@
+%%% File        : aeso_utils_eqc.erl
+%%% Author      : Ulf Norell
+%%% Description :
+%%% Created     : 2 Jul 2018 by Ulf Norell
+-module(aeso_utils_eqc).
+
+-compile([export_all, nowarn_export_all]).
+
+-include_lib("eqc/include/eqc.hrl").
+
+%% QuickCheck property
+
+graph() ->
+    ?LET(M, map(choose(0, 10), list(choose(0, 10))),
+    return(complete(M))).
+
+complete(G) ->
+    Is = lists:usort(lists:concat(maps:values(G))),
+    maps:merge(maps:from_list([ {I, []} || I <- Is ]), G).
+
+prop_scc() ->
+    ?FORALL(G, graph(),
+    begin
+        SCCs = aeso_utils:scc(G),
+        BadSCC = fun({acyclic, I}) -> reachable_from(G, I, I);
+                    ({cyclic, Is}) -> [] /= [ {I, J} || I <- Is, J <- Is, not reachable_from(G, I, J) ]
+                 end,
+        ToList = fun({acyclic, I}) -> [I];
+                    ({cyclic, Is}) -> Is end,
+        ?WHENFAIL(eqc:format("SCCs = ~p\n", [SCCs]),
+        conjunction(
+            [ {elems,  equals(lists:sort(lists:flatmap(ToList, SCCs)), lists:sort(maps:keys(G)))}
+            , {sorted, equals([], [ {I, J} || {I, Js} <- maps:to_list(G),
+                                              J <- Js,
+                                              find_component(I, SCCs) < find_component(J, SCCs) ])}
+            , {precise, equals([], [ SCC || SCC <- SCCs, BadSCC(SCC) ])}
+            ]))
+    end).
+
+reachable_from(Graph, I, J) ->
+    reachable_from1(Graph, maps:get(I, Graph, []), J).
+
+reachable_from1(_, [], _) -> false;
+reachable_from1(_, [I | _], I) -> true;
+reachable_from1(Graph, [I | Is], J) ->
+    case maps:get(I, Graph, undefined) of
+        undefined -> reachable_from1(Graph, Is, J);
+        Js        -> reachable_from1(maps:remove(I, Graph), Js ++ Is, J)
+    end.
+
+find_component(X, SCCs) ->
+    ISCCs = lists:zip(SCCs, lists:seq(1, length(SCCs))),
+    HasX  = fun({acyclic, Y}) -> X == Y;
+               ({cyclic, Ys}) -> lists:member(X, Ys) end,
+    case [ I || {SCC, I} <- ISCCs, HasX(SCC) ] of
+        [I | _] -> I;
+        []      -> false
+    end.
+

rebar.config

@@ -1,24 +1,34 @@
-%% -*- mode: erlang; indent-tabs-mode: nil -*-
-
 {erl_opts, [debug_info]}.
 
-{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git", {ref,"72b2a58"}}}
+{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git",
+                            {ref,"720510a"}}}
        , {getopt, "1.0.1"}
-       , {eblake2, "1.0.0"}
-       , {jsx, {git, "https://github.com/talentdeficit/jsx.git",
-                     {tag, "2.8.0"}}}
        ]}.
 
+
+{profiles, [ {eqc, [{erl_opts, [{parse_transform, eqc_cover}]},
+                    {deps, [{eqc_ci, "1.0.0"}]},
+                    {extra_src_dirs, ["quickcheck"]}    %% May not be called eqc!
+                   ]}
+           ]}.
+
+{escript_incl_apps, [aesophia, aebytecode, getopt]}.
+{escript_main_app, aesophia}.
+{escript_name, aesophia}.
+{escript_emu_args, "%%! +sbtu +A0\n"}.
+{provider_hooks, [{post, [{compile, escriptize}]}]}.
+
+{post_hooks, [{"(linux|darwin|solaris|freebsd|netbsd|openbsd)",
+               escriptize,
+               "cp \"$REBAR_BUILD_DIR/bin/aesophia\" ./aesophia"},
+              {"win32",
+               escriptize,
+               "robocopy \"%REBAR_BUILD_DIR%/bin/\" ./ aesophia* "
+               "/njs /njh /nfl /ndl & exit /b 0"} % silence things
+             ]}.
+
 {dialyzer, [
             {warnings, [unknown]},
             {plt_apps, all_deps},
             {base_plt_apps, [erts, kernel, stdlib, crypto, mnesia]}
            ]}.
-
-{relx, [{release, {aesophia, "4.0.0-rc1"},
-         [aesophia, aebytecode, getopt]},
-
-        {dev_mode, true},
-        {include_erts, false},
-
-        {extended_start_script, true}]}.

rebar.lock

@@ -1,28 +1,10 @@
 {"1.1.0",
 [{<<"aebytecode">>,
   {git,"https://github.com/aeternity/aebytecode.git",
-       {ref,"72b2a581d5a6d488a208331da88de1a488ac2da1"}},
+       {ref,"720510a24de32c9bad6486f34ca7babde124bf1e"}},
   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"}},
-  2},
- {<<"getopt">>,{pkg,<<"getopt">>,<<"1.0.1">>},0},
- {<<"jsx">>,
-  {git,"https://github.com/talentdeficit/jsx.git",
-       {ref,"3074d4865b3385a050badf7828ad31490d860df5"}},
-  0}]}.
+ {<<"getopt">>,{pkg,<<"getopt">>,<<"1.0.1">>},0}]}.
 [
 {pkg_hash,[
- {<<"eblake2">>, <<"EC8AD20E438AAB3F2E8D5D118C366A0754219195F8A0F536587440F8F9BCF2EF">>},
  {<<"getopt">>, <<"C73A9FA687B217F2FF79F68A3B637711BB1936E712B521D8CE466B29CBF7808A">>}]}
 ].

src/aeso_abi.erl

@@ -0,0 +1,239 @@
+%%%-------------------------------------------------------------------
+%%% @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      :: binary() %% binary typerep
+                              , OutType      :: binary() %% 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(binary(), type_info()) ->
+                        {'ok', typerep(), 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} = aeso_blake2:blake2b(?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(), 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

@@ -1,367 +0,0 @@
-%%%-------------------------------------------------------------------
-%%% @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
-        %% The compiler errors.
-        error:{parse_errors, Errors} ->
-            {error, join_errors("Parse errors", Errors, fun(E) -> E end)};
-        error:{type_errors, Errors} ->
-            {error, join_errors("Type errors", Errors, fun(E) -> E end)};
-        error:{code_errors, Errors} ->
-            {error, join_errors("Code errors", Errors,
-                                fun (E) -> io_lib:format("~p", [E]) end)}
-        %% General programming errors in the compiler just signal error.
-    end.
-
-join_errors(Prefix, Errors, Pfun) ->
-    Ess = [ Pfun(E) || E <- Errors ],
-    list_to_binary(string:join([Prefix|Ess], "\n")).
-
-encode_contract(Contract = {contract, _, {con, _, Name}, _}) ->
-    C0 = #{name => encode_name(Name)},
-
-    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,6 +17,7 @@ line({symbol, Line, _}) -> Line.
 symbol_name({symbol, _, Name}) -> Name.
 
 pp(Ast) ->
+    %% io:format("Tree:\n~p\n",[Ast]),
     String = prettypr:format(aeso_pretty:decls(Ast, [])),
     io:format("Ast:\n~s\n", [String]).
 

src/aeso_ast_to_icode.erl

@@ -17,27 +17,14 @@
 
 -spec convert_typed(aeso_syntax:ast(), list()) -> aeso_icode:icode().
 convert_typed(TypedTree, Options) ->
-    {Payable, Name} =
-        case lists:last(TypedTree) of
-            {contract, Attrs, {con, _, Con}, _} ->
-                {proplists:get_value(payable, Attrs, false), Con};
-            _ ->
-                gen_error(last_declaration_must_be_contract)
-           end,
-    NewIcode = aeso_icode:set_payable(Payable,
-                   aeso_icode:set_name(Name, aeso_icode:new(Options))),
-    Icode    = code(TypedTree, NewIcode, Options),
-    deadcode_elimination(Icode).
+    code(TypedTree, aeso_icode:new(Options)).
 
-code([{contract, _Attribs, Con, Code}|Rest], Icode, Options) ->
-    NewIcode = contract_to_icode(Code, aeso_icode:set_namespace(Con, Icode)),
-    code(Rest, NewIcode, Options);
-code([{namespace, _Ann, Name, Code}|Rest], Icode, Options) ->
-    %% TODO: nested namespaces
-    NewIcode = contract_to_icode(Code, aeso_icode:set_namespace(Name, Icode)),
-    code(Rest, NewIcode, Options);
-code([], Icode, Options) ->
-    add_default_init_function(add_builtins(Icode), Options).
+code([{contract, _Attribs, {con, _, Name}, Code}|Rest], Icode) ->
+    NewIcode = contract_to_icode(Code,
+                                 aeso_icode:set_name(Name, Icode)),
+    code(Rest, NewIcode);
+code([], Icode) ->
+    add_default_init_function(add_builtins(Icode)).
 
 %% Generate error on correct format.
 
@@ -45,41 +32,31 @@ gen_error(Error) ->
     error({code_errors, [Error]}).
 
 %% Create default init function (only if state is unit).
-add_default_init_function(Icode = #{functions := Funs, state_type := State}, Options) ->
-    NoCode        = proplists:get_value(no_code, Options, false),
-    {_, _, QInit} = aeso_icode:qualify({id, [], "init"}, Icode),
-    case lists:keymember(QInit, 1, Funs) of
+add_default_init_function(Icode = #{functions := Funs, state_type := State}) ->
+    case lists:keymember("init", 1, Funs) of
         true -> Icode;
-        false when NoCode -> Icode;
-        false when State /= {tuple, []} ->
-            gen_error(missing_init_function);
+        false when State /= {tuple, []} -> gen_error(missing_init_function);
         false ->
             Type  = {tuple, [typerep, {tuple, []}]},
             Value = #tuple{ cpts = [type_value({tuple, []}), {tuple, []}] },
-            DefaultInit = {QInit, [], [], Value, Type},
+            DefaultInit = {"init", [], [], Value, Type},
             Icode#{ functions => [DefaultInit | Funs] }
     end.
 
 -spec contract_to_icode(aeso_syntax:ast(), aeso_icode:icode()) ->
                                aeso_icode:icode().
-contract_to_icode([{namespace, _, Name, Defs} | Rest], Icode) ->
-    NS = aeso_icode:get_namespace(Icode),
-    Icode1 = contract_to_icode(Defs, aeso_icode:enter_namespace(Name, Icode)),
-    contract_to_icode(Rest, aeso_icode:set_namespace(NS, Icode1));
-contract_to_icode([{type_def, _Attrib, Id = {id, _, Name}, Args, Def} | Rest],
+contract_to_icode([{type_def, _Attrib, {id, _, Name}, Args, Def} | Rest],
                   Icode = #{ types := Types, constructors := Constructors }) ->
     TypeDef = make_type_def(Args, Def, Icode),
     NewConstructors =
         case Def of
             {variant_t, Cons} ->
                 Tags = lists:seq(0, length(Cons) - 1),
-                GetName = fun({constr_t, _, C, _}) -> C end,
-                QName = fun(Con) -> {_, _, Xs} = aeso_icode:qualify(GetName(Con), Icode), Xs end,
-                maps:from_list([ {QName(Con), Tag} || {Tag, Con} <- lists:zip(Tags, Cons) ]);
+                GetName = fun({constr_t, _, {con, _, C}, _}) -> C end,
+                maps:from_list([ {GetName(Con), Tag} || {Tag, Con} <- lists:zip(Tags, Cons) ]);
             _ -> #{}
         end,
-    {_, _, TName} = aeso_icode:qualify(Id, Icode),
-    Icode1 = Icode#{ types := Types#{ TName => TypeDef },
+    Icode1 = Icode#{ types := Types#{ Name => TypeDef },
                      constructors := maps:merge(Constructors, NewConstructors) },
     Icode2 = case Name of
                 "state" when Args == [] -> Icode1#{ state_type => ast_typerep(Def, Icode) };
@@ -91,10 +68,8 @@ contract_to_icode([{type_def, _Attrib, Id = {id, _, Name}, Args, Def} | Rest],
     contract_to_icode(Rest, Icode2);
 contract_to_icode([{letfun, Attrib, Name, Args, _What, Body={typed,_,_,T}}|Rest], Icode) ->
     FunAttrs = [ stateful || proplists:get_value(stateful, Attrib, false) ] ++
-               [ payable  || proplists:get_value(payable, Attrib, false) ] ++
-               [ private  || is_private(Attrib, Icode) ],
-    [ check_entrypoint_type(Attrib, Name, Args, T)
-      || aeso_syntax:get_ann(entrypoint, Attrib, false) ],
+               [ private  || proplists:get_value(private, Attrib, false) orelse
+                             proplists:get_value(internal, Attrib, false) ],
     %% TODO: Handle types
     FunName = ast_id(Name),
     %% TODO: push funname to env
@@ -107,23 +82,26 @@ contract_to_icode([{letfun, Attrib, Name, Args, _What, Body={typed,_,_,T}}|Rest]
                 #{ state_type := StateType } = Icode,
                 {#tuple{ cpts = [type_value(StateType), ast_body(Body, Icode)] },
                  {tuple, [typerep, ast_typerep(T, Icode)]}};
-            _ -> {ast_body(Body, Icode), ast_typerep1(T, Icode)}
+            _ -> {ast_body(Body, Icode), ast_typerep(T, Icode)}
         end,
-    QName    = aeso_icode:qualify(Name, Icode),
-    NewIcode = ast_fun_to_icode(ast_id(QName), FunAttrs, FunArgs, FunBody, TypeRep, Icode),
+    NewIcode = ast_fun_to_icode(FunName, FunAttrs, FunArgs, FunBody, TypeRep, Icode),
     contract_to_icode(Rest, NewIcode);
+contract_to_icode([{letrec,_,Defs}|Rest], Icode) ->
+    %% OBS! This code ignores the letrec structure of the source,
+    %% because the back end treats ALL declarations as recursive! We
+    %% need to decide whether to (a) modify the back end to respect
+    %% the letrec structure, or (b) (preferably) modify the front end
+    %% just to parse a list of (mutually recursive) definitions.
+    contract_to_icode(Defs++Rest, Icode);
 contract_to_icode([], Icode) -> Icode;
-contract_to_icode([{fun_decl, _, _, _} | Code], Icode) ->
-    contract_to_icode(Code, Icode);
-contract_to_icode([Decl | Code], Icode) ->
-    io:format("Unhandled declaration: ~p\n", [Decl]),
-    contract_to_icode(Code, Icode).
+contract_to_icode(_Code, Icode) ->
+    %% TODO debug output for debug("Unhandled code ~p~n",[Code]),
+    Icode.
 
-ast_id({id, _, Id}) -> Id;
-ast_id({qid, _, Id}) -> Id.
+ast_id({id, _, Id}) -> Id.
 
 ast_args([{arg, _, Name, Type}|Rest], Acc, Icode) ->
-    ast_args(Rest, [{ast_id(Name), ast_typerep1(Type, Icode)}| Acc], Icode);
+    ast_args(Rest, [{ast_id(Name), ast_type(Type, Icode)}| Acc], Icode);
 ast_args([], Acc, _Icode) -> lists:reverse(Acc).
 
 ast_type(T, Icode) ->
@@ -143,7 +121,7 @@ ast_type(T, Icode) ->
 ast_body(?qid_app(["Chain","spend"], [To, Amount], _, _), Icode) ->
     prim_call(?PRIM_CALL_SPEND, ast_body(Amount, Icode), [ast_body(To, Icode)], [word], {tuple, []});
 
-ast_body(?qid_app([Con, "Chain", "event"], [Event], _, _), Icode = #{ contract_name := Con }) ->
+ast_body(?qid_app(["Chain","event"], [Event], _, _), Icode) ->
     aeso_builtins:check_event_type(Icode),
     builtin_call({event, maps:get(event_type, Icode)}, [ast_body(Event, Icode)]);
 
@@ -151,11 +129,10 @@ ast_body(?qid_app([Con, "Chain", "event"], [Event], _, _), Icode = #{ contract_n
 ast_body(?qid_app(["Chain", "balance"], [Address], _, _), Icode) ->
     #prim_balance{ address = ast_body(Address, Icode) };
 ast_body(?qid_app(["Chain", "block_hash"], [Height], _, _), Icode) ->
-    builtin_call(block_hash, [ast_body(Height, Icode)]);
+    #prim_block_hash{ height = ast_body(Height, Icode) };
 ast_body(?qid_app(["Call", "gas_left"], [], _, _), _Icode) ->
     prim_gas_left;
 ast_body({qid, _, ["Contract", "address"]}, _Icode)      -> prim_contract_address;
-ast_body({qid, _, ["Contract", "creator"]}, _Icode)      -> prim_contract_creator;
 ast_body({qid, _, ["Contract", "balance"]}, _Icode)      -> #prim_balance{ address = prim_contract_address };
 ast_body({qid, _, ["Call",     "origin"]}, _Icode)       -> prim_call_origin;
 ast_body({qid, _, ["Call",     "caller"]}, _Icode)       -> prim_caller;
@@ -175,22 +152,16 @@ ast_body({qid, _, ["Chain", "spend"]}, _Icode) ->
     gen_error({underapplied_primitive, 'Chain.spend'});
 
 %% State
-ast_body({qid, _, [Con, "state"]}, #{ contract_name := Con }) -> prim_state;
-ast_body(?qid_app([Con, "put"], [NewState], _, _), Icode = #{ contract_name := Con }) ->
+ast_body({id, _, "state"}, _Icode) -> prim_state;
+ast_body(?id_app("put", [NewState], _, _), Icode) ->
     #prim_put{ state = ast_body(NewState, Icode) };
-ast_body({qid, _, [Con, "put"]}, #{ contract_name := Con }) ->
+ast_body({id, _, "put"}, _Icode) ->
     gen_error({underapplied_primitive, put});   %% TODO: eta
 
 %% Abort
 ast_body(?id_app("abort", [String], _, _), Icode) ->
-    builtin_call(abort, [ast_body(String, Icode)]);
-ast_body(?id_app("require", [Bool, String], _, _), Icode) ->
-    builtin_call(require, [ast_body(Bool, Icode), ast_body(String, Icode)]);
-
-%% Authentication
-ast_body({qid, _, ["Auth", "tx_hash"]}, _Icode) ->
-    prim_call(?PRIM_CALL_AUTH_TX_HASH, #integer{value = 0},
-              [], [], aeso_icode:option_typerep(word));
+    #funcall{ function = #var_ref{ name = {builtin, abort} },
+              args     = [ast_body(String, Icode)] };
 
 %% Oracles
 ast_body(?qid_app(["Oracle", "register"], Args, _, ?oracle_t(QType, RType)), Icode) ->
@@ -229,17 +200,6 @@ ast_body(?qid_app(["Oracle", "get_answer"], [Oracle, Q], [_, ?query_t(_, RType)]
     prim_call(?PRIM_CALL_ORACLE_GET_ANSWER, #integer{value = 0},
               [ast_body(Oracle, Icode), ast_body(Q, Icode)], [word, word], aeso_icode:option_typerep(ast_type(RType, Icode)));
 
-ast_body(?qid_app(["Oracle", "check"], [Oracle], [?oracle_t(Q, R)], _), Icode) ->
-    prim_call(?PRIM_CALL_ORACLE_CHECK, #integer{value = 0},
-              [ast_body(Oracle, Icode), ast_type_value(Q, Icode), ast_type_value(R, Icode)],
-              [word, typerep, typerep], word);
-
-ast_body(?qid_app(["Oracle", "check_query"], [Oracle, Query], [_, ?query_t(Q, R)], _), Icode) ->
-    prim_call(?PRIM_CALL_ORACLE_CHECK_QUERY, #integer{value = 0},
-              [ast_body(Oracle, Icode), ast_body(Query, Icode),
-               ast_type_value(Q, Icode), ast_type_value(R, Icode)],
-              [word, typerep, typerep], word);
-
 ast_body({qid, _, ["Oracle", "register"]}, _Icode)     -> gen_error({underapplied_primitive, 'Oracle.register'});
 ast_body({qid, _, ["Oracle", "query"]}, _Icode)        -> gen_error({underapplied_primitive, 'Oracle.query'});
 ast_body({qid, _, ["Oracle", "extend"]}, _Icode)       -> gen_error({underapplied_primitive, 'Oracle.extend'});
@@ -270,21 +230,21 @@ ast_body(?qid_app(["AENS", "preclaim"], Args, _, _), Icode) ->
               [word, word, sign_t()], {tuple, []});
 
 ast_body(?qid_app(["AENS", "claim"], Args, _, _), Icode) ->
-    {Sign, [Addr, Name, Salt, NameFee]} = get_signature_arg(Args),
+    {Sign, [Addr, Name, Salt]} = get_signature_arg(Args),
     prim_call(?PRIM_CALL_AENS_CLAIM, #integer{value = 0},
-              [ast_body(Addr, Icode), ast_body(Name, Icode), ast_body(Salt, Icode), ast_body(NameFee, Icode), ast_body(Sign, Icode)],
-              [word, string, word, word, sign_t()], {tuple, []});
+              [ast_body(Addr, Icode), ast_body(Name, Icode), ast_body(Salt, Icode), ast_body(Sign, Icode)],
+              [word, string, word, sign_t()], {tuple, []});
 
 ast_body(?qid_app(["AENS", "transfer"], Args, _, _), Icode) ->
-    {Sign, [FromAddr, ToAddr, Name]} = get_signature_arg(Args),
+    {Sign, [FromAddr, ToAddr, NameHash]} = get_signature_arg(Args),
     prim_call(?PRIM_CALL_AENS_TRANSFER, #integer{value = 0},
-              [ast_body(FromAddr, Icode), ast_body(ToAddr, Icode), ast_body(Name, Icode), ast_body(Sign, Icode)],
+              [ast_body(FromAddr, Icode), ast_body(ToAddr, Icode), ast_body(NameHash, Icode), ast_body(Sign, Icode)],
               [word, word, word, sign_t()], {tuple, []});
 
 ast_body(?qid_app(["AENS", "revoke"], Args, _, _), Icode) ->
-    {Sign, [Addr, Name]} = get_signature_arg(Args),
+    {Sign, [Addr, NameHash]} = get_signature_arg(Args),
     prim_call(?PRIM_CALL_AENS_REVOKE, #integer{value = 0},
-              [ast_body(Addr, Icode), ast_body(Name, Icode), ast_body(Sign, Icode)],
+              [ast_body(Addr, Icode), ast_body(NameHash, Icode), ast_body(Sign, Icode)],
               [word, word, sign_t()], {tuple, []});
 
 ast_body({qid, _, ["AENS", "resolve"]}, _Icode)  -> gen_error({underapplied_primitive, 'AENS.resolve'});
@@ -357,26 +317,11 @@ ast_body({map, Ann, Map, [Upd | Upds]}, Icode) ->
     ast_body({map, Ann, {map, Ann, Map, [Upd]}, Upds}, Icode);
 
 %% Crypto
-ast_body(?qid_app(["Crypto", "verify_sig"], [Msg, PK, Sig], _, _), Icode) ->
-    prim_call(?PRIM_CALL_CRYPTO_VERIFY_SIG, #integer{value = 0},
+ast_body(?qid_app(["Crypto", "ecverify"], [Msg, PK, Sig], _, _), Icode) ->
+    prim_call(?PRIM_CALL_CRYPTO_ECVERIFY, #integer{value = 0},
               [ast_body(Msg, Icode), ast_body(PK, Icode), ast_body(Sig, Icode)],
               [word, word, sign_t()], word);
 
-ast_body(?qid_app(["Crypto", "verify_sig_secp256k1"], [Msg, PK, Sig], _, _), Icode) ->
-    prim_call(?PRIM_CALL_CRYPTO_VERIFY_SIG_SECP256K1, #integer{value = 0},
-              [ast_body(Msg, Icode), ast_body(PK, Icode), ast_body(Sig, Icode)],
-              [bytes_t(32), bytes_t(64), bytes_t(64)], word);
-
-ast_body(?qid_app(["Crypto", "ecverify_secp256k1"], [Msg, Addr, Sig], _, _), Icode) ->
-    prim_call(?PRIM_CALL_CRYPTO_ECVERIFY_SECP256K1, #integer{value = 0},
-              [ast_body(Msg, Icode), ast_body(Addr, Icode), ast_body(Sig, Icode)],
-              [word, bytes_t(20), bytes_t(65)], word);
-
-ast_body(?qid_app(["Crypto", "ecrecover_secp256k1"], [Msg, Sig], _, _), Icode) ->
-    prim_call(?PRIM_CALL_CRYPTO_ECRECOVER_SECP256K1, #integer{value = 0},
-              [ast_body(Msg, Icode), ast_body(Sig, Icode)],
-              [word, bytes_t(65)], aeso_icode:option_typerep(bytes_t(20)));
-
 ast_body(?qid_app(["Crypto", "sha3"], [Term], [Type], _), Icode) ->
     generic_hash_primop(?PRIM_CALL_CRYPTO_SHA3, Term, Type, Icode);
 ast_body(?qid_app(["Crypto", "sha256"], [Term], [Type], _), Icode) ->
@@ -391,11 +336,13 @@ ast_body(?qid_app(["String", "blake2b"], [String], _, _), Icode) ->
 %% Strings
 %% -- String length
 ast_body(?qid_app(["String", "length"], [String], _, _), Icode) ->
-    builtin_call(string_length, [ast_body(String, Icode)]);
+    #funcall{ function = #var_ref{ name = {builtin, string_length} },
+              args     = [ast_body(String, Icode)] };
 
 %% -- String concat
 ast_body(?qid_app(["String", "concat"], [String1, String2], _, _), Icode) ->
-    builtin_call(string_concat, [ast_body(String1, Icode), ast_body(String2, Icode)]);
+    #funcall{ function = #var_ref{ name = {builtin, string_concat} },
+              args     = [ast_body(String1, Icode), ast_body(String2, Icode)] };
 
 %% -- String hash (sha3)
 ast_body(?qid_app(["String", "sha3"], [String], _, _), Icode) ->
@@ -434,46 +381,26 @@ ast_body(?qid_app(["Int", "to_str"], [Int], _, _), Icode) ->
 
 ast_body(?qid_app(["Address", "to_str"], [Addr], _, _), Icode) ->
     builtin_call(addr_to_str, [ast_body(Addr, Icode)]);
-ast_body(?qid_app(["Address", "is_oracle"], [Addr], _, _), Icode) ->
-    prim_call(?PRIM_CALL_ADDR_IS_ORACLE, #integer{value = 0},
-              [ast_body(Addr, Icode)], [word], word);
-ast_body(?qid_app(["Address", "is_contract"], [Addr], _, _), Icode) ->
-    prim_call(?PRIM_CALL_ADDR_IS_CONTRACT, #integer{value = 0},
-              [ast_body(Addr, Icode)], [word], word);
-ast_body(?qid_app(["Address", "is_payable"], [Addr], _, _), Icode) ->
-    prim_call(?PRIM_CALL_ADDR_IS_PAYABLE, #integer{value = 0},
-              [ast_body(Addr, Icode)], [word], word);
-
-ast_body(?qid_app(["Bytes", "to_int"], [Bytes], _, _), Icode) ->
-    {typed, _, _, {bytes_t, _, N}} = Bytes,
-    builtin_call({bytes_to_int, N}, [ast_body(Bytes, Icode)]);
-ast_body(?qid_app(["Bytes", "to_str"], [Bytes], _, _), Icode) ->
-    {typed, _, _, {bytes_t, _, N}} = Bytes,
-    builtin_call({bytes_to_str, N}, [ast_body(Bytes, Icode)]);
 
 %% Other terms
 ast_body({id, _, Name}, _Icode) ->
-    #var_ref{name = Name};
-ast_body({qid, _, Name}, _Icode) ->
+    %% TODO Look up id in env
     #var_ref{name = Name};
 ast_body({bool, _, Bool}, _Icode) ->        %BOOL as ints
     Value = if Bool -> 1 ; true -> 0 end,
     #integer{value = Value};
 ast_body({int, _, Value}, _Icode) ->
     #integer{value = Value};
-ast_body({bytes, _, Bin}, _Icode) ->
-    case aeb_memory:binary_to_words(Bin) of
-        [Word] -> #integer{value = Word};
-        Words  -> #tuple{cpts = [#integer{value = W} || W <- Words]}
+ast_body({hash, _, Hash}, _Icode) ->
+    case Hash of
+        <<Value:32/unit:8>> ->              %% address
+            #integer{value = Value};
+        <<Hi:32/unit:8, Lo:32/unit:8>> ->   %% signature
+            #tuple{cpts = [#integer{value = Hi},
+                           #integer{value = Lo}]}
     end;
-ast_body({Key, _, Bin}, _Icode) when Key == account_pubkey;
-                                     Key == contract_pubkey;
-                                     Key == oracle_pubkey;
-                                     Key == oracle_query_id ->
-    <<Value:32/unit:8>> = Bin,
-    #integer{value = Value};
 ast_body({string,_,Bin}, _Icode) ->
-    Cpts = [size(Bin) | aeb_memory:binary_to_words(Bin)],
+    Cpts = [size(Bin) | aeso_memory:binary_to_words(Bin)],
     #tuple{cpts = [#integer{value=X} || X <- Cpts]};
 ast_body({tuple,_,Args}, Icode) ->
     #tuple{cpts = [ast_body(A, Icode) || A <- Args]};
@@ -497,7 +424,7 @@ ast_body({app, _, {typed, _, {proj, _, {typed, _, Addr, {con, _, Contract}}, {id
     Gas    = proplists:get_value("gas",   ArgOpts ++ Defaults),
     Value  = proplists:get_value("value", ArgOpts ++ Defaults),
     OutType = ast_typerep(OutT, Icode),
-    <<TypeHash:256>> = aeb_aevm_abi:function_type_hash(list_to_binary(FunName), ArgType, OutType),
+    <<TypeHash:256>> = aeso_abi:function_type_hash(list_to_binary(FunName), ArgType, OutType),
     %% The function is represented by its type hash (which includes the name)
     Fun    = #integer{value = TypeHash},
     #prim_call_contract{
@@ -514,21 +441,11 @@ ast_body({proj, _, {typed, _, _, {con, _, Contract}}, {id, _, FunName}}, _Icode)
                string:join([Contract, FunName], ".")});
 
 ast_body({con, _, Name}, Icode) ->
-    Tag = aeso_icode:get_constructor_tag([Name], Icode),
-    #tuple{cpts = [#integer{value = Tag}]};
-ast_body({qcon, _, Name}, Icode) ->
     Tag = aeso_icode:get_constructor_tag(Name, Icode),
     #tuple{cpts = [#integer{value = Tag}]};
 ast_body({app, _, {typed, _, {con, _, Name}, _}, Args}, Icode) ->
-    Tag = aeso_icode:get_constructor_tag([Name], Icode),
-    #tuple{cpts = [#integer{value = Tag} | [ ast_body(Arg, Icode) || Arg <- Args ]]};
-ast_body({app, _, {typed, _, {qcon, _, Name}, _}, Args}, Icode) ->
     Tag = aeso_icode:get_constructor_tag(Name, Icode),
     #tuple{cpts = [#integer{value = Tag} | [ ast_body(Arg, Icode) || Arg <- Args ]]};
-ast_body({app, _, {'..', _}, [A, B]}, Icode) ->
-    #funcall
-    { function = #var_ref{ name = ["ListInternal", "from_to"] }
-    , args     = [ast_body(A, Icode), ast_body(B, Icode)] };
 ast_body({app,As,Fun,Args}, Icode) ->
     case aeso_syntax:get_ann(format, As) of
         infix  ->
@@ -543,24 +460,6 @@ ast_body({app,As,Fun,Args}, Icode) ->
             #funcall{function=ast_body(Fun, Icode),
                      args=[ast_body(A, Icode) || A <- Args]}
     end;
-ast_body({list_comp, _, Yield, []}, Icode) ->
-    #list{elems = [ast_body(Yield, Icode)]};
-ast_body({list_comp, As, Yield, [{comprehension_bind, {typed, Arg, ArgType}, BindExpr}|Rest]}, Icode) ->
-    #funcall
-        { function = #var_ref{ name = ["ListInternal", "flat_map"] }
-        , args =
-              [ #lambda{ args=[#arg{name = ast_id(Arg), type = ast_type(ArgType, Icode)}]
-                       , body = ast_body({list_comp, As, Yield, Rest}, Icode)
-                       }
-              , ast_body(BindExpr, Icode)
-              ]
-        };
-ast_body({list_comp, As, Yield, [{comprehension_if, AsIF, Cond}|Rest]}, Icode) ->
-    ast_body({'if', AsIF, Cond, {list_comp, As, Yield, Rest}, {list, As, []}}, Icode);
-ast_body({list_comp, As, Yield, [LV = {letval, _, _, _, _}|Rest]}, Icode) ->
-    ast_body({block, As, [LV, {list_comp, As, Yield, Rest}]}, Icode);
-ast_body({list_comp, As, Yield, [LF = {letfun, _, _, _, _, _}|Rest]}, Icode) ->
-    ast_body({block, As, [LF, {list_comp, As, Yield, Rest}]}, Icode);
 ast_body({'if',_,Dec,Then,Else}, Icode) ->
     #ifte{decision = ast_body(Dec, Icode)
          ,then     = ast_body(Then, Icode)
@@ -574,8 +473,6 @@ ast_body({switch,_,A,Cases}, Icode) ->
 ast_body({block,As,[{letval,_,Pat,_,E}|Rest]}, Icode) ->
     #switch{expr=ast_body(E, Icode),
             cases=[{ast_body(Pat, Icode),ast_body({block,As,Rest}, Icode)}]};
-ast_body({block, As, [{letfun, Ann, F, Args, _Type, Expr} | Rest]}, Icode) ->
-    ast_body({block, As, [{letval, Ann, F, unused, {lam, Ann, Args, Expr}} | Rest]}, Icode);
 ast_body({block,_,[]}, _Icode) ->
     #tuple{cpts=[]};
 ast_body({block,_,[E]}, Icode) ->
@@ -584,7 +481,7 @@ ast_body({block,As,[E|Rest]}, Icode) ->
     #switch{expr=ast_body(E, Icode),
             cases=[{#var_ref{name="_"},ast_body({block,As,Rest}, Icode)}]};
 ast_body({lam,_,Args,Body}, Icode) ->
-    #lambda{args=[#arg{name = ast_id(P), type = ast_typerep1(T, Icode)} || {arg,_,P,T} <- Args],
+    #lambda{args=[#arg{name = ast_id(P), type = ast_type(T, Icode)} || {arg,_,P,T} <- Args],
             body=ast_body(Body, Icode)};
 ast_body({typed,_,{record,Attrs,Fields},{record_t,DefFields}}, Icode) ->
     %% Compile as a tuple with the fields in the order they appear in the definition.
@@ -643,30 +540,19 @@ ast_binop(Op, Ann, {typed, _, A, Type}, B, Icode)
         _ when not Monomorphic ->
             gen_error({cant_compare_polymorphic_type, Ann, Op, Type});
         word   -> #binop{op = Op, left = ast_body(A, Icode), right = ast_body(B, Icode)};
-        OtherType ->
+        string ->
             Neg = case Op of
                     '==' -> fun(X) -> X end;
                     '!=' -> fun(X) -> #unop{ op = '!', rand = X } end;
                     _    -> gen_error({cant_compare, Ann, Op, Type})
                   end,
-            Args = [ast_body(A, Icode), ast_body(B, Icode)],
-            Builtin =
-                case OtherType of
-                    string ->
-                        builtin_call(str_equal, Args);
-                    {tuple, Types} ->
-                        case lists:usort(Types) of
-                            [word] ->
-                                builtin_call(str_equal_p, [ #integer{value = 32 * length(Types)} | Args]);
-                            _ -> gen_error({cant_compare, Ann, Op, Type})
-                        end;
-                    _ ->
-                        gen_error({cant_compare, Ann, Op, Type})
-                end,
-            Neg(Builtin)
+            Neg(#funcall{ function = #var_ref{name = {builtin, str_equal}},
+                          args     = [ast_body(A, Icode), ast_body(B, Icode)] });
+        _ -> gen_error({cant_compare, Ann, Op, Type})
     end;
 ast_binop('++', _, A, B, Icode) ->
-    builtin_call(list_concat, [ast_body(A, Icode), ast_body(B, Icode)]);
+    #funcall{ function = #var_ref{ name = {builtin, list_concat} },
+              args     = [ast_body(A, Icode), ast_body(B, Icode)] };
 ast_binop(Op, _, A, B, Icode) ->
     #binop{op = Op, left = ast_body(A, Icode), right = ast_body(B, Icode)}.
 
@@ -719,22 +605,6 @@ map_upd(Key, Default, ValFun, Map = {typed, Ann, _, MapType}, Icode) ->
     Args    = [ast_body(Map, Icode), ast_body(Key, Icode), ast_body(Default, Icode), ast_body(ValFun, Icode)],
     builtin_call(FunName, Args).
 
-check_entrypoint_type(Ann, Name, Args, Ret) ->
-    Check = fun(T, Err) ->
-                case is_simple_type(T) of
-                    false -> gen_error(Err);
-                    true  -> ok
-                end end,
-    [ Check(T, {entrypoint_argument_must_have_simple_type, Ann1, Name, X, T})
-      || {arg, Ann1, X, T} <- Args ],
-    Check(Ret, {entrypoint_must_have_simple_return_type, Ann, Name, Ret}).
-
-is_simple_type({tvar, _, _})        -> false;
-is_simple_type({fun_t, _, _, _, _}) -> false;
-is_simple_type(Ts) when is_list(Ts) -> lists:all(fun is_simple_type/1, Ts);
-is_simple_type(T) when is_tuple(T)  -> is_simple_type(tuple_to_list(T));
-is_simple_type(_)                   -> true.
-
 is_monomorphic({tvar, _, _}) -> false;
 is_monomorphic([H|T]) ->
   is_monomorphic(H) andalso is_monomorphic(T);
@@ -749,7 +619,7 @@ prim_call(Prim, Amount, Args, ArgTypes, OutType) ->
             true ->
                 PrimBin = binary:encode_unsigned(Prim),
                 ArgType = {tuple, ArgTypes},
-                <<TH:256>> = aeb_aevm_abi:function_type_hash(PrimBin, ArgType, OutType),
+                <<TH:256>> = aeso_abi:function_type_hash(PrimBin, ArgType, OutType),
                 TH;
             false ->
                 0
@@ -775,57 +645,47 @@ make_type_def(Args, Def, Icode = #{ type_vars := TypeEnv }) ->
     TVars = [ X || {tvar, _, X} <- Args ],
     fun(Types) ->
         TypeEnv1 = maps:from_list(lists:zip(TVars, Types)),
-        ast_typerep1(Def, Icode#{ type_vars := maps:merge(TypeEnv, TypeEnv1) })
+        ast_typerep(Def, Icode#{ type_vars := maps:merge(TypeEnv, TypeEnv1) })
     end.
 
--spec ast_typerep(aeso_syntax:type()) -> aeb_aevm_data:type().
-ast_typerep(Type) ->
-    ast_typerep(Type, aeso_icode:new([])).
+-spec ast_typerep(aeso_syntax:type()) -> aeso_sophia:type().
+ast_typerep(Type) -> ast_typerep(Type, aeso_icode:new([])).
 
-ast_typerep(Type, Icode) ->
-    case is_simple_type(Type) of
-        false -> gen_error({not_a_simple_type, Type});
-        true  -> ast_typerep1(Type, Icode)
-    end.
-
-ast_typerep1({id, _, Name}, Icode) ->
+ast_typerep({id, _, Name}, Icode) ->
     lookup_type_id(Name, [], Icode);
-ast_typerep1({qid, _, Name}, Icode) ->
+ast_typerep({qid, _, Name}, Icode) ->
     lookup_type_id(Name, [], Icode);
-ast_typerep1({con, _, _}, _) ->
+ast_typerep({con, _, _}, _) ->
     word;   %% Contract type
-ast_typerep1({bytes_t, _, Len}, _) ->
-    bytes_t(Len);
-ast_typerep1({app_t, _, {I, _, Name}, Args}, Icode) when I =:= id; I =:= qid ->
-    ArgReps = [ ast_typerep1(Arg, Icode) || Arg <- Args ],
+ast_typerep({app_t, _, {id, _, Name}, Args}, Icode) ->
+    ArgReps = [ ast_typerep(Arg, Icode) || Arg <- Args ],
     lookup_type_id(Name, ArgReps, Icode);
-ast_typerep1({tvar,_,A}, #{ type_vars := TypeVars }) ->
+ast_typerep({tvar,_,A}, #{ type_vars := TypeVars }) ->
     case maps:get(A, TypeVars, undefined) of
         undefined -> word; %% We serialize type variables just as addresses in the originating VM.
         Type      -> Type
     end;
-ast_typerep1({tuple_t,_,Cpts}, Icode) ->
-    {tuple, [ast_typerep1(C, Icode) || C<-Cpts]};
-ast_typerep1({record_t,Fields}, Icode) ->
+ast_typerep({tuple_t,_,Cpts}, Icode) ->
+    {tuple, [ast_typerep(C, Icode) || C<-Cpts]};
+ast_typerep({record_t,Fields}, Icode) ->
     {tuple, [ begin
                 {field_t, _, _, T} = Field,
-                ast_typerep1(T, Icode)
+                ast_typerep(T, Icode)
               end || Field <- Fields]};
-ast_typerep1({fun_t,_,_,_,_}, _Icode) ->
+ast_typerep({fun_t,_,_,_,_}, _Icode) ->
     function;
-ast_typerep1({alias_t, T}, Icode) -> ast_typerep1(T, Icode);
-ast_typerep1({variant_t, Cons}, Icode) ->
+ast_typerep({alias_t, T}, Icode) -> ast_typerep(T, Icode);
+ast_typerep({variant_t, Cons}, Icode) ->
     {variant, [ begin
                   {constr_t, _, _, Args} = Con,
-                  [ ast_typerep1(Arg, Icode) || Arg <- Args ]
+                  [ ast_typerep(Arg, Icode) || Arg <- Args ]
                 end || Con <- Cons ]}.
 
 ttl_t(Icode) ->
     ast_typerep({qid, [], ["Chain", "ttl"]}, Icode).
 
-sign_t() -> bytes_t(64).
-bytes_t(Len) when Len =< 32 -> word;
-bytes_t(Len)                -> {tuple, lists:duplicate((31 + Len) div 32, word)}.
+sign_t() ->
+    {tuple, [word, word]}.
 
 get_signature_arg(Args0) ->
     NamedArgs = [Arg || Arg = {named_arg, _, _, _} <- Args0],
@@ -866,6 +726,13 @@ type_value({map, K, V}) ->
     #tuple{ cpts = [#integer{ value = ?TYPEREP_MAP_TAG },
                     type_value(K), type_value(V)] }.
 
+%% As abort is a built-in in the future it will be illegal to for
+%% users to define abort. For the time being strip away all user
+%% defined abort functions.
+
+ast_fun_to_icode("abort", _Atts, _Args, _Body, _TypeRep, Icode) ->
+    %% Strip away all user defined abort functions.
+    Icode;
 ast_fun_to_icode(Name, Attrs, Args, Body, TypeRep, #{functions := Funs} = Icode) ->
     NewFuns = [{Name, Attrs, Args, Body, TypeRep}| Funs],
     aeso_icode:set_functions(NewFuns, Icode).
@@ -878,13 +745,6 @@ has_maps({list, T})     -> has_maps(T);
 has_maps({tuple, Ts})   -> lists:any(fun has_maps/1, Ts);
 has_maps({variant, Cs}) -> lists:any(fun has_maps/1, lists:append(Cs)).
 
-%% A function is private if not an 'entrypoint', or if it's not defined in the
-%% main contract name space. (NOTE: changes when we introduce inheritance).
-is_private(Ann, #{ contract_name := MainContract } = Icode) ->
-    {_, _, CurrentNamespace} = aeso_icode:get_namespace(Icode),
-    not proplists:get_value(entrypoint, Ann, false) orelse
-    MainContract /= CurrentNamespace.
-
 %% -------------------------------------------------------------------
 %% Builtins
 %% -------------------------------------------------------------------
@@ -896,39 +756,3 @@ builtin_call(Builtin, Args) ->
 add_builtins(Icode = #{functions := Funs}) ->
     Builtins = aeso_builtins:used_builtins(Funs),
     Icode#{functions := [ aeso_builtins:builtin_function(B) || B <- Builtins ] ++ Funs}.
-
-
-%% -------------------------------------------------------------------
-%% Deadcode elimination
-%% -------------------------------------------------------------------
-
-deadcode_elimination(Icode = #{ functions := Funs }) ->
-    PublicNames = [ Name || {Name, Ann, _, _, _} <- Funs, not lists:member(private, Ann) ],
-    ArgsToPat   = fun(Args) -> [ #var_ref{ name = X } || {X, _} <- Args ] end,
-    Defs        = maps:from_list([ {Name, {binder, ArgsToPat(Args), Body}} || {Name, _, Args, Body, _} <- Funs ]),
-    UsedNames   = chase_names(Defs, PublicNames, #{}),
-    UsedFuns    = [ Def || Def = {Name, _, _, _, _} <- Funs, maps:is_key(Name, UsedNames) ],
-    Icode#{ functions := UsedFuns }.
-
-chase_names(_Defs, [], Used) -> Used;
-chase_names(Defs, [X | Xs], Used) ->
-                              %% can happen when compiling __call contracts
-    case maps:is_key(X, Used) orelse not maps:is_key(X, Defs) of
-        true  -> chase_names(Defs, Xs, Used); %% already chased
-        false ->
-            Def  = maps:get(X, Defs),
-            Vars = maps:keys(free_vars(Def)),
-            chase_names(Defs, Vars ++ Xs, Used#{ X => true })
-    end.
-
-free_vars(#var_ref{ name = X }) -> #{ X => true };
-free_vars(#arg{ name = X }) -> #{ X => true };
-free_vars({binder, Pat, Body}) ->
-    maps:without(maps:keys(free_vars(Pat)), free_vars(Body));
-free_vars(#switch{ expr = E, cases = Cases }) ->
-    free_vars([E | [{binder, P, B} || {P, B} <- Cases]]);
-free_vars(#lambda{ args = Xs, body = E }) ->
-    free_vars({binder, Xs, E});
-free_vars(T) when is_tuple(T) -> free_vars(tuple_to_list(T));
-free_vars([H | T]) -> maps:merge(free_vars(H), free_vars(T));
-free_vars(_) -> #{}.

src/aeso_blake2.erl

@@ -0,0 +1,149 @@
+%%%=============================================================================
+%%% @copyright (C) 2019, Aeternity Anstalt
+%%% @doc
+%%%  BLAKE2b implementation in Erlang - for details see: https://blake2.net
+%%% @end
+%%%=============================================================================
+
+-module(aeso_blake2).
+
+-export([ blake2b/2
+        , blake2b/3
+        ]).
+
+-define(MAX_64BIT, 16#ffffffffffffffff).
+
+-spec blake2b(HashLen :: integer(), Msg :: binary()) -> {ok, binary()}.
+blake2b(HashLen, Msg) ->
+    blake2b(HashLen, Msg, <<>>).
+
+-spec blake2b(HashLen :: integer(), Msg :: binary(), Key :: binary()) -> {ok, binary()}.
+blake2b(HashLen, Msg0, Key) ->
+    %% If message should be keyed, prepend message with padded key.
+    Msg = <<(pad(128, Key))/binary, Msg0/binary>>,
+
+    %% Set up the initial state
+    Init  = (16#01010000 + (byte_size(Key) bsl 8) + HashLen),
+    <<H0:64, H1_7/binary>> = blake_iv(),
+    H = <<(H0 bxor Init):64, H1_7/binary>>,
+
+    %% Perform the compression - message will be chopped into 128-byte chunks.
+    State = blake2b_compress(H, Msg, 0),
+
+    %% Just return the requested part of the hash
+    {ok, binary_part(to_little_endian(State), {0, HashLen})}.
+
+blake2b_compress(H, <<Chunk:(128*8), Rest/binary>>, BCompr) when Rest /= <<>> ->
+    H1 = blake2b_compress(H, <<Chunk:(128*8)>>, BCompr + 128, false),
+    blake2b_compress(H1, Rest, BCompr + 128);
+blake2b_compress(H, SmallChunk, BCompr) ->
+    Size    = byte_size(SmallChunk),
+    FillSize = (128 - Size) * 8,
+    blake2b_compress(H, <<SmallChunk/binary, 0:FillSize>>, BCompr + Size, true).
+
+blake2b_compress(H, Chunk0, BCompr, Last) ->
+    Chunk = to_big_endian(Chunk0),
+    <<V0_11:(12*64), V12:64, V13:64, V14:64, V15:64>> = <<H/binary, (blake_iv())/binary>>,
+    V12_ = V12 bxor (BCompr band ?MAX_64BIT),
+    V13_ = V13 bxor ((BCompr bsr 64) band ?MAX_64BIT),
+    V14_ = case Last of
+               false -> V14;
+               true  -> V14 bxor ?MAX_64BIT
+           end,
+    V = <<V0_11:(12*64), V12_:64, V13_:64, V14_:64, V15:64>>,
+
+    <<VLow:(8*64), VHigh:(8*64)>> =
+        lists:foldl(fun(Round, Vx) -> blake2b_mix(Round, Chunk, Vx) end, V, lists:seq(0, 11)),
+
+  <<HInt:(8*64)>> = H,
+  <<((HInt bxor VLow) bxor VHigh):(8*64)>>.
+
+blake2b_mix(Rnd, Chunk, V) ->
+    <<V0:64, V1:64, V2:64, V3:64, V4:64, V5:64, V6:64, V7:64, V8:64,
+      V9:64, V10:64, V11:64, V12:64, V13:64, V14:64, V15:64>> = V,
+    <<M0:64, M1:64, M2:64, M3:64, M4:64, M5:64, M6:64, M7:64, M8:64,
+      M9:64, M10:64, M11:64, M12:64, M13:64, M14:64, M15:64>> = Chunk,
+    Ms = {M0, M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15},
+    M = fun(Ix) -> element(Ix+1, Ms) end,
+
+    [S0, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15] = sigma(Rnd rem 10),
+
+    {Vx0, Vx4, Vx8,  Vx12} = blake2b_mix(V0, V4, V8,  V12, M(S0), M(S1)),
+    {Vx1, Vx5, Vx9,  Vx13} = blake2b_mix(V1, V5, V9,  V13, M(S2), M(S3)),
+    {Vx2, Vx6, Vx10, Vx14} = blake2b_mix(V2, V6, V10, V14, M(S4), M(S5)),
+    {Vx3, Vx7, Vx11, Vx15} = blake2b_mix(V3, V7, V11, V15, M(S6), M(S7)),
+
+    {Vy0, Vy5, Vy10, Vy15} = blake2b_mix(Vx0, Vx5, Vx10, Vx15, M(S8),  M(S9)),
+    {Vy1, Vy6, Vy11, Vy12} = blake2b_mix(Vx1, Vx6, Vx11, Vx12, M(S10), M(S11)),
+    {Vy2, Vy7, Vy8,  Vy13} = blake2b_mix(Vx2, Vx7, Vx8,  Vx13, M(S12), M(S13)),
+    {Vy3, Vy4, Vy9,  Vy14} = blake2b_mix(Vx3, Vx4, Vx9,  Vx14, M(S14), M(S15)),
+
+    <<Vy0:64, Vy1:64, Vy2:64, Vy3:64, Vy4:64, Vy5:64, Vy6:64, Vy7:64, Vy8:64,
+      Vy9:64, Vy10:64, Vy11:64, Vy12:64, Vy13:64, Vy14:64, Vy15:64>>.
+
+blake2b_mix(Va, Vb, Vc, Vd, X, Y) ->
+    Va1 = (Va + Vb + X) band ?MAX_64BIT,
+    Vd1 = rotr64(32, Vd bxor Va1),
+
+    Vc1 = (Vc + Vd1) band ?MAX_64BIT,
+    Vb1 = rotr64(24, Vb bxor Vc1),
+
+    Va2 = (Va1 + Vb1 + Y) band ?MAX_64BIT,
+    Vd2 = rotr64(16, Va2 bxor Vd1),
+
+    Vc2 = (Vc1 + Vd2) band ?MAX_64BIT,
+    Vb2 = rotr64(63, Vb1 bxor Vc2),
+
+    {Va2, Vb2, Vc2, Vd2}.
+
+blake_iv() ->
+    IV0 = 16#6A09E667F3BCC908,
+    IV1 = 16#BB67AE8584CAA73B,
+    IV2 = 16#3C6EF372FE94F82B,
+    IV3 = 16#A54FF53A5F1D36F1,
+    IV4 = 16#510E527FADE682D1,
+    IV5 = 16#9B05688C2B3E6C1F,
+    IV6 = 16#1F83D9ABFB41BD6B,
+    IV7 = 16#5BE0CD19137E2179,
+    <<IV0:64, IV1:64, IV2:64, IV3:64, IV4:64, IV5:64, IV6:64, IV7:64>>.
+
+sigma(N) ->
+    {_, Row} = lists:keyfind(N, 1, sigma()), Row.
+
+sigma() ->
+    [{0, [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15]},
+     {1, [14, 10,  4,  8,  9, 15, 13,  6,  1, 12,  0,  2, 11,  7,  5,  3]},
+     {2, [11,  8, 12,  0,  5,  2, 15, 13, 10, 14,  3,  6,  7,  1,  9,  4]},
+     {3, [ 7,  9,  3,  1, 13, 12, 11, 14,  2,  6,  5, 10,  4,  0, 15,  8]},
+     {4, [ 9,  0,  5,  7,  2,  4, 10, 15, 14,  1, 11, 12,  6,  8,  3, 13]},
+     {5, [ 2, 12,  6, 10,  0, 11,  8,  3,  4, 13,  7,  5, 15, 14,  1,  9]},
+     {6, [12,  5,  1, 15, 14, 13,  4, 10,  0,  7,  6,  3,  9,  2,  8, 11]},
+     {7, [13, 11,  7, 14, 12,  1,  3,  9,  5,  0, 15,  4,  8,  6,  2, 10]},
+     {8, [ 6, 15, 14,  9, 11,  3,  0,  8, 12,  2, 13,  7,  1,  4, 10,  5]},
+     {9, [10,  2,  8,  4,  7,  6,  1,  5, 15, 11,  9, 14,  3, 12, 13,  0]}].
+
+rotr64(N, I64) ->
+    <<I64rot:64>> = rotr641(N, <<I64:64>>),
+    I64rot.
+
+rotr641(16, <<X:(64-16), Y:16>>) -> <<Y:16, X:(64-16)>>;
+rotr641(24, <<X:(64-24), Y:24>>) -> <<Y:24, X:(64-24)>>;
+rotr641(32, <<X:(64-32), Y:32>>) -> <<Y:32, X:(64-32)>>;
+rotr641(63, <<X:(64-63), Y:63>>) -> <<Y:63, X:(64-63)>>.
+
+pad(N, Bin) ->
+    case (N - (byte_size(Bin) rem N)) rem N of
+        0   -> Bin;
+        Pad -> <<Bin/binary, 0:(Pad *8)>>
+    end.
+
+to_big_endian(Bin) -> to_big_endian(Bin, <<>>).
+to_big_endian(<<>>, Acc) -> Acc;
+to_big_endian(<<UInt64:1/little-unsigned-integer-unit:64, Rest/binary>>, Acc) ->
+  to_big_endian(Rest, <<Acc/binary, UInt64:1/big-unsigned-integer-unit:64>>).
+
+to_little_endian(Bin) -> to_little_endian(Bin, <<>>).
+to_little_endian(<<>>, Acc) -> Acc;
+to_little_endian(<<UInt64:1/big-unsigned-integer-unit:64, Rest/binary>>, Acc) ->
+  to_little_endian(Rest, <<Acc/binary, UInt64:1/little-unsigned-integer-unit:64>>).
+

src/aeso_builtins.erl

@@ -44,9 +44,7 @@ builtin_deps1(addr_to_str)                -> [{baseX_int, 58}];
 builtin_deps1({baseX_int, X})             -> [{baseX_int_pad, X}];
 builtin_deps1({baseX_int_pad, X})         -> [{baseX_int_encode, X}];
 builtin_deps1({baseX_int_encode, X})      -> [{baseX_int_encode_, X}, {baseX_tab, X}, {baseX_digits, X}];
-builtin_deps1({bytes_to_str, _})          -> [bytes_to_str_worker];
 builtin_deps1(string_reverse)             -> [string_reverse_];
-builtin_deps1(require)                    -> [abort];
 builtin_deps1(_)                          -> [].
 
 dep_closure(Deps) ->
@@ -62,14 +60,12 @@ 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, operand(Ptr), [{{tuple, [v(Var)]}, Body}]}).
+-define(DEREF(Var, Ptr, Body), {switch, v(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)).
@@ -95,6 +91,12 @@ 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,23 +106,21 @@ check_event_type(Icode) ->
     end.
 
 check_event_type(Evts, Icode) ->
-    [ check_event_type(Name, Ix, T, Icode)
-      || {constr_t, Ann, {con, _, Name}, Types} <- Evts,
-         {Ix, T} <- lists:zip(aeso_syntax:get_ann(indices, Ann), Types) ].
+    [ check_event_type(Name, T, Icode)
+      || {constr_t, _, {con, _, Name}, Types} <- Evts, T <- Types ].
 
-check_event_type(EvtName, Ix, Type, Icode) ->
+check_event_type(EvtName, Type, Icode) ->
     VMType =
         try
            aeso_ast_to_icode:ast_typerep(Type, Icode)
         catch _:_ ->
             error({EvtName, could_not_resolve_type, Type})
         end,
-    case {Ix, VMType, Type} of
-        {indexed, word, _}      -> ok;
-        {notindexed, string, _} -> ok;
-        {notindexed, _, {bytes_t, _, N}} when N > 32 -> ok;
-        {indexed, _, _}         -> error({EvtName, indexed_field_should_be_word, is, VMType});
-        {notindexed, _, _}      -> error({EvtName, payload_should_be_string, is, VMType})
+    case aeso_syntax:get_ann(indexed, Type, false) of
+        true when VMType == word    -> ok;
+        false when VMType == string -> ok;
+        true  -> error({EvtName, indexed_field_should_be_word, is, VMType});
+        false -> error({EvtName, payload_should_be_string, is, VMType})
     end.
 
 bfun(B, {IArgs, IExpr, IRet}) ->
@@ -130,8 +130,6 @@ 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());
@@ -159,9 +157,6 @@ builtin_function(BF) ->
         {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_to_str_worker        -> bfun(BF, builtin_bytes_to_str_worker());
         string_reverse             -> bfun(BF, builtin_string_reverse());
         string_reverse_            -> bfun(BF, builtin_string_reverse_())
     end.
@@ -174,24 +169,18 @@ 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]};
-           ([{{id, _, "string"}, V}]) ->
-                {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)}]}
+        fun([]) ->  {inline_asm, [A(?PUSH1), 0, A(?PUSH1), 0]};
+           ([V]) -> {seq, [V, {inline_asm, [A(?DUP1), A(?MLOAD),                  %% length, ptr
+                                            A(?SWAP1), A(?PUSH1), 32, A(?ADD)]}]} %% ptr+32, length
         end,
-    Ix =
-        fun({bytes_t, _, N}, V) when N < 32 -> ?BSR(V, 32 - N);
-           (_, V) -> V end,
     Clause =
-        fun(_Tag, {con, _, Con}, IxTypes) ->
-            Types     = [ T || {_Ix, T} <- IxTypes ],
-            Indexed   = [ Ix(Type, Var) || {Var, {indexed, Type}} <- lists:zip(ArgPats(Types), IxTypes) ],
-            Data      = [ {Type, Var} || {Var, {notindexed, Type}} <- lists:zip(ArgPats(Types), IxTypes) ],
-            {ok, <<EvtIndexN:256>>} = eblake2:blake2b(?HASH_BYTES, list_to_binary(Con)),
-            EvtIndex  = {integer, EvtIndexN},
-            {event, lists:reverse(Indexed) ++ [EvtIndex], Payload(Data)}
+        fun(_Tag, {con, _, Con}, Types) ->
+            Indexed   = [ Var || {Var, Type} <- lists:zip(ArgPats(Types), Types),
+                                 IsIndexed(Type) ],
+            EvtIndex  = {unop, 'sha3', str_to_icode(Con)},
+            {event, lists:reverse(Indexed) ++ [EvtIndex], Payload(ArgPats(Types) -- Indexed)}
         end,
     Pat = fun(Tag, Types) -> {tuple, [{integer, Tag} | ArgPats(Types)]} end,
 
@@ -200,8 +189,8 @@ builtin_event(EventT) ->
 
     {[{"e", event}],
      {switch, v(e),
-         [{Pat(Tag, Types), Clause(Tag, Con, lists:zip(aeso_syntax:get_ann(indices, Ann), Types))}
-          || {Tag, {constr_t, Ann, Con, Types}} <- lists:zip(Tags, Cons) ]},
+         [{Pat(Tag, Types), Clause(Tag, Con, Types)}
+          || {Tag, {constr_t, _, Con, Types}} <- lists:zip(Tags, Cons) ]},
      {tuple, []}}.
 
 %% Abort primitive.
@@ -212,17 +201,6 @@ builtin_abort() ->
                    A(?REVERT)]}, %% Stack: 0,Ptr
      {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_map_lookup(Type) ->
     Ret = aeso_icode:option_typerep(Type),
@@ -459,10 +437,6 @@ builtin_baseX_int_pad(X = 10) ->
         ?call({baseX_int_encode, X}, [?NEG(src), ?I(1), ?BSL($-, 31)]),
         ?call({baseX_int_encode, X}, [?V(src), ?V(ix), ?V(dst)])},
      word};
-builtin_baseX_int_pad(X = 16) ->
-    {[{"src", word}, {"ix", word}, {"dst", 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),
@@ -497,57 +471,6 @@ builtin_baseX_digits(X) ->
         {ifte, ?EQ(x1, 0), ?V(dgts), ?call({baseX_digits, X}, [?V(x1), ?ADD(dgts, 1)])}),
      word}.
 
-builtin_bytes_to_int(32) ->
-    {[{"w", word}], ?V(w), word};
-builtin_bytes_to_int(N) when N < 32 ->
-    {[{"w", word}], ?BSR(w, 32 - N), word};
-builtin_bytes_to_int(N) when N > 32 ->
-    LastFullWord = N div 32 - 1,
-    Body = case N rem 32 of
-                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_bytes_to_str_worker() ->
-    <<Tab:256>> = <<"0123456789ABCDEF________________">>,
-    {[{"w", word}, {"offs", word}, {"acc", word}],
-     {seq, [{ifte, ?AND(?GT(offs, 0), ?EQ(0, ?MOD(offs, 16))),
-                    {seq, [?V(acc), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]}]},
-                    {inline_asm, []}},
-            {ifte, ?EQ(offs, 32), {inline_asm, [?A(?MSIZE)]},
-                ?LET(b,  ?BYTE(offs, w),
-                ?LET(lo, ?BYTE(?MOD(b, 16), Tab),
-                ?LET(hi, ?BYTE(op('bsr', 4 , b), Tab),
-                ?call(bytes_to_str_worker,
-                      [?V(w), ?ADD(offs, 1), ?ADD(?BSL(acc, 2), ?ADD(?BSL(hi, 1), lo))]))))
-            }
-           ]},
-     word}.
-
-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)]},
-            ?call(bytes_to_str_worker, [?V(w), ?I(0), ?I(0)]),
-            {inline_asm, [?A(?POP)]},
-            ?V(ret)]}),
-     string};
-builtin_bytes_to_str(N) when N > 32 ->
-    Work = fun(I) ->
-            [?DEREF(w, ?ADD(p, 32 * I), ?call(bytes_to_str_worker, [?V(w), ?I(0), ?I(0)])),
-             {inline_asm, [?A(?POP)]}]
-           end,
-    {[{"p", pointer}],
-     ?LET(ret, {inline_asm, [?A(?MSIZE)]},
-     {seq, [?I(N * 2), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]}] ++
-           lists:append([ Work(I) || I <- lists:seq(0, (N + 31) div 32 - 1) ]) ++
-           [?V(ret)]}),
-     string}.
-
 builtin_string_reverse() ->
     {[{"s", string}],
      ?DEREF(n, s,

src/aeso_compiler.erl

@@ -11,92 +11,70 @@
 -export([ file/1
         , file/2
         , from_string/2
-        , check_call/4
-        , create_calldata/3  %% deprecated
-        , create_calldata/4
+        , check_call/2
+        , create_calldata/3
         , 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_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 option() :: pp_sophia_code | pp_ast | pp_types | pp_typed_ast |
+                  pp_icode| pp_assembler | pp_bytecode.
 -type options() :: [option()].
 
 -export_type([ option/0
              , options/0
              ]).
 
--spec version() -> {ok, binary()} | {error, term()}.
+-define(COMPILER_VERSION_1, 1).
+-define(COMPILER_VERSION_2, 2).
+
+-define(COMPILER_VERSION, ?COMPILER_VERSION_2).
+
+-spec version() -> pos_integer().
 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.
+    ?COMPILER_VERSION.
 
 -spec file(string()) -> {ok, map()} | {error, binary()}.
 file(Filename) ->
     file(Filename, []).
 
 -spec file(string(), options()) -> {ok, map()} | {error, binary()}.
-file(File, Options0) ->
-    Options = add_include_path(File, Options0),
+file(File, Options) ->
     case read_contract(File) of
-        {ok, Bin} -> from_string(Bin, [{src_file, File} | Options]);
+        {ok, Bin} -> from_string(Bin, Options);
         {error, Error} ->
 	    ErrorString = [File,": ",file:format_error(Error)],
 	    {error, join_errors("File errors", [ErrorString], fun(E) -> E end)}
     end.
 
-add_include_path(File, Options) ->
-    case lists:keymember(include, 1, Options) of
-        true  -> Options;
-        false ->
-            Dir = filename:dirname(File),
-            {ok, Cwd} = file:get_cwd(),
-            [{include, {file_system, [Cwd, Dir]}} | Options]
-    end.
-
 -spec from_string(binary() | string(), options()) -> {ok, map()} | {error, binary()}.
-from_string(Contract, Options) ->
-    from_string(proplists:get_value(backend, Options, aevm), Contract, Options).
-
-from_string(Backend, ContractBin, Options) when is_binary(ContractBin) ->
-    from_string(Backend, binary_to_list(ContractBin), Options);
-from_string(Backend, ContractString, Options) ->
+from_string(ContractBin, Options) when is_binary(ContractBin) ->
+    from_string(binary_to_list(ContractBin), Options);
+from_string(ContractString, Options) ->
     try
-        from_string1(Backend, ContractString, Options)
+        Ast = parse(ContractString, Options),
+        ok = pp_sophia_code(Ast, Options),
+        ok = pp_ast(Ast, Options),
+        TypedAst = aeso_ast_infer_types:infer(Ast, Options),
+        %% pp_types is handled inside aeso_ast_infer_types.
+        ok = pp_typed_ast(TypedAst, Options),
+        ICode = to_icode(TypedAst, Options),
+        TypeInfo = extract_type_info(ICode),
+        ok = pp_icode(ICode, Options),
+        Assembler =  assemble(ICode, Options),
+        ok = pp_assembler(Assembler, Options),
+        ByteCodeList = to_bytecode(Assembler, Options),
+        ByteCode = << << B:8 >> || B <- ByteCodeList >>,
+        ok = pp_bytecode(ByteCode, Options),
+        {ok, #{byte_code => ByteCode,
+               compiler_version => version(),
+               contract_source => ContractString,
+               type_info => TypeInfo
+              }}
     catch
         %% The compiler errors.
         error:{parse_errors, Errors} ->
@@ -109,126 +87,38 @@ from_string(Backend, ContractString, Options) ->
         %% General programming errors in the compiler just signal error.
     end.
 
-from_string1(aevm, ContractString, Options) ->
-    #{icode := Icode} = string_to_code(ContractString, Options),
-    TypeInfo  = extract_type_info(Icode),
-    Assembler = assemble(Icode, Options),
-    pp_assembler(Assembler, Options),
-    ByteCodeList = to_bytecode(Assembler, Options),
-    ByteCode = << << B:8 >> || B <- ByteCodeList >>,
-    pp_bytecode(ByteCode, Options),
-    {ok, Version} = version(),
-    {ok, #{byte_code => ByteCode,
-           compiler_version => Version,
-           contract_source => ContractString,
-           type_info => TypeInfo,
-           abi_version => aeb_aevm_abi:abi_version(),
-           payable => maps:get(payable, Icode)
-          }};
-from_string1(fate, ContractString, Options) ->
-    #{fcode := FCode} = string_to_code(ContractString, Options),
-    FateCode = aeso_fcode_to_fate:compile(FCode, 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)
-          }}.
-
--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]),
-    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.
-
 join_errors(Prefix, Errors, Pfun) ->
     Ess = [ Pfun(E) || E <- Errors ],
     list_to_binary(string:join([Prefix|Ess], "\n")).
 
--define(CALL_NAME,   "__call").
--define(DECODE_NAME, "__decode").
+-define(CALL_NAME, "__call").
 
 %% Takes a string containing a contract with a declaration/prototype of a
-%% function (foo, say) and adds function __call() = foo(args) calling this
+%% function (foo, say) and a function __call() = foo(args) calling this
 %% function. Returns the name of the called functions, typereps and Erlang
 %% terms for the arguments.
-%% 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, term()}
+-spec check_call(string(), options()) -> {ok, string(), {[Type], Type | any}, [term()]} | {error, term()}
     when Type :: term().
-check_call(Source, "init" = FunName, Args, Options) ->
-    case check_call1(Source, FunName, Args, Options) of
-        Err = {error, _} when Args == [] ->
-            %% Try with default init-function
-            case check_call1(insert_init_function(Source, Options), FunName, Args, Options) of
-                {error, _} -> Err; %% The first error is most likely better...
-                Res        -> Res
-            end;
-        Res ->
-            Res
-    end;
-check_call(Source, FunName, Args, Options) ->
-    check_call1(Source, FunName, Args, Options).
-
-check_call1(ContractString0, FunName, Args, Options) ->
+check_call(ContractString, Options) ->
     try
-        case proplists:get_value(backend, Options, aevm) of
-            aevm ->
-                %% First check the contract without the __call function
-                #{} = string_to_code(ContractString0, Options),
-                ContractString = insert_call_function(ContractString0, ?CALL_NAME, FunName, Args, Options),
-                #{typed_ast := TypedAst,
-                  icode     := Icode} = string_to_code(ContractString, Options),
-                {ok, {FunName, {fun_t, _, _, ArgTypes, RetType}}} = get_call_type(TypedAst),
-                ArgVMTypes = [ aeso_ast_to_icode:ast_typerep(T, Icode) || T <- ArgTypes ],
-                RetVMType  = case RetType of
-                                 {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
+        Ast = parse(ContractString, Options),
+        ok = pp_sophia_code(Ast, Options),
+        ok = pp_ast(Ast, Options),
+        TypedAst = aeso_ast_infer_types:infer(Ast, [permissive_address_literals]),
+        {ok, {FunName, {fun_t, _, _, ArgTypes, RetType}}} = get_call_type(TypedAst),
+        ok = pp_typed_ast(TypedAst, Options),
+        Icode = to_icode(TypedAst, Options),
+        ArgVMTypes = [ aeso_ast_to_icode:ast_typerep(T, Icode) || T <- ArgTypes ],
+        RetVMType  = case RetType of
+                         {id, _, "_"} -> any;
+                         _            -> aeso_ast_to_icode:ast_typerep(RetType, Icode)
+                     end,
+        ok = pp_icode(Icode, Options),
+        #{ functions := Funs } = Icode,
+        ArgIcode = get_arg_icode(Funs),
+        ArgTerms = [ icode_to_term(T, Arg) ||
+                       {T, Arg} <- lists:zip(ArgVMTypes, ArgIcode) ],
+        {ok, FunName, {ArgVMTypes, RetVMType}, ArgTerms}
     catch
         error:{parse_errors, Errors} ->
             {error, join_errors("Parse errors", Errors, fun (E) -> E end)};
@@ -242,232 +132,44 @@ check_call1(ContractString0, FunName, Args, Options) ->
                                 fun (E) -> io_lib:format("~p", [E]) end)}
     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, term()}.
-to_sophia_value(ContractString, Fun, ResType, Data) ->
-    to_sophia_value(ContractString, Fun, ResType, Data, [{backend, aevm}]).
-
--spec to_sophia_value(string(), string(), ok | error | revert, binary(), options()) ->
-        {ok, aeso_syntax:expr()} | {error, term()}.
-to_sophia_value(_, _, error, Err, _Options) ->
-    {ok, {app, [], {id, [], "error"}, [{string, [], Err}]}};
-to_sophia_value(_, _, revert, Data, Options) ->
-    case proplists:get_value(backend, Options, aevm) of
-        aevm ->
-            case aeb_heap:from_binary(string, Data) of
-                {ok, Err} -> {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}};
-                {error, _} = Err -> Err
-            end;
-        fate ->
-            Err = aeb_fate_encoding:deserialize(Data),
-            {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}}
+-spec create_calldata(map(), string(), string()) ->
+                             {ok, binary(), 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;
-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)),
-                            {error, join_errors("Translation error", [lists:flatten(io_lib:format("Cannot translate VM value ~p\n  of type ~p\n  to Sophia type ~s\n",
-                                                                                    [Data, VmType, Type0Str]))],
-                                                fun (E) -> E end)}
-                        end;
-                    {error, _Err} ->
-                        {error, join_errors("Decode errors", [lists:flatten(io_lib:format("Failed to decode binary at type ~p", [VmType]))],
-                                            fun(E) -> E end)}
-                end;
-            fate ->
-               try
-                   {ok, aeso_vm_decode:from_fate(Type, aeb_fate_encoding:deserialize(Data))}
-               catch throw:cannot_translate_to_sophia ->
-                   {error, join_errors("Translation error",
-                                       [lists:flatten(io_lib:format("Cannot translate fate value ~p\n of Sophia type ~s\n",
-                                                                    [aeb_fate_encoding:deserialize(Data), Type]))],
-                                       fun (E) -> E end)};
-                     _:R ->
-                   {error, iolist_to_binary(io_lib:format("Decode error ~p: ~p\n", [R, erlang:get_stacktrace()]))}
-               end
-        end
-    catch
-        error:{parse_errors, Errors} ->
-            {error, join_errors("Parse errors", Errors, fun (E) -> E end)};
-        error:{type_errors, Errors} ->
-            {error, join_errors("Type errors", Errors, fun (E) -> E end)};
-        error:{badmatch, {error, missing_function}} ->
-            {error, join_errors("Type errors", ["no function: '" ++ FunName ++ "'"],
-                                fun (E) -> E end)};
-        throw:Error ->                          %Don't ask
-            {error, join_errors("Code errors", [Error],
-                                fun (E) -> io_lib:format("~p", [E]) end)}
+create_calldata(Contract, Function, Argument) when is_map(Contract) ->
+    %% Slightly hacky shortcut to let you get away without writing the full
+    %% call contract code.
+    %% Function should be "foo : type", and
+    %% Argument should be "Arg1, Arg2, .., ArgN" (no parens)
+    case string:lexemes(Function, ": ") of
+        %% If function is a single word fallback to old calldata generation
+        [FunName] -> aeso_abi:old_create_calldata(Contract, FunName, Argument);
+        [FunName | _] ->
+            Args    = lists:map(fun($\n) -> 32; (X) -> X end, Argument),    %% newline to space
+            CallContract = lists:flatten(
+                [ "contract Call =\n"
+                , "  function ", Function, "\n"
+                , "  function __call() = ", FunName, "(", Args, ")"
+                ]),
+            create_calldata(Contract, "", CallContract)
     end.
 
 
--spec create_calldata(string(), string(), [string()]) ->
-                             {ok, binary(), aeb_aevm_data:type(), aeb_aevm_data:type()}
-                             | {error, term()}.
-create_calldata(Code, Fun, Args) ->
-    create_calldata(Code, Fun, Args, [{backend, aevm}]).
-
--spec create_calldata(string(), string(), [string()], [{atom(), any()}]) ->
-                             {ok, binary()}
-                             | {error, term()}.
-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, term()}.
-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)),
-                                {error, join_errors("Translation error",
-                                                    [lists:flatten(io_lib:format("Cannot translate VM value ~p\n  of type ~p\n  to Sophia type ~s\n",
-                                                                                 [VmValue, VmType, Type0Str]))],
-                                                    fun (E) -> E end)}
-                        end;
-                    {error, _Err} ->
-                        {error, join_errors("Decode errors", [lists:flatten(io_lib:format("Failed to decode binary at type ~p", [VmType]))],
-                                            fun(E) -> E end)}
-                end;
-            fate ->
-                case aeb_fate_abi:decode_calldata(FunName, Calldata) of
-                    {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)),
-                                {error, join_errors("Translation error",
-                                                    [lists:flatten(io_lib:format("Cannot translate fate value ~p\n of Sophia type ~s\n",
-                                                                                 [FateArgs, Type0Str]))],
-                                                    fun (E) -> E end)}
-                        end;
-                    {error, _} ->
-                        {error, join_errors("Decode errors", ["Failed to decode binary"],
-                                            fun(E) -> E end)}
-                end
-        end
-    catch
-        error:{parse_errors, Errors} ->
-            {error, join_errors("Parse errors", Errors, fun (E) -> E end)};
-        error:{type_errors, Errors} ->
-            {error, join_errors("Type errors", Errors, fun (E) -> E end)};
-        error:{badmatch, {error, missing_function}} ->
-            {error, join_errors("Type errors", ["no function: '" ++ FunName ++ "'"],
-                                fun (E) -> E end)};
-        throw:Error ->                          %Don't ask
-            {error, join_errors("Code errors", [Error],
-                                fun (E) -> io_lib:format("~p", [E]) end)}
-    end.
-
 get_arg_icode(Funs) ->
-    case [ Args || {[_, ?CALL_NAME], _, _, {funcall, _, Args}, _} <- Funs ] of
-        [Args] -> Args;
-        []     -> error({missing_call_function, Funs})
-    end.
+    [Args] = [ Args || {?CALL_NAME, _, _, {funcall, _, Args}, _} <- Funs ],
+    Args.
 
 get_call_type([{contract, _, _, Defs}]) ->
-    case [ {lists:last(QFunName), FunType}
+    case [ {FunName, FunType}
           || {letfun, _, {id, _, ?CALL_NAME}, [], _Ret,
                 {typed, _,
                     {app, _,
-                        {typed, _, {qid, _, QFunName}, FunType}, _}, _}} <- Defs ] of
+                        {typed, _, {id, _, FunName}, FunType}, _}, _}} <- Defs ] of
         [Call] -> {ok, Call};
         []     -> {error, missing_call_function}
     end;
@@ -475,26 +177,9 @@ get_call_type([_ | Contracts]) ->
     %% The __call should be in the final contract
     get_call_type(Contracts).
 
-get_decode_type(FunName, [{contract, _, _, Defs}]) ->
-    GetType = fun({letfun, _, {id, _, Name}, Args, Ret, _})               when Name == FunName -> [{Args, Ret}];
-                 ({fun_decl, _, {id, _, Name}, {fun_t, _, _, Args, Ret}}) when Name == FunName -> [{Args, Ret}];
-                 (_) -> [] end,
-    case lists:flatmap(GetType, Defs) of
-        [{Args, Ret}] -> {ok, Args, Ret};
-        []            ->
-            case FunName of
-                "init" -> {ok, [], {tuple_t, [], []}};
-                 _ -> {error, missing_function}
-            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 aeb_heap:to_binary().
+%% consumed by aeso_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;
@@ -526,7 +211,10 @@ icode_to_term(T, V) ->
 icodes_to_terms(Ts, Vs) ->
     [ icode_to_term(T, V) || {T, V} <- lists:zip(Ts, Vs) ].
 
-ast_to_icode(TypedAst, Options) ->
+parse(C,_Options) ->
+    parse_string(C).
+
+to_icode(TypedAst, Options) ->
     aeso_ast_to_icode:convert_typed(TypedAst, Options).
 
 assemble(Icode, Options) ->
@@ -540,10 +228,7 @@ to_bytecode([Op|Rest], Options) ->
 to_bytecode([], _) -> [].
 
 extract_type_info(#{functions := Functions} =_Icode) ->
-    ArgTypesOnly = fun(As) -> [ T || {_, T} <- As ] end,
-    Payable = fun(Attrs) -> proplists:get_value(payable, Attrs, false) end,
-    TypeInfo = [aeb_aevm_abi:function_type_info(list_to_binary(lists:last(Name)),
-                                            Payable(Attrs), ArgTypesOnly(Args), TypeRep)
+    TypeInfo = [aeso_abi:function_type_info(list_to_binary(Name), Args, TypeRep)
                 || {Name, Attrs, Args,_Body, TypeRep} <- Functions,
                    not is_tuple(Name),
                    not lists:member(private, Attrs)
@@ -567,7 +252,9 @@ pp(Code, Options, Option, PPFun) ->
             ok
     end.
 
+
 %% -------------------------------------------------------------------
+%% TODO: Tempoary parser hook below...
 
 sophia_type_to_typerep(String) ->
     {ok, Ast} = aeso_parser:type(String),
@@ -576,14 +263,9 @@ sophia_type_to_typerep(String) ->
     catch _:_ -> {error, bad_type}
     end.
 
--spec parse(string(), aeso_compiler:options()) -> none() | aeso_syntax:ast().
-parse(Text, Options) ->
-    parse(Text, sets:new(), Options).
-
--spec parse(string(), sets:set(), aeso_compiler:options()) -> none() | aeso_syntax:ast().
-parse(Text, Included, Options) ->
+parse_string(Text) ->
     %% Try and return something sensible here!
-    case aeso_parser:string(Text, Included, Options) of
+    case aeso_parser:string(Text) of
         %% Yay, it worked!
         {ok, Contract} -> Contract;
         %% Scan errors.
@@ -596,23 +278,12 @@ parse(Text, Included, Options) ->
             parse_error(Pos, Error);
         {error, {Pos, ambiguous_parse, As}} ->
             ErrorString = io_lib:format("Ambiguous ~p", [As]),
-            parse_error(Pos, ErrorString);
-        %% Include error
-        {error, {Pos, include_error, File}} ->
-            parse_error(Pos, io_lib:format("could not find include file '~s'", [File]))
+            parse_error(Pos, ErrorString)
     end.
 
--spec parse_error(aeso_parse_lib:pos(), string()) -> none().
-parse_error(Pos, ErrorString) ->
-    Error = io_lib:format("~s: ~s", [pos_error(Pos), ErrorString]),
+parse_error({Line, Pos}, ErrorString) ->
+    Error = io_lib:format("line ~p, column ~p: ~s", [Line, Pos, ErrorString]),
     error({parse_errors, [Error]}).
 
 read_contract(Name) ->
     file:read_file(Name).
-
-pos_error({Line, Pos}) ->
-    io_lib:format("line ~p, column ~p", [Line, Pos]);
-pos_error({no_file, Line, Pos}) ->
-    pos_error({Line, Pos});
-pos_error({File, Line, Pos}) ->
-    io_lib:format("file ~s, line ~p, column ~p", [File, Line, Pos]).

src/aeso_heap.erl

@@ -0,0 +1,301 @@
+-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,31 +9,19 @@
 %%%-------------------------------------------------------------------
 -module(aeso_icode).
 
--export([new/1,
-         pp/1,
-         set_name/2,
-         set_namespace/2,
-         set_payable/2,
-         enter_namespace/2,
-         get_namespace/1,
-         qualify/2,
-         set_functions/2,
-         map_typerep/2,
-         option_typerep/1,
-         get_constructor_tag/2]).
-
+-export([new/1, pp/1, set_name/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(([aeb_aevm_data:type()]) -> aeb_aevm_data:type()).
+-type type_def() :: fun(([aeso_sophia:type()]) -> aeso_sophia:type()).
 
 -type bindings() :: any().
 -type fun_dec() :: { string()
                    , [modifier()]
                    , arg_list()
                    , expr()
-                   , aeb_aevm_data:type()}.
+                   , aeso_sophia:type()}.
 
 -type modifier() :: private | stateful.
 
@@ -41,15 +29,13 @@
 
 -type icode() :: #{ contract_name => string()
                   , functions => [fun_dec()]
-                  , namespace => aeso_syntax:con() | aeso_syntax:qcon()
                   , env => [bindings()]
-                  , state_type => aeb_aevm_data:type()
-                  , event_type => aeb_aevm_data:type()
+                  , state_type => aeso_sophia:type()
+                  , event_type => aeso_sophia:type()
                   , types => #{ type_name() => type_def() }
-                  , type_vars => #{ string() => aeb_aevm_data:type() }
-                  , constructors => #{ [string()] => integer() }  %% name to tag
+                  , type_vars => #{ string() => aeso_sophia:type() }
+                  , constructors => #{ string() => integer() }  %% name to tag
                   , options => [any()]
-                  , payable => boolean()
                   }.
 
 pp(Icode) ->
@@ -67,8 +53,7 @@ new(Options) ->
      , types => builtin_types()
      , type_vars => #{}
      , constructors => builtin_constructors()
-     , options => Options
-     , payable => false }.
+     , options => Options}.
 
 builtin_types() ->
     Word = fun([]) -> word end,
@@ -78,7 +63,6 @@ builtin_types() ->
      , "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
@@ -89,10 +73,10 @@ builtin_types() ->
      }.
 
 builtin_constructors() ->
-    #{ ["RelativeTTL"] => 0
-     , ["FixedTTL"]    => 1
-     , ["None"]        => 0
-     , ["Some"]        => 1 }.
+    #{ "RelativeTTL" => 0
+     , "FixedTTL"    => 1
+     , "None"        => 0
+     , "Some"        => 1 }.
 
 map_typerep(K, V) ->
     {map, K, V}.
@@ -107,34 +91,11 @@ 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 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,5 +1,14 @@
 
--include_lib("aebytecode/include/aeb_typerep_def.hrl").
+-define(Type(), aeso_sophia:type()).
+
+-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()}).
 
@@ -11,7 +20,7 @@
                  , args :: arg_list()
                  , body :: expr()}).
 
--record(var_ref, { name :: string() | list(string()) | {builtin, atom() | tuple()}}).
+-record(var_ref, { name :: 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, _, _, _, _}) -> lists:last(FName) /= "init".
+is_stateful({FName, _, _, _, _}) -> FName /= "init".
 
 is_public({_Name, Attrs, _Args, _Body, _Type}) -> not lists:member(private, Attrs).
 
@@ -105,7 +105,7 @@ make_args(Args) ->
 
 fun_hash({FName, _, Args, _, TypeRep}) ->
     ArgType = {tuple, [T || {_, T} <- Args]},
-    <<Hash:256>> = aeb_aevm_abi:function_type_hash(list_to_binary(lists:last(FName)), ArgType, TypeRep),
+    <<Hash:256>> = aeso_abi:function_type_hash(list_to_binary(FName), ArgType, TypeRep),
     {integer, Hash}.
 
 %% Expects two return addresses below N elements on the stack. Picks the top
@@ -343,8 +343,6 @@ 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) ->

src/aeso_memory.erl

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

@@ -19,7 +19,7 @@
 
 -export_type([parser/1, parser_expr/1, pos/0, token/0, tokens/0]).
 
--type pos()    :: {string() | no_file, integer(), integer()} | {integer(), integer()}.
+-type pos()    :: {integer(), integer()}.
 -type token()  :: {atom(), pos(), term()} | {atom(), pos()}.
 -type tokens() :: [token()].
 -type error()  :: {pos(), string() | no_error}.

src/aeso_parser.erl

@@ -5,48 +5,28 @@
 -module(aeso_parser).
 
 -export([string/1,
-         string/2,
-         string/3,
-         hash_include/2,
          type/1]).
 
 -include("aeso_parse_lib.hrl").
 
--type parse_result() :: {ok, aeso_syntax:ast()}
-                      | {error, {aeso_parse_lib:pos(), atom(), term()}}
-                      | {error, {aeso_parse_lib:pos(), atom()}}.
-
--type include_hash() :: {string(), binary()}.
-
--spec string(string()) -> parse_result().
+-spec string(string()) ->
+                    {ok, aeso_syntax:ast()}
+                        | {error, {aeso_parse_lib:pos(),
+                                   atom(),
+                                   term()}}
+                        | {error, {aeso_parse_lib:pos(),
+                                   atom()}}.
 string(String) ->
-    string(String, sets:new(), []).
-
--spec string(string(), aeso_compiler:options()) -> parse_result().
-string(String, Opts) ->
-    case lists:keyfind(src_file, 1, Opts) of
-        {src_file, File} -> string(String, sets:add_element(File, sets:new()), Opts);
-        false -> string(String, sets:new(), Opts)
-    end.
-
--spec string(string(), sets:set(include_hash()), aeso_compiler:options()) -> parse_result().
-string(String, Included, Opts) ->
-    case parse_and_scan(file(), String, Opts) of
-        {ok, AST} ->
-            expand_includes(AST, Included, Opts);
-        Err = {error, _} ->
-            Err
-    end.
+  parse_and_scan(file(), String).
 
 type(String) ->
-    parse_and_scan(type(), String, []).
+  parse_and_scan(type(), String).
 
-parse_and_scan(P, S, Opts) ->
-    set_current_file(proplists:get_value(src_file, Opts, no_file)),
-    case aeso_scan:scan(S) of
-        {ok, Tokens} -> aeso_parse_lib:parse(P, Tokens);
-        Error        -> Error
-    end.
+parse_and_scan(P, S) ->
+  case aeso_scan:scan(S) of
+    {ok, Tokens} -> aeso_parse_lib:parse(P, Tokens);
+    Error        -> Error
+  end.
 
 %% -- Parsing rules ----------------------------------------------------------
 
@@ -56,10 +36,7 @@ decl() ->
     ?LAZY_P(
     choice(
       %% Contract declaration
-    [ ?RULE(keyword(contract),  con(), tok('='), maybe_block(decl()), {contract, _1, _2, _4})
-    , ?RULE(token(payable),     keyword(contract), con(), tok('='), maybe_block(decl()), add_modifiers([_1], {contract, _2, _3, _5}))
-    , ?RULE(keyword(namespace), con(), tok('='), maybe_block(decl()), {namespace, _1, _2, _4})
-    , ?RULE(keyword(include),   str(), {include, get_ann(_1), _2})
+    [ ?RULE(keyword(contract), con(), tok('='), maybe_block(decl()), {contract, _1, _2, _4})
 
       %% Type declarations  TODO: format annotation for "type bla" vs "type bla()"
     , ?RULE(keyword(type),     id(),                                          {type_decl, _1, _2, []})
@@ -72,31 +49,17 @@ decl() ->
     , ?RULE(keyword(datatype), id(), type_vars(), tok('='), typedef(variant), {type_def, _1, _2, _3, _5})
 
       %% Function declarations
-    , ?RULE(modifiers(), fun_or_entry(), id(), tok(':'), type(), add_modifiers(_1, _2, {fun_decl, get_ann(_2), _3, _5}))
-    , ?RULE(modifiers(), fun_or_entry(), fundef(),               add_modifiers(_1, _2, set_pos(get_pos(get_ann(_2)), _3)))
-    , ?RULE(keyword('let'),    valdef(),                         set_pos(get_pos(_1), _2))
+    , ?RULE(modifiers(), keyword(function), id(), tok(':'), type(), add_modifiers(_1, {fun_decl, _2, _3, _5}))
+    , ?RULE(modifiers(), keyword(function), fundef(),               add_modifiers(_1, set_pos(get_pos(_2), _3)))
+    , ?RULE(keyword('let'),    valdef(),                            set_pos(get_pos(_1), _2))
     ])).
 
-fun_or_entry() ->
-    choice([?RULE(keyword(function), {function, _1}),
-            ?RULE(keyword(entrypoint), {entrypoint, _1})]).
-
 modifiers() ->
-    many(choice([token(stateful), token(payable), token(private), token(public)])).
+    many(choice([token(stateful), token(public), token(private), token(internal)])).
 
-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)).
+add_modifiers(Mods, Node) ->
+    lists:foldl(fun({Mod, _}, X) -> set_ann(Mod, true, X) end,
+                Node, Mods).
 
 %% -- Type declarations ------------------------------------------------------
 
@@ -108,7 +71,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()).
@@ -120,7 +83,9 @@ con_arg()    -> choice(type(), ?RULE(keyword(indexed), type(), set_ann(indexed,
 %% -- Let declarations -------------------------------------------------------
 
 letdecl() ->
-    ?RULE(keyword('let'), letdef(), set_pos(get_pos(_1), _2)).
+    choice(
+        ?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()).
 
@@ -150,35 +115,24 @@ type() -> ?LAZY_P(type100()).
 type100() -> type200().
 
 type200() ->
-    ?RULE(many({type300(), keyword('=>')}), type300(), fun_t(_1, _2)).
+    ?RULE(many({fun_domain(), keyword('=>')}), type300(), fun_t(_1, _2)).
 
-type300() ->
-    ?RULE(sep1(type400(), tok('*')), tuple_t(get_ann(lists:nth(1, _1)), _1)).
+type300() -> type400().
 
 type400() ->
-    choice(
-    [?RULE(typeAtom(), optional(type_args()),
+    ?RULE(typeAtom(), optional(type_args()),
           case _2 of
             none       -> _1;
             {ok, Args} -> {app_t, get_ann(_1), _1, Args}
-          end),
-     ?RULE(id("bytes"), parens(token(int)),
-           {bytes_t, get_ann(_1), element(3, _2)})
-    ]).
+          end).
 
 typeAtom() ->
     ?LAZY_P(choice(
-    [ parens(type())
-    , args_t()
-    , id(), token(con), token(qcon), token(qid), tvar()
+    [ id(), token(con), token(qcon), token(qid), tvar()
+    , ?RULE(keyword('('), comma_sep(type()), tok(')'), tuple_t(_1, _2))
     ])).
 
-args_t() ->
-    ?LAZY_P(choice(
-    [ ?RULE(tok('('), tok(')'), {args_t, get_ann(_1), []})
-      %% Singleton case handled separately
-    , ?RULE(tok('('), type(), tok(','), sep1(type(), tok(',')), tok(')'), {args_t, get_ann(_1), [_2|_4]})
-    ])).
+fun_domain() -> ?RULE(?LAZY_P(type300()), fun_domain(_1)).
 
 %% -- Statements -------------------------------------------------------------
 
@@ -233,33 +187,19 @@ exprAtom() ->
     ?LAZY_P(begin
         Expr = ?LAZY_P(expr()),
         choice(
-        [ id_or_addr(), con(), token(qid), token(qcon)
-        , token(bytes), token(string), token(char)
+        [ id(), con(), token(qid), token(qcon)
+        , token(hash), 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}
-        , ?LET_P(Fs, brace_list(?LAZY_P(field_assignment())), record(Fs))
+        , ?RULE(brace_list(?LAZY_P(field_assignment())), record(_1))
         , {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})
@@ -296,20 +236,14 @@ record_update(Ann, E, Flds) ->
 record([]) -> {map, [], []};
 record(Fs) ->
     case record_or_map(Fs) of
-        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)};
+        record -> {record, get_ann(hd(Fs)), Fs};
         map    ->
             Ann = get_ann(hd(Fs ++ [{empty, []}])), %% TODO: source location for empty maps
             KV = fun({field, _, [{map_get, _, Key}], Val}) -> {Key, Val};
-                    ({field, FAnn, LV, Id, _}) ->
-                        bad_expr_err("Cannot use '@' in map construction", infix({lvalue, FAnn, LV}, {'@', Ann}, Id));
-                    ({field, FAnn, LV, _}) ->
-                        bad_expr_err("Cannot use nested fields or keys in map construction", {lvalue, FAnn, LV}) end,
+                    ({field, _, LV, Id, _}) ->
+                        bad_expr_err("Cannot use '@' in map construction", infix(LV, {op, Ann, '@'}, Id));
+                    ({field, _, LV, _}) ->
+                        bad_expr_err("Cannot use nested fields or keys in map construction", LV) end,
             {map, Ann, lists:map(KV, Fs)}
     end.
 
@@ -367,7 +301,6 @@ binop(Ops) ->
 con()      -> token(con).
 id()       -> token(id).
 tvar()     -> token(tvar).
-str()      -> token(string).
 
 token(Tag) ->
     ?RULE(tok(Tag),
@@ -376,26 +309,6 @@ 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)).
@@ -423,17 +336,10 @@ 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) -> [{file, current_file()}, {line, Line}, {col, Col}].
-
-current_file() ->
-    get('$current_file').
-
-set_current_file(File) ->
-    put('$current_file', File).
+pos_ann(Line, Col) -> [{line, Line}, {col, Col}].
 
 ann_pos(Ann) ->
-    {proplists:get_value(file, Ann),
-     proplists:get_value(line, Ann),
+    {proplists:get_value(line, Ann),
      proplists:get_value(col, Ann)}.
 
 get_ann(Ann) when is_list(Ann) -> Ann;
@@ -451,10 +357,10 @@ set_ann(Key, Val, Node) ->
     setelement(2, Node, lists:keystore(Key, 1, Ann, {Key, Val})).
 
 get_pos(Node) ->
-    {current_file(), get_ann(line, Node), get_ann(col, Node)}.
+    {get_ann(line, Node), get_ann(col, Node)}.
 
-set_pos({F, L, C}, Node) ->
-    set_ann(file, F, set_ann(line, L, set_ann(col, C, Node))).
+set_pos({L, C}, Node) ->
+    set_ann(line, L, set_ann(col, C, Node)).
 
 infix(L, Op, R) -> set_ann(format, infix,  {app, get_ann(L), Op, [L, R]}).
 
@@ -487,7 +393,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, {tuple, [{origin, system}], []}}.
+    {'if', Ann, Cond, Then, {unit, [{origin, system}]}}.
 
 else_branches([Elif = {elif, _, _, _} | Stmts], Acc) ->
     else_branches(Stmts, [Elif | Acc]);
@@ -500,14 +406,16 @@ tuple_t(_Ann, [Type]) -> Type;  %% Not a tuple
 tuple_t(Ann, Types)   -> {tuple_t, Ann, Types}.
 
 fun_t(Domains, Type) ->
-    lists:foldr(fun({{args_t, _, Dom}, Ann}, T) -> {fun_t, Ann, [], Dom, T};
-                    ({Dom, Ann}, T)             -> {fun_t, Ann, [], [Dom], T} end,
+    lists:foldr(fun({Dom, Ann}, T) -> {fun_t, Ann, [], Dom, T} end,
                 Type, Domains).
 
+tuple_e(Ann, [])      -> {unit, Ann};
 tuple_e(_Ann, [Expr]) -> Expr;  %% Not a tuple
 tuple_e(Ann, Exprs)   -> {tuple, Ann, Exprs}.
 
-list_comp_e(Ann, Expr, Binds) -> {list_comp, Ann, Expr, Binds}.
+%% TODO: not nice
+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}) ->
@@ -522,9 +430,10 @@ 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 = {bytes, _, _})  -> E;
+parse_pattern(E = {hash, _, _})   -> E;
 parse_pattern(E = {string, _, _}) -> E;
 parse_pattern(E = {char, _, _})   -> E;
 parse_pattern(E) -> bad_expr_err("Not a valid pattern", E).
@@ -533,92 +442,16 @@ parse_pattern(E) -> bad_expr_err("Not a valid pattern", E).
 parse_field_pattern({field, Ann, F, E}) ->
     {field, Ann, F, parse_pattern(E)}.
 
-return_error({no_file, L, C}, Err) ->
-    fail(io_lib:format("~p:~p:\n~s", [L, C, Err]));
-return_error({F, L, C}, Err) ->
-    fail(io_lib:format("In ~s at ~p:~p:\n~s", [F, L, C, Err])).
+return_error({L, C}, Err) ->
+    fail(io_lib:format("~p:~p:\n~s", [L, C, Err])).
 
--spec ret_doc_err(ann(), prettypr:document()) -> aeso_parse_lib:parser(none()).
+-spec ret_doc_err(ann(), prettypr:document()) -> no_return().
 ret_doc_err(Ann, Doc) ->
     return_error(ann_pos(Ann), prettypr:format(Doc)).
 
--spec bad_expr_err(string(), aeso_syntax:expr()) -> aeso_parse_lib:parser(none()).
+-spec bad_expr_err(string(), aeso_syntax:expr()) -> no_return().
 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,_ }} ->
-            return_error(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,28 +147,19 @@ 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, Ann, 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({fun_decl, _, F, T}) ->
+    hsep(text("function"), typed(name(F), T));
 decl(D = {letfun, Attrs, _, _, _, _}) ->
-    Mod = fun({Mod, true}) when Mod == private; Mod == stateful ->
+    Mod = fun({Mod, true}) when Mod == private; Mod == internal; Mod == public; Mod == stateful ->
                             text(atom_to_list(Mod));
              (_) -> empty() end,
-    Fun = case aeso_syntax:get_ann(entrypoint, Attrs, false) of
-              true  -> "entrypoint";
-              false -> "function"
-          end,
-    hsep(lists:map(Mod, Attrs) ++ [letdecl(Fun, D)]);
-decl(D = {letval, _, _, _, _}) -> letdecl("let", D).
+    hsep(lists:map(Mod, Attrs) ++ [letdecl("function", D)]);
+decl(D = {letval, _, _, _, _})    -> letdecl("let", D);
+decl(D = {letrec, _, _})          -> letdecl("let", D).
 
 -spec expr(aeso_syntax:expr(), options()) -> doc().
 expr(E, Options) ->
@@ -191,7 +182,9 @@ 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) ->
@@ -222,7 +215,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), args_type(Args)).
+constructor_t({constr_t, _, C, Args}) -> beside(name(C), tuple_type(Args)).
 
 -spec field_t(aeso_syntax:field_t()) -> doc().
 field_t({field_t, _, Name, Type}) ->
@@ -234,24 +227,15 @@ type(Type, Options) ->
 
 -spec type(aeso_syntax:type()) -> doc().
 type({fun_t, _, Named, Args, Ret}) ->
-    follow(hsep(args_type(Named ++ Args), text("=>")), type(Ret));
-type({type_sig, _, Named, Args, Ret}) ->
     follow(hsep(tuple_type(Named ++ Args), text("=>")), type(Ret));
 type({app_t, _, Type, []}) ->
     type(Type);
 type({app_t, _, Type, Args}) ->
-    beside(type(Type), args_type(Args));
+    beside(type(Type), tuple_type(Args));
 type({tuple_t, _, Args}) ->
     tuple_type(Args);
-type({args_t, _, Args}) ->
-    args_type(Args);
-type({bytes_t, _, any}) -> text("bytes(_)");
-type({bytes_t, _, Len}) ->
-    text(lists:concat(["bytes(", Len, ")"]));
-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({named_arg_t, _, Name, Type, Default}) ->
+    follow(hsep(typed(name(Name), Type), text("=")), expr(Default));
 
 type(R = {record_t, _}) -> typedef(R);
 type(T = {id, _, _})   -> name(T);
@@ -260,19 +244,9 @@ type(T = {con, _, _})  -> name(T);
 type(T = {qcon, _, _}) -> name(T);
 type(T = {tvar, _, _}) -> name(T).
 
--spec args_type([aeso_syntax:type()]) -> doc().
-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(")")
-      ]).
+tuple_type(Args) ->
+    tuple(lists:map(fun type/1, Args)).
 
 -spec arg_expr(aeso_syntax:arg_expr()) -> doc().
 arg_expr({named_arg, _, Name, E}) ->
@@ -329,8 +303,6 @@ 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
@@ -341,18 +313,8 @@ expr_p(_, E = {int, _, N}) ->
            end,
     text(S);
 expr_p(_, {bool, _, B}) -> text(atom_to_list(B));
-expr_p(_, {bytes, _, Bin}) ->
-    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(_, {hash, _, <<N:256>>}) -> text("#" ++ integer_to_list(N, 16));
+expr_p(_, {unit, _}) -> text("()");
 expr_p(_, {string, _, S}) -> term(binary_to_list(S));
 expr_p(_, {char, _, C}) ->
     case C of
@@ -385,7 +347,6 @@ 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};
@@ -457,6 +418,7 @@ 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, "+"],
-    BYTES    = ["#", HEXDIGIT, "+"],
+    HASH     = ["#", HEXDIGIT, "+"],
     WS       = "[\\000-\\ ]+",
     ID       = [LOWER, "[a-zA-Z0-9_']*"],
     TVAR     = ["'", ID],
@@ -36,8 +36,8 @@ lexer() ->
         , {"\\*/",        pop(skip())}
         , {"[^/*]+|[/*]", skip()} ],
 
-    Keywords = ["contract", "include", "let", "switch", "type", "record", "datatype", "if", "elif", "else", "function",
-                "stateful", "payable", "true", "false", "mod", "public", "entrypoint", "private", "indexed", "namespace"],
+    Keywords = ["contract", "import", "let", "rec", "switch", "type", "record", "datatype", "if", "elif", "else", "function",
+                "stateful", "true", "false", "and", "mod", "public", "private", "indexed", "internal"],
     KW = string:join(Keywords, "|"),
 
     Rules =
@@ -54,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)}
-        , {BYTES,  token(bytes,  fun parse_bytes/1)}
+        , {HASH,   token(hash,   fun parse_hash/1)}
 
           %% Identifiers (qualified first!)
         , {QID,   token(qid,  fun(S) -> string:tokens(S, ".") end)}
@@ -117,8 +117,10 @@ unescape([C | Chars], Acc) ->
 
 parse_hex("0x" ++ Chars) -> list_to_integer(Chars, 16).
 
-parse_bytes("#" ++ Chars) ->
-    N      = list_to_integer(Chars, 16),
-    Digits = (length(Chars) + 1) div 2,
-    <<N:Digits/unit:8>>.
+parse_hash("#" ++ Chars) ->
+    N = list_to_integer(Chars, 16),
+    case length(Chars) > 64 of  %% 64 hex digits = 32 bytes
+        true  -> <<N:64/unit:8>>;   %% signature
+        false -> <<N:32/unit:8>>    %% address
+    end.
 

src/aeso_sophia.erl

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

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

src/aeso_syntax.erl

@@ -8,14 +8,14 @@
 
 -module(aeso_syntax).
 
--export([get_ann/1, get_ann/2, get_ann/3, set_ann/2, qualify/2]).
+-export([get_ann/1, get_ann/2, get_ann/3, set_ann/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, named_arg_t/0]).
--export_type([type/0, constant/0, expr/0, arg_expr/0, field/1, stmt/0, alt/0, lvalue/0, elim/0, pat/0]).
+-export_type([arg/0, field_t/0, constructor_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([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()} | stateful | private].
+-type ann() :: [{line, ann_line()} | {col, ann_col()} | {format, ann_format()} | {origin, ann_origin()}].
 
 -type name() :: string().
 -type id()   :: {id,   ann(), name()}.
@@ -35,7 +35,6 @@
 -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()}
@@ -43,7 +42,8 @@
 
 -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,8 +59,6 @@
 -type type() :: {fun_t, ann(), [named_arg_t()], [type()], type()}
               | {app_t, ann(), type(), [type()]}
               | {tuple_t, ann(), [type()]}
-              | {args_t, ann(), [type()]}   %% old tuple syntax, old for error messages
-              | {bytes_t, ann(), integer() | any}
               | id()  | qid()
               | con() | qcon()  %% contracts
               | tvar().
@@ -70,11 +68,8 @@
 -type constant()
     :: {int, ann(), integer()}
      | {bool, ann(), true | false}
-     | {bytes, ann(), binary()}
-     | {account_pubkey, ann(), binary()}
-     | {contract_pubkey, ann(), binary()}
-     | {oracle_pubkey, ann(), binary()}
-     | {oracle_query_id, ann(), binary()}
+     | {hash, ann(), binary()}
+     | {unit, ann()}
      | {string, ann(), binary()}
      | {char, ann(), integer()}.
 
@@ -93,7 +88,6 @@
      | {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
@@ -106,10 +100,6 @@
      | 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
@@ -150,7 +140,3 @@ 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,151 +6,89 @@
 %%%-------------------------------------------------------------------
 -module(aeso_syntax_utils).
 
--export([used_ids/1, used_types/2, used/1]).
+-export([used_ids/1, used_types/1]).
 
--record(alg, {zero, plus, scoped}).
+%% Var set combinators
+none()           -> [].
+one(X)           -> [X].
+union_map(F, Xs) -> lists:umerge(lists:map(F, Xs)).
+minus(Xs, Ys)    -> Xs -- Ys.
 
--type alg(A) :: #alg{ zero   :: A
-                    , plus   :: fun((A, A) -> A)
-                    , scoped :: fun((A, A) -> A) }.
+%% Compute names used by a definition or expression.
+used_ids(Es) when is_list(Es) ->
+    union_map(fun used_ids/1, Es);
+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).
 
--type kind() :: decl | type | bind_type | expr | bind_expr.
+%% Statements
+used_ids_s([])       -> none();
+used_ids_s([S | Ss]) ->
+    used_ids([S, {bind, bound_ids(S), {block, [], Ss}}]).
 
--spec fold(alg(A), fun((kind(), _) -> A), kind(), E | [E]) -> A
-    when E :: aeso_syntax:decl()
-            | aeso_syntax:typedef()
-            | 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).
+bound_ids({letval, _, X, _, _})    -> one(X);
+bound_ids({letfun, _, X, _, _, _}) -> one(X);
+bound_ids({letrec, _, Decls})      -> union_map(fun bound_ids/1, Decls);
+bound_ids(_)                       -> none().
 
+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

@@ -1,113 +0,0 @@
-%%%-------------------------------------------------------------------
-%%% @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,15 +1,13 @@
 {application, aesophia,
- [{description, "Contract Language for aeternity"},
-  {vsn, "4.0.0-rc1"},
+ [{description, "Contract Language for Aethernity"},
+  {vsn, "1.2.0"},
   {registered, []},
   {applications,
    [kernel,
     stdlib,
-    jsx,
     syntax_tools,
     getopt,
-    aebytecode,
-    eblake2
+    aebytecode
    ]},
   {env,[]},
   {modules, []},

src/aesophia.erl

@@ -0,0 +1,71 @@
+-module(aesophia).
+
+-export([main/1]).
+
+-define(OPT_SPEC,
+    [ {src_file, undefined, undefined, string, "Sophia source code file"}
+    , {verbose, $v, "verbose", undefined, "Verbose output"}
+    , {help, $h, "help", undefined, "Show this message"}
+    , {outfile, $o, "out", string, "Output file (experimental)"} ]).
+
+usage() ->
+    getopt:usage(?OPT_SPEC, "aesophia").
+
+main(Args) ->
+    case getopt:parse(?OPT_SPEC, Args) of
+        {ok, {Opts, []}} ->
+            case proplists:get_value(help, Opts, false) of
+                false ->
+                    compile(Opts);
+                true ->
+                    usage()
+            end;
+
+        {ok, {_, NonOpts}} ->
+            io:format("Can't understand ~p\n\n", [NonOpts]),
+            usage();
+
+        {error, {Reason, Data}} ->
+            io:format("Error: ~s ~p\n\n", [Reason, Data]),
+            usage()
+    end.
+
+
+compile(Opts) ->
+    case proplists:get_value(src_file, Opts, undefined) of
+        undefined ->
+            io:format("Error: no input source file\n\n"),
+            usage();
+        File ->
+            compile(File, Opts)
+    end.
+
+compile(File, Opts) ->
+    Verbose = proplists:get_value(verbose, Opts, false),
+    OutFile = proplists:get_value(outfile, Opts, undefined),
+
+    try
+        Res = aeso_compiler:file(File, [pp_ast || Verbose]),
+        write_outfile(OutFile, Res),
+        io:format("\nCompiled successfully!\n")
+    catch
+        %% The compiler errors.
+        error:{type_errors, Errors} ->
+            io:format("\n~s\n", [string:join(["** Type errors\n" | Errors], "\n")]);
+        error:{parse_errors, Errors} ->
+            io:format("\n~s\n", [string:join(["** Parse errors\n" | Errors], "\n")]);
+        error:{code_errors, Errors} ->
+            ErrorStrings = [ io_lib:format("~p", [E]) || E <- Errors ],
+            io:format("\n~s\n", [string:join(["** Code errors\n" | ErrorStrings], "\n")]);
+        %% General programming errors in the compiler.
+        error:Error ->
+            Where = hd(erlang:get_stacktrace()),
+            ErrorString = io_lib:format("Error: ~p in\n   ~p", [Error,Where]),
+            io:format("\n~s\n", [ErrorString])
+    end.
+
+write_outfile(undefined, _) -> ok;
+write_outfile(Out, ResMap)  ->
+    %% Lazy approach
+    file:write_file(Out, term_to_binary(ResMap)),
+    io:format("Output written to: ~s\n", [Out]).

test/aeso_abi_tests.erl

@@ -1,12 +1,9 @@
 -module(aeso_abi_tests).
 
 -include_lib("eunit/include/eunit.hrl").
--compile([export_all, nowarn_export_all]).
+-compile(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(),
@@ -22,8 +19,8 @@ sandbox(Code) ->
 
 malicious_from_binary_test() ->
     CircularList = from_words([32, 1, 32]), %% Xs = 1 :: Xs
-    {ok, {error, circular_references}}   = ?SANDBOX(aeb_heap:from_binary({list, word}, CircularList)),
-    {ok, {error, {binary_too_short, _}}} = ?SANDBOX(aeb_heap:from_binary(word, <<1, 2, 3, 4>>)),
+    {ok, {error, circular_references}}   = ?SANDBOX(aeso_heap:from_binary({list, word}, CircularList)),
+    {ok, {error, {binary_too_short, _}}} = ?SANDBOX(aeso_heap:from_binary(word, <<1, 2, 3, 4>>)),
     ok.
 
 from_words(Ws) ->
@@ -57,144 +54,35 @@ encode_decode_test() ->
     ok.
 
 encode_decode_sophia_test() ->
-    Check = fun(Type, Str) -> case {encode_decode_sophia_string(Type, Str), Str} of
-                                {X, X} -> ok;
-                                Other -> Other
-                              end end,
-    ok = Check("int", "42"),
-    ok = Check("int", "-42"),
-    ok = Check("bool", "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}"),
+    {42} = encode_decode_sophia_string("int", "42"),
+    {1} = encode_decode_sophia_string("bool", "true"),
+    {0} = encode_decode_sophia_string("bool", "false"),
+    {<<"Hello">>} = encode_decode_sophia_string("string", "\"Hello\""),
+    {<<"Hello">>, [1,2,3], {variant, 1, [1]}} =
+        encode_decode_sophia_string(
+          "(string, list(int), option(bool))",
+          "\"Hello\", [1,2,3], Some(true)"),
     ok.
 
 encode_decode_sophia_string(SophiaType, String) ->
     io:format("String ~p~n", [String]),
-    Code = [ "contract MakeCall =\n"
-           , "  type arg_type = ", SophiaType, "\n"
-           , "  type an_alias('a) = string * 'a\n"
-           , "  record r = {x : an_alias(int), y : variant}\n"
-           , "  datatype variant = Red | Blue(map(string, int))\n"
-           , "  entrypoint foo : arg_type => arg_type\n" ],
-    case aeso_compiler:check_call(lists:flatten(Code), "foo", [String], []) of
-        {ok, _, {[Type], _}, [Arg]} ->
-            io:format("Type ~p~n", [Type]),
-            Data = encode(Arg),
-            case aeso_compiler:to_sophia_value(Code, "foo", ok, Data, []) of
-                {ok, Sophia} ->
-                    lists:flatten(io_lib:format("~s", [prettypr:format(aeso_pretty:expr(Sophia))]));
-                {error, Err} ->
-                    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"], []),
-
-    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, <<"Type errors\nCannot unify", _/binary>>} =
-            aeso_compiler:check_call(Contract, "haxx", ["#123"], []),
-    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}]),
-    ?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).
+    Code = [ "contract Call =\n"
+           , "  function foo : ", SophiaType, " => _\n"
+           , "  function __call() = foo(", String, ")\n" ],
+    {ok, _, {Types, _}, Args} = aeso_compiler:check_call(lists:flatten(Code), []),
+    Arg  = list_to_tuple(Args),
+    Type = {tuple, Types},
+    io:format("Type ~p~n", [Type]),
+    Data = encode(Arg),
+    decode(Type, Data).
 
 encode_decode(T, D) ->
     ?assertEqual(D, decode(T, encode(D))),
     D.
 
 encode(D) ->
-    aeb_heap:to_binary(D).
+    aeso_heap:to_binary(D).
 
 decode(T,B) ->
-    {ok, D} = aeb_heap:from_binary(T, B),
+    {ok, D} = aeso_heap:from_binary(T, B),
     D.

test/aeso_aci_tests.erl

@@ -1,125 +0,0 @@
--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
-        {ok, Ast} ->
-            try
-                %% io:format("AST: ~120p\n", [Ast]),
-                aeso_ast_infer_types:infer(Ast, [])
-            catch _:{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_blake2_tests.erl

@@ -0,0 +1,73 @@
+%%%=============================================================================
+%%% @copyright (C) 2019, Aeternity Anstalt
+%%% @doc
+%%%   Unit tests for the aeso_blake2 module
+%%%
+%%%   In addition the aeso_blake2 module was compared to the C reference
+%%%   implementation by writing a QuickCheck property.
+%%% @end
+%%%=============================================================================
+-module(aeso_blake2_tests).
+
+-ifdef(TEST).
+
+-include_lib("eunit/include/eunit.hrl").
+
+blake2b_test_() ->
+    {"Tests for BLAKE2b hash implementation",
+     [ fun() -> blake2b(Data) end || Data <- test_data_blake2b() ]}.
+
+blake2b({Msg0, Key0, ExpectedOut0}) ->
+    Msg = mk_binary(Msg0),
+    Key = mk_binary(Key0),
+    ExpectedOut = mk_binary(ExpectedOut0),
+    Result = aeso_blake2:blake2b(byte_size(ExpectedOut), Msg, Key),
+    ?assertEqual(Result, {ok, ExpectedOut}).
+
+mk_binary(Bin) when is_binary(Bin) -> Bin;
+mk_binary(HexStr) when is_list(HexStr) ->
+    << << (erlang:list_to_integer([H], 16)):4 >> || H <- HexStr >>.
+
+test_data_blake2b() ->
+    [ %% {Message, Key, ExpectedHash}
+      %% From Wikipedia
+      %% https://en.wikipedia.org/wiki/BLAKE_(hash_function)#BLAKE2
+      {<<>>,
+       <<>>,
+       "786A02F742015903C6C6FD852552D272912F4740E15847618A86E217F71F5419D25E1031AFEE585313896444934EB04B903A685B1448B755D56F701AFE9BE2CE"}
+    , {<<"The quick brown fox jumps over the lazy dog">>,
+       <<>>,
+       "A8ADD4BDDDFD93E4877D2746E62817B116364A1FA7BC148D95090BC7333B3673F82401CF7AA2E4CB1ECD90296E3F14CB5413F8ED77BE73045B13914CDCD6A918"}
+
+      %% From reference implementation testvectors
+      %% https://github.com/BLAKE2/BLAKE2/tree/master/testvectors
+      %%
+      %% Non-keyed
+    , {"00",
+        "",
+        "2FA3F686DF876995167E7C2E5D74C4C7B6E48F8068FE0E44208344D480F7904C36963E44115FE3EB2A3AC8694C28BCB4F5A0F3276F2E79487D8219057A506E4B"}
+    , {"0001",
+       "",
+       "1C08798DC641ABA9DEE435E22519A4729A09B2BFE0FF00EF2DCD8ED6F8A07D15EAF4AEE52BBF18AB5608A6190F70B90486C8A7D4873710B1115D3DEBBB4327B5"}
+    , {"00010203040506070809",
+       "",
+       "29102511D749DB3CC9B4E335FA1F5E8FACA8421D558F6A3F3321D50D044A248BA595CFC3EFD3D2ADC97334DA732413F5CBF4751C362BA1D53862AC1E8DABEEE8"}
+
+      %% Keyed
+    , {"",
+       "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f",
+       "10ebb67700b1868efb4417987acf4690ae9d972fb7a590c2f02871799aaa4786b5e996e8f0f4eb981fc214b005f42d2ff4233499391653df7aefcbc13fc51568"}
+    , {"00",
+       "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f",
+       "961f6dd1e4dd30f63901690c512e78e4b45e4742ed197c3c5e45c549fd25f2e4187b0bc9fe30492b16b0d0bc4ef9b0f34c7003fac09a5ef1532e69430234cebd"}
+    , {"0001",
+       "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f",
+       "da2cfbe2d8409a0f38026113884f84b50156371ae304c4430173d08a99d9fb1b983164a3770706d537f49e0c916d9f32b95cc37a95b99d857436f0232c88a965"}
+    , {"00010203040506070809",
+       "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f",
+       "4fe181f54ad63a2983feaaf77d1e7235c2beb17fa328b6d9505bda327df19fc37f02c4b6f0368ce23147313a8e5738b5fa2a95b29de1c7f8264eb77b69f585cd"}
+    ].
+
+
+-endif.
+

test/aeso_calldata_tests.erl

@@ -1,129 +0,0 @@
-%%% -*- 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,62 +8,31 @@
 
 -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_() ->
-     [ {"Testing the " ++ ContractName ++ " contract with the " ++ atom_to_list(Backend) ++ " backend",
+    {setup,
+     fun () -> ok end,                          %Setup
+     fun (_) -> ok end,                         %Cleanup
+     [ {"Testing the " ++ ContractName ++ " contract",
         fun() ->
-            case compile(Backend, ContractName) of
-                #{byte_code := ByteCode,
-                  contract_source := _,
-                  type_info := _} when Backend == aevm ->
-                    ?assertMatch(Code when is_binary(Code), ByteCode);
-                #{fate_code := Code} when Backend == fate ->
-                    Code1 = aeb_fate_code:deserialize(aeb_fate_code:serialize(Code)),
-                    ?assertMatch({X, X}, {Code1, Code});
-                ErrBin ->
-                    io:format("\n~s", [ErrBin]),
-                    error(ErrBin)
-            end
-        end} || ContractName <- compilable_contracts(), Backend <- [aevm, fate],
-                not lists:member(ContractName, not_yet_compilable(Backend))] ++
+            #{byte_code := ByteCode,
+              contract_source := _,
+              type_info := _} = compile(ContractName),
+            ?assertMatch(Code when is_binary(Code), ByteCode)
+        end} || ContractName <- compilable_contracts() ] ++
      [ {"Testing error messages of " ++ ContractName,
         fun() ->
-            case compile(aevm, ContractName) of
-                <<"Type errors\n", ErrorString/binary>> ->
-                    check_errors(lists:sort(ExpectedErrors), ErrorString);
-                <<"Parse errors\n", ErrorString/binary>> ->
-                    check_errors(lists:sort(ExpectedErrors), ErrorString)
-            end
+            <<"Type errors\n",ErrorString/binary>> = compile(ContractName),
+            check_errors(lists:sort(ExpectedErrors), ErrorString)
         end} ||
-            {ContractName, ExpectedErrors} <- failing_contracts() ] ++
-     [ {"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] ].
+            {ContractName, ExpectedErrors} <- failing_contracts() ]
+    }.
 
 check_errors(Expect, ErrorString) ->
     %% This removes the final single \n as well.
@@ -74,15 +43,11 @@ check_errors(Expect, ErrorString) ->
         {Missing, Extra} -> ?assertEqual(Missing, Extra)
     end.
 
-compile(Backend, Name) ->
-    compile(Backend, Name,
-            [{include, {file_system, [aeso_test_utils:contract_path()]}}]).
-
-compile(Backend, Name, Options) ->
+compile(Name) ->
     String = aeso_test_utils:read_contract(Name),
-    case aeso_compiler:from_string(String, [{src_file, Name}, {backend, Backend} | Options]) of
-        {ok, Map}            -> Map;
-        {error, ErrorString} -> ErrorString
+    case aeso_compiler:from_string(String, []) of
+        {ok,Map} -> Map;
+        {error,ErrorString} -> ErrorString
     end.
 
 %% compilable_contracts() -> [ContractName].
@@ -94,7 +59,6 @@ compilable_contracts() ->
      "dutch_auction",
      "environment",
      "factorial",
-     "functions",
      "fundme",
      "identity",
      "maps",
@@ -106,33 +70,9 @@ compilable_contracts() ->
      "stack",
      "test",
      "builtin_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",
-     "aens",
-     "tuple_match",
-     "cyclic_include",
-     "stdlib_include",
-     "double_include",
-     "manual_stdlib_include",
-     "list_comp",
-     "payable"
+     "builtin_map_get_bug"
     ].
 
-not_yet_compilable(fate) -> [];
-not_yet_compilable(aevm) -> [].
-
 %% Contracts that should produce type errors
 
 failing_contracts() ->
@@ -140,9 +80,6 @@ failing_contracts() ->
        [<<"Duplicate definitions of abort at\n"
           "  - (builtin location)\n"
           "  - line 14, column 3">>,
-        <<"Duplicate definitions of require at\n"
-          "  - (builtin location)\n"
-          "  - line 15, column 3">>,
         <<"Duplicate definitions of double_def at\n"
           "  - line 10, column 3\n"
           "  - line 11, column 3">>,
@@ -154,12 +91,12 @@ failing_contracts() ->
           "  - line 8, column 3">>,
         <<"Duplicate definitions of put at\n"
           "  - (builtin location)\n"
-          "  - line 16, column 3">>,
+          "  - line 15, column 3">>,
         <<"Duplicate definitions of state at\n"
           "  - (builtin location)\n"
-          "  - line 17, column 3">>]}
+          "  - line 16, column 3">>]}
     , {"type_errors",
-       [<<"Unbound variable zz at line 17, column 23">>,
+       [<<"Unbound variable zz at line 17, column 21">>,
         <<"Cannot unify int\n"
           "         and list(int)\n"
           "when checking the application at line 26, column 9 of\n"
@@ -170,18 +107,18 @@ failing_contracts() ->
         <<"Cannot unify string\n"
           "         and int\n"
           "when checking the assignment of the field\n"
-          "  x : map(string, string) (at line 9, column 48)\n"
+          "  x : map(string, string) (at line 9, column 46)\n"
           "to the old value __x and the new value\n"
           "  __x {[\"foo\"] @ x = x + 1} : map(string, int)">>,
         <<"Cannot unify int\n"
           "         and string\n"
-          "when checking the type of the expression at line 34, column 47\n"
+          "when checking the type of the expression at line 34, column 45\n"
           "  1 : int\n"
           "against the expected type\n"
           "  string">>,
         <<"Cannot unify string\n"
           "         and int\n"
-          "when checking the type of the expression at line 34, column 52\n"
+          "when checking the type of the expression at line 34, column 50\n"
           "  \"bla\" : string\n"
           "against the expected type\n"
           "  int">>,
@@ -193,7 +130,7 @@ failing_contracts() ->
           "  int">>,
         <<"Cannot unify string\n"
           "         and int\n"
-          "when checking the type of the expression at line 11, column 58\n"
+          "when checking the type of the expression at line 11, column 56\n"
           "  \"foo\" : string\n"
           "against the expected type\n"
           "  int">>,
@@ -203,174 +140,31 @@ failing_contracts() ->
           "  - w : int (at line 38, column 13)\n"
           "  - z : string (at line 39, column 10)">>,
         <<"Not a record type: string\n"
-          "arising from the projection of the field y (at line 22, column 40)">>,
+          "arising from the projection of the field y (at line 22, column 38)">>,
         <<"Not a record type: string\n"
-          "arising from an assignment of the field y (at line 21, column 44)">>,
+          "arising from an assignment of the field y (at line 21, column 42)">>,
         <<"Not a record type: string\n"
-          "arising from an assignment of the field y (at line 20, column 40)">>,
+          "arising from an assignment of the field y (at line 20, column 38)">>,
         <<"Not a record type: string\n"
-          "arising from an assignment of the field y (at line 19, column 37)">>,
-        <<"Ambiguous record type with field y (at line 13, column 27) could be one of\n"
+          "arising from an assignment of the field y (at line 19, column 35)">>,
+        <<"Ambiguous record type with field y (at line 13, column 25) could be one of\n"
           "  - r (at line 4, column 10)\n"
           "  - r' (at line 5, column 10)">>,
+        <<"Record type r2 does not have field y (at line 15, column 22)">>,
+        <<"The field z is missing when constructing an element of type r2 (at line 15, column 24)">>,
         <<"Repeated name x in pattern\n"
           "  x :: x (at line 26, column 7)">>,
-        <<"Repeated argument x to function repeated_arg (at line 44, column 14).">>,
-        <<"Repeated argument y to function repeated_arg (at line 44, column 14).">>,
-        <<"No record type with fields y, z (at line 14, column 24)">>,
-        <<"The field z is missing when constructing an element of type r2 (at line 15, column 26)">>,
-        <<"Record type r2 does not have field y (at line 15, column 24)">>,
-        <<"Let binding at line 47, column 5 must be followed by an expression">>,
-        <<"Let binding at line 50, column 5 must be followed by an expression">>,
-        <<"Let binding at line 54, column 5 must be followed by an expression">>,
-        <<"Let binding at line 58, column 5 must be followed by an expression">>]}
+        <<"No record type with fields y, z (at line 14, column 22)">>]}
     , {"init_type_error",
        [<<"Cannot unify string\n"
           "         and map(int, int)\n"
           "when checking that 'init' returns a value of type 'state' at line 7, column 3">>]}
     , {"missing_state_type",
        [<<"Cannot unify string\n"
-          "         and unit\n"
+          "         and ()\n"
           "when checking that 'init' returns a value of type 'state' at line 5, column 3">>]}
     , {"missing_fields_in_record_expression",
-       [<<"The field x is missing when constructing an element of type r('a) (at line 7, column 42)">>,
-        <<"The field y is missing when constructing an element of type r(int) (at line 8, column 42)">>,
-        <<"The fields y, z are missing when constructing an element of type r('a) (at line 6, column 42)">>]}
-    , {"namespace_clash",
-       [<<"The contract Call (at line 4, column 10) has the same name as a namespace at (builtin location)">>]}
-    , {"bad_events",
-        [<<"The indexed type string (at line 9, column 25) is not a word type">>,
-         <<"The indexed type alias_string (at line 10, column 25) equals string which is not a word type">>]}
-    , {"bad_events2",
-        [<<"The event constructor BadEvent1 (at line 9, column 7) has too many non-indexed values (max 1)">>,
-         <<"The event constructor BadEvent2 (at line 10, column 7) has too many indexed values (max 3)">>]}
-    , {"type_clash",
-        [<<"Cannot unify int\n"
-           "         and string\n"
-           "when checking the record projection at line 12, column 42\n"
-           "  r.foo : (gas : int, value : int) => Remote.themap\n"
-           "against the expected type\n"
-           "  (gas : int, value : int) => map(string, int)">>]}
-    , {"bad_include_and_ns",
-        [<<"Include of 'included.aes' at line 2, column 11\nnot allowed, include only allowed at top level.">>,
-         <<"Nested namespace not allowed\nNamespace 'Foo' at line 3, column 13 not defined at top level.">>]}
-    , {"bad_address_literals",
-        [<<"The type bytes(32) is not a contract type\n"
-           "when checking that the contract literal at line 32, column 5\n"
-           "  ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ\n"
-           "has the type\n"
-           "  bytes(32)">>,
-         <<"The type oracle(int, bool) is not a contract type\n"
-           "when checking that the contract literal at line 30, column 5\n"
-           "  ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ\n"
-           "has the type\n"
-           "  oracle(int, bool)">>,
-         <<"The type address is not a contract type\n"
-           "when checking that the contract literal at line 28, column 5\n"
-           "  ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ\n"
-           "has the type\n"
-           "  address">>,
-         <<"Cannot unify oracle_query('a, 'b)\n"
-           "         and Remote\n"
-           "when checking the type of the expression at line 25, column 5\n"
-           "  oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY :\n"
-           "    oracle_query('a, 'b)\n"
-           "against the expected type\n"
-           "  Remote">>,
-         <<"Cannot unify oracle_query('c, 'd)\n"
-           "         and bytes(32)\n"
-           "when checking the type of the expression at line 23, column 5\n"
-           "  oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY :\n"
-           "    oracle_query('c, 'd)\n"
-           "against the expected type\n"
-           "  bytes(32)">>,
-         <<"Cannot unify oracle_query('e, 'f)\n"
-           "         and oracle(int, bool)\n"
-           "when checking the type of the expression at line 21, column 5\n"
-           "  oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY :\n"
-           "    oracle_query('e, 'f)\n"
-           "against the expected type\n"
-           "  oracle(int, bool)">>,
-         <<"Cannot unify oracle('g, 'h)\n"
-           "         and Remote\n"
-           "when checking the type of the expression at line 18, column 5\n"
-           "  ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5 :\n"
-           "    oracle('g, 'h)\n"
-           "against the expected type\n"
-           "  Remote">>,
-         <<"Cannot unify oracle('i, 'j)\n"
-           "         and bytes(32)\n"
-           "when checking the type of the expression at line 16, column 5\n"
-           "  ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5 :\n"
-           "    oracle('i, 'j)\n"
-           "against the expected type\n"
-           "  bytes(32)">>,
-         <<"Cannot unify oracle('k, 'l)\n"
-           "         and oracle_query(int, bool)\n"
-           "when checking the type of the expression at line 14, column 5\n"
-           "  ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5 :\n"
-           "    oracle('k, 'l)\n"
-           "against the expected type\n"
-           "  oracle_query(int, bool)">>,
-         <<"Cannot unify address\n"
-           "         and oracle(int, bool)\n"
-           "when checking the type of the expression at line 11, column 5\n"
-           "  ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt : address\n"
-           "against the expected type\n"
-           "  oracle(int, bool)">>,
-         <<"Cannot unify address\n"
-           "         and Remote\n"
-           "when checking the type of the expression at line 9, column 5\n"
-           "  ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt : address\n"
-           "against the expected type\n"
-           "  Remote">>,
-         <<"Cannot unify address\n"
-           "         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)">>]}
-    , {"stateful",
-       [<<"Cannot reference stateful function Chain.spend (at line 13, column 35)\nin the definition of non-stateful function fail1.">>,
-        <<"Cannot reference stateful function local_spend (at line 14, column 35)\nin the definition of non-stateful function fail2.">>,
-        <<"Cannot reference stateful function Chain.spend (at line 16, column 15)\nin the definition of non-stateful function fail3.">>,
-        <<"Cannot reference stateful function Chain.spend (at line 20, column 31)\nin the definition of non-stateful function fail4.">>,
-        <<"Cannot reference stateful function Chain.spend (at line 35, column 47)\nin the definition of non-stateful function fail5.">>,
-        <<"Cannot pass non-zero value argument 1000 (at line 48, column 57)\nin the definition of non-stateful function fail6.">>,
-        <<"Cannot pass non-zero value argument 1000 (at line 49, column 56)\nin the definition of non-stateful function fail7.">>,
-        <<"Cannot pass non-zero value argument 1000 (at line 52, column 17)\nin the definition of non-stateful function fail8.">>]}
-    , {"bad_init_state_access",
-       [<<"The init function should return the initial state as its result and cannot write the state,\n"
-          "but it calls\n"
-          "  - set_state (at line 11, column 5), which calls\n"
-          "  - roundabout (at line 8, column 38), which calls\n"
-          "  - put (at line 7, column 39)">>,
-        <<"The init function should return the initial state as its result and cannot read the state,\n"
-          "but it calls\n"
-          "  - new_state (at line 12, column 5), which calls\n"
-          "  - state (at line 5, column 29)">>,
-        <<"The init function should return the initial state as its result and cannot read the state,\n"
-          "but it calls\n"
-          "  - state (at line 13, column 13)">>]}
-    , {"field_parse_error",
-       [<<"line 6, column 1: In field_parse_error at 5:26:\n"
-          "Cannot use nested fields or keys in record construction: p.x\n">>]}
-    , {"modifier_checks",
-       [<<"The function all_the_things (at line 11, column 3) cannot be both public and private.">>,
-        <<"Namespaces cannot contain entrypoints (at line 3, column 3). Use 'function' instead.">>,
-        <<"The contract Remote (at line 5, column 10) has no entrypoints. Since Sophia version 3.2, public\ncontract functions must be declared with the 'entrypoint' keyword instead of\n'function'.">>,
-        <<"The entrypoint wha (at line 12, column 3) cannot be private. Use 'function' instead.">>,
-        <<"Use 'entrypoint' for declaration of foo (at line 6, column 3):\n  entrypoint foo : () => unit">>,
-        <<"Use 'entrypoint' instead of 'function' for public function foo (at line 10, column 3):\n  entrypoint foo() = ()">>,
-        <<"Use 'entrypoint' instead of 'function' for public function foo (at line 6, column 3):\n  entrypoint foo : () => unit">>]}
-    , {"list_comp_not_a_list",
-      [<<"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)">>
-      ]}
-    , {"list_comp_if_not_bool",
-      [<<"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">>
-      ]}
-    , {"list_comp_bad_shadow",
-      [<<"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">>
-      ]}
+       [<<"The field x is missing when constructing an element of type r('a) (at line 7, column 40)">>,
+        <<"The field y is missing when constructing an element of type r(int) (at line 8, column 40)">>,
+        <<"The fields y, z are missing when constructing an element of type r('1) (at line 6, column 40)">>]}
     ].
-

test/aeso_eunit_SUITE.erl

@@ -12,11 +12,9 @@ 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

@@ -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, fundme, dutch_auction] ]
+        || Contract <- [counter, voting, all_syntax, '05_greeter', aeproof, multi_sig, simple_storage, withdrawal, fundme, dutch_auction] ]
     }.
 
 parse_contract(Name) ->
@@ -71,10 +71,8 @@ parse_contract(Name) ->
 roundtrip_contract(Name) ->
     round_trip(aeso_test_utils:read_contract(Name)).
 
-parse_string(Text) -> parse_string(Text, []).
-
-parse_string(Text, Opts) ->
-    case aeso_parser:string(Text, Opts) of
+parse_string(Text) ->
+    case aeso_parser:string(Text) of
         {ok, Contract} -> Contract;
         Err -> error(Err)
     end.
@@ -86,16 +84,12 @@ parse_expr(Text) ->
 
 round_trip(Text) ->
     Contract  = parse_string(Text),
-    Text1     = prettypr:format(aeso_pretty:decls(strip_stdlib(Contract))),
+    Text1     = prettypr:format(aeso_pretty:decls(Contract)),
     Contract1 = parse_string(Text1),
     NoSrcLoc  = remove_line_numbers(Contract),
     NoSrcLoc1 = remove_line_numbers(Contract1),
     ?assertMatch(NoSrcLoc, diff(NoSrcLoc, NoSrcLoc1)).
 
-strip_stdlib([{namespace, _, {con, _, "ListInternal"}, _} | Decls]) ->
-    strip_stdlib(Decls);
-strip_stdlib(Decls) -> Decls.
-
 remove_line_numbers({line, _L}) -> {line, 0};
 remove_line_numbers({col,  _C}) -> {col, 0};
 remove_line_numbers([H|T]) ->

test/aeso_scan_tests.erl

@@ -41,14 +41,14 @@ all_tokens() ->
     %% Operators
     lists:map(Lit, ['=', '==', '!=', '>', '<', '>=', '=<', '-', '+', '++', '*', '/', mod, ':', '::', '->', '=>', '||', '&&', '!']) ++
     %% Keywords
-    lists:map(Lit, [contract, type, 'let', switch]) ++
+    lists:map(Lit, [contract, type, 'let', switch, rec, 'and']) ++
     %% 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(bytes, Hash)
+    , Tok(hash, 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({bytes, _, <<N:256>>}) -> fmt("#~64.16.0b", N);
+show_token({hash, _, <<N:256>>}) -> fmt("#~.16b", N);
 show_token({comment, _, S}) -> S;
 show_token({_, _, _}) -> "TODO".
 

test/contract_tests.erl

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

@@ -1,5 +0,0 @@
-
-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) : unit =
+  public function do_abort(v : int, s : string) : () =
     put_value(v)
     revert_abort(s)
 

test/contracts/abort_test_int.aes

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

test/contracts/address_chain.aes

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

@@ -1,14 +0,0 @@
-
-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,54 +3,53 @@ contract AENSTest =
 
   // Name resolution
 
-  stateful entrypoint resolve_word(name : string, key : string) : option(address) =
+  function resolve_word(name : string, key : string) : option(address) =
     AENS.resolve(name, key)
 
-  stateful entrypoint resolve_string(name : string, key : string) : option(string) =
+  function resolve_string(name : string, key : string) : option(string) =
     AENS.resolve(name, key)
 
   // Transactions
 
-  stateful entrypoint preclaim(addr  : address,     // Claim on behalf of this account (can be Contract.address)
-                             chash : hash) : unit = // Commitment hash
+  function preclaim(addr  : address,          // Claim on behalf of this account (can be Contract.address)
+                    chash : hash) : () =      // Commitment hash
     AENS.preclaim(addr, chash)
 
-  stateful entrypoint signedPreclaim(addr  : address, // Claim on behalf of this account (can be Contract.address)
-                                   chash : hash,             // Commitment hash
-                                   sign  : signature) : unit = // Signed by addr (if not Contract.address)
+  function signedPreclaim(addr  : address,          // Claim on behalf of this account (can be Contract.address)
+                          chash : hash,             // Commitment hash
+                          sign  : signature) : () = // Signed by addr (if not Contract.address)
     AENS.preclaim(addr, chash, signature = sign)
 
-  stateful entrypoint claim(addr : address,
-                          name : string,
-                          salt : int,
-                          name_fee : int) : unit =
-    AENS.claim(addr, name, salt, name_fee)
+  function claim(addr : address,
+                 name : string,
+                 salt : int) : () =
+    AENS.claim(addr, name, salt)
 
-  stateful entrypoint signedClaim(addr : address,
-                                name : string,
-                                salt : int,
-                                name_fee : int,
-                                sign : signature) : unit =
-    AENS.claim(addr, name, salt, name_fee, signature = sign)
+  function signedClaim(addr : address,
+                       name : string,
+                       salt : int,
+                       sign : signature) : () =
+    AENS.claim(addr, name, salt, signature = sign)
 
   // TODO: update() -- how to handle pointers?
 
-  stateful entrypoint transfer(owner     : address,
-                             new_owner : address,
-                             name      : string) : unit =
-    AENS.transfer(owner, new_owner, name)
+  function transfer(owner     : address,
+                    new_owner : address,
+                    name_hash : hash) : () =
+    AENS.transfer(owner, new_owner, name_hash)
 
-  stateful entrypoint signedTransfer(owner     : address,
-                                     new_owner : address,
-                                     name      : string,
-                                     sign      : signature) : unit =
-    AENS.transfer(owner, new_owner, name, signature = sign)
+  function signedTransfer(owner     : address,
+                          new_owner : address,
+                          name_hash : hash,
+                          sign      : signature) : () =
+    AENS.transfer(owner, new_owner, name_hash, signature = sign)
 
-  stateful entrypoint revoke(owner     : address,
-                           name      : string) : unit =
-    AENS.revoke(owner, name)
+  function revoke(owner     : address,
+                  name_hash : hash) : () =
+    AENS.revoke(owner, name_hash)
+
+  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, "false")
+        let _ = require(aetoken.balanceOf(caller()) > 0)
         let proofHash: uint = calculateHash(document)
         let proof : proof = Map.get_(proofHash, state().proofs)
-        let _ = require(proof.owner == #0, "false")
+        let _ = require(proof.owner == #0)
         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, "false")
+        let _ = require(proof.owner != #0)
         proof
 
     function getProofByHash(hash: uint) : proof =
         let proof = Map.get_(hash, state().proofs)
-        let _ = require(proof.owner != #0, "false")
+        let _ = require(proof.owner != #0)
         proof
 
 
@@ -141,3 +141,5 @@ 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,6 +36,11 @@ contract AllSyntax =
       (x, [y, z]) => bar({x = z, y = -y + - -z * (-1)})
       (x, 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

@@ -1,33 +0,0 @@
-
-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_events.aes

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

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

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

test/contracts/bad_init_state_access.aes

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

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

@@ -1,16 +0,0 @@
-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))}
 
-  entrypoint init() = {proofs = {}}
+  public function init() = {proofs = {}}
 
-  stateful entrypoint createProof(hash : string) =
+  public stateful function createProof(hash : string) =
     put( state{ proofs[Call.caller] = hash :: state.proofs[Call.caller] } )
 

test/contracts/builtin_map_get_bug.aes

@@ -1,8 +1,12 @@
 contract TestContract =
-  record state = {_allowed : map(address, map(address, int))}
+  record state = { 
+    _allowed          : map(address, map(address, int))}
 
-  entrypoint init() = {_allowed = {}}
+  public stateful function init() = {
+    _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_equality.aes

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

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

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

test/contracts/complex_types.aes

@@ -1,53 +1,53 @@
 
 contract Remote =
-  entrypoint up_to       : (int)               => list(int)
-  entrypoint sum         : (list(int))         => int
-  entrypoint some_string : ()                  => string
-  entrypoint pair        : (int, string)       => int * string
-  entrypoint squares     : (int)               => list(int * int)
-  entrypoint filter_some : (list(option(int))) => list(int)
-  entrypoint all_some    : (list(option(int))) => option(list(int))
+  function up_to       : (int)               => list(int)
+  function sum         : (list(int))         => int
+  function some_string : ()                  => string
+  function pair        : (int, string)       => (int, string)
+  function squares     : (int)               => list((int, int))
+  function filter_some : (list(option(int))) => list(int)
+  function all_some    : (list(option(int))) => option(list(int))
 
 contract ComplexTypes =
 
   record state = { worker : Remote }
 
-  entrypoint init(worker) = {worker = worker}
+  function init(worker) = {worker = worker}
 
-  entrypoint sum_acc(xs, n) =
+  function sum_acc(xs, n) =
     switch(xs)
       []      => n
       x :: xs => sum_acc(xs, x + n)
 
   // Sum a list of integers
-  entrypoint sum(xs : list(int)) =
+  function sum(xs : list(int)) =
     sum_acc(xs, 0)
 
-  entrypoint up_to_acc(n, xs) =
+  function up_to_acc(n, xs) =
     switch(n)
       0 => xs
       _ => up_to_acc(n - 1, n :: xs)
 
-  entrypoint up_to(n) = up_to_acc(n, [])
+  function up_to(n) = up_to_acc(n, [])
 
   record answer('a) = {label : string, result : 'a}
 
-  entrypoint remote_triangle(worker, n) : answer(int) =
+  function remote_triangle(worker, n) : answer(int) =
     let xs = worker.up_to(gas = 100000, n)
     let t  = worker.sum(xs)
     { label = "answer:", result = t }
 
-  entrypoint remote_list(n) : list(int) =
+  function remote_list(n) : list(int) =
     state.worker.up_to(n)
 
-  entrypoint some_string() = "string"
+  function some_string() = "string"
 
-  entrypoint remote_string() : string =
+  function remote_string() : string =
     state.worker.some_string()
 
-  entrypoint pair(x : int, y : string) = (x, y)
+  function pair(x : int, y : string) = (x, y)
 
-  entrypoint remote_pair(n : int, s : string) : int * string =
+  function remote_pair(n : int, s : string) : (int, string) =
     state.worker.pair(gas = 10000, n, s)
 
   function map(f, xs) =
@@ -55,24 +55,24 @@ contract ComplexTypes =
       []      => []
       x :: xs => f(x) :: map(f, xs)
 
-  entrypoint squares(n) =
+  function squares(n) =
     map((i) => (i, i * i), up_to(n))
 
-  entrypoint remote_squares(n) : list(int * int) =
+  function remote_squares(n) : list((int, int)) =
     state.worker.squares(n)
 
   // option types
 
-  entrypoint filter_some(xs : list(option(int))) : list(int) =
+  function filter_some(xs : list(option(int))) : list(int) =
     switch(xs)
       []            => []
       None    :: ys => filter_some(ys)
       Some(x) :: ys => x :: filter_some(ys)
 
-  entrypoint remote_filter_some(xs : list(option(int))) : list(int) =
+  function remote_filter_some(xs : list(option(int))) : list(int) =
     state.worker.filter_some(xs)
 
-  entrypoint all_some(xs : list(option(int))) : option(list(int)) =
+  function all_some(xs : list(option(int))) : option(list(int)) =
     switch(xs)
       []         => Some([])
       None :: ys => None
@@ -81,6 +81,6 @@ contract ComplexTypes =
           Some(xs) => Some(x :: xs)
           None     => None
 
-  entrypoint remote_all_some(xs : list(option(int))) : option(list(int)) =
+  function remote_all_some(xs : list(option(int))) : option(list(int)) =
     state.worker.all_some(gas = 10000, xs)
 

test/contracts/counter.aes

@@ -3,7 +3,7 @@ contract Counter =
 
   record state = { value : int }
 
-  entrypoint init(val) = { value = val }
-  entrypoint get()     = state.value
-  stateful entrypoint tick()    = put(state{ value = state.value + 1 })
+  function init(val) = { value = val }
+  function get()     = state.value
+  function tick()    = put(state{ value = state.value + 1 })
 

test/contracts/cyclic_include.aes

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

test/contracts/cyclic_include_back.aes

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

test/contracts/cyclic_include_forth.aes

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

test/contracts/deadcode.aes

@@ -1,21 +0,0 @@
-
-namespace MyList =
-
-  function map1(f : 'a => 'b, xs : list('a)) =
-    switch(xs)
-      [] => []
-      x :: xs => f(x) :: map1(f, xs)
-
-  function map2(f : 'a => 'b, xs : list('a)) =
-    switch(xs)
-      [] => []
-      x :: xs => f(x) :: map2(f, xs)
-
-contract Deadcode =
-
-  entrypoint inc1(xs : list(int)) : list(int) =
-    MyList.map1((x) => x + 1, xs)
-
-  entrypoint inc2(xs : list(int)) : list(int) =
-    MyList.map1((x) => x + 1, xs)
-

test/contracts/double_include.aes

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

test/contracts/dutch_auction.aes

@@ -10,13 +10,16 @@ contract DutchAuction =
                    sold         : bool }
 
   // Add to work around current lack of predefined functions
-  stateful function spend(to, amount) =
+  private function spend(to, amount) =
     let total = Contract.balance
     Chain.spend(to, amount)
     total - amount
 
+  private function require(b : bool, err : string) =
+    if(!b) abort(err)
+
   // TTL set by user on posting contract, typically (start - end ) div dec
-  entrypoint init(beneficiary, start, decrease) : state =
+  public function init(beneficiary, start, decrease) : state =
     require(start > 0 && decrease > 0, "bad args")
     { start_amount = start,
       start_height = Chain.block_height,
@@ -27,7 +30,7 @@ contract DutchAuction =
   // -- API
 
   // We are the buyer... interesting case to buy for someone else and keep 10%
-  stateful entrypoint bid() =
+  public stateful function bid() =
     require( !(state.sold), "sold")
     let cost =
       state.start_amount - (Chain.block_height - state.start_height) * state.dec

test/contracts/environment.aes

@@ -1,69 +1,69 @@
 
 // Testing primitives for accessing the block chain environment
 contract Interface =
-  entrypoint contract_address : () => address
-  entrypoint call_origin      : () => address
-  entrypoint call_caller      : () => address
-  entrypoint call_value       : () => int
+  function contract_address : () => address
+  function call_origin      : () => address
+  function call_caller      : () => address
+  function call_value       : () => int
 
 contract Environment =
 
   record state = {remote : Interface}
 
-  entrypoint init(remote) = {remote = remote}
+  function init(remote) = {remote = remote}
 
-  stateful entrypoint set_remote(remote) = put({remote = remote})
+  function set_remote(remote) = put({remote = remote})
 
   // -- Information about the this contract ---
 
   // Address
-  entrypoint contract_address() : address = Contract.address
-  entrypoint nested_address(who) : address =
+  function contract_address() : address = Contract.address
+  function nested_address(who) : address =
     who.contract_address(gas = 1000)
 
   // Balance
-  entrypoint contract_balance() : int = Contract.balance
+  function contract_balance() : int = Contract.balance
 
   // -- Information about the current call ---
 
   // Origin
-  entrypoint call_origin()   : address = Call.origin
-  entrypoint nested_origin() : address =
+  function call_origin()   : address = Call.origin
+  function nested_origin() : address =
     state.remote.call_origin()
 
   // Caller
-  entrypoint call_caller() : address = Call.caller
-  entrypoint nested_caller() : address =
+  function call_caller() : address = Call.caller
+  function nested_caller() : address =
     state.remote.call_caller()
 
   // Value
-  entrypoint call_value() : int = Call.value
-  stateful entrypoint nested_value(value : int) : int =
+  function call_value() : int = Call.value
+  function nested_value(value : int) : int =
     state.remote.call_value(value = value / 2)
 
   // Gas price
-  entrypoint call_gas_price() : int = Call.gas_price
+  function call_gas_price() : int = Call.gas_price
 
   // -- Information about the chain ---
 
   // Account balances
-  entrypoint get_balance(acct : address) : int = Chain.balance(acct)
+  function get_balance(acct : address) : int = Chain.balance(acct)
 
   // Block hash
-  entrypoint block_hash(height : int) : option(hash) = Chain.block_hash(height)
+  function block_hash(height : int) : int = Chain.block_hash(height)
 
   // Coinbase
-  entrypoint coinbase() : address = Chain.coinbase
+  function coinbase() : address = Chain.coinbase
 
   // Block timestamp
-  entrypoint timestamp() : int = Chain.timestamp
+  function timestamp() : int = Chain.timestamp
 
   // Block height
-  entrypoint block_height() : int = Chain.block_height
+  function block_height() : int = Chain.block_height
 
   // Difficulty
-  entrypoint difficulty() : int = Chain.difficulty
+  function difficulty() : int = Chain.difficulty
 
   // Gas limit
-  entrypoint gas_limit() : int = Chain.gas_limit
+  function gas_limit() : int = Chain.gas_limit
 

test/contracts/erc20_token.aes

@@ -77,6 +77,9 @@ contract ERC20Token =
     put( state{approval_log = e :: state.approval_log })
     e
 
+  private function require(b : bool, err : string) =
+    if(!b) abort(err)
+
   private function sub(_a : int, _b : int) : int =
     require(_b =< _a, "Error")
     _a - _b

test/contracts/events.aes

@@ -1,40 +1,22 @@
-contract Remote =
-  entrypoint dummy : () => unit
-
 contract Events =
+  type alias_int = int
+  type alias_address = address
+  type alias_string = string
 
-  // Valid index types
-  type ix1 = int
-  type ix2 = bool
-  type ix3 = bits
-  type ix4 = bytes(12)
-  type ix5 = hash // bytes(32)
-  type ix6 = address
-  type ix7 = Remote
-  type ix8 = oracle(int, int)
-  type ix9 = oracle_query(int, int)
+  datatype event =
+      Event1(indexed alias_int, indexed int, string)
+    | Event2(alias_string, indexed alias_address)
+    // | BadEvent1(indexed string, string)
+    // | BadEvent2(indexed int, int)
 
-  // Valid payload types
-  type data1 = string
-  type data2 = signature  // bytes(64)
-  type data3 = bytes(65)
+  function f1(x : int, y : string) =
+    Chain.event(Event1(x, x+1, y))
 
-  datatype event
-    = Nodata0
-    | Nodata1(ix1)
-    | Nodata2(ix2, ix3)
-    | Nodata3(ix4, ix5, ix6)
-    | Data0(data1)
-    | Data1(data2, ix7)
-    | Data2(ix8, data3, ix9)
-    | Data3(ix1, ix2, ix5, data1)
+  function f2(s : string) =
+    Chain.event(Event2(s, Call.caller))
 
-  entrypoint nodata0()                   = Chain.event(Nodata0)
-  entrypoint nodata1(ix1)                = Chain.event(Nodata1(ix1))
-  entrypoint nodata2(ix2, ix3)           = Chain.event(Nodata2(ix2, ix3))
-  entrypoint nodata3(ix4, ix5, ix6)      = Chain.event(Nodata3(ix4, ix5, ix6))
-  entrypoint data0(data1)                = Chain.event(Data0(data1))
-  entrypoint data1(data2, ix7)           = Chain.event(Data1(data2, ix7))
-  entrypoint data2(ix8, data3, ix9)      = Chain.event(Data2(ix8, data3, ix9))
-  entrypoint data3(ix1, ix2, ix5, data1) = Chain.event(Data3(ix1, ix2, ix5, data1))
+  function f3(x : int) =
+    Chain.event(Event1(x, x + 2, Int.to_str(x + 7)))
 
+  function i2s(i : int) = Int.to_str(i)
+  function a2s(a : address) = Address.to_str(a)

test/contracts/factorial.aes

@@ -1,17 +1,17 @@
 // An implementation of the factorial function where each recursive
 // call is to another contract. Not the cheapest way to compute factorial.
 contract FactorialServer =
-  entrypoint fac : (int) => int
+  function fac : (int) => int
 
 contract Factorial =
 
   record state = {worker : FactorialServer}
 
-  entrypoint init(worker) = {worker = worker}
+  function init(worker) = {worker = worker}
 
-  stateful entrypoint set_worker(worker) = put(state{worker = worker})
+  function set_worker(worker) = put(state{worker = worker})
 
-  entrypoint fac(x : int) : int =
+  function fac(x : int) : int =
     if(x == 0) 1
     else x * state.worker.fac(x - 1)
 

test/contracts/field_parse_error.aes

@@ -1,5 +0,0 @@
-
-contract Fail =
-  record pt = {x : int, y : int}
-  record r  = {p : pt}
-  function fail() = {p.x = 0, p.y = 0}

test/contracts/funargs.aes

@@ -1,47 +0,0 @@
-
-contract FunctionArguments =
-
-  entrypoint sum(n : int, m: int) =
-    n + m
-
-  entrypoint append(xs : list(string)) =
-     switch(xs)
-      []      => ""
-      y :: ys => String.concat(y, append(ys))
-
-  entrypoint menot(b) =
-    !b
-
-  entrypoint bitsum(b : bits) =
-    Bits.sum(b)
-
-  record answer('a) = {label : string, result : 'a}
-
-  entrypoint read(a : answer(int)) =
-     a.result
-
-  entrypoint sjutton(b : bytes(17)) =
-     b
-
-  entrypoint sextiosju(b : bytes(67)) =
-     b
-
-  entrypoint trettiotva(b : bytes(32)) =
-     b
-
-  entrypoint find_oracle(o : oracle(int, bool)) =
-     true
-
-  entrypoint find_query(q : oracle_query(int, bool)) =
-     true
-
-  datatype colour() = Green | Yellow | Red | Pantone(int)
-
-  entrypoint traffic_light(c : colour) =
-     Red
-
-  entrypoint tuples(t : unit) =
-     t
-
-  entrypoint due(t : Chain.ttl) =
-     true

test/contracts/functions.aes

@@ -1,15 +0,0 @@
-contract Functions =
-  function curry(f : ('a, 'b) => 'c) =
-    (x) => (y) => f(x, y)
-  function map(f : 'a => 'b, xs : list('a)) =
-    switch(xs)
-      [] => []
-      x :: xs => f(x) :: map(f, xs)
-  function map'() = map
-  function plus(x, y) = x + y
-  entrypoint test1(xs : list(int)) = map(curry(plus)(5), xs)
-  entrypoint test2(xs : list(int)) = map'()(((x) => (y) => ((x, y) => x + y)(x, y))(100), xs)
-  entrypoint test3(xs : list(int)) =
-    let m(f, xs) = map(f, xs)
-    m((x) => x + 1, xs)
-

test/contracts/fundme.aes

@@ -12,20 +12,23 @@ contract FundMe =
                    deadline      : int,
                    goal          : int }
 
-  stateful function spend(args : spend_args) =
+  private function require(b : bool, err : string) =
+    if(!b) abort(err)
+
+  private function spend(args : spend_args) =
     Chain.spend(args.recipient, args.amount)
 
-  entrypoint init(beneficiary, deadline, goal) : state =
+  public function init(beneficiary, deadline, goal) : state =
     { contributions = {},
       beneficiary   = beneficiary,
       deadline      = deadline,
       total         = 0,
       goal          = goal }
 
-  function is_contributor(addr) =
+  private function is_contributor(addr) =
     Map.member(addr, state.contributions)
 
-  stateful entrypoint contribute() =
+  public stateful function contribute() =
     if(Chain.block_height >= state.deadline)
       spend({ recipient = Call.caller, amount = Call.value }) // Refund money
       false
@@ -36,7 +39,7 @@ contract FundMe =
                  total @ tot = tot + Call.value })
       true
 
-  stateful entrypoint withdraw() =
+  public stateful function withdraw() =
     if(Chain.block_height < state.deadline)
       abort("Cannot withdraw before deadline")
     if(Call.caller == state.beneficiary)
@@ -46,13 +49,13 @@ contract FundMe =
     else
       abort("Not a contributor or beneficiary")
 
-  stateful function withdraw_beneficiary() =
+  private stateful function withdraw_beneficiary() =
     require(state.total >= state.goal, "Project was not funded")
     spend({recipient = state.beneficiary,
            amount    = Contract.balance })
-    put(state{ beneficiary = ak_11111111111111111111111111111111273Yts })
+    put(state{ beneficiary = #0 })
 
-  stateful function withdraw_contributor() =
+  private stateful function withdraw_contributor() =
     if(state.total >= state.goal)
       abort("Project was funded")
     let to = Call.caller

test/contracts/identity.aes

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

test/contracts/include.aes

@@ -1,9 +0,0 @@
-include "included.aes"
-include "../contracts/included2.aes"
-
-contract Include =
-  entrypoint foo() =
-    Included.foo() < Included2a.bar()
-
-  entrypoint bar() =
-    Included2b.foo() > Included.foo()

test/contracts/included.aes

@@ -1,2 +0,0 @@
-namespace Included =
-  function foo() = 42

test/contracts/included2.aes

@@ -1,5 +0,0 @@
-namespace Included2a =
-  function bar() = 43
-
-namespace Included2b =
-  function foo() = 44

test/contracts/init_type_error.aes

@@ -3,6 +3,6 @@ contract InitTypeError =
 
   type state = map(int, int)
 
-  // Check that the compiler catches ill-typed init entrypoint
-  entrypoint init() = "not the right type!"
+  // Check that the compiler catches ill-typed init function
+  function init() = "not the right type!"
 

test/contracts/list_comp.aes

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

test/contracts/list_comp_bad_shadow.aes

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

test/contracts/list_comp_if_not_bool.aes

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

test/contracts/list_comp_not_a_list.aes

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

test/contracts/local_poly_fail.aes

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