Merge pull request #81 from aeternity/PT-166406414-v3.1.0

Prepare v3.1.0

.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:

.gitignore

@@ -18,3 +18,4 @@ _build
 rebar3.crashdump
 *.erl~
 *.aes~
+aesophia

CHANGELOG.md

@@ -0,0 +1,78 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+### Added
+### Changed
+### Removed
+
+## [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/v3.1.0...HEAD
+[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,8 +9,17 @@ 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

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

docs/aeso_compiler.md

@@ -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 => string(),
+                   compiler_version => binary(),
                    contract_souce => string(),
                    type_info => type_info()}
 type_info()
@@ -75,12 +75,12 @@ Types
 
 Get the type representation of a type declaration.
 
-#### version() -> Version
+#### version() -> {ok, Version} | {error, term()}
 
 Types
 
 ``` erlang
-Version = integer()
+Version = binary()
 ```
 
 Get the current version of the Sophia compiler.

include/aeso_heap.hrl

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

rebar.config

@@ -1,27 +1,23 @@
+%% -*- mode: erlang; indent-tabs-mode: nil -*-
+
 {erl_opts, [debug_info]}.
 
-{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git",
-                            {ref,"720510a"}}}
+{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git", {ref, "f129887"}}}
        , {getopt, "1.0.1"}
+       , {jsx, {git, "https://github.com/talentdeficit/jsx.git",
+                     {tag, "2.8.0"}}}
        ]}.
 
-{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, "3.1.0"},
+         [aesophia, aebytecode, getopt]},
+
+        {dev_mode, true},
+        {include_erts, false},
+
+        {extended_start_script, true}]}.

rebar.lock

@@ -1,10 +1,24 @@
 {"1.1.0",
 [{<<"aebytecode">>,
   {git,"https://github.com/aeternity/aebytecode.git",
-       {ref,"720510a24de32c9bad6486f34ca7babde124bf1e"}},
+       {ref,"f1298870e526f4e9330447d3a281af5ef4e06e17"}},
   0},
- {<<"getopt">>,{pkg,<<"getopt">>,<<"1.0.1">>},0}]}.
+ {<<"aeserialization">>,
+  {git,"https://github.com/aeternity/aeserialization.git",
+       {ref,"816bf994ffb5cee218c3f22dc5fea296c9e0882e"}},
+  1},
+ {<<"base58">>,
+  {git,"https://github.com/aeternity/erl-base58.git",
+       {ref,"60a335668a60328a29f9731b67c4a0e9e3d50ab6"}},
+  2},
+ {<<"eblake2">>,{pkg,<<"eblake2">>,<<"1.0.0">>},1},
+ {<<"getopt">>,{pkg,<<"getopt">>,<<"1.0.1">>},0},
+ {<<"jsx">>,
+  {git,"https://github.com/talentdeficit/jsx.git",
+       {ref,"3074d4865b3385a050badf7828ad31490d860df5"}},
+  0}]}.
 [
 {pkg_hash,[
+ {<<"eblake2">>, <<"EC8AD20E438AAB3F2E8D5D118C366A0754219195F8A0F536587440F8F9BCF2EF">>},
  {<<"getopt">>, <<"C73A9FA687B217F2FF79F68A3B637711BB1936E712B521D8CE466B29CBF7808A">>}]}
 ].

src/aeso_abi.erl

@@ -1,239 +0,0 @@
-%%%-------------------------------------------------------------------
-%%% @copyright (C) 2017, Aeternity Anstalt
-%%% @doc
-%%%     Encode and decode data and function calls according to
-%%%     Sophia-AEVM-ABI.
-%%% @end
-%%% Created : 25 Jan 2018
-%%%
-%%%-------------------------------------------------------------------
--module(aeso_abi).
--define(HASH_SIZE, 32).
-
--export([ old_create_calldata/3
-        , create_calldata/5
-        , check_calldata/2
-        , function_type_info/3
-        , function_type_hash/3
-        , arg_typerep_from_function/2
-        , type_hash_from_function_name/2
-        , typereps_from_type_hash/2
-        , function_name_from_type_hash/2
-        , get_function_hash_from_calldata/1
-        ]).
-
--type hash() :: <<_:256>>. %% 256 = ?HASH_SIZE * 8.
--type function_name() :: binary(). %% String
--type typerep() :: aeso_sophia:type().
--type function_type_info() :: { FunctionHash :: hash()
-                              , FunctionName :: function_name()
-                              , ArgType      :: 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

@@ -0,0 +1,339 @@
+%%%-------------------------------------------------------------------
+%%% @author Robert Virding
+%%% @copyright (C) 2019, Aeternity Anstalt
+%%% @doc
+%%%     ACI interface
+%%% @end
+%%% Created : 12 Jan 2019
+%%%-------------------------------------------------------------------
+
+-module(aeso_aci).
+
+-export([ 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 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) ->
+    C0 = #{name => encode_name(contract_name(Contract))},
+
+    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)),
+                 not is_private(F) ],
+
+    #{contract => C3#{functions => Fdefs}}.
+
+%%  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)};
+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)}.
+
+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) || #{contract := C} <- Contracts ],
+    {ok, list_to_binary(string:join(DecodedContracts, "\n"))}.
+
+decode_contract(#{name := Name,
+                  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,
+    ["contract"," ",io_lib:format("~s", [Name])," =\n",
+     decode_tdefs(Ts), decode_funcs(Fs)].
+
+decode_funcs(Fs) -> [ decode_func(F) || F <- Fs ].
+
+%% decode_func(#{name := init}) -> [];
+decode_func(#{name := Name, arguments := As, returns := T}) ->
+    ["  function", " ", 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),
+    [$(,lists:join(",", Ts),$)];
+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]).
+
+%% #contract{Ann, Con, [Declarations]}.
+
+contract_name({contract, _, {con, _, Name}, _})  -> Name;
+contract_name({namespace, _, {con, _, Name}, _}) -> Name.
+
+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_private(Node) -> aeso_syntax:get_ann(private, Node, false).
+is_stateful(Node) -> aeso_syntax:get_ann(stateful, 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,7 +17,6 @@ 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,11 +17,19 @@
 
 -spec convert_typed(aeso_syntax:ast(), list()) -> aeso_icode:icode().
 convert_typed(TypedTree, Options) ->
-    code(TypedTree, aeso_icode:new(Options)).
+    Name = case lists:last(TypedTree) of
+               {contract, _, {con, _, Con}, _} -> Con;
+               _ -> gen_error(last_declaration_must_be_contract)
+           end,
+    Icode = code(TypedTree, aeso_icode:set_name(Name, aeso_icode:new(Options))),
+    deadcode_elimination(Icode).
 
-code([{contract, _Attribs, {con, _, Name}, Code}|Rest], Icode) ->
-    NewIcode = contract_to_icode(Code,
-                                 aeso_icode:set_name(Name, Icode)),
+code([{contract, _Attribs, Con, Code}|Rest], Icode) ->
+    NewIcode = contract_to_icode(Code, aeso_icode:set_namespace(Con, Icode)),
+    code(Rest, NewIcode);
+code([{namespace, _Ann, Name, Code}|Rest], Icode) ->
+                                            %% TODO: nested namespaces
+    NewIcode = contract_to_icode(Code, aeso_icode:set_namespace(Name, Icode)),
     code(Rest, NewIcode);
 code([], Icode) ->
     add_default_init_function(add_builtins(Icode)).
@@ -33,30 +41,38 @@ gen_error(Error) ->
 
 %% Create default init function (only if state is unit).
 add_default_init_function(Icode = #{functions := Funs, state_type := State}) ->
-    case lists:keymember("init", 1, Funs) of
+    {_, _, QInit} = aeso_icode:qualify({id, [], "init"}, Icode),
+    case lists:keymember(QInit, 1, Funs) of
         true -> 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 = {"init", [], [], Value, Type},
+            DefaultInit = {QInit, [], [], Value, Type},
             Icode#{ functions => [DefaultInit | Funs] }
     end.
 
 -spec contract_to_icode(aeso_syntax:ast(), aeso_icode:icode()) ->
                                aeso_icode:icode().
-contract_to_icode([{type_def, _Attrib, {id, _, Name}, Args, Def} | Rest],
+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],
                   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, _, {con, _, C}, _}) -> C end,
-                maps:from_list([ {GetName(Con), Tag} || {Tag, Con} <- lists:zip(Tags, Cons) ]);
+                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) ]);
             _ -> #{}
         end,
-    Icode1 = Icode#{ types := Types#{ Name => TypeDef },
+    {_, _, TName} = aeso_icode:qualify(Id, Icode),
+    Icode1 = Icode#{ types := Types#{ TName => TypeDef },
                      constructors := maps:merge(Constructors, NewConstructors) },
     Icode2 = case Name of
                 "state" when Args == [] -> Icode1#{ state_type => ast_typerep(Def, Icode) };
@@ -68,8 +84,7 @@ contract_to_icode([{type_def, _Attrib, {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) ] ++
-               [ private  || proplists:get_value(private, Attrib, false) orelse
-                             proplists:get_value(internal, Attrib, false) ],
+               [ private  || is_private(Attrib, Icode) ],
     %% TODO: Handle types
     FunName = ast_id(Name),
     %% TODO: push funname to env
@@ -84,21 +99,18 @@ contract_to_icode([{letfun, Attrib, Name, Args, _What, Body={typed,_,_,T}}|Rest]
                  {tuple, [typerep, ast_typerep(T, Icode)]}};
             _ -> {ast_body(Body, Icode), ast_typerep(T, Icode)}
         end,
-    NewIcode = ast_fun_to_icode(FunName, FunAttrs, FunArgs, FunBody, TypeRep, Icode),
+    QName    = aeso_icode:qualify(Name, Icode),
+    NewIcode = ast_fun_to_icode(ast_id(QName), 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(_Code, Icode) ->
-    %% TODO debug output for debug("Unhandled code ~p~n",[Code]),
-    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).
 
-ast_id({id, _, Id}) -> Id.
+ast_id({id, _, Id}) -> Id;
+ast_id({qid, _, Id}) -> Id.
 
 ast_args([{arg, _, Name, Type}|Rest], Acc, Icode) ->
     ast_args(Rest, [{ast_id(Name), ast_type(Type, Icode)}| Acc], Icode);
@@ -121,7 +133,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(["Chain","event"], [Event], _, _), Icode) ->
+ast_body(?qid_app([Con, "Chain", "event"], [Event], _, _), Icode = #{ contract_name := Con }) ->
     aeso_builtins:check_event_type(Icode),
     builtin_call({event, maps:get(event_type, Icode)}, [ast_body(Event, Icode)]);
 
@@ -133,6 +145,7 @@ ast_body(?qid_app(["Chain", "block_hash"], [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;
@@ -152,16 +165,20 @@ ast_body({qid, _, ["Chain", "spend"]}, _Icode) ->
     gen_error({underapplied_primitive, 'Chain.spend'});
 
 %% State
-ast_body({id, _, "state"}, _Icode) -> prim_state;
-ast_body(?id_app("put", [NewState], _, _), Icode) ->
+ast_body({qid, _, [Con, "state"]}, #{ contract_name := Con }) -> prim_state;
+ast_body(?qid_app([Con, "put"], [NewState], _, _), Icode = #{ contract_name := Con }) ->
     #prim_put{ state = ast_body(NewState, Icode) };
-ast_body({id, _, "put"}, _Icode) ->
+ast_body({qid, _, [Con, "put"]}, #{ contract_name := Con }) ->
     gen_error({underapplied_primitive, put});   %% TODO: eta
 
 %% Abort
 ast_body(?id_app("abort", [String], _, _), Icode) ->
-    #funcall{ function = #var_ref{ name = {builtin, abort} },
-              args     = [ast_body(String, Icode)] };
+    builtin_call(abort, [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));
 
 %% Oracles
 ast_body(?qid_app(["Oracle", "register"], Args, _, ?oracle_t(QType, RType)), Icode) ->
@@ -200,6 +217,17 @@ 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'});
@@ -322,6 +350,11 @@ ast_body(?qid_app(["Crypto", "ecverify"], [Msg, PK, Sig], _, _), Icode) ->
               [ast_body(Msg, Icode), ast_body(PK, Icode), ast_body(Sig, Icode)],
               [word, word, sign_t()], word);
 
+ast_body(?qid_app(["Crypto", "ecverify_secp256k1"], [Msg, PK, Sig], _, _), Icode) ->
+    prim_call(?PRIM_CALL_CRYPTO_ECVERIFY_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", "sha3"], [Term], [Type], _), Icode) ->
     generic_hash_primop(?PRIM_CALL_CRYPTO_SHA3, Term, Type, Icode);
 ast_body(?qid_app(["Crypto", "sha256"], [Term], [Type], _), Icode) ->
@@ -336,13 +369,11 @@ ast_body(?qid_app(["String", "blake2b"], [String], _, _), Icode) ->
 %% Strings
 %% -- String length
 ast_body(?qid_app(["String", "length"], [String], _, _), Icode) ->
-    #funcall{ function = #var_ref{ name = {builtin, string_length} },
-              args     = [ast_body(String, Icode)] };
+    builtin_call(string_length, [ast_body(String, Icode)]);
 
 %% -- String concat
 ast_body(?qid_app(["String", "concat"], [String1, String2], _, _), Icode) ->
-    #funcall{ function = #var_ref{ name = {builtin, string_concat} },
-              args     = [ast_body(String1, Icode), ast_body(String2, Icode)] };
+    builtin_call(string_concat, [ast_body(String1, Icode), ast_body(String2, Icode)]);
 
 %% -- String hash (sha3)
 ast_body(?qid_app(["String", "sha3"], [String], _, _), Icode) ->
@@ -381,26 +412,36 @@ 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);
 
 %% Other terms
 ast_body({id, _, Name}, _Icode) ->
-    %% TODO Look up id in env
+    #var_ref{name = Name};
+ast_body({qid, _, Name}, _Icode) ->
     #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({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}]}
+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]}
     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) | aeso_memory:binary_to_words(Bin)],
