Merge pull request #26 from aeternity/improved_roma_standalone

Improved roma standalone

.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

@@ -16,6 +16,3 @@ _build
 .idea
 *.iml
 rebar3.crashdump
-*.erl~
-*.aes~
-aesophia

CHANGELOG.md

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

README.md

@@ -5,21 +5,6 @@ This is the __sophia__ compiler for the æternity system which compiles contract
 For more information about æternity smart contracts and the sophia language see [Smart Contracts](https://github.com/aeternity/protocol/blob/master/contracts/contracts.md) and the [Sophia Language](https://github.com/aeternity/protocol/blob/master/contracts/sophia.md).
 
 It is an OTP application written in Erlang and is by default included in
-[the æternity node](https://github.com/aeternity/epoch). However, it can
-also be included in other systems to compile contracts coded in sophia which
+[æternity Epoch](https://github.com/aeternity/epoch). However, it can
+also be included in other system to compile contracts coded in sophia which
 can then be loaded into the æternity system.
-
-## Versioning
-
-`aesophia` has a version that is only loosely connected to the version of the
-Aeternity node - in principle they will share the major version but not
-minor/patch version. The `aesophia` compiler version MUST be bumped whenever
-there is a change in how byte code is generated, but it MAY also be bumped upon
-API changes etc.
-
-## Interface Modules
-
-The basic modules for interfacing the compiler:
-
-* [aeso_compiler: the Sophia compiler](./docs/aeso_compiler.md)
-* [aeso_aci: the ACI interface](./docs/aeso_aci.md)

docs/aeso_aci.md

@@ -1,221 +0,0 @@
-# aeso_aci
-
-### Module
-
-### aeso_aci
-
-The ACI interface encoder and decoder.
-
-### Description
-
-This module provides an interface to generate and convert between
-Sophia contracts and a suitable JSON encoding of contract
-interface. As yet the interface is very basic.
-
-Encoding this contract:
-
-```
-contract Answers =
-  record state = { a : answers }
-  type answers() = map(string, int)
-
-  stateful function init() = { a = {} }
-  private function the_answer() = 42
-  function new_answer(q : string, a : int) : answers() = { [q] = a }
-```
-
-generates the following JSON structure representing the contract interface:
-
-
-``` json
-{
-  "contract": {
-    "name": "Answers",
-    "state": {
-      "record": [
-        {
-          "name": "a",
-          "type": {
-            "map": {
-              "key": "string",
-              "value": "int"
-            }
-          }
-        }
-      ]
-    },
-    "type_defs": [
-      {
-        "name": "answers",
-        "vars": [],
-        "typedef": {
-          "map": {
-            "key": "string",
-            "value": "int"
-          }
-        }
-      }
-    ],
-    "functions": [
-      {
-        "name": "init",
-        "arguments": [],
-        "returns": {
-          "record": [
-            {
-              "name": "a",
-              "type": {
-                "map": {
-                  "key": "string",
-                  "value": "int"
-                }
-              }
-            }
-          ]
-        },
-        "stateful": true
-      },
-      {
-        "name": "new_answer",
-        "arguments": [
-          {
-            "name": "q",
-            "type": "string"
-          },
-          {
-            "name": "a",
-            "type": "int"
-          }
-        ],
-        "returns": {
-          "map": {
-            "key": "string",
-            "value": "int"
-          }
-        },
-        "stateful": false
-      }
-    ]
-  }
-}
-```
-
-When that encoding is decoded the following include definition is generated:
-
-```
-contract Answers =
-  function new_answer : (string, int) => map(string, int)
-```
-
-### Types
-``` erlang
-contract_string() = string() | binary()
-json_string() = binary()
-```
-
-### Exports
-
-#### encode_contract(ContractString) -> {ok,JSONstring} | {error,ErrorString}
-
-Types
-
-``` erlang
-ConstractString = contract_string()
-JSONstring = json_string()
-```
-
-This is equivalent to `aeso_aci:encode_contract(ConstractString, [])`.
-
-#### encode_contract(ContractString, Options) -> {ok,JSONstring} | {error,ErrorString}
-
-Types
-
-``` erlang
-ConstractString = contract_string()
-Options = [option()]
-JSONstring = json_string()
-```
-
-Generate the JSON encoding of the interface to a contract. The type definitions and non-private functions are included in the JSON string.
-
-#### decode_contract(JSONstring) -> ConstractString.
-
-Types
-
-``` erlang
-ConstractString = contract_string()
-JSONstring = json_string()
-```
-
-Take a JSON encoding of a contract interface and generate and generate a contract definition which can be included in another contract.
-
-#### encode_type(TypeAST) -> JSONstring.
-
-Types
-
-``` erlang
-JSONstring = json_string()
-```
-
-Generate the JSON encoding of a type from the AST of the type.
-
-#### encode_arg(ArgAST) -> JSONstring.
-
-Types
-
-``` erlang
-JSONstring = json_string()
-```
-
-Generate the JSON encoding of a function argument from the AST of the argument.
-
-#### encode_stmt(StmtAST) -> JSONstring.
-
-Types
-
-``` erlang
-JSONstring = json_string()
-```
-
-Generate the JSON encoding of a statement from the AST of the statement.
-
-#### encode_expr(ExprAST) -> JSONstring.
-
-Types
-
-``` erlang
-JSONstring = json_string()
-```
-
-Generate the JSON encoding of an expression from the AST of the expression.
-
-### Notes
-
-The deprecated functions `aseo_aci:encode/2` and `aeso_aci:decode/1` are still available but should not be used.
-
-### 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\n  record state = { a : answers }\n  type answers() = map(string, int)\n\n  stateful functio"...>>}
-2> {ok,Encoding} = aeso_aci:encode_contract(Contract).
-{ok,<<"{\"contract\":{\"name\":\"Answers\",\"state\":{\"record\":[{\"name\":\"a\",\"type\":{\"map\":{\"key\":\"string\",\"value\":\"int\"}}}]"...>>}
-3> file:write_file("aci_test.aci", Encoding).
-ok
-4> Decoded = aeso_aci:decode_contract(Encoding).
-<<"contract Answers =\n  function new_answer : (string, int) => map(string, int)\n">>
-5> file:write_file("aci_test.include", Decoded).
-ok
-6> jsx:prettify(Encoding).
-<<"{\n  \"contract\": {\n    \"name\": \"Answers\",\n    \"state\": {\n      \"record\": [\n        {\n          \"name\": \"a\",\n         "...>>
-```
-
-The final call to `jsx:prettify(Encoding)` returns the encoding in a
-more easily readable form. This is what is shown in the description
-above.
-
-### Notes
-
-The ACI generator currently cannot properly handle types defined using `datatype`.

docs/aeso_compiler.md

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

include/aeso_heap.hrl

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

rebar.config

@@ -1,18 +1,14 @@
-%% -*- mode: erlang; indent-tabs-mode: nil -*-
-
 {erl_opts, [debug_info]}.
 
 {deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git",
-                            {ref, "e8253b0"}}}
+                            {ref,"99bf097"}}}
        , {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, "%%! \n"}.
+{escript_emu_args, "%%! +sbtu +A0\n"}.
 {provider_hooks, [{post, [{compile, escriptize}]}]}.
 
 {post_hooks, [{"(linux|darwin|solaris|freebsd|netbsd|openbsd)",
@@ -29,11 +25,3 @@
             {plt_apps, all_deps},
             {base_plt_apps, [erts, kernel, stdlib, crypto, mnesia]}
            ]}.
-
-{relx, [{release, {aesophia, "2.1.0"},
-         [aesophia, aebytecode, getopt]},
-
-        {dev_mode, true},
-        {include_erts, false},
-
-        {extended_start_script, true}]}.

rebar.lock

@@ -1,24 +1,10 @@
 {"1.1.0",
 [{<<"aebytecode">>,
   {git,"https://github.com/aeternity/aebytecode.git",
-       {ref,"e8253b09709f1595d8bd6a1756a0ce93185c6518"}},
+       {ref,"99bf097759dedbe7553f87a796bc7e1c7322e64b"}},
   0},
- {<<"aeserialization">>,
-  {git,"https://github.com/aeternity/aeserialization.git",
-       {ref,"6dce265753af4e651f77746e77ea125145c85dd3"}},
-  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}]}.
+ {<<"getopt">>,{pkg,<<"getopt">>,<<"1.0.1">>},0}]}.
 [
 {pkg_hash,[
- {<<"eblake2">>, <<"EC8AD20E438AAB3F2E8D5D118C366A0754219195F8A0F536587440F8F9BCF2EF">>},
  {<<"getopt">>, <<"C73A9FA687B217F2FF79F68A3B637711BB1936E712B521D8CE466B29CBF7808A">>}]}
 ].

src/aeso_abi.erl

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

src/aeso_aci.erl

@@ -1,572 +0,0 @@
-%%%-------------------------------------------------------------------
-%%% @author Robert Virding
-%%% @copyright (C) 2019, Aeternity Anstalt
-%%% @doc
-%%%     ACI interface
-%%% @end
-%%% Created : 12 Jan 2019
-%%%-------------------------------------------------------------------
-
--module(aeso_aci).
-
-%% Old deprecated interface.
--export([encode/1,encode/2,decode/1]).
-
--export([encode_contract/1,encode_contract/2,decode_contract/1]).
--export([encode_func/1,encode_type/1,encode_arg/1,
-         encode_stmt/1,encode_expr/1]).
-
-%% Define records for the various typed syntactic forms. These make
-%% the code easier but don't seem to exist elsewhere. Unfortunately
-%% sometimes the same typename is used with different fields.
-
-%% Top-level
--record(contract, {ann,con,decls}).
-%% -record(namespace, {ann,con,decls}).
--record(letfun, {ann,id,args,type,body}).
--record(type_def, {ann,id,vars,typedef}).
-
-%% Types
--record(app_t, {ann,id,fields}).
--record(tuple_t, {ann,args}).
--record(bytes_t, {ann,len}).
--record(record_t, {fields}).
--record(field_t, {ann,id,type}).
--record(alias_t, {type}).
--record(variant_t, {cons}).
--record(constr_t, {ann,con,args}).
--record(fun_t, {ann,named,args,type}).
-
-%% Tokens
--record(arg, {ann,id,type}).
--record(id, {ann,name}).
--record(con, {ann,name}).
--record(qid, {ann,names}).
--record(qcon, {ann,names}).
--record(tvar, {ann,name}).
-
-%% Statements
--record(block, {ann,body}).
--record('if', {ann,test,then,else}).            %Both statement and expression
--record(letval, {ann,pat,type,exp}).
--record(switch, {ann,arg,cases}).
--record('case', {ann,pat,body}).
-
-%% Expressions
--record(bool, {ann,bool}).
--record(int, {ann,value}).
--record(string, {ann,bin}).
--record(bytes, {ann,bin}).
--record(tuple, {ann,args}).
--record(list, {ann,args}).
--record(record, {ann,fields}).                  %Create a record
--record(field, {ann,name,value}).               %A record field
--record(proj, {ann,value}).                     %?
--record(map, {ann,fields}).                     %Create a map
--record(map_get, {ann,field}).
--record(lam, {ann,args,body}).
--record(app, {ann,func,args}).
--record(typed, {ann,expr,type}).
-
-%% The old deprecated interface.
-
-encode(C) -> encode_contract(C).
-encode(C, Os) -> encode_contract(C, Os).
-decode(J) -> decode_contract(J).
-
-%% encode_contract(ContractString) -> {ok,JSON} | {error,String}.
-%% encode_contract(ContractString, Options) -> {ok,JSON} | {error,String}.
-%%  Build a JSON structure with lists and tuples, not maps, as this
-%%  allows us to order the fields in the contructed JSON string.
-
-encode_contract(ContractString) -> 
-    encode_contract(ContractString, []).
-encode_contract(ContractString, Options) when is_binary(ContractString) ->
-    encode_contract(binary_to_list(ContractString), Options);
-encode_contract(ContractString, Options) ->
-    try
-        Ast = parse(ContractString, Options),
-        %% io:format("Ast\n~p\n", [Ast]),
-        %% aeso_ast:pp(Ast),
-        TypedAst = aeso_ast_infer_types:infer(Ast, Options),
-        %% io:format("Typed ast\n~p\n", [TypedAst]),
-        %% aeso_ast:pp_typed(TypedAst),
-        %% We find and look at the last contract.
-        Contract = lists:last(TypedAst),
-        Cname = contract_name(Contract),
-        Tdefs = do_encode_contract_typedefs(sort_decls(contract_types(Contract))),
-        Fdefs = [ do_encode_func(F) || F <- sort_decls(contract_funcs(Contract)),
-                                       not is_private_func(F) ],
-        Jmap = [{<<"contract">>,
-                 [{<<"name">>, do_encode_name(Cname)}] ++
-                     Tdefs ++
-                     [{<<"functions">>, Fdefs}]}],
-        %% io:format("~p\n", [Jmap]),
-        {ok,jsx:encode(Jmap)}
-    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")).
-
-%% do_encode_contract_typedefs(TypeDefs) -> [JSON].
-%%  Return a list of typedefs and state and event if they occur.
-
-do_encode_contract_typedefs(Tdefs) ->
-    Fun = fun(T, {Ts,Ss,Es}) ->
-                  %% Only one state and event.
-                  case typedef_name(T) of
-                      "state" -> {Ts,[do_encode_state_typedef(T)],Es};
-                      "event" -> {Ts,Ss,[do_encode_event_typedef(T)]};
-                      _Name  -> {Ts ++ [do_encode_typedef(T)],Ss,Es}
-                  end
-          end,
-    {Ts,Ss,Es} = lists:foldl(Fun, {[],[],[]}, Tdefs),
-    Ss ++ [{<<"type_defs">>, Ts}] ++ Es.
-
-%% do_encode_state_typedef(StateTdef) -> JSON.
-%% do_encode_event_typedef(EventTdef) -> JSON.
-
-do_encode_state_typedef(State) ->
-    Def = typedef_def(State),
-    {<<"state">>,do_encode_alias(Def)}.
-
-do_encode_event_typedef(State) ->
-    Def = typedef_def(State),
-    {<<"event">>,do_encode_alias(Def)}.
-
-%% encode_func(TypedAST) -> JSON.
-%%  Encode a function AST into a JSON structure.
-
-encode_func(AST) ->
-    jsx:encode(do_encode_func(AST)).
-
-%% do_encode_func(Function) -> JSONmap
-%%  Encode a function definition. Currently we are only interested in
-%%  the interface and type.
-
-do_encode_func(Fdef) ->
-    Name = function_name(Fdef),
-    Args = function_args(Fdef),
-    Type = function_type(Fdef),
-    [{<<"name">>, do_encode_name(Name)},
-     {<<"arguments">>, do_encode_args(Args)},
-     {<<"returns">>, do_encode_type(Type)},
-     {<<"stateful">>, is_stateful_func(Fdef)}].
-
-%% encode_arg(TypedAST) -> JSON.
-%%  Encode an argument AST into a JSON structure.
-
-encode_arg(AST) ->
-    jsx:encode(do_encode_arg(AST)).
-
-%% do_encode_args(ArgASTs) -> [JSONmap].
-%% do_encode_arg(ArgAST) -> JSONmap.
-
-do_encode_args(Args) ->
-    [ do_encode_arg(A) || A <- Args ].
-
-do_encode_arg(#arg{id=Id,type=T}) ->
-    [{<<"name">>,do_encode_type(Id)},
-     {<<"type">>,do_encode_type(T)}].
-
-%% encode_type(TypedAST) -> JSON.
-%%  Encode a type AST into a JSON structure.
-
-encode_type(AST) ->
-    jsx:encode(do_encode_type(AST)).
-
-%% do_encode_types([TypeAST]) -> [JSONmap].
-%% do_encode_type(TypeAST) -> JsonMap.
-
-do_encode_types(Types) ->
-    [ do_encode_type(T) || T <- Types ].
-
-do_encode_type(#tvar{name=N}) -> do_encode_name(N);
-do_encode_type(#id{name=N}) -> do_encode_name(N);
-do_encode_type(#con{name=N}) -> do_encode_name(N);
-do_encode_type(#qid{names=Ns}) ->
-    do_encode_name(lists:join(".", Ns));
-do_encode_type(#qcon{names=Ns}) ->
-    do_encode_name(lists:join(".", Ns));        %?
-do_encode_type(#tuple_t{args=As}) ->
-    Eas = do_encode_types(As),
-    [{<<"tuple">>,Eas}];
-do_encode_type(#bytes_t{len=Len}) ->
-    {<<"bytes">>,Len};
-do_encode_type(#record_t{fields=Fs}) ->
-    Efs = do_encode_type_rec_fields(Fs),
-    [{<<"record">>,Efs}];
-%% Special case lists and maps as they are built-in types.
-do_encode_type(#app_t{id=#id{name="list"},fields=[F]}) ->
-    Ef = do_encode_type(F),
-    [{<<"list">>,Ef}];
-do_encode_type(#app_t{id=#id{name="map"},fields=Fs}) ->
-    Ef = do_encode_type_mapo_field(Fs),
-    [{<<"map">>,Ef}];
-%% Other applications.
-do_encode_type(#app_t{id=Id,fields=Fs}) ->
-    Name = do_encode_type(Id),
-    Efs = do_encode_types(Fs),
-    [{Name,Efs}];
-do_encode_type(#variant_t{cons=Cs}) ->
-    Ecs = do_encode_types(Cs),
-    [{<<"variant">>,Ecs}];
-do_encode_type(#constr_t{con=C,args=As}) ->
-    Ec = do_encode_type(C),
-    Eas = do_encode_types(As),
-    [{Ec,Eas}];
-do_encode_type(#fun_t{args=As,type=T}) ->
-    Eas = do_encode_types(As),
-    Et = do_encode_type(T),
-    [{<<"function">>,[{<<"arguments">>,Eas},{<<"returns">>,Et}]}].
-
-do_encode_name(Name) ->
-    list_to_binary(Name).
-
-%% do_encode_type_rec_fields(Fields) -> [JSONmap].
-%% do_encode_type_rec_field(Field) -> JSONmap.
-%%  Encode a record field type.
-
-do_encode_type_rec_fields(Fs) ->
-    [ do_encode_type_rec_field(F) || F <- Fs ].
-
-do_encode_type_rec_field(#field_t{id=Id,type=T}) ->
-    [{<<"name">>,do_encode_type(Id)},
-     {<<"type">>,do_encode_type(T)}].
-
-%% do_encode_type_mapo_field(Field) -> JSONmap.
-%%  Two fields for one map type.
-
-do_encode_type_mapo_field([K,V]) ->
-    [{<<"key">>,do_encode_type(K)},
-     {<<"value">>,do_encode_type(V)}].
-
-%% do_encode_typedef(TypeDefAST) -> JSON.
-
-do_encode_typedef(Type) ->
-    Name = typedef_name(Type),
-    Vars = typedef_vars(Type),
-    Def = typedef_def(Type),
-    [{<<"name">>, do_encode_name(Name)},
-     {<<"vars">>, do_encode_tvars(Vars)},
-     {<<"typedef">>, do_encode_alias(Def)}].
-
-do_encode_tvars(Vars) ->
-    [ do_encode_tvar(V) || V <- Vars ].
-
-do_encode_tvar(#tvar{name=N}) ->
-    [{<<"name">>, do_encode_name(N)}].
-
-do_encode_alias(#alias_t{type=T}) ->
-    do_encode_type(T);
-do_encode_alias(A) -> do_encode_type(A).
-
-%% encode_stmt(StmtAST) -> JSON.
-%%  Encode a statement AST into a JSON structure.
-
-encode_stmt(AST) ->
-    jsx:encode(do_encode_stmt(AST)).
-
-%% do_encode_stmt(StmtAST) -> JSONmap.
-
-do_encode_stmt(#typed{expr=E}) ->               %Ignore the type
-    do_encode_stmt(E);
-do_encode_stmt(#block{body=Body}) ->
-    Eblock = [ do_encode_stmt(B) || B <- Body ],
-    [{<<"block">>,Eblock}];
-do_encode_stmt(#'if'{test=Test,then=Then,else=Else}) ->
-    %% This is both a statement and en expression.
-    Etest = do_encode_expr(Test),
-    Ethen = do_encode_stmt(Then),
-    Eelse = do_encode_stmt(Else),
-    [{<<"if">>,[{<<"test">>,Etest},{<<"then">>,Ethen},{<<"else">>,Eelse}]}];
-do_encode_stmt(#letval{pat=Pat,exp=Exp}) ->
-    Epat = do_encode_expr(Pat),
-    Eexp = do_encode_expr(Exp),
-    [{<<"let">>,[{<<"pattern">>,Epat},{<<"expression">>,Eexp}]}];
-do_encode_stmt(#switch{arg=Arg,cases=Cases}) ->
-    Earg = do_encode_expr(Arg),
-    Ecases = [ do_encode_stmt_case(Case) || Case <- Cases ],
-    [{<<"switch">>,[{<<"arg">>,Earg},{<<"cases">>,Ecases}]}];
-do_encode_stmt(E) ->
-    do_encode_expr(E).
-
-do_encode_stmt_case(#'case'{pat=Pat,body=Body}) ->
-    Epat = do_encode_expr(Pat),                 %Patterns are expessions
-    Ebody = do_encode_stmt(Body),
-    [{<<"pattern">>,Epat},{<<"body">>,Ebody}].
-
-%% encode_expr(ExprAST) -> JSON.
-%%  Encode an expression AST into a JSON structure.
-
-encode_expr(AST) ->
-    jsx:encode(do_encode_expr(AST)).
-
-%% do_encode_exprs(ExprASTs) -> [JSONmap].
-%% do_encode_expr(ExprAST) -> JSONmap.
-
-do_encode_exprs(Es) ->
-    [ do_encode_expr(E) || E <- Es ].
-
-do_encode_expr(#typed{expr=E}) ->               %Ignore the type
-    do_encode_expr(E);
-do_encode_expr(#id{name=N}) -> do_encode_name(N);
-do_encode_expr(#con{name=N}) -> do_encode_name(N);
-do_encode_expr(#qid{names=Ns}) ->
-    do_encode_name(lists:join(".", Ns));
-do_encode_expr(#qcon{names=Ns}) ->
-    do_encode_name(lists:join(".", Ns));        %?
-do_encode_expr(#bool{bool=B}) -> B;
-do_encode_expr(#int{value=V}) -> V;
-do_encode_expr(#string{bin=B}) ->
-    [{<<"string">>,B}];
-do_encode_expr(#bytes{bin=B}) -> B;
-do_encode_expr(#tuple{args=As}) ->
-    Eas = do_encode_exprs(As),
-    [{<<"tuple">>,Eas}];
-do_encode_expr(#list{args=As}) ->
-    Eas = do_encode_exprs(As),
-    [{<<"list">>,Eas}];
-do_encode_expr(#record{fields=Fs}) ->           %Create a record
-    Efs = do_encode_expr_rec_fields(Fs),
-    [{<<"create_record">>,Efs}];
-do_encode_expr({record,_Ann,Rec,Fs}) ->         %Update a record
-    Erec = do_encode_expr(Rec),
-    Efs = do_encode_expr_rec_fields(Fs),
-    [{<<"update_record">>,[Erec,Efs]}];
-do_encode_expr(#lam{args=As,body=B}) ->
-    Eas = do_encode_args(As),
-    Eb = do_encode_stmt(B),
-    [{<<"function">>,[{<<"arguments">>,Eas},{<<"body">>,Eb}]}];
-do_encode_expr(#map{fields=Fs}) ->              %Create a map
-    Efs = do_encode_expr_map_fields(Fs),
-    [{<<"create_map">>,Efs}];
-do_encode_expr({map,_Ann,Map,Fs}) ->            %Update a map
-    Emap = do_encode_expr(Map),
-    Efs = do_encode_expr_map_fields(Fs),
-    [{<<"update_map">>,[Emap,Efs]}];
-do_encode_expr(#map_get{field=F}) ->
-    do_encode_expr(F);
-do_encode_expr(#proj{value=V}) ->
-    do_encode_expr(V);
-do_encode_expr(#app{func=F,args=As}) ->
-    Ef = do_encode_expr(F),
-    Eas = do_encode_exprs(As),
-    [{<<"apply">>,[{<<"function">>,Ef},
-                   {<<"arguments">>,Eas}]}];
-do_encode_expr(#'if'{test=Test,then=Then,else=Else}) ->
-    %% This is both a statement and en expression.
-    Etest = do_encode_expr(Test),
-    Ethen = do_encode_expr(Then),
-    Eelse = do_encode_expr(Else),
-    [{<<"if">>,[{<<"test">>,Etest},{<<"then">>,Ethen},{<<"else">>,Eelse}]}];
-do_encode_expr({Op,_Ann}) ->
-    list_to_binary(atom_to_list(Op)).
-
-%% do_encode_expr_rec_fields(Fields) -> [JSON].
-%% do_encode_expr_rec_field(Field) -> JSON.
-%%  Encode a record field expression.
-
-do_encode_expr_rec_fields(Fs) ->
-    [ do_encode_expr_rec_field(F) || F <- Fs ].
-
-do_encode_expr_rec_field(#field{name=[N],value=V}) ->
-    [{<<"name">>,do_encode_expr(N)},
-     {<<"value">>,do_encode_expr(V)}].
-
-%% do_encode_expr_map_fields(Fields) -> [JSON].
-%% do_encode_expr_map_field(Field) -> JSON.
-%%  Encode a map field expression.
-
-do_encode_expr_map_fields(Fs) ->
-    [ do_encode_expr_map_field(F) || F <- Fs ].
-
-do_encode_expr_map_field({K,V}) ->
-    [{<<"key">>,do_encode_expr(K)},
-     {<<"value">>,do_encode_expr(V)}];
-do_encode_expr_map_field(#field{name=[K],value=V}) ->
-    [{<<"key">>,do_encode_expr(K)},
-     {<<"value">>,do_encode_expr(V)}].
-
-%% decode_contract(JSON) -> ContractString.
-%%  Decode a JSON string and generate a suitable contract string which
-%%  can be included in a contract definition. We decode into a map
-%%  here as this is easier to work with and order is not important.
-
-decode_contract(Json) ->
-    Map = jsx:decode(Json, [return_maps]),
-    %% io:format("~p\n", [Map]),
-    #{<<"contract">> := C} = Map,
-    #{<<"name">> := Name, <<"type_defs">> := Ts, <<"functions">> := Fs} = C,
-    CS = ["contract"," ",io_lib:format("~s", [Name])," =\n",
-          do_decode_tdefs(Ts),
-          do_decode_funcs(Fs)],
-    list_to_binary(CS).
-
-do_decode_funcs(Fs) -> [ do_decode_func(F) || F <- Fs ].
-
-do_decode_func(#{<<"name">> := <<"init">>}) -> [];
-do_decode_func(#{<<"name">> := Name,<<"arguments">> := As,<<"returns">> := T}) ->
-    ["  function"," ",io_lib:format("~s", [Name])," : ",
-     do_decode_args(As)," => ",do_decode_type(T),$\n].
-
-do_decode_args(As) ->
-    Das = [ do_decode_arg(A) || A <- As ],
-    [$(,lists:join(", ", Das),$)].
-
-do_decode_arg(#{<<"type">> := T}) -> do_decode_type(T).
-
-do_decode_types(Ets) ->
-    [ do_decode_type(Et) || Et <- Ets ].
-
-do_decode_type(#{<<"tuple">> := Ets}) ->
-    Ts = do_decode_types(Ets),
-    [$(,lists:join(", ", Ts),$)];
-do_decode_type(#{<<"record">> := Efs}) ->
-    Fs = do_decode_type_rec_fields(Efs),
-    [${,lists:join(", ", Fs),$}];
-do_decode_type(#{<<"list">> := Et}) ->
-    T = do_decode_type(Et),
-    ["list",$(,T,$)];
-do_decode_type(#{<<"map">> := Et}) ->
-    T = do_decode_type_map(Et),
-    ["map",$(,T,$)];
-do_decode_type(#{<<"variant">> := Ets}) ->
-    Ts = do_decode_types(Ets),
-    lists:join(" | ", Ts);
-do_decode_type(Econs) when is_map(Econs) ->     %General constructor
-    %% io:format("~p\n", [Econs]),
-    [{Ec,Ets}] = maps:to_list(Econs),
-    C = do_decode_name(Ec),
-    Ts = do_decode_types(Ets),
-    [C,$(,lists:join(", ", Ts),$)];
-do_decode_type(T) ->                            %Just raw names.
-    do_decode_name(T).
-
-do_decode_name(En) ->
-    binary_to_list(En).
-
-do_decode_type_rec_fields(Efs) ->
-    [ do_decode_type_rec_field(Ef) || Ef <- Efs ].
-
-do_decode_type_rec_field(#{<<"name">> := En,<<"type">> := Et}) ->
-    Name = do_decode_name(En),
-    Type = do_decode_type(Et),
-    [Name," : ",Type].
-
-do_decode_type_map(#{<<"key">> := Ek,<<"value">> := Ev}) ->
-    Key = do_decode_type(Ek),
-    Value = do_decode_type(Ev),
-    [Key,", ",Value].
-
-%% do_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.
-
-do_decode_tdefs(Ts) -> [ do_decode_tdef(T) ||
-                        #{<<"typedef">> := #{<<"variant">> := _}} = T <- Ts
-                    ].
-
-do_decode_tdef(#{<<"name">> := Name,<<"vars">> := Vs,<<"typedef">> := T}) ->
-    ["  datatype"," ",do_decode_name(Name),do_decode_tvars(Vs),
-     " = ",do_decode_type(T),$\n].
-
-do_decode_tvars([]) -> [];                      %No tvars, no parentheses
-do_decode_tvars(Vs) ->
-    Dvs = [ do_decode_tvar(V) || V <- Vs ],
-    [$(,lists:join(", ", Dvs),$)].
-
-do_decode_tvar(#{<<"name">> := N}) -> io_lib:format("~s", [N]).
-
-%% #contract{Ann, Con, [Declarations]}.
-
-contract_name(#contract{con=#con{name=N}}) -> N.
-
-contract_funcs(#contract{decls=Decls}) ->
-    [ D || D <- Decls, is_record(D, letfun) ].
-
-contract_types(#contract{decls=Decls}) ->
-    [ D || D <- Decls, is_record(D, type_def) ].
-
-%% To keep dialyzer happy and quiet.
-%% namespace_name(#namespace{con=#con{name=N}}) -> N.
-%%
-%% namespace_funcs(#namespace{decls=Decls}) ->
-%%     [ D || D <- Decls, is_record(D, letfun) ].
-%%
-%% namespace_types(#namespace{decls=Decls}) ->
-%%     [ D || D <- Decls, is_record(D, type_def) ].
-
-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).
-
-%% #letfun{Ann, Id, [Arg], Type, Typedef}.
-
-function_name(#letfun{id=#id{name=N}}) -> N.
-
-function_args(#letfun{args=Args}) -> Args.
-
-function_type(#letfun{type=Type}) -> Type.
-
-is_private_func(#letfun{ann=A}) -> aeso_syntax:get_ann(private, A, false).
-
-is_stateful_func(#letfun{ann=A}) -> aeso_syntax:get_ann(stateful, A, false).
-
-%% #type_def{Ann, Id, [Var], Typedef}.
-
-typedef_name(#type_def{id=#id{name=N}}) -> N.
-
-typedef_vars(#type_def{vars=Vars}) -> Vars.
-
-typedef_def(#type_def{typedef=Def}) -> Def.
-
-%% parse(ContractString, Options) -> {ok,AST}.
-%%  Signal errors, the sophia compiler way. Sigh!
-
-parse(Text, Options) ->
-    %% Try and return something sensible here!
-    case aeso_parser:string(Text, Options) of
-        %% Yay, it worked!
-        {ok, Contract} -> Contract;
-        %% Scan errors.
-        {error, {Pos, scan_error}} ->
-            parse_error(Pos, "scan error");
-        {error, {Pos, scan_error_no_state}} ->
-            parse_error(Pos, "scan error");
-        %% Parse errors.
-        {error, {Pos, parse_error, Error}} ->
-            parse_error(Pos, Error);
-        {error, {Pos, ambiguous_parse, As}} ->
-            ErrorString = io_lib:format("Ambiguous ~p", [As]),
-            parse_error(Pos, ErrorString);
-        %% Include error
-        {error, {Pos, include_error, File}} ->
-            parse_error(Pos, io_lib:format("could not find include file '~s'", [File]))
-    end.
-
-parse_error(Pos, ErrorString) ->
-    %% io:format("Error ~p ~p\n", [Pos,ErrorString]),
-    Error = io_lib:format("~s: ~s", [pos_error(Pos), ErrorString]),
-    error({parse_errors, [Error]}).
-
-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_ast.erl

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

src/aeso_ast_to_icode.erl

@@ -17,19 +17,11 @@
 
 -spec convert_typed(aeso_syntax:ast(), list()) -> aeso_icode:icode().
 convert_typed(TypedTree, 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(TypedTree, aeso_icode:new(Options)).
 
-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([{contract, _Attribs, {con, _, Name}, Code}|Rest], Icode) ->
+    NewIcode = contract_to_icode(Code,
+                                 aeso_icode:set_name(Name, Icode)),
     code(Rest, NewIcode);
 code([], Icode) ->
     add_default_init_function(add_builtins(Icode)).
@@ -41,38 +33,30 @@ gen_error(Error) ->
 
 %% Create default init function (only if state is unit).
 add_default_init_function(Icode = #{functions := Funs, state_type := State}) ->
-    {_, _, QInit} = aeso_icode:qualify({id, [], "init"}, Icode),
-    case lists:keymember(QInit, 1, Funs) of
+    case lists:keymember("init", 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 = {QInit, [], [], Value, Type},
+            DefaultInit = {"init", [], [], Value, Type},
             Icode#{ functions => [DefaultInit | Funs] }
     end.
 
 -spec contract_to_icode(aeso_syntax:ast(), aeso_icode:icode()) ->
                                aeso_icode:icode().
-contract_to_icode([{namespace, _, Name, Defs} | Rest], Icode) ->
-    NS = aeso_icode:get_namespace(Icode),
-    Icode1 = contract_to_icode(Defs, aeso_icode:enter_namespace(Name, Icode)),
-    contract_to_icode(Rest, aeso_icode:set_namespace(NS, Icode1));
-contract_to_icode([{type_def, _Attrib, Id = {id, _, Name}, Args, Def} | Rest],
+contract_to_icode([{type_def, _Attrib, {id, _, Name}, Args, Def} | Rest],
                   Icode = #{ types := Types, constructors := Constructors }) ->
     TypeDef = make_type_def(Args, Def, Icode),
     NewConstructors =
         case Def of
             {variant_t, Cons} ->
                 Tags = lists:seq(0, length(Cons) - 1),
-                GetName = fun({constr_t, _, C, _}) -> C end,
-                QName = fun(Con) -> {_, _, Xs} = aeso_icode:qualify(GetName(Con), Icode), Xs end,
-                maps:from_list([ {QName(Con), Tag} || {Tag, Con} <- lists:zip(Tags, Cons) ]);
+                GetName = fun({constr_t, _, {con, _, C}, _}) -> C end,
+                maps:from_list([ {GetName(Con), Tag} || {Tag, Con} <- lists:zip(Tags, Cons) ]);
             _ -> #{}
         end,
-    {_, _, TName} = aeso_icode:qualify(Id, Icode),
-    Icode1 = Icode#{ types := Types#{ TName => TypeDef },
+    Icode1 = Icode#{ types := Types#{ Name => TypeDef },
                      constructors := maps:merge(Constructors, NewConstructors) },
     Icode2 = case Name of
                 "state" when Args == [] -> Icode1#{ state_type => ast_typerep(Def, Icode) };
@@ -84,7 +68,8 @@ contract_to_icode([{type_def, _Attrib, Id = {id, _, Name}, Args, Def} | Rest],
     contract_to_icode(Rest, Icode2);
 contract_to_icode([{letfun, Attrib, Name, Args, _What, Body={typed,_,_,T}}|Rest], Icode) ->
     FunAttrs = [ stateful || proplists:get_value(stateful, Attrib, false) ] ++
-               [ private  || is_private(Attrib, Icode) ],
+               [ private  || proplists:get_value(private, Attrib, false) orelse
+                             proplists:get_value(internal, Attrib, false) ],
     %% TODO: Handle types
     FunName = ast_id(Name),
     %% TODO: push funname to env
@@ -99,8 +84,7 @@ 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,
-    QName    = aeso_icode:qualify(Name, Icode),
-    NewIcode = ast_fun_to_icode(ast_id(QName), FunAttrs, FunArgs, FunBody, TypeRep, Icode),
+    NewIcode = ast_fun_to_icode(FunName, FunAttrs, FunArgs, FunBody, TypeRep, Icode),
     contract_to_icode(Rest, NewIcode);
 contract_to_icode([{letrec,_,Defs}|Rest], Icode) ->
     %% OBS! This code ignores the letrec structure of the source,
@@ -110,14 +94,11 @@ contract_to_icode([{letrec,_,Defs}|Rest], Icode) ->
     %% just to parse a list of (mutually recursive) definitions.
     contract_to_icode(Defs++Rest, Icode);
 contract_to_icode([], Icode) -> Icode;
-contract_to_icode([{fun_decl, _, _, _} | Code], Icode) ->
-    contract_to_icode(Code, Icode);
-contract_to_icode([Decl | Code], Icode) ->
-    io:format("Unhandled declaration: ~p\n", [Decl]),
-    contract_to_icode(Code, Icode).
+contract_to_icode(_Code, Icode) ->
+    %% TODO debug output for debug("Unhandled code ~p~n",[Code]),
+    Icode.
 
-ast_id({id, _, Id}) -> Id;
-ast_id({qid, _, Id}) -> Id.
+ast_id({id, _, Id}) -> Id.
 
 ast_args([{arg, _, Name, Type}|Rest], Acc, Icode) ->
     ast_args(Rest, [{ast_id(Name), ast_type(Type, Icode)}| Acc], Icode);
@@ -140,7 +121,7 @@ ast_type(T, Icode) ->
 ast_body(?qid_app(["Chain","spend"], [To, Amount], _, _), Icode) ->
     prim_call(?PRIM_CALL_SPEND, ast_body(Amount, Icode), [ast_body(To, Icode)], [word], {tuple, []});
 
-ast_body(?qid_app([Con, "Chain", "event"], [Event], _, _), Icode = #{ contract_name := Con }) ->
+ast_body(?qid_app(["Chain","event"], [Event], _, _), Icode) ->
     aeso_builtins:check_event_type(Icode),
     builtin_call({event, maps:get(event_type, Icode)}, [ast_body(Event, Icode)]);
 
@@ -171,10 +152,10 @@ ast_body({qid, _, ["Chain", "spend"]}, _Icode) ->
     gen_error({underapplied_primitive, 'Chain.spend'});
 
 %% State
-ast_body({qid, _, [Con, "state"]}, #{ contract_name := Con }) -> prim_state;
-ast_body(?qid_app([Con, "put"], [NewState], _, _), Icode = #{ contract_name := Con }) ->
+ast_body({id, _, "state"}, _Icode) -> prim_state;
+ast_body(?id_app("put", [NewState], _, _), Icode) ->
     #prim_put{ state = ast_body(NewState, Icode) };
-ast_body({qid, _, [Con, "put"]}, #{ contract_name := Con }) ->
+ast_body({id, _, "put"}, _Icode) ->
     gen_error({underapplied_primitive, put});   %% TODO: eta
 
 %% Abort
@@ -182,11 +163,6 @@ ast_body(?id_app("abort", [String], _, _), Icode) ->
     #funcall{ function = #var_ref{ name = {builtin, abort} },
               args     = [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) ->
     {Sign, [Acct, QFee, TTL]} = get_signature_arg(Args),
@@ -340,28 +316,6 @@ ast_body({map, _, Map, [Upd]}, Icode) ->
 ast_body({map, Ann, Map, [Upd | Upds]}, Icode) ->
     ast_body({map, Ann, {map, Ann, Map, [Upd]}, Upds}, Icode);
 
-%% Crypto
-ast_body(?qid_app(["Crypto", "ecverify"], [Msg, PK, Sig], _, _), Icode) ->
-    prim_call(?PRIM_CALL_CRYPTO_ECVERIFY, #integer{value = 0},
-              [ast_body(Msg, Icode), ast_body(PK, Icode), ast_body(Sig, Icode)],
-              [word, word, sign_t()], word);
-
-ast_body(?qid_app(["Crypto", "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) ->
-    generic_hash_primop(?PRIM_CALL_CRYPTO_SHA256, Term, Type, Icode);
-ast_body(?qid_app(["Crypto", "blake2b"], [Term], [Type], _), Icode) ->
-    generic_hash_primop(?PRIM_CALL_CRYPTO_BLAKE2B, Term, Type, Icode);
-ast_body(?qid_app(["String", "sha256"], [String], _, _), Icode) ->
-    string_hash_primop(?PRIM_CALL_CRYPTO_SHA256_STRING, String, Icode);
-ast_body(?qid_app(["String", "blake2b"], [String], _, _), Icode) ->
-    string_hash_primop(?PRIM_CALL_CRYPTO_BLAKE2B_STRING, String, Icode);
-
 %% Strings
 %% -- String length
 ast_body(?qid_app(["String", "length"], [String], _, _), Icode) ->
@@ -377,33 +331,6 @@ ast_body(?qid_app(["String", "concat"], [String1, String2], _, _), Icode) ->
 ast_body(?qid_app(["String", "sha3"], [String], _, _), Icode) ->
     #unop{ op = 'sha3', rand = ast_body(String, Icode) };
 
-%% -- Bits
-ast_body(?qid_app(["Bits", Fun], Args, _, _), Icode)
-        when Fun == "test"; Fun == "set"; Fun == "clear";
-             Fun == "union"; Fun == "intersection"; Fun == "difference" ->
-    C  = fun(N) when is_integer(N) -> #integer{ value = N };
-            (X) -> X end,
-    Bin = fun(O) -> fun(A, B) -> #binop{ op = O, left = C(A), right = C(B) } end end,
-    And = Bin('band'),
-    Or  = Bin('bor'),
-    Bsl = fun(A, B) -> (Bin('bsl'))(B, A) end, %% flipped arguments
-    Bsr = fun(A, B) -> (Bin('bsr'))(B, A) end,
-    Neg = fun(A) -> #unop{ op = 'bnot', rand = C(A) } end,
-    case [Fun | [ ast_body(Arg, Icode) || Arg <- Args ]] of
-        ["test", Bits, Ix]     -> And(Bsr(Bits, Ix), 1);
-        ["set", Bits, Ix]      -> Or(Bits, Bsl(1, Ix));
-        ["clear", Bits, Ix]    -> And(Bits, Neg(Bsl(1, Ix)));
-        ["union", A, B]        -> Or(A, B);
-        ["intersection", A, B] -> And(A, B);
-        ["difference", A, B]   -> And(A, Neg(And(A, B)))
-    end;
-ast_body({qid, _, ["Bits", "none"]}, _Icode) ->
-    #integer{ value = 0 };
-ast_body({qid, _, ["Bits", "all"]}, _Icode) ->
-    #integer{ value = 1 bsl 256 - 1 };
-ast_body(?qid_app(["Bits", "sum"], [Bits], _, _), Icode) ->
-    builtin_call(popcount, [ast_body(Bits, Icode), #integer{ value = 0 }]);
-
 %% -- Conversion
 ast_body(?qid_app(["Int", "to_str"], [Int], _, _), Icode) ->
     builtin_call(int_to_str, [ast_body(Int, Icode)]);
@@ -413,27 +340,23 @@ ast_body(?qid_app(["Address", "to_str"], [Addr], _, _), Icode) ->
 
 %% Other terms
 ast_body({id, _, Name}, _Icode) ->
-    #var_ref{name = Name};
-ast_body({qid, _, Name}, _Icode) ->
+    %% TODO Look up id in env
     #var_ref{name = Name};
 ast_body({bool, _, Bool}, _Icode) ->        %BOOL as ints
     Value = if Bool -> 1 ; true -> 0 end,
     #integer{value = Value};
 ast_body({int, _, Value}, _Icode) ->
     #integer{value = Value};
-ast_body({bytes, _, Bin}, _Icode) ->
-    case aeb_memory:binary_to_words(Bin) of
-        [Word] -> #integer{value = Word};
-        Words  -> #tuple{cpts = [#integer{value = W} || W <- Words]}
+ast_body({hash, _, Hash}, _Icode) ->
+    case Hash of
+        <<Value:32/unit:8>> ->              %% address
+            #integer{value = Value};
+        <<Hi:32/unit:8, Lo:32/unit:8>> ->   %% signature
+            #tuple{cpts = [#integer{value = Hi},
+                           #integer{value = Lo}]}
     end;
-ast_body({Key, _, Bin}, _Icode) when Key == account_pubkey;
-                                     Key == contract_pubkey;
-                                     Key == oracle_pubkey;
-                                     Key == oracle_query_id ->
-    <<Value:32/unit:8>> = Bin,
-    #integer{value = Value};
 ast_body({string,_,Bin}, _Icode) ->
-    Cpts = [size(Bin) | aeb_memory:binary_to_words(Bin)],
+    Cpts = [size(Bin) | aeso_memory:binary_to_words(Bin)],
     #tuple{cpts = [#integer{value=X} || X <- Cpts]};
 ast_body({tuple,_,Args}, Icode) ->
     #tuple{cpts = [ast_body(A, Icode) || A <- Args]};
@@ -457,7 +380,7 @@ ast_body({app, _, {typed, _, {proj, _, {typed, _, Addr, {con, _, Contract}}, {id
     Gas    = proplists:get_value("gas",   ArgOpts ++ Defaults),
     Value  = proplists:get_value("value", ArgOpts ++ Defaults),
     OutType = ast_typerep(OutT, Icode),
-    <<TypeHash:256>> = aeb_abi:function_type_hash(list_to_binary(FunName), ArgType, OutType),
+    <<TypeHash:256>> = aeso_abi:function_type_hash(list_to_binary(FunName), ArgType, OutType),
     %% The function is represented by its type hash (which includes the name)
     Fun    = #integer{value = TypeHash},
     #prim_call_contract{
@@ -474,15 +397,9 @@ 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) ->
@@ -592,6 +509,12 @@ ast_binop(Op, Ann, {typed, _, A, Type}, B, Icode)
 ast_binop('++', _, A, B, Icode) ->
     #funcall{ function = #var_ref{ name = {builtin, list_concat} },
               args     = [ast_body(A, Icode), ast_body(B, Icode)] };
+ast_binop('bsl', _, A, B, Icode) ->
+    #binop{op = '*', left = ast_body(A, Icode),
+                     right = #binop{op = '^', left = {integer, 2}, right = ast_body(B, Icode)}};
+ast_binop('bsr', _, A, B, Icode) ->
+    #binop{op = 'div', left = ast_body(A, Icode),
+                       right = #binop{op = '^', left = {integer, 2}, right = ast_body(B, Icode)}};
 ast_binop(Op, _, A, B, Icode) ->
     #binop{op = Op, left = ast_body(A, Icode), right = ast_body(B, Icode)}.
 
@@ -658,7 +581,7 @@ prim_call(Prim, Amount, Args, ArgTypes, OutType) ->
             true ->
                 PrimBin = binary:encode_unsigned(Prim),
                 ArgType = {tuple, ArgTypes},
-                <<TH:256>> = aeb_abi:function_type_hash(PrimBin, ArgType, OutType),
+                <<TH:256>> = aeso_abi:function_type_hash(PrimBin, ArgType, OutType),
                 TH;
             false ->
                 0
@@ -670,16 +593,6 @@ prim_call(Prim, Amount, Args, ArgTypes, OutType) ->
                          type_hash= #integer{value = TypeHash}
                        }.
 
-generic_hash_primop(PrimOp, Term, Type, Icode) ->
-    ArgType   = ast_type(Type, Icode),
-    TypeValue = type_value(ArgType),
-    prim_call(PrimOp, #integer{value = 0},
-        [TypeValue, ast_body(Term, Icode)],
-        [typerep, ArgType], word).
-
-string_hash_primop(PrimOp, String, Icode) ->
-    prim_call(PrimOp, #integer{value = 0}, [ast_body(String, Icode)], [string], word).
-
 make_type_def(Args, Def, Icode = #{ type_vars := TypeEnv }) ->
     TVars = [ X || {tvar, _, X} <- Args ],
     fun(Types) ->
@@ -687,7 +600,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()) -> aeb_aevm_data:type().
+-spec ast_typerep(aeso_syntax:type()) -> aeso_sophia:type().
 ast_typerep(Type) -> ast_typerep(Type, aeso_icode:new([])).
 
 ast_typerep({id, _, Name}, Icode) ->
@@ -696,8 +609,6 @@ ast_typerep({qid, _, Name}, Icode) ->
     lookup_type_id(Name, [], Icode);
 ast_typerep({con, _, _}, _) ->
     word;   %% Contract type
-ast_typerep({bytes_t, _, Len}, _) ->
-    {bytes, Len};
 ast_typerep({app_t, _, {id, _, Name}, Args}, Icode) ->
     ArgReps = [ ast_typerep(Arg, Icode) || Arg <- Args ],
     lookup_type_id(Name, ArgReps, Icode);
@@ -725,8 +636,8 @@ ast_typerep({variant_t, Cons}, Icode) ->
 ttl_t(Icode) ->
     ast_typerep({qid, [], ["Chain", "ttl"]}, Icode).
 
-sign_t() -> bytes_t(64).
-bytes_t(Len) -> {bytes, Len}.
+sign_t() ->
+    {tuple, [word, word]}.
 
 get_signature_arg(Args0) ->
     NamedArgs = [Arg || Arg = {named_arg, _, _, _} <- Args0],
@@ -760,8 +671,6 @@ type_value({list, A}) ->
 type_value({tuple, As}) ->
     #tuple{ cpts = [#integer{ value = ?TYPEREP_TUPLE_TAG },
                     #list{ elems = [ type_value(A) || A <- As ] }] };
-type_value({bytes, Len}) ->
-    #tuple{ cpts = [#integer{ value = ?TYPEREP_BYTES_TAG }, #integer{ value = Len }] };
 type_value({variant, Cs}) ->
     #tuple{ cpts = [#integer{ value = ?TYPEREP_VARIANT_TAG },
                     #list{ elems = [ #list{ elems = [ type_value(A) || A <- As ] } || As <- Cs ] }] };
@@ -788,15 +697,6 @@ has_maps({list, T})     -> has_maps(T);
 has_maps({tuple, Ts})   -> lists:any(fun has_maps/1, Ts);
 has_maps({variant, Cs}) -> lists:any(fun has_maps/1, lists:append(Cs)).
 
-%% A function is private if 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
 %% -------------------------------------------------------------------
@@ -808,39 +708,3 @@ builtin_call(Builtin, Args) ->
 add_builtins(Icode = #{functions := Funs}) ->
     Builtins = aeso_builtins:used_builtins(Funs),
     Icode#{functions := [ aeso_builtins:builtin_function(B) || B <- Builtins ] ++ Funs}.
-
-
-%% -------------------------------------------------------------------
-%% Deadcode elimination
-%% -------------------------------------------------------------------
-
-deadcode_elimination(Icode = #{ functions := Funs }) ->
-    PublicNames = [ Name || {Name, Ann, _, _, _} <- Funs, not lists:member(private, Ann) ],
-    ArgsToPat   = fun(Args) -> [ #var_ref{ name = X } || {X, _} <- Args ] end,
-    Defs        = maps:from_list([ {Name, {binder, ArgsToPat(Args), Body}} || {Name, _, Args, Body, _} <- Funs ]),
-    UsedNames   = chase_names(Defs, PublicNames, #{}),
-    UsedFuns    = [ Def || Def = {Name, _, _, _, _} <- Funs, maps:is_key(Name, UsedNames) ],
-    Icode#{ functions := UsedFuns }.
-
-chase_names(_Defs, [], Used) -> Used;
-chase_names(Defs, [X | Xs], Used) ->
-                              %% can happen when compiling __call contracts
-    case maps:is_key(X, Used) orelse not maps:is_key(X, Defs) of
-        true  -> chase_names(Defs, Xs, Used); %% already chased
-        false ->
-            Def  = maps:get(X, Defs),
-            Vars = maps:keys(free_vars(Def)),
-            chase_names(Defs, Vars ++ Xs, Used#{ X => true })
-    end.
-
-free_vars(#var_ref{ name = X }) -> #{ X => true };
-free_vars(#arg{ name = X }) -> #{ X => true };
-free_vars({binder, Pat, Body}) ->
-    maps:without(maps:keys(free_vars(Pat)), free_vars(Body));
-free_vars(#switch{ expr = E, cases = Cases }) ->
-    free_vars([E | [{binder, P, B} || {P, B} <- Cases]]);
-free_vars(#lambda{ args = Xs, body = E }) ->
-    free_vars({binder, Xs, E});
-free_vars(T) when is_tuple(T) -> free_vars(tuple_to_list(T));
-free_vars([H | T]) -> maps:merge(free_vars(H), free_vars(T));
-free_vars(_) -> #{}.

src/aeso_blake2.erl

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

src/aeso_builtins.erl

@@ -38,7 +38,7 @@ builtin_deps1({map_upd, Type})            -> [{map_get, Type}, map_put];
 builtin_deps1({map_upd_default, Type})    -> [{map_lookup_default, Type}, map_put];
 builtin_deps1(map_from_list)              -> [map_put];
 builtin_deps1(str_equal)                  -> [str_equal_p];
-builtin_deps1(string_concat)              -> [string_concat_inner1, string_copy, string_shift_copy];
+builtin_deps1(string_concat)              -> [string_concat_inner1, string_concat_inner2];
 builtin_deps1(int_to_str)                 -> [{baseX_int, 10}];
 builtin_deps1(addr_to_str)                -> [{baseX_int, 58}];
 builtin_deps1({baseX_int, X})             -> [{baseX_int_pad, X}];
@@ -81,9 +81,8 @@ option_some(X) -> {tuple, [{integer, 1}, X]}.
 -define(EXP(A, B), op('^', A, B)).
 -define(AND(A, B), op('&&', A, B)).
 
-%% Bit shift operations takes their arguments backwards!?
--define(BSL(X, B), op('bsl', ?MUL(B, 8), X)).
--define(BSR(X, B), op('bsr', ?MUL(B, 8), X)).
+-define(BSL(X, B), ?MUL(X, ?EXP(2, ?MUL(B, 8)))).
+-define(BSR(X, B), ?DIV(X, ?EXP(2, ?MUL(B, 8)))).
 
 op(Op, A, B) -> {binop, Op, operand(A), operand(B)}.
 
@@ -94,7 +93,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) | aeb_memory:binary_to_words(BinStr)],
+    Cpts = [size(BinStr) | aeso_memory:binary_to_words(BinStr)],
     #tuple{ cpts = [ #integer{value = X} || X <- Cpts ] }.
 
 check_event_type(Icode) ->
@@ -106,22 +105,21 @@ check_event_type(Icode) ->
     end.
 
 check_event_type(Evts, Icode) ->
-    [ check_event_type(Name, Ix, T, Icode)
-      || {constr_t, Ann, {con, _, Name}, Types} <- Evts,
-         {Ix, T} <- lists:zip(aeso_syntax:get_ann(indices, Ann), Types) ].
+    [ check_event_type(Name, T, Icode)
+      || {constr_t, _, {con, _, Name}, Types} <- Evts, T <- Types ].
 
-check_event_type(EvtName, Ix, Type, Icode) ->
+check_event_type(EvtName, Type, Icode) ->
     VMType =
         try
            aeso_ast_to_icode:ast_typerep(Type, Icode)
         catch _:_ ->
             error({EvtName, could_not_resolve_type, Type})
         end,
-    case {Ix, VMType} 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})
+    case aeso_syntax:get_ann(indexed, Type, false) of
+        true when VMType == word    -> ok;
+        false when VMType == string -> ok;
+        true  -> error({EvtName, indexed_field_should_be_word, is, VMType});
+        false -> error({EvtName, payload_should_be_string, is, VMType})
     end.
 
 bfun(B, {IArgs, IExpr, IRet}) ->
@@ -145,11 +143,9 @@ builtin_function(BF) ->
         string_length              -> bfun(BF, builtin_string_length());
         string_concat              -> bfun(BF, builtin_string_concat());
         string_concat_inner1       -> bfun(BF, builtin_string_concat_inner1());
-        string_copy                -> bfun(BF, builtin_string_copy());
-        string_shift_copy          -> bfun(BF, builtin_string_shift_copy());
+        string_concat_inner2       -> bfun(BF, builtin_string_concat_inner2());
         str_equal_p                -> bfun(BF, builtin_str_equal_p());
         str_equal                  -> bfun(BF, builtin_str_equal());
-        popcount                   -> bfun(BF, builtin_popcount());
         int_to_str                 -> bfun(BF, builtin_int_to_str());
         addr_to_str                -> bfun(BF, builtin_addr_to_str());
         {baseX_int, X}             -> bfun(BF, builtin_baseX_int(X));
@@ -170,15 +166,16 @@ 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}, IxTypes) ->
-            Types     = [ T || {_Ix, T} <- IxTypes ],
-            Indexed   = [ Var || {Var, {indexed, _Type}} <- lists:zip(ArgPats(Types), IxTypes) ],
+        fun(_Tag, {con, _, Con}, Types) ->
+            Indexed   = [ Var || {Var, Type} <- lists:zip(ArgPats(Types), Types),
+                                 IsIndexed(Type) ],
             EvtIndex  = {unop, 'sha3', str_to_icode(Con)},
             {event, lists:reverse(Indexed) ++ [EvtIndex], Payload(ArgPats(Types) -- Indexed)}
         end,
@@ -189,8 +186,8 @@ builtin_event(EventT) ->
 
     {[{"e", event}],
      {switch, v(e),
-         [{Pat(Tag, Types), Clause(Tag, Con, lists:zip(aeso_syntax:get_ann(indices, Ann), Types))}
-          || {Tag, {constr_t, Ann, Con, Types}} <- lists:zip(Tags, Cons) ]},
+         [{Pat(Tag, Types), Clause(Tag, Con, Types)}
+          || {Tag, {constr_t, _, Con, Types}} <- lists:zip(Tags, Cons) ]},
      {tuple, []}}.
 
 %% Abort primitive.
@@ -324,17 +321,14 @@ builtin_string_concat() ->
     {[{"s1", string}, {"s2", string}],
      ?DEREF(n1, s1,
      ?DEREF(n2, s2,
-        {ifte, ?EQ(n1, 0),
-            ?V(s2), %% First string is empty return second string
-            {ifte, ?EQ(n2, 0),
-                ?V(s1), %% Second string is empty return first string
-                ?LET(ret, {inline_asm, [?A(?MSIZE)]},
-                    {seq, [?ADD(n1, n2), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]}, %% Store total len
-                           ?call(string_concat_inner1, [?V(n1), ?NXT(s1), ?V(n2), ?NXT(s2)]),
-                           {inline_asm, [?A(?POP)]}, %% Discard fun ret val
-                           ?V(ret)                   %% Put the actual return value
-                          ]})}
-        }
+        {ifte, ?EQ(n2, 0),
+            ?V(s1), %% Second string is empty return first string
+            ?LET(ret, {inline_asm, [?A(?MSIZE)]},
+                {seq, [?ADD(n1, n2), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]}, %% Store total len
+                       ?call(string_concat_inner1, [?V(n1), ?NXT(s1), ?V(n2), ?NXT(s2)]),
+                       {inline_asm, [?A(?POP)]}, %% Discard fun ret val
+                       ?V(ret)                   %% Put the actual return value
+                      ]})}
      )),
      word}.
 
@@ -342,33 +336,33 @@ builtin_string_concat_inner1() ->
     %% Copy all whole words from the first string, and set up for word fusion
     %% Special case when the length of the first string is divisible by 32.
     {[{"n1", word}, {"p1", pointer}, {"n2", word}, {"p2", pointer}],
-     ?LET(w1, ?call(string_copy, [?V(n1), ?V(p1)]),
-        ?LET(nx, ?MOD(n1, 32),
-        {ifte, ?EQ(nx, 0),
-            ?LET(w2, ?call(string_copy, [?V(n2), ?V(p2)]),
-                {seq, [?V(w2), {inline_asm, [?A(?MSIZE), ?A(?MSTORE), ?A(?MSIZE)]}]}),
-            ?call(string_shift_copy, [?V(nx), ?V(w1), ?V(n2), ?V(p2)])
-        })),
-     word}.
-
-builtin_string_copy() ->
-    {[{"n", word}, {"p", pointer}],
-     ?DEREF(w, p,
-        {ifte, ?GT(n, 31),
-            {seq, [?V(w), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
-                   ?call(string_copy, [?SUB(n, 32), ?NXT(p)])]},
-            ?V(w)
+     ?DEREF(w1, p1,
+        {ifte, ?GT(n1, 32),
+            {seq, [?V(w1), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
+                   ?call(string_concat_inner1, [?SUB(n1, 32), ?NXT(p1), ?V(n2), ?V(p2)])]},
+            {ifte, ?EQ(n1, 0),
+                ?call(string_concat_inner2, [?I(32), ?I(0), ?V(n2), ?V(p2)]),
+                ?call(string_concat_inner2, [?SUB(32, n1), ?V(w1), ?V(n2), ?V(p2)])}
         }),
      word}.
 
-builtin_string_shift_copy() ->
-    {[{"off", word}, {"dst", word}, {"n", word}, {"p", pointer}],
-     ?DEREF(w, p,
-        {seq, [?ADD(dst, ?BSR(w, off)), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
-               {ifte, ?GT(n, ?SUB(32, off)),
-                    ?call(string_shift_copy, [?V(off), ?BSL(w, ?SUB(32, off)), ?SUB(n, 32), ?NXT(p)]),
-                    {inline_asm, [?A(?MSIZE)]}}]
-        }),
+builtin_string_concat_inner2() ->
+    %% Current "work in progess" word 'x', has 'o' bytes that are "free" - fill them from
+    %% words of the second string.
+    {[{"o", word}, {"x", word}, {"n2", word}, {"p2", pointer}],
+     {ifte, ?LT(n2, 1),
+        {seq, [?V(x), {inline_asm, [?A(?MSIZE), ?A(?MSTORE), ?A(?MSIZE)]}]}, %% Use MSIZE as dummy return value
+        ?DEREF(w2, p2,
+            {ifte, ?GT(n2, o),
+                {seq, [?ADD(x, ?BSR(w2, ?SUB(32, o))),
+                       {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
+                       ?call(string_concat_inner2,
+                             [?V(o), ?BSL(w2, o), ?SUB(n2, 32), ?NXT(p2)])
+                      ]},
+                {seq, [?ADD(x, ?BSR(w2, ?SUB(32, o))),
+                       {inline_asm, [?A(?MSIZE), ?A(?MSTORE), ?A(?MSIZE)]}]} %% Use MSIZE as dummy return value
+            })
+     },
      word}.
 
 builtin_str_equal_p() ->
@@ -399,17 +393,6 @@ builtin_str_equal() ->
      )),
      word}.
 
-%% Count the number of 1s in a bit field.
-builtin_popcount() ->
-    %% function popcount(bits, acc) =
-    %%   if (bits == 0) acc
-    %%   else popcount(bits bsr 1, acc + bits band 1)
-    {[{"bits", word}, {"acc", word}],
-     {ifte, ?EQ(bits, 0),
-        ?V(acc),
-        ?call(popcount, [op('bsr', 1, bits), ?ADD(acc, op('band', bits, 1))])
-     }, word}.
-
 builtin_int_to_str() ->
     {[{"i", word}], ?call({baseX_int, 10}, [?V(i)]), word}.
 

src/aeso_compiler.erl

@@ -11,67 +11,42 @@
 -export([ file/1
         , file/2
         , from_string/2
-        , check_call/4
+        , check_call/2
         , create_calldata/3
         , version/0
         , sophia_type_to_typerep/1
-        , to_sophia_value/4
-        , to_sophia_value/5
-        , decode_calldata/3
         ]).
 
 -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
-                | {include, {file_system, [string()]} |
-                            {explicit_files, #{string() => binary()}}}
-                | {src_file, string()}.
+-type option() :: pp_sophia_code | pp_ast | pp_types | pp_typed_ast |
+                  pp_icode| pp_assembler | pp_bytecode.
 -type options() :: [option()].
 
 -export_type([ option/0
              , options/0
              ]).
 
--spec version() -> {ok, binary()} | {error, term()}.
+-define(COMPILER_VERSION_1, 1).
+-define(COMPILER_VERSION_2, 2).
+
+-define(COMPILER_VERSION, ?COMPILER_VERSION_2).
+
+-spec version() -> pos_integer().
 version() ->
-    case lists:keyfind(aesophia, 1, application:loaded_applications()) of
-        false ->
-            case application:load(aesophia) of
-                ok ->
-                    case application:get_key(aesophia, vsn) of
-                        {ok, VsnString} ->
-                            {ok, list_to_binary(VsnString)};
-                        undefined ->
-                            {error, failed_to_load_aesophia}
-                    end;
-                Err = {error, _} ->
-                    Err
-            end;
-        {_App, _Des, VsnString} ->
-            {ok, list_to_binary(VsnString)}
-    end.
+    ?COMPILER_VERSION.
 
 -spec file(string()) -> {ok, map()} | {error, binary()}.
 file(Filename) ->
-    Dir = filename:dirname(Filename),
-    {ok, Cwd} = file:get_cwd(),
-    file(Filename, [{include, {file_system, [Cwd, Dir]}}]).
+    file(Filename, []).
 
 -spec file(string(), options()) -> {ok, map()} | {error, binary()}.
 file(File, Options) ->
     case read_contract(File) of
-        {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)}
+        {ok, Bin} -> from_string(Bin, Options);
+        {error, Error} -> {error, {File, Error}}
     end.
 
 -spec from_string(binary() | string(), options()) -> {ok, map()} | {error, binary()}.
@@ -79,16 +54,22 @@ from_string(ContractBin, Options) when is_binary(ContractBin) ->
     from_string(binary_to_list(ContractBin), Options);
 from_string(ContractString, Options) ->
     try
-        #{icode := Icode} = string_to_icode(ContractString, Options),
-        TypeInfo  = extract_type_info(Icode),
-        Assembler = assemble(Icode, Options),
-        pp_assembler(Assembler, Options),
+        Ast = parse(ContractString, Options),
+        ok = pp_sophia_code(Ast, Options),
+        ok = pp_ast(Ast, Options),
+        TypedAst = aeso_ast_infer_types:infer(Ast, Options),
+        %% pp_types is handled inside aeso_ast_infer_types.
+        ok = pp_typed_ast(TypedAst, Options),
+        ICode = to_icode(TypedAst, Options),
+        TypeInfo = extract_type_info(ICode),
+        ok = pp_icode(ICode, Options),
+        Assembler =  assemble(ICode, Options),
+        ok = pp_assembler(Assembler, Options),
         ByteCodeList = to_bytecode(Assembler, Options),
         ByteCode = << << B:8 >> || B <- ByteCodeList >>,
-        pp_bytecode(ByteCode, Options),
-        {ok, Version} = version(),
+        ok = pp_bytecode(ByteCode, Options),
         {ok, #{byte_code => ByteCode,
-               compiler_version => Version,
+               compiler_version => version(),
                contract_source => ContractString,
                type_info => TypeInfo
               }}
@@ -104,68 +85,38 @@ from_string(ContractString, Options) ->
         %% General programming errors in the compiler just signal error.
     end.
 
--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(DECODE_NAME, "__decode").
+-define(CALL_NAME, "__call").
 
 %% Takes a string containing a contract with a declaration/prototype of a
-%% function (foo, say) and adds function __call() = foo(args) calling this
+%% function (foo, say) and a function __call() = foo(args) calling this
 %% function. Returns the name of the called functions, typereps and Erlang
 %% terms for the arguments.
-%% NOTE: Special treatment for "init" since it might be implicit and has
-%%       a special return type (typerep, T)
--spec check_call(string(), string(), [string()], options()) -> {ok, string(), {[Type], Type}, [term()]} | {error, term()}
+-spec check_call(string(), options()) -> {ok, string(), {[Type], Type | any}, [term()]} | {error, term()}
     when Type :: term().
-check_call(Source, "init" = FunName, Args, Options) ->
-    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) ->
+check_call(ContractString, Options) ->
     try
-        %% 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),
+        Ast = parse(ContractString, Options),
+        ok = pp_sophia_code(Ast, Options),
+        ok = pp_ast(Ast, Options),
+        TypedAst = aeso_ast_infer_types:infer(Ast, [permissive_address_literals]),
         {ok, {FunName, {fun_t, _, _, ArgTypes, RetType}}} = get_call_type(TypedAst),
+        ok = pp_typed_ast(TypedAst, Options),
+        Icode = to_icode(TypedAst, Options),
         ArgVMTypes = [ aeso_ast_to_icode:ast_typerep(T, Icode) || T <- ArgTypes ],
         RetVMType  = case RetType of
                          {id, _, "_"} -> any;
                          _            -> aeso_ast_to_icode:ast_typerep(RetType, Icode)
                      end,
+        ok = pp_icode(Icode, Options),
         #{ functions := Funs } = Icode,
         ArgIcode = get_arg_icode(Funs),
         ArgTerms = [ icode_to_term(T, Arg) ||
                        {T, Arg} <- lists:zip(ArgVMTypes, ArgIcode) ],
-        {ok, FunName, {ArgVMTypes, PatchFun(RetVMType)}, ArgTerms}
+        {ok, FunName, {ArgVMTypes, RetVMType}, ArgTerms}
     catch
         error:{parse_errors, Errors} ->
             {error, join_errors("Parse errors", Errors, fun (E) -> E end)};
@@ -179,205 +130,44 @@ check_call(ContractString0, FunName, Args, Options, PatchFun) ->
                                 fun (E) -> io_lib:format("~p", [E]) end)}
     end.
 
-%% 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, " "),
-          "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}]}};
+-spec create_calldata(map(), string(), string()) ->
+                             {ok, binary(), aeso_sophia:type(), aeso_sophia:type()}
+                                 | {error, argument_syntax_error}.
+create_calldata(Contract, "", CallCode) when is_map(Contract) ->
+    case check_call(CallCode, []) of
+        {ok, FunName, {ArgTypes, RetType}, Args} ->
+            aeso_abi:create_calldata(Contract, FunName, Args, ArgTypes, RetType);
         {error, _} = Err -> Err
     end;
-to_sophia_value(ContractString, FunName, ok, Data, 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) -> {int, [], N};
-translate_vm_value(word, {id, _, "bits"},    N) -> error({todo, bits, N});
-translate_vm_value(word, {id, _, "bool"},    N) -> {bool, [], N /= 0};
-translate_vm_value({bytes, Len}, {bytes_t, _, Len}, Val) when Len =< 32 ->
-    {bytes, [], <<Val:Len/unit:8>>};
-translate_vm_value({bytes, Len}, {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)}
+create_calldata(Contract, Function, Argument) when is_map(Contract) ->
+    %% Slightly hacky shortcut to let you get away without writing the full
+    %% call contract code.
+    %% Function should be "foo : type", and
+    %% Argument should be "Arg1, Arg2, .., ArgN" (no parens)
+    case string:lexemes(Function, ": ") of
+        %% If function is a single word fallback to old calldata generation
+        [FunName] -> aeso_abi:old_create_calldata(Contract, FunName, Argument);
+        [FunName | _] ->
+            Args    = lists:map(fun($\n) -> 32; (X) -> X end, Argument),    %% newline to space
+            CallContract = lists:flatten(
+                [ "contract Call =\n"
+                , "  function ", Function, "\n"
+                , "  function __call() = ", FunName, "(", Args, ")"
+                ]),
+            create_calldata(Contract, "", CallContract)
     end.
 
 
 get_arg_icode(Funs) ->
-    case [ Args || {[_, ?CALL_NAME], _, _, {funcall, _, Args}, _} <- Funs ] of
-        [Args] -> Args;
-        []     -> error({missing_call_function, Funs})
-    end.
+    [Args] = [ Args || {?CALL_NAME, _, _, {funcall, _, Args}, _} <- Funs ],
+    Args.
 
 get_call_type([{contract, _, _, Defs}]) ->
-    case [ {lists:last(QFunName), FunType}
+    case [ {FunName, FunType}
           || {letfun, _, {id, _, ?CALL_NAME}, [], _Ret,
                 {typed, _,
                     {app, _,
-                        {typed, _, {qid, _, QFunName}, FunType}, _}, _}} <- Defs ] of
+                        {typed, _, {id, _, FunName}, FunType}, _}, _}} <- Defs ] of
         [Call] -> {ok, Call};
         []     -> {error, missing_call_function}
     end;
@@ -385,28 +175,12 @@ 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 aeb_heap:to_binary().
+%% consumed by aeso_heap:to_binary().
 icode_to_term(word, {integer, N}) -> N;
 icode_to_term(string, {tuple, [{integer, Len} | Words]}) ->
     <<Str:Len/binary, _/binary>> = << <<W:256>> || {integer, W} <- Words >>,
     Str;
-icode_to_term({bytes, Len}, {integer, Value}) when Len =< 32 ->
-    Value;
-icode_to_term({bytes, Len}, {tuple, Words}) when Len > 32->
-    list_to_tuple([W || {integer, W} <- Words]);
 icode_to_term({list, T}, {list, Vs}) ->
     [ icode_to_term(T, V) || V <- Vs ];
 icode_to_term({tuple, Ts}, {tuple, Vs}) ->
@@ -435,7 +209,10 @@ icode_to_term(T, V) ->
 icodes_to_terms(Ts, Vs) ->
     [ icode_to_term(T, V) || {T, V} <- lists:zip(Ts, Vs) ].
 
-ast_to_icode(TypedAst, Options) ->
+parse(C,_Options) ->
+    parse_string(C).
+
+to_icode(TypedAst, Options) ->
     aeso_ast_to_icode:convert_typed(TypedAst, Options).
 
 assemble(Icode, Options) ->
@@ -449,9 +226,7 @@ to_bytecode([Op|Rest], Options) ->
 to_bytecode([], _) -> [].
 
 extract_type_info(#{functions := Functions} =_Icode) ->
-    ArgTypesOnly = fun(As) -> [ T || {_, T} <- As ] end,
-    TypeInfo = [aeb_abi:function_type_info(list_to_binary(lists:last(Name)),
-                                            ArgTypesOnly(Args), TypeRep)
+    TypeInfo = [aeso_abi:function_type_info(list_to_binary(Name), Args, TypeRep)
                 || {Name, Attrs, Args,_Body, TypeRep} <- Functions,
                    not is_tuple(Name),
                    not lists:member(private, Attrs)
@@ -486,9 +261,9 @@ sophia_type_to_typerep(String) ->
     catch _:_ -> {error, bad_type}
     end.
 
-parse(Text, Options) ->
+parse_string(Text) ->
     %% Try and return something sensible here!
-    case aeso_parser:string(Text, Options) of
+    case aeso_parser:string(Text) of
         %% Yay, it worked!
         {ok, Contract} -> Contract;
         %% Scan errors.
@@ -501,23 +276,13 @@ parse(Text, Options) ->
             parse_error(Pos, Error);
         {error, {Pos, ambiguous_parse, As}} ->
             ErrorString = io_lib:format("Ambiguous ~p", [As]),
-            parse_error(Pos, ErrorString);
-        %% Include error
-        {error, {Pos, include_error, File}} ->
-            parse_error(Pos, io_lib:format("could not find include file '~s'", [File]))
+            parse_error(Pos, ErrorString)
     end.
 
-parse_error(Pos, ErrorString) ->
-    Error = io_lib:format("~s: ~s", [pos_error(Pos), ErrorString]),
+parse_error({Line, Pos}, ErrorString) ->
+    Error = io_lib:format("line ~p, column ~p: ~s", [Line, Pos, ErrorString]),
     error({parse_errors, [Error]}).
 
 read_contract(Name) ->
     file:read_file(Name).
 
-pos_error({Line, Pos}) ->
-    io_lib:format("line ~p, column ~p", [Line, Pos]);
-pos_error({no_file, Line, Pos}) ->
-    pos_error({Line, Pos});
-pos_error({File, Line, Pos}) ->
-    io_lib:format("file ~s, line ~p, column ~p", [File, Line, Pos]).
-

src/aeso_heap.erl

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

src/aeso_icode.erl

@@ -9,30 +9,19 @@
 %%%-------------------------------------------------------------------
 -module(aeso_icode).
 
--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([new/1, pp/1, set_name/2, set_functions/2, map_typerep/2, option_typerep/1, get_constructor_tag/2]).
 -export_type([icode/0]).
 
 -include("aeso_icode.hrl").
 
--type type_def() :: fun(([aeb_aevm_data:type()]) -> aeb_aevm_data:type()).
+-type type_def() :: fun(([aeso_sophia:type()]) -> aeso_sophia:type()).
 
 -type bindings() :: any().
 -type fun_dec() :: { string()
                    , [modifier()]
                    , arg_list()
                    , expr()
-                   , aeb_aevm_data:type()}.
+                   , aeso_sophia:type()}.
 
 -type modifier() :: private | stateful.
 
@@ -40,13 +29,12 @@
 
 -type icode() :: #{ contract_name => string()
                   , functions => [fun_dec()]
-                  , namespace => aeso_syntax:con() | aeso_syntax:qcon()
                   , env => [bindings()]
-                  , state_type => aeb_aevm_data:type()
-                  , event_type => aeb_aevm_data:type()
+                  , state_type => aeso_sophia:type()
+                  , event_type => aeso_sophia:type()
                   , types => #{ type_name() => type_def() }
-                  , type_vars => #{ string() => aeb_aevm_data:type() }
-                  , constructors => #{ [string()] => integer() }  %% name to tag
+                  , type_vars => #{ string() => aeso_sophia:type() }
+                  , constructors => #{ string() => integer() }  %% name to tag
                   , options => [any()]
                   }.
 
@@ -71,7 +59,6 @@ builtin_types() ->
     Word = fun([]) -> word end,
     #{ "bool"         => Word
      , "int"          => Word
-     , "bits"         => Word
      , "string"       => fun([]) -> string end
      , "address"      => Word
      , "hash"         => Word
@@ -85,10 +72,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}.
@@ -103,30 +90,11 @@ 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,5 +1,14 @@
 
--include_lib("aebytecode/include/aeb_typerep_def.hrl").
+-define(Type(), aeso_sophia:type()).
+
+-define(TYPEREP_WORD_TAG,   0).
+-define(TYPEREP_STRING_TAG, 1).
+-define(TYPEREP_LIST_TAG,   2).
+-define(TYPEREP_TUPLE_TAG,  3).
+-define(TYPEREP_VARIANT_TAG, 4).
+-define(TYPEREP_TYPEREP_TAG, 5).
+-define(TYPEREP_MAP_TAG,     6).
+-define(TYPEREP_FUN_TAG,     7).
 
 -record(arg, {name::string(), type::?Type()}).
 
@@ -11,7 +20,7 @@
                  , args :: arg_list()
                  , body :: expr()}).
 
--record(var_ref, { name :: string() | list(string()) | {builtin, atom() | tuple()}}).
+-record(var_ref, { name :: string() | {builtin, atom() | tuple()}}).
 
 -record(prim_call_contract,
     { gas      :: expr()

src/aeso_icode_to_asm.erl

@@ -17,7 +17,7 @@
 i(Code) -> aeb_opcodes:mnemonic(Code).
 
 %% We don't track purity or statefulness in the type checker yet.
-is_stateful({FName, _, _, _, _}) -> lists:last(FName) /= "init".
+is_stateful({FName, _, _, _, _}) -> FName /= "init".
 
 is_public({_Name, Attrs, _Args, _Body, _Type}) -> not lists:member(private, Attrs).
 
@@ -105,7 +105,7 @@ make_args(Args) ->
 
 fun_hash({FName, _, Args, _, TypeRep}) ->
     ArgType = {tuple, [T || {_, T} <- Args]},
-    <<Hash:256>> = aeb_abi:function_type_hash(list_to_binary(lists:last(FName)), ArgType, TypeRep),
+    <<Hash:256>> = aeso_abi:function_type_hash(list_to_binary(FName), ArgType, TypeRep),
     {integer, Hash}.
 
 %% Expects two return addresses below N elements on the stack. Picks the top
@@ -562,8 +562,6 @@ assemble_infix('^')    -> i(?EXP);
 assemble_infix('bor')  -> i(?OR);
 assemble_infix('band') -> i(?AND);
 assemble_infix('bxor') -> i(?XOR);
-assemble_infix('bsl')  -> i(?SHL);
-assemble_infix('bsr')  -> i(?SHR);
 assemble_infix('<')    -> i(?SLT);    %% comparisons are SIGNED
 assemble_infix('>')    -> i(?SGT);
 assemble_infix('==')   -> i(?EQ);

src/aeso_icode_to_fate.erl

@@ -1,299 +0,0 @@
-%%%-------------------------------------------------------------------
-%%% @author Ulf Norell
-%%% @copyright (C) 2019, Aeternity Anstalt
-%%% @doc
-%%%     Fate backend for Sophia compiler
-%%% @end
-%%% Created : 11 Jan 2019
-%%%
-%%%-------------------------------------------------------------------
--module(aeso_icode_to_fate).
-
--include("aeso_icode.hrl").
-
--export([compile/2]).
-
-%% -- Preamble ---------------------------------------------------------------
-
--define(TODO(What), error({todo, ?FILE, ?LINE, ?FUNCTION_NAME, What})).
-
--define(i(__X__), {immediate, __X__}).
--define(a, {stack, 0}).
-
--record(env, { args = [], stack = [], tailpos = true }).
-
-%% -- Debugging --------------------------------------------------------------
-
-%% debug(Options, Fmt) -> debug(Options, Fmt, []).
-debug(Options, Fmt, Args) ->
-    case proplists:get_value(debug, Options, true) of
-        true  -> io:format(Fmt, Args);
-        false -> ok
-    end.
-
-%% -- Main -------------------------------------------------------------------
-
-%% @doc Main entry point.
-compile(ICode, Options) ->
-    #{ contract_name := _ContractName,
-       state_type    := _StateType,
-       functions     := Functions } = ICode,
-    SFuns  = functions_to_scode(Functions, Options),
-    SFuns1 = optimize_scode(SFuns, Options),
-    to_basic_blocks(SFuns1, Options).
-
-functions_to_scode(Functions, Options) ->
-    maps:from_list(
-        [ {list_to_binary(Name), function_to_scode(Name, Args, Body, Type, Options)}
-        || {Name, _Ann, Args, Body, Type} <- Functions, Name /= "init" ]).  %% TODO: skip init for now
-
-function_to_scode(Name, Args, Body, Type, Options) ->
-    debug(Options, "Compiling ~p ~p : ~p ->\n  ~p\n", [Name, Args, Type, Body]),
-    ArgTypes = [ icode_type_to_fate(T) || {_, T} <- Args ],
-    ResType  = icode_type_to_fate(Type),
-    SCode    = to_scode(init_env(Args), Body),
-    debug(Options, "  scode: ~p\n", [SCode]),
-    {{ArgTypes, ResType}, SCode}.
-
-%% -- Types ------------------------------------------------------------------
-
-%% TODO: the Fate types don't seem to be specified anywhere...
-icode_type_to_fate(word)           -> integer;
-icode_type_to_fate(string)         -> string;
-icode_type_to_fate({tuple, Types}) ->
-    {tuple, lists:map(fun icode_type_to_fate/1, Types)};
-icode_type_to_fate({list, Type})   ->
-    {list, icode_type_to_fate(Type)};
-icode_type_to_fate(typerep) -> typerep;
-icode_type_to_fate(Type) -> ?TODO(Type).
-
-%% -- Phase I ----------------------------------------------------------------
-%%  Icode to structured assembly
-
-%% -- Environment functions --
-
-init_env(Args) ->
-    #env{ args = Args, stack = [], tailpos = true }.
-
-push_env(Type, Env) ->
-    Env#env{ stack = [{"_", Type} | Env#env.stack] }.
-
-notail(Env) -> Env#env{ tailpos = false }.
-
-lookup_var(#env{ args = Args, stack = S }, X) ->
-    case {keyfind_index(X, 1, S), keyfind_index(X, 1, Args)} of
-        {false, false} -> false;
-        {false, Arg}   -> {arg, Arg};
-        {Local, _}     -> {stack, Local}
-    end.
-
-%% -- The compiler --
-
-to_scode(_Env, #integer{ value = N }) ->
-    [aeb_fate_code:push(?i(N))];    %% Doesn't exist (yet), translated by desugaring
-
-to_scode(Env, #var_ref{name = X}) ->
-    case lookup_var(Env, X) of
-        false      -> error({unbound_variable, X, Env});
-        {stack, N} -> [aeb_fate_code:dup(?i(N))];
-        {arg, N}   -> [aeb_fate_code:push({arg, N})]
-    end;
-to_scode(Env, #binop{ op = Op, left = A, right = B }) ->
-    [ to_scode(notail(Env), B)
-    , to_scode(push_env(binop_type_r(Op), Env), A)
-    , binop_to_scode(Op) ];
-
-to_scode(Env, #ifte{decision = Dec, then = Then, else = Else}) ->
-    [ to_scode(notail(Env), Dec)
-    , {ifte, to_scode(Env, Then), to_scode(Env, Else)} ];
-
-to_scode(_Env, Icode) -> ?TODO(Icode).
-
-%% -- Operators --
-
-binop_types('+')  -> {word, word};
-binop_types('-')  -> {word, word};
-binop_types('==') -> {word, word};
-binop_types(Op)   -> ?TODO(Op).
-
-%% binop_type_l(Op) -> element(1, binop_types(Op)).
-binop_type_r(Op) -> element(2, binop_types(Op)).
-
-binop_to_scode('+') -> add_a_a_a();  %% Optimization introduces other variants
-binop_to_scode('-') -> sub_a_a_a();
-binop_to_scode('==') -> eq_a_a_a().
-% binop_to_scode(Op) -> ?TODO(Op).
-
-add_a_a_a() -> aeb_fate_code:add(?a, ?a, ?a).
-sub_a_a_a() -> aeb_fate_code:sub(?a, ?a, ?a).
-eq_a_a_a() -> aeb_fate_code:eq(?a, ?a, ?a).
-
-%% -- Phase II ---------------------------------------------------------------
-%%  Optimize
-
-optimize_scode(Funs, Options) ->
-    maps:map(fun(Name, Def) -> optimize_fun(Funs, Name, Def, Options) end,
-             Funs).
-
-flatten(Code) -> lists:map(fun flatten_s/1, lists:flatten(Code)).
-
-flatten_s({ifte, Then, Else}) -> {ifte, flatten(Then), flatten(Else)};
-flatten_s(I) -> I.
-
-optimize_fun(_Funs, Name, {{Args, Res}, Code}, Options) ->
-    Code0 = flatten(Code),
-    debug(Options, "Optimizing ~s\n", [Name]),
-    debug(Options, "  original  : ~p\n", [Code0]),
-    Code1 = simplify(Code0),
-    debug(Options, "  simplified: ~p\n", [Code1]),
-    Code2 = desugar(Code1),
-    debug(Options, "  desugared : ~p\n", [Code2]),
-    {{Args, Res}, Code2}.
-
-simplify([]) -> [];
-simplify([I | Code]) ->
-    simpl_top(simpl_s(I), simplify(Code)).
-
-simpl_s({ifte, Then, Else}) ->
-    {ifte, simplify(Then), simplify(Else)};
-simpl_s(I) -> I.
-
-%% add_i 0 --> nop
-simpl_top({'ADD', _, ?i(0), _}, Code) -> Code;
-%% push n, add_a --> add_i n
-simpl_top({'PUSH', ?a, ?i(N)},
-          [{'ADD', ?a, ?a, ?a} | Code]) ->
-    simpl_top( aeb_fate_code:add(?a, ?i(N), ?a), Code);
-%% push n, add_i m --> add_i (n + m)
-simpl_top({'PUSH', ?a, ?i(N)}, [{'ADD', ?a, ?i(M), ?a} | Code]) ->
-    simpl_top(aeb_fate_code:push(?i(N + M)), Code);
-%% add_i n, add_i m --> add_i (n + m)
-simpl_top({'ADD', ?a, ?i(N), ?a}, [{'ADD', ?a, ?i(M), ?a} | Code]) ->
-    simpl_top({'ADD', ?a, ?i(N + M), ?a}, Code);
-
-simpl_top(I, Code) -> [I | Code].
-
-%% Desugar and specialize
-desugar({'ADD', ?a, ?i(1), ?a})     -> [aeb_fate_code:inc()];
-desugar({ifte, Then, Else}) -> [{ifte, desugar(Then), desugar(Else)}];
-desugar(Code) when is_list(Code) ->
-    lists:flatmap(fun desugar/1, Code);
-desugar(I) -> [I].
-
-%% -- Phase III --------------------------------------------------------------
-%%  Constructing basic blocks
-
-to_basic_blocks(Funs, Options) ->
-    maps:from_list([ {Name, {{Args, Res},
-                             bb(Name, Code ++ [aeb_fate_code:return()], Options)}}
-                     || {Name, {{Args, Res}, Code}} <- maps:to_list(Funs) ]).
-
-bb(Name, Code, Options) ->
-    Blocks0 = blocks(Code),
-    Blocks  = optimize_blocks(Blocks0),
-    Labels  = maps:from_list([ {Ref, I} || {I, {Ref, _}} <- with_ixs(Blocks) ]),
-    BBs     = [ set_labels(Labels, B) || B <- Blocks ],
-    debug(Options, "Final code for ~s:\n  ~p\n", [Name, BBs]),
-    maps:from_list(BBs).
-
-%% -- Break up scode into basic blocks --
-
-blocks(Code) ->
-    Top = make_ref(),
-    blocks([{Top, Code}], []).
-
-blocks([], Acc) ->
-    lists:reverse(Acc);
-blocks([{Ref, Code} | Blocks], Acc) ->
-    block(Ref, Code, [], Blocks, Acc).
-
-block(Ref, [], CodeAcc, Blocks, BlockAcc) ->
-    blocks(Blocks, [{Ref, lists:reverse(CodeAcc)} | BlockAcc]);
-block(Ref, [{ifte, Then, Else} | Code], Acc, Blocks, BlockAcc) ->
-    ThenLbl = make_ref(),
-    RestLbl = make_ref(),
-    block(Ref, Else ++ [{jump, RestLbl}],
-               [{jumpif, ThenLbl} | Acc],
-               [{ThenLbl, Then ++ [{jump, RestLbl}]},
-                {RestLbl, Code} | Blocks],
-               BlockAcc);
-block(Ref, [I | Code], Acc, Blocks, BlockAcc) ->
-    block(Ref, Code, [I | Acc], Blocks, BlockAcc).
-
-%% -- Reorder, inline, and remove dead blocks --
-
-optimize_blocks(Blocks) ->
-    %% We need to look at the last instruction a lot, so reverse all blocks.
-    Rev       = fun(Bs) -> [ {Ref, lists:reverse(Code)} || {Ref, Code} <- Bs ] end,
-    RBlocks   = Rev(Blocks),
-    RBlockMap = maps:from_list(RBlocks),
-    RBlocks1  = reorder_blocks(RBlocks, []),
-    RBlocks2  = [ {Ref, inline_block(RBlockMap, Ref, Code)} || {Ref, Code} <- RBlocks1 ],
-    RBlocks3  = remove_dead_blocks(RBlocks2),
-    Rev(RBlocks3).
-
-%% Choose the next block based on the final jump.
-reorder_blocks([], Acc) ->
-    lists:reverse(Acc);
-reorder_blocks([{Ref, Code} | Blocks], Acc) ->
-    reorder_blocks(Ref, Code, Blocks, Acc).
-
-reorder_blocks(Ref, Code, Blocks, Acc) ->
-    Acc1 = [{Ref, Code} | Acc],
-    case Code of
-        ['RETURN'|_]        -> reorder_blocks(Blocks, Acc1);
-        [{'RETURNR', _}|_]  -> reorder_blocks(Blocks, Acc1);
-        [{jump, L}|_]     ->
-            NotL = fun({L1, _}) -> L1 /= L end,
-            case lists:splitwith(NotL, Blocks) of
-                {Blocks1, [{L, Code1} | Blocks2]} ->
-                    reorder_blocks(L, Code1, Blocks1 ++ Blocks2, Acc1);
-                {_, []} -> reorder_blocks(Blocks, Acc1)
-            end
-    end.
-
-%% Inline short blocks (≤ 2 instructions)
-inline_block(BlockMap, Ref, [{jump, L} | Code] = Code0) when L /= Ref ->
-    case maps:get(L, BlockMap, nocode) of
-        Dest when length(Dest) < 3 ->
-            %% Remove Ref to avoid infinite loops
-            inline_block(maps:remove(Ref, BlockMap), L, Dest) ++ Code;
-        _ -> Code0
-    end;
-inline_block(_, _, Code) -> Code.
-
-%% Remove unused blocks
-remove_dead_blocks(Blocks = [{Top, _} | _]) ->
-    BlockMap   = maps:from_list(Blocks),
-    LiveBlocks = chase_labels([Top], BlockMap, #{}),
-    [ B || B = {L, _} <- Blocks, maps:is_key(L, LiveBlocks) ].
-
-chase_labels([], _, Live) -> Live;
-chase_labels([L | Ls], Map, Live) ->
-    Code = maps:get(L, Map),
-    Jump = fun({jump, A})   -> [A || not maps:is_key(A, Live)];
-              ({jumpif, A}) -> [A || not maps:is_key(A, Live)];
-              (_)                 -> [] end,
-    New  = lists:flatmap(Jump, Code),
-    chase_labels(New ++ Ls, Map, Live#{ L => true }).
-
-
-%% -- Translate label refs to indices --
-
-set_labels(Labels, {Ref, Code}) when is_reference(Ref) ->
-    {maps:get(Ref, Labels), [ set_labels(Labels, I) || I <- Code ]};
-set_labels(Labels, {jump, Ref})   -> aeb_fate_code:jump(maps:get(Ref, Labels));
-set_labels(Labels, {jumpif, Ref}) -> aeb_fate_code:jumpif(?a, maps:get(Ref, Labels));
-set_labels(_, I) -> I.
-
-%% -- Helpers ----------------------------------------------------------------
-
-with_ixs(Xs) ->
-    lists:zip(lists:seq(0, length(Xs) - 1), Xs).
-
-keyfind_index(X, J, Xs) ->
-    case [ I || {I, E} <- with_ixs(Xs), X == element(J, E) ] of
-        [I | _] -> I;
-        []      -> false
-    end.
-

src/aeso_memory.erl

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

src/aeso_parse_lib.erl

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

src/aeso_parser.erl

@@ -5,37 +5,28 @@
 -module(aeso_parser).
 
 -export([string/1,
-         string/2,
          type/1]).
 
 -include("aeso_parse_lib.hrl").
 
--type parse_result() :: {ok, aeso_syntax:ast()}
-                      | {error, {aeso_parse_lib:pos(), atom(), term()}}
-                      | {error, {aeso_parse_lib:pos(), atom()}}.
-
--spec string(string()) -> parse_result().
+-spec string(string()) ->
+                    {ok, aeso_syntax:ast()}
+                        | {error, {aeso_parse_lib:pos(),
+                                   atom(),
+                                   term()}}
+                        | {error, {aeso_parse_lib:pos(),
+                                   atom()}}.
 string(String) ->
-    string(String, []).
-
--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.
+  parse_and_scan(file(), String).
 
 type(String) ->
-    parse_and_scan(type(), String, []).
+  parse_and_scan(type(), String).
 
-parse_and_scan(P, S, Opts) ->
-    set_current_file(proplists:get_value(src_file, Opts, no_file)),
-    case aeso_scan:scan(S) of
-        {ok, Tokens} -> aeso_parse_lib:parse(P, Tokens);
-        Error        -> Error
-    end.
+parse_and_scan(P, S) ->
+  case aeso_scan:scan(S) of
+    {ok, Tokens} -> aeso_parse_lib:parse(P, Tokens);
+    Error        -> Error
+  end.
 
 %% -- Parsing rules ----------------------------------------------------------
 
@@ -45,9 +36,7 @@ decl() ->
     ?LAZY_P(
     choice(
       %% Contract declaration
-    [ ?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})
+    [ ?RULE(keyword(contract), con(), tok('='), maybe_block(decl()), {contract, _1, _2, _4})
 
       %% Type declarations  TODO: format annotation for "type bla" vs "type bla()"
     , ?RULE(keyword(type),     id(),                                          {type_decl, _1, _2, []})
@@ -68,14 +57,9 @@ decl() ->
 modifiers() ->
     many(choice([token(stateful), token(public), token(private), token(internal)])).
 
-add_modifiers([], Node) -> Node;
-add_modifiers(Mods = [Tok | _], Node) ->
-    %% Set the position to the position of the first modifier. This is
-    %% important for code transformation tools (like what we do in
-    %% create_calldata) to be able to get the indentation of the declaration.
-    set_pos(get_pos(Tok),
-        lists:foldl(fun({Mod, _}, X) -> set_ann(Mod, true, X) end,
-                    Node, Mods)).
+add_modifiers(Mods, Node) ->
+    lists:foldl(fun({Mod, _}, X) -> set_ann(Mod, true, X) end,
+                Node, Mods).
 
 %% -- Type declarations ------------------------------------------------------
 
@@ -136,15 +120,11 @@ type200() ->
 type300() -> type400().
 
 type400() ->
-    choice(
-    [?RULE(typeAtom(), optional(type_args()),
+    ?RULE(typeAtom(), optional(type_args()),
           case _2 of
             none       -> _1;
             {ok, Args} -> {app_t, get_ann(_1), _1, Args}
-          end),
-     ?RULE(id("bytes"), parens(token(int)),
-           {bytes_t, get_ann(_1), element(3, _2)})
-    ]).
+          end).
 
 typeAtom() ->
     ?LAZY_P(choice(
@@ -196,19 +176,19 @@ expr200() -> infixr(expr300(), binop('||')).
 expr300() -> infixr(expr400(), binop('&&')).
 expr400() -> infix(expr500(),  binop(['<', '>', '=<', '>=', '==', '!='])).
 expr500() -> infixr(expr600(), binop(['::', '++'])).
-expr600() -> infixl(expr650(), binop(['+', '-'])).
+expr600() -> infixl(expr650(), binop(['+', '-', 'bor', 'bxor', 'bsr', 'bsl'])).
 expr650() -> ?RULE(many(token('-')), expr700(), prefixes(_1, _2)).
-expr700() -> infixl(expr750(), binop(['*', '/', mod])).
+expr700() -> infixl(expr750(), binop(['*', '/', mod, 'band'])).
 expr750() -> infixl(expr800(), binop(['^'])).
-expr800() -> ?RULE(many(token('!')), expr900(), prefixes(_1, _2)).
+expr800() -> ?RULE(many(choice(token('!'), token('bnot'))), expr900(), prefixes(_1, _2)).
 expr900() -> ?RULE(exprAtom(), many(elim()), elim(_1, _2)).
 
 exprAtom() ->
     ?LAZY_P(begin
         Expr = ?LAZY_P(expr()),
         choice(
-        [ id_or_addr(), con(), token(qid), token(qcon)
-        , token(bytes), token(string), token(char)
+        [ id(), con(), token(qid), token(qcon)
+        , token(hash), token(string), token(char)
         , token(int)
         , ?RULE(token(hex), set_ann(format, hex, setelement(1, _1, int)))
         , {bool, keyword(true), true}
@@ -321,7 +301,6 @@ binop(Ops) ->
 con()      -> token(con).
 id()       -> token(id).
 tvar()     -> token(tvar).
-str()      -> token(string).
 
 token(Tag) ->
     ?RULE(tok(Tag),
@@ -330,26 +309,6 @@ token(Tag) ->
         {Tok, {Line, Col}, Val} -> {Tok, pos_ann(Line, Col), Val}
     end).
 
-id(Id) ->
-    ?LET_P({id, A, X} = Y, id(),
-           if X == Id -> Y;
-              true    -> fail({A, "expected 'bytes'"})
-           end).
-
-id_or_addr() ->
-    ?RULE(id(), parse_addr_literal(_1)).
-
-parse_addr_literal(Id = {id, Ann, Name}) ->
-    case lists:member(lists:sublist(Name, 3), ["ak_", "ok_", "oq_", "ct_"]) of
-        false -> Id;
-        true  ->
-            try aeser_api_encoder:decode(list_to_binary(Name)) of
-                {Type, Bin} -> {Type, Ann, Bin}
-            catch _:_ ->
-                Id
-            end
-    end.
-
 %% -- Helpers ----------------------------------------------------------------
 
 keyword(K) -> ann(tok(K)).
@@ -377,17 +336,10 @@ bracket_list(P) -> brackets(comma_sep(P)).
 -type ann_col()  :: aeso_syntax:ann_col().
 
 -spec pos_ann(ann_line(), ann_col()) -> ann().
-pos_ann(Line, Col) -> [{file, current_file()}, {line, Line}, {col, Col}].
-
-current_file() ->
-    get('$current_file').
-
-set_current_file(File) ->
-    put('$current_file', File).
+pos_ann(Line, Col) -> [{line, Line}, {col, Col}].
 
 ann_pos(Ann) ->
-    {proplists:get_value(file, Ann),
-     proplists:get_value(line, Ann),
+    {proplists:get_value(line, Ann),
      proplists:get_value(col, Ann)}.
 
 get_ann(Ann) when is_list(Ann) -> Ann;
@@ -405,10 +357,10 @@ set_ann(Key, Val, Node) ->
     setelement(2, Node, lists:keystore(Key, 1, Ann, {Key, Val})).
 
 get_pos(Node) ->
-    {current_file(), get_ann(line, Node), get_ann(col, Node)}.
+    {get_ann(line, Node), get_ann(col, Node)}.
 
-set_pos({F, L, C}, Node) ->
-    set_ann(file, F, set_ann(line, L, set_ann(col, C, Node))).
+set_pos({L, C}, Node) ->
+    set_ann(line, L, set_ann(col, C, Node)).
 
 infix(L, Op, R) -> set_ann(format, infix,  {app, get_ann(L), Op, [L, R]}).
 
@@ -481,7 +433,7 @@ parse_pattern(E = {id, _, _})     -> E;
 parse_pattern(E = {unit, _})      -> E;
 parse_pattern(E = {int, _, _})    -> E;
 parse_pattern(E = {bool, _, _})   -> E;
-parse_pattern(E = {bytes, _, _})  -> E;
+parse_pattern(E = {hash, _, _})   -> E;
 parse_pattern(E = {string, _, _}) -> E;
 parse_pattern(E = {char, _, _})   -> E;
 parse_pattern(E) -> bad_expr_err("Not a valid pattern", E).
@@ -490,10 +442,8 @@ parse_pattern(E) -> bad_expr_err("Not a valid pattern", E).
 parse_field_pattern({field, Ann, F, E}) ->
     {field, Ann, F, parse_pattern(E)}.
 
-return_error({no_file, L, C}, Err) ->
-    fail(io_lib:format("~p:~p:\n~s", [L, C, Err]));
-return_error({F, L, C}, Err) ->
-    fail(io_lib:format("In ~s at ~p:~p:\n~s", [F, L, C, Err])).
+return_error({L, C}, Err) ->
+    fail(io_lib:format("~p:~p:\n~s", [L, C, Err])).
 
 -spec ret_doc_err(ann(), prettypr:document()) -> no_return().
 ret_doc_err(Ann, Doc) ->
@@ -505,38 +455,3 @@ bad_expr_err(Reason, 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,8 +147,6 @@ 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),
@@ -236,12 +234,8 @@ type({app_t, _, Type, Args}) ->
     beside(type(Type), tuple_type(Args));
 type({tuple_t, _, Args}) ->
     tuple_type(Args);
-type({bytes_t, _, Len}) ->
-    text(lists:concat(["bytes(", Len, ")"]));
-type({named_arg_t, _, Name, Type, _Default}) ->
-    %% Drop the default value
-    %% follow(hsep(typed(name(Name), Type), text("=")), expr(Default));
-    typed(name(Name), Type);
+type({named_arg_t, _, Name, Type, Default}) ->
+    follow(hsep(typed(name(Name), Type), text("=")), expr(Default));
 
 type(R = {record_t, _}) -> typedef(R);
 type(T = {id, _, _})   -> name(T);
@@ -309,8 +303,6 @@ expr_p(P, E = {app, _, F = {Op, _}, Args}) when is_atom(Op) ->
         {prefix, [A]}   -> prefix(P, Op, A);
         _               -> app(P, F, Args)
     end;
-expr_p(_, {app, _, C={Tag, _, _}, []}) when Tag == con; Tag == qcon ->
-    expr_p(0, C);
 expr_p(P, {app, _, F, Args}) ->
     app(P, F, Args);
 %% -- Constants
@@ -321,17 +313,7 @@ expr_p(_, E = {int, _, N}) ->
            end,
     text(S);
 expr_p(_, {bool, _, B}) -> text(atom_to_list(B));
-expr_p(_, {bytes, _, Bin}) ->
-    Digits = byte_size(Bin),
-    <<N:Digits/unit:8>> = Bin,
-    text(lists:flatten(io_lib:format("#~*.16.0b", [Digits*2, N])));
-expr_p(_, {hash, _, <<N:512>>}) -> text("#" ++ integer_to_list(N, 16));
-expr_p(_, {Type, _, Bin})
-    when Type == account_pubkey;
-         Type == contract_pubkey;
-         Type == oracle_pubkey;
-         Type == oracle_query_id ->
-    text(binary_to_list(aeser_api_encoder:encode(Type, Bin)));
+expr_p(_, {hash, _, <<N:256>>}) -> text("#" ++ integer_to_list(N, 16));
 expr_p(_, {unit, _}) -> text("()");
 expr_p(_, {string, _, S}) -> term(binary_to_list(S));
 expr_p(_, {char, _, C}) ->
@@ -377,14 +359,20 @@ bin_prec('++')   -> {500, 600, 500};
 bin_prec('::')   -> {500, 600, 500};
 bin_prec('+')    -> {600, 600, 650};
 bin_prec('-')    -> {600, 600, 650};
+bin_prec('bor')  -> {600, 600, 650};
+bin_prec('bxor') -> {600, 600, 650};
+bin_prec('bsl')  -> {600, 600, 650};
+bin_prec('bsr')  -> {600, 600, 650};
 bin_prec('*')    -> {700, 700, 750};
 bin_prec('/')    -> {700, 700, 750};
 bin_prec(mod)    -> {700, 700, 750};
+bin_prec('band') -> {700, 700, 750};
 bin_prec('^')    -> {750, 750, 800}.
 
 -spec un_prec(aeso_syntax:un_op()) -> {integer(), integer()}.
 un_prec('-')    -> {650, 650};
-un_prec('!')    -> {800, 800}.
+un_prec('!')    -> {800, 800};
+un_prec('bnot') -> {800, 800}.
 
 equals(Ann, A, B) ->
     {app, [{format, infix} | Ann], {'=', Ann}, [A, B]}.

src/aeso_scan.erl

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

src/aeso_sophia.erl

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

src/aeso_syntax.erl

@@ -8,14 +8,14 @@
 
 -module(aeso_syntax).
 
--export([get_ann/1, get_ann/2, get_ann/3, set_ann/2, qualify/2]).
+-export([get_ann/1, get_ann/2, get_ann/3, set_ann/2]).
 
 -export_type([ann_line/0, ann_col/0, ann_origin/0, ann_format/0, ann/0]).
 -export_type([name/0, id/0, con/0, qid/0, qcon/0, tvar/0, op/0]).
 -export_type([bin_op/0, un_op/0]).
 -export_type([decl/0, letbind/0, typedef/0]).
--export_type([arg/0, field_t/0, constructor_t/0, named_arg_t/0]).
--export_type([type/0, constant/0, expr/0, arg_expr/0, field/1, stmt/0, alt/0, lvalue/0, elim/0, pat/0]).
+-export_type([arg/0, field_t/0, constructor_t/0]).
+-export_type([type/0, constant/0, expr/0, arg_expr/0, field/1, stmt/0, alt/0, lvalue/0, pat/0]).
 -export_type([ast/0]).
 
 -type ast() :: [decl()].
@@ -35,7 +35,6 @@
 -type tvar() :: {tvar, ann(), name()}.
 
 -type decl() :: {contract, ann(), con(), [decl()]}
-              | {namespace, ann(), con(), [decl()]}
               | {type_decl, ann(), id(), [tvar()]}
               | {type_def, ann(), id(), [tvar()], typedef()}
               | {fun_decl, ann(), id(), type()}
@@ -60,7 +59,6 @@
 -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().
@@ -71,20 +69,16 @@
     :: {int, ann(), integer()}
      | {bool, ann(), true | false}
      | {hash, ann(), binary()}
-     | {account_pubkey, binary()}
-     | {contract_pubkey, binary()}
-     | {oracle_pubkey, binary()}
-     | {oracle_query_id, binary()}
      | {unit, ann()}
      | {string, ann(), binary()}
      | {char, ann(), integer()}.
 
 -type op() :: bin_op() | un_op().
 
--type bin_op() :: '+' | '-' | '*' | '/' | mod | '^'
+-type bin_op() :: '+' | '-' | '*' | '/' | mod | '^' | 'band' | 'bor' | 'bsl' | 'bsr' | 'bxor'
                 | '++' | '::' | '<' | '>' | '=<' | '>=' | '==' | '!='
                 | '||' | '&&' | '..'.
--type un_op() :: '-' | '!'.
+-type un_op() :: '-' | '!' | 'bnot'.
 
 -type expr()
     :: {lam, ann(), [arg()], expr()}
@@ -146,8 +140,3 @@ get_ann(Key, Node) ->
 
 get_ann(Key, Node, Default) ->
     proplists:get_value(Key, get_ann(Node), Default).
-
-qualify({con, Ann, N}, X)             -> qualify({qcon, Ann, [N]}, X);
-qualify({qcon, _, NS}, {con, Ann, C}) -> {qcon, Ann, NS ++ [C]};
-qualify({qcon, _, NS}, {id, Ann, X})  -> {qid, Ann, NS ++ [X]}.
-

src/aeso_syntax_utils.erl

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

src/aesophia.app.src

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

src/aesophia.erl

@@ -4,10 +4,15 @@
 
 -define(OPT_SPEC,
     [ {src_file, undefined, undefined, string, "Sophia source code file"}
-    , {version, $V, "version", undefined, "Print compiler version"}
     , {verbose, $v, "verbose", undefined, "Verbose output"}
     , {help, $h, "help", undefined, "Show this message"}
-    , {outfile, $o, "out", string, "Output file (experimental)"} ]).
+    , {create_calldata, $c, "create_calldata", string,
+        "Create calldata with respect to (compiled) contract in this file"}
+    , {create_calldata_fun, undefined, "calldata_fun", string,
+        "Deprecated calldata creation - using function + arguments - function"}
+    , {create_calldata_args, undefined, "calldata_args", string,
+        "Deprecated calldata creation - using function + arguments - arguments"}
+    , {outfile, $o, "out", string, "Output the result to file (experimental)"} ]).
 
 usage() ->
     getopt:usage(?OPT_SPEC, "aesophia").
@@ -15,12 +20,13 @@ usage() ->
 main(Args) ->
     case getopt:parse(?OPT_SPEC, Args) of
         {ok, {Opts, []}} ->
-            case Opts of
-                [version] ->
-                    print_vsn();
-                [help] ->
+            IsHelp = proplists:get_value(help, Opts, false),
+            CreateCallData = proplists:get_value(create_calldata, Opts, undefined),
+            if  IsHelp ->
                     usage();
-                _ ->
+                CreateCallData /= undefined ->
+                    create_calldata(CreateCallData, Opts);
+                true ->
                     compile(Opts)
             end;
 
@@ -47,32 +53,83 @@ 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])
+    Res =
+        try aeso_compiler:file(File, [pp_ast || Verbose]) of
+            {ok, Map} ->
+                io:format("\nCompiled successfully!\n"),
+                {ok, Map};
+            {error, Reason} ->
+                io:format("\nError: ~p\n\n", [Reason]),
+                {error, Reason}
+        catch
+            error:Error ->
+                Where = hd(erlang:get_stacktrace()),
+                ErrorString = io_lib:format("Error: ~p in\n   ~p", [Error, Where]),
+                io:format("~s\n", [ErrorString]),
+                {error, list_to_binary(lists:flatten(ErrorString))}
+        end,
+    write_outfile(OutFile, Res).
+
+
+create_calldata(ContractFile, Opts) ->
+    case file:read_file(ContractFile) of
+        {ok, Bin} ->
+            try
+                Contract = binary_to_term(Bin),
+                create_calldata_(Contract, Opts)
+            catch _:_ ->
+                io:format("Error: Bad contract file ~s\n\n", [ContractFile]), usage()
+            end;
+        {error, _} ->
+            io:format("Error: Could not find file ~s\n\n", [ContractFile]), usage()
     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]).
 
-print_vsn() ->
-    {ok, Vsn} = aeso_compiler:version(),
-    io:format("Compiler version: ~s\n", [Vsn]).
+create_calldata_(Contract, Opts) ->
+    case proplists:get_value(src_file, Opts, undefined) of
+        undefined -> %% Check if old deprecated style is used
+            case {proplists:get_value(create_calldata_fun, Opts, undefined),
+                  proplists:get_value(create_calldata_args, Opts, undefined)} of
+                {undefined, _} ->
+                    io:format("Error: not enough create call data input\n\n"), usage();
+                {_, undefined} ->
+                    io:format("Error: not enough create call data input\n\n"), usage();
+                {Fun, Args} ->
+                    create_calldata(Contract, Fun, Args, Opts)
+            end;
+        CallFile ->
+            case file:read_file(CallFile) of
+                {ok, Bin} ->
+                    create_calldata(Contract, "", binary_to_list(Bin), Opts);
+                {error, _} ->
+                    io:format("Error: Could not find file ~s\n\n", [CallFile]), usage()
+            end
+    end.
+
+create_calldata(Contract, CallFun, CallArgs, Opts) ->
+    OutFile = proplists:get_value(outfile, Opts, undefined),
+
+    Res = try
+        case aeso_compiler:create_calldata(Contract, CallFun, CallArgs) of
+            {ok, CallData, _CallDataType, _OutputType} ->
+                io:format("Call data created successfully!\n"),
+                {ok, CallData};
+            Err = {error, Reason} ->
+                io:format("Error: Create calldata failed: ~p\n\n", [Reason]),
+                Err
+        end
+    catch
+        error:Error ->
+            Where = hd(erlang:get_stacktrace()),
+            ErrorString = io_lib:format("Error: ~p in\n   ~p", [Error, Where]),
+            io:format("~s\n", [ErrorString]),
+            {error, list_to_binary(lists:flatten(ErrorString))}
+    end,
+    write_outfile(OutFile, Res).
+
+
+write_outfile(undefined, _) -> ok;
+write_outfile(Out, Res)  ->
+    %% Lazy approach
+    file:write_file(Out, term_to_binary(Res)),
+    io:format("Output written to: ~s\n\n", [Out]).

test/aeso_abi_tests.erl

@@ -4,9 +4,6 @@
 -compile(export_all).
 
 -define(SANDBOX(Code), sandbox(fun() -> Code end)).
--define(DUMMY_HASH_WORD, 16#123).
--define(DUMMY_HASH, <<0:30/unit:8, 127, 119>>). %% 16#123
--define(DUMMY_HASH_LIT, "#0000000000000000000000000000000000000000000000000000000000000123").
 
 sandbox(Code) ->
     Parent = self(),
@@ -22,8 +19,8 @@ sandbox(Code) ->
 
 malicious_from_binary_test() ->
     CircularList = from_words([32, 1, 32]), %% Xs = 1 :: Xs
-    {ok, {error, circular_references}}   = ?SANDBOX(aeb_heap:from_binary({list, word}, CircularList)),
-    {ok, {error, {binary_too_short, _}}} = ?SANDBOX(aeb_heap:from_binary(word, <<1, 2, 3, 4>>)),
+    {ok, {error, circular_references}}   = ?SANDBOX(aeso_heap:from_binary({list, word}, CircularList)),
+    {ok, {error, {binary_too_short, _}}} = ?SANDBOX(aeso_heap:from_binary(word, <<1, 2, 3, 4>>)),
     ok.
 
 from_words(Ws) ->
@@ -57,143 +54,35 @@ encode_decode_test() ->
     ok.
 
 encode_decode_sophia_test() ->
-    Check = fun(Type, Str) -> case {encode_decode_sophia_string(Type, Str), Str} of
-                                {X, X} -> ok;
-                                Other -> Other
-                              end end,
-    ok = Check("int", "42"),
-    ok = Check("bool", "true"),
-    ok = Check("bool", "false"),
-    ok = Check("string", "\"Hello\""),
-    ok = Check("(string, list(int), option(bool))",
-               "(\"Hello\", [1, 2, 3], Some(true))"),
-    ok = Check("variant", "Blue({[\"x\"] = 1})"),
-    ok = Check("r", "{x = (\"foo\", 0), y = Red}"),
+    {42} = encode_decode_sophia_string("int", "42"),
+    {1} = encode_decode_sophia_string("bool", "true"),
+    {0} = encode_decode_sophia_string("bool", "false"),
+    {<<"Hello">>} = encode_decode_sophia_string("string", "\"Hello\""),
+    {<<"Hello">>, [1,2,3], {variant, 1, [1]}} =
+        encode_decode_sophia_string(
+          "(string, list(int), option(bool))",
+          "\"Hello\", [1,2,3], Some(true)"),
     ok.
 
 encode_decode_sophia_string(SophiaType, String) ->
     io:format("String ~p~n", [String]),
-    Code = [ "contract MakeCall =\n"
-           , "  type arg_type = ", SophiaType, "\n"
-           , "  type an_alias('a) = (string, 'a)\n"
-           , "  record r = {x : an_alias(int), y : variant}\n"
-           , "  datatype variant = Red | Blue(map(string, int))\n"
-           , "  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"
-        "  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).
+    Code = [ "contract Call =\n"
+           , "  function foo : ", SophiaType, " => _\n"
+           , "  function __call() = foo(", String, ")\n" ],
+    {ok, _, {Types, _}, Args} = aeso_compiler:check_call(lists:flatten(Code), []),
+    Arg  = list_to_tuple(Args),
+    Type = {tuple, Types},
+    io:format("Type ~p~n", [Type]),
+    Data = encode(Arg),
+    decode(Type, Data).
 
 encode_decode(T, D) ->
     ?assertEqual(D, decode(T, encode(D))),
     D.
 
 encode(D) ->
-    aeb_heap:to_binary(D).
+    aeso_heap:to_binary(D).
 
 decode(T,B) ->
-    {ok, D} = aeb_heap:from_binary(T, B),
+    {ok, D} = aeso_heap:from_binary(T, B),
     D.

test/aeso_aci_tests.erl

@@ -1,76 +0,0 @@
--module(aeso_aci_tests).
-
--include_lib("eunit/include/eunit.hrl").
-
-
-do_test() ->
-    test_contract(1),
-    test_contract(2),
-    test_contract(3).
-
-test_contract(N) ->
-    {Contract,MapACI,DecACI} = test_cases(N),
-    {ok,JSON} = aeso_aci:encode(Contract),
-    ?assertEqual(MapACI, jsx:decode(JSON, [return_maps])),
-    ?assertEqual(DecACI, aeso_aci:decode(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">> => <<"int">>}],
-                                <<"name">> => <<"a">>,
-                                <<"returns">> => <<"int">>,
-                                <<"stateful">> => false}]}},
-    DecACI = <<"contract C =\n"
-	       "  function a : (int) => int\n">>,
-    {Contract,MapACI,DecACI};
-test_cases(3) ->
-    Contract = <<"contract C =\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">>,
-		     <<"type_defs">> =>
-			 [#{<<"name">> => <<"bert">>,
-			    <<"typedef">> =>
-				#{<<"variant">> =>
-				      [#{<<"Bin">> => [<<"'a">>]}]},
-			    <<"vars">> => [#{<<"name">> => <<"'a">>}]}]}},
-    DecACI = <<"contract C =\n"
-	       "  datatype bert('a) = Bin('a)\n"
-	       "  function a : (C.bert(string)) => int\n">>,
-    {Contract,MapACI,DecACI}.

test/aeso_blake2_tests.erl

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

test/aeso_compiler_tests.erl

@@ -8,55 +8,31 @@
 
 -module(aeso_compiler_tests).
 
--compile([export_all, nowarn_export_all]).
-
 -include_lib("eunit/include/eunit.hrl").
 
+%% simple_compile_test_() -> ok.
 %%  Very simply test compile the given contracts. Only basic checks
 %%  are made on the output, just that it is a binary which indicates
 %%  that the compilation worked.
+
 simple_compile_test_() ->
+    {setup,
+     fun () -> ok end,                          %Setup
+     fun (_) -> ok end,                         %Cleanup
      [ {"Testing the " ++ ContractName ++ " contract",
         fun() ->
-            case compile(ContractName) of
-                #{byte_code := ByteCode,
-                  contract_source := _,
-                  type_info := _} -> ?assertMatch(Code when is_binary(Code), ByteCode);
-                ErrBin ->
-                    io:format("\n~s", [ErrBin]),
-                    error(ErrBin)
-            end
+            #{byte_code := ByteCode,
+              contract_source := _,
+              type_info := _} = compile(ContractName),
+            ?assertMatch(Code when is_binary(Code), ByteCode)
         end} || ContractName <- compilable_contracts() ] ++
      [ {"Testing error messages of " ++ ContractName,
         fun() ->
-            case compile(ContractName) of
-                <<"Type errors\n", ErrorString/binary>> ->
-                    check_errors(lists:sort(ExpectedErrors), ErrorString);
-                <<"Parse errors\n", ErrorString/binary>> ->
-                    check_errors(lists:sort(ExpectedErrors), ErrorString)
-            end
+            <<"Type errors\n",ErrorString/binary>> = compile(ContractName),
+            check_errors(lists:sort(ExpectedErrors), ErrorString)
         end} ||
-            {ContractName, ExpectedErrors} <- failing_contracts() ] ++
-     [ {"Testing include with explicit files",
-        fun() ->
-            FileSystem = maps:from_list(
-                [ begin
-                    {ok, Bin} = file:read_file(filename:join([aeso_test_utils:contract_path(), File])),
-                    {File, Bin}
-                  end || File <- ["included.aes", "../contracts/included2.aes"] ]),
-            #{byte_code := Code1} = compile("include", [{include, {explicit_files, FileSystem}}]),
-            #{byte_code := Code2} = compile("include"),
-            ?assertMatch(true, Code1 == Code2)
-        end} ] ++
-     [ {"Testing deadcode elimination",
-        fun() ->
-            #{ byte_code := NoDeadCode } = compile("nodeadcode"),
-            #{ byte_code := DeadCode   } = compile("deadcode"),
-            SizeNoDeadCode = byte_size(NoDeadCode),
-            SizeDeadCode   = byte_size(DeadCode),
-            ?assertMatch({_, _, true}, {SizeDeadCode, SizeNoDeadCode, SizeDeadCode + 40 < SizeNoDeadCode}),
-            ok
-        end} ].
+            {ContractName, ExpectedErrors} <- failing_contracts() ]
+    }.
 
 check_errors(Expect, ErrorString) ->
     %% This removes the final single \n as well.
@@ -68,13 +44,10 @@ check_errors(Expect, ErrorString) ->
     end.
 
 compile(Name) ->
-    compile(Name, [{include, {file_system, [aeso_test_utils:contract_path()]}}]).
-
-compile(Name, Options) ->
     String = aeso_test_utils:read_contract(Name),
-    case aeso_compiler:from_string(String, [{src_file, Name} | Options]) of
-        {ok, Map}            -> Map;
-        {error, ErrorString} -> ErrorString
+    case aeso_compiler:from_string(String, []) of
+        {ok,Map} -> Map;
+        {error,ErrorString} -> ErrorString
     end.
 
 %% compilable_contracts() -> [ContractName].
@@ -97,16 +70,7 @@ compilable_contracts() ->
      "stack",
      "test",
      "builtin_bug",
-     "builtin_map_get_bug",
-     "nodeadcode",
-     "deadcode",
-     "variant_types",
-     "state_handling",
-     "events",
-     "include",
-     "basic_auth",
-     "bitcoin_auth",
-     "address_literals"
+     "builtin_map_get_bug"
     ].
 
 %% Contracts that should produce type errors
@@ -186,11 +150,11 @@ 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)">>,
-        <<"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)">>]}
+        <<"No record type with fields y, z (at line 14, column 22)">>]}
     , {"init_type_error",
        [<<"Cannot unify string\n"
           "         and map(int, int)\n"
@@ -203,103 +167,4 @@ failing_contracts() ->
        [<<"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)">>]}
-    , {"namespace_clash",
-       [<<"The contract Call (at line 4, column 10) has the same name as a namespace at (builtin location)">>]}
-    , {"bad_events",
-        [<<"The payload type int (at line 10, column 30) should be string">>,
-         <<"The payload type alias_address (at line 12, column 30) equals address but it should be string">>,
-         <<"The indexed type string (at line 9, column 25) is not a word type">>,
-         <<"The indexed type alias_string (at line 11, 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)">>,
-         <<"The event constructor BadEvent3 (at line 11, column 7) has too many non-indexed values (max 1)">>,
-         <<"The payload type address (at line 11, column 17) should be string">>,
-         <<"The payload type int (at line 11, column 26) should be string">>]}
-    , {"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('1, '2)\n"
-           "         and Remote\n"
-           "when checking the type of the expression at line 25, column 5\n"
-           "  oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY :\n"
-           "    oracle_query('1, '2)\n"
-           "against the expected type\n"
-           "  Remote">>,
-         <<"Cannot unify oracle_query('3, '4)\n"
-           "         and bytes(32)\n"
-           "when checking the type of the expression at line 23, column 5\n"
-           "  oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY :\n"
-           "    oracle_query('3, '4)\n"
-           "against the expected type\n"
-           "  bytes(32)">>,
-         <<"Cannot unify oracle_query('5, '6)\n"
-           "         and oracle(int, bool)\n"
-           "when checking the type of the expression at line 21, column 5\n"
-           "  oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY :\n"
-           "    oracle_query('5, '6)\n"
-           "against the expected type\n"
-           "  oracle(int, bool)">>,
-         <<"Cannot unify oracle('7, '8)\n"
-           "         and Remote\n"
-           "when checking the type of the expression at line 18, column 5\n"
-           "  ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5 :\n"
-           "    oracle('7, '8)\n"
-           "against the expected type\n"
-           "  Remote">>,
-         <<"Cannot unify oracle('9, '10)\n"
-           "         and bytes(32)\n"
-           "when checking the type of the expression at line 16, column 5\n"
-           "  ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5 :\n"
-           "    oracle('9, '10)\n"
-           "against the expected type\n"
-           "  bytes(32)">>,
-         <<"Cannot unify oracle('11, '12)\n"
-           "         and oracle_query(int, bool)\n"
-           "when checking the type of the expression at line 14, column 5\n"
-           "  ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5 :\n"
-           "    oracle('11, '12)\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)">>]}
     ].

test/aeso_eunit_SUITE.erl

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

test/aeso_scan_tests.erl

@@ -48,7 +48,7 @@ all_tokens() ->
     %% Literals
     [ Lit(true), Lit(false)
     , Tok(id, "foo"), Tok(id, "_"), Tok(con, "Foo")
-    , Tok(bytes, Hash)
+    , Tok(hash, Hash)
     , Tok(int, 1234567890), Tok(hex, 9876543210)
     , Tok(string, <<"bla\"\\\b\e\f\n\r\t\vbla">>)
     ].
@@ -78,7 +78,7 @@ show_token({param, _, P}) -> "@" ++ P;
 show_token({string, _, S}) -> fmt(binary_to_list(S));
 show_token({int, _, N}) -> fmt(N);
 show_token({hex, _, N}) -> fmt("0x~.16b", N);
-show_token({bytes, _, <<N:256>>}) -> fmt("#~64.16.0b", N);
+show_token({hash, _, <<N:256>>}) -> fmt("#~.16b", N);
 show_token({comment, _, S}) -> S;
 show_token({_, _, _}) -> "TODO".
 

test/contract_tests.erl

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

test/contracts/address_literals.aes

@@ -1,14 +0,0 @@
-
-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,6 +36,8 @@ contract AllSyntax =
       (x, [y, z]) => bar({x = z, y = -y + - -z * (-1)})
       (x, y :: _) => ()
 
+  function bitOperations(x, y) = bnot (0xff00 band x bsl 4 bxor 0xa5a5a5 bsr 4 bor y)
+
   function mutual() =
     let rec recFun(x : int) = mutFun(x)
         and mutFun(x) = if(x =< 0) 1 else x * recFun(x - 1)

test/contracts/bad_address_literals.aes

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

@@ -1,25 +0,0 @@
-contract Events =
-  type alias_int = int
-  type alias_address = address
-  type alias_string = string
-
-  datatype event =
-      Event1(indexed alias_int, indexed int, string)
-    | Event2(alias_string, indexed alias_address)
-    | BadEvent1(indexed string, string)
-    | BadEvent2(indexed int, int)
-    | BadEvent3(indexed alias_string, string)
-    | BadEvent4(indexed int, alias_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_events2.aes

@@ -1,24 +0,0 @@
-contract Events =
-  type alias_int = int
-  type alias_address = address
-  type alias_string = string
-
-  datatype event =
-      Event1(indexed alias_int, indexed int, string)
-    | Event2(alias_string, indexed alias_address)
-    | BadEvent1(string, string)
-    | BadEvent2(indexed int, indexed int, indexed int, indexed address)
-    | BadEvent3(address, int)
-
-  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

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

test/contracts/basic_auth.aes

@@ -1,19 +0,0 @@
-// Contract replicating "normal" Aeternity authentication
-contract BasicAuth =
-  record state = { nonce : int, owner : address }
-
-  function init() = { nonce = 1, owner = Call.caller }
-
-  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

@@ -1,18 +0,0 @@
-contract BitcoinAuth =
-  record state = { nonce : int, owner : bytes(64) }
-
-  function init(owner' : bytes(64)) = { nonce = 1, owner = owner' }
-
-  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/chain.aes

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

test/contracts/deadcode.aes

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

@@ -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 = ak_11111111111111111111111111111111273Yts })
+    put(state{ beneficiary = #0 })
 
   private stateful function withdraw_contributor() =
     if(state.total >= state.goal)

test/contracts/include.aes

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

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

test/contracts/included2.aes

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

test/contracts/multi_sig.aes

@@ -5,7 +5,7 @@
 
 contract MultiSig =
 
-    record pending_state = { yetNeeded : int, ownersDone : bits, index : int }
+    record pending_state = { yetNeeded : uint, ownersDone : uint, index : uint }
 
     datatype event =
         Confirmation (address, hash)    // of { .owner : Address, .operation : Hash }
@@ -13,18 +13,18 @@ contract MultiSig =
       | OwnerChanged (address, address) // of { .oldOwner : Address, .newOwner : Address }
       | OwnerAdded   (address)          // of { .newOwner : Address }
       | OwnerRemoved (address)          // of { .removedOwner : Address }
-      | ReqChanged   (int)             // of { .newReq : int }
+      | ReqChanged   (uint)             // of { .newReq : uint }
 
-    let maxOwners : int = 250
+    let maxOwners : uint = 250
 
-    record state = { nRequired    : int
-                 , nOwners      : int
-                 , owners       : map(int, address)
-                 , ownerIndex   : map(address, int)
+    record state = { nRequired    : uint
+                 , nOwners      : uint
+                 , owners       : map(uint, address)
+                 , ownerIndex   : map(address, uint)
                  , pending      : map(hash, pending_state)
                  , pendingIndex : list(address) }
 
-    function init (owners : list(address), nRequired : int) : state =
+    function init (owners : list(address), nRequired : uint) : state =
       let n = length(owners) + 1
       { nRequired  = nRequired,
         nOwners    = n,
@@ -39,9 +39,10 @@ contract MultiSig =
     function revoke(operation : hash) =
       let ownerIx = lookup(state.ownerIndex, caller())
       let pending = lookup(state.pendingIndex, operation)
-      let _ = require(Bits.test(pending.ownersDone, ownerIx))
+      let ownerIxBit = 1 bsl (ownerIx - 1)
+      let _ = require(pending.ownersDone band ownerIxBit > 0)
       let pending' = pending { yetNeeded  = pending.yetNeeded + 1
-                             , ownersDone = Bits.clear(pending.ownersDone, ownerIx - 1) }
+                             , ownersDone = pending.ownersDone - ownerIxBit }
       put(state{ pendingIndex.operator = pending' })
       event(Revoke(caller, operation))
 
@@ -90,7 +91,7 @@ contract MultiSig =
                              , pendingIx = [] },
               event = [OwnerRemoved(oldOwner)] }
 
-    function changeRequirement(newReq : int) =
+    function changeRequirement(newReq : uint) =
       let _ = require(newReq =< state.nOwners)
       switch(check_pending(callhash()))
         CheckFail(state') => { state = state' }
@@ -101,7 +102,7 @@ contract MultiSig =
             event = [ReqChanged(newReq)] }
 
 
-    function getOwner(ownerIx0 : int) =
+    function getOwner(ownerIx0 : uint) =
       lookup(state.owners, ownerIx0 + 1)
 
     function isOwner(owner : address) =
@@ -115,7 +116,8 @@ contract MultiSig =
         Some(pending) =>
           let _ = require(isOwner(owner))
           let ownerIx = lookup(state.ownerIndex, owner)
-          Bits.test(pending.ownersDone, ownerIx - 1)
+          let ownerIxBit = 1 bsl (ownerIx - 1)
+          (pending.ownersDone band ownerIxBit) != 0
 
     /* Leave the rest for now... */
 

test/contracts/namespace_clash.aes

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

test/contracts/namespaces.aes

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

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

@@ -1,4 +1,5 @@
 // - + * / mod 	arithmetic operators
+// bnot band bor bxor bsl bsr 	bitwise operators
 // ! && || 	logical operators
 // == != < > =< >= 	comparison operators
 // :: ++ 	list operators
@@ -12,6 +13,12 @@ contract Operators =
       "/"    => a / b
       "mod"  => a mod b
       "^"    => a ^ b
+      "bnot" => bnot a
+      "band" => a band b
+      "bor"  => a bor b
+      "bxor" => a bxor b
+      "bsl"  => a bsl b
+      "bsr"  => a bsr b
 
   function bool_op(a : bool, b : bool, op : string) =
     switch(op)

test/contracts/simple_storage.aes

@@ -18,6 +18,7 @@
 
 contract SimpleStorage =
 
+  type event = int
   record state = { data : int }
 
   function init(value : int) : state = { data = value }

test/contracts/state_handling.aes

@@ -1,22 +1,19 @@
 contract Remote =
-  record rstate = { i : int, s : string, m : map(int, int) }
-
-  function look_at : (rstate) => ()
+  function look_at : (state) => ()
   function return_s : (bool) => string
   function return_m : (bool) => 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 get : (state) => state
+  function get_i : (state) => int
+  function get_s : (state) => string
+  function get_m : (state) => map(int, int)
 
-  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
+  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
 
 contract StateHandling =
-
-  type state = Remote.rstate
+  record state = { i : int, s : string, m : map(int, int) }
 
   function init(r : Remote, i : int) =
     let state0 = { i = 0, s = "undefined", m = {} }

test/contracts/type_clash.aes

@@ -1,13 +0,0 @@
-
-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()
-