+    Cpts = [size(Bin) | aeb_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]};
@@ -424,7 +465,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>> = aeso_abi:function_type_hash(list_to_binary(FunName), ArgType, OutType),
+    <<TypeHash:256>> = aeb_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{
@@ -441,9 +482,15 @@ 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,As,Fun,Args}, Icode) ->
@@ -473,6 +520,8 @@ 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) ->
@@ -540,19 +589,30 @@ 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)};
-        string ->
+        OtherType ->
             Neg = case Op of
                     '==' -> fun(X) -> X end;
                     '!=' -> fun(X) -> #unop{ op = '!', rand = X } end;
                     _    -> gen_error({cant_compare, Ann, Op, Type})
                   end,
-            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})
+            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)
     end;
 ast_binop('++', _, A, B, Icode) ->
-    #funcall{ function = #var_ref{ name = {builtin, list_concat} },
-              args     = [ast_body(A, Icode), ast_body(B, Icode)] };
+    builtin_call(list_concat, [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)}.
 
@@ -619,7 +679,7 @@ prim_call(Prim, Amount, Args, ArgTypes, OutType) ->
             true ->
                 PrimBin = binary:encode_unsigned(Prim),
                 ArgType = {tuple, ArgTypes},
-                <<TH:256>> = aeso_abi:function_type_hash(PrimBin, ArgType, OutType),
+                <<TH:256>> = aeb_abi:function_type_hash(PrimBin, ArgType, OutType),
                 TH;
             false ->
                 0
@@ -648,7 +708,7 @@ make_type_def(Args, Def, Icode = #{ type_vars := TypeEnv }) ->
         ast_typerep(Def, Icode#{ type_vars := maps:merge(TypeEnv, TypeEnv1) })
     end.
 
--spec ast_typerep(aeso_syntax:type()) -> aeso_sophia:type().
+-spec ast_typerep(aeso_syntax:type()) -> aeb_aevm_data:type().
 ast_typerep(Type) -> ast_typerep(Type, aeso_icode:new([])).
 
 ast_typerep({id, _, Name}, Icode) ->
@@ -657,6 +717,8 @@ ast_typerep({qid, _, Name}, Icode) ->
     lookup_type_id(Name, [], Icode);
 ast_typerep({con, _, _}, _) ->
     word;   %% Contract type
+ast_typerep({bytes_t, _, Len}, _) ->
+    bytes_t(Len);
 ast_typerep({app_t, _, {id, _, Name}, Args}, Icode) ->
     ArgReps = [ ast_typerep(Arg, Icode) || Arg <- Args ],
     lookup_type_id(Name, ArgReps, Icode);
@@ -684,8 +746,9 @@ ast_typerep({variant_t, Cons}, Icode) ->
 ttl_t(Icode) ->
     ast_typerep({qid, [], ["Chain", "ttl"]}, Icode).
 
-sign_t() ->
-    {tuple, [word, word]}.
+sign_t() -> bytes_t(64).
+bytes_t(Len) when Len =< 32 -> word;
+bytes_t(Len)                -> {tuple, lists:duplicate((31 + Len) div 32, word)}.
 
 get_signature_arg(Args0) ->
     NamedArgs = [Arg || Arg = {named_arg, _, _, _} <- Args0],
@@ -745,6 +808,15 @@ 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 marked 'private' or 'internal', 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),
+    proplists:get_value(private,  Ann, false) orelse
+    proplists:get_value(internal, Ann, false) orelse
+    MainContract /= CurrentNamespace.
+
 %% -------------------------------------------------------------------
 %% Builtins
 %% -------------------------------------------------------------------
@@ -756,3 +828,39 @@ 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

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

@@ -94,7 +94,7 @@ 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)],
+    Cpts = [size(BinStr) | aeb_memory:binary_to_words(BinStr)],
     #tuple{ cpts = [ #integer{value = X} || X <- Cpts ] }.
 
 check_event_type(Icode) ->
@@ -106,21 +106,22 @@ check_event_type(Icode) ->
     end.
 
 check_event_type(Evts, Icode) ->
-    [ check_event_type(Name, T, Icode)
-      || {constr_t, _, {con, _, Name}, Types} <- Evts, T <- Types ].
+    [ 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(EvtName, Type, Icode) ->
+check_event_type(EvtName, Ix, Type, Icode) ->
     VMType =
         try
            aeso_ast_to_icode:ast_typerep(Type, Icode)
         catch _:_ ->
             error({EvtName, could_not_resolve_type, Type})
         end,
-    case aeso_syntax:get_ann(indexed, Type, false) of
-        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})
+    case {Ix, VMType} of
+        {indexed, word}      -> ok;
+        {notindexed, string} -> ok;
+        {indexed, _}         -> error({EvtName, indexed_field_should_be_word, is, VMType});
+        {notindexed, _}      -> error({EvtName, payload_should_be_string, is, VMType})
     end.
 
 bfun(B, {IArgs, IExpr, IRet}) ->
@@ -169,16 +170,15 @@ 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]};
            ([V]) -> {seq, [V, {inline_asm, [A(?DUP1), A(?MLOAD),                  %% length, ptr
                                             A(?SWAP1), A(?PUSH1), 32, A(?ADD)]}]} %% ptr+32, length
         end,
     Clause =
-        fun(_Tag, {con, _, Con}, Types) ->
-            Indexed   = [ Var || {Var, Type} <- lists:zip(ArgPats(Types), Types),
-                                 IsIndexed(Type) ],
+        fun(_Tag, {con, _, Con}, IxTypes) ->
+            Types     = [ T || {_Ix, T} <- IxTypes ],
+            Indexed   = [ Var || {Var, {indexed, _Type}} <- lists:zip(ArgPats(Types), IxTypes) ],
             EvtIndex  = {unop, 'sha3', str_to_icode(Con)},
             {event, lists:reverse(Indexed) ++ [EvtIndex], Payload(ArgPats(Types) -- Indexed)}
         end,
@@ -189,8 +189,8 @@ builtin_event(EventT) ->
 
     {[{"e", event}],
      {switch, v(e),
-         [{Pat(Tag, Types), Clause(Tag, Con, Types)}
-          || {Tag, {constr_t, _, Con, Types}} <- lists:zip(Tags, Cons) ]},
+         [{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) ]},
      {tuple, []}}.
 
 %% Abort primitive.

src/aeso_compiler.erl

@@ -11,70 +11,79 @@
 -export([ file/1
         , file/2
         , from_string/2
-        , check_call/2
+        , check_call/4
         , create_calldata/3
         , version/0
         , sophia_type_to_typerep/1
+        , to_sophia_value/4
+        , to_sophia_value/5
+        , decode_calldata/3
+        , parse/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.
+-type option() :: pp_sophia_code
+                | pp_ast
+                | pp_types
+                | pp_typed_ast
+                | pp_icode
+                | pp_assembler
+                | pp_bytecode
+                | {include, {file_system, [string()]} |
+                            {explicit_files, #{string() => binary()}}}
+                | {src_file, string()}.
 -type options() :: [option()].
 
 -export_type([ option/0
              , options/0
              ]).
 
--define(COMPILER_VERSION_1, 1).
--define(COMPILER_VERSION_2, 2).
-
--define(COMPILER_VERSION, ?COMPILER_VERSION_2).
-
--spec version() -> pos_integer().
+-spec version() -> {ok, binary()} | {error, term()}.
 version() ->
-    ?COMPILER_VERSION.
+    case lists:keyfind(aesophia, 1, application:loaded_applications()) of
+        false ->
+            case application:load(aesophia) of
+                ok ->
+                    case application:get_key(aesophia, vsn) of
+                        {ok, VsnString} ->
+                            {ok, list_to_binary(VsnString)};
+                        undefined ->
+                            {error, failed_to_load_aesophia}
+                    end;
+                Err = {error, _} ->
+                    Err
+            end;
+        {_App, _Des, VsnString} ->
+            {ok, list_to_binary(VsnString)}
+    end.
 
 -spec file(string()) -> {ok, map()} | {error, binary()}.
 file(Filename) ->
-    file(Filename, []).
+    Dir = filename:dirname(Filename),
+    {ok, Cwd} = file:get_cwd(),
+    file(Filename, [{include, {file_system, [Cwd, Dir]}}]).
 
 -spec file(string(), options()) -> {ok, map()} | {error, binary()}.
 file(File, Options) ->
     case read_contract(File) of
-        {ok, Bin} -> from_string(Bin, Options);
+        {ok, Bin} -> from_string(Bin, [{src_file, File} | Options]);
         {error, Error} ->
 	    ErrorString = [File,": ",file:format_error(Error)],
 	    {error, join_errors("File errors", [ErrorString], fun(E) -> E end)}
     end.
 
 -spec from_string(binary() | string(), options()) -> {ok, map()} | {error, binary()}.
-from_string(ContractBin, Options) when is_binary(ContractBin) ->
-    from_string(binary_to_list(ContractBin), Options);
-from_string(ContractString, Options) ->
+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) ->
     try
-        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
-              }}
+        from_string1(Backend, ContractString, Options)
     catch
         %% The compiler errors.
         error:{parse_errors, Errors} ->
@@ -87,38 +96,88 @@ from_string(ContractString, Options) ->
         %% General programming errors in the compiler just signal error.
     end.
 
+from_string1(aevm, ContractString, Options) ->
+    #{icode := Icode} = string_to_icode(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
+          }};
+from_string1(fate, ContractString, Options) ->
+    Ast       = parse(ContractString, Options),
+    TypedAst  = aeso_ast_infer_types:infer(Ast, Options),
+    FCode     = aeso_ast_to_fcode:ast_to_fcode(TypedAst, Options),
+    {ok, aeso_fcode_to_fate:compile(FCode, Options)}.
+
+-spec string_to_icode(string(), [option()]) -> map().
+string_to_icode(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),
+    Icode = ast_to_icode(TypedAst, Options),
+    pp_icode(Icode, Options),
+    #{ typed_ast => TypedAst,
+       type_env  => TypeEnv,
+       icode     => Icode }.
+
 join_errors(Prefix, Errors, Pfun) ->
     Ess = [ Pfun(E) || E <- Errors ],
     list_to_binary(string:join([Prefix|Ess], "\n")).
 
--define(CALL_NAME, "__call").
+-define(CALL_NAME,   "__call").
+-define(DECODE_NAME, "__decode").
 
 %% Takes a string containing a contract with a declaration/prototype of a
-%% function (foo, say) and a function __call() = foo(args) calling this
+%% function (foo, say) and adds function __call() = foo(args) calling this
 %% function. Returns the name of the called functions, typereps and Erlang
 %% terms for the arguments.
--spec check_call(string(), options()) -> {ok, string(), {[Type], Type | any}, [term()]} | {error, term()}
+%% NOTE: Special treatment for "init" since it might be implicit and has
+%%       a special return type (typerep, T)
+-spec check_call(string(), string(), [string()], options()) -> {ok, string(), {[Type], Type}, [term()]} | {error, term()}
     when Type :: term().
-check_call(ContractString, Options) ->
+check_call(Source, "init" = FunName, Args, Options) ->
+    PatchFun = fun(T) -> {tuple, [typerep, T]} end,
+    case check_call(Source, FunName, Args, Options, PatchFun) of
+        Err = {error, _} when Args == [] ->
+            %% Try with default init-function
+            case check_call(insert_init_function(Source, Options), FunName, Args, Options, PatchFun) of
+                {error, _} -> Err; %% The first error is most likely better...
+                Res        -> Res
+            end;
+        Res ->
+            Res
+    end;
+check_call(Source, FunName, Args, Options) ->
+    PatchFun = fun(T) -> T end,
+    check_call(Source, FunName, Args, Options, PatchFun).
+
+check_call(ContractString0, FunName, Args, Options, PatchFun) ->
     try
-        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]),
+        %% First check the contract without the __call function
+        #{} = string_to_icode(ContractString0, Options),
+        ContractString = insert_call_function(ContractString0, FunName, Args, Options),
+        #{typed_ast := TypedAst,
+          icode     := Icode} = string_to_icode(ContractString, Options),
         {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}
+        {ok, FunName, {ArgVMTypes, PatchFun(RetVMType)}, ArgTerms}
     catch
         error:{parse_errors, Errors} ->
             {error, join_errors("Parse errors", Errors, fun (E) -> E end)};
@@ -132,44 +191,205 @@ check_call(ContractString, Options) ->
                                 fun (E) -> io_lib:format("~p", [E]) end)}
     end.
 
--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);
+%% Add the __call function to a contract.
+-spec insert_call_function(string(), string(), [string()], options()) -> string().
+insert_call_function(Code, FunName, Args, Options) ->
+    Ast = parse(Code, Options),
+    Ind = last_contract_indent(Ast),
+    lists:flatten(
+        [ Code,
+          "\n\n",
+          lists:duplicate(Ind, " "),
+          "stateful function __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, " "), "function 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, []).
+
+-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 aeb_heap:from_binary(string, Data) of
+        {ok, Err} -> {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}};
         {error, _} = Err -> Err
     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)
+to_sophia_value(ContractString, FunName, ok, Data, Options) ->
+    try
+        #{ typed_ast := TypedAst,
+           type_env  := TypeEnv,
+           icode     := Icode } = string_to_icode(ContractString, Options),
+        {ok, _, Type0} = get_decode_type(FunName, TypedAst),
+        Type   = aeso_ast_infer_types:unfold_types_in_type(TypeEnv, Type0, [unfold_record_types, unfold_variant_types]),
+        VmType = aeso_ast_to_icode:ast_typerep(Type, Icode),
+        case aeb_heap:from_binary(VmType, Data) of
+            {ok, VmValue} ->
+                try
+                    {ok, translate_vm_value(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
+    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.
+
+address_literal(Type, N) -> {Type, [], <<N:256>>}.
+
+%% TODO: somewhere else
+-spec translate_vm_value(aeb_aevm_data:type(), aeso_syntax:type(), aeb_aevm_data:data()) -> aeso_syntax:expr().
+translate_vm_value(word, {id, _, "address"},                     N) -> address_literal(account_pubkey, N);
+translate_vm_value(word, {app_t, _, {id, _, "oracle"}, _},       N) -> address_literal(oracle_pubkey, N);
+translate_vm_value(word, {app_t, _, {id, _, "oracle_query"}, _}, N) -> address_literal(oracle_query_id, N);
+translate_vm_value(word, {con, _, _Name},                        N) -> address_literal(contract_pubkey, N);
+translate_vm_value(word, {id, _, "int"},     N) -> <<N1:256/signed>> = <<N:256>>, {int, [], N1};
+translate_vm_value(word, {id, _, "bits"},    N) -> error({todo, bits, N});
+translate_vm_value(word, {id, _, "bool"},    N) -> {bool, [], N /= 0};
+translate_vm_value(word, {bytes_t, _, Len}, Val) when Len =< 32 ->
+    {bytes, [], <<Val:Len/unit:8>>};
+translate_vm_value({tuple, _}, {bytes_t, _, Len}, Val) ->
+    {bytes, [], binary:part(<< <<W:32/unit:8>> || W <- tuple_to_list(Val) >>, 0, Len)};
+translate_vm_value(string, {id, _, "string"}, S) -> {string, [], S};
+translate_vm_value({list, VmType}, {app_t, _, {id, _, "list"}, [Type]}, List) ->
+    {list, [], [translate_vm_value(VmType, Type, X) || X <- List]};
+translate_vm_value({option, VmType}, {app_t, _, {id, _, "option"}, [Type]}, Val) ->
+    case Val of
+        none              -> {con, [], "None"};
+        {some, X}         -> {app, [], {con, [], "Some"}, [translate_vm_value(VmType, Type, X)]}
+    end;
+translate_vm_value({variant, [[], [VmType]]}, {app_t, _, {id, _, "option"}, [Type]}, Val) ->
+    case Val of
+        {variant, 0, []}  -> {con, [], "None"};
+        {variant, 1, [X]} -> {app, [], {con, [], "Some"}, [translate_vm_value(VmType, Type, X)]}
+    end;
+translate_vm_value({tuple, VmTypes}, {tuple_t, _, Types}, Val)
+        when length(VmTypes) == length(Types),
+             length(VmTypes) == tuple_size(Val) ->
+    {tuple, [], [translate_vm_value(VmType, Type, X)
+                 || {VmType, Type, X} <- lists:zip3(VmTypes, Types, tuple_to_list(Val))]};
+translate_vm_value({tuple, VmTypes}, {record_t, Fields}, Val)
+        when length(VmTypes) == length(Fields),
+             length(VmTypes) == tuple_size(Val) ->
+    {record, [], [ {field, [], [{proj, [], FName}], translate_vm_value(VmType, FType, X)}
+                   || {VmType, {field_t, _, FName, FType}, X} <- lists:zip3(VmTypes, Fields, tuple_to_list(Val)) ]};
+translate_vm_value({map, VmKeyType, VmValType}, {app_t, _, {id, _, "map"}, [KeyType, ValType]}, Map)
+        when is_map(Map) ->
+    {map, [], [ {translate_vm_value(VmKeyType, KeyType, Key),
+                 translate_vm_value(VmValType, ValType, Val)}
+                || {Key, Val} <- maps:to_list(Map) ]};
+translate_vm_value({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),
+    translate_vm_value(VmTypes, ConType, Args);
+translate_vm_value(VmTypes, {constr_t, _, Con, Types}, Args)
+        when length(VmTypes) == length(Types),
+             length(VmTypes) == length(Args) ->
+    {app, [], Con, [ translate_vm_value(VmType, Type, Arg)
+                     || {VmType, Type, Arg} <- lists:zip3(VmTypes, Types, Args) ]};
+translate_vm_value(_VmType, _Type, _Data) ->
+    throw(cannot_translate_to_sophia).
+
+-spec create_calldata(string(), string(), [string()]) ->
+                             {ok, binary(), aeb_aevm_data:type(), aeb_aevm_data:type()}
+                             | {error, term()}.
+create_calldata(Code, Fun, Args) ->
+    case check_call(Code, Fun, Args, []) of
+        {ok, FunName, {ArgTypes, RetType}, VMArgs} ->
+            aeb_abi:create_calldata(FunName, VMArgs, ArgTypes, RetType);
+        {error, _} = Err -> Err
+    end.
+
+-spec decode_calldata(string(), string(), binary()) ->
+                             {ok, [aeso_syntax:type()], [aeso_syntax:expr()]}
+                             | {error, term()}.
+decode_calldata(ContractString, FunName, Calldata) ->
+    try
+        #{ typed_ast := TypedAst,
+           type_env  := TypeEnv,
+           icode     := Icode } = string_to_icode(ContractString, []),
+        {ok, Args, _} = get_decode_type(FunName, TypedAst),
+        DropArg       = fun({arg, _, _, T}) -> T; (T) -> T end,
+        ArgTypes      = lists:map(DropArg, Args),
+        Type0         = {tuple_t, [], ArgTypes},
+        Type   = aeso_ast_infer_types:unfold_types_in_type(TypeEnv, Type0, [unfold_record_types, unfold_variant_types]),
+        VmType = aeso_ast_to_icode:ast_typerep(Type, Icode),
+        case aeb_heap:from_binary({tuple, [word, VmType]}, Calldata) of
+            {ok, {_, VmValue}} ->
+                try
+                    {tuple, [], Values} = translate_vm_value(VmType, Type, VmValue),
+                    {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
+    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) ->
-    [Args] = [ Args || {?CALL_NAME, _, _, {funcall, _, Args}, _} <- Funs ],
-    Args.
+    case [ Args || {[_, ?CALL_NAME], _, _, {funcall, _, Args}, _} <- Funs ] of
+        [Args] -> Args;
+        []     -> error({missing_call_function, Funs})
+    end.
 
 get_call_type([{contract, _, _, Defs}]) ->
-    case [ {FunName, FunType}
+    case [ {lists:last(QFunName), FunType}
           || {letfun, _, {id, _, ?CALL_NAME}, [], _Ret,
                 {typed, _,
                     {app, _,
-                        {typed, _, {id, _, FunName}, FunType}, _}, _}} <- Defs ] of
+                        {typed, _, {qid, _, QFunName}, FunType}, _}, _}} <- Defs ] of
         [Call] -> {ok, Call};
         []     -> {error, missing_call_function}
     end;
@@ -177,9 +397,22 @@ 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};
+        []            -> {error, missing_function}
+    end;
+get_decode_type(FunName, [_ | Contracts]) ->
+    %% The __decode should be in the final contract
+    get_decode_type(FunName, Contracts).
+
 %% Translate an icode value (error if not value) to an Erlang term that can be
-%% consumed by aeso_heap:to_binary().
+%% consumed by aeb_heap:to_binary().
 icode_to_term(word, {integer, N}) -> N;
+icode_to_term(word, {unop, '-', {integer, N}}) -> -N;
 icode_to_term(string, {tuple, [{integer, Len} | Words]}) ->
     <<Str:Len/binary, _/binary>> = << <<W:256>> || {integer, W} <- Words >>,
     Str;
@@ -211,10 +444,7 @@ icode_to_term(T, V) ->
 icodes_to_terms(Ts, Vs) ->
     [ icode_to_term(T, V) || {T, V} <- lists:zip(Ts, Vs) ].
 
-parse(C,_Options) ->
-    parse_string(C).
-
-to_icode(TypedAst, Options) ->
+ast_to_icode(TypedAst, Options) ->
     aeso_ast_to_icode:convert_typed(TypedAst, Options).
 
 assemble(Icode, Options) ->
@@ -228,7 +458,9 @@ to_bytecode([Op|Rest], Options) ->
 to_bytecode([], _) -> [].
 
 extract_type_info(#{functions := Functions} =_Icode) ->
-    TypeInfo = [aeso_abi:function_type_info(list_to_binary(Name), Args, TypeRep)
+    ArgTypesOnly = fun(As) -> [ T || {_, T} <- As ] end,
+    TypeInfo = [aeb_abi:function_type_info(list_to_binary(lists:last(Name)),
+                                            ArgTypesOnly(Args), TypeRep)
                 || {Name, Attrs, Args,_Body, TypeRep} <- Functions,
                    not is_tuple(Name),
                    not lists:member(private, Attrs)
@@ -263,9 +495,9 @@ sophia_type_to_typerep(String) ->
     catch _:_ -> {error, bad_type}
     end.
 
-parse_string(Text) ->
+parse(Text, Options) ->
     %% Try and return something sensible here!
-    case aeso_parser:string(Text) of
+    case aeso_parser:string(Text, Options) of
         %% Yay, it worked!
         {ok, Contract} -> Contract;
         %% Scan errors.
@@ -278,12 +510,23 @@ parse_string(Text) ->
             parse_error(Pos, Error);
         {error, {Pos, ambiguous_parse, As}} ->
             ErrorString = io_lib:format("Ambiguous ~p", [As]),
-            parse_error(Pos, ErrorString)
+            parse_error(Pos, ErrorString);
+        %% Include error
+        {error, {Pos, include_error, File}} ->
+            parse_error(Pos, io_lib:format("could not find include file '~s'", [File]))
     end.
 
-parse_error({Line, Pos}, ErrorString) ->
-    Error = io_lib:format("line ~p, column ~p: ~s", [Line, Pos, ErrorString]),
+parse_error(Pos, ErrorString) ->
+    Error = io_lib:format("~s: ~s", [pos_error(Pos), ErrorString]),
     error({parse_errors, [Error]}).
 
 read_contract(Name) ->
     file:read_file(Name).
+
+pos_error({Line, Pos}) ->
+    io_lib:format("line ~p, column ~p", [Line, Pos]);
+pos_error({no_file, Line, Pos}) ->
+    pos_error({Line, Pos});
+pos_error({File, Line, Pos}) ->
+    io_lib:format("file ~s, line ~p, column ~p", [File, Line, Pos]).
+

src/aeso_heap.erl

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

src/aeso_icode.erl

@@ -9,19 +9,30 @@
 %%%-------------------------------------------------------------------
 -module(aeso_icode).
 
--export([new/1, pp/1, set_name/2, set_functions/2, map_typerep/2, option_typerep/1, get_constructor_tag/2]).
+-export([new/1,
+         pp/1,
+         set_name/2,
+         set_namespace/2,
+         enter_namespace/2,
+         get_namespace/1,
+         qualify/2,
+         set_functions/2,
+         map_typerep/2,
+         option_typerep/1,
+         get_constructor_tag/2]).
+
 -export_type([icode/0]).
 
 -include("aeso_icode.hrl").
 
--type type_def() :: fun(([aeso_sophia:type()]) -> aeso_sophia:type()).
+-type type_def() :: fun(([aeb_aevm_data:type()]) -> aeb_aevm_data:type()).
 
 -type bindings() :: any().
 -type fun_dec() :: { string()
                    , [modifier()]
                    , arg_list()
                    , expr()
-                   , aeso_sophia:type()}.
+                   , aeb_aevm_data:type()}.
 
 -type modifier() :: private | stateful.
 
@@ -29,12 +40,13 @@
 
 -type icode() :: #{ contract_name => string()
                   , functions => [fun_dec()]
+                  , namespace => aeso_syntax:con() | aeso_syntax:qcon()
                   , env => [bindings()]
-                  , state_type => aeso_sophia:type()
-                  , event_type => aeso_sophia:type()
+                  , state_type => aeb_aevm_data:type()
+                  , event_type => aeb_aevm_data:type()
                   , types => #{ type_name() => type_def() }
-                  , type_vars => #{ string() => aeso_sophia:type() }
-                  , constructors => #{ string() => integer() }  %% name to tag
+                  , type_vars => #{ string() => aeb_aevm_data:type() }
+                  , constructors => #{ [string()] => integer() }  %% name to tag
                   , options => [any()]
                   }.
 
@@ -73,10 +85,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}.
@@ -91,11 +103,30 @@ new_env() ->
 set_name(Name, Icode) ->
     maps:put(contract_name, Name, 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,14 +1,5 @@
 
--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).
+-include_lib("aebytecode/include/aeb_typerep_def.hrl").
 
 -record(arg, {name::string(), type::?Type()}).
 
@@ -20,7 +11,7 @@
                  , args :: arg_list()
                  , body :: expr()}).
 
--record(var_ref, { name :: string() | {builtin, atom() | tuple()}}).
+-record(var_ref, { name :: string() | list(string()) | {builtin, atom() | tuple()}}).
 
 -record(prim_call_contract,
     { gas      :: expr()

src/aeso_icode_to_asm.erl

@@ -17,7 +17,7 @@
 i(Code) -> aeb_opcodes:mnemonic(Code).
 
 %% We don't track purity or statefulness in the type checker yet.
-is_stateful({FName, _, _, _, _}) -> FName /= "init".
+is_stateful({FName, _, _, _, _}) -> lists:last(FName) /= "init".
 
 is_public({_Name, Attrs, _Args, _Body, _Type}) -> not lists:member(private, Attrs).
 
@@ -105,7 +105,7 @@ make_args(Args) ->
 
 fun_hash({FName, _, Args, _, TypeRep}) ->
     ArgType = {tuple, [T || {_, T} <- Args]},
-    <<Hash:256>> = aeso_abi:function_type_hash(list_to_binary(FName), ArgType, TypeRep),
+    <<Hash:256>> = aeb_abi:function_type_hash(list_to_binary(lists:last(FName)), ArgType, TypeRep),
     {integer, Hash}.
 
 %% Expects two return addresses below N elements on the stack. Picks the top
@@ -343,6 +343,8 @@ assemble_expr(Funs, Stack, _Tail, #prim_put{ state = State }) ->
 %% Environment primitives
 assemble_expr(_Funs, _Stack, _Tail, prim_contract_address) ->
     [i(?ADDRESS)];
+assemble_expr(_Funs, _Stack, _Tail, prim_contract_creator) ->
+    [i(?CREATOR)];
 assemble_expr(_Funs, _Stack, _Tail, prim_call_origin) ->
     [i(?ORIGIN)];
 assemble_expr(_Funs, _Stack, _Tail, prim_caller) ->

src/aeso_memory.erl

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

src/aeso_parse_lib.erl

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

src/aeso_parser.erl

@@ -5,28 +5,37 @@
 -module(aeso_parser).
 
 -export([string/1,
+         string/2,
          type/1]).
 
 -include("aeso_parse_lib.hrl").
 
--spec string(string()) ->
-                    {ok, aeso_syntax:ast()}
-                        | {error, {aeso_parse_lib:pos(),
-                                   atom(),
-                                   term()}}
-                        | {error, {aeso_parse_lib:pos(),
-                                   atom()}}.
+-type parse_result() :: {ok, aeso_syntax:ast()}
+                      | {error, {aeso_parse_lib:pos(), atom(), term()}}
+                      | {error, {aeso_parse_lib:pos(), atom()}}.
+
+-spec string(string()) -> parse_result().
 string(String) ->
-  parse_and_scan(file(), String).
+    string(String, []).
+
+-spec string(string(), aeso_compiler:options()) -> parse_result().
+string(String, Opts) ->
+    case parse_and_scan(file(), String, Opts) of
+        {ok, AST} ->
+            expand_includes(AST, Opts);
+        Err = {error, _} ->
+            Err
+    end.
 
 type(String) ->
-  parse_and_scan(type(), String).
+    parse_and_scan(type(), String, []).
 
-parse_and_scan(P, S) ->
-  case aeso_scan:scan(S) of
-    {ok, Tokens} -> aeso_parse_lib:parse(P, Tokens);
-    Error        -> Error
-  end.
+parse_and_scan(P, S, Opts) ->
+    set_current_file(proplists:get_value(src_file, Opts, no_file)),
+    case aeso_scan:scan(S) of
+        {ok, Tokens} -> aeso_parse_lib:parse(P, Tokens);
+        Error        -> Error
+    end.
 
 %% -- Parsing rules ----------------------------------------------------------
 
@@ -36,7 +45,9 @@ decl() ->
     ?LAZY_P(
     choice(
       %% Contract declaration
-    [ ?RULE(keyword(contract), con(), tok('='), maybe_block(decl()), {contract, _1, _2, _4})
+    [ ?RULE(keyword(contract),  con(), tok('='), maybe_block(decl()), {contract, _1, _2, _4})
+    , ?RULE(keyword(namespace), con(), tok('='), maybe_block(decl()), {namespace, _1, _2, _4})
+    , ?RULE(keyword(include),   str(), {include, _2})
 
       %% Type declarations  TODO: format annotation for "type bla" vs "type bla()"
     , ?RULE(keyword(type),     id(),                                          {type_decl, _1, _2, []})
@@ -57,9 +68,14 @@ decl() ->
 modifiers() ->
     many(choice([token(stateful), token(public), token(private), token(internal)])).
 
-add_modifiers(Mods, Node) ->
-    lists:foldl(fun({Mod, _}, X) -> set_ann(Mod, true, X) end,
-                Node, Mods).
+add_modifiers([], Node) -> Node;
+add_modifiers(Mods = [Tok | _], Node) ->
+    %% Set the position to the position of the first modifier. This is
+    %% important for code transformation tools (like what we do in
+    %% create_calldata) to be able to get the indentation of the declaration.
+    set_pos(get_pos(Tok),
+        lists:foldl(fun({Mod, _}, X) -> set_ann(Mod, true, X) end,
+                    Node, Mods)).
 
 %% -- Type declarations ------------------------------------------------------
 
@@ -71,7 +87,7 @@ constructors() ->
     sep1(constructor(), tok('|')).
 
 constructor() ->    %% TODO: format for Con() vs Con
-    choice(?RULE(con(),              {constr_t, get_ann(_1), _1, []}),
+    choice(?RULE(con(),             {constr_t, get_ann(_1), _1, []}),
            ?RULE(con(), con_args(), {constr_t, get_ann(_1), _1, _2})).
 
 con_args()   -> paren_list(con_arg()).
@@ -83,9 +99,7 @@ con_arg()    -> choice(type(), ?RULE(keyword(indexed), type(), set_ann(indexed,
 %% -- Let declarations -------------------------------------------------------
 
 letdecl() ->
-    choice(
-        ?RULE(keyword('let'), letdef(),                             set_pos(get_pos(_1), _2)),
-        ?RULE(keyword('let'), tok(rec), sep1(letdef(), tok('and')), {letrec, _1, _3})).
+    ?RULE(keyword('let'), letdef(), set_pos(get_pos(_1), _2)).
 
 letdef() -> choice(valdef(), fundef()).
 
@@ -120,11 +134,15 @@ type200() ->
 type300() -> type400().
 
 type400() ->
-    ?RULE(typeAtom(), optional(type_args()),
+    choice(
+    [?RULE(typeAtom(), optional(type_args()),
           case _2 of
             none       -> _1;
             {ok, Args} -> {app_t, get_ann(_1), _1, Args}
-          end).
+          end),
+     ?RULE(id("bytes"), parens(token(int)),
+           {bytes_t, get_ann(_1), element(3, _2)})
+    ]).
 
 typeAtom() ->
     ?LAZY_P(choice(
@@ -187,13 +205,13 @@ exprAtom() ->
     ?LAZY_P(begin
         Expr = ?LAZY_P(expr()),
         choice(
-        [ id(), con(), token(qid), token(qcon)
-        , token(hash), token(string), token(char)
+        [ id_or_addr(), con(), token(qid), token(qcon)
+        , token(bytes), token(string), token(char)
         , token(int)
         , ?RULE(token(hex), set_ann(format, hex, setelement(1, _1, int)))
         , {bool, keyword(true), true}
         , {bool, keyword(false), false}
-        , ?RULE(brace_list(?LAZY_P(field_assignment())), record(_1))
+        , ?LET_P(Fs, brace_list(?LAZY_P(field_assignment())), record(Fs))
         , {list, [], bracket_list(Expr)}
         , ?RULE(tok('['), Expr, binop('..'), Expr, tok(']'), _3(_2, _4))
         , ?RULE(keyword('('), comma_sep(Expr), tok(')'), tuple_e(_1, _2))
@@ -236,14 +254,20 @@ record_update(Ann, E, Flds) ->
 record([]) -> {map, [], []};
 record(Fs) ->
     case record_or_map(Fs) of
-        record -> {record, get_ann(hd(Fs)), Fs};
+        record ->
+            Fld = fun({field, _, [_], _} = F) -> F;
+                     ({field, Ann, LV, Id, _}) ->
+                         bad_expr_err("Cannot use '@' in record construction", infix({lvalue, Ann, LV}, {'@', Ann}, Id));
+                     ({field, Ann, LV, _}) ->
+                         bad_expr_err("Cannot use nested fields or keys in record construction", {lvalue, Ann, LV}) end,
+            {record, get_ann(hd(Fs)), lists:map(Fld, Fs)};
         map    ->
             Ann = get_ann(hd(Fs ++ [{empty, []}])), %% TODO: source location for empty maps
             KV = fun({field, _, [{map_get, _, Key}], Val}) -> {Key, Val};
-                    ({field, _, LV, Id, _}) ->
-                        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,
+                    ({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,
             {map, Ann, lists:map(KV, Fs)}
     end.
 
@@ -301,6 +325,7 @@ binop(Ops) ->
 con()      -> token(con).
 id()       -> token(id).
 tvar()     -> token(tvar).
+str()      -> token(string).
 
 token(Tag) ->
     ?RULE(tok(Tag),
@@ -309,6 +334,26 @@ token(Tag) ->
         {Tok, {Line, Col}, Val} -> {Tok, pos_ann(Line, Col), Val}
     end).
 
+id(Id) ->
+    ?LET_P({id, A, X} = Y, id(),
+           if X == Id -> Y;
+              true    -> fail({A, "expected 'bytes'"})
+           end).
+
+id_or_addr() ->
+    ?RULE(id(), parse_addr_literal(_1)).
+
+parse_addr_literal(Id = {id, Ann, Name}) ->
+    case lists:member(lists:sublist(Name, 3), ["ak_", "ok_", "oq_", "ct_"]) of
+        false -> Id;
+        true  ->
+            try aeser_api_encoder:decode(list_to_binary(Name)) of
+                {Type, Bin} -> {Type, Ann, Bin}
+            catch _:_ ->
+                Id
+            end
+    end.
+
 %% -- Helpers ----------------------------------------------------------------
 
 keyword(K) -> ann(tok(K)).
@@ -336,10 +381,17 @@ bracket_list(P) -> brackets(comma_sep(P)).
 -type ann_col()  :: aeso_syntax:ann_col().
 
 -spec pos_ann(ann_line(), ann_col()) -> ann().
-pos_ann(Line, Col) -> [{line, Line}, {col, Col}].
+pos_ann(Line, Col) -> [{file, current_file()}, {line, Line}, {col, Col}].
+
+current_file() ->
+    get('$current_file').
+
+set_current_file(File) ->
+    put('$current_file', File).
 
 ann_pos(Ann) ->
-    {proplists:get_value(line, Ann),
+    {proplists:get_value(file, Ann),
+     proplists:get_value(line, Ann),
      proplists:get_value(col, Ann)}.
 
 get_ann(Ann) when is_list(Ann) -> Ann;
@@ -357,10 +409,10 @@ set_ann(Key, Val, Node) ->
     setelement(2, Node, lists:keystore(Key, 1, Ann, {Key, Val})).
 
 get_pos(Node) ->
-    {get_ann(line, Node), get_ann(col, Node)}.
+    {current_file(), get_ann(line, Node), get_ann(col, Node)}.
 
-set_pos({L, C}, Node) ->
-    set_ann(line, L, set_ann(col, C, Node)).
+set_pos({F, L, C}, Node) ->
+    set_ann(file, F, set_ann(line, L, set_ann(col, C, Node))).
 
 infix(L, Op, R) -> set_ann(format, infix,  {app, get_ann(L), Op, [L, R]}).
 
@@ -393,7 +445,7 @@ build_if(Ann, Cond, Then, [{elif, Ann1, Cond1, Then1} | Elses]) ->
 build_if(Ann, Cond, Then, [{else, _Ann, Else}]) ->
     {'if', Ann, Cond, Then, Else};
 build_if(Ann, Cond, Then, []) ->
-    {'if', Ann, Cond, Then, {unit, [{origin, system}]}}.
+    {'if', Ann, Cond, Then, {tuple, [{origin, system}], []}}.
 
 else_branches([Elif = {elif, _, _, _} | Stmts], Acc) ->
     else_branches(Stmts, [Elif | Acc]);
@@ -409,7 +461,6 @@ fun_t(Domains, Type) ->
     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}.
 
@@ -430,10 +481,9 @@ parse_pattern({record, Ann, Fs}) ->
     {record, Ann, lists:map(fun parse_field_pattern/1, Fs)};
 parse_pattern(E = {con, _, _})    -> E;
 parse_pattern(E = {id, _, _})     -> E;
-parse_pattern(E = {unit, _})      -> E;
 parse_pattern(E = {int, _, _})    -> E;
 parse_pattern(E = {bool, _, _})   -> E;
-parse_pattern(E = {hash, _, _})   -> E;
+parse_pattern(E = {bytes, _, _})  -> E;
 parse_pattern(E = {string, _, _}) -> E;
 parse_pattern(E = {char, _, _})   -> E;
 parse_pattern(E) -> bad_expr_err("Not a valid pattern", E).
@@ -442,16 +492,53 @@ parse_pattern(E) -> bad_expr_err("Not a valid pattern", E).
 parse_field_pattern({field, Ann, F, E}) ->
     {field, Ann, F, parse_pattern(E)}.
 
-return_error({L, C}, Err) ->
-    fail(io_lib:format("~p:~p:\n~s", [L, C, Err])).
+return_error({no_file, L, C}, Err) ->
+    fail(io_lib:format("~p:~p:\n~s", [L, C, Err]));
+return_error({F, L, C}, Err) ->
+    fail(io_lib:format("In ~s at ~p:~p:\n~s", [F, L, C, Err])).
 
--spec ret_doc_err(ann(), prettypr:document()) -> no_return().
+-spec ret_doc_err(ann(), prettypr:document()) -> aeso_parse_lib:parser(none()).
 ret_doc_err(Ann, Doc) ->
     return_error(ann_pos(Ann), prettypr:format(Doc)).
 
--spec bad_expr_err(string(), aeso_syntax:expr()) -> no_return().
+-spec bad_expr_err(string(), aeso_syntax:expr()) -> aeso_parse_lib:parser(none()).
 bad_expr_err(Reason, E) ->
   ret_doc_err(get_ann(E),
               prettypr:sep([prettypr:text(Reason ++ ":"),
                             prettypr:nest(2, aeso_pretty:expr(E))])).
 
+%% -- Helper functions -------------------------------------------------------
+expand_includes(AST, Opts) ->
+    expand_includes(AST, [], Opts).
+
+expand_includes([], Acc, _Opts) ->
+    {ok, lists:reverse(Acc)};
+expand_includes([{include, S = {string, _, File}} | AST], Acc, Opts) ->
+    case read_file(File, Opts) of
+        {ok, Bin} ->
+            Opts1 = lists:keystore(src_file, 1, Opts, {src_file, File}),
+            case string(binary_to_list(Bin), Opts1) of
+                {ok, AST1} ->
+                    expand_includes(AST1 ++ AST, Acc, Opts);
+                Err = {error, _} ->
+                    Err
+            end;
+        {error, _} ->
+            {error, {get_pos(S), include_error, File}}
+    end;
+expand_includes([E | AST], Acc, Opts) ->
+    expand_includes(AST, [E | Acc], Opts).
+
+read_file(File, Opts) ->
+    case proplists:get_value(include, Opts, {explicit_files, #{}}) of
+        {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.
+

src/aeso_pretty.erl

@@ -147,6 +147,8 @@ 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),
@@ -158,8 +160,7 @@ decl(D = {letfun, Attrs, _, _, _, _}) ->
                             text(atom_to_list(Mod));
              (_) -> empty() end,
     hsep(lists:map(Mod, Attrs) ++ [letdecl("function", D)]);
-decl(D = {letval, _, _, _, _})    -> letdecl("let", D);
-decl(D = {letrec, _, _})          -> letdecl("let", D).
+decl(D = {letval, _, _, _, _}) -> letdecl("let", D).
 
 -spec expr(aeso_syntax:expr(), options()) -> doc().
 expr(E, Options) ->
@@ -182,9 +183,7 @@ name({typed, _, Name, _}) -> name(Name).
 letdecl(Let, {letval, _, F, T, E}) ->
     block_expr(0, hsep([text(Let), typed(name(F), T), text("=")]), E);
 letdecl(Let, {letfun, _, F, Args, T, E}) ->
-    block_expr(0, hsep([text(Let), typed(beside(name(F), args(Args)), T), text("=")]), E);
-letdecl(Let, {letrec, _, [D | Ds]}) ->
-    hsep(text(Let), above([ letdecl("rec", D) | [ letdecl("and", D1) || D1 <- Ds ] ])).
+    block_expr(0, hsep([text(Let), typed(beside(name(F), args(Args)), T), text("=")]), E).
 
 -spec args([aeso_syntax:arg()]) -> doc().
 args(Args) ->
@@ -234,8 +233,12 @@ type({app_t, _, Type, Args}) ->
     beside(type(Type), tuple_type(Args));
 type({tuple_t, _, Args}) ->
     tuple_type(Args);
-type({named_arg_t, _, Name, Type, Default}) ->
-    follow(hsep(typed(name(Name), Type), text("=")), expr(Default));
+type({bytes_t, _, Len}) ->
+    text(lists:concat(["bytes(", Len, ")"]));
+type({named_arg_t, _, Name, Type, _Default}) ->
+    %% Drop the default value
+    %% follow(hsep(typed(name(Name), Type), text("=")), expr(Default));
+    typed(name(Name), Type);
 
 type(R = {record_t, _}) -> typedef(R);
 type(T = {id, _, _})   -> name(T);
@@ -303,6 +306,8 @@ expr_p(P, E = {app, _, F = {Op, _}, Args}) when is_atom(Op) ->
         {prefix, [A]}   -> prefix(P, Op, A);
         _               -> app(P, F, Args)
     end;
+expr_p(_, {app, _, C={Tag, _, _}, []}) when Tag == con; Tag == qcon ->
+    expr_p(0, C);
 expr_p(P, {app, _, F, Args}) ->
     app(P, F, Args);
 %% -- Constants
@@ -313,8 +318,17 @@ expr_p(_, E = {int, _, N}) ->
            end,
     text(S);
 expr_p(_, {bool, _, B}) -> text(atom_to_list(B));
-expr_p(_, {hash, _, <<N:256>>}) -> text("#" ++ integer_to_list(N, 16));
-expr_p(_, {unit, _}) -> text("()");
+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, _, S}) -> term(binary_to_list(S));
 expr_p(_, {char, _, C}) ->
     case C of
@@ -347,6 +361,7 @@ stmt_p({else, Else}) ->
 -spec bin_prec(aeso_syntax:bin_op()) -> {integer(), integer(), integer()}.
 bin_prec('..')   -> {  0,   0,   0};  %% Always printed inside '[ ]'
 bin_prec('=')    -> {  0,   0,   0};  %% Always printed inside '[ ]'
+bin_prec('@')    -> {  0,   0,   0};  %% Only in error messages
 bin_prec('||')   -> {200, 300, 200};
 bin_prec('&&')   -> {300, 400, 300};
 bin_prec('<')    -> {400, 500, 500};
@@ -418,7 +433,6 @@ statements(Stmts) ->
 
 statement(S = {letval, _, _, _, _})    -> letdecl("let", S);
 statement(S = {letfun, _, _, _, _, _}) -> letdecl("let", S);
-statement(S = {letrec, _, _})          -> letdecl("let", S);
 statement(E) -> expr(E).
 
 get_elifs(Expr) -> get_elifs(Expr, []).

src/aeso_scan.erl

@@ -20,7 +20,7 @@ lexer() ->
     CON      = [UPPER, "[a-zA-Z0-9_]*"],
     INT      = [DIGIT, "+"],
     HEX      = ["0x", HEXDIGIT, "+"],
-    HASH     = ["#", HEXDIGIT, "+"],
+    BYTES    = ["#", HEXDIGIT, "+"],
     WS       = "[\\000-\\ ]+",
     ID       = [LOWER, "[a-zA-Z0-9_']*"],
     TVAR     = ["'", ID],
@@ -36,8 +36,8 @@ lexer() ->
         , {"\\*/",        pop(skip())}
         , {"[^/*]+|[/*]", skip()} ],
 
-    Keywords = ["contract", "import", "let", "rec", "switch", "type", "record", "datatype", "if", "elif", "else", "function",
-                "stateful", "true", "false", "and", "mod", "public", "private", "indexed", "internal"],
+    Keywords = ["contract", "include", "let", "switch", "type", "record", "datatype", "if", "elif", "else", "function",
+                "stateful", "true", "false", "mod", "public", "private", "indexed", "internal", "namespace"],
     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)}
-        , {HASH,   token(hash,   fun parse_hash/1)}
+        , {BYTES,  token(bytes,  fun parse_bytes/1)}
 
           %% Identifiers (qualified first!)
         , {QID,   token(qid,  fun(S) -> string:tokens(S, ".") end)}
@@ -117,10 +117,8 @@ unescape([C | Chars], Acc) ->
 
 parse_hex("0x" ++ Chars) -> list_to_integer(Chars, 16).
 
-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.
+parse_bytes("#" ++ Chars) ->
+    N      = list_to_integer(Chars, 16),
+    Digits = (length(Chars) + 1) div 2,
+    <<N:Digits/unit:8>>.
 

src/aeso_sophia.erl

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

src/aeso_syntax.erl

@@ -8,14 +8,14 @@
 
 -module(aeso_syntax).
 
--export([get_ann/1, get_ann/2, get_ann/3, set_ann/2]).
+-export([get_ann/1, get_ann/2, get_ann/3, set_ann/2, qualify/2]).
 
 -export_type([ann_line/0, ann_col/0, ann_origin/0, ann_format/0, ann/0]).
 -export_type([name/0, id/0, con/0, qid/0, qcon/0, tvar/0, op/0]).
 -export_type([bin_op/0, un_op/0]).
 -export_type([decl/0, letbind/0, typedef/0]).
--export_type([arg/0, field_t/0, constructor_t/0]).
--export_type([type/0, constant/0, expr/0, arg_expr/0, field/1, stmt/0, alt/0, lvalue/0, pat/0]).
+-export_type([arg/0, field_t/0, constructor_t/0, named_arg_t/0]).
+-export_type([type/0, constant/0, expr/0, arg_expr/0, field/1, stmt/0, alt/0, lvalue/0, elim/0, pat/0]).
 -export_type([ast/0]).
 
 -type ast() :: [decl()].
@@ -25,7 +25,7 @@
 -type ann_origin() :: system | user.
 -type ann_format() :: '?:' | hex | infix | prefix | elif.
 
--type ann() :: [{line, ann_line()} | {col, ann_col()} | {format, ann_format()} | {origin, ann_origin()}].
+-type ann() :: [{line, ann_line()} | {col, ann_col()} | {format, ann_format()} | {origin, ann_origin()} | stateful | private].
 
 -type name() :: string().
 -type id()   :: {id,   ann(), name()}.
@@ -35,6 +35,7 @@
 -type tvar() :: {tvar, ann(), name()}.
 
 -type decl() :: {contract, ann(), con(), [decl()]}
+              | {namespace, ann(), con(), [decl()]}
               | {type_decl, ann(), id(), [tvar()]}
               | {type_def, ann(), id(), [tvar()], typedef()}
               | {fun_decl, ann(), id(), type()}
@@ -42,8 +43,7 @@
 
 -type letbind()
     :: {letval, ann(), id(), type(), expr()}
-     | {letfun, ann(), id(), [arg()], type(), expr()}
-     | {letrec, ann(), [letbind()]}.
+     | {letfun, ann(), id(), [arg()], type(), expr()}.
 
 -type arg() :: {arg, ann(), id(), type()}.
 
@@ -59,6 +59,7 @@
 -type type() :: {fun_t, ann(), [named_arg_t()], [type()], type()}
               | {app_t, ann(), type(), [type()]}
               | {tuple_t, ann(), [type()]}
+              | {bytes_t, ann(), integer()}
               | id()  | qid()
               | con() | qcon()  %% contracts
               | tvar().
@@ -69,7 +70,10 @@
     :: {int, ann(), integer()}
      | {bool, ann(), true | false}
      | {hash, ann(), binary()}
-     | {unit, ann()}
+     | {account_pubkey, binary()}
+     | {contract_pubkey, binary()}
+     | {oracle_pubkey, binary()}
+     | {oracle_query_id, binary()}
      | {string, ann(), binary()}
      | {char, ann(), integer()}.
 
@@ -140,3 +144,8 @@ get_ann(Key, Node) ->
 
 get_ann(Key, Node, Default) ->
     proplists:get_value(Key, get_ann(Node), Default).
+
+qualify({con, Ann, N}, X)             -> qualify({qcon, Ann, [N]}, X);
+qualify({qcon, _, NS}, {con, Ann, C}) -> {qcon, Ann, NS ++ [C]};
+qualify({qcon, _, NS}, {id, Ann, X})  -> {qid, Ann, NS ++ [X]}.
+

src/aeso_syntax_utils.erl

@@ -6,89 +6,142 @@
 %%%-------------------------------------------------------------------
 -module(aeso_syntax_utils).
 
--export([used_ids/1, used_types/1]).
+-export([used_ids/1, used_types/2, used/1]).
 
-%% Var set combinators
-none()           -> [].
-one(X)           -> [X].
-union_map(F, Xs) -> lists:umerge(lists:map(F, Xs)).
-minus(Xs, Ys)    -> Xs -- Ys.
+-record(alg, {zero, plus, scoped}).
 
-%% 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 alg(A) :: #alg{ zero   :: A
+                    , plus   :: fun((A, A) -> A)
+                    , scoped :: fun((A, A) -> A) }.
 
-%% Statements
-used_ids_s([])       -> none();
-used_ids_s([S | Ss]) ->
-    used_ids([S, {bind, bound_ids(S), {block, [], Ss}}]).
+-type kind() :: decl | type | bind_type | expr | bind_expr.
 
-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().
+-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), Scoped(BindExpr(Xs), Expr(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);
+            {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, _, X, T} -> Plus(Expr(X), 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) -> lists:foldl(fun maps:remove/2, Map, Keys) end,
+    Scoped = fun(Xs, Ys) ->
+                Bound  = [E || E <- maps:keys(Ys), IsBound(E)],
+                Others = Remove(Bound, Ys),
+                Bound1 = [ {Unbind(Tag), X} || {Tag, X} <- Bound ],
+                maps:merge(Remove(Bound1, Xs), Others)
+            end,
+    #alg{ zero   = #{}
+        , plus   = fun maps:merge/2
+        , scoped = Scoped }.
+
+-spec used(_) -> [{entity(), aeso_syntax:ann()}].
+used(D) ->
+    Kind = fun(expr)      -> term;
+              (bind_expr) -> bound_term;
+              (type)      -> type;
+              (bind_type) -> bound_type
+           end,
+    NS = fun(Xs) -> {namespace, lists:droplast(Xs)} end,
+    NotBound = fun({{Tag, _}, _}) -> not lists:member(Tag, [bound_term, bound_type]) end,
+    Xs =
+        maps:to_list(fold(entity_alg(),
+            fun(K, {id,   Ann, X})  -> #{{Kind(K), [X]} => Ann};
+               (K, {qid,  Ann, Xs}) -> #{{Kind(K), Xs}  => Ann, NS(Xs) => Ann};
+               (K, {con,  Ann, X})  -> #{{Kind(K), [X]} => Ann};
+               (K, {qcon, Ann, Xs}) -> #{{Kind(K), Xs}  => Ann, NS(Xs) => Ann};
+               (_, _)             -> #{}
+            end, decl, D)),
+    lists:filter(NotBound, Xs).
 
-used_types(Ts) when is_list(Ts)    -> union_map(fun used_types/1, Ts);
-used_types({type_def, _, _, _, T}) -> used_types(T);
-used_types({alias_t, T})           -> used_types(T);
-used_types({record_t, Fs})         -> used_types(Fs);
-used_types({variant_t, Cs})        -> used_types(Cs);
-used_types({field_t, _, _, T})     -> used_types(T);
-used_types({constr_t, _, _, Ts})   -> used_types(Ts);
-used_types({fun_t, _, Named, Args, T}) -> used_types([T | Named ++ Args]);
-used_types({named_arg_t, _, _, T, _}) -> used_types(T);
-used_types({app_t, _, T, Ts})      -> used_types([T | Ts]);
-used_types({tuple_t, _, Ts})       -> used_types(Ts);
-used_types({id, _, X})             -> one(X);
-used_types({qid, _, _})            -> none();
-used_types({con, _, _})            -> none();
-used_types({qcon, _, _})           -> none();
-used_types({tvar, _, _})           -> none().

src/aesophia.app.src

@@ -1,10 +1,11 @@
 {application, aesophia,
- [{description, "Contract Language for Aethernity"},
-  {vsn, "1.2.0"},
+ [{description, "Contract Language for aeternity"},
+  {vsn, "3.1.0"},
   {registered, []},
   {applications,
    [kernel,
     stdlib,
+    jsx,
     syntax_tools,
     getopt,
     aebytecode

src/aesophia.erl

@@ -1,71 +0,0 @@
--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,9 +1,12 @@
 -module(aeso_abi_tests).
 
 -include_lib("eunit/include/eunit.hrl").
--compile(export_all).
+-compile([export_all, nowarn_export_all]).
 
 -define(SANDBOX(Code), sandbox(fun() -> Code end)).
+-define(DUMMY_HASH_WORD, 16#123).
+-define(DUMMY_HASH, <<0:30/unit:8, 127, 119>>). %% 16#123
+-define(DUMMY_HASH_LIT, "#0000000000000000000000000000000000000000000000000000000000000123").
 
 sandbox(Code) ->
     Parent = self(),
@@ -19,8 +22,8 @@ sandbox(Code) ->
 
 malicious_from_binary_test() ->
     CircularList = from_words([32, 1, 32]), %% Xs = 1 :: Xs
-    {ok, {error, circular_references}}   = ?SANDBOX(aeso_heap:from_binary({list, word}, CircularList)),
-    {ok, {error, {binary_too_short, _}}} = ?SANDBOX(aeso_heap:from_binary(word, <<1, 2, 3, 4>>)),
+    {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.
 
 from_words(Ws) ->
@@ -54,35 +57,144 @@ encode_decode_test() ->
     ok.
 
 encode_decode_sophia_test() ->
-    {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)"),
+    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}"),
     ok.
 
 encode_decode_sophia_string(SophiaType, String) ->
     io:format("String ~p~n", [String]),
-    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).
+    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"
+           , "  function 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) ->
+            encode_decode_calldata_(
+                parameterized_contract(Extra, "foo", ["int"]),
+                "foo", ["42"], word)
+           end,
+    Test("  stateful function bla() = ()"),
+    Test("  type x = int"),
+    Test("  private function bla : int => int"),
+    Test("  public stateful function bla(x : int) =\n"
+         "    x + 1"),
+    Test("  stateful private function 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"
+         "  function bla : () => ()\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"
+         "  function ", FunName, " : (", string:join(Types, ", "), ") => int\n" ]).
+
+oracle_test() ->
+    Contract =
+        "contract OracleTest =\n"
+        "  function 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 function 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, CalldataType, RetVMType1} = aeso_compiler:create_calldata(Code, FunName, Args),
+    ?assertEqual(RetVMType1, RetVMType),
+    {ok, {_Hash, ArgTuple}} = aeb_heap:from_binary(CalldataType, Calldata),
+    case FunName of
+        "init" ->
+            ok;
+        _ ->
+            {ok, _ArgTypes, ValueASTs} = aeso_compiler:decode_calldata(Code, FunName, Calldata),
+            Values = [ prettypr:format(aeso_pretty:expr(V)) || V <- ValueASTs ],
+            ?assertMatch({X, X}, {Args, Values})
+    end,
+    tuple_to_list(ArgTuple).
 
 encode_decode(T, D) ->
     ?assertEqual(D, decode(T, encode(D))),
     D.
 
 encode(D) ->
-    aeso_heap:to_binary(D).
+    aeb_heap:to_binary(D).
 
 decode(T,B) ->
-    {ok, D} = aeso_heap:from_binary(T, B),
+    {ok, D} = aeb_heap:from_binary(T, B),
     D.

test/aeso_aci_tests.erl

@@ -0,0 +1,122 @@
+-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 = <<"contract C =\n"
+		 "  function a(i : int) = i+1\n">>,
+    MapACI = #{contract =>
+		   #{name => <<"C">>,
+		     type_defs => [],
+		     functions =>
+			 [#{name => <<"a">>,
+			    arguments =>
+				[#{name => <<"i">>,
+				   type => <<"int">>}],
+			    returns => <<"int">>,
+			    stateful => false}]}},
+    DecACI = <<"contract C =\n"
+	       "  function a : (int) => int\n">>,
+    {Contract,MapACI,DecACI};
+
+test_cases(2) ->
+    Contract = <<"contract C =\n"
+		 "  type allan = int\n"
+		 "  function a(i : allan) = i+1\n">>,
+    MapACI = #{contract =>
+                       #{name => <<"C">>,
+                         type_defs =>
+                             [#{name => <<"allan">>,
+                                typedef => <<"int">>,
+                                vars => []}],
+			 functions =>
+                             [#{arguments =>
+                                    [#{name => <<"i">>,
+                                       type => <<"C.allan">>}],
+                                name => <<"a">>,
+                                returns => <<"int">>,
+                                stateful => false}]}},
+    DecACI = <<"contract C =\n"
+               "  type allan = int\n"
+               "  function a : (C.allan) => int\n">>,
+    {Contract,MapACI,DecACI};
+test_cases(3) ->
+    Contract = <<"contract C =\n"
+                 "  type state = ()\n"
+                 "  datatype event = SingleEventDefined\n"
+		 "  datatype bert('a) = Bin('a)\n"
+		 "  function a(i : bert(string)) = 1\n">>,
+    MapACI = #{contract =>
+		   #{functions =>
+			 [#{arguments =>
+				[#{name => <<"i">>,
+				   type =>
+				       #{<<"C.bert">> => [<<"string">>]}}],
+			    name => <<"a">>,returns => <<"int">>,
+			    stateful => false}],
+		     name => <<"C">>,
+                     event => #{variant => [#{<<"SingleEventDefined">> => []}]},
+                     state => #{tuple => []},
+		     type_defs =>
+			 [#{name => <<"bert">>,
+			    typedef =>
+				#{variant =>
+				      [#{<<"Bin">> => [<<"'a">>]}]},
+			    vars => [#{name => <<"'a">>}]}]}},
+    DecACI = <<"contract C =\n"
+               "  type state = ()\n"
+               "  datatype event = SingleEventDefined\n"
+	       "  datatype bert('a) = Bin('a)\n"
+	       "  function 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

@@ -1,73 +0,0 @@
-%%%=============================================================================
-%%% @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_compiler_tests.erl

@@ -8,31 +8,59 @@
 
 -module(aeso_compiler_tests).
 
+-compile([export_all, nowarn_export_all]).
+
 -include_lib("eunit/include/eunit.hrl").
 
-%% simple_compile_test_() -> ok.
 %%  Very simply test compile the given contracts. Only basic checks
 %%  are made on the output, just that it is a binary which indicates
 %%  that the compilation worked.
-
 simple_compile_test_() ->
-    {setup,
-     fun () -> ok end,                          %Setup
-     fun (_) -> ok end,                         %Cleanup
-     [ {"Testing the " ++ ContractName ++ " contract",
+     [ {"Testing the " ++ ContractName ++ " contract with the " ++ atom_to_list(Backend) ++ " backend",
         fun() ->
-            #{byte_code := ByteCode,
-              contract_source := _,
-              type_info := _} = compile(ContractName),
-            ?assertMatch(Code when is_binary(Code), ByteCode)
-        end} || ContractName <- compilable_contracts() ] ++
+            case compile(Backend, ContractName) of
+                #{byte_code := ByteCode,
+                  contract_source := _,
+                  type_info := _} when Backend == aevm ->
+                    ?assertMatch(Code when is_binary(Code), ByteCode);
+                Code when Backend == fate, is_tuple(Code) ->
+                    ?assertMatch(#{}, aeb_fate_code:functions(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))] ++
      [ {"Testing error messages of " ++ ContractName,
         fun() ->
-            <<"Type errors\n",ErrorString/binary>> = compile(ContractName),
-            check_errors(lists:sort(ExpectedErrors), ErrorString)
+            case compile(aevm, ContractName) of
+                <<"Type errors\n", ErrorString/binary>> ->
+                    check_errors(lists:sort(ExpectedErrors), ErrorString);
+                <<"Parse errors\n", ErrorString/binary>> ->
+                    check_errors(lists:sort(ExpectedErrors), ErrorString)
+            end
         end} ||
-            {ContractName, ExpectedErrors} <- failing_contracts() ]
-    }.
+            {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",
+        fun() ->
+            #{ byte_code := NoDeadCode } = compile(aevm, "nodeadcode"),
+            #{ byte_code := DeadCode   } = compile(aevm, "deadcode"),
+            SizeNoDeadCode = byte_size(NoDeadCode),
+            SizeDeadCode   = byte_size(DeadCode),
+            ?assertMatch({_, _, true}, {SizeDeadCode, SizeNoDeadCode, SizeDeadCode + 40 < SizeNoDeadCode}),
+            ok
+        end} ].
 
 check_errors(Expect, ErrorString) ->
     %% This removes the final single \n as well.
@@ -43,11 +71,14 @@ check_errors(Expect, ErrorString) ->
         {Missing, Extra} -> ?assertEqual(Missing, Extra)
     end.
 
-compile(Name) ->
+compile(Backend, Name) ->
+    compile(Backend, Name, [{include, {file_system, [aeso_test_utils:contract_path()]}}]).
+
+compile(Backend, Name, Options) ->
     String = aeso_test_utils:read_contract(Name),
-    case aeso_compiler:from_string(String, []) of
-        {ok,Map} -> Map;
-        {error,ErrorString} -> ErrorString
+    case aeso_compiler:from_string(String, [{src_file, Name}, {backend, Backend} | Options]) of
+        {ok, Map}            -> Map;
+        {error, ErrorString} -> ErrorString
     end.
 
 %% compilable_contracts() -> [ContractName].
@@ -59,6 +90,7 @@ compilable_contracts() ->
      "dutch_auction",
      "environment",
      "factorial",
+     "functions",
      "fundme",
      "identity",
      "maps",
@@ -70,9 +102,30 @@ compilable_contracts() ->
      "stack",
      "test",
      "builtin_bug",
-     "builtin_map_get_bug"
+     "builtin_map_get_bug",
+     "nodeadcode",
+     "deadcode",
+     "variant_types",
+     "state_handling",
+     "events",
+     "include",
+     "basic_auth",
+     "bitcoin_auth",
+     "address_literals",
+     "bytes_equality",
+     "address_chain"
     ].
 
+not_yet_compilable(fate) ->
+    ["oracles",             %% Oracle.register
+     "events",              %% events
+     "basic_auth",          %% auth_tx_hash instruction
+     "bitcoin_auth",        %% auth_tx_hash instruction
+     "address_literals",    %% oracle_query_id literals
+     "address_chain"        %% Oracle.check_query
+    ];
+not_yet_compilable(aevm) -> [].
+
 %% Contracts that should produce type errors
 
 failing_contracts() ->
@@ -150,11 +203,13 @@ failing_contracts() ->
         <<"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)">>,
-        <<"No record type with fields y, z (at line 14, column 22)">>]}
+        <<"Repeated argument x to function repeated_arg (at line 44, column 12).">>,
+        <<"Repeated argument y to function repeated_arg (at line 44, column 12).">>,
+        <<"No record type with fields y, z (at line 14, column 22)">>,
+        <<"The field z is missing when constructing an element of type r2 (at line 15, column 24)">>,
+        <<"Record type r2 does not have field y (at line 15, column 22)">>]}
     , {"init_type_error",
        [<<"Cannot unify string\n"
           "         and map(int, int)\n"
@@ -166,5 +221,124 @@ failing_contracts() ->
     , {"missing_fields_in_record_expression",
        [<<"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)">>]}
+        <<"The fields y, z are missing when constructing an element of type r('a) (at line 6, column 40)">>]}
+    , {"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 40\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 33)\nin the definition of non-stateful function fail1.">>,
+        <<"Cannot reference stateful function local_spend (at line 14, column 33)\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 53)\nin the definition of non-stateful function fail5.">>,
+        <<"Cannot pass non-zero value argument 1000 (at line 48, column 55)\nin the definition of non-stateful function fail6.">>,
+        <<"Cannot pass non-zero value argument 1000 (at line 49, column 54)\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 36), which calls\n"
+          "  - put (at line 7, column 37)">>,
+        <<"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 27)">>,
+        <<"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">>]}
     ].

test/aeso_eunit_SUITE.erl

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

test/aeso_parser_tests.erl

@@ -62,7 +62,7 @@ simple_contracts_test_() ->
      %% Parse tests of example contracts
      [ {lists:concat(["Parse the ", Contract, " contract."]),
         fun() -> roundtrip_contract(Contract) end}
-        || Contract <- [counter, voting, all_syntax, '05_greeter', aeproof, multi_sig, simple_storage, withdrawal, fundme, dutch_auction] ]
+        || Contract <- [counter, voting, all_syntax, '05_greeter', aeproof, multi_sig, simple_storage, fundme, dutch_auction] ]
     }.
 
 parse_contract(Name) ->

test/aeso_scan_tests.erl

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

test/contract_tests.erl

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

test/contracts/address_chain.aes

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

test/contracts/address_literals.aes

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

test/contracts/all_syntax.aes

@@ -36,11 +36,6 @@ 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

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

test/contracts/bad_events.aes

@@ -0,0 +1,23 @@
+contract Events =
+  type alias_int = int
+  type alias_address = address
+  type alias_string = string
+
+  datatype event =
+      Event1(indexed alias_int, indexed int, string)
+    | Event2(alias_string, indexed alias_address)
+    | BadEvent1(indexed string)
+    | BadEvent2(indexed alias_string)
+
+  function f1(x : int, y : string) =
+    Chain.event(Event1(x, x+1, y))
+
+  function f2(s : string) =
+    Chain.event(Event2(s, Call.caller))
+
+  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/bad_events2.aes

@@ -0,0 +1,23 @@
+contract Events =
+  type alias_int = int
+  type alias_address = address
+  type alias_string = string
+
+  datatype event =
+      Event1(indexed alias_int, indexed int, string)
+    | Event2(alias_string, indexed alias_address)
+    | BadEvent1(string, string)
+    | BadEvent2(indexed int, indexed int, indexed int, indexed address)
+
+  function f1(x : int, y : string) =
+    Chain.event(Event1(x, x+1, y))
+
+  function f2(s : string) =
+    Chain.event(Event2(s, Call.caller))
+
+  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/bad_include_and_ns.aes

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

test/contracts/bad_init_state_access.aes

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

test/contracts/basic_auth.aes

@@ -0,0 +1,19 @@
+// Contract replicating "normal" Aeternity authentication
+contract BasicAuth =
+  record state = { nonce : int, owner : address }
+
+  function init() = { nonce = 1, owner = Call.caller }
+
+  stateful function 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.ecverify(to_sign(tx_hash, n), state.owner, s)
+
+  function to_sign(h : hash, n : int) =
+    Crypto.blake2b((h, n))
+
+  private function require(b : bool, err : string) =
+    if(!b) abort(err)

test/contracts/bitcoin_auth.aes

@@ -0,0 +1,18 @@
+contract BitcoinAuth =
+  record state = { nonce : int, owner : bytes(64) }
+
+  function init(owner' : bytes(64)) = { nonce = 1, owner = owner' }
+
+  stateful function 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.ecverify_secp256k1(to_sign(tx_hash, n), state.owner, s)
+
+  function to_sign(h : hash, n : int) : hash =
+    Crypto.blake2b((h, n))
+
+  private function require(b : bool, err : string) =
+    if(!b) abort(err)

test/contracts/bytes_equality.aes

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

test/contracts/chain.aes

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

test/contracts/counter.aes

@@ -5,5 +5,5 @@ contract Counter =
 
   function init(val) = { value = val }
   function get()     = state.value
-  function tick()    = put(state{ value = state.value + 1 })
+  stateful function tick()    = put(state{ value = state.value + 1 })
 

test/contracts/deadcode.aes

@@ -0,0 +1,21 @@
+
+namespace List =
+
+  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 =
+
+  function inc1(xs : list(int)) : list(int) =
+    List.map1((x) => x + 1, xs)
+
+  function inc2(xs : list(int)) : list(int) =
+    List.map1((x) => x + 1, xs)
+

test/contracts/dutch_auction.aes

@@ -10,7 +10,7 @@ contract DutchAuction =
                    sold         : bool }
 
   // Add to work around current lack of predefined functions
-  private function spend(to, amount) =
+  private stateful function spend(to, amount) =
     let total = Contract.balance
     Chain.spend(to, amount)
     total - amount

test/contracts/environment.aes

@@ -12,7 +12,7 @@ contract Environment =
 
   function init(remote) = {remote = remote}
 
-  function set_remote(remote) = put({remote = remote})
+  stateful function set_remote(remote) = put({remote = remote})
 
   // -- Information about the this contract ---
 
@@ -38,7 +38,7 @@ contract Environment =
 
   // Value
   function call_value() : int = Call.value
-  function nested_value(value : int) : int =
+  stateful function nested_value(value : int) : int =
     state.remote.call_value(value = value / 2)
 
   // Gas price

test/contracts/factorial.aes

@@ -9,7 +9,7 @@ contract Factorial =
 
   function init(worker) = {worker = worker}
 
-  function set_worker(worker) = put(state{worker = worker})
+  stateful function set_worker(worker) = put(state{worker = worker})
 
   function fac(x : int) : int =
     if(x == 0) 1

test/contracts/field_parse_error.aes

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

test/contracts/functions.aes

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

test/contracts/fundme.aes

@@ -15,7 +15,7 @@ contract FundMe =
   private function require(b : bool, err : string) =
     if(!b) abort(err)
 
-  private function spend(args : spend_args) =
+  private stateful function spend(args : spend_args) =
     Chain.spend(args.recipient, args.amount)
 
   public function init(beneficiary, deadline, goal) : state =
@@ -53,7 +53,7 @@ contract FundMe =
     require(state.total >= state.goal, "Project was not funded")
     spend({recipient = state.beneficiary,
            amount    = Contract.balance })
-    put(state{ beneficiary = #0 })
+    put(state{ beneficiary = ak_11111111111111111111111111111111273Yts })
 
   private stateful function withdraw_contributor() =
     if(state.total >= state.goal)

test/contracts/include.aes

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

test/contracts/included.aes

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

test/contracts/included2.aes

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

test/contracts/maps.aes

@@ -17,8 +17,8 @@ contract Maps =
     { ["one"]   = {x = 1, y = 2},
       ["two"]   = {x = 3, y = 4},
       ["three"] = {x = 5, y = 6} }
-  function map_state_i() = put(state{ map_i = map_i() })
-  function map_state_s() = put(state{ map_s = map_s() })
+  stateful function map_state_i() = put(state{ map_i = map_i() })
+  stateful function map_state_s() = put(state{ map_s = map_s() })
 
   // m[k]
   function get_i(k, m : map(int,    pt)) = m[k]
@@ -35,20 +35,20 @@ contract Maps =
   // m{[k] = v}
   function set_i(k, p, m : map(int,    pt)) = m{ [k] = p }
   function set_s(k, p, m : map(string, pt)) = m{ [k] = p }
-  function set_state_i(k, p) = put(state{ map_i = set_i(k, p, state.map_i) })
-  function set_state_s(k, p) = put(state{ map_s = set_s(k, p, state.map_s) })
+  stateful function set_state_i(k, p) = put(state{ map_i = set_i(k, p, state.map_i) })
+  stateful function set_state_s(k, p) = put(state{ map_s = set_s(k, p, state.map_s) })
 
   // m{f[k].x = v}
   function setx_i(k, x, m : map(int,    pt)) = m{ [k].x = x }
   function setx_s(k, x, m : map(string, pt)) = m{ [k].x = x }
-  function setx_state_i(k, x) = put(state{ map_i[k].x = x })
-  function setx_state_s(k, x) = put(state{ map_s[k].x = x })
+  stateful function setx_state_i(k, x) = put(state{ map_i[k].x = x })
+  stateful function setx_state_s(k, x) = put(state{ map_s[k].x = x })
 
   // m{[k] @ x = v }
   function addx_i(k, d, m : map(int,    pt)) = m{ [k].x @ x = x + d }
   function addx_s(k, d, m : map(string, pt)) = m{ [k].x @ x = x + d }
-  function addx_state_i(k, d) = put(state{ map_i[k].x @ x = x + d })
-  function addx_state_s(k, d) = put(state{ map_s[k].x @ x = x + d })
+  stateful function addx_state_i(k, d) = put(state{ map_i[k].x @ x = x + d })
+  stateful function addx_state_s(k, d) = put(state{ map_s[k].x @ x = x + d })
 
   // m{[k = def] @ x = v }
   function addx_def_i(k, v, d, m : map(int,    pt)) = m{ [k = v].x @ x = x + d }
@@ -77,8 +77,8 @@ contract Maps =
   // Map.delete
   function delete_i(k, m : map(int,    pt)) = Map.delete(k, m)
   function delete_s(k, m : map(string, pt)) = Map.delete(k, m)
-  function delete_state_i(k) = put(state{ map_i = delete_i(k, state.map_i) })
-  function delete_state_s(k) = put(state{ map_s = delete_s(k, state.map_s) })
+  stateful function delete_state_i(k) = put(state{ map_i = delete_i(k, state.map_i) })
+  stateful function delete_state_s(k) = put(state{ map_s = delete_s(k, state.map_s) })
 
   // Map.size
   function size_i(m : map(int,    pt)) = Map.size(m)
@@ -95,6 +95,6 @@ contract Maps =
   // Map.from_list
   function fromlist_i(xs : list((int,    pt))) = Map.from_list(xs)
   function fromlist_s(xs : list((string, pt))) = Map.from_list(xs)
-  function fromlist_state_i(xs) = put(state{ map_i = fromlist_i(xs) })
-  function fromlist_state_s(xs) = put(state{ map_s = fromlist_s(xs) })
+  stateful function fromlist_state_i(xs) = put(state{ map_i = fromlist_i(xs) })
+  stateful function fromlist_state_s(xs) = put(state{ map_s = fromlist_s(xs) })
 

test/contracts/namespace_clash.aes

@@ -0,0 +1,5 @@
+
+// You can't shadow existing contracts or namespaces.
+
+contract Call =
+  function whatever() = ()

test/contracts/namespaces.aes

@@ -0,0 +1,21 @@
+
+namespace Lib =
+
+  private function rev(xs, ys) =
+    switch(xs)
+      []      => ys
+      x :: xs => rev(xs, x :: ys)
+
+  function reverse(xs : list('a)) : list('a) = rev(xs, [])
+
+  function eqlist(xs : list(int), ys : list(int)) =
+    switch((xs, ys))
+      ([], [])           => true
+      (x :: xs, y :: ys) => x == y && eqlist(xs, ys)
+      _                  => false
+
+contract TestNamespaces =
+
+  function palindrome(xs : list(int)) : bool =
+    Lib.eqlist(xs, Lib.reverse(xs))
+

test/contracts/nodeadcode.aes

@@ -0,0 +1,21 @@
+
+namespace List =
+
+  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 =
+
+  function inc1(xs : list(int)) : list(int) =
+    List.map1((x) => x + 1, xs)
+
+  function inc2(xs : list(int)) : list(int) =
+    List.map2((x) => x + 1, xs)
+

test/contracts/oracles.aes

@@ -9,22 +9,22 @@ contract Oracles =
   type oracle_id = oracle(query_t, answer_t)
   type query_id  = oracle_query(query_t, answer_t)
 
-  function registerOracle(acct : address,
+  stateful function registerOracle(acct : address,
                           qfee : fee,
                           ttl  : ttl) : oracle_id =
      Oracle.register(acct, qfee, ttl)
 
-  function registerIntIntOracle(acct : address,
+  stateful function registerIntIntOracle(acct : address,
                                 qfee : fee,
                                 ttl  : ttl) : oracle(int, int) =
      Oracle.register(acct, qfee, ttl)
 
-  function registerStringStringOracle(acct : address,
+  stateful function registerStringStringOracle(acct : address,
                                       qfee : fee,
                                       ttl  : ttl) : oracle(string, string) =
      Oracle.register(acct, qfee, ttl)
 
-  function signedRegisterOracle(acct : address,
+  stateful function signedRegisterOracle(acct : address,
                                 sign : signature,
                                 qfee : fee,
                                 ttl  : ttl) : oracle_id =
@@ -33,7 +33,7 @@ contract Oracles =
   function queryFee(o : oracle_id) : fee =
     Oracle.query_fee(o)
 
-  function createQuery(o    : oracle_id,
+  stateful function createQuery(o    : oracle_id,
                        q    : query_t,
                        qfee : fee,
                        qttl : ttl,
@@ -42,7 +42,7 @@ contract Oracles =
     Oracle.query(o, q, qfee, qttl, rttl)
 
   // Do not use in production!
-  function unsafeCreateQuery(o    : oracle_id,
+  stateful function unsafeCreateQuery(o    : oracle_id,
                        q    : query_t,
                        qfee : fee,
                        qttl : ttl,
@@ -50,7 +50,7 @@ contract Oracles =
     Oracle.query(o, q, qfee, qttl, rttl)
 
   // Do not use in production!
-  function unsafeCreateQueryThenErr(o    : oracle_id,
+  stateful function unsafeCreateQueryThenErr(o    : oracle_id,
                        q    : query_t,
                        qfee : fee,
                        qttl : ttl,
@@ -59,21 +59,21 @@ contract Oracles =
     require(qfee >= 100000000000000000, "causing a late error")
     res
 
-  function extendOracle(o    : oracle_id,
+  stateful function extendOracle(o    : oracle_id,
                         ttl  : ttl) : () =
     Oracle.extend(o, ttl)
 
-  function signedExtendOracle(o    : oracle_id,
+  stateful function signedExtendOracle(o    : oracle_id,
                               sign : signature,   // Signed oracle address
                               ttl  : ttl) : () =
     Oracle.extend(o, signature = sign, ttl)
 
-  function respond(o    : oracle_id,
+  stateful function respond(o    : oracle_id,
                    q    : query_id,
                    r    : answer_t) : () =
     Oracle.respond(o, q, r)
 
-  function signedRespond(o    : oracle_id,
+  stateful function signedRespond(o    : oracle_id,
                          q    : query_id,
                          sign : signature,
                          r    : answer_t) : () =
@@ -96,13 +96,13 @@ contract Oracles =
   datatype complexQuestion = Why(int) | How(string)
   datatype complexAnswer   = NoAnswer | Answer(complexQuestion, string, int)
 
-  function complexOracle(question) =
+  stateful function complexOracle(question) =
     let o = Oracle.register(Contract.address, 0, FixedTTL(1000)) : oracle(complexQuestion, complexAnswer)
     let q = Oracle.query(o, question, 0, RelativeTTL(100), RelativeTTL(100))
     Oracle.respond(o, q, Answer(question, "magic", 1337))
     Oracle.get_answer(o, q)
 
-  function signedComplexOracle(question, sig) =
+  stateful function signedComplexOracle(question, sig) =
     let o = Oracle.register(signature = sig, Contract.address, 0, FixedTTL(1000)) : oracle(complexQuestion, complexAnswer)
     let q = Oracle.query(o, question, 0, RelativeTTL(100), RelativeTTL(100))
     Oracle.respond(o, q, Answer(question, "magic", 1337), signature = sig)

test/contracts/remote_call.aes

@@ -11,7 +11,7 @@ contract Remote3 =
 
 contract RemoteCall =
 
-    function call(r : Remote1, x : int) : int =
+    stateful function call(r : Remote1, x : int) : int =
         r.main(gas = 10000, value = 10, x)
 
     function staged_call(r1 : Remote1, r2 : Remote2, x : int) =

test/contracts/remote_oracles.aes

@@ -1,99 +0,0 @@
-contract Oracles =
-
-  function registerOracle :
-    (address,
-     int,
-     Chain.ttl) => oracle(string, int)
-
-  function createQuery :
-    (oracle(string, int),
-     string,
-     int,
-     Chain.ttl,
-     Chain.ttl) => oracle_query(string, int)
-
-  function unsafeCreateQuery :
-    (oracle(string, int),
-     string,
-     int,
-     Chain.ttl,
-     Chain.ttl) => oracle_query(string, int)
-
-  function respond :
-    (oracle(string, int),
-     oracle_query(string, int),
-     int) => ()
-
-contract OraclesErr =
-
-  function unsafeCreateQueryThenErr :
-    (oracle(string, int),
-     string,
-     int,
-     Chain.ttl,
-     Chain.ttl) => oracle_query(string, int)
-
-contract RemoteOracles =
-
-  public function callRegisterOracle(
-      r    : Oracles,
-      acct : address,
-      qfee : int,
-      ttl  : Chain.ttl) : oracle(string, int) =
-    r.registerOracle(acct, qfee, ttl)
-
-  public function callCreateQuery(
-    r     : Oracles,
-    value : int,
-    o     : oracle(string, int),
-    q     : string,
-    qfee  : int,
-    qttl  : Chain.ttl,
-    rttl  : Chain.ttl) : oracle_query(string, int) =
-    require(value =< Call.value, "insufficient value")
-    r.createQuery(value = value, o, q, qfee, qttl, rttl)
-
-  // Do not use in production!
-  public function callUnsafeCreateQuery(
-    r     : Oracles,
-    value : int,
-    o     : oracle(string, int),
-    q     : string,
-    qfee  : int,
-    qttl  : Chain.ttl,
-    rttl  : Chain.ttl) : oracle_query(string, int) =
-    r.unsafeCreateQuery(value = value, o, q, qfee, qttl, rttl)
-
-  // Do not use in production!
-  public function callUnsafeCreateQueryThenErr(
-    r     : OraclesErr,
-    value : int,
-    o     : oracle(string, int),
-    q     : string,
-    qfee  : int,
-    qttl  : Chain.ttl,
-    rttl  : Chain.ttl) : oracle_query(string, int) =
-    r.unsafeCreateQueryThenErr(value = value, o, q, qfee, qttl, rttl)
-
-  // Do not use in production!
-  public function callUnsafeCreateQueryAndThenErr(
-    r     : Oracles,
-    value : int,
-    o     : oracle(string, int),
-    q     : string,
-    qfee  : int,
-    qttl  : Chain.ttl,
-    rttl  : Chain.ttl) : oracle_query(string, int) =
-    let x = r.unsafeCreateQuery(value = value, o, q, qfee, qttl, rttl)
-    switch(0) 1 => ()
-    x // Never reached.
-
-  public function callRespond(
-    r    : Oracles,
-    o    : oracle(string, int),
-    q    : oracle_query(string, int),
-    qr   : int) =
-    r.respond(o, q, qr)
-
-  private function require(b : bool, err : string) =
-    if(!b) abort(err)

test/contracts/simple_storage.aes

@@ -18,12 +18,11 @@
 
 contract SimpleStorage =
 
-  type event = int
   record state = { data : int }
 
   function init(value : int) : state = { data = value }
 
   function get() : int = state.data
 
-  function set(value : int) =
+  stateful function set(value : int) =
       put(state{data = value})

test/contracts/spend_test.aes

@@ -4,19 +4,19 @@ contract SpendContract =
 
 contract SpendTest =
 
-  function spend(to, amount) =
+  stateful function spend(to, amount) =
     let total = Contract.balance
     Chain.spend(to, amount)
     total - amount
 
-  function withdraw(amount) : int =
+  stateful function withdraw(amount) : int =
     spend(Call.caller, amount)
 
-  function withdraw_from(account, amount) =
+  stateful function withdraw_from(account, amount) =
     account.withdraw(amount)
     withdraw(amount)
 
-  function spend_from(from, to, amount) =
+  stateful function spend_from(from, to, amount) =
     from.withdraw(amount)
     Chain.spend(to, amount)
     Chain.balance(to)

test/contracts/state_handling.aes

@@ -1,19 +1,22 @@
 contract Remote =
-  function look_at : (state) => ()
+  record rstate = { i : int, s : string, m : map(int, int) }
+
+  function look_at : (rstate) => ()
   function return_s : (bool) => string
   function return_m : (bool) => map(int, int)
-  function get : (state) => state
-  function get_i : (state) => int
-  function get_s : (state) => string
-  function get_m : (state) => map(int, int)
+  function get : (rstate) => rstate
+  function get_i : (rstate) => int
+  function get_s : (rstate) => string
+  function get_m : (rstate) => map(int, int)
 
-  function fun_update_i  : (state, int)           => state
-  function fun_update_s  : (state, string)        => state
-  function fun_update_m  : (state, map(int, int)) => state
-  function fun_update_mk : (state, int, int)      => state
+  function fun_update_i  : (rstate, int)           => rstate
+  function fun_update_s  : (rstate, string)        => rstate
+  function fun_update_m  : (rstate, map(int, int)) => rstate
+  function fun_update_mk : (rstate, int, int)      => rstate
 
 contract StateHandling =
-  record state = { i : int, s : string, m : map(int, int) }
+
+  type state = Remote.rstate
 
   function init(r : Remote, i : int) =
     let state0 = { i = 0, s = "undefined", m = {} }
@@ -24,13 +27,13 @@ contract StateHandling =
   function read_s() = state.s
   function read_m() = state.m
 
-  function update(new_state : state) = put(new_state)
-  function update_i(new_i) = put(state{ i = new_i })
-  function update_s(new_s) = put(state{ s = new_s })
-  function update_m(new_m) = put(state{ m = new_m })
+  stateful function update(new_state : state) = put(new_state)
+  stateful function update_i(new_i) = put(state{ i = new_i })
+  stateful function update_s(new_s) = put(state{ s = new_s })
+  stateful function update_m(new_m) = put(state{ m = new_m })
 
   function pass_it(r : Remote) = r.look_at(state)
-  function nop(r : Remote) = put(state{ i = state.i })
+  stateful function nop(r : Remote) = put(state{ i = state.i })
   function return_it_s(r : Remote, big : bool) =
     let x = r.return_s(big)
     String.length(x)
@@ -47,10 +50,10 @@ contract StateHandling =
   function pass_update_s(r : Remote, s) = r.fun_update_s(state, s)
   function pass_update_m(r : Remote, m) = r.fun_update_m(state, m)
 
-  function remote_update_i (r : Remote, i)    = put(r.fun_update_i(state, i))
-  function remote_update_s (r : Remote, s)    = put(r.fun_update_s(state, s))
-  function remote_update_m (r : Remote, m)    = put(r.fun_update_m(state, m))
-  function remote_update_mk(r : Remote, k, v) = put(r.fun_update_mk(state, k, v))
+  stateful function remote_update_i (r : Remote, i)    = put(r.fun_update_i(state, i))
+  stateful function remote_update_s (r : Remote, s)    = put(r.fun_update_s(state, s))
+  stateful function remote_update_m (r : Remote, m)    = put(r.fun_update_m(state, m))
+  stateful function remote_update_mk(r : Remote, k, v) = put(r.fun_update_mk(state, k, v))
 
   // remote called
   function look_at(s : state) = ()

test/contracts/stateful.aes

@@ -0,0 +1,54 @@
+
+contract Remote =
+  stateful function remote_spend : (address, int) => ()
+  function remote_pure : int => int
+
+contract Stateful =
+
+  private function pure(x) = x + 1
+  private stateful function local_spend(a) =
+    Chain.spend(a, 1000)
+
+  // Non-stateful functions cannot mention stateful functions
+  function fail1(a : address) = Chain.spend(a, 1000)
+  function fail2(a : address) = local_spend(a)
+  function fail3(a : address) =
+    let foo = Chain.spend
+    foo(a, 1000)
+
+  // Private functions must also be annotated
+  private function fail4(a) = Chain.spend(a, 1000)
+
+  // If annotated, stateful functions are allowed
+  stateful function ok1(a : address) = Chain.spend(a, 1000)
+
+  // And pure functions are always allowed
+  stateful function ok2(a : address) = pure(5)
+  stateful function ok3(a : address) =
+    let foo = pure
+    foo(5)
+
+  // No error here (fail4 is annotated as not stateful)
+  function ok4(a : address) = fail4(a)
+
+  // Lamdbas are checked at the construction site
+  private function fail5() : address => () = (a) => Chain.spend(a, 1000)
+
+  // .. so you can pass a stateful lambda to a non-stateful higher-order
+  // function:
+  private function apply(f : 'a => 'b, x) = f(x)
+  stateful function ok5(a : address) =
+    apply((val) => Chain.spend(a, val), 1000)
+
+  // It doesn't matter if remote calls are stateful or not
+  function ok6(r : Remote) = r.remote_spend(Contract.address, 1000)
+  function ok7(r : Remote) = r.remote_pure(5)
+
+  // But you can't send any tokens if not stateful
+  function fail6(r : Remote) = r.remote_spend(value = 1000, Contract.address, 1000)
+  function fail7(r : Remote) = r.remote_pure(value = 1000, 5)
+  function fail8(r : Remote) =
+    let foo = r.remote_pure
+    foo(value = 1000, 5)
+  function ok8(r : Remote) = r.remote_spend(Contract.address, 1000, value = 0)
+

test/contracts/type_clash.aes

@@ -0,0 +1,13 @@
+
+contract Remote =
+
+  type themap = map(int, string)
+  function foo : () => themap
+
+contract Main =
+
+  type themap = map(string, int)
+
+  // Should fail
+  function foo(r : Remote) : themap = r.foo()
+

test/contracts/type_errors.aes

@@ -40,3 +40,5 @@ contract Test =
 
   function type_error(r, x) =
     set_x(set_x(x, r), x)
+
+  function repeated_arg(x : int, y, x : string, y : bool) : string = x

test/contracts/variant_types.aes

@@ -11,11 +11,11 @@ contract VariantTypes =
 
   function require(b) = if(!b) abort("required")
 
-  function start(bal : int) =
+  stateful function start(bal : int) =
     switch(state)
       Stopped => put(Started({owner = Call.caller, balance = bal, color = Grey(0)}))
 
-  function stop() =
+  stateful function stop() =
     switch(state)
       Started(st) =>
         require(Call.caller == st.owner)
@@ -23,7 +23,7 @@ contract VariantTypes =
         st.balance
 
   function get_color()  = switch(state) Started(st) => st.color
-  function set_color(c) = switch(state) Started(st) => put(Started(st{color = c}))
+  stateful function set_color(c) = switch(state) Started(st) => put(Started(st{color = c}))
 
   function get_state() = state
 

test/contracts/withdrawal.aes

@@ -1,56 +0,0 @@
-/* Example from Solidity by Example
-   http://solidity.readthedocs.io/en/develop/common-patterns.html
-
-   contract WithdrawalContract {
-     address public richest
-     uint public mostSent
-
-      mapping (address => uint) pendingWithdrawals
-
-      function WithdrawalContract() payable {
-        richest = msg.sender
-        mostSent = msg.value
-      }
-
-      function becomeRichest() payable returns (bool) {
-        if (msg.value > mostSent) {
-            pendingWithdrawals[richest] += msg.value
-            richest = msg.sender
-            mostSent = msg.value
-            return true
-        } else {
-            return false
-        }
-      }
-
-      function withdraw() {
-        uint amount = pendingWithdrawals[msg.sender]
-        // Remember to zero the pending refund before
-        // sending to prevent re-entrancy attacks
-        pendingWithdrawals[msg.sender] = 0
-        msg.sender.transfer(amount)
-      }
-  }
-
-*/
-
-contract WithdrawalContract =
-
-  record state = { richest  : address,
-                   mostSent : uint,
-                   pendingWithdrawals : map(address, uint) }
-
-  function becomeRichest() : result(bool) =
-      if (call().value > state.mostSent)
-        let totalAmount : uint = Map.get_(state.richest, pendingWithdrawals) + call().value
-        {state = state{ pendingWithdrawals = Map.insert(state.richest, call().value, state.pendingWithdrawals),
-                        richest  = call().sender,
-                        mostSent = call().value },
-         result = true}
-      else
-        {result = false}
-
-  function withdraw() =
-      let amount : uint = Map.get_(call().sender, state.pendingWithdrawals)
-      { state.pendingWithdrawals = Map.insert(call().sender, 0, state.pendingWithdrawals),
-        transactions = spend_tx(amount, call().sender) }