Break out state and event from typedefs and update docs

.circleci/config.yml

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

.gitignore

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

CHANGELOG.md

@@ -9,269 +9,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 ### Removed
 
-## [6.0.0] 2021-05-26
-### Added
-- Child contracts
-- `Chain.clone`
-- `Chain.create`
-- `Chain.bytecode_hash`
-- Minor support for variadic functions
-- `void` type that represents an empty type
-- `Call.fee` builtin
-### Changed
-- Contract interfaces must be now invocated by `contract interface` keywords
-- `main` keyword to indicate the main contract in case there are child contracts around
-- `List.sum` and `List.product` no longer use `List.foldl`
-### Removed
-
-## [5.0.0] 2021-04-30
-### Added
-- A new and improved [`String` standard library](https://github.com/aeternity/aesophia/blob/master/docs/sophia_stdlib.md#string)
-  has been added. Use it by `include "String.aes"`. It includes functions for
-  turning strings into lists of characters for detailed manipulation. For
-  example:
-  ```
-  include "String.aes"
-  contract C =
-    entrypoint filter_all_a(s: string) : string =
-      String.from_list(List.filter((c : char) => c != 'a', String.to_list(s)))
-  ```
-  will return a list with all `a`'s removed.
-
-  There are also convenience functions `split`, `concat`, `to_upper`,
-  `to_lower`, etc.
-
-  All String functions in FATEv2 operate on unicode code points.
-- Operations for pairing-based cryptography has been added the operations
-  are in the standard library [BLS12_381](https://github.com/aeternity/aesophia/blob/master/docs/sophia_stdlib.md#bls12_381).
-  With these operations it is possible to do Zero Knowledge-proofs, etc.
-  The operations are for the BLS12-381 curve (as the name suggests).
-- Calls to functions in other contracts (i.e. _remote calls_) can now be
-  [`protected`](https://github.com/aeternity/aesophia/blob/master/docs/sophia.md#protected-contract-calls).
-  If a contract call fails for any reason (for instance, the remote contract
-  crashes or runs out of gas, or the entrypoint doesn't exist or has the
-  wrong type) the parent call also fails. To make it possible to recover
-  from failures, contract calls takes a named argument `protected : bool`
-  (default `false`).
-
-  If `protected = true` the result of the contract call is wrapped in an
-  `option`, and `Some(value)` indicates a succesful execution and `None`
-  indicates that the contract call failed. Note: any gas consumed until
-  the failure is still charged, but all side effects in the remote
-  contract are rolled back on failure.
-- A new chain operation [`AENS.update`](https://github.com/aeternity/aesophia/blob/master/docs/sophia.md#aens-interface)
-  is supported.
-- New chain exploring operations `AENS.lookup` and `Oracle.expiry` to
-  look up an AENS record and the expiry of an Oracle respectively, are added.
-- Transaction introspection (`Auth.tx`) has been added. When a Generalized
-  account is authorized, the authorization function needs access to the
-  transaction (and the transaction hash) for the wrapped transaction. The
-  transaction and the transaction hash is available `Auth.tx`, it is only
-  available during authentication if invoked by a normal contract call
-  it returns `None`. Example:
-  ```
-  switch(Auth.tx)
-    None      => abort("Not in Auth context")
-    Some(tx0) =>
-      switch(tx0.tx)
-        Chain.SpendTx(_, amount, _)  => amount > 400
-        Chain.ContractCallTx(_, _)   => true
-        _                            => false
-  ```
-- A debug mode is a added to the compiler. Right now its only use is to
-  turn off hermetization.
-### Changed
-- The function `Chain.block_hash(height)` is now (in FATEv2) defined for
-  the current height - this used to be an error.
-- Standard library: Sort is optimized to do `mergesort` and a `contains`
-  function is added.
-- Improved type errors and explicit errors for some syntax errors (empty code
-  blocks, etc.).
-- Compiler optimization: The ACI is generated alongside bytecode. This means
-  that multiple compiler passes can be avoided.
-- Compiler optimization: Improved parsing (less stack used when transpiled).
-- A bug where constraints were handled out of order fixed.
-- Fixed calldata decoding for singleton records.
-- Improved the documentation w.r.t. signatures, especially stressing the fact that
-  the network ID is a part of what is signed.
-### Removed
-
-## [4.3.0]
-### Added
-- Added documentation (moved from `protocol`)
-- `Frac.aes` – library for rational numbers
-- Added some more meaningful error messages
-- Exported several parsing functionalities
- - With option `keep_included` it is possible to see which files were included during the parse
- - There is a function `run_parser` that be used to evaluate any parsing rule
- - Exported parsers: `body`, `type` and `decl`
-### Changed
-- Performance improvements in the standard library
-- Fixed ACI encoder to handle `-` unary operator
-- Fixed including by absolute path
-- Fixed variant type printing in the ACI error messages
-- Fixed pretty printing of combined function clauses
-### Removed
-- `let` definitions are no longer supported in the toplevel of the contract
-- type declarations are no longer supported
-
-## [4.2.0] - 2020-01-15
-### Added
-- Allow separate entrypoint/function type signature and definition, and pattern
-  matching in left-hand sides:
-  ```
-    function
-      length : list('a) => int
-      length([])      = 0
-      length(x :: xs) = 1 + length(xs)
-  ```
-- Allow pattern matching in list comprehension generators (filtering out match
-  failures):
-  ```
-    function somes(xs : list(option('a))) : list('a) =
-      [ x | Some(x) <- xs ]
-  ```
-- Allow pattern matching in let-bindings (aborting on match failures):
-  ```
-    function test(m : map(int, int)) =
-        let Some(x) = Map.lookup(m, 0)
-        x
-  ```
-### Changed
-- FATE code generator improvements.
-- Bug fix: Handle qualified constructors in patterns.
-- Bug fix: Allow switching also on negative numbers.
-### Removed
-
-## [4.1.0] - 2019-11-26
-### Added
-- Support encoding and decoding bit fields in call arguments and results.
-### Changed
-- Various improvements to FATE code generator.
-### Removed
-
-## [4.0.0] - 2019-10-11
-### Added
-- `Address.to_contract` - casts an address to a (any) contract type.
-- Pragma to check compiler version, e.g. `@compiler >= 4.0`.
-- Handle numeric escapes, i.e. `"\x19Ethereum Signed Message:\n"`, and similar strings.
-- `Bytes.concat` and `Bytes.split` are added to be able to
-  (de-)construct byte arrays.
-- `[a..b]` language construct, returning the list of numbers between
-  `a` and `b` (inclusive). Returns the empty list if `a` > `b`.
-- [Standard libraries](https://github.com/aeternity/aesophia/blob/master/docs/sophia_stdlib.md)
-- Checks that `init` is not called from other functions.
-- FATE backend - the compiler is able to produce VM code for both `AEVM` and `FATE`. Many
-  of the APIs now take `{backend, aevm | fate}` to decide wich backend to produce artifacts
-  for.
-- New builtin functions `Crypto.ecrecover_secp256k1: (hash, bytes(65)) => option(bytes(20))`
-  and `Crypto.ecverify_secp256k1 : (hash, bytes(20), bytes(65)) => bool` for recovering
-  and verifying an Ethereum address for a message hash and a signature.
-- Sophia supports list comprehensions known from languages like Python, Haskell or Erlang.
-  Example syntax:
-```
-[x + y | x <- [1,2,3,4,5], let k = x*x, if (k > 5), y <- [k, k+1, k+2]]
-// yields [12,13,14,20,21,22,30,31,32]
-```
-- A new contract, and endpoint, modifier `payable` is introduced. Contracts, and enpoints,
-  that shall be able to receive funds should be marked as payable. `Address.is_payable(a)`
-  can be used to check if an (contract) address is payable or not.
-### Changed
-- Nice type error if contract function is called as from a namespace.
-- Fail on function definitions in contracts other than the main contract.
-- Bug fix in variable optimization - don't discard writes to the store/state.
-- Bug fixes in error reporting.
-- Bug fix in variable liveness analysis for FATE.
-- Error messages are changed into a uniform format, and more helpful
-  messages have been added.
-- `Crypto.<hash_fun>` and `String.<hash_fun>` for byte arrays now only
-  hash the actual byte array - not the internal ABI format.
-- More strict checks for polymorphic oracles and higher order oracles
-  and entrypoints.
-- `AENS.claim` is updated with a `NameFee` field - to be able to do
-  name auctions within contracts.
-- Fixed a bug in `Bytes.to_str` for AEVM.
-- New syntax for tuple types. Now 0-tuple type is encoded as `unit` instead of `()` and
-  regular tuples are encoded by interspersing inner types with `*`, for instance `int * string`.
-  Parens are not necessary. Note it only affects the types, values remain as their were before,
-  so `(1, "a") : int * string`
-- The `AENS.transfer` and `AENS.revoke` functions have been updated to take a name `string`
-  instead of a name `hash`.
-- Fixed a bug where the `AEVM` backend complained about a missing `init` function when
-  trying to generate calldata from an ACI-generated interface.
-- Compiler now returns the ABI-version in the compiler result map.
-- Renamed `Crypto.ecverify` and `Crypto.ecverify_secp256k1` into `Crypto.verify_sig` and
-  `Crypto.verify_sig_secp256k1` respectively.
-### Removed
-
-## [3.2.0] - 2019-06-28
-### Added
-- New builtin function `require : (bool, string) => ()`. Defined as
-    ```
-    function require(b, err) = if(!b) abort(err)
-    ```
-- New builtin functions
-    ```
-    Bytes.to_str : bytes(_) => string
-    Bytes.to_int : bytes(_) => int
-    ```
-  for converting a byte array to a hex string and interpreting it as a
-  big-endian encoded integer respectively.
-### Changed
-- Public contract functions must now be declared as *entrypoints*:
-  ```
-  contract Example =
-    // Exported
-    entrypoint exported_fun(x) = local_fun(x)
-    // Not exported
-    function local_fun(x) = x
-  ```
-  Functions in namespaces still use `function` (and `private function` for
-  private functions).
-- The return type of `Chain.block_hash(height)` has changed, it used to
-  be `int`, where `0` denoted an incorrect height. New return type is
-  `option(hash)`, where `None` represents an incorrect height.
-- Event name hashes now use BLAKE2b instead of Keccak256.
-- Fixed bugs when defining record types in namespaces.
-- Fixed a bug in include path handling when passing options to the compiler.
-### Removed
-
-## [3.1.0] - 2019-06-03
-### Added
-### Changed
-- Keyword `indexed` is now optional for word typed (`bool`, `int`, `address`,
-  ...) event arguments.
-- State variable pretty printing now produce `'a, 'b, ...` instead of `'1, '2, ...`.
-- ACI is restructured and improved:
-    - `state` and `event` types (if present) now appear at the top level.
-    - Namespaces and remote interfaces are no longer ignored.
-    - All type definitions are included in the interface rendering.
-    - API functions are renamed, new functions are `contract_interface`
-      and `render_aci_json`.
-- Fixed a bug in `create_calldata`/`to_sophia_value` - it can now handle negative
-  literals.
-### Removed
-
-## [3.0.0] - 2019-05-21
-### Added
-- `stateful` annotations are now properly enforced. Functions must be marked stateful
-  in order to update the state or spend tokens.
-- Primitives `Contract.creator`, `Address.is_contract`, `Address.is_oracle`,
-  `Oracle.check` and `Oracle.check_query` has been added to Sophia.
-- A byte array type `bytes(N)` has been added to generalize `hash (== bytes(32))` and
-  `signature (== bytes(64))` and allow for byte arrays of arbitrary fixed length.
-- `Crypto.ecverify_secp256k1` has been added.
-### Changed
-- Address literals (+ Oracle, Oracle query and remote contracts) have been changed
-  from `#<hex>` to address as `ak_<base58check>`, oracle `ok_<base58check>`,
-  oracle query `oq_<base58check>` and remote contract `ct_<base58check>`.
-- The compilation and typechecking of `letfun` (e.g. `let m(f, xs) = map(f, xs)`) was
-  not working properly and has been fixed.
-### Removed
-- `let rec` has been removed from the language, it has never worked.
-- The standalone CLI compiler is served in the repo `aeternity/aesophia_cli` and has
-  been completely removed from `aesophia`.
-
 ## [2.1.0] - 2019-04-11
 ### Added
 - Stubs (not yet wired up) for compilation to FATE
@@ -298,15 +35,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Simplify calldata creation - instead of passing a compiled contract, simply
   pass a (stubbed) contract string.
 
-[Unreleased]: https://github.com/aeternity/aesophia/compare/v6.0.0...HEAD
-[6.0.0]: https://github.com/aeternity/aesophia/compare/v5.0.0...v6.0.0
-[5.0.0]: https://github.com/aeternity/aesophia/compare/v4.3.0...v5.0.0
-[4.3.0]: https://github.com/aeternity/aesophia/compare/v4.2.0...v4.3.0
-[4.2.0]: https://github.com/aeternity/aesophia/compare/v4.1.0...v4.2.0
-[4.1.0]: https://github.com/aeternity/aesophia/compare/v4.0.0...v4.1.0
-[4.0.0]: https://github.com/aeternity/aesophia/compare/v3.2.0...v4.0.0
-[3.2.0]: https://github.com/aeternity/aesophia/compare/v3.1.0...v3.2.0
-[3.1.0]: https://github.com/aeternity/aesophia/compare/v3.0.0...v3.1.0
-[3.0.0]: https://github.com/aeternity/aesophia/compare/v2.1.0...v3.0.0
+[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

@@ -1,26 +1,21 @@
 # aesophia
 
-This is the __sophia__ compiler for the æternity system which compiles contracts written in __sophia__ to [FATE](https://github.com/aeternity/protocol/blob/master/contracts/fate.md) instructions.
+This is the __sophia__ compiler for the æternity system which compiles contracts written in __sophia__ code to the æternity VM code.
 
-The compiler is currently being used three places
- - [The command line compiler](https://github.com/aeternity/aesophia_cli)
- - [The HTTP compiler](https://github.com/aeternity/aesophia_http)
- - In [Aeternity node](https://github.com/aeternity/aeternity) tests
+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).
 
-## Documentation
-
-* [Smart Contracts on aeternity Blockchain](https://github.com/aeternity/protocol/blob/master/contracts/contracts.md).
-* [Sophia Documentation](docs/sophia.md).
-* [Sophia Standard Library](docs/sophia_stdlib.md).
+It is an OTP application written in Erlang and is by default included in
+[the æternity node](https://github.com/aeternity/epoch). However, it can
+also be included in other systems to compile contracts coded in sophia which
+can then be loaded into the æternity system.
 
 ## Versioning
 
-Versioning should follow the [semantic versioning](https://semver.org/spec/v2.0.0) guidelines. Id est, given a version number MAJOR.MINOR.PATCH, increment the:
-
-- MAJOR version when you make incompatible API changes
-- MINOR version when you add functionality in a backwards compatible manner
-- PATCH version when you make backwards compatible bug fixes
-
+`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
 

docs/aeso_aci.md

@@ -30,14 +30,53 @@ 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": [
       {
-        "arguments": [],
         "name": "init",
-        "returns": "Answers.state",
+        "arguments": [],
+        "returns": {
+          "record": [
+            {
+              "name": "a",
+              "type": {
+                "map": {
+                  "key": "string",
+                  "value": "int"
+                }
+              }
+            }
+          ]
+        },
         "stateful": true
       },
       {
+        "name": "new_answer",
         "arguments": [
           {
             "name": "q",
@@ -48,36 +87,14 @@ generates the following JSON structure representing the contract interface:
             "type": "int"
           }
         ],
-        "name": "new_answer",
         "returns": {
-          "map": [
-            "string",
-            "int"
-          ]
+          "map": {
+            "key": "string",
+            "value": "int"
+          }
         },
         "stateful": false
       }
-    ],
-    "name": "Answers",
-    "state": {
-      "record": [
-        {
-          "name": "a",
-          "type": "Answers.answers"
-        }
-      ]
-    },
-    "type_defs": [
-      {
-        "name": "answers",
-        "typedef": {
-          "map": [
-            "string",
-            "int"
-          ]
-        },
-        "vars": []
-      }
     ]
   }
 }
@@ -87,70 +104,118 @@ When that encoding is decoded the following include definition is generated:
 
 ```
 contract Answers =
-  record state = {a : Answers.answers}
-  type answers = map(string, int)
-  function init : () => Answers.state
   function new_answer : (string, int) => map(string, int)
 ```
 
 ### Types
-```erlang
--type aci_type()  :: json | string.
--type json()      :: jsx:json_term().
--type json_text() :: binary().
+``` erlang
+contract_string() = string() | binary()
+json_string() = binary()
 ```
 
 ### Exports
 
-#### contract\_interface(aci\_type(), string()) -> {ok, json() | string()} | {error, term()}
+#### encode_contract(ContractString) -> {ok,JSONstring} | {error,ErrorString}
 
-Generate the JSON encoding of the interface to a contract. The type definitions
-and non-private functions are included in the JSON string.
+Types
 
-#### render\_aci\_json(json() | json\_text()) -> string().
+``` erlang
+ConstractString = contract_string()
+JSONstring = json_string()
+```
 
-Take a JSON encoding of a contract interface and generate a contract interface
-that can be included in another contract.
+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.
+This is an example of using the ACI generator from an Erlang shell. The file called `aci_test.aes` contains the contract in the description from which we want to generate files `aci_test.json` which is the JSON encoding of the contract interface and `aci_test.include` which is the contract definition to be included inside another contract.
 
 ``` erlang
 1> {ok,Contract} = file:read_file("aci_test.aes").
-{ok,<<"contract Answers =\n  record state = { a : answers }\n  type answers() = map(string, int)\n\n  stateful function"...>>}
-2> {ok,JsonACI} = aeso_aci:contract_interface(json, Contract).
-{ok,[#{contract =>
-           #{functions =>
-                 [#{arguments => [],name => <<"init">>,
-                    returns => <<"Answers.state">>,stateful => true},
-                  #{arguments =>
-                        [#{name => <<"q">>,type => <<"string">>},
-                         #{name => <<"a">>,type => <<"int">>}],
-                    name => <<"new_answer">>,
-                    returns => #{<<"map">> => [<<"string">>,<<"int">>]},
-                    stateful => false}],
-             name => <<"Answers">>,
-             state =>
-                 #{record =>
-                       [#{name => <<"a">>,type => <<"Answers.answers">>}]},
-             type_defs =>
-                 [#{name => <<"answers">>,
-                    typedef => #{<<"map">> => [<<"string">>,<<"int">>]},
-                    vars => []}]}}]}
-3> file:write_file("aci_test.aci", jsx:encode(JsonACI)).
+{ok,<<"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> {ok,InterfaceStub} = aeso_aci:render_aci_json(JsonACI).
-{ok,<<"contract Answers =\n  record state = {a : Answers.answers}\n  type answers = map(string, int)\n  function init "...>>}
-5> file:write_file("aci_test.include", InterfaceStub).
+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(jsx:encode(JsonACI)).
-<<"[\n  {\n    \"contract\": {\n      \"functions\": [\n        {\n          \"arguments\": [],\n          \"name\": \"init\",\n        "...>>
+6> jsx:prettify(Encoding).
+<<"{\n  \"contract\": {\n    \"name\": \"Answers\",\n    \"state\": {\n      \"record\": [\n        {\n          \"name\": \"a\",\n         "...>>
 ```
 
-The final call to `jsx:prettify(jsx:encode(JsonACI))` returns the encoding in a
-more easily readable form. This is what is shown in the description above.
+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`.

priv/stdlib/BLS12_381.aes

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

priv/stdlib/Frac.aes

@@ -1,183 +0,0 @@
-namespace Frac =
-
-  private function gcd(a : int, b : int) =
-    if (b == 0) a else gcd(b, a mod b)
-
-  private function abs_int(a : int) = if (a < 0) -a else a
-
-  datatype frac = Pos(int, int) | Zero | Neg(int, int)
-
-/** Checks if the internal representation is correct.
-  * Numerator and denominator must be positive.
-  * Exposed for debug purposes
-  */
-  function is_sane(f : frac) : bool = switch(f)
-    Pos(n, d) => n > 0 && d > 0
-    Zero => true
-    Neg(n, d) => n > 0 && d > 0
-
-  function num(f : frac) : int = switch(f)
-    Pos(n, _) => n
-    Neg(n, _) => -n
-    Zero      => 0
-
-  function den(f : frac) : int = switch(f)
-    Pos(_, d) => d
-    Neg(_, d) => d
-    Zero      => 1
-
-  function to_pair(f : frac) : int * int = switch(f)
-    Pos(n, d) => (n, d)
-    Neg(n, d) => (-n, d)
-    Zero      => (0, 1)
-
-  function sign(f : frac) : int = switch(f)
-    Pos(_, _) => 1
-    Neg(_, _) => -1
-    Zero      => 0
-
-  function to_str(f : frac) : string = switch(f)
-    Pos(n, d) => String.concat(Int.to_str(n), if (d == 1) "" else String.concat("/", Int.to_str(d)))
-    Neg(n, d) => String.concat("-", to_str(Pos(n, d)))
-    Zero      => "0"
-
-/** Reduce fraction to normal form
- */
-  function simplify(f : frac) : frac =
-    switch(f)
-      Neg(n, d) =>
-        let cd = gcd(n, d)
-        Neg(n / cd, d / cd)
-      Zero  => Zero
-      Pos(n, d)  =>
-        let cd = gcd(n, d)
-        Pos(n / cd, d / cd)
-
-/** Integer to rational division
- */
-  function make_frac(n : int, d : int) : frac =
-    if (d == 0) abort("Zero denominator")
-    elif (n == 0) Zero
-    elif ((n < 0) == (d < 0)) simplify(Pos(abs_int(n), abs_int(d)))
-    else simplify(Neg(abs_int(n), abs_int(d)))
-
-  function one() : frac = Pos(1, 1)
-  function zero() : frac = Zero
-
-  function eq(a : frac, b : frac) : bool =
-    let (na, da) = to_pair(a)
-    let (nb, db) = to_pair(b)
-    (na == nb && da == db) || na * db == nb * da // they are more likely to be normalized
-
-  function neq(a : frac, b : frac) : bool =
-    let (na, da) = to_pair(a)
-    let (nb, db) = to_pair(b)
-    (na != nb || da != db) && na * db != nb * da
-
-  function geq(a : frac, b : frac) : bool = num(a) * den(b) >= num(b) * den(a)
-
-  function leq(a : frac, b : frac) : bool = num(a) * den(b) =< num(b) * den(a)
-
-  function gt(a : frac, b : frac) : bool = num(a) * den(b) > num(b) * den(a)
-
-  function lt(a : frac, b : frac) : bool = num(a) * den(b) < num(b) * den(a)
-
-  function min(a : frac, b : frac) : frac = if (leq(a, b)) a else b 
-
-  function max(a : frac, b : frac) : frac = if (geq(a, b)) a else b 
-
-  function abs(f : frac) : frac = switch(f)
-    Pos(n, d) => Pos(n, d)
-    Zero      => Zero
-    Neg(n, d) => Pos(n, d)
-
-  function from_int(n : int) : frac =
-    if   (n > 0) Pos(n, 1)
-    elif (n < 0) Neg(-n, 1)
-    else Zero
-
-  function floor(f : frac) : int = switch(f)
-    Pos(n, d) => n / d
-    Zero      => 0
-    Neg(n, d) => -(n + d - 1) / d
-
-  function ceil(f : frac) : int = switch(f)
-    Pos(n, d) => (n + d - 1) / d
-    Zero      => 0
-    Neg(n, d) => -n / d
-  
-  function round_to_zero(f : frac) : int = switch(f)
-    Pos(n, d) => n / d
-    Zero      => 0
-    Neg(n, d) => -n / d
-
-  function round_from_zero(f : frac) : int = switch(f)
-    Pos(n, d) => (n + d - 1) / d
-    Zero      => 0
-    Neg(n, d) => -(n + d - 1) / d
-
-/** Round towards nearest integer. If two integers are in the same
- * distance, choose the even one.
- */
-  function round(f : frac) : int =
-    let fl = floor(f)
-    let cl = ceil(f)
-    let dif_fl = abs(sub(f, from_int(fl)))
-    let dif_cl = abs(sub(f, from_int(cl)))
-    if   (gt(dif_fl, dif_cl)) cl
-    elif (gt(dif_cl, dif_fl)) fl
-    elif (fl mod 2 == 0) fl
-    else cl
-
-  function add(a : frac, b : frac) : frac =
-    let (na, da) = to_pair(a)
-    let (nb, db) = to_pair(b)
-    if   (da == db) make_frac(na + nb, da)
-    else make_frac(na * db + nb * da, da * db)
-
-  function neg(a : frac) : frac = switch(a)
-    Neg(n, d) => Pos(n, d)
-    Zero      => Zero
-    Pos(n, d) => Neg(n, d)
-
-  function sub(a : frac, b : frac) : frac = add(a, neg(b))
-
-  function inv(a : frac) : frac = switch(a)
-    Neg(n, d) => Neg(d, n)
-    Zero      => abort("Inversion of zero")
-    Pos(n, d) => Pos(d, n)
-
-  function mul(a : frac, b : frac) : frac = make_frac(num(a) * num(b), den(a) * den(b))
-
-  function div(a : frac, b : frac) : frac = switch(b)
-    Neg(n, d) => mul(a, Neg(d, n))
-    Zero      => abort("Division by zero")
-    Pos(n, d) => mul(a, Pos(d, n))
-
-/** `b` to the power of `e`
- */
-  function int_exp(b : frac, e : int) : frac =
-    if (sign(b) == 0 && e == 0) abort("Zero to the zero exponentation")
-    elif (e < 0) inv(int_exp_(b, -e))
-    else int_exp_(b, e)
-  private function int_exp_(b : frac, e : int) =
-      if (e == 0) from_int(1)
-      elif (e == 1) b
-      else
-        let half = int_exp_(b, e / 2)
-        if (e mod 2 == 1) mul(mul(half, half), b)
-        else mul(half, half)
-
-/** Reduces the fraction's in-memory size by dividing its components by two until the
- * the error is bigger than `loss` value
- */
-  function optimize(f : frac, loss : frac) : frac =
-    require(geq(loss, Zero), "negative loss optimize")
-    let s = sign(f)
-    mul(from_int(s), run_optimize(abs(f), abs(f), loss))
-  private function run_optimize(orig : frac, f : frac, loss : frac) : frac =
-    let (n, d) = to_pair(f)
-    let t = make_frac((n+1)/2, (d+1)/2)
-    if(gt(abs(sub(t, orig)), loss)) f
-    elif (eq(t, f)) f
-    else run_optimize(orig, t, loss)

priv/stdlib/Func.aes

@@ -1,77 +0,0 @@
-namespace Func =
-
-  function id(x : 'a) : 'a = x
-
-  function const(x : 'a) : 'b => 'a = (y) => x
-
-  function flip(f : ('a, 'b) => 'c) : ('b, 'a) => 'c = (b, a) => f(a, b)
-
-  function comp(f : 'b => 'c, g : 'a => 'b) : 'a => 'c = (x) => f(g(x))
-
-  function pipe(f : 'a => 'b, g : 'b => 'c) : 'a => 'c = (x) => g(f(x))
-
-  function rapply(x : 'a, f : 'a => 'b) : 'b = f(x)
-
-/** The Z combinator - replacement for local and anonymous recursion.
-  */
-  function recur(f : ('arg => 'res, 'arg) => 'res) : 'arg => 'res =
-    (x) => f(recur(f), x)
-
-/** n-times composition with itself
- */
-  function iter(n : int, f : 'a => 'a) : 'a => 'a = iter_(n, f, (x) => x)
-  private function iter_(n : int, f : 'a => 'a, acc : 'a => 'a) : 'a => 'a =
-    if(n == 0) acc
-    elif(n == 1) comp(f, acc)
-    else iter_(n / 2, comp(f, f), if(n mod 2 == 0) acc else comp(f, acc))
-
-/** Turns an ugly, bad and disgusting arity-n function into
- * a beautiful and sweet function taking the first argument
- * and returning a function watiting for the remaining ones
- * in the same manner
- */
-  function curry2(f : ('a, 'b) => 'x) : 'a => ('b => 'x) =
-    (x) => (y) => f(x, y)
-  function curry3(f : ('a, 'b, 'c) => 'x) : 'a => ('b => ('c => 'x)) =
-    (x) => (y) => (z) => f(x, y, z)
-  function curry4(f : ('a, 'b, 'c, 'd) => 'x) : 'a => ('b => ('c => ('d => 'x))) =
-    (x) => (y) => (z) => (w) => f(x, y, z, w)
-  function curry5(f : ('a, 'b, 'c, 'd, 'e) => 'x) : 'a => ('b => ('c => ('d => ('e => 'x)))) =
-    (x) => (y) => (z) => (w) => (q) => f(x, y, z, w, q)
-
-/** Opposite of curry. Gross
- */
-  function uncurry2(f : 'a => ('b => 'x)) : ('a, 'b) => 'x =
-    (x, y) => f(x)(y)
-  function uncurry3(f : 'a => ('b => ('c => 'x))) : ('a, 'b, 'c) => 'x =
-    (x, y, z) => f(x)(y)(z)
-  function uncurry4(f : 'a => ('b => ('c => ('d => 'x)))) : ('a, 'b, 'c, 'd) => 'x =
-    (x, y, z, w) => f(x)(y)(z)(w)
-  function uncurry5(f : 'a => ('b => ('c => ('d => ('e => 'x))))) : ('a, 'b, 'c, 'd, 'e) => 'x =
-    (x, y, z, w, q) => f(x)(y)(z)(w)(q)
-
-/** Turns an arity-n function into a function taking n-tuple
- */
-  function tuplify2(f : ('a, 'b) => 'x) : (('a * 'b)) => 'x =
-    (t) => switch(t)
-      (x, y) => f(x, y)
-  function tuplify3(f : ('a, 'b, 'c) => 'x) : 'a * 'b * 'c => 'x =
-    (t) => switch(t)
-      (x, y, z) => f(x, y, z)
-  function tuplify4(f : ('a, 'b, 'c, 'd) => 'x) : 'a * 'b * 'c * 'd => 'x =
-    (t) => switch(t)
-      (x, y, z, w) => f(x, y, z, w)
-  function tuplify5(f : ('a, 'b, 'c, 'd, 'e) => 'x) : 'a * 'b * 'c * 'd * 'e => 'x =
-    (t) => switch(t)
-      (x, y, z, w, q) => f(x, y, z, w, q)
-
-/** Opposite of tuplify
- */
-  function untuplify2(f : 'a * 'b => 'x) : ('a, 'b) => 'x =
-    (x, y) => f((x, y))
-  function untuplify3(f : 'a * 'b * 'c => 'x) : ('a, 'b, 'c) => 'x =
-    (x, y, z) => f((x, y, z))
-  function untuplify4(f : 'a * 'b * 'c * 'd => 'x) : ('a, 'b, 'c, 'd) => 'x =
-    (x, y, z, w) => f((x, y, z, w))
-  function untuplify5(f : 'a * 'b * 'c * 'd * 'e => 'x) : ('a, 'b, 'c, 'd, 'e) => 'x =
-    (x, y, z, w, q) => f((x, y, z, w, q))

priv/stdlib/List.aes

@@ -1,315 +0,0 @@
-include "ListInternal.aes"
-
-namespace List =
-
-  function is_empty(l : list('a)) : bool = switch(l)
-    [] => true
-    _  => false
-
-  function first(l : list('a)) : option('a) = switch(l)
-    []   => None
-    h::_ => Some(h)
-
-  function tail(l : list('a)) : option(list('a)) = switch(l)
-    []   => None
-    _::t => Some(t)
-
-  function last(l : list('a)) : option('a) = switch(l)
-    []   => None
-    [x]  => Some(x)
-    _::t => last(t)
-
-  function drop_last(l : list('a)) : option(list('a)) = switch(l)
-    [] => None
-    _  => Some(drop_last_unsafe(l))
-
-  function drop_last_unsafe(l : list('a)) : list('a) = switch(l)
-    [_]  => []
-    h::t => h::drop_last_unsafe(t)
-    []   => abort("drop_last_unsafe: list empty")
-
-
-  function contains(e : 'a, l : list('a)) = switch(l)
-    []   => false
-    h::t => h == e || contains(e, t)
-
-/** Finds first element of `l` fulfilling predicate `p` as `Some` or `None`
- * if no such element exists.
- */
-  function find(p : 'a => bool, l : list('a)) : option('a) = switch(l)
-    []   => None
-    h::t => if(p(h)) Some(h) else find(p, t)
-
-/** Returns list of all indices of elements from `l` that fulfill the predicate `p`.
- */
-  function find_indices(p : 'a => bool, l : list('a)) : list(int) = find_indices_(p, l, 0)
-  private function find_indices_( p : 'a => bool
-                                , l : list('a)
-                                , n : int
-                                ) : list(int) = switch(l)
-    []   => []
-    h::t =>
-     let rest = find_indices_(p, t, n+1)
-     if(p(h)) n::rest else rest
-
-  function nth(n : int, l : list('a)) : option('a) =
-    switch(l)
-      []   => None
-      h::t => if(n == 0) Some(h) else nth(n-1, t)
-
-  /* Unsafe version of `nth` */
-  function get(n : int, l : list('a)) : 'a =
-    switch(l)
-      [] => abort(if(n < 0) "Negative index get" else "Out of index get")
-      h::t => if(n == 0) h else get(n-1, t)
-
-
-  function length(l : list('a)) : int = length_(l, 0)
-  private function length_(l : list('a), acc : int) : int = switch(l)
-    []   => acc
-    _::t => length_(t, acc + 1)
-
-
-/** Creates an ascending sequence of all integer numbers
- * between `a` and `b` (including `a` and `b`)
- */
-  function from_to(a : int, b : int) : list(int) = [a..b]
-
-/** Creates an ascending sequence of integer numbers betweeen
- * `a` and `b` jumping by given `step`. Includes `a` and takes
- * `b` only if `(b - a) mod step == 0`. `step` should be bigger than 0.
- */
-  function from_to_step(a : int, b : int, s : int) : list(int) =
-    from_to_step_(a, b - (b-a) mod s, s, [])
-  private function from_to_step_(a : int, b : int, s : int, acc : list(int)) : list(int) =
-    if(b < a) acc
-    else from_to_step_(a, b - s, s, b::acc)
-
-
-/** Unsafe. Replaces `n`th element of `l` with `e`. Crashes on over/underflow
- */
-  function replace_at(n : int, e : 'a, l : list('a)) : list('a) =
-    if(n<0) abort("insert_at underflow") else replace_at_(n, e, l)
-  private function replace_at_(n : int, e : 'a, l : list('a)) : list('a) =
-   switch(l)
-     []   => abort("replace_at overflow")
-     h::t => if (n == 0) e::t
-             else h::replace_at_(n-1, e, t)
-
-/** Unsafe. Adds `e` to `l` to be its `n`th element. Crashes on over/underflow
- */
-  function insert_at(n : int, e : 'a, l : list('a)) : list('a) =
-    if(n<0) abort("insert_at underflow") else insert_at_(n, e, l)
-  private function insert_at_(n : int, e : 'a, l : list('a)) : list('a) =
-   if (n == 0) e::l
-   else switch(l)
-     []   => abort("insert_at overflow")
-     h::t => h::insert_at_(n-1, e, t)
-
-/** Assuming that cmp represents `<` comparison, inserts `x` before
- * the first element in the list `l` which is greater than it
- */
-  function insert_by(cmp : (('a, 'a) => bool), x : 'a, l : list('a)) : list('a) =
-    switch(l)
-      []   => [x]
-      h::t =>
-        if(cmp(x, h)) // x < h
-          x::l
-        else
-          h::insert_by(cmp, x, t)
-
-
-  function foldr(cons : ('a, 'b) => 'b, nil : 'b, l : list('a)) : 'b = switch(l)
-    []   => nil
-    h::t => cons(h, foldr(cons, nil, t))
-
-  function foldl(rcons : ('b, 'a) => 'b, acc : 'b, l : list('a)) : 'b = switch(l)
-    []   => acc
-    h::t => foldl(rcons, rcons(acc, h), t)
-
-  function foreach(l : list('a), f : 'a => unit) : unit =
-    switch(l)
-     []    => ()
-     e::l' =>
-       f(e)
-       foreach(l', f)
-
-  function reverse(l : list('a)) : list('a) = reverse_(l, [])
-  private function reverse_(l : list('a), acc : list('a)) : list('a) = switch(l)
-    [] => acc
-    h::t => reverse_(t, h::acc)
-
-  function map(f : 'a => 'b, l : list('a)) : list('b) = switch(l)
-    [] => []
-    h::t => f(h)::map(f, t)
-
-/** Effectively composition of `map` and `flatten`
- */
-  function flat_map(f : 'a => list('b), l : list('a)) : list('b) =
-    ListInternal.flat_map(f, l)
-
-  function filter(p : 'a => bool, l : list('a)) : list('a) = switch(l)
-    []   => []
-    h::t =>
-      let rest = filter(p, t)
-      if(p(h)) h::rest else rest
-
-/** Take up to `n` first elements
- */
-  function take(n : int, l : list('a)) : list('a) =
-    if(n < 0) abort("Take negative number of elements") else take_(n, l)
-  private function take_(n : int, l : list('a)) : list('a) =
-    if(n == 0) []
-    else switch(l)
-      []   => []
-      h::t => h::take_(n-1, t)
-
-/** Drop up to `n` first elements
- */
-  function drop(n : int, l : list('a)) : list('a) =
-   if(n < 0) abort("Drop negative number of elements") else drop_(n, l)
-  private function drop_(n : int, l : list('a)) : list('a) =
-   if (n == 0) l
-   else switch(l)
-      []   => []
-      h::t => drop_(n-1, t)
-
-/** Get the longest prefix of a list in which every element
- * matches predicate `p`
- */
-  function take_while(p : 'a => bool, l : list('a)) : list('a) = switch(l)
-    []   => []
-    h::t => if(p(h)) h::take_while(p, t) else []
-
-/** Drop elements from `l` until `p` holds
- */
-  function drop_while(p : 'a => bool, l : list('a)) : list('a) = switch(l)
-    []   => []
-    h::t => if(p(h)) drop_while(p, t) else l
-
-/** Splits list into two lists of elements that respectively
- * match and don't match predicate `p`
- */
-  function partition(p : 'a => bool, l : list('a)) : (list('a) * list('a)) = switch(l)
-    []   => ([], [])
-    h::t =>
-      let (l, r) = partition(p, t)
-      if(p(h)) (h::l, r) else (l, h::r)
-
-  function flatten(l : list(list('a))) : list('a) = switch(l)
-    []   => []
-    h::t => h ++ flatten(t)
-
-  function all(p : 'a => bool, l : list('a)) : bool = switch(l)
-    []   => true
-    h::t => if(p(h)) all(p, t) else false
-
-  function any(p : 'a => bool, l : list('a)) : bool = switch(l)
-    []   => false
-    h::t => if(p(h)) true else any(p, t)
-
-  function sum(l : list(int)) : int = switch(l)
-    []   => 0
-    h::t => h + sum(t)
-
-  function product(l : list(int)) : int = switch(l)
-    []   => 1
-    h::t => h * sum(t)
-
-/** Zips two list by applying bimapping function on respective elements.
- * Drops the tail of the longer list.
- */
-  private function zip_with( f : ('a, 'b) => 'c
-                            , l1 : list('a)
-                            , l2 : list('b)
-                            ) : list('c) = switch ((l1, l2))
-    (h1::t1, h2::t2) => f(h1, h2)::zip_with(f, t1, t2)
-    _ => []
-
-/** Zips two lists into list of pairs.
- * Drops the tail of the longer list.
- */
-  function zip(l1 : list('a), l2 : list('b)) : list('a * 'b) = zip_with((a, b) => (a, b), l1, l2)
-
-  function unzip(l : list('a * 'b)) : (list('a) * list('b)) = switch(l)
-    []          => ([], [])
-    (h1, h2)::t =>
-      let (t1, t2) = unzip(t)
-      (h1::t1, h2::t2)
-
-
-  /** Merges two sorted lists using `lt` comparator
-   */
-  function
-    merge : (('a, 'a) => bool, list('a), list('a)) => list('a)
-    merge(lt, x::xs, y::ys) =
-      if(lt(x, y)) x::merge(lt, xs, y::ys)
-      else y::merge(lt, x::xs, ys)
-    merge(_, [], ys) = ys
-    merge(_, xs, []) = xs
-
-
-  /** Mergesort inspired by
-   * https://hackage.haskell.org/package/base-4.14.1.0/docs/src/Data.OldList.html#sort
-   */
-  function
-    sort : (('a, 'a) => bool, list('a)) => list('a)
-    sort(_, []) = []
-    sort(lt, l) =
-      merge_all(lt, monotonic_subs(lt, l))
-
-  /** Splits list into compound increasing sublists
-   */
-  private function
-    monotonic_subs : (('a, 'a) => bool, list('a)) => list(list('a))
-    monotonic_subs(lt, x::y::rest) =
-      if(lt(y, x)) desc(lt, y, [x], rest)
-      else asc(lt, y, [x], rest)
-    monotonic_subs(_, l) = [l]
-
-  /** Extracts the longest descending prefix and proceeds with monotonic split
-   */
-  private function
-    desc : (('a, 'a) => bool, 'a, list('a), list('a)) => list(list('a))
-    desc(lt, x, acc, h::t) =
-      if(lt(x, h)) (x::acc) :: monotonic_subs(lt, h::t)
-      else desc(lt, h, x::acc, t)
-    desc(_, x, acc, []) = [x::acc]
-
-  /** Extracts the longest ascending prefix and proceeds with monotonic split
-   */
-  private function
-    asc : (('a, 'a) => bool, 'a, list('a), list('a)) => list(list('a))
-    asc(lt, x, acc, h::t) =
-      if(lt(h, x)) List.reverse(x::acc) :: monotonic_subs(lt, h::t)
-      else asc(lt, h, x::acc, t)
-    asc(_, x, acc, []) = [List.reverse(x::acc)]
-
-  /** Merges list of sorted lists
-   */
-  private function
-    merge_all : (('a, 'a) => bool, list(list('a))) => list('a)
-    merge_all(_, [part]) = part
-    merge_all(lt, parts) = merge_all(lt, merge_pairs(lt, parts))
-
-  /** Single round of `merge_all` – pairs of lists in a list of list
-   */
-  private function
-    merge_pairs : (('a, 'a) => bool, list(list('a))) => list(list('a))
-    merge_pairs(lt, x::y::rest) = merge(lt, x, y) :: merge_pairs(lt, rest)
-    merge_pairs(_, l) = l
-
-
-/** Puts `delim` between every two members of the list
- */
-  function intersperse(delim : 'a, l : list('a)) : list('a) = switch(l)
-    []   => []
-    [e]  => [e]
-    h::t => h::delim::intersperse(delim, t)
-
-/** Effectively a zip with an infinite sequence of natural numbers
- */
-  function enumerate(l : list('a)) : list(int * 'a) = enumerate_(l, 0)
-  private function enumerate_(l : list('a), n : int) : list(int * 'a) = switch(l)
-    []   => []
-    h::t => (n, h)::enumerate_(t, n + 1)

priv/stdlib/ListInternal.aes

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

priv/stdlib/Option.aes

@@ -1,98 +0,0 @@
-include "List.aes"
-
-namespace Option =
-
-  function is_none(o : option('a)) : bool = switch(o)
-    None => true
-    Some(_) => false
-
-  function is_some(o : option('a)) : bool = switch(o)
-    None => false
-    Some(_) => true
-
-/** Catamorphism on `option`. Also known as inlined pattern matching.
- */
-  function match(n : 'b, s : 'a => 'b, o : option('a)) : 'b = switch(o)
-    None => n
-    Some(x) => s(x)
-
-/** Escape option providing default if `None`
- */
-  function default(def : 'a, o : option('a)) : 'a = match(def, (x) => x, o)
-
-/** Assume it is `Some`
- */
-  function force(o : option('a)) : 'a = switch(o)
-    None    => abort("Forced None value")
-    Some(x) => x
-
-  function contains(e : 'a, o : option('a)) = o == Some(e)
-
-  function on_elem(o : option('a), f : 'a => unit) : unit = match((), f, o)
-
-  function map(f : 'a => 'b, o : option('a)) : option('b) = switch(o)
-    None => None
-    Some(x) => Some(f(x))
-
-  function map2(f : ('a, 'b) => 'c
-               , o1 : option('a)
-               , o2 : option('b)
-               ) : option('c) = switch((o1, o2))
-    (Some(x1), Some(x2)) => Some(f(x1, x2))
-    _ => None
-
-  function map3( f : ('a, 'b, 'c) => 'd
-               , o1 : option('a)
-               , o2 : option('b)
-               , o3 : option('c)
-               ) : option('d) = switch((o1, o2, o3))
-    (Some(x1), Some(x2), Some(x3)) => Some(f(x1, x2, x3))
-    _ => None
-
-/** Like `map`, but the function is in `option`
- */
-  function app_over(f : option ('a => 'b), o : option('a)) : option('b) = switch((f, o))
-    (Some(ff), Some(xx)) => Some(ff(xx))
-    _ => None
-
-/** Monadic bind
- */
-  function flat_map(f : 'a => option('b), o : option('a)) : option('b) = switch(o)
-    None => None
-    Some(x) => f(x)
-
-
-  function to_list(o : option('a)) : list('a) = switch(o)
-    None => []
-    Some(x) => [x]
-
-/** Turns list of options into a list of elements that are under `Some`s.
- * Safe.
- */
-  function filter_options(l : list(option('a))) : list('a) = switch(l)
-    []         => []
-    None::t    => filter_options(t)
-    Some(x)::t => x::filter_options(t)
-
-/** Just like `filter_options` but requires all elements to be `Some` and returns
- * None if any of them is not
- */
-  function seq_options(l : list (option('a))) : option (list('a)) = switch(l)
-    []         => Some([])
-    None::_    => None
-    Some(x)::t => switch(seq_options(t))
-      None => None
-      Some(st) => Some(x::st)
-
-
-/** Choose `Some` out of two if possible
- */
-  function choose(o1 : option('a), o2 : option('a)) : option('a) =
-    if(is_some(o1)) o1 else o2
-
-/** Choose `Some` from list of options if possible
- */
-  function choose_first(l : list(option('a))) : option('a) = switch(l)
-    [] => None
-    None::t    => choose_first(t)
-    Some(x)::_ => Some(x)

priv/stdlib/Pair.aes

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

priv/stdlib/String.aes

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

priv/stdlib/Triple.aes

@@ -1,49 +0,0 @@
-namespace Triple =
-
-  function fst(t : ('a * 'b * 'c)) : 'a = switch(t)
-    (x, _, _) => x
-
-  function snd(t : ('a * 'b * 'c)) : 'b = switch(t)
-    (_, y, _) => y
-
-  function thd(t : ('a * 'b * 'c)) : 'c = switch(t)
-    (_, _, z) => z
-
-
-/** Map over first
- */
-  function map1(f : 'a => 'm, t : ('a * 'b * 'c)) : ('m * 'b * 'c) = switch(t)
-    (x, y, z) => (f(x), y, z)
-
-/** Map over second
- */
-  function map2(f : 'b => 'm, t : ('a * 'b * 'c)) : ('a * 'm * 'c) = switch(t)
-    (x, y, z) => (x, f(y), z)
-
-/** Map over third
- */
-  function map3(f : 'c => 'm, t : ('a * 'b * 'c)) : ('a * 'b * 'm) = switch(t)
-    (x, y, z) => (x, y, f(z))
-
-/** Map over all elements
- */
-  function trimap( f : 'a => 'x
-                 , g : 'b => 'y
-                 , h : 'c => 'z
-                 , t : ('a * 'b * 'c)
-                 ) : ('x * 'y * 'z) = switch(t)
-    (x, y, z) => (f(x), g(y), h(z))
-
-  function swap(t : ('a * 'b * 'c)) : ('c * 'b * 'a) = switch(t)
-    (x, y, z) => (z, y, x)
-
-/** Right rotation
- */
-  function rotr(t : ('a * 'b * 'c)) : ('c * 'a * 'b) = switch(t)
-    (x, y, z) => (z, x, y)
-
-/** Left rotation
- */
-  function rotl(t : ('a * 'b * 'c)) : ('b * 'c * 'a) = switch(t)
-    (x, y, z) => (y, z, x)
-

rebar.config

@@ -2,20 +2,35 @@
 
 {erl_opts, [debug_info]}.
 
-{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git", {ref,"05dfd7f"}}}
+{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git",
+                            {ref, "e8253b0"}}}
        , {getopt, "1.0.1"}
-       , {eblake2, "1.0.0"}
        , {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"}.
+{provider_hooks, [{post, [{compile, escriptize}]}]}.
+
+{post_hooks, [{"(linux|darwin|solaris|freebsd|netbsd|openbsd)",
+               escriptize,
+               "cp \"$REBAR_BUILD_DIR/bin/aesophia\" ./aesophia"},
+              {"win32",
+               escriptize,
+               "robocopy \"%REBAR_BUILD_DIR%/bin/\" ./ aesophia* "
+               "/njs /njh /nfl /ndl & exit /b 0"} % silence things
+             ]}.
+
 {dialyzer, [
             {warnings, [unknown]},
             {plt_apps, all_deps},
             {base_plt_apps, [erts, kernel, stdlib, crypto, mnesia]}
            ]}.
 
-{relx, [{release, {aesophia, "6.0.0"},
+{relx, [{release, {aesophia, "2.1.0"},
          [aesophia, aebytecode, getopt]},
 
         {dev_mode, true},

rebar.lock

@@ -1,21 +1,17 @@
 {"1.1.0",
 [{<<"aebytecode">>,
   {git,"https://github.com/aeternity/aebytecode.git",
-       {ref,"05dfd7ffc7fb1e07ecc0b1e516da571f56d7dc8f"}},
+       {ref,"e8253b09709f1595d8bd6a1756a0ce93185c6518"}},
   0},
  {<<"aeserialization">>,
   {git,"https://github.com/aeternity/aeserialization.git",
-       {ref,"47aaa8f5434b365c50a35bfd1490340b19241991"}},
+       {ref,"6dce265753af4e651f77746e77ea125145c85dd3"}},
   1},
  {<<"base58">>,
   {git,"https://github.com/aeternity/erl-base58.git",
        {ref,"60a335668a60328a29f9731b67c4a0e9e3d50ab6"}},
   2},
- {<<"eblake2">>,{pkg,<<"eblake2">>,<<"1.0.0">>},0},
- {<<"enacl">>,
-  {git,"https://github.com/aeternity/enacl.git",
-       {ref,"26180f42c0b3a450905d2efd8bc7fd5fd9cece75"}},
-  2},
+ {<<"eblake2">>,{pkg,<<"eblake2">>,<<"1.0.0">>},1},
  {<<"getopt">>,{pkg,<<"getopt">>,<<"1.0.1">>},0},
  {<<"jsx">>,
   {git,"https://github.com/talentdeficit/jsx.git",

src/aeso_aci.erl

@@ -9,347 +9,504 @@
 
 -module(aeso_aci).
 
--export([ file/2
-        , file/3
-        , contract_interface/2
-        , contract_interface/3
+%% Old deprecated interface.
+-export([encode/1,encode/2,decode/1]).
 
-        , from_typed_ast/2
+-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]).
 
-        , render_aci_json/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.
 
-        , json_encode_expr/1
-        , json_encode_type/1]).
+%% 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}).
 
--include("aeso_utils.hrl").
+%% 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}).
 
--type aci_type()  :: json | string.
--type json()      :: jsx:json_term().
--type json_text() :: binary().
+%% 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}).
 
--export_type([aci_type/0]).
+%% 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}).
 
-%% External API
--spec file(aci_type(), string()) -> {ok, json() | string()} | {error, term()}.
-file(Type, File) ->
-    file(Type, File, []).
+%% 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}).
 
-file(Type, File, Options0) ->
-    Options = aeso_compiler:add_include_path(File, Options0),
-    case file:read_file(File) of
-        {ok, BinCode} ->
-            do_contract_interface(Type, binary_to_list(BinCode), Options);
-        {error, _} = Err -> Err
-    end.
+%% The old deprecated interface.
 
--spec contract_interface(aci_type(), string()) ->
-    {ok, json() | string()} | {error, term()}.
-contract_interface(Type, ContractString) ->
-    contract_interface(Type, ContractString, []).
+encode(C) -> encode_contract(C).
+encode(C, Os) -> encode_contract(C, Os).
+decode(J) -> decode_contract(J).
 
--spec contract_interface(aci_type(), string(), [term()]) ->
-    {ok, json() | string()} | {error, term()}.
-contract_interface(Type, ContractString, CompilerOpts) ->
-    do_contract_interface(Type, ContractString, CompilerOpts).
+%% 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.
 
--spec render_aci_json(json() | json_text()) -> {ok, binary()}.
-render_aci_json(Json) ->
-    do_render_aci_json(Json).
-
--spec json_encode_expr(aeso_syntax:expr()) -> json().
-json_encode_expr(Expr) ->
-    encode_expr(Expr).
-
--spec json_encode_type(aeso_syntax:type()) -> json().
-json_encode_type(Type) ->
-    encode_type(Type).
-
-%% Internal functions
-do_contract_interface(Type, Contract, Options) when is_binary(Contract) ->
-    do_contract_interface(Type, binary_to_list(Contract), Options);
-do_contract_interface(Type, ContractString, Options) ->
+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 = aeso_compiler:parse(ContractString, Options),
-        {TypedAst, _} = aeso_ast_infer_types:infer(Ast, [dont_unfold | Options]),
-        from_typed_ast(Type, TypedAst)
+        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
-        throw:{error, Errors} -> {error, Errors}
+        %% 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.
 
-from_typed_ast(Type, TypedAst) ->
-    JArray = [ encode_contract(C) || C <- TypedAst ],
-    case Type of
-        json   -> {ok, JArray};
-        string -> do_render_aci_json(JArray)
-    end.
+join_errors(Prefix, Errors, Pfun) ->
+    Ess = [ Pfun(E) || E <- Errors ],
+    list_to_binary(string:join([Prefix|Ess], "\n")).
 
-encode_contract(Contract = {Head, _, {con, _, Name}, _}) when ?IS_CONTRACT_HEAD(Head) ->
-    C0 = #{name => encode_name(Name)},
+%% do_encode_contract_typedefs(TypeDefs) -> [JSON].
+%%  Return a list of typedefs and state and event if they occur.
 
-    Tdefs0 = [ encode_typedef(T) || T <- sort_decls(contract_types(Contract)) ],
-    FilterT = fun(N) -> fun(#{name := N1}) -> N == N1 end end,
-    {Es, Tdefs1} = lists:partition(FilterT(<<"event">>), Tdefs0),
-    {Ss, Tdefs}  = lists:partition(FilterT(<<"state">>), Tdefs1),
+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.
 
-    C1 = C0#{type_defs => Tdefs},
+%% do_encode_state_typedef(StateTdef) -> JSON.
+%% do_encode_event_typedef(EventTdef) -> JSON.
 
-    C2 = case Es of
-             []                 -> C1;
-             [#{typedef := ET}] -> C1#{event => ET}
-         end,
+do_encode_state_typedef(State) ->
+    Def = typedef_def(State),
+    {<<"state">>,do_encode_alias(Def)}.
 
-    C3 = case Ss of
-             []                 -> C2;
-             [#{typedef := ST}] -> C2#{state => ST}
-         end,
+do_encode_event_typedef(State) ->
+    Def = typedef_def(State),
+    {<<"event">>,do_encode_alias(Def)}.
 
-    Fdefs  = [ encode_function(F)
-               || F <- sort_decls(contract_funcs(Contract)),
-                  is_entrypoint(F) ],
+%% encode_func(TypedAST) -> JSON.
+%%  Encode a function AST into a JSON structure.
 
-    #{contract => C3#{kind => Head, functions => Fdefs, payable => is_payable(Contract)}};
-encode_contract(Namespace = {namespace, _, {con, _, Name}, _}) ->
-    Tdefs = [ encode_typedef(T) || T <- sort_decls(contract_types(Namespace)) ],
-    #{namespace => #{name => encode_name(Name),
-                     type_defs => Tdefs}}.
+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.
-encode_function(FDef = {letfun, _, {id, _, Name}, Args, Type, _}) ->
-    #{name      => encode_name(Name),
-      arguments => encode_args(Args),
-      returns   => encode_type(Type),
-      stateful  => is_stateful(FDef),
-      payable   => is_payable(FDef)};
-encode_function(FDecl = {fun_decl, _, {id, _, Name}, {fun_t, _, _, Args, Type}}) ->
-    #{name      => encode_name(Name),
-      arguments => encode_anon_args(Args),
-      returns   => encode_type(Type),
-      stateful  => is_stateful(FDecl),
-      payable   => is_payable(FDecl)}.
 
-encode_anon_args(Types) ->
-    Anons = [ list_to_binary("_" ++ integer_to_list(X)) || X <- lists:seq(1, length(Types))],
-    [ #{name => V, type => encode_type(T)}
-      || {V, T} <- lists:zip(Anons, Types) ].
+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_args(Args) -> [ encode_arg(A) || A <- Args ].
+%% encode_arg(TypedAST) -> JSON.
+%%  Encode an argument AST into a JSON structure.
 
-encode_arg({typed, _, Id, T}) ->
-    #{name => encode_type(Id),
-      type => encode_type(T)}.
+encode_arg(AST) ->
+    jsx:encode(do_encode_arg(AST)).
 
-encode_typedef(Type) ->
+%% 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    => encode_name(Name),
-      vars    => encode_tvars(Vars),
-      typedef => encode_type(Def)}.
+    Def = typedef_def(Type),
+    [{<<"name">>, do_encode_name(Name)},
+     {<<"vars">>, do_encode_tvars(Vars)},
+     {<<"typedef">>, do_encode_alias(Def)}].
 
-encode_tvars(Vars) ->
-    [ #{name => encode_type(V)} || V <- Vars ].
+do_encode_tvars(Vars) ->
+    [ do_encode_tvar(V) || V <- Vars ].
 
-%% Encode type
-encode_type({tvar, _, N})         -> encode_name(N);
-encode_type({id, _, N})           -> encode_name(N);
-encode_type({con, _, N})          -> encode_name(N);
-encode_type({qid, _, Ns})         -> encode_name(lists:join(".", Ns));
-encode_type({qcon, _, Ns})        -> encode_name(lists:join(".", Ns));
-encode_type({tuple_t, _, As})     -> #{tuple => encode_types(As)};
-encode_type({bytes_t, _, Len})    -> #{bytes => Len};
-encode_type({record_t, Fs})       -> #{record => encode_type_fields(Fs)};
-encode_type({app_t, _, Id, Fs})   -> #{encode_type(Id) => encode_types(Fs)};
-encode_type({variant_t, Cs})      -> #{variant => encode_types(Cs)};
-encode_type({constr_t, _, C, As}) -> #{encode_type(C) => encode_types(As)};
-encode_type({alias_t, Type})      -> encode_type(Type);
-encode_type({fun_t, _, _, As, T}) -> #{function =>
-                                         #{arguments => encode_types(As),
-                                           returns => encode_type(T)}}.
+do_encode_tvar(#tvar{name=N}) ->
+    [{<<"name">>, do_encode_name(N)}].
 
-encode_types(Ts) -> [ encode_type(T) || T <- Ts ].
+do_encode_alias(#alias_t{type=T}) ->
+    do_encode_type(T);
+do_encode_alias(A) -> do_encode_type(A).
 
-encode_type_fields(Fs) -> [ encode_type_field(F) || F <- Fs ].
+%% encode_stmt(StmtAST) -> JSON.
+%%  Encode a statement AST into a JSON structure.
 
-encode_type_field({field_t, _, Id, T}) ->
-    #{name => encode_type(Id),
-      type => encode_type(T)}.
+encode_stmt(AST) ->
+    jsx:encode(do_encode_stmt(AST)).
 
-encode_name(Name) when is_list(Name) ->
-    list_to_binary(Name);
-encode_name(Name) when is_binary(Name) ->
-    Name.
+%% do_encode_stmt(StmtAST) -> JSONmap.
 
-%% Encode Expr
-encode_exprs(Es) -> [ encode_expr(E) || E <- Es ].
+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).
 
-encode_expr({id, _, N})     -> encode_name(N);
-encode_expr({con, _, N})    -> encode_name(N);
-encode_expr({qid, _, Ns})   -> encode_name(lists:join(".", Ns));
-encode_expr({qcon, _, Ns})  -> encode_name(lists:join(".", Ns));
-encode_expr({typed, _, E})  -> encode_expr(E);
-encode_expr({bool, _, B})   -> B;
-encode_expr({int, _, V})    -> V;
-encode_expr({string, _, S}) -> S;
-encode_expr({tuple, _, As}) -> encode_exprs(As);
-encode_expr({list, _, As})  -> encode_exprs(As);
-encode_expr({bytes, _, B})  ->
-    Digits = byte_size(B),
-    <<N:Digits/unit:8>> = B,
-    list_to_binary(lists:flatten(io_lib:format("#~*.16.0b", [Digits*2, N])));
-encode_expr({Lit, _, L}) when Lit == oracle_pubkey; Lit == oracle_query_id;
-                              Lit == contract_pubkey; Lit == account_pubkey ->
-    aeser_api_encoder:encode(Lit, L);
-encode_expr({app, _, {'-', _}, [{int, _, N}]}) ->
-  encode_expr({int, [], -N});
-encode_expr({app, _, F, As}) ->
-    Ef = encode_expr(F),
-    Eas = encode_exprs(As),
-    #{Ef => Eas};
-encode_expr({record, _, Flds}) -> maps:from_list(encode_fields(Flds));
-encode_expr({map, _, KVs})     -> [ [encode_expr(K), encode_expr(V)] || {K, V} <- KVs ];
-encode_expr({Op,_Ann}) ->
-    error({encode_expr_todo, Op}).
+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_fields(Flds) -> [ encode_field(F) || F <- Flds ].
+%% encode_expr(ExprAST) -> JSON.
+%%  Encode an expression AST into a JSON structure.
 
-encode_field({field, _, [{proj, _, {id, _, Fld}}], Val}) ->
-    {encode_name(Fld), encode_expr(Val)}.
+encode_expr(AST) ->
+    jsx:encode(do_encode_expr(AST)).
 
-do_render_aci_json(Json) ->
-    Contracts =
-        case Json of
-            JArray when is_list(JArray)  -> JArray;
-            JObject when is_map(JObject) -> [JObject];
-            JText when is_binary(JText)  ->
-                case jsx:decode(Json, [{labels, atom}, return_maps]) of
-                    JArray when is_list(JArray)  -> JArray;
-                    JObject when is_map(JObject) -> [JObject];
-                    _                            -> error(bad_aci_json)
-                end
-        end,
-    DecodedContracts = [ decode_contract(C) || C <- Contracts ],
-    {ok, list_to_binary(string:join(DecodedContracts, "\n"))}.
+%% do_encode_exprs(ExprASTs) -> [JSONmap].
+%% do_encode_expr(ExprAST) -> JSONmap.
 
-decode_contract(#{contract := #{name := Name,
-                                kind := Kind,
-                                payable := Payable,
-                                type_defs := Ts0,
-                                functions := Fs} = C}) ->
-    MkTDef = fun(N, T) -> #{name => N, vars => [], typedef => T} end,
-    Ts = [ MkTDef(<<"state">>, maps:get(state, C)) || maps:is_key(state, C) ] ++
-         [ MkTDef(<<"event">>, maps:get(event, C)) || maps:is_key(event, C) ] ++ Ts0,
-    [payable(Payable), case Kind of
-                           contract_main -> "main contract ";
-                           contract_child -> "contract ";
-                           contract_interface -> "contract interface "
-                       end,
-     io_lib:format("~s", [Name])," =\n",
-     decode_tdefs(Ts), decode_funcs(Fs)];
-decode_contract(#{namespace := #{name := Name, type_defs := Ts}}) when Ts /= [] ->
-    ["namespace ", io_lib:format("~s", [Name])," =\n",
-     decode_tdefs(Ts)];
-decode_contract(_) -> [].
+do_encode_exprs(Es) ->
+    [ do_encode_expr(E) || E <- Es ].
 
-decode_funcs(Fs) -> [ decode_func(F) || F <- Fs ].
+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)).
 
-%% decode_func(#{name := init}) -> [];
-decode_func(#{name := Name, payable := Payable, arguments := As, returns := T}) ->
-    ["  ", payable(Payable), "entrypoint ", io_lib:format("~s", [Name]), " : ",
-     decode_args(As), " => ", decode_type(T), $\n].
+%% do_encode_expr_rec_fields(Fields) -> [JSON].
+%% do_encode_expr_rec_field(Field) -> JSON.
+%%  Encode a record field expression.
 
-decode_args(As) ->
-    Das = [ decode_arg(A) || A <- As ],
+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),$)].
 
-decode_arg(#{type := T}) -> decode_type(T).
+do_decode_arg(#{<<"type">> := T}) -> do_decode_type(T).
 
-decode_types(Ets) ->
-    [ decode_type(Et) || Et <- Ets ].
+do_decode_types(Ets) ->
+    [ do_decode_type(Et) || Et <- Ets ].
 
-decode_type(#{tuple := Ets}) ->
-    Ts = decode_types(Ets),
-    case Ts of
-        [] -> ["unit"];
-        _ -> [$(,lists:join(" * ", Ts),$)]
-    end;
-decode_type(#{record := Efs}) ->
-    Fs = decode_fields(Efs),
-    [${,lists:join(",", Fs),$}];
-decode_type(#{list := [Et]}) ->
-    T = decode_type(Et),
+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,$)];
-decode_type(#{map := Ets}) ->
-    Ts = decode_types(Ets),
-    ["map",$(,lists:join(",", Ts),$)];
-decode_type(#{bytes := Len}) ->
-    ["bytes(", integer_to_list(Len), ")"];
-decode_type(#{variant := Ets}) ->
-    Ts = decode_types(Ets),
+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);
-decode_type(#{function := #{arguments := Args, returns := R}}) ->
-    [decode_type(#{tuple => Args}), " => ", decode_type(R)];
-decode_type(Econs) when is_map(Econs) ->	%General constructor
+do_decode_type(Econs) when is_map(Econs) ->     %General constructor
+    %% io:format("~p\n", [Econs]),
     [{Ec,Ets}] = maps:to_list(Econs),
-    AppName = decode_name(Ec),
-    AppArgs = decode_types(Ets),
-    case AppArgs of
-        [] -> [AppName];
-        _  -> [AppName,$(,lists:join(", ", AppArgs),$)]
-    end;
-decode_type(T) ->				%Just raw names.
-    decode_name(T).
+    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).
 
-decode_name(En) when is_atom(En)   -> erlang:atom_to_list(En);
-decode_name(En) when is_binary(En) -> binary_to_list(En).
+do_decode_name(En) ->
+    binary_to_list(En).
 
-decode_fields(Efs) ->
-    [ decode_field(Ef) || Ef <- Efs ].
+do_decode_type_rec_fields(Efs) ->
+    [ do_decode_type_rec_field(Ef) || Ef <- Efs ].
 
-decode_field(#{name := En, type := Et}) ->
-    Name = decode_name(En),
-    Type = decode_type(Et),
+do_decode_type_rec_field(#{<<"name">> := En,<<"type">> := Et}) ->
+    Name = do_decode_name(En),
+    Type = do_decode_type(Et),
     [Name," : ",Type].
 
-%% decode_tdefs(Json) -> [TypeString].
+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.
 
-decode_tdefs(Ts) -> [ decode_tdef(T) || T <- Ts ].
+do_decode_tdefs(Ts) -> [ do_decode_tdef(T) ||
+                        #{<<"typedef">> := #{<<"variant">> := _}} = T <- Ts
+                    ].
 
-decode_tdef(#{name := Name, vars := Vs, typedef := T}) ->
-    TypeDef = decode_type(T),
-    DefType = decode_deftype(T),
-    ["  ", DefType, " ", decode_name(Name), decode_tvars(Vs), " = ", TypeDef, $\n].
+do_decode_tdef(#{<<"name">> := Name,<<"vars">> := Vs,<<"typedef">> := T}) ->
+    ["  datatype"," ",do_decode_name(Name),do_decode_tvars(Vs),
+     " = ",do_decode_type(T),$\n].
 
-decode_deftype(#{record := _Efs}) -> "record";
-decode_deftype(#{variant := _})   -> "datatype";
-decode_deftype(_T)                      -> "type".
-
-decode_tvars([]) -> [];  %No tvars, no parentheses
-decode_tvars(Vs) ->
-    Dvs = [ decode_tvar(V) || V <- Vs ],
+do_decode_tvars([]) -> [];                      %No tvars, no parentheses
+do_decode_tvars(Vs) ->
+    Dvs = [ do_decode_tvar(V) || V <- Vs ],
     [$(,lists:join(", ", Dvs),$)].
 
-decode_tvar(#{name := N}) -> io_lib:format("~s", [N]).
-
-payable(true)  -> "payable ";
-payable(false) -> "".
+do_decode_tvar(#{<<"name">> := N}) -> io_lib:format("~s", [N]).
 
 %% #contract{Ann, Con, [Declarations]}.
 
-contract_funcs({C, _, _, Decls}) when ?IS_CONTRACT_HEAD(C); C == namespace ->
-    [ D || D <- Decls, is_fun(D)].
+contract_name(#contract{con=#con{name=N}}) -> N.
 
-contract_types({C, _, _, Decls}) when ?IS_CONTRACT_HEAD(C); C == namespace ->
-    [ D || D <- Decls, is_type(D) ].
+contract_funcs(#contract{decls=Decls}) ->
+    [ D || D <- Decls, is_record(D, letfun) ].
 
-is_fun({letfun, _, _, _, _, _}) -> true;
-is_fun({fun_decl, _, _, _})     -> true;
-is_fun(_)                       -> false.
+contract_types(#contract{decls=Decls}) ->
+    [ D || D <- Decls, is_record(D, type_def) ].
 
-is_type({type_def, _, _, _, _}) -> true;
-is_type(_)                      -> false.
+%% 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) ->
@@ -358,12 +515,58 @@ sort_decls(Ds) ->
            end,
     lists:sort(Sort, Ds).
 
-is_entrypoint(Node) -> aeso_syntax:get_ann(entrypoint, Node, false).
-is_stateful(Node) -> aeso_syntax:get_ann(stateful, Node, false).
-is_payable(Node) -> aeso_syntax:get_ann(payable, Node, false).
+%% #letfun{Ann, Id, [Arg], Type, Typedef}.
 
-typedef_name({type_def, _, {id, _, Name}, _, _}) -> Name.
+function_name(#letfun{id=#id{name=N}}) -> N.
 
-typedef_vars({type_def, _, _, Vars, _}) -> Vars.
+function_args(#letfun{args=Args}) -> Args.
 
-typedef_def({type_def, _, _, _, Def}) -> Def.
+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_builtins.erl

@@ -10,7 +10,6 @@
 -module(aeso_builtins).
 
 -export([ builtin_function/1
-        , bytes_to_raw_string/2
         , check_event_type/1
         , used_builtins/1 ]).
 
@@ -45,9 +44,7 @@ builtin_deps1(addr_to_str)                -> [{baseX_int, 58}];
 builtin_deps1({baseX_int, X})             -> [{baseX_int_pad, X}];
 builtin_deps1({baseX_int_pad, X})         -> [{baseX_int_encode, X}];
 builtin_deps1({baseX_int_encode, X})      -> [{baseX_int_encode_, X}, {baseX_tab, X}, {baseX_digits, X}];
-builtin_deps1({bytes_to_str, _})          -> [bytes_to_str_worker, bytes_to_str_worker_x];
 builtin_deps1(string_reverse)             -> [string_reverse_];
-builtin_deps1(require)                    -> [abort];
 builtin_deps1(_)                          -> [].
 
 dep_closure(Deps) ->
@@ -63,14 +60,12 @@ v(X) when is_list(X) -> #var_ref{name = X}.
 option_none()  -> {tuple, [{integer, 0}]}.
 option_some(X) -> {tuple, [{integer, 1}, X]}.
 
--define(HASH_BYTES, 32).
-
 -define(call(Fun, Args), #funcall{ function = #var_ref{ name = {builtin, Fun} }, args = Args }).
 -define(I(X), {integer, X}).
 -define(V(X), v(X)).
 -define(A(Op), aeb_opcodes:mnemonic(Op)).
 -define(LET(Var, Expr, Body), {switch, Expr, [{v(Var), Body}]}).
--define(DEREF(Var, Ptr, Body), {switch, operand(Ptr), [{{tuple, [v(Var)]}, Body}]}).
+-define(DEREF(Var, Ptr, Body), {switch, v(Ptr), [{{tuple, [v(Var)]}, Body}]}).
 -define(NXT(Ptr), op('+', Ptr, 32)).
 -define(NEG(A), op('/', A, {unop, '-', {integer, 1}})).
 -define(BYTE(Ix, Word), op('byte', Ix, Word)).
@@ -90,18 +85,18 @@ option_some(X) -> {tuple, [{integer, 1}, X]}.
 -define(BSL(X, B), op('bsl', ?MUL(B, 8), X)).
 -define(BSR(X, B), op('bsr', ?MUL(B, 8), X)).
 
-op(Op, A, B) -> simpl({binop, Op, operand(A), operand(B)}).
-
-%% We generate a lot of B * 8 for integer B from BSL and BSR.
-simpl({binop, '*', {integer, A}, {integer, B}}) when A >= 0, B >= 0, A * B < 1 bsl 256 ->
-    {integer, A * B};
-simpl(Op) -> Op.
-
+op(Op, A, B) -> {binop, Op, operand(A), operand(B)}.
 
 operand(A) when is_atom(A) -> v(A);
 operand(I) when is_integer(I) -> {integer, I};
 operand(T) -> T.
 
+str_to_icode(String) when is_list(String) ->
+    str_to_icode(list_to_binary(String));
+str_to_icode(BinStr) ->
+    Cpts = [size(BinStr) | aeb_memory:binary_to_words(BinStr)],
+    #tuple{ cpts = [ #integer{value = X} || X <- Cpts ] }.
+
 check_event_type(Icode) ->
     case maps:get(event_type, Icode) of
         {variant_t, Cons} ->
@@ -122,12 +117,11 @@ check_event_type(EvtName, Ix, Type, Icode) ->
         catch _:_ ->
             error({EvtName, could_not_resolve_type, Type})
         end,
-    case {Ix, VMType, Type} of
-        {indexed, word, _}      -> ok;
-        {notindexed, string, _} -> ok;
-        {notindexed, _, {bytes_t, _, N}} when N > 32 -> ok;
-        {indexed, _, _}         -> error({EvtName, indexed_field_should_be_word, is, VMType});
-        {notindexed, _, _}      -> error({EvtName, payload_should_be_string, is, VMType})
+    case {Ix, VMType} of
+        {indexed, word}      -> ok;
+        {notindexed, string} -> ok;
+        {indexed, _}         -> error({EvtName, indexed_field_should_be_word, is, VMType});
+        {notindexed, _}      -> error({EvtName, payload_should_be_string, is, VMType})
     end.
 
 bfun(B, {IArgs, IExpr, IRet}) ->
@@ -137,8 +131,6 @@ builtin_function(BF) ->
     case BF of
         {event, EventT}            -> bfun(BF, builtin_event(EventT));
         abort                      -> bfun(BF, builtin_abort());
-        block_hash                 -> bfun(BF, builtin_block_hash());
-        require                    -> bfun(BF, builtin_require());
         {map_lookup, Type}         -> bfun(BF, builtin_map_lookup(Type));
         map_put                    -> bfun(BF, builtin_map_put());
         map_delete                 -> bfun(BF, builtin_map_delete());
@@ -166,12 +158,6 @@ builtin_function(BF) ->
         {baseX_int_pad, X}         -> bfun(BF, builtin_baseX_int_pad(X));
         {baseX_int_encode, X}      -> bfun(BF, builtin_baseX_int_encode(X));
         {baseX_int_encode_, X}     -> bfun(BF, builtin_baseX_int_encode_(X));
-        {bytes_to_int, N}          -> bfun(BF, builtin_bytes_to_int(N));
-        {bytes_to_str, N}          -> bfun(BF, builtin_bytes_to_str(N));
-        {bytes_concat, A, B}       -> bfun(BF, builtin_bytes_concat(A, B));
-        {bytes_split, A, B}        -> bfun(BF, builtin_bytes_split(A, B));
-        bytes_to_str_worker        -> bfun(BF, builtin_bytes_to_str_worker());
-        bytes_to_str_worker_x      -> bfun(BF, builtin_bytes_to_str_worker_x());
         string_reverse             -> bfun(BF, builtin_string_reverse());
         string_reverse_            -> bfun(BF, builtin_string_reverse_())
     end.
@@ -185,23 +171,16 @@ builtin_event(EventT) ->
     VIx       = fun(Ix) -> v(lists:concat(["v", Ix])) end,
     ArgPats   = fun(Ts) -> [ VIx(Ix) || Ix <- lists:seq(0, length(Ts) - 1) ] end,
     Payload = %% Should put data ptr, length on stack.
-        fun([])            -> {inline_asm, [A(?PUSH1), 0, A(?PUSH1), 0]};
-           ([{{id, _, "string"}, V}]) ->
-                {seq, [V, {inline_asm, [A(?DUP1), A(?MLOAD),  %% length, ptr
-                       A(?SWAP1), A(?PUSH1), 32, A(?ADD)]}]}; %% ptr+32, length
-           ([{{bytes_t, _, N}, V}]) -> {seq, [V, {integer, N}, {inline_asm, A(?SWAP1)}]}
+        fun([]) ->  {inline_asm, [A(?PUSH1), 0, A(?PUSH1), 0]};
+           ([V]) -> {seq, [V, {inline_asm, [A(?DUP1), A(?MLOAD),                  %% length, ptr
+                                            A(?SWAP1), A(?PUSH1), 32, A(?ADD)]}]} %% ptr+32, length
         end,
-    Ix =
-        fun({bytes_t, _, N}, V) when N < 32 -> ?BSR(V, 32 - N);
-           (_, V) -> V end,
     Clause =
         fun(_Tag, {con, _, Con}, IxTypes) ->
             Types     = [ T || {_Ix, T} <- IxTypes ],
-            Indexed   = [ Ix(Type, Var) || {Var, {indexed, Type}} <- lists:zip(ArgPats(Types), IxTypes) ],
-            Data      = [ {Type, Var} || {Var, {notindexed, Type}} <- lists:zip(ArgPats(Types), IxTypes) ],
-            {ok, <<EvtIndexN:256>>} = eblake2:blake2b(?HASH_BYTES, list_to_binary(Con)),
-            EvtIndex  = {integer, EvtIndexN},
-            {event, lists:reverse(Indexed) ++ [EvtIndex], Payload(Data)}
+            Indexed   = [ Var || {Var, {indexed, _Type}} <- lists:zip(ArgPats(Types), IxTypes) ],
+            EvtIndex  = {unop, 'sha3', str_to_icode(Con)},
+            {event, lists:reverse(Indexed) ++ [EvtIndex], Payload(ArgPats(Types) -- Indexed)}
         end,
     Pat = fun(Tag, Types) -> {tuple, [{integer, Tag} | ArgPats(Types)]} end,
 
@@ -222,17 +201,6 @@ builtin_abort() ->
                    A(?REVERT)]}, %% Stack: 0,Ptr
      {tuple,[]}}.
 
-builtin_block_hash() ->
-    {[{"height", word}],
-     ?LET(hash, #prim_block_hash{ height = ?V(height)},
-          {ifte, ?EQ(hash, 0), option_none(), option_some(?V(hash))}),
-     aeso_icode:option_typerep(word)}.
-
-builtin_require() ->
-    {[{"c", word}, {"msg", string}],
-     {ifte, ?V(c), {tuple, []}, ?call(abort, [?V(msg)])},
-     {tuple, []}}.
-
 %% Map primitives
 builtin_map_lookup(Type) ->
     Ret = aeso_icode:option_typerep(Type),
@@ -469,10 +437,6 @@ builtin_baseX_int_pad(X = 10) ->
         ?call({baseX_int_encode, X}, [?NEG(src), ?I(1), ?BSL($-, 31)]),
         ?call({baseX_int_encode, X}, [?V(src), ?V(ix), ?V(dst)])},
      word};
-builtin_baseX_int_pad(X = 16) ->
-    {[{"src", word}, {"ix", word}, {"dst", word}],
-        ?call({baseX_int_encode, X}, [?V(src), ?V(ix), ?V(dst)]),
-     word};
 builtin_baseX_int_pad(X = 58) ->
     {[{"src", word}, {"ix", word}, {"dst", word}],
      {ifte, ?GT(?ADD(?DIV(ix, 31), ?BYTE(ix, src)), 0),
@@ -507,77 +471,6 @@ builtin_baseX_digits(X) ->
         {ifte, ?EQ(x1, 0), ?V(dgts), ?call({baseX_digits, X}, [?V(x1), ?ADD(dgts, 1)])}),
      word}.
 
-builtin_bytes_to_int(32) ->
-    {[{"w", word}], ?V(w), word};
-builtin_bytes_to_int(N) when N < 32 ->
-    {[{"w", word}], ?BSR(w, 32 - N), word};
-builtin_bytes_to_int(N) when N > 32 ->
-    LastFullWord = N div 32 - 1,
-    Body = case N rem 32 of
-                0 -> ?DEREF(n, ?ADD(b, LastFullWord * 32), ?V(n));
-                R ->
-                    ?DEREF(hi, ?ADD(b, LastFullWord * 32),
-                    ?DEREF(lo, ?ADD(b, (LastFullWord + 1) * 32),
-                    ?ADD(?BSR(lo, 32 - R), ?BSL(hi, R))))
-           end,
-    {[{"b", pointer}], Body, word}.
-
-%% Two versions of this helper function, worker for sections not even 16 bytes long
-%% and worker_x for the full sized chunks.
-builtin_bytes_to_str_worker_x() ->
-    <<Tab:256>> = <<"0123456789ABCDEF________________">>,
-    {[{"w", word}, {"offs", word}, {"acc", word}],
-     {ifte, ?EQ(offs, 16), {seq, [?V(acc), {inline_asm, [?A(?MSIZE), ?A(?MSTORE), ?A(?MSIZE)]}]},
-         ?LET(b,  ?BYTE(offs, w),
-         ?LET(lo, ?BYTE(?MOD(b, 16), Tab),
-         ?LET(hi, ?BYTE(op('bsr', 4 , b), Tab),
-         ?call(bytes_to_str_worker_x, [?V(w), ?ADD(offs, 1), ?ADD(?BSL(acc, 2), ?ADD(?BSL(hi, 1), lo))]))))
-     },
-     word}.
-
-builtin_bytes_to_str_worker() ->
-    <<Tab:256>> = <<"0123456789ABCDEF________________">>,
-    {[{"w", word}, {"offs", word}, {"acc", word}, {"stop", word}],
-     {ifte, ?EQ(stop, offs), {seq, [?BSL(acc, ?MUL(2, ?SUB(16, offs))), {inline_asm, [?A(?MSIZE), ?A(?MSTORE), ?A(?MSIZE)]}]},
-         ?LET(b,  ?BYTE(offs, w),
-         ?LET(lo, ?BYTE(?MOD(b, 16), Tab),
-         ?LET(hi, ?BYTE(op('bsr', 4 , b), Tab),
-         ?call(bytes_to_str_worker, [?V(w), ?ADD(offs, 1), ?ADD(?BSL(acc, 2), ?ADD(?BSL(hi, 1), lo)), ?V(stop)]))))
-     },
-     word}.
-
-builtin_bytes_to_str_body(Var, N) when N < 16 ->
-    [?call(bytes_to_str_worker, [?V(Var), ?I(0), ?I(0), ?I(N)])];
-builtin_bytes_to_str_body(Var, 16) ->
-    [?call(bytes_to_str_worker_x, [?V(Var), ?I(0), ?I(0)])];
-builtin_bytes_to_str_body(Var, N) when N < 32 ->
-    builtin_bytes_to_str_body(Var, 16) ++ [{inline_asm, [?A(?POP)]}] ++
-    [?call(bytes_to_str_worker, [?BSL(Var, 16), ?I(0), ?I(0), ?I(N - 16)])];
-builtin_bytes_to_str_body(Var, 32) ->
-    builtin_bytes_to_str_body(Var, 16) ++ [{inline_asm, [?A(?POP)]}] ++
-    [?call(bytes_to_str_worker_x, [?BSL(Var, 16), ?I(0), ?I(0)])];
-builtin_bytes_to_str_body(Var, N) when N > 32 ->
-    WholeWords = ((N + 31) div 32) - 1,
-    lists:append(
-    [ [?DEREF(w, ?ADD(Var, 32 * I), {seq, builtin_bytes_to_str_body(w, 32)}), {inline_asm, [?A(?POP)]}]
-      || I <- lists:seq(0, WholeWords - 1) ]) ++
-    [ ?DEREF(w, ?ADD(Var, 32 * WholeWords), {seq, builtin_bytes_to_str_body(w, N - WholeWords * 32)}) ].
-
-builtin_bytes_to_str(N) when N =< 32 ->
-    {[{"w", word}],
-     ?LET(ret, {inline_asm, [?A(?MSIZE)]},
-     {seq, [?I(N * 2), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]}] ++
-            builtin_bytes_to_str_body(w, N) ++
-            [{inline_asm, [?A(?POP)]}, ?V(ret)]}),
-     string};
-builtin_bytes_to_str(N) when N > 32 ->
-    {[{"p", pointer}],
-     ?LET(ret, {inline_asm, [?A(?MSIZE)]},
-     {seq, [?I(N * 2), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]}] ++
-            builtin_bytes_to_str_body(p, N) ++
-            [{inline_asm, [?A(?POP)]}, ?V(ret)]}),
-     string}.
-
 builtin_string_reverse() ->
     {[{"s", string}],
      ?DEREF(n, s,
@@ -605,80 +498,3 @@ builtin_string_reverse_() ->
 builtin_addr_to_str() ->
     {[{"a", word}], ?call({baseX_int, 58}, [?V(a)]), word}.
 
-%% At most one word
-%% | ..... | ========= | ........ |
-%%    Offs ^ ^- Len -^   TotalLen ^
-bytes_slice(Offs, Len, TotalLen, Bytes) when TotalLen =< 32 ->
-    %% Bytes are packed into a single word
-    Masked =
-        case Offs of
-            0 -> Bytes;
-            _ -> ?MOD(Bytes, 1 bsl ((32 - Offs) * 8))
-        end,
-    Unpadded =
-        case 32 - (Offs + Len) of
-            0 -> Masked;
-            N -> ?BSR(Masked, N)
-        end,
-    case Len of
-        32 -> Unpadded;
-        _  -> ?BSL(Unpadded, 32 - Len)
-    end;
-bytes_slice(Offs, Len, TotalLen, Bytes) when TotalLen > 32 ->
-    %% Bytes is a pointer to memory. The VM can read at non-aligned addresses.
-    %% Might read one word more than necessary.
-    Word = op('!', Offs, Bytes),
-    case Len == 32 of
-        true -> Word;
-        _    -> ?BSL(?BSR(Word, 32 - Len), 32 - Len)
-    end.
-
-builtin_bytes_concat(A, B) ->
-    Type     = fun(N) when N =< 32 -> word; (_) -> pointer end,
-    MkBytes  = fun([W]) -> W;
-                  (Ws)  -> {tuple, Ws} end,
-    Words    = fun(N) -> (N + 31) div 32 end,
-    WordsRes = Words(A + B),
-    Word = fun(I) when 32 * (I + 1) =< A -> bytes_slice(I * 32, 32, A, ?V(a));
-              (I) when 32 * I < A ->
-                   Len = A rem 32,
-                   Hi  = bytes_slice(32 * I, Len, A, ?V(a)),
-                   Lo  = bytes_slice(0, min(32 - Len, B), B, ?V(b)),
-                   ?ADD(Hi, ?BSR(Lo, Len));
-              (I) ->
-                   Offs = 32 * I - A,
-                   Len  = min(32, B - Offs),
-                   bytes_slice(Offs, Len, B, ?V(b))
-           end,
-    Body =
-        case {A, B} of
-            {0, _} -> ?V(b);
-            {_, 0} -> ?V(a);
-            _      -> MkBytes([ Word(I) || I <- lists:seq(0, WordsRes - 1) ])
-        end,
-    {[{"a", Type(A)}, {"b", Type(B)}], Body, Type(A + B)}.
-
-builtin_bytes_split(A, B) ->
-    Type    = fun(N) when N =< 32 -> word; (_) -> pointer end,
-    MkBytes = fun([W]) -> W;
-                 (Ws)  -> {tuple, Ws} end,
-    Word    = fun(I, Max) ->
-                bytes_slice(I, min(32, Max - I), A + B, ?V(c))
-              end,
-    Body =
-        case {A, B} of
-            {0, _} -> [?I(0), ?V(c)];
-            {_, 0} -> [?V(c), ?I(0)];
-            _      -> [MkBytes([ Word(I, A)     || I <- lists:seq(0, A - 1, 32) ]),
-                       MkBytes([ Word(I, A + B) || I <- lists:seq(A, A + B - 1, 32) ])]
-        end,
-    {[{"c", Type(A + B)}], {tuple, Body}, {tuple, [Type(A), Type(B)]}}.
-
-bytes_to_raw_string(N, Term) when N =< 32 ->
-    {tuple, [?I(N), Term]};
-bytes_to_raw_string(N, Term) when N > 32 ->
-    Elem  = fun(I) -> #binop{op = '!', left = ?I(32 * I), right = ?V(bin)}
-            end,
-    Words = (N + 31) div 32,
-    ?LET(bin, Term, {tuple, [?I(N) | [Elem(I) || I <- lists:seq(0, Words - 1)]]}).
-

src/aeso_code_errors.erl

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

src/aeso_compiler.erl

@@ -12,23 +12,16 @@
         , file/2
         , from_string/2
         , check_call/4
-        , create_calldata/3  %% deprecated
-        , create_calldata/4
+        , create_calldata/3
         , version/0
-        , numeric_version/0
         , sophia_type_to_typerep/1
-        , to_sophia_value/4  %% deprecated, need a backend
+        , to_sophia_value/4
         , to_sophia_value/5
-        , decode_calldata/3  %% deprecated
-        , decode_calldata/4
-        , parse/2
-        , add_include_path/2
-        , validate_byte_code/3
+        , decode_calldata/3
         ]).
 
 -include_lib("aebytecode/include/aeb_opcodes.hrl").
 -include("aeso_icode.hrl").
--include("aeso_utils.hrl").
 
 
 -type option() :: pp_sophia_code
@@ -38,14 +31,9 @@
                 | pp_icode
                 | pp_assembler
                 | pp_bytecode
-                | no_code
-                | keep_included
-                | debug_mode
-                | {backend, aevm | fate}
                 | {include, {file_system, [string()]} |
                             {explicit_files, #{string() => binary()}}}
-                | {src_file, string()}
-                | {aci, aeso_aci:aci_type()}.
+                | {src_file, string()}.
 -type options() :: [option()].
 
 -export_type([ option/0
@@ -71,123 +59,67 @@ version() ->
             {ok, list_to_binary(VsnString)}
     end.
 
--spec numeric_version() -> {ok, [non_neg_integer()]} | {error, term()}.
-numeric_version() ->
-    case version() of
-        {ok, Bin} ->
-            [NoSuf | _] = binary:split(Bin, <<"-">>),
-            Numbers     = binary:split(NoSuf, <<".">>, [global]),
-            {ok, [binary_to_integer(Num) || Num <- Numbers]};
-        {error, _} = Err ->
-            Err
-    end.
-
--spec file(string()) -> {ok, map()} | {error, [aeso_errors:error()]}.
+-spec file(string()) -> {ok, map()} | {error, binary()}.
 file(Filename) ->
-    file(Filename, []).
+    Dir = filename:dirname(Filename),
+    {ok, Cwd} = file:get_cwd(),
+    file(Filename, [{include, {file_system, [Cwd, Dir]}}]).
 
--spec file(string(), options()) -> {ok, map()} | {error, [aeso_errors:error()]}.
-file(File, Options0) ->
-    Options = add_include_path(File, Options0),
+-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} ->
-            Msg = lists:flatten([File,": ",file:format_error(Error)]),
-            {error, [aeso_errors:new(file_error, Msg)]}
+	    ErrorString = [File,": ",file:format_error(Error)],
+	    {error, join_errors("File errors", [ErrorString], fun(E) -> E end)}
     end.
 
-add_include_path(File, Options) ->
-    case lists:keymember(include, 1, Options) of
-        true  -> Options;
-        false ->
-            Dir = filename:dirname(File),
-            {ok, Cwd} = file:get_cwd(),
-            [{include, {file_system, [Cwd, Dir]}} | Options]
-    end.
-
--spec from_string(binary() | string(), options()) -> {ok, map()} | {error, [aeso_errors:error()]}.
-from_string(Contract, Options) ->
-    from_string(proplists:get_value(backend, Options, aevm), Contract, Options).
-
-from_string(Backend, ContractBin, Options) when is_binary(ContractBin) ->
-    from_string(Backend, binary_to_list(ContractBin), Options);
-from_string(Backend, ContractString, Options) ->
+-spec from_string(binary() | string(), options()) -> {ok, map()} | {error, binary()}.
+from_string(ContractBin, Options) when is_binary(ContractBin) ->
+    from_string(binary_to_list(ContractBin), Options);
+from_string(ContractString, Options) ->
     try
-        from_string1(Backend, ContractString, Options)
+        #{icode := Icode} = string_to_icode(ContractString, Options),
+        TypeInfo  = extract_type_info(Icode),
+        Assembler = assemble(Icode, Options),
+        pp_assembler(Assembler, Options),
+        ByteCodeList = to_bytecode(Assembler, Options),
+        ByteCode = << << B:8 >> || B <- ByteCodeList >>,
+        pp_bytecode(ByteCode, Options),
+        {ok, Version} = version(),
+        {ok, #{byte_code => ByteCode,
+               compiler_version => Version,
+               contract_source => ContractString,
+               type_info => TypeInfo
+              }}
     catch
-        throw:{error, Errors} -> {error, Errors}
+        %% 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.
 
-from_string1(aevm, ContractString, Options) ->
-    #{ icode := Icode
-     , folded_typed_ast := FoldedTypedAst } = string_to_code(ContractString, Options),
-    TypeInfo  = extract_type_info(Icode),
-    Assembler = assemble(Icode, Options),
-    pp_assembler(aevm, Assembler, Options),
-    ByteCodeList = to_bytecode(Assembler, Options),
-    ByteCode = << << B:8 >> || B <- ByteCodeList >>,
-    pp_bytecode(ByteCode, Options),
-    {ok, Version} = version(),
-    Res = #{byte_code => ByteCode,
-            compiler_version => Version,
-            contract_source => ContractString,
-            type_info => TypeInfo,
-            abi_version => aeb_aevm_abi:abi_version(),
-            payable => maps:get(payable, Icode)
-           },
-    {ok, maybe_generate_aci(Res, FoldedTypedAst, Options)};
-from_string1(fate, ContractString, Options) ->
-    #{ fcode := FCode
-     , fcode_env := #{child_con_env := ChildContracts}
-     , folded_typed_ast := FoldedTypedAst } = string_to_code(ContractString, Options),
-    FateCode = aeso_fcode_to_fate:compile(ChildContracts, FCode, Options),
-    pp_assembler(fate, FateCode, Options),
-    ByteCode = aeb_fate_code:serialize(FateCode, []),
-    {ok, Version} = version(),
-    Res = #{byte_code => ByteCode,
-            compiler_version => Version,
-            contract_source => ContractString,
-            type_info => [],
-            fate_code => FateCode,
-            abi_version => aeb_fate_abi:abi_version(),
-            payable => maps:get(payable, FCode)
-           },
-    {ok, maybe_generate_aci(Res, FoldedTypedAst, Options)}.
-
-maybe_generate_aci(Result, FoldedTypedAst, Options) ->
-    case proplists:get_value(aci, Options) of
-        undefined ->
-            Result;
-        Type ->
-            {ok, Aci} = aeso_aci:from_typed_ast(Type, FoldedTypedAst),
-            maps:put(aci, Aci, Result)
-    end.
-
--spec string_to_code(string(), options()) -> map().
-string_to_code(ContractString, Options) ->
+-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, FoldedTypedAst, UnfoldedTypedAst} = aeso_ast_infer_types:infer(Ast, [return_env | Options]),
-    pp_typed_ast(UnfoldedTypedAst, Options),
-    case proplists:get_value(backend, Options, aevm) of
-        aevm ->
-            Icode = ast_to_icode(UnfoldedTypedAst, Options),
-            pp_icode(Icode, Options),
-            #{ icode => Icode
-             , unfolded_typed_ast => UnfoldedTypedAst
-             , folded_typed_ast => FoldedTypedAst
-             , type_env  => TypeEnv
-             , ast => Ast };
-        fate ->
-            {Env, Fcode} = aeso_ast_to_fcode:ast_to_fcode(UnfoldedTypedAst, [{original_src, ContractString}|Options]),
-            #{ fcode => Fcode
-             , fcode_env => Env
-             , unfolded_typed_ast => UnfoldedTypedAst
-             , folded_typed_ast => FoldedTypedAst
-             , type_env  => TypeEnv
-             , ast => Ast }
-    end.
+    {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").
@@ -198,15 +130,14 @@ string_to_code(ContractString, Options) ->
 %% terms for the arguments.
 %% NOTE: Special treatment for "init" since it might be implicit and has
 %%       a special return type (typerep, T)
--spec check_call(string(), string(), [string()], options()) -> {ok, string(), {[Type], Type}, [term()]}
-                                                                   | {ok, string(), [term()]}
-                                                                   | {error, [aeso_errors:error()]}
+-spec check_call(string(), string(), [string()], options()) -> {ok, string(), {[Type], Type}, [term()]} | {error, term()}
     when Type :: term().
 check_call(Source, "init" = FunName, Args, Options) ->
-    case check_call1(Source, FunName, Args, Options) of
+    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_call1(insert_init_function(Source, Options), FunName, Args, Options) of
+            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;
@@ -214,76 +145,50 @@ check_call(Source, "init" = FunName, Args, Options) ->
             Res
     end;
 check_call(Source, FunName, Args, Options) ->
-    check_call1(Source, FunName, Args, Options).
+    PatchFun = fun(T) -> T end,
+    check_call(Source, FunName, Args, Options, PatchFun).
 
-check_call1(ContractString0, FunName, Args, Options) ->
+check_call(ContractString0, FunName, Args, Options, PatchFun) ->
     try
-        case proplists:get_value(backend, Options, aevm) of
-            aevm ->
-                %% First check the contract without the __call function
-                #{ast := Ast} = string_to_code(ContractString0, Options),
-                ContractString = insert_call_function(Ast, ContractString0, ?CALL_NAME, FunName, Args),
-                #{unfolded_typed_ast := TypedAst,
-                  icode     := Icode} = string_to_code(ContractString, Options),
-                {ok, {FunName, {fun_t, _, _, ArgTypes, RetType}}} = get_call_type(TypedAst),
-                ArgVMTypes = [ aeso_ast_to_icode:ast_typerep(T, Icode) || T <- ArgTypes ],
-                RetVMType  = case RetType of
-                                 {id, _, "_"} -> any;
-                                 _            -> aeso_ast_to_icode:ast_typerep(RetType, Icode)
-                             end,
-                #{ functions := Funs } = Icode,
-                ArgIcode = get_arg_icode(Funs),
-                ArgTerms = [ icode_to_term(T, Arg) ||
-                               {T, Arg} <- lists:zip(ArgVMTypes, ArgIcode) ],
-                RetVMType1 =
-                    case FunName of
-                        "init" -> {tuple, [typerep, RetVMType]};
-                        _ -> RetVMType
-                    end,
-                {ok, FunName, {ArgVMTypes, RetVMType1}, ArgTerms};
-            fate ->
-                %% First check the contract without the __call function
-                #{ fcode := OrgFcode
-                 , ast := Ast } = string_to_code(ContractString0, Options),
-                FateCode = aeso_fcode_to_fate:compile(OrgFcode, []),
-                %% collect all hashes and compute the first name without hash collision to
-                SymbolHashes = maps:keys(aeb_fate_code:symbols(FateCode)),
-                CallName = first_none_match(?CALL_NAME, SymbolHashes,
-                                            lists:seq($1, $9) ++ lists:seq($A, $Z) ++ lists:seq($a, $z)),
-                ContractString = insert_call_function(Ast, ContractString0, CallName, FunName, Args),
-                #{fcode := Fcode} = string_to_code(ContractString, Options),
-                CallArgs = arguments_of_body(CallName, FunName, Fcode),
-                {ok, FunName, CallArgs}
-        end
+        %% First check the contract without the __call function
+        #{} = string_to_icode(ContractString0, Options),
+        ContractString = insert_call_function(ContractString0, FunName, Args, Options),
+        #{typed_ast := TypedAst,
+          icode     := Icode} = string_to_icode(ContractString, Options),
+        {ok, {FunName, {fun_t, _, _, ArgTypes, RetType}}} = get_call_type(TypedAst),
+        ArgVMTypes = [ aeso_ast_to_icode:ast_typerep(T, Icode) || T <- ArgTypes ],
+        RetVMType  = case RetType of
+                         {id, _, "_"} -> any;
+                         _            -> aeso_ast_to_icode:ast_typerep(RetType, Icode)
+                     end,
+        #{ functions := Funs } = Icode,
+        ArgIcode = get_arg_icode(Funs),
+        ArgTerms = [ icode_to_term(T, Arg) ||
+                       {T, Arg} <- lists:zip(ArgVMTypes, ArgIcode) ],
+        {ok, FunName, {ArgVMTypes, PatchFun(RetVMType)}, ArgTerms}
     catch
-        throw:{error, Errors} -> {error, Errors}
-    end.
-
-arguments_of_body(CallName, _FunName, Fcode) ->
-    #{body := Body} = maps:get({entrypoint, list_to_binary(CallName)}, maps:get(functions, Fcode)),
-    {def, _FName, Args} = Body,
-    %% FName is either {entrypoint, list_to_binary(FunName)} or 'init'
-    [ aeso_fcode_to_fate:term_to_fate(A) || A <- Args ].
-
-first_none_match(_CallName, _Hashes, []) ->
-    error(unable_to_find_unique_call_name);
-first_none_match(CallName, Hashes, [Char|Chars]) ->
-    case not lists:member(aeb_fate_code:symbol_identifier(list_to_binary(CallName)), Hashes) of
-        true ->
-            CallName;
-        false ->
-            first_none_match(?CALL_NAME++[Char], Hashes, Chars)
+        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_call_function}} ->
+            {error, join_errors("Type errors", ["missing __call function"],
+                                fun (E) -> E end)};
+        throw:Error ->                          %Don't ask
+            {error, join_errors("Code errors", [Error],
+                                fun (E) -> io_lib:format("~p", [E]) end)}
     end.
 
 %% Add the __call function to a contract.
--spec insert_call_function(aeso_syntax:ast(), string(), string(), string(), [string()]) -> string().
-insert_call_function(Ast, Code, Call, FunName, Args) ->
+-spec insert_call_function(string(), string(), [string()], options()) -> string().
+insert_call_function(Code, FunName, Args, Options) ->
+    Ast = parse(Code, Options),
     Ind = last_contract_indent(Ast),
     lists:flatten(
         [ Code,
           "\n\n",
           lists:duplicate(Ind, " "),
-          "stateful entrypoint ", Call, "() = ", FunName, "(", string:join(Args, ","), ")\n"
+          "function __call() = ", FunName, "(", string:join(Args, ","), ")\n"
         ]).
 
 -spec insert_init_function(string(), options()) -> string().
@@ -293,7 +198,7 @@ insert_init_function(Code, Options) ->
     lists:flatten(
         [ Code,
           "\n\n",
-          lists:duplicate(Ind, " "), "entrypoint init() = ()\n"
+          lists:duplicate(Ind, " "), "function init() = ()\n"
         ]).
 
 last_contract_indent(Decls) ->
@@ -303,202 +208,190 @@ last_contract_indent(Decls) ->
     end.
 
 -spec to_sophia_value(string(), string(), ok | error | revert, aeb_aevm_data:data()) ->
-        {ok, aeso_syntax:expr()} | {error, [aeso_errors:error()]}.
+        {ok, aeso_syntax:expr()} | {error, term()}.
 to_sophia_value(ContractString, Fun, ResType, Data) ->
-    to_sophia_value(ContractString, Fun, ResType, Data, [{backend, aevm}]).
+    to_sophia_value(ContractString, Fun, ResType, Data, []).
 
 -spec to_sophia_value(string(), string(), ok | error | revert, binary(), options()) ->
-        {ok, aeso_syntax:expr()} | {error, [aeso_errors:error()]}.
+        {ok, aeso_syntax:expr()} | {error, term()}.
 to_sophia_value(_, _, error, Err, _Options) ->
     {ok, {app, [], {id, [], "error"}, [{string, [], Err}]}};
-to_sophia_value(_, _, revert, Data, Options) ->
-    case proplists:get_value(backend, Options, aevm) of
-        aevm ->
-            case aeb_heap:from_binary(string, Data) of
-                {ok, Err} ->
-                    {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}};
-                {error, _} ->
-                    Msg = "Could not interpret the revert message\n",
-                    {error, [aeso_errors:new(data_error, Msg)]}
-            end;
-        fate ->
-            try aeb_fate_encoding:deserialize(Data) of
-                Err -> {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}}
-            catch _:_ ->
-                Msg = "Could not deserialize the revert message\n",
-                {error, [aeso_errors:new(data_error, Msg)]}
-            end
+to_sophia_value(_, _, revert, Data, _Options) ->
+    case aeb_heap:from_binary(string, Data) of
+        {ok, Err} -> {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}};
+        {error, _} = Err -> Err
     end;
-to_sophia_value(ContractString, FunName, ok, Data, Options0) ->
-    Options = [no_code | Options0],
+to_sophia_value(ContractString, FunName, ok, Data, Options) ->
     try
-        Code = string_to_code(ContractString, Options),
-        #{ unfolded_typed_ast := TypedAst, type_env  := TypeEnv} = Code,
+        #{ 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]),
-
-        case proplists:get_value(backend, Options, aevm) of
-            aevm ->
-                Icode  = maps:get(icode, Code),
-                VmType = aeso_ast_to_icode:ast_typerep(Type, Icode),
-                case aeb_heap:from_binary(VmType, Data) of
-                    {ok, VmValue} ->
-                        try
-                            {ok, aeso_vm_decode:from_aevm(VmType, Type, VmValue)}
-                        catch throw:cannot_translate_to_sophia ->
-                            Type0Str = prettypr:format(aeso_pretty:type(Type0)),
-                            Msg = io_lib:format("Cannot translate VM value ~p\n  of type ~p\n  to Sophia type ~s\n",
-                                                [Data, VmType, Type0Str]),
-                            {error, [aeso_errors:new(data_error, Msg)]}
-                        end;
-                    {error, _Err} ->
-                        Msg = io_lib:format("Failed to decode binary as type ~p\n", [VmType]),
-                        {error, [aeso_errors:new(data_error, Msg)]}
-                end;
-            fate ->
+        VmType = aeso_ast_to_icode:ast_typerep(Type, Icode),
+        case aeb_heap:from_binary(VmType, Data) of
+            {ok, VmValue} ->
                 try
-                    {ok, aeso_vm_decode:from_fate(Type, aeb_fate_encoding:deserialize(Data))}
+                    {ok, translate_vm_value(VmType, Type, VmValue)}
                 catch throw:cannot_translate_to_sophia ->
-                        Type1 = prettypr:format(aeso_pretty:type(Type0)),
-                        Msg = io_lib:format("Cannot translate FATE value ~p\n  of Sophia type ~s\n",
-                                            [aeb_fate_encoding:deserialize(Data), Type1]),
-                        {error, [aeso_errors:new(data_error, Msg)]};
-                      _:_ ->
-                        Type1 = prettypr:format(aeso_pretty:type(Type0)),
-                        Msg = io_lib:format("Failed to decode binary as type ~s\n", [Type1]),
-                        {error, [aeso_errors:new(data_error, Msg)]}
-               end
+                    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
-        throw:{error, Errors} -> {error, 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:{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, [aeso_errors:error()]}.
+                             | {error, term()}.
 create_calldata(Code, Fun, Args) ->
-    create_calldata(Code, Fun, Args, [{backend, aevm}]).
-
--spec create_calldata(string(), string(), [string()], [{atom(), any()}]) ->
-                             {ok, binary()} | {error, [aeso_errors:error()]}.
-create_calldata(Code, Fun, Args, Options0) ->
-    Options = [no_code | Options0],
-    case proplists:get_value(backend, Options, aevm) of
-        aevm ->
-            case check_call(Code, Fun, Args, Options) of
-                {ok, FunName, {ArgTypes, RetType}, VMArgs} ->
-                    aeb_aevm_abi:create_calldata(FunName, VMArgs, ArgTypes, RetType);
-                {error, _} = Err -> Err
-            end;
-        fate ->
-            case check_call(Code, Fun, Args, Options) of
-                {ok, FunName, FateArgs} ->
-                    aeb_fate_abi:create_calldata(FunName, FateArgs);
-                {error, _} = Err -> Err
-            end
+    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, [aeso_errors:error()]}.
+                             | {error, term()}.
 decode_calldata(ContractString, FunName, Calldata) ->
-    decode_calldata(ContractString, FunName, Calldata, [{backend, aevm}]).
-
-decode_calldata(ContractString, FunName, Calldata, Options0) ->
-    Options = [no_code | Options0],
     try
-        Code = string_to_code(ContractString, Options),
-        #{ unfolded_typed_ast := TypedAst, type_env  := TypeEnv} = Code,
-
+        #{ typed_ast := TypedAst,
+           type_env  := TypeEnv,
+           icode     := Icode } = string_to_icode(ContractString, []),
         {ok, Args, _} = get_decode_type(FunName, TypedAst),
-        GetType       = fun({typed, _, _, T}) -> T; (T) -> T end,
-        ArgTypes      = lists:map(GetType, Args),
+        DropArg       = fun({arg, _, _, T}) -> T; (T) -> T end,
+        ArgTypes      = lists:map(DropArg, Args),
         Type0         = {tuple_t, [], ArgTypes},
-        %% user defined data types such as variants needed to match against
-        Type          = aeso_ast_infer_types:unfold_types_in_type(TypeEnv, Type0, [unfold_record_types, unfold_variant_types]),
-        case proplists:get_value(backend, Options, aevm) of
-            aevm ->
-                Icode  = maps:get(icode, Code),
-                VmType = aeso_ast_to_icode:ast_typerep(Type, Icode),
-                case aeb_heap:from_binary({tuple, [word, VmType]}, Calldata) of
-                    {ok, {_, VmValue}} ->
-                        try
-                            {tuple, [], Values} = aeso_vm_decode:from_aevm(VmType, Type, VmValue),
-                            %% Values are Sophia expressions in AST format
-                            {ok, ArgTypes, Values}
-                        catch throw:cannot_translate_to_sophia ->
-                            Type0Str = prettypr:format(aeso_pretty:type(Type0)),
-                            Msg = io_lib:format("Cannot translate VM value ~p\n  of type ~p\n  to Sophia type ~s\n",
-                                                [VmValue, VmType, Type0Str]),
-                            {error, [aeso_errors:new(data_error, Msg)]}
-                        end;
-                    {error, _Err} ->
-                        Msg = io_lib:format("Failed to decode calldata as type ~p\n", [VmType]),
-                        {error, [aeso_errors:new(data_error, Msg)]}
+        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;
-            fate ->
-                case aeb_fate_abi:decode_calldata(FunName, Calldata) of
-                    {ok, FateArgs} ->
-                        try
-                            {tuple_t, [], ArgTypes1} = Type,
-                            AstArgs = [ aeso_vm_decode:from_fate(ArgType, FateArg)
-                                        || {ArgType, FateArg} <- lists:zip(ArgTypes1, FateArgs)],
-                            {ok, ArgTypes, AstArgs}
-                        catch throw:cannot_translate_to_sophia ->
-                                Type0Str = prettypr:format(aeso_pretty:type(Type0)),
-                                Msg = io_lib:format("Cannot translate FATE value ~p\n  to Sophia type ~s\n",
-                                                    [FateArgs, Type0Str]),
-                                {error, [aeso_errors:new(data_error, Msg)]}
-                        end;
-                    {error, _} ->
-                        Msg = io_lib:format("Failed to decode calldata binary\n", []),
-                        {error, [aeso_errors:new(data_error, Msg)]}
-                end
+            {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
-        throw:{error, Errors} -> {error, 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:{badmatch, {error, missing_function}} ->
+            {error, join_errors("Type errors", ["no function: '" ++ FunName ++ "'"],
+                                fun (E) -> E end)};
+        throw:Error ->                          %Don't ask
+            {error, join_errors("Code errors", [Error],
+                                fun (E) -> io_lib:format("~p", [E]) end)}
     end.
 
+
 get_arg_icode(Funs) ->
     case [ Args || {[_, ?CALL_NAME], _, _, {funcall, _, Args}, _} <- Funs ] of
         [Args] -> Args;
-        []     -> error_missing_call_function()
+        []     -> error({missing_call_function, Funs})
     end.
 
--dialyzer({nowarn_function, error_missing_call_function/0}).
-error_missing_call_function() ->
-    Msg = "Internal error: missing '__call'-function",
-    aeso_errors:throw(aeso_errors:new(internal_error, Msg)).
-
-get_call_type([{Contract, _, _, Defs}]) when ?IS_CONTRACT_HEAD(Contract) ->
+get_call_type([{contract, _, _, Defs}]) ->
     case [ {lists:last(QFunName), FunType}
           || {letfun, _, {id, _, ?CALL_NAME}, [], _Ret,
                 {typed, _,
                     {app, _,
                         {typed, _, {qid, _, QFunName}, FunType}, _}, _}} <- Defs ] of
         [Call] -> {ok, Call};
-        []     -> error_missing_call_function()
+        []     -> {error, missing_call_function}
     end;
 get_call_type([_ | Contracts]) ->
     %% The __call should be in the final contract
     get_call_type(Contracts).
 
--dialyzer({nowarn_function, get_decode_type/2}).
-get_decode_type(FunName, [{Contract, Ann, _, Defs}]) when ?IS_CONTRACT_HEAD(Contract) ->
+get_decode_type(FunName, [{contract, _, _, Defs}]) ->
     GetType = fun({letfun, _, {id, _, Name}, Args, Ret, _})               when Name == FunName -> [{Args, Ret}];
                  ({fun_decl, _, {id, _, Name}, {fun_t, _, _, Args, Ret}}) when Name == FunName -> [{Args, Ret}];
                  (_) -> [] end,
     case lists:flatmap(GetType, Defs) of
         [{Args, Ret}] -> {ok, Args, Ret};
-        []            ->
-            case FunName of
-                "init" -> {ok, [], {tuple_t, [], []}};
-                 _ ->
-                    Msg = io_lib:format("Function '~s' is missing in contract\n", [FunName]),
-                    Pos = aeso_code_errors:pos(Ann),
-                    aeso_errors:throw(aeso_errors:new(data_error, Pos, Msg))
-            end
+        []            -> {error, missing_function}
     end;
 get_decode_type(FunName, [_ | Contracts]) ->
     %% The __decode should be in the final contract
@@ -507,10 +400,13 @@ 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().
 icode_to_term(word, {integer, N}) -> N;
-icode_to_term(word, {unop, '-', {integer, N}}) -> -N;
 icode_to_term(string, {tuple, [{integer, Len} | Words]}) ->
     <<Str:Len/binary, _/binary>> = << <<W:256>> || {integer, W} <- Words >>,
     Str;
+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}) ->
@@ -531,14 +427,6 @@ icode_to_term(T = {map, KT, VT}, M) ->
             #{};
         _ -> throw({todo, M})
     end;
-icode_to_term(word, {unop, 'bnot', A}) ->
-    bnot icode_to_term(word, A);
-icode_to_term(word, {binop, 'bor', A, B}) ->
-    icode_to_term(word, A) bor icode_to_term(word, B);
-icode_to_term(word, {binop, 'bsl', A, B}) ->
-    icode_to_term(word, B) bsl icode_to_term(word, A);
-icode_to_term(word, {binop, 'band', A, B}) ->
-    icode_to_term(word, A) band icode_to_term(word, B);
 icode_to_term(typerep, _) ->
     throw({todo, typerep});
 icode_to_term(T, V) ->
@@ -562,9 +450,8 @@ to_bytecode([], _) -> [].
 
 extract_type_info(#{functions := Functions} =_Icode) ->
     ArgTypesOnly = fun(As) -> [ T || {_, T} <- As ] end,
-    Payable = fun(Attrs) -> proplists:get_value(payable, Attrs, false) end,
-    TypeInfo = [aeb_aevm_abi:function_type_info(list_to_binary(lists:last(Name)),
-                                            Payable(Attrs), ArgTypesOnly(Args), TypeRep)
+    TypeInfo = [aeb_abi:function_type_info(list_to_binary(lists:last(Name)),
+                                            ArgTypesOnly(Args), TypeRep)
                 || {Name, Attrs, Args,_Body, TypeRep} <- Functions,
                    not is_tuple(Name),
                    not lists:member(private, Attrs)
@@ -577,11 +464,9 @@ pp_sophia_code(C, Opts)->  pp(C, Opts, pp_sophia_code, fun(Code) ->
 pp_ast(C, Opts)      ->  pp(C, Opts, pp_ast, fun aeso_ast:pp/1).
 pp_typed_ast(C, Opts)->  pp(C, Opts, pp_typed_ast, fun aeso_ast:pp_typed/1).
 pp_icode(C, Opts)    ->  pp(C, Opts, pp_icode, fun aeso_icode:pp/1).
+pp_assembler(C, Opts)->  pp(C, Opts, pp_assembler, fun aeb_asm:pp/1).
 pp_bytecode(C, Opts) ->  pp(C, Opts, pp_bytecode, fun aeb_disassemble:pp/1).
 
-pp_assembler(aevm, C, Opts) ->  pp(C, Opts, pp_assembler, fun aeb_asm:pp/1);
-pp_assembler(fate, C, Opts) ->  pp(C, Opts, pp_assembler, fun(Asm) -> io:format("~s", [aeb_fate_asm:pp(Asm)]) end).
-
 pp(Code, Options, Option, PPFun) ->
     case proplists:lookup(Option, Options) of
         {Option, true} ->
@@ -590,104 +475,49 @@ pp(Code, Options, Option, PPFun) ->
             ok
     end.
 
-%% -- Byte code validation ---------------------------------------------------
-
--define(protect(Tag, Code), fun() -> try Code catch _:Err1 -> throw({Tag, Err1}) end end()).
-
--spec validate_byte_code(map(), string(), options()) -> ok | {error, [aeso_errors:error()]}.
-validate_byte_code(#{ byte_code := ByteCode, payable := Payable }, Source, Options) ->
-    Fail = fun(Err) -> {error, [aeso_errors:new(data_error, Err)]} end,
-    case proplists:get_value(backend, Options, aevm) of
-        B when B /= fate -> Fail(io_lib:format("Unsupported backend: ~s\n", [B]));
-        fate ->
-            try
-                FCode1 = ?protect(deserialize, aeb_fate_code:strip_init_function(aeb_fate_code:deserialize(ByteCode))),
-                {FCode2, SrcPayable} =
-                    ?protect(compile,
-                             begin
-                               {ok, #{ byte_code := SrcByteCode, payable := SrcPayable }} =
-                                    from_string1(fate, Source, Options),
-                               FCode = aeb_fate_code:deserialize(SrcByteCode),
-                               {aeb_fate_code:strip_init_function(FCode), SrcPayable}
-                             end),
-                case compare_fate_code(FCode1, FCode2) of
-                    ok when SrcPayable /= Payable ->
-                        Not = fun(true) -> ""; (false) -> " not" end,
-                        Fail(io_lib:format("Byte code contract is~s payable, but source code contract is~s.\n",
-                                           [Not(Payable), Not(SrcPayable)]));
-                    ok           -> ok;
-                    {error, Why} -> Fail(io_lib:format("Byte code does not match source code.\n~s", [Why]))
-                end
-            catch
-                throw:{deserialize, _}         -> Fail("Invalid byte code");
-                throw:{compile, {error, Errs}} -> {error, Errs}
-            end
-    end.
-
-compare_fate_code(FCode1, FCode2) ->
-    Funs1 = aeb_fate_code:functions(FCode1),
-    Funs2 = aeb_fate_code:functions(FCode2),
-    Syms1 = aeb_fate_code:symbols(FCode1),
-    Syms2 = aeb_fate_code:symbols(FCode2),
-    FunHashes1 = maps:keys(Funs1),
-    FunHashes2 = maps:keys(Funs2),
-    case FunHashes1 == FunHashes2 of
-        false ->
-            InByteCode   = [ binary_to_list(maps:get(H, Syms1)) || H <- FunHashes1 -- FunHashes2 ],
-            InSourceCode = [ binary_to_list(maps:get(H, Syms2)) || H <- FunHashes2 -- FunHashes1 ],
-            Msg = [ io_lib:format("- Functions in the byte code but not in the source code:\n"
-                                  "    ~s\n", [string:join(InByteCode, ", ")]) || InByteCode /= [] ] ++
-                  [ io_lib:format("- Functions in the source code but not in the byte code:\n"
-                                  "    ~s\n", [string:join(InSourceCode, ", ")]) || InSourceCode /= [] ],
-            {error, Msg};
-        true ->
-            case lists:append([ compare_fate_fun(maps:get(H, Syms1), Fun1, Fun2)
-                                || {{H, Fun1}, {_, Fun2}} <- lists:zip(maps:to_list(Funs1),
-                                                                       maps:to_list(Funs2)) ]) of
-                [] -> ok;
-                Errs -> {error, Errs}
-            end
-    end.
-
-compare_fate_fun(_Name, Fun, Fun) -> [];
-compare_fate_fun(Name, {Attr, Type, _}, {Attr, Type, _}) ->
-    [io_lib:format("- The implementation of the function ~s is different.\n", [Name])];
-compare_fate_fun(Name, {Attr1, Type, _}, {Attr2, Type, _}) ->
-    [io_lib:format("- The attributes of the function ~s differ:\n"
-                   "    Byte code:   ~s\n"
-                   "    Source code: ~s\n",
-                   [Name, string:join([ atom_to_list(A) || A <- Attr1 ], ", "),
-                          string:join([ atom_to_list(A) || A <- Attr2 ], ", ")])];
-compare_fate_fun(Name, {_, Type1, _}, {_, Type2, _}) ->
-    [io_lib:format("- The type of the function ~s differs:\n"
-                   "    Byte code:   ~s\n"
-                   "    Source code: ~s\n",
-                   [Name, pp_fate_sig(Type1), pp_fate_sig(Type2)])].
-
-pp_fate_sig({[Arg], Res}) ->
-    io_lib:format("~s => ~s", [pp_fate_type(Arg), pp_fate_type(Res)]);
-pp_fate_sig({Args, Res}) ->
-    io_lib:format("(~s) => ~s", [string:join([pp_fate_type(Arg) || Arg <- Args], ", "), pp_fate_type(Res)]).
-
-pp_fate_type(T) -> io_lib:format("~w", [T]).
 
 %% -------------------------------------------------------------------
+%% TODO: Tempoary parser hook below...
 
--spec sophia_type_to_typerep(string()) -> {error, bad_type} | {ok, aeb_aevm_data:type()}.
 sophia_type_to_typerep(String) ->
-    Ast = aeso_parser:run_parser(aeso_parser:type(), String),
+    {ok, Ast} = aeso_parser:type(String),
     try aeso_ast_to_icode:ast_typerep(Ast) of
         Type -> {ok, Type}
     catch _:_ -> {error, bad_type}
     end.
 
--spec parse(string(), aeso_compiler:options()) -> none() | aeso_syntax:ast().
 parse(Text, Options) ->
-    parse(Text, sets:new(), 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.
 
--spec parse(string(), sets:set(), aeso_compiler:options()) -> none() | aeso_syntax:ast().
-parse(Text, Included, Options) ->
-    aeso_parser:string(Text, Included, Options).
+parse_error(Pos, ErrorString) ->
+    Error = io_lib:format("~s: ~s", [pos_error(Pos), ErrorString]),
+    error({parse_errors, [Error]}).
 
 read_contract(Name) ->
     file:read_file(Name).
+
+pos_error({Line, Pos}) ->
+    io_lib:format("line ~p, column ~p", [Line, Pos]);
+pos_error({no_file, Line, Pos}) ->
+    pos_error({Line, Pos});
+pos_error({File, Line, Pos}) ->
+    io_lib:format("file ~s, line ~p, column ~p", [File, Line, Pos]).
+

src/aeso_constants.erl

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

src/aeso_errors.erl

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

src/aeso_icode.erl

@@ -13,10 +13,8 @@
          pp/1,
          set_name/2,
          set_namespace/2,
-         set_payable/2,
          enter_namespace/2,
          get_namespace/1,
-         in_main_contract/1,
          qualify/2,
          set_functions/2,
          map_typerep/2,
@@ -50,7 +48,6 @@
                   , type_vars => #{ string() => aeb_aevm_data:type() }
                   , constructors => #{ [string()] => integer() }  %% name to tag
                   , options => [any()]
-                  , payable => boolean()
                   }.
 
 pp(Icode) ->
@@ -68,38 +65,30 @@ new(Options) ->
      , types => builtin_types()
      , type_vars => #{}
      , constructors => builtin_constructors()
-     , options => Options
-     , payable => false }.
+     , options => Options}.
 
 builtin_types() ->
     Word = fun([]) -> word end,
-    #{ "bool"              => Word
-     , "int"               => Word
-     , "char"              => Word
-     , "bits"              => Word
-     , "string"            => fun([]) -> string end
-     , "address"           => Word
-     , "hash"              => Word
-     , "unit"              => fun([]) -> {tuple, []} end
-     , "signature"         => fun([]) -> {tuple, [word, word]} end
-     , "oracle"            => fun([_, _]) -> word end
-     , "oracle_query"      => fun([_, _]) -> word end
-     , "list"              => fun([A]) -> {list, A} end
-     , "option"            => fun([A]) -> {variant, [[], [A]]} end
-     , "map"               => fun([K, V]) -> map_typerep(K, V) end
-     , ["Chain", "ttl"]    => fun([]) -> {variant, [[word], [word]]} end
-     , ["AENS", "pointee"] => fun([]) -> {variant, [[word], [word], [word]]} end
+    #{ "bool"         => Word
+     , "int"          => Word
+     , "bits"         => Word
+     , "string"       => fun([]) -> string end
+     , "address"      => Word
+     , "hash"         => Word
+     , "signature"    => fun([]) -> {tuple, [word, word]} end
+     , "oracle"       => fun([_, _]) -> word end
+     , "oracle_query" => fun([_, _]) -> word end
+     , "list"         => fun([A]) -> {list, A} end
+     , "option"       => fun([A]) -> {variant, [[], [A]]} end
+     , "map"          => fun([K, V]) -> map_typerep(K, V) end
+     , ["Chain", "ttl"] => fun([]) -> {variant, [[word], [word]]} end
      }.
 
 builtin_constructors() ->
-    #{ ["RelativeTTL"]     => 0
-     , ["FixedTTL"]        => 1
-     , ["None"]            => 0
-     , ["Some"]            => 1
-     , ["AccountPointee"]  => 0
-     , ["OraclePointee"]   => 1
-     , ["ContractPointee"] => 2
-     }.
+    #{ ["RelativeTTL"] => 0
+     , ["FixedTTL"]    => 1
+     , ["None"]        => 0
+     , ["Some"]        => 1 }.
 
 map_typerep(K, V) ->
     {map, K, V}.
@@ -114,10 +103,6 @@ new_env() ->
 set_name(Name, Icode) ->
     maps:put(contract_name, Name, Icode).
 
--spec set_payable(boolean(), icode()) -> icode().
-set_payable(Payable, Icode) ->
-    maps:put(payable, Payable, Icode).
-
 -spec set_namespace(aeso_syntax:con() | aeso_syntax:qcon(), icode()) -> icode().
 set_namespace(NS, Icode) -> Icode#{ namespace => NS }.
 
@@ -127,10 +112,6 @@ enter_namespace(NS, Icode = #{ namespace := NS1 }) ->
 enter_namespace(NS, Icode) ->
     Icode#{ namespace => NS }.
 
--spec in_main_contract(icode()) -> boolean().
-in_main_contract(#{ namespace := {con, _, Main}, contract_name := Main }) -> true;
-in_main_contract(_Icode) -> false.
-
 -spec get_namespace(icode()) -> false | aeso_syntax:con() | aeso_syntax:qcon().
 get_namespace(Icode) -> maps:get(namespace, Icode, false).
 
@@ -151,3 +132,4 @@ get_constructor_tag(Name, #{constructors := Constructors}) ->
         undefined -> error({undefined_constructor, Name});
         Tag       -> Tag
     end.
+

src/aeso_icode_to_asm.erl

@@ -27,7 +27,7 @@ convert(#{ contract_name := _ContractName
               },
         _Options) ->
     %% Create a function dispatcher
-    DispatchFun = {"%main", [], [{"arg", "_"}],
+    DispatchFun = {"_main", [], [{"arg", "_"}],
                    {switch, {var_ref, "arg"},
                     [{{tuple, [fun_hash(Fun),
                                {tuple, make_args(Args)}]},
@@ -44,7 +44,7 @@ convert(#{ contract_name := _ContractName
     %% taken from the stack
     StopLabel = make_ref(),
     StatefulStopLabel = make_ref(),
-    MainFunction = lookup_fun(Funs, "%main"),
+    MainFunction = lookup_fun(Funs, "_main"),
 
     StateTypeValue = aeso_ast_to_icode:type_value(StateType),
 
@@ -105,7 +105,7 @@ make_args(Args) ->
 
 fun_hash({FName, _, Args, _, TypeRep}) ->
     ArgType = {tuple, [T || {_, T} <- Args]},
-    <<Hash:256>> = aeb_aevm_abi:function_type_hash(list_to_binary(lists:last(FName)), ArgType, TypeRep),
+    <<Hash:256>> = aeb_abi:function_type_hash(list_to_binary(lists:last(FName)), ArgType, TypeRep),
     {integer, Hash}.
 
 %% Expects two return addresses below N elements on the stack. Picks the top
@@ -343,8 +343,6 @@ assemble_expr(Funs, Stack, _Tail, #prim_put{ state = State }) ->
 %% Environment primitives
 assemble_expr(_Funs, _Stack, _Tail, prim_contract_address) ->
     [i(?ADDRESS)];
-assemble_expr(_Funs, _Stack, _Tail, prim_contract_creator) ->
-    [i(?CREATOR)];
 assemble_expr(_Funs, _Stack, _Tail, prim_call_origin) ->
     [i(?ORIGIN)];
 assemble_expr(_Funs, _Stack, _Tail, prim_caller) ->

src/aeso_icode_to_fate.erl

@@ -0,0 +1,299 @@
+%%%-------------------------------------------------------------------
+%%% @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_parse_lib.erl

@@ -9,14 +9,12 @@
 -module(aeso_parse_lib).
 
 -export([parse/2,
-         return/1, fail/0, fail/1, fail/2, map/2, bind/2,
+         return/1, fail/0, fail/1, map/2, bind/2,
          lazy/1, choice/1, choice/2, tok/1, layout/0,
          left/2, right/2, between/3, optional/1,
          many/1, many1/1, sep/2, sep1/2,
          infixl/2, infixr/2]).
 
--export([current_file/0, set_current_file/1]).
-
 %% -- Types ------------------------------------------------------------------
 
 -export_type([parser/1, parser_expr/1, pos/0, token/0, tokens/0]).
@@ -74,31 +72,25 @@
                     %%   first argument. I.e. no backtracking to the second argument if the first
                     %%   fails.
 
-trampoline({bounce, Cont}) when is_function(Cont, 0) ->
-    trampoline(Cont());
-trampoline(Res) ->
-    Res.
--define(BOUNCE(X), {bounce, fun() -> X end}).
-
 %% Apply a parser to its continuation. This compiles a parser to its low-level representation.
 -spec apply_p(parser(A), fun((A) -> parser1(B))) -> parser1(B).
 apply_p(?lazy(F), K)           -> apply_p(F(), K);
 apply_p(?fail(Err), _)         -> {fail, Err};
-apply_p(?choice([P | Ps]), K)  -> lists:foldl(fun(Q, R) -> choice1(trampoline(apply_p(Q, K)), R) end,
-                                              trampoline(apply_p(P, K)), Ps);
+apply_p(?choice([P | Ps]), K)  -> lists:foldl(fun(Q, R) -> choice1(apply_p(Q, K), R) end,
+                                             apply_p(P, K), Ps);
 apply_p(?bind(P, F), K)        -> apply_p(P, fun(X) -> apply_p(F(X), K) end);
 apply_p(?right(P, Q), K)       -> apply_p(P, fun(_) -> apply_p(Q, K) end);
 apply_p(?left(P, Q), K)        -> apply_p(P, fun(X) -> apply_p(Q, fun(_) -> K(X) end) end);
 apply_p(?map(F, P), K)         -> apply_p(P, fun(X) -> K(F(X)) end);
 apply_p(?layout, K)            -> {layout, K, {fail, {expected, layout_block}}};
 apply_p(?tok(Atom), K)         -> {tok_bind, #{Atom => K}};
-apply_p(?return(X), K)         -> ?BOUNCE(K(X));
+apply_p(?return(X), K)         -> K(X);
 apply_p([P | Q], K)            -> apply_p(P, fun(H) -> apply_p(Q, fun(T) -> K([H | T]) end) end);
 apply_p(T, K) when is_tuple(T) -> apply_p(tuple_to_list(T), fun(Xs) -> K(list_to_tuple(Xs)) end);
 apply_p(M, K) when is_map(M) ->
     {Keys, Ps} = lists:unzip(maps:to_list(M)),
     apply_p(Ps, fun(Vals) -> K(maps:from_list(lists:zip(Keys, Vals))) end);
-apply_p(X, K) -> ?BOUNCE(K(X)).
+apply_p(X, K) -> K(X).
 
 %% -- Primitive combinators --------------------------------------------------
 
@@ -106,10 +98,6 @@ apply_p(X, K) -> ?BOUNCE(K(X)).
 -spec lazy(fun(() -> parser(A))) -> parser(A).
 lazy(Delayed) -> ?lazy(Delayed).
 
-%% @doc A parser that always fails at a known location.
--spec fail(pos(), term()) -> parser(none()).
-fail(Pos, Err) -> ?fail({Pos, Err}).
-
 %% @doc A parser that always fails.
 -spec fail(term()) -> parser(none()).
 fail(Err) -> ?fail(Err).
@@ -166,8 +154,8 @@ layout() -> ?layout.
 %% @doc Parse a sequence of tokens using a parser. Fails if the parse is ambiguous.
 -spec parse(parser(A), tokens()) -> {ok, A} | {error, term()}.
 parse(P, S) ->
-  case parse1(trampoline(apply_p(P, fun(X) -> {return_plus, X, {fail, no_error}} end)), S) of
-    {[], {Pos, Err}} -> {error, {add_current_file(Pos), parse_error, flatten_error(Err)}};
+  case parse1(apply_p(P, fun(X) -> {return_plus, X, {fail, no_error}} end), S) of
+    {[], {Pos, Err}} -> {error, {Pos, parse_error, flatten_error(Err)}};
     {[A], _}         -> {ok, A};
     {As, _}          -> {error, {{1, 1}, ambiguous_parse, As}}
   end.
@@ -247,7 +235,7 @@ col(T)  when is_tuple(T) -> element(2, pos(T)).
 
 %% If both parsers want the next token we grab it and merge the continuations.
 choice1({tok_bind, Map1}, {tok_bind, Map2}) ->
-    {tok_bind, merge_with(fun(F, G) -> fun(T) -> choice1(trampoline(F(T)), trampoline(G(T))) end end, Map1, Map2)};
+    {tok_bind, merge_with(fun(F, G) -> fun(T) -> choice1(F(T), G(T)) end end, Map1, Map2)};
 
 %% If both parsers fail we combine the error messages. If only one fails we discard it.
 choice1({fail, E1}, {fail, E2})             -> {fail, add_error(E1, E2)};
@@ -261,7 +249,7 @@ choice1(P, {return_plus, X, Q})             -> {return_plus, X, choice1(P, Q)};
 %% If both sides want a layout block we combine them. If only one side wants a layout block we
 %% will commit to a layout block is there is one.
 choice1({layout, F, P}, {layout, G, Q})     ->
-    {layout, fun(N) -> choice1(trampoline(F(N)), trampoline(G(N))) end, choice1(P, Q)};
+    {layout, fun(N) -> choice1(F(N), G(N)) end, choice1(P, Q)};
 choice1({layout, F, P}, Q)                  -> {layout, F, choice1(P, Q)};
 choice1(P, {layout, G, Q})                  -> {layout, G, choice1(P, Q)}.
 
@@ -284,8 +272,6 @@ parse1(P, S) ->
 %% The main work horse. Returns a list of possible parses and an error message in case parsing
 %% fails.
 -spec parse1(parser1(A), #ts{}, [A], term()) -> {[A], error()}.
-parse1({bounce, F}, Ts, Acc, Err) ->
-    parse1(F(), Ts, Acc, Err);
 parse1({tok_bind, Map}, Ts, Acc, Err) ->
     case next_token(Ts) of
         {T, Ts1} ->
@@ -299,7 +285,7 @@ parse1({tok_bind, Map}, Ts, Acc, Err) ->
                     %%            y + y)(4)
                     case maps:get(vclose, Map, '$not_found') of
                         '$not_found' ->
-                            {Acc, unexpected_token_error(Ts, maps:keys(Map), T)};
+                            {Acc, unexpected_token_error(Ts, T)};
                         F ->
                             VClose = {vclose, pos(T)},
                             Ts2    = pop_layout(VClose, Ts#ts{ last = VClose }),
@@ -336,52 +322,12 @@ current_pos(#ts{ tokens   = [T | _] }) -> pos(T);
 current_pos(#ts{ last     = T })       -> end_pos(pos(T)).
 
 -spec mk_error(#ts{}, term()) -> error().
-mk_error(_Ts, {Pos, Err}) ->
-    {Pos, Err};
 mk_error(Ts, Err) ->
     {current_pos(Ts), Err}.
 
 -spec unexpected_token_error(#ts{}, token()) -> error().
 unexpected_token_error(Ts, T) ->
-    unexpected_token_error(Ts, [], T).
-
-unexpected_token_error(Ts, Expect, {Tag, _}) when Tag == vclose; Tag == vsemi ->
-    Braces = [')', ']', '}'],
-    Fix    = case lists:filter(fun(T) -> lists:member(T, Braces) end, Expect) of
-                 []      -> " Probable causes:\n"
-                            "  - something is missing in the previous statement, or\n"
-                            "  - this line should be indented more.";
-                 [T | _] -> io_lib:format(" Did you forget a ~p?", [T])
-             end,
-    Msg = io_lib:format("Unexpected indentation.~s", [Fix]),
-    mk_error(Ts, Msg);
-unexpected_token_error(Ts, Expect, T) ->
-    ExpectCon = lists:member(con, Expect),
-    ExpectId  = lists:member(id,  Expect),
-    Fix = case T of
-              {id, _,  X}   when ExpectCon, hd(X) /= $_ -> io_lib:format(" Did you mean ~s?", [mk_upper(X)]);
-              {con, _, X}   when ExpectId               -> io_lib:format(" Did you mean ~s?", [mk_lower(X)]);
-              {qcon, _, Xs} when ExpectCon              -> io_lib:format(" Did you mean ~s?", [lists:last(Xs)]);
-              {qid, _,  Xs} when ExpectId               -> io_lib:format(" Did you mean ~s?", [lists:last(Xs)]);
-              _ -> ""
-          end,
-    mk_error(Ts, io_lib:format("Unexpected ~s.~s", [describe(T), Fix])).
-
-mk_upper([C | Rest]) -> string:to_upper([C]) ++ Rest.
-mk_lower([C | Rest]) -> string:to_lower([C]) ++ Rest.
-
-
-describe({id, _, X})     -> io_lib:format("identifier ~s", [X]);
-describe({con, _, X})    -> io_lib:format("identifier ~s", [X]);
-describe({qid, _, Xs})   -> io_lib:format("qualified identifier ~s", [string:join(Xs, ".")]);
-describe({qcon, _, Xs})  -> io_lib:format("qualified identifier ~s", [string:join(Xs, ".")]);
-describe({tvar, _, X})   -> io_lib:format("type variable ~s", [X]);
-describe({char, _, _})   -> "character literal";
-describe({string, _, _}) -> "string literal";
-describe({hex, _, _})    -> "integer literal";
-describe({int, _, _})    -> "integer literal";
-describe({bytes, _, _})  -> "bytes literal";
-describe(T)              -> io_lib:format("token '~s'", [tag(T)]).
+    mk_error(Ts, io_lib:format("Unexpected token ~p", [tag(T)])).
 
 %% Get the next token from a token stream. Inserts layout tokens if necessary.
 -spec next_token(#ts{}) -> false | {token(), #ts{}}.
@@ -465,13 +411,3 @@ merge_with(Fun, Map1, Map2) ->
                         end, Map2, maps:to_list(Map1))
     end.
 
-%% Current source file
-current_file() ->
-    get('$current_file').
-
-set_current_file(File) ->
-    put('$current_file', File).
-
-add_current_file({L, C}) -> {current_file(), L, C};
-add_current_file(Pos)    -> Pos.
-

src/aeso_parse_lib.hrl

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

src/aeso_parser.erl

@@ -3,88 +3,40 @@
 %%% Description :
 %%% Created     : 1 Mar 2018 by Ulf Norell
 -module(aeso_parser).
--compile({no_auto_import,[map_get/2]}).
 
 -export([string/1,
          string/2,
-         string/3,
-         auto_imports/1,
-         hash_include/2,
-         decl/0,
-         type/0,
-         body/0,
-         maybe_block/1,
-         run_parser/2,
-         run_parser/3]).
+         type/1]).
 
 -include("aeso_parse_lib.hrl").
--import(aeso_parse_lib, [current_file/0, set_current_file/1]).
 
--type parse_result() :: aeso_syntax:ast() | {aeso_syntax:ast(), sets:set(include_hash())} | none().
-
--type include_hash() :: {string(), binary()}.
-
-
-escape_errors({ok, Ok}) ->
-    Ok;
-escape_errors({error, Err}) ->
-    parse_error(Err).
+-type parse_result() :: {ok, aeso_syntax:ast()}
+                      | {error, {aeso_parse_lib:pos(), atom(), term()}}
+                      | {error, {aeso_parse_lib:pos(), atom()}}.
 
 -spec string(string()) -> parse_result().
 string(String) ->
-    string(String, sets:new(), []).
+    string(String, []).
 
 -spec string(string(), aeso_compiler:options()) -> parse_result().
 string(String, Opts) ->
-    case lists:keyfind(src_file, 1, Opts) of
-        {src_file, File} -> string(String, sets:add_element(File, sets:new()), Opts);
-        false -> string(String, sets:new(), Opts)
+    case parse_and_scan(file(), String, Opts) of
+        {ok, AST} ->
+            expand_includes(AST, Opts);
+        Err = {error, _} ->
+            Err
     end.
 
--spec string(string(), sets:set(include_hash()), aeso_compiler:options()) -> parse_result().
-string(String, Included, Opts) ->
-    AST = run_parser(file(), String, Opts),
-    case expand_includes(AST, Included, Opts) of
-        {ok, AST1}   -> AST1;
-        {error, Err} -> parse_error(Err)
-    end.
-
-
-run_parser(P, Inp) ->
-    escape_errors(parse_and_scan(P, Inp, [])).
-run_parser(P, Inp, Opts) ->
-    escape_errors(parse_and_scan(P, Inp, Opts)).
+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, {{Input, Pos}, _}} ->
-            {error, {Pos, scan_error, Input}}
+        Error        -> Error
     end.
 
--dialyzer({nowarn_function, parse_error/1}).
-parse_error(Err) ->
-    aeso_errors:throw(mk_error(Err)).
-
-mk_p_err(Pos, Msg) ->
-    aeso_errors:new(parse_error, mk_pos(Pos), lists:flatten(Msg)).
-
-mk_error({Pos, scan_error, Input}) ->
-    mk_p_err(Pos, io_lib:format("Lexical error on input: ~s\n", [Input]));
-mk_error({Pos, parse_error, Err}) ->
-    Msg = io_lib:format("~s\n", [Err]),
-    mk_p_err(Pos, Msg);
-mk_error({Pos, ambiguous_parse, As}) ->
-    Msg = io_lib:format("Ambiguous parse result: ~p\n", [As]),
-    mk_p_err(Pos, Msg);
-mk_error({Pos, include_error, File}) ->
-    Msg = io_lib:format("Couldn't find include file '~s'\n", [File]),
-    mk_p_err(Pos, Msg).
-
-mk_pos({Line, Col})       -> aeso_errors:pos(Line, Col);
-mk_pos({File, Line, Col}) -> aeso_errors:pos(File, Line, Col).
-
 %% -- Parsing rules ----------------------------------------------------------
 
 file() -> choice([], block(decl())).
@@ -93,23 +45,9 @@ decl() ->
     ?LAZY_P(
     choice(
       %% Contract declaration
-    [ ?RULE(token(main), keyword(contract),
-            con(), tok('='), maybe_block(decl()), {contract_main, _2, _3, _5})
-    , ?RULE(keyword(contract),
-            con(), tok('='), maybe_block(decl()), {contract_child, _1, _2, _4})
-    , ?RULE(keyword(contract), token(interface),
-            con(), tok('='), maybe_block(decl()), {contract_interface, _1, _3, _5})
-    , ?RULE(token(payable), token(main), keyword(contract),
-            con(), tok('='), maybe_block(decl()), add_modifiers([_1], {contract_main, _3, _4, _6}))
-    , ?RULE(token(payable), keyword(contract),
-            con(), tok('='), maybe_block(decl()), add_modifiers([_1], {contract_child, _2, _3, _5}))
-    , ?RULE(token(payable), keyword(contract), token(interface),
-            con(), tok('='), maybe_block(decl()), add_modifiers([_1], {contract_interface, _2, _4, _6}))
-
-
+    [ ?RULE(keyword(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, get_ann(_1), _2})
-    , pragma()
+    , ?RULE(keyword(include),   str(), {include, _2})
 
       %% Type declarations  TODO: format annotation for "type bla" vs "type bla()"
     , ?RULE(keyword(type),     id(),                                          {type_decl, _1, _2, []})
@@ -122,40 +60,13 @@ decl() ->
     , ?RULE(keyword(datatype), id(), type_vars(), tok('='), typedef(variant), {type_def, _1, _2, _3, _5})
 
       %% Function declarations
-    , ?RULE(modifiers(), fun_or_entry(), maybe_block(fundef_or_decl()), fun_block(_1, _2, _3))
-    , ?RULE(keyword('let'), valdef(), set_pos(get_pos(_1), _2))
+    , ?RULE(modifiers(), keyword(function), id(), tok(':'), type(), add_modifiers(_1, {fun_decl, _2, _3, _5}))
+    , ?RULE(modifiers(), keyword(function), fundef(),               add_modifiers(_1, set_pos(get_pos(_2), _3)))
+    , ?RULE(keyword('let'),    valdef(),                            set_pos(get_pos(_1), _2))
     ])).
 
-fun_block(Mods, Kind, [Decl]) ->
-    add_modifiers(Mods, Kind, set_pos(get_pos(Kind), Decl));
-fun_block(Mods, Kind, Decls) ->
-    {block, get_ann(Kind), [ add_modifiers(Mods, Kind, Decl) || Decl <- Decls ]}.
-
-fundef_or_decl() ->
-    choice([?RULE(id(), tok(':'), type(), {fun_decl, get_ann(_1), _1, _3}),
-            fundef()]).
-
-pragma() ->
-    Op = choice([token(T) || T <- ['<', '=<', '==', '>=', '>']]),
-    ?RULE(tok('@'), id("compiler"), Op, version(), {pragma, get_ann(_1), {compiler, element(1, _3), _4}}).
-
-version() ->
-    ?RULE(token(int), many({tok('.'), token(int)}), mk_version(_1, _2)).
-
-mk_version({int, _, Maj}, Rest) ->
-    [Maj | [N || {_, {int, _, N}} <- Rest]].
-
-fun_or_entry() ->
-    choice([?RULE(keyword(function),   {function,   _1}),
-            ?RULE(keyword(entrypoint), {entrypoint, _1})]).
-
 modifiers() ->
-    many(choice([token(stateful), token(payable), token(private), token(public)])).
-
-add_modifiers(Mods, Entry = {entrypoint, _}, Node) ->
-    add_modifiers(Mods ++ [Entry], Node);
-add_modifiers(Mods, {function, _}, Node) ->
-    add_modifiers(Mods, Node).
+    many(choice([token(stateful), token(public), token(private), token(internal)])).
 
 add_modifiers([], Node) -> Node;
 add_modifiers(Mods = [Tok | _], Node) ->
@@ -176,7 +87,7 @@ constructors() ->
     sep1(constructor(), tok('|')).
 
 constructor() ->    %% TODO: format for Con() vs Con
-    choice(?RULE(con(),             {constr_t, get_ann(_1), _1, []}),
+    choice(?RULE(con(),              {constr_t, get_ann(_1), _1, []}),
            ?RULE(con(), con_args(), {constr_t, get_ann(_1), _1, _2})).
 
 con_args()   -> paren_list(con_arg()).
@@ -188,24 +99,27 @@ con_arg()    -> choice(type(), ?RULE(keyword(indexed), type(), set_ann(indexed,
 %% -- Let declarations -------------------------------------------------------
 
 letdecl() ->
-    ?RULE(keyword('let'), letdef(), set_pos(get_pos(_1), _2)).
+    choice(
+        ?RULE(keyword('let'), letdef(),                             set_pos(get_pos(_1), _2)),
+        ?RULE(keyword('let'), tok(rec), sep1(letdef(), tok('and')), {letrec, _1, _3})).
 
 letdef() -> choice(valdef(), fundef()).
 
 valdef() ->
-    ?RULE(pattern(), tok('='), body(), {letval, [], _1, _3}).
+    choice(
+        ?RULE(id(),                   tok('='), body(), {letval, [], _1, type_wildcard(), _3}),
+        ?RULE(id(), tok(':'), type(), tok('='), body(), {letval, [], _1, _3, _5})).
 
 fundef() ->
     choice(
-    [ ?RULE(id(), args(),                   tok('='), body(), {letfun, get_ann(_1), _1, _2, type_wildcard(get_ann(_1)), _4})
-    , ?RULE(id(), args(), tok(':'), type(), tok('='), body(), {letfun, get_ann(_1), _1, _2, _4, _6})
+    [ ?RULE(id(), args(),                   tok('='), body(), {letfun, [], _1, _2, type_wildcard(), _4})
+    , ?RULE(id(), args(), tok(':'), type(), tok('='), body(), {letfun, [], _1, _2, _4, _6})
     ]).
 
-args() -> paren_list(pattern()).
-lam_args() -> paren_list(arg()).
+args() -> paren_list(arg()).
 
 arg() -> choice(
-    ?RULE(id(),                   {arg, get_ann(_1), _1, type_wildcard(get_ann(_1))}),
+    ?RULE(id(),                   {arg, get_ann(_1), _1, type_wildcard()}),
     ?RULE(id(), tok(':'), type(), {arg, get_ann(_1), _1, _3})).
 
 %% -- Types ------------------------------------------------------------------
@@ -217,10 +131,9 @@ type() -> ?LAZY_P(type100()).
 type100() -> type200().
 
 type200() ->
-    ?RULE(many({type300(), keyword('=>')}), type300(), fun_t(_1, _2)).
+    ?RULE(many({fun_domain(), keyword('=>')}), type300(), fun_t(_1, _2)).
 
-type300() ->
-    ?RULE(sep1(type400(), tok('*')), tuple_t(get_ann(lists:nth(1, _1)), _1)).
+type300() -> type400().
 
 type400() ->
     choice(
@@ -235,17 +148,11 @@ type400() ->
 
 typeAtom() ->
     ?LAZY_P(choice(
-    [ parens(type())
-    , args_t()
-    , id(), token(con), token(qcon), token(qid), tvar()
+    [ id(), token(con), token(qcon), token(qid), tvar()
+    , ?RULE(keyword('('), comma_sep(type()), tok(')'), tuple_t(_1, _2))
     ])).
 
-args_t() ->
-    ?LAZY_P(choice(
-    [ ?RULE(tok('('), tok(')'), {args_t, get_ann(_1), []})
-      %% Singleton case handled separately
-    , ?RULE(tok('('), type(), tok(','), sep1(type(), tok(',')), tok(')'), {args_t, get_ann(_1), [_2|_4]})
-    ])).
+fun_domain() -> ?RULE(?LAZY_P(type300()), fun_domain(_1)).
 
 %% -- Statements -------------------------------------------------------------
 
@@ -266,7 +173,7 @@ branch() ->
     ?RULE(pattern(), keyword('=>'), body(), {'case', _2, _1, _3}).
 
 pattern() ->
-    ?LET_P(E, expr(), parse_pattern(E)).
+    ?LET_P(E, expr500(), parse_pattern(E)).
 
 %% -- Expressions ------------------------------------------------------------
 
@@ -276,7 +183,7 @@ expr100() ->
     Expr100 = ?LAZY_P(expr100()),
     Expr200 = ?LAZY_P(expr200()),
     choice(
-    [ ?RULE(lam_args(), keyword('=>'), body(), {lam, _2, _1, _3})   %% TODO: better location
+    [ ?RULE(args(), keyword('=>'), body(), {lam, _2, _1, _3})   %% TODO: better location
     , {'if', keyword('if'), parens(Expr100), Expr200, right(tok(else), Expr100)}
     , ?RULE(Expr200, optional(right(tok(':'), type())),
             case _2 of
@@ -306,27 +213,13 @@ exprAtom() ->
         , ?RULE(token(hex), set_ann(format, hex, setelement(1, _1, int)))
         , {bool, keyword(true), true}
         , {bool, keyword(false), false}
-        , ?LET_P(Fs, brace_list(?LAZY_P(field_assignment())), record(Fs))
+        , ?RULE(brace_list(?LAZY_P(field_assignment())), record(_1))
         , {list, [], bracket_list(Expr)}
-        , ?RULE(keyword('['), Expr, token('|'), comma_sep(comprehension_exp()), tok(']'), list_comp_e(_1, _2, _4))
         , ?RULE(tok('['), Expr, binop('..'), Expr, tok(']'), _3(_2, _4))
         , ?RULE(keyword('('), comma_sep(Expr), tok(')'), tuple_e(_1, _2))
         ])
     end).
 
-comprehension_exp() ->
-    ?LAZY_P(choice(
-      [ comprehension_bind()
-      , letdecl()
-      , comprehension_if()
-      ])).
-
-comprehension_if() ->
-    ?RULE(keyword('if'), parens(expr()), {comprehension_if, _1, _2}).
-
-comprehension_bind() ->
-    ?RULE(pattern(), tok('<-'), expr(), {comprehension_bind, _1, _3}).
-
 arg_expr() ->
     ?LAZY_P(
         choice([ ?RULE(id(), tok('='), expr(), {named_arg, [], _1, _3})
@@ -352,7 +245,7 @@ map_key(Key, {ok, {_, Val}}) -> {map_key, Key, Val}.
 
 elim(E, [])                              -> E;
 elim(E, [{proj, Ann, P} | Es])           -> elim({proj, Ann, E, P}, Es);
-elim(E, [{app, _Ann, Args} | Es])        -> elim({app, aeso_syntax:get_ann(E), E, Args}, Es);
+elim(E, [{app, Ann, Args} | Es])         -> elim({app, Ann, E, Args}, Es);
 elim(E, [{rec_upd, Ann, Flds} | Es])     -> elim(record_update(Ann, E, Flds), Es);
 elim(E, [{map_get, Ann, Key} | Es])      -> elim({map_get, Ann, E, Key}, Es);
 elim(E, [{map_get, Ann, Key, Val} | Es]) -> elim({map_get, Ann, E, Key, Val}, Es).
@@ -363,23 +256,15 @@ record_update(Ann, E, Flds) ->
 record([]) -> {map, [], []};
 record(Fs) ->
     case record_or_map(Fs) of
-        record ->
-            Fld = fun({field, _, [_], _} = F) -> F;
-                     ({field, Ann, LV, Id, _}) ->
-                         bad_expr_err("Cannot use '@' in record construction", infix({lvalue, Ann, LV}, {'@', Ann}, Id));
-                     ({field, Ann, LV, _}) ->
-                         bad_expr_err("Cannot use nested fields or keys in record construction", {lvalue, Ann, LV}) end,
-            {record, get_ann(hd(Fs)), lists:map(Fld, Fs)};
+        record -> {record, get_ann(hd(Fs)), Fs};
         map    ->
             Ann = get_ann(hd(Fs ++ [{empty, []}])), %% TODO: source location for empty maps
             KV = fun({field, _, [{map_get, _, Key}], Val}) -> {Key, Val};
-                    ({field, FAnn, LV, Id, _}) ->
-                        bad_expr_err("Cannot use '@' in map construction", infix({lvalue, FAnn, LV}, {'@', Ann}, Id));
-                    ({field, FAnn, LV, _}) ->
-                        bad_expr_err("Cannot use nested fields or keys in map construction", {lvalue, FAnn, LV}) end,
-            {map, Ann, lists:map(KV, Fs)};
-        record_or_map_error ->
-            {record_or_map_error, get_ann(hd(Fs)), Fs}
+                    ({field, _, LV, Id, _}) ->
+                        bad_expr_err("Cannot use '@' in map construction", infix(LV, {op, Ann, '@'}, Id));
+                    ({field, _, LV, _}) ->
+                        bad_expr_err("Cannot use nested fields or keys in map construction", LV) end,
+            {map, Ann, lists:map(KV, Fs)}
     end.
 
 record_or_map(Fields) ->
@@ -391,7 +276,9 @@ record_or_map(Fields) ->
     case lists:usort(lists:map(Kind, Fields)) of
         [proj]    -> record;
         [map_get] -> map;
-        _         -> record_or_map_error %% Defer error until type checking
+        _         ->
+            [{field, Ann, _, _} | _] = Fields,
+            bad_expr_err("Mixed record fields and map keys in", {record, Ann, Fields})
     end.
 
 field_assignment() ->
@@ -446,7 +333,7 @@ token(Tag) ->
 id(Id) ->
     ?LET_P({id, A, X} = Y, id(),
            if X == Id -> Y;
-              true    -> fail({A, "expected '" ++ Id ++ "'"})
+              true    -> fail({A, "expected 'bytes'"})
            end).
 
 id_or_addr() ->
@@ -492,6 +379,12 @@ bracket_list(P) -> brackets(comma_sep(P)).
 -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).
+
 ann_pos(Ann) ->
     {proplists:get_value(file, Ann),
      proplists:get_value(line, Ann),
@@ -522,8 +415,8 @@ infix(L, Op, R) -> set_ann(format, infix,  {app, get_ann(L), Op, [L, R]}).
 prefixes(Ops, E) -> lists:foldr(fun prefix/2, E, Ops).
 prefix(Op, E)    -> set_ann(format, prefix, {app, get_ann(Op), Op, [E]}).
 
-type_wildcard(Ann) ->
-    {id, [{origin, system} | Ann], "_"}.
+type_wildcard() ->
+    {id, [{origin, system}], "_"}.
 
 block_e(Stmts) ->
     group_ifs(Stmts, []).
@@ -548,7 +441,7 @@ build_if(Ann, Cond, Then, [{elif, Ann1, Cond1, Then1} | Elses]) ->
 build_if(Ann, Cond, Then, [{else, _Ann, Else}]) ->
     {'if', Ann, Cond, Then, Else};
 build_if(Ann, Cond, Then, []) ->
-    {'if', Ann, Cond, Then, {tuple, [{origin, system}], []}}.
+    {'if', Ann, Cond, Then, {unit, [{origin, system}]}}.
 
 else_branches([Elif = {elif, _, _, _} | Stmts], Acc) ->
     else_branches(Stmts, [Elif | Acc]);
@@ -561,21 +454,21 @@ tuple_t(_Ann, [Type]) -> Type;  %% Not a tuple
 tuple_t(Ann, Types)   -> {tuple_t, Ann, Types}.
 
 fun_t(Domains, Type) ->
-    lists:foldr(fun({{args_t, _, Dom}, Ann}, T) -> {fun_t, Ann, [], Dom, T};
-                    ({Dom, Ann}, T)             -> {fun_t, Ann, [], [Dom], T} end,
+    lists:foldr(fun({Dom, Ann}, T) -> {fun_t, Ann, [], Dom, T} end,
                 Type, Domains).
 
+tuple_e(Ann, [])      -> {unit, Ann};
 tuple_e(_Ann, [Expr]) -> Expr;  %% Not a tuple
 tuple_e(Ann, Exprs)   -> {tuple, Ann, Exprs}.
 
-list_comp_e(Ann, Expr, Binds) -> {list_comp, Ann, Expr, Binds}.
+%% TODO: not nice
+fun_domain({tuple_t, _, Args}) -> Args;
+fun_domain(T)                  -> [T].
 
 -spec parse_pattern(aeso_syntax:expr()) -> aeso_parse_lib:parser(aeso_syntax:pat()).
 parse_pattern({app, Ann, Con = {'::', _}, Es}) ->
     {app, Ann, Con, lists:map(fun parse_pattern/1, Es)};
-parse_pattern({app, Ann, {'-', _}, [{int, _, N}]}) ->
-    {int, Ann, -N};
-parse_pattern({app, Ann, Con = {Tag, _, _}, Es}) when Tag == con; Tag == qcon ->
+parse_pattern({app, Ann, Con = {con, _, _}, Es}) ->
     {app, Ann, Con, lists:map(fun parse_pattern/1, Es)};
 parse_pattern({tuple, Ann, Es}) ->
     {tuple, Ann, lists:map(fun parse_pattern/1, Es)};
@@ -583,11 +476,9 @@ parse_pattern({list, Ann, Es}) ->
     {list, Ann, lists:map(fun parse_pattern/1, Es)};
 parse_pattern({record, Ann, Fs}) ->
     {record, Ann, lists:map(fun parse_field_pattern/1, Fs)};
-parse_pattern({typed, Ann, E, Type}) ->
-    {typed, Ann, parse_pattern(E), Type};
 parse_pattern(E = {con, _, _})    -> E;
-parse_pattern(E = {qcon, _, _})   -> E;
 parse_pattern(E = {id, _, _})     -> E;
+parse_pattern(E = {unit, _})      -> E;
 parse_pattern(E = {int, _, _})    -> E;
 parse_pattern(E = {bool, _, _})   -> E;
 parse_pattern(E = {bytes, _, _})  -> E;
@@ -599,53 +490,42 @@ parse_pattern(E) -> bad_expr_err("Not a valid pattern", E).
 parse_field_pattern({field, Ann, F, E}) ->
     {field, Ann, F, parse_pattern(E)}.
 
--spec ret_doc_err(ann(), prettypr:document()) -> aeso_parse_lib:parser(none()).
-ret_doc_err(Ann, Doc) ->
-    fail(ann_pos(Ann), prettypr:format(Doc)).
+return_error({no_file, L, C}, Err) ->
+    fail(io_lib:format("~p:~p:\n~s", [L, C, Err]));
+return_error({F, L, C}, Err) ->
+    fail(io_lib:format("In ~s at ~p:~p:\n~s", [F, L, C, Err])).
 
--spec bad_expr_err(string(), aeso_syntax:expr()) -> aeso_parse_lib:parser(none()).
+-spec ret_doc_err(ann(), prettypr:document()) -> no_return().
+ret_doc_err(Ann, Doc) ->
+    return_error(ann_pos(Ann), prettypr:format(Doc)).
+
+-spec bad_expr_err(string(), aeso_syntax:expr()) -> no_return().
 bad_expr_err(Reason, E) ->
   ret_doc_err(get_ann(E),
               prettypr:sep([prettypr:text(Reason ++ ":"),
                             prettypr:nest(2, aeso_pretty:expr(E))])).
 
 %% -- Helper functions -------------------------------------------------------
+expand_includes(AST, Opts) ->
+    expand_includes(AST, [], Opts).
 
-expand_includes(AST, Included, Opts) ->
-    Ann  = [{origin, system}],
-    AST1 = [ {include, Ann, {string, Ann, File}}
-             || File <- lists:usort(auto_imports(AST)) ] ++ AST,
-    expand_includes(AST1, Included, [], Opts).
-
-expand_includes([], Included, Acc, Opts) ->
-    case lists:member(keep_included, Opts) of
-        false ->
-            {ok, lists:reverse(Acc)};
-        true ->
-            {ok, {lists:reverse(Acc), Included}}
-    end;
-expand_includes([{include, Ann, {string, _SAnn, File}} | AST], Included, Acc, Opts) ->
-    case get_include_code(File, Ann, Opts) of
-        {ok, Code} ->
-            Hashed = hash_include(File, Code),
-            case sets:is_element(Hashed, Included) of
-                false ->
-                    Opts1 = lists:keystore(src_file, 1, Opts, {src_file, File}),
-                    Included1 = sets:add_element(Hashed, Included),
-                    case parse_and_scan(file(), Code, Opts1) of
-                        {ok, AST1} ->
-                            expand_includes(AST1 ++ AST, Included1, Acc, Opts);
-                        Err = {error, _} ->
-                            Err
-                    end;
-                true ->
-                    expand_includes(AST, Included, Acc, Opts)
+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;
-        Err = {error, _} ->
-            Err
+        {error, _} ->
+            {error, {get_pos(S), include_error, File}}
     end;
-expand_includes([E | AST], Included, Acc, Opts) ->
-    expand_includes(AST, Included, [E | Acc], Opts).
+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
@@ -657,57 +537,6 @@ read_file(File, Opts) ->
             case maps:get(binary_to_list(File), Files, not_found) of
                 not_found -> {error, not_found};
                 Src       -> {ok, Src}
-            end;
-        escript ->
-            try
-                Escript        = escript:script_name(),
-                {ok, Sections} = escript:extract(Escript, []),
-                Archive        = proplists:get_value(archive, Sections),
-                FileName       = binary_to_list(filename:join([aesophia, priv, stdlib, File])),
-                case zip:extract(Archive, [{file_list, [FileName]}, memory]) of
-                    {ok, [{_, Src}]} -> {ok, Src};
-                    _                -> {error, not_found}
-                end
-            catch _:_ ->
-                {error, not_found}
             end
     end.
 
-stdlib_options() ->
-    StdLibDir = aeso_stdlib:stdlib_include_path(),
-    case filelib:is_dir(StdLibDir) of
-        true  -> [{include, {file_system, [StdLibDir]}}];
-        false -> [{include, escript}]
-    end.
-
-get_include_code(File, Ann, Opts) ->
-    case {read_file(File, Opts), read_file(File, stdlib_options())} of
-        {{ok, Bin}, {ok, _}} ->
-            case filename:basename(File) == File of
-                true -> { error
-                        , fail( ann_pos(Ann)
-                              , "Illegal redefinition of standard library " ++ binary_to_list(File))};
-                %% If a path is provided then the stdlib takes lower priority
-                false -> {ok, binary_to_list(Bin)}
-            end;
-        {_, {ok, Bin}} ->
-            {ok, binary_to_list(Bin)};
-        {{ok, Bin}, _} ->
-            {ok, binary_to_list(Bin)};
-        {_, _} ->
-            {error, {ann_pos(Ann), include_error, File}}
-    end.
-
--spec hash_include(string() | binary(), string()) -> include_hash().
-hash_include(File, Code) when is_binary(File) ->
-    hash_include(binary_to_list(File), Code);
-hash_include(File, Code) when is_list(File) ->
-    {filename:basename(File), crypto:hash(sha256, Code)}.
-
-auto_imports({comprehension_bind, _, _}) -> [<<"ListInternal.aes">>];
-auto_imports({'..', _})                  -> [<<"ListInternal.aes">>];
-auto_imports(L) when is_list(L) ->
-    lists:flatmap(fun auto_imports/1, L);
-auto_imports(T) when is_tuple(T) ->
-    auto_imports(tuple_to_list(T));
-auto_imports(_) -> [].

src/aeso_pretty.erl

@@ -13,8 +13,6 @@
 
 -export_type([options/0]).
 
--include("aeso_utils.hrl").
-
 -type doc() :: prettypr:document().
 -type options() :: [{indent, non_neg_integer()} | show_generated].
 
@@ -133,10 +131,6 @@ typed(A, Type) ->
         false -> follow(hsep(A, text(":")), type(Type))
     end.
 
-contract_head(contract_main)      -> text("main contract");
-contract_head(contract_child)     -> text("contract");
-contract_head(contract_interface) -> text("contract interface").
-
 %% -- Exports ----------------------------------------------------------------
 
 -spec decls([aeso_syntax:decl()], options()) -> doc().
@@ -151,46 +145,23 @@ decl(D, Options) ->
     with_options(Options, fun() -> decl(D) end).
 
 -spec decl(aeso_syntax:decl()) -> doc().
-decl({Con, Attrs, C, Ds}) when ?IS_CONTRACT_HEAD(Con) ->
-    Mod = fun({Mod, true}) when Mod == payable ->
-                  text(atom_to_list(Mod));
-             (_) -> empty() end,
-    block(follow( hsep(lists:map(Mod, Attrs) ++ [contract_head(Con)])
-                , hsep(name(C), text("="))), decls(Ds));
+decl({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({pragma, _, Pragma}) -> pragma(Pragma);
 decl({type_decl, _, T, Vars}) -> typedecl(alias_t, T, Vars);
 decl({type_def, _, T, Vars, Def}) ->
     Kind = element(1, Def),
     equals(typedecl(Kind, T, Vars), typedef(Def));
-decl({fun_decl, Ann, F, T}) ->
-    Mod = fun({Mod, true}) when Mod == private; Mod == stateful; Mod == payable ->
-                  text(atom_to_list(Mod));
-             (_) -> empty() end,
-    Fun = case aeso_syntax:get_ann(entrypoint, Ann, false) of
-            true  -> text("entrypoint");
-            false -> text("function")
-          end,
-    hsep(lists:map(Mod, Ann) ++ [Fun, typed(name(F), T)]);
+decl({fun_decl, _, F, T}) ->
+    hsep(text("function"), typed(name(F), T));
 decl(D = {letfun, Attrs, _, _, _, _}) ->
-    Mod = fun({Mod, true}) when Mod == private; Mod == stateful; Mod == payable ->
+    Mod = fun({Mod, true}) when Mod == private; Mod == internal; Mod == public; Mod == stateful ->
                             text(atom_to_list(Mod));
              (_) -> empty() end,
-    Fun = case aeso_syntax:get_ann(entrypoint, Attrs, false) of
-              true  -> "entrypoint";
-              false -> "function"
-          end,
-    hsep(lists:map(Mod, Attrs) ++ [letdecl(Fun, D)]);
-decl({fun_clauses, Ann, Name, Type, Clauses}) ->
-    above([ decl(D) || D <- [{fun_decl, Ann, Name, Type} | Clauses] ]);
-decl(D = {letval, _, _, _}) -> letdecl("let", D);
-decl({block, _, Ds}) ->
-    above([ decl(D) || D <- Ds ]).
-
--spec pragma(aeso_syntax:pragma()) -> doc().
-pragma({compiler, Op, Ver}) ->
-    text("@compiler " ++ atom_to_list(Op) ++ " " ++ string:join([integer_to_list(N) || N <- Ver], ".")).
+    hsep(lists:map(Mod, Attrs) ++ [letdecl("function", D)]);
+decl(D = {letval, _, _, _, _})    -> letdecl("let", D);
+decl(D = {letrec, _, _})          -> letdecl("let", D).
 
 -spec expr(aeso_syntax:expr(), options()) -> doc().
 expr(E, Options) ->
@@ -210,10 +181,12 @@ name({tvar, _, Name})  -> text(Name);
 name({typed, _, Name, _}) -> name(Name).
 
 -spec letdecl(string(), aeso_syntax:letbind()) -> doc().
-letdecl(Let, {letval, _, P, E}) ->
-    block_expr(0, hsep([text(Let), expr(P), text("=")]), E);
+letdecl(Let, {letval, _, F, T, E}) ->
+    block_expr(0, hsep([text(Let), typed(name(F), T), text("=")]), E);
 letdecl(Let, {letfun, _, F, Args, T, E}) ->
-    block_expr(0, hsep([text(Let), typed(beside(name(F), expr({tuple, [], Args})), T), text("=")]), E).
+    block_expr(0, hsep([text(Let), typed(beside(name(F), args(Args)), T), text("=")]), E);
+letdecl(Let, {letrec, _, [D | Ds]}) ->
+    hsep(text(Let), above([ letdecl("rec", D) | [ letdecl("and", D1) || D1 <- Ds ] ])).
 
 -spec args([aeso_syntax:arg()]) -> doc().
 args(Args) ->
@@ -244,7 +217,7 @@ typedef({variant_t, Constructors}) ->
 
 -spec constructor_t(aeso_syntax:constructor_t()) -> doc().
 constructor_t({constr_t, _, C, []}) -> name(C);
-constructor_t({constr_t, _, C, Args}) -> beside(name(C), args_type(Args)).
+constructor_t({constr_t, _, C, Args}) -> beside(name(C), tuple_type(Args)).
 
 -spec field_t(aeso_syntax:field_t()) -> doc().
 field_t({field_t, _, Name, Type}) ->
@@ -256,22 +229,15 @@ type(Type, Options) ->
 
 -spec type(aeso_syntax:type()) -> doc().
 type({fun_t, _, Named, Args, Ret}) ->
-    follow(hsep(args_type(Named ++ Args), text("=>")), type(Ret));
-type({type_sig, _, Named, Args, Ret}) ->
     follow(hsep(tuple_type(Named ++ Args), text("=>")), type(Ret));
 type({app_t, _, Type, []}) ->
     type(Type);
 type({app_t, _, Type, Args}) ->
-    beside(type(Type), args_type(Args));
+    beside(type(Type), tuple_type(Args));
 type({tuple_t, _, Args}) ->
     tuple_type(Args);
-type({args_t, _, Args}) ->
-    args_type(Args);
-type({bytes_t, _, any}) -> text("bytes(_)");
 type({bytes_t, _, Len}) ->
     text(lists:concat(["bytes(", Len, ")"]));
-type({if_t, _, Id, Then, Else}) ->
-    beside(text("if"), args_type([Id, Then, Else]));
 type({named_arg_t, _, Name, Type, _Default}) ->
     %% Drop the default value
     %% follow(hsep(typed(name(Name), Type), text("=")), expr(Default));
@@ -284,23 +250,16 @@ type(T = {con, _, _})  -> name(T);
 type(T = {qcon, _, _}) -> name(T);
 type(T = {tvar, _, _}) -> name(T).
 
--spec args_type([aeso_syntax:type()]) -> doc().
-args_type(Args) ->
+-spec tuple_type([aeso_syntax:type()]) -> doc().
+tuple_type(Args) ->
     tuple(lists:map(fun type/1, Args)).
 
--spec tuple_type([aeso_syntax:type()]) -> doc().
-tuple_type([]) ->
-    text("unit");
-tuple_type(Factors) ->
-    beside(
-      [ text("(")
-      , par(punctuate(text(" *"), lists:map(fun type/1, Factors)), 0)
-      , text(")")
-      ]).
+-spec arg_expr(aeso_syntax:arg_expr()) -> doc().
+arg_expr({named_arg, _, Name, E}) ->
+    follow(hsep(expr(Name), text("=")), expr(E));
+arg_expr(E) -> expr(E).
 
--spec expr_p(integer(), aeso_syntax:arg_expr()) -> doc().
-expr_p(P, {named_arg, _, Name, E}) ->
-    paren(P > 100, follow(hsep(expr(Name), text("=")), expr(E)));
+-spec expr_p(integer(), aeso_syntax:expr()) -> doc().
 expr_p(P, {lam, _, Args, E}) ->
     paren(P > 100, follow(hsep(args(Args), text("=>")), expr_p(100, E)));
 expr_p(P, If = {'if', Ann, Cond, Then, Else}) ->
@@ -321,8 +280,6 @@ expr_p(_, {tuple, _, Es}) ->
     tuple(lists:map(fun expr/1, Es));
 expr_p(_, {list, _, Es}) ->
     list(lists:map(fun expr/1, Es));
-expr_p(_, {list_comp, _, E, Binds}) ->
-    list([follow(expr(E), hsep(text("|"), par(punctuate(text(","), lists:map(fun lc_bind/1, Binds)), 0)), 0)]);
 expr_p(_, {record, _, Fs}) ->
     record(lists:map(fun field/1, Fs));
 expr_p(_, {map, Ann, KVs}) ->
@@ -375,20 +332,14 @@ expr_p(_, {Type, _, Bin})
          Type == oracle_pubkey;
          Type == oracle_query_id ->
     text(binary_to_list(aeser_api_encoder:encode(Type, Bin)));
-expr_p(_, {string, _, <<>>}) -> text("\"\"");
-expr_p(_, {string, _, S}) ->
-    text(io_lib:format("\"~s\"", [binary_to_list(S)]));
+expr_p(_, {unit, _}) -> text("()");
+expr_p(_, {string, _, S}) -> term(binary_to_list(S));
 expr_p(_, {char, _, C}) ->
     case C of
         $' -> text("'\\''");
         $" -> text("'\"'");
-        _ when C < 16#80 ->
-            S = lists:flatten(io_lib:format("~p", [[C]])),
-            text("'" ++ tl(lists:droplast(S)) ++ "'");
-        _  ->
-            S = lists:flatten(
-                  io_lib:format("'~ts'", [list_to_binary(aeso_scan:utf8_encode([C]))])),
-            text(S)
+        _  -> S = lists:flatten(io_lib:format("~p", [[C]])),
+              text("'" ++ tl(lists:droplast(S)) ++ "'")
     end;
 %% -- Names
 expr_p(_, E = {id, _, _})   -> name(E);
@@ -411,17 +362,9 @@ stmt_p({else, Else}) ->
         _ -> block_expr(200, text("else"), Else)
     end.
 
-lc_bind({comprehension_bind, P, E}) ->
-    follow(hsep(expr(P), text("<-")), expr(E));
-lc_bind({comprehension_if, _, E}) ->
-    beside([text("if("), expr(E), text(")")]);
-lc_bind(Let) ->
-    letdecl("let", Let).
-
 -spec bin_prec(aeso_syntax:bin_op()) -> {integer(), integer(), integer()}.
 bin_prec('..')   -> {  0,   0,   0};  %% Always printed inside '[ ]'
 bin_prec('=')    -> {  0,   0,   0};  %% Always printed inside '[ ]'
-bin_prec('@')    -> {  0,   0,   0};  %% Only in error messages
 bin_prec('||')   -> {200, 300, 200};
 bin_prec('&&')   -> {300, 400, 300};
 bin_prec('<')    -> {400, 500, 500};
@@ -460,7 +403,7 @@ prefix(P, Op, A) ->
 app(P, F, Args) ->
     paren(P > 900,
     beside(expr_p(900, F),
-           tuple(lists:map(fun expr/1, Args)))).
+           tuple(lists:map(fun arg_expr/1, Args)))).
 
 field({field, _, LV, E}) ->
     follow(hsep(lvalue(LV), text("=")), expr(E));
@@ -481,7 +424,7 @@ elim1(Get={map_get, _, _})    -> elim(Get);
 elim1(Get={map_get, _, _, _}) -> elim(Get).
 
 alt({'case', _, Pat, Body}) ->
-    block_expr(0, hsep(expr(Pat), text("=>")), Body).
+    block_expr(0, hsep(expr_p(500, Pat), text("=>")), Body).
 
 block_expr(_, Header, {block, _, Ss}) ->
     block(Header, statements(Ss));
@@ -491,8 +434,9 @@ block_expr(P, Header, E) ->
 statements(Stmts) ->
     above([ statement(S) || S <- Stmts ]).
 
-statement(S = {letval, _, _, _})       -> letdecl("let", S);
+statement(S = {letval, _, _, _, _})    -> letdecl("let", S);
 statement(S = {letfun, _, _, _, _, _}) -> letdecl("let", S);
+statement(S = {letrec, _, _})          -> letdecl("let", S);
 statement(E) -> expr(E).
 
 get_elifs(Expr) -> get_elifs(Expr, []).
@@ -504,3 +448,6 @@ get_elifs(If = {'if', Ann, Cond, Then, Else}, Elifs) ->
     end;
 get_elifs(Else, Elifs) -> {lists:reverse(Elifs), {else, Else}}.
 
+fmt(Fmt, Args) -> text(lists:flatten(io_lib:format(Fmt, Args))).
+term(X) -> fmt("~p", [X]).
+

src/aeso_scan.erl

@@ -7,34 +7,27 @@
 %%%-------------------------------------------------------------------
 -module(aeso_scan).
 
--export([scan/1, utf8_encode/1]).
+-export([scan/1]).
 
 -import(aeso_scan_lib, [token/1, token/2, symbol/0, skip/0,
                         override/2, push/2, pop/1]).
 
 lexer() ->
-    Number   = fun(Digit) -> [Digit, "+(_", Digit, "+)*"] end,
     DIGIT    = "[0-9]",
     HEXDIGIT = "[0-9a-fA-F]",
     LOWER    = "[a-z_]",
     UPPER    = "[A-Z]",
     CON      = [UPPER, "[a-zA-Z0-9_]*"],
-    INT      = Number(DIGIT),
-    HEX      = ["0x", Number(HEXDIGIT)],
-    BYTES    = ["#", Number(HEXDIGIT)],
+    INT      = [DIGIT, "+"],
+    HEX      = ["0x", HEXDIGIT, "+"],
+    BYTES    = ["#", HEXDIGIT, "+"],
     WS       = "[\\000-\\ ]+",
     ID       = [LOWER, "[a-zA-Z0-9_']*"],
     TVAR     = ["'", ID],
     QID      = ["(", CON, "\\.)+", ID],
     QCON     = ["(", CON, "\\.)+", CON],
     OP       = "[=!<>+\\-*/:&|?~@^]+",
-    %% Five cases for a character
-    %%  * 1 7-bit ascii, not \ or '
-    %%  * 2-4 8-bit values (UTF8)
-    %%  * \ followed by a known modifier [aernrtv]
-    %%  * \xhh
-    %%  * \x{hhh...}
-    CHAR     = "'(([\\x00-\\x26\\x28-\\x5b\\x5d-\\x7f])|([\\x00-\\xff][\\x80-\\xff]{1,3})|(\\\\[befnrtv'\\\\])|(\\\\x[0-9a-fA-F]{2,2})|(\\\\x\\{[0-9a-fA-F]*\\}))'",
+    CHAR     = "'([^'\\\\]|(\\\\.))'",
     STRING   = "\"([^\"\\\\]|(\\\\.))*\"",
 
     CommentStart = {"/\\*", push(comment, skip())},
@@ -43,10 +36,8 @@ lexer() ->
         , {"\\*/",        pop(skip())}
         , {"[^/*]+|[/*]", skip()} ],
 
-    Keywords = ["contract", "include", "let", "switch", "type", "record", "datatype", "if", "elif", "else", "function",
-                "stateful", "payable", "true", "false", "mod", "public", "entrypoint", "private", "indexed", "namespace",
-                "interface", "main"
-               ],
+    Keywords = ["contract", "include", "let", "rec", "switch", "type", "record", "datatype", "if", "elif", "else", "function",
+                "stateful", "true", "false", "and", "mod", "public", "private", "indexed", "internal", "namespace"],
     KW = string:join(Keywords, "|"),
 
     Rules =
@@ -62,7 +53,7 @@ lexer() ->
         , {CHAR,   token(char,   fun parse_char/1)}
         , {STRING, token(string, fun parse_string/1)}
         , {HEX,    token(hex,    fun parse_hex/1)}
-        , {INT,    token(int,    fun parse_int/1)}
+        , {INT,    token(int,    fun list_to_integer/1)}
         , {BYTES,  token(bytes,  fun parse_bytes/1)}
 
           %% Identifiers (qualified first!)
@@ -85,34 +76,32 @@ scan(String) ->
 %% -- Helpers ----------------------------------------------------------------
 
 parse_string([$" | Chars]) ->
-    unicode:characters_to_nfc_binary(unescape(Chars)).
+    unescape(Chars).
 
-parse_char([$' | Chars]) ->
-    case unicode:characters_to_nfc_list(unescape($', Chars, [])) of
-        [Char] -> Char;
-        _Bad   -> {error, "Bad character literal: '" ++ Chars}
-    end.
-
-utf8_encode(Cs) ->
-    binary_to_list(unicode:characters_to_binary(Cs)).
-
-unescape(Str) -> unescape($", Str, []).
-
-unescape(Delim, [Delim], Acc) ->
-    list_to_binary(lists:reverse(Acc));
-unescape(Delim, [$\\, $x, ${ | Chars ], Acc) ->
-    {Ds, [_ | Cs]} = lists:splitwith(fun($}) -> false ; (_) -> true end, Chars),
-    C = list_to_integer(Ds, 16),
-    Utf8Cs = binary_to_list(unicode:characters_to_binary([C])),
-    unescape(Delim, Cs, [Utf8Cs | Acc]);
-unescape(Delim, [$\\, $x, D1, D2 | Chars ], Acc) ->
-    C = list_to_integer([D1, D2], 16),
-    Utf8Cs = binary_to_list(unicode:characters_to_binary([C])),
-    unescape(Delim, Chars, [Utf8Cs | Acc]);
-unescape(Delim, [$\\, Code | Chars], Acc) ->
-    Ok = fun(C) -> unescape(Delim, Chars, [C | Acc]) end,
+parse_char([$', $\\, Code, $']) ->
     case Code of
-        Delim -> Ok(Delim);
+        $'  -> $';
+        $\\ -> $\\;
+        $b  -> $\b;
+        $e  -> $\e;
+        $f  -> $\f;
+        $n  -> $\n;
+        $r  -> $\r;
+        $t  -> $\t;
+        $v  -> $\v;
+        _   -> {error, "Bad control sequence: \\" ++ [Code]}
+    end;
+parse_char([$', C, $']) -> C.
+
+unescape(Str) -> unescape(Str, []).
+
+%% TODO: numeric escapes
+unescape([$"], Acc) ->
+    list_to_binary(lists:reverse(Acc));
+unescape([$\\, Code | Chars], Acc) ->
+    Ok = fun(C) -> unescape(Chars, [C | Acc]) end,
+    case Code of
+        $"  -> Ok($");
         $\\ -> Ok($\\);
         $b  -> Ok($\b);
         $e  -> Ok($\e);
@@ -123,21 +112,13 @@ unescape(Delim, [$\\, Code | Chars], Acc) ->
         $v  -> Ok($\v);
         _   -> error("Bad control sequence: \\" ++ [Code])  %% TODO
     end;
-unescape(Delim, [C | Chars], Acc) ->
-    unescape(Delim, Chars, [C | Acc]).
+unescape([C | Chars], Acc) ->
+    unescape(Chars, [C | Acc]).
 
-strip_underscores(S) ->
-    lists:filter(fun(C) -> C /= $_ end, S).
+parse_hex("0x" ++ Chars) -> list_to_integer(Chars, 16).
 
-parse_hex("0x" ++ S) ->
-    list_to_integer(strip_underscores(S), 16).
-
-parse_int(S) ->
-    list_to_integer(strip_underscores(S)).
-
-parse_bytes("#" ++ S0) ->
-    S      = strip_underscores(S0),
-    N      = list_to_integer(S, 16),
-    Digits = (length(S) + 1) div 2,
+parse_bytes("#" ++ Chars) ->
+    N      = list_to_integer(Chars, 16),
+    Digits = (length(Chars) + 1) div 2,
     <<N:Digits/unit:8>>.
 

src/aeso_stdlib.erl

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

src/aeso_syntax.erl

@@ -13,7 +13,7 @@
 -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, pragma/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([ast/0]).
@@ -25,8 +25,7 @@
 -type ann_origin() :: system | user.
 -type ann_format() :: '?:' | hex | infix | prefix | elif.
 
--type ann() :: [ {line, ann_line()} | {col, ann_col()} | {format, ann_format()} | {origin, ann_origin()}
-               | stateful | private | payable | main | interface].
+-type ann() :: [{line, ann_line()} | {col, ann_col()} | {format, ann_format()} | {origin, ann_origin()}].
 
 -type name() :: string().
 -type id()   :: {id,   ann(), name()}.
@@ -35,31 +34,17 @@
 -type qcon() :: {qcon, ann(), [name()]}.
 -type tvar() :: {tvar, ann(), name()}.
 
--type decl() :: {contract_main, ann(), con(), [decl()]}
-              | {contract_child, ann(), con(), [decl()]}
-              | {contract_interface, ann(), con(), [decl()]}
+-type decl() :: {contract, ann(), con(), [decl()]}
               | {namespace, ann(), con(), [decl()]}
-              | {pragma, ann(), pragma()}
-              | {type_decl, ann(), id(), [tvar()]} % Only for error msgs
+              | {type_decl, ann(), id(), [tvar()]}
               | {type_def, ann(), id(), [tvar()], typedef()}
-              | {fun_clauses, ann(), id(), type(), [letfun() | fundecl()]}
-              | {block, ann(), [decl()]}
-              | fundecl()
-              | letfun()
-              | letval(). % Only for error msgs
-
--type compiler_version() :: [non_neg_integer()].
-
--type pragma() :: {compiler, '==' | '<' | '>' | '=<' | '>=', compiler_version()}.
-
-
--type letval()  :: {letval, ann(), pat(), expr()}.
--type letfun()  :: {letfun, ann(), id(), [pat()], type(), expr()}.
--type fundecl() :: {fun_decl, ann(), id(), type()}.
+              | {fun_decl, ann(), id(), type()}
+              | letbind().
 
 -type letbind()
-    :: letfun()
-     | letval().
+    :: {letval, ann(), id(), type(), expr()}
+     | {letfun, ann(), id(), [arg()], type(), expr()}
+     | {letrec, ann(), [letbind()]}.
 
 -type arg() :: {arg, ann(), id(), type()}.
 
@@ -75,8 +60,7 @@
 -type type() :: {fun_t, ann(), [named_arg_t()], [type()], type()}
               | {app_t, ann(), type(), [type()]}
               | {tuple_t, ann(), [type()]}
-              | {args_t, ann(), [type()]}   %% old tuple syntax, old for error messages
-              | {bytes_t, ann(), integer() | any}
+              | {bytes_t, ann(), integer()}
               | id()  | qid()
               | con() | qcon()  %% contracts
               | tvar().
@@ -86,11 +70,12 @@
 -type constant()
     :: {int, ann(), integer()}
      | {bool, ann(), true | false}
-     | {bytes, ann(), binary()}
-     | {account_pubkey, ann(), binary()}
-     | {contract_pubkey, ann(), binary()}
-     | {oracle_pubkey, ann(), binary()}
-     | {oracle_query_id, ann(), binary()}
+     | {hash, ann(), binary()}
+     | {account_pubkey, binary()}
+     | {contract_pubkey, binary()}
+     | {oracle_pubkey, binary()}
+     | {oracle_query_id, binary()}
+     | {unit, ann()}
      | {string, ann(), binary()}
      | {char, ann(), integer()}.
 
@@ -109,10 +94,10 @@
      | {proj, ann(), expr(), id()}
      | {tuple, ann(), [expr()]}
      | {list, ann(), [expr()]}
-     | {list_comp, ann(), expr(), [comprehension_exp()]}
      | {typed, ann(), expr(), type()}
-     | {record_or_map(), ann(), [field(expr())]}
-     | {record_or_map(), ann(), expr(), [field(expr())]} %% record/map update
+     | {record, ann(), [field(expr())]}
+     | {record, ann(), expr(), [field(expr())]} %% record update
+     | {map, ann(), expr(), [field(expr())]}    %% map update
      | {map, ann(), [{expr(), expr()}]}
      | {map_get, ann(), expr(), expr()}
      | {map_get, ann(), expr(), expr(), expr()}
@@ -121,12 +106,6 @@
      | id() | qid() | con() | qcon()
      | constant().
 
--type record_or_map() :: record | map | record_or_map_error.
-
--type comprehension_exp() :: [ {comprehension_bind, pat(), expr()}
-                             | {comprehension_if, ann(), expr()}
-                             | letbind() ].
-
 -type arg_expr() :: expr() | {named_arg, ann(), id(), expr()}.
 
 %% When lvalue is a projection this is sugar for accessing fields in nested
@@ -151,7 +130,6 @@
 -type pat() :: {app, ann(), con() | op(), [pat()]}
              | {tuple, ann(), [pat()]}
              | {list, ann(), [pat()]}
-             | {typed, ann(), pat(), type()}
              | {record, ann(), [field(pat())]}
              | constant()
              | con()
@@ -172,3 +150,4 @@ get_ann(Key, 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,7 +6,7 @@
 %%%-------------------------------------------------------------------
 -module(aeso_syntax_utils).
 
--export([used_ids/1, used_types/2, used/1]).
+-export([used_ids/1, used_types/1, used/1]).
 
 -record(alg, {zero, plus, scoped}).
 
@@ -39,17 +39,23 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
     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, _, P, E}        -> Scoped(BindExpr(P), Expr(E));
-            {letfun, _, F, Xs, T, E} -> Sum([BindExpr(F), Type(T), Expr(Xs ++ [E])]);
-            {fun_clauses, _, _, T, Cs} -> Sum([Type(T) | [Decl(C) || C <- Cs]]);
+            {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);
@@ -71,15 +77,6 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
             {proj, _, E, _}        -> Expr(E);
             {tuple, _, As}         -> Expr(As);
             {list, _, As}          -> Expr(As);
-            {list_comp, _, Y, []}  -> Expr(Y);
-            {list_comp, A, Y, [{comprehension_bind, I, E}|R]} ->
-                Plus(Expr(E), Scoped(BindExpr(I), Expr({list_comp, A, Y, R})));
-            {list_comp, A, Y, [{comprehension_if, _, E}|R]} ->
-                Plus(Expr(E), Expr({list_comp, A, Y, R}));
-            {list_comp, A, Y, [D = {letval, _, Pat, _} | R]} ->
-                Plus(Decl(D), Scoped(BindExpr(Pat), Expr({list_comp, A, Y, R})));
-            {list_comp, A, Y, [D = {letfun, _, F, _, _, _} | R]} ->
-                Plus(Decl(D), Scoped(BindExpr(F), Expr({list_comp, A, Y, R})));
             {typed, _, E, T}       -> Plus(Expr(E), Type(T));
             {record, _, Fs}        -> Expr(Fs);
             {record, _, E, Fs}     -> Expr([E | Fs]);
@@ -92,7 +89,7 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
             {field, _, LV, E}    -> Expr([LV, E]);
             {field, _, LV, _, E} -> Expr([LV, E]);
             %% arg()
-            {arg, _, Y, T} -> Plus(BindExpr(Y), Type(T));
+            {arg, _, X, T} -> Plus(Expr(X), Type(T));
             %% alt()
             {'case', _, P, E} -> Scoped(BindExpr(P), Expr(E));
             %% elim()
@@ -107,35 +104,29 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
 %% Name dependencies
 
 used_ids(E) ->
-    [ X || {{term, [X]}, _} <- used(E) ].
+    [ X || {term, [X]} <- used(E) ].
 
-used_types([Top] = _CurrentNS, T) ->
-    F = fun({{type, [X]}, _}) -> [X];
-           ({{type, [Top1, X]}, _}) when Top1 == Top -> [X];
-           (_) -> []
-        end,
-    lists:flatmap(F, used(T)).
+used_types(T) ->
+    [ X || {type, [X]} <- used(T) ].
 
 -type entity() :: {term, [string()]}
                 | {type, [string()]}
                 | {namespace, [string()]}.
 
--spec entity_alg() -> alg(#{entity() => aeso_syntax:ann()}).
+-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,
-    Remove  = fun(Keys, Map) -> maps:without(Keys, Map) end,
     Scoped = fun(Xs, Ys) ->
-                Bound  = [E || E <- maps:keys(Xs), IsBound(E)],
+                {Bound, Others} = lists:partition(IsBound, Ys),
                 Bound1 = [ {Unbind(Tag), X} || {Tag, X} <- Bound ],
-                Others = Remove(Bound1, Ys),
-                maps:merge(Remove(Bound, Xs), Others)
+                lists:umerge(Xs -- Bound1, Others)
             end,
-    #alg{ zero   = #{}
-        , plus   = fun maps:merge/2
+    #alg{ zero   = []
+        , plus   = fun lists:umerge/2
         , scoped = Scoped }.
 
--spec used(_) -> [{entity(), aeso_syntax:ann()}].
+-spec used(_) -> [entity()].
 used(D) ->
     Kind = fun(expr)      -> term;
               (bind_expr) -> bound_term;
@@ -143,14 +134,14 @@ used(D) ->
               (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,
+    NotBound = fun({Tag, _}) -> not lists:member(Tag, [bound_term, bound_type]) end,
     Xs =
-        maps:to_list(fold(entity_alg(),
-            fun(K, {id,   Ann, X})  -> #{{Kind(K), [X]} => Ann};
-               (K, {qid,  Ann, Xs}) -> #{{Kind(K), Xs}  => Ann, NS(Xs) => Ann};
-               (K, {con,  Ann, X})  -> #{{Kind(K), [X]} => Ann};
-               (K, {qcon, Ann, Xs}) -> #{{Kind(K), Xs}  => Ann, NS(Xs) => Ann};
-               (_, _)             -> #{}
-            end, decl, D)),
+        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).
 

src/aeso_utils.hrl

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

src/aeso_vm_decode.erl

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

src/aesophia.app.src

@@ -1,6 +1,6 @@
 {application, aesophia,
  [{description, "Contract Language for aeternity"},
-  {vsn, "6.0.0"},
+  {vsn, "2.1.0"},
   {registered, []},
   {applications,
    [kernel,
@@ -8,8 +8,7 @@
     jsx,
     syntax_tools,
     getopt,
-    aebytecode,
-    eblake2
+    aebytecode
    ]},
   {env,[]},
   {modules, []},

src/aesophia.erl

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

test/aeso_abi_tests.erl

@@ -1,7 +1,7 @@
 -module(aeso_abi_tests).
 
 -include_lib("eunit/include/eunit.hrl").
--compile([export_all, nowarn_export_all]).
+-compile(export_all).
 
 -define(SANDBOX(Code), sandbox(fun() -> Code end)).
 -define(DUMMY_HASH_WORD, 16#123).
@@ -62,81 +62,28 @@ encode_decode_sophia_test() ->
                                 Other -> Other
                               end end,
     ok = Check("int", "42"),
-    ok = Check("int", "- 42"),
     ok = Check("bool", "true"),
     ok = Check("bool", "false"),
     ok = Check("string", "\"Hello\""),
-    ok = Check("string * list(int) * option(bool)",
+    ok = Check("(string, list(int), option(bool))",
                "(\"Hello\", [1, 2, 3], Some(true))"),
     ok = Check("variant", "Blue({[\"x\"] = 1})"),
     ok = Check("r", "{x = (\"foo\", 0), y = Red}"),
     ok.
 
-to_sophia_value_neg_test() ->
-    Code = [ "contract Foo =\n"
-             "  entrypoint x(y : int) : string = \"hello\"\n" ],
-
-    {error, [Err1]} = aeso_compiler:to_sophia_value(Code, "x", ok, encode(12)),
-    ?assertEqual("Data error:\nFailed to decode binary as type string\n", aeso_errors:pp(Err1)),
-    {error, [Err2]} = aeso_compiler:to_sophia_value(Code, "x", ok, encode(12), [{backend, fate}]),
-    ?assertEqual("Data error:\nFailed to decode binary as type string\n", aeso_errors:pp(Err2)),
-
-    {error, [Err3]} = aeso_compiler:to_sophia_value(Code, "x", revert, encode(12)),
-    ?assertEqual("Data error:\nCould not interpret the revert message\n", aeso_errors:pp(Err3)),
-    {error, [Err4]} = aeso_compiler:to_sophia_value(Code, "x", revert, encode(12), [{backend, fate}]),
-    ?assertEqual("Data error:\nCould not deserialize the revert message\n", aeso_errors:pp(Err4)),
-    ok.
-
-encode_calldata_neg_test() ->
-    Code = [ "contract Foo =\n"
-             "  entrypoint x(y : int) : string = \"hello\"\n" ],
-
-    ExpErr1 = "Type error at line 5, col 34:\nCannot unify int\n         and bool\n"
-              "when checking the application at line 5, column 34 of\n"
-              "  x : (int) => string\nto arguments\n  true : bool\n",
-    {error, [Err1]} = aeso_compiler:create_calldata(Code, "x", ["true"]),
-    ?assertEqual(ExpErr1, aeso_errors:pp(Err1)),
-    {error, [Err2]} = aeso_compiler:create_calldata(Code, "x", ["true"], [{backend, fate}]),
-    ?assertEqual(ExpErr1, aeso_errors:pp(Err2)),
-
-    ok.
-
-decode_calldata_neg_test() ->
-    Code1 = [ "contract Foo =\n"
-              "  entrypoint x(y : int) : string = \"hello\"\n" ],
-    Code2 = [ "contract Foo =\n"
-              "  entrypoint x(y : string) : int = 42\n" ],
-
-    {ok, CallDataAEVM} = aeso_compiler:create_calldata(Code1, "x", ["42"]),
-    {ok, CallDataFATE} = aeso_compiler:create_calldata(Code1, "x", ["42"], [{backend, fate}]),
-
-    {error, [Err1]} = aeso_compiler:decode_calldata(Code2, "x", CallDataAEVM),
-    ?assertEqual("Data error:\nFailed to decode calldata as type {tuple,[string]}\n", aeso_errors:pp(Err1)),
-    {error, [Err2]} = aeso_compiler:decode_calldata(Code2, "x", <<1,2,3>>, [{backend, fate}]),
-    ?assertEqual("Data error:\nFailed to decode calldata binary\n", aeso_errors:pp(Err2)),
-    {error, [Err3]} = aeso_compiler:decode_calldata(Code2, "x", CallDataFATE, [{backend, fate}]),
-    ?assertEqual("Data error:\nCannot translate FATE value \"*\"\n  to Sophia type (string)\n", aeso_errors:pp(Err3)),
-
-    {error, [Err4]} = aeso_compiler:decode_calldata(Code2, "y", CallDataAEVM),
-    ?assertEqual("Data error at line 1, col 1:\nFunction 'y' is missing in contract\n", aeso_errors:pp(Err4)),
-    {error, [Err5]} = aeso_compiler:decode_calldata(Code2, "y", CallDataFATE, [{backend, fate}]),
-    ?assertEqual("Data error at line 1, col 1:\nFunction 'y' is missing in contract\n", aeso_errors:pp(Err5)),
-    ok.
-
-
 encode_decode_sophia_string(SophiaType, String) ->
     io:format("String ~p~n", [String]),
     Code = [ "contract MakeCall =\n"
            , "  type arg_type = ", SophiaType, "\n"
-           , "  type an_alias('a) = string * 'a\n"
+           , "  type an_alias('a) = (string, 'a)\n"
            , "  record r = {x : an_alias(int), y : variant}\n"
            , "  datatype variant = Red | Blue(map(string, int))\n"
-           , "  entrypoint foo : arg_type => arg_type\n" ],
-    case aeso_compiler:check_call(lists:flatten(Code), "foo", [String], [no_code]) of
+           , "  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, [no_code]) of
+            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} ->
@@ -172,14 +119,16 @@ calldata_init_test() ->
 
 calldata_indent_test() ->
     Test = fun(Extra) ->
-            Code = parameterized_contract(Extra, "foo", ["int"]),
-            encode_decode_calldata_(Code, "foo", ["42"], word)
+            encode_decode_calldata_(
+                parameterized_contract(Extra, "foo", ["int"]),
+                "foo", ["42"], word)
            end,
-    Test("  stateful entrypoint bla() = ()"),
+    Test("  stateful function bla() = ()"),
     Test("  type x = int"),
-    Test("  stateful entrypoint bla(x : int) =\n"
+    Test("  private function bla : int => int"),
+    Test("  public stateful function bla(x : int) =\n"
          "    x + 1"),
-    Test("  stateful entrypoint bla(x : int) : int =\n"
+    Test("  stateful private function bla(x : int) : int =\n"
          "    x + 1"),
     ok.
 
@@ -189,34 +138,32 @@ parameterized_contract(FunName, Types) ->
 parameterized_contract(ExtraCode, FunName, Types) ->
     lists:flatten(
         ["contract Remote =\n"
-         "  entrypoint bla : () => unit\n\n"
-         "main contract Dummy =\n",
+         "  function bla : () => ()\n\n"
+         "contract Dummy =\n",
          ExtraCode, "\n",
-         "  type an_alias('a) = string * 'a\n"
+         "  type an_alias('a) = (string, 'a)\n"
          "  record r = {x : an_alias(int), y : variant}\n"
          "  datatype variant = Red | Blue(map(string, int))\n"
-         "  entrypoint ", FunName, " : (", string:join(Types, ", "), ") => int\n" ]).
+         "  function ", FunName, " : (", string:join(Types, ", "), ") => int\n" ]).
 
 oracle_test() ->
     Contract =
         "contract OracleTest =\n"
-        "  entrypoint question(o, q : oracle_query(list(string), option(int))) =\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"], [no_code]),
+                                                        "oq_1111111111111111111111111111113AFEFpt5"], []),
 
     ok.
 
 permissive_literals_fail_test() ->
     Contract =
         "contract OracleTest =\n"
-        "  stateful entrypoint haxx(o : oracle(list(string), option(int))) =\n"
+        "  function haxx(o : oracle(list(string), option(int))) =\n"
         "    Chain.spend(o, 1000000)\n",
-    {error, [Err]} =
-        aeso_compiler:check_call(Contract, "haxx", ["#123"], []),
-    ?assertMatch("Type error at line 3, col 5:\nCannot unify" ++ _, aeso_errors:pp(Err)),
-    ?assertEqual(type_error, aeso_errors:type(Err)),
+        {error, <<"Type errors\nCannot unify", _/binary>>} =
+            aeso_compiler:check_call(Contract, "haxx", ["#123"], []),
     ok.
 
 encode_decode_calldata(FunName, Types, Args) ->
@@ -227,16 +174,14 @@ encode_decode_calldata(FunName, Types, Args, RetType) ->
     encode_decode_calldata_(Code, FunName, Args, RetType).
 
 encode_decode_calldata_(Code, FunName, Args, RetVMType) ->
-    {ok, Calldata} = aeso_compiler:create_calldata(Code, FunName, Args, []),
-    {ok, _, {ArgTypes, RetType}, _} = aeso_compiler:check_call(Code, FunName, Args, [{backend, aevm}, no_code]),
-    ?assertEqual(RetType, RetVMType),
-    CalldataType = {tuple, [word, {tuple, ArgTypes}]},
+    {ok, 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, []),
+            {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,

test/aeso_aci_tests.erl

@@ -2,140 +2,75 @@
 
 -include_lib("eunit/include/eunit.hrl").
 
-simple_aci_test_() ->
-    [{"Test contract " ++ integer_to_list(N),
-      fun() -> test_contract(N) end}
-     || N <- [1, 2, 3]].
+
+do_test() ->
+    test_contract(1),
+    test_contract(2),
+    test_contract(3).
 
 test_contract(N) ->
     {Contract,MapACI,DecACI} = test_cases(N),
-    {ok,JSON} = aeso_aci:contract_interface(json, Contract),
-    ?assertEqual([MapACI], JSON),
-    ?assertEqual({ok, DecACI}, aeso_aci:render_aci_json(JSON)),
-    %% Check if the compiler provides correct aci
-    {ok,#{aci := JSON2}} = aeso_compiler:from_string(Contract, [{aci, json}]),
-    ?assertEqual(JSON, JSON2).
+    {ok,JSON} = aeso_aci:encode(Contract),
+    ?assertEqual(MapACI, jsx:decode(JSON, [return_maps])),
+    ?assertEqual(DecACI, aeso_aci:decode(JSON)).
 
 test_cases(1) ->
-    Contract = <<"payable contract C =\n"
-		 "  payable stateful entrypoint a(i : int) = i+1\n">>,
-    MapACI = #{contract =>
-		   #{name => <<"C">>,
-		     type_defs => [],
-         payable => true,
-         kind => contract_main,
-		     functions =>
-			 [#{name => <<"a">>,
-			    arguments =>
-				[#{name => <<"i">>,
-				   type => <<"int">>}],
-			    returns => <<"int">>,
-			    stateful => true,
-                            payable  => true}]}},
-    DecACI = <<"payable main contract C =\n"
-	       "  payable entrypoint a : (int) => int\n">>,
+    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 = <<"main contract C =\n"
+    Contract = <<"contract C =\n"
 		 "  type allan = int\n"
-		 "  entrypoint a(i : allan) = i+1\n">>,
-    MapACI = #{contract =>
-                   #{name => <<"C">>, payable => false,
-                     kind => contract_main,
-                     type_defs =>
-                         [#{name => <<"allan">>,
-                            typedef => <<"int">>,
-                            vars => []}],
-                     functions =>
-                         [#{arguments =>
-                                [#{name => <<"i">>,
-                                   type => <<"C.allan">>}],
-                            name => <<"a">>,
-                            returns => <<"int">>,
-                            stateful => false,
-                            payable  => false}]}},
-    DecACI = <<"main contract C =\n"
-               "  type allan = int\n"
-               "  entrypoint a : (C.allan) => int\n">>,
+		 "  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 = <<"main contract C =\n"
-                 "  type state = unit\n"
-                 "  datatype event = SingleEventDefined\n"
-                 "  datatype bert('a) = Bin('a)\n"
-                 "  entrypoint a(i : bert(string)) = 1\n">>,
-    MapACI = #{contract =>
-		   #{functions =>
-             [#{arguments =>
-                    [#{name => <<"i">>,
-                       type =>
-                           #{<<"C.bert">> => [<<"string">>]}}],
-                name => <<"a">>,returns => <<"int">>,
-                stateful => false, payable  => false}],
-		     name => <<"C">>, payable => false, kind => contract_main,
-         event => #{variant => [#{<<"SingleEventDefined">> => []}]},
-         state => <<"unit">>,
-		     type_defs =>
-             [#{name => <<"bert">>,
-                typedef =>
-                    #{variant =>
-                          [#{<<"Bin">> => [<<"'a">>]}]},
-                vars => [#{name => <<"'a">>}]}]}},
-    DecACI = <<"main contract C =\n"
-               "  type state = unit\n"
-               "  datatype event = SingleEventDefined\n"
-               "  datatype bert('a) = Bin('a)\n"
-               "  entrypoint a : (C.bert(string)) => int\n">>,
+    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}.
-
-%% Roundtrip
-aci_test_() ->
-    [{"Testing ACI generation for " ++ ContractName,
-      fun() -> aci_test_contract(ContractName) end}
-     || ContractName <- all_contracts()].
-
-all_contracts() -> aeso_compiler_tests:compilable_contracts().
-
-aci_test_contract(Name) ->
-    String = aeso_test_utils:read_contract(Name),
-    Opts   = case lists:member(Name, aeso_compiler_tests:debug_mode_contracts()) of
-                 true  -> [debug_mode];
-                 false -> []
-             end ++ [{include, {file_system, [aeso_test_utils:contract_path()]}}],
-    JSON = case aeso_aci:contract_interface(json, String, Opts) of
-               {ok, J} -> J;
-               {error, ErrorStringJ} when is_binary(ErrorStringJ) -> error(ErrorStringJ);
-               {error, ErrorJ} -> aeso_compiler_tests:print_and_throw(ErrorJ)
-           end,
-    case aeso_compiler:from_string(String, [{aci, json}, {backend, fate} | Opts]) of
-        {ok, #{aci := JSON1}} ->
-            ?assertEqual(JSON, JSON1),
-            io:format("JSON:\n~p\n", [JSON]),
-            {ok, ContractStub} = aeso_aci:render_aci_json(JSON),
-
-            io:format("STUB:\n~s\n", [ContractStub]),
-            check_stub(ContractStub, [{src_file, Name}]),
-
-            ok;
-        {error, ErrorString} when is_binary(ErrorString) -> error(ErrorString);
-        {error, Error} -> aeso_compiler_tests:print_and_throw(Error)
-    end.
-
-check_stub(Stub, Options) ->
-    try aeso_parser:string(binary_to_list(Stub), Options) of
-        Ast ->
-            try
-                %% io:format("AST: ~120p\n", [Ast]),
-                aeso_ast_infer_types:infer(Ast, [])
-            catch throw:{type_errors, TE} ->
-                io:format("Type error:\n~s\n", [TE]),
-                error(TE);
-                  _:R ->
-                io:format("Error: ~p\n", [R]),
-                error(R)
-            end
-    catch throw:{error, Errs} ->
-        _ = [ io:format("~s\n", [aeso_errors:pp(E)]) || E <- Errs ],
-        error({parse_errors, Errs})
-    end.

test/aeso_calldata_tests.erl

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

test/aeso_parser_tests.erl

@@ -4,19 +4,17 @@
 
 -include_lib("eunit/include/eunit.hrl").
 
-id(X) -> X.
-
 simple_contracts_test_() ->
     {foreach,
      fun() -> ok end,
      fun(_) -> ok end,
      [{"Parse a contract with an identity function.",
        fun() ->
-            Text = "main contract Identity =\n"
+            Text = "contract Identity =\n"
                    "  function id(x) = x\n",
             ?assertMatch(
-                [{contract_main, _, {con, _, "Identity"},
-                    [{letfun, _, {id, _, "id"}, [{id, _, "x"}], {id, _, "_"},
+                [{contract, _, {con, _, "Identity"},
+                    [{letfun, _, {id, _, "id"}, [{arg, _, {id, _, "x"}, {id, _, "_"}}], {id, _, "_"},
                         {id, _, "x"}}]}], parse_string(Text)),
             ok
        end},
@@ -32,7 +30,7 @@ simple_contracts_test_() ->
                     end,
             Parse = fun(S) ->
                     try remove_line_numbers(parse_expr(S))
-                    catch _:_ -> ?assertMatch(ok, id({parse_fail, S})) end
+                    catch _:_ -> ?assertMatch(ok, {parse_fail, S}) end
                 end,
             CheckParens = fun(Expr) ->
                     ?assertEqual(Parse(NoPar(Expr)), Parse(Par(Expr)))
@@ -40,7 +38,8 @@ simple_contracts_test_() ->
             LeftAssoc  = fun(Op) -> CheckParens({{a, Op, b}, Op, c}) end,
             RightAssoc = fun(Op) -> CheckParens({a, Op, {b, Op, c}}) end,
             NonAssoc   = fun(Op) ->
-                            ?assertThrow({error, [_]},
+                            OpAtom = list_to_atom(Op),
+                            ?assertError({error, {_, parse_error, _}},
                                          parse_expr(NoPar({a, Op, {b, Op, c}}))) end,
             Stronger = fun(Op1, Op2) ->
                     CheckParens({{a, Op1, b}, Op2, c}),
@@ -63,8 +62,7 @@ simple_contracts_test_() ->
      %% Parse tests of example contracts
      [ {lists:concat(["Parse the ", Contract, " contract."]),
         fun() -> roundtrip_contract(Contract) end}
-        || Contract <- [counter, voting, all_syntax, '05_greeter', aeproof,
-                        multi_sig, simple_storage, fundme, dutch_auction, utf8] ]
+        || Contract <- [counter, voting, all_syntax, '05_greeter', aeproof, multi_sig, simple_storage, withdrawal, fundme, dutch_auction] ]
     }.
 
 parse_contract(Name) ->
@@ -73,28 +71,25 @@ parse_contract(Name) ->
 roundtrip_contract(Name) ->
     round_trip(aeso_test_utils:read_contract(Name)).
 
-parse_string(Text) -> parse_string(Text, []).
-
-parse_string(Text, Opts) ->
-    aeso_parser:string(Text, Opts).
+parse_string(Text) ->
+    case aeso_parser:string(Text) of
+        {ok, Contract} -> Contract;
+        Err -> error(Err)
+    end.
 
 parse_expr(Text) ->
-    [{letval, _, _, Expr}] =
+    [{letval, _, _, _, Expr}] =
         parse_string("let _ = " ++ Text),
     Expr.
 
 round_trip(Text) ->
     Contract  = parse_string(Text),
-    Text1     = prettypr:format(aeso_pretty:decls(strip_stdlib(Contract))),
-    Contract1 = parse_string(aeso_scan:utf8_encode(Text1)),
+    Text1     = prettypr:format(aeso_pretty:decls(Contract)),
+    Contract1 = parse_string(Text1),
     NoSrcLoc  = remove_line_numbers(Contract),
     NoSrcLoc1 = remove_line_numbers(Contract1),
     ?assertMatch(NoSrcLoc, diff(NoSrcLoc, NoSrcLoc1)).
 
-strip_stdlib([{namespace, _, {con, _, "ListInternal"}, _} | Decls]) ->
-    strip_stdlib(Decls);
-strip_stdlib(Decls) -> Decls.
-
 remove_line_numbers({line, _L}) -> {line, 0};
 remove_line_numbers({col,  _C}) -> {col, 0};
 remove_line_numbers([H|T]) ->

test/aeso_scan_tests.erl

@@ -41,7 +41,7 @@ all_tokens() ->
     %% Operators
     lists:map(Lit, ['=', '==', '!=', '>', '<', '>=', '=<', '-', '+', '++', '*', '/', mod, ':', '::', '->', '=>', '||', '&&', '!']) ++
     %% Keywords
-    lists:map(Lit, [contract, type, 'let', switch]) ++
+    lists:map(Lit, [contract, type, 'let', switch, rec, 'and']) ++
     %% Comment token (not an actual token), just for tests
     [{comment, 0, "// *Comment!\"\n"},
      {comment, 0, "/* bla /* bla bla */*/"}] ++

test/contracts/05_greeter.aes

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

test/contracts/__call.aes

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

test/contracts/abort_test.aes

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

test/contracts/abort_test_int.aes

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

test/contracts/address_chain.aes

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

test/contracts/address_literals.aes

@@ -1,16 +1,14 @@
 
-contract interface Remote =
-  entrypoint foo : () => unit
+contract Remote =
+  function foo : () => ()
 
 contract AddressLiterals =
-  entrypoint addr() : address =
+  function addr() : address =
     ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt
-  entrypoint oracle() : oracle(int, bool) =
+  function oracle() : oracle(int, bool) =
     ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5
-  entrypoint query() : oracle_query(int, bool) =
+  function query() : oracle_query(int, bool) =
     oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY
-  entrypoint contr() : Remote =
+  function contr() : Remote =
     ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ
-  entrypoint contr_addr() : Remote =
-    Address.to_contract(addr())
 

test/contracts/aens.aes

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

test/contracts/aens_update.aes

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

test/contracts/aeproof.aes

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

test/contracts/all_syntax.aes

@@ -1,82 +1,49 @@
 // Try to cover all syntactic constructs.
-@compiler > 0
-@compiler =< 10.1.1.1.1.1.2.3.4
 
+contract AllSyntaxType =
+  type typeDecl /* bla */
+  type paramTypeDecl('a, 'b)
 
-namespace Ns =
-  datatype d('a) = D | S(int) | M('a, list('a), int)
-  private function fff() = 123
-
-  stateful entrypoint
-    f (1, x) = (_) => x
-
-payable contract AllSyntaxType =
   /** Multi-
     * line
     * comment
     */
-  stateful function foo : _
-  entrypoint bar : int => (int * 'a)
-
+  function foo : _
 
 contract AllSyntax =
 
-  datatype mickiewicz = Adam | Mickiewicz
-  record goethe('a, 'b) = {
-    johann : int,
-    wolfgang : 'a,
-    von : 'a * 'b * int,
-    goethe : unit
-    }
-  type dante = Ns.d(int)
-  type shakespeare('a) = goethe('a, 'a)
+  type typeDecl = int
+  type paramTypeDecl('a, 'b) = (('a, 'b) => 'b) => list('a) => 'b => 'b
 
-  type state = shakespeare(int)
+  record nestedRecord = { x : int }
+  record recordType = { z : nestedRecord, y : int }
+  datatype variantType('a) = None | Some('a)
 
-  entrypoint init() = {
-    johann = 1000,
-    wolfgang = -10,
+  let valWithType : map(int, int) => option(int) = (m) => Map.get(m, 42)
+  let valNoType =
+        if(valWithType(Map.empty) == None)
+          print(42 mod 10 * 5 / 3)
 
-/* TODO: This does not compile because of bug in the parser tester.
-    von = (2 + 2, 0, List.sum([x | k <- [1,2,3]
-                                 , let l = k + 1
-                                 , if(l < 10)
-                                 , let f(x) = x + 100
-                                 , Adam <- [Adam, Mickiewicz]
-                                 , let x = f(l)
-                                 ])),
-*/
-    von = (2 + 2, 0, List.sum([1,2,3,4])),
-    goethe = () }
+  function funWithType(x : int, y) : (int, list(int)) = (x, 0 :: [y] ++ [])
+  function funNoType() =
+    let foo = (x, y : bool) =>
+                if (! (y && x =< 0x0b || true)) [x]
+                else [11..20]
+    let setY(r : recordType) : unit = r{ y = 5 }
+    let setX(r : recordType, x : int) : recordType = r { z.x = x }  // nested record update
+    let getY(r) = switch(r) {y = y} => y
+    switch (funWithType(1, -2))
+      (x, [y, z]) => bar({x = z, y = -y + - -z * (-1)})
+      (x, y :: _) => ()
 
-  function f() =
-     let kp = "nietzsche"
-     // let p = "Пушкин" // TODO: this also doesn't do right round_trip...
-     let k(x : bytes(8)) : bytes(8) = Bytes.to_int(#fedcba9876543210)
+  function mutual() =
+    let rec recFun(x : int) = mutFun(x)
+        and mutFun(x) = if(x =< 0) 1 else x * recFun(x - 1)
+    recFun(0)
 
-     let f : () => address = () => ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt
-     if(Bits.test(Bits.all, 10))
-       abort("ohno")
-     if(true && false)
-       require(true, "ohyes")
-     elif(false || 2 == 2)
-       ()
-     else
-       ()
-     if(true) f(1,2)((1,2))
-     else switch(1::[1,2,3])
-       [] => 1
-       a::b => 123
-       1::2::3 => 123123
-       [2,3,4] => 1
-       _ => 13
-       1::[2] => 2138
-     put(state{johann = 1})
-     
-     let m = {["foo"] = 19, /*hey wanna talk about inlined comments?*/ ["bar"] = 42}
-     let n = {}
-     m{ ["x" = 0] @ z = z + state.johann }
+  let hash : address = #01ab0fff11
+  let b = false
+  let qcon = Mod.Con
+  let str = "blabla\nfoo"
+  let chr = '"'
 
-     let sh : shakespeare(shakespeare(int)) =
-       {wolfgang = state}
-     sh{wolfgang.wolfgang = sh.wolfgang} // comment

test/contracts/ambiguous_main.aes

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

test/contracts/bad_address_literals.aes

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

test/contracts/bad_arity.aes

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

test/contracts/bad_bytes_concat.aes

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

test/contracts/bad_bytes_split.aes

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

test/contracts/bad_events.aes

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

test/contracts/bad_events2.aes

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

test/contracts/bad_function_block.aes

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

test/contracts/bad_include_and_ns.aes

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

test/contracts/bad_init_state_access.aes

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

test/contracts/bad_number_of_args.aes

@@ -1,6 +0,0 @@
-contract Test =
-  entrypoint f() = ()
-  entrypoint g(x : int, y : string) = f(1)
-  entrypoint h() = g(1)
-  entrypoint i() = g("Litwo, ojczyzno moja")
-  

test/contracts/bad_protected_call.aes

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

test/contracts/bad_records.aes

@@ -1,5 +0,0 @@
-contract BadRecord =
-  entrypoint foo() =
-    let r = {x = 0, [0] = 1}
-    r{x = 0, [0] = 1}
-    r{}

test/contracts/bad_state.aes

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

test/contracts/bad_top_level_decl.aes

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

test/contracts/bad_unnamed_map_update_default.aes

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

test/contracts/basic_auth.aes

@@ -2,18 +2,18 @@
 contract BasicAuth =
   record state = { nonce : int, owner : address }
 
-  entrypoint init() = { nonce = 1, owner = Call.caller }
+  function init() = { nonce = 1, owner = Call.caller }
 
-  stateful entrypoint authorize(n : int, s : signature) : bool =
+  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.verify_sig(to_sign(tx_hash, n), state.owner, s)
+      Some(tx_hash) => Crypto.ecverify(to_sign(tx_hash, n), state.owner, s)
 
-  entrypoint to_sign(h : hash, n : int) =
+  function to_sign(h : hash, n : int) =
     Crypto.blake2b((h, n))
 
-  entrypoint weird_string() : string =
-    "\x19Weird String\x42\nMore\n"
+  private function require(b : bool, err : string) =
+    if(!b) abort(err)

test/contracts/basic_auth_tx.aes

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

test/contracts/bitcoin_auth.aes

@@ -1,9 +1,9 @@
 contract BitcoinAuth =
-  record state = { nonce : int, owner : bytes(20) }
+  record state = { nonce : int, owner : bytes(64) }
 
-  entrypoint init(owner' : bytes(20)) = { nonce = 1, owner = owner' }
+  function init(owner' : bytes(64)) = { nonce = 1, owner = owner' }
 
-  stateful entrypoint authorize(n : int, s : bytes(65)) : bool =
+  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 })
@@ -11,6 +11,8 @@ contract BitcoinAuth =
       None          => abort("Not in Auth context")
       Some(tx_hash) => Crypto.ecverify_secp256k1(to_sign(tx_hash, n), state.owner, s)
 
-  entrypoint to_sign(h : hash, n : int) : hash =
+  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/builtin_bug.aes

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

test/contracts/builtin_map_get_bug.aes

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

test/contracts/bytes_concat.aes

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

test/contracts/bytes_equality.aes

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

test/contracts/bytes_to_x.aes

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

test/contracts/calling_init_function.aes

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

test/contracts/channel_on_chain_contract_oracle.aes

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

test/contracts/clone.aes

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

test/contracts/clone_simple.aes

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

test/contracts/code_errors/bad_aens_resolve.aes

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

test/contracts/code_errors/child_with_decls.aes

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

test/contracts/code_errors/complex_compare.aes

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

test/contracts/code_errors/complex_compare_leq.aes

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

test/contracts/code_errors/higher_order_compare.aes

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

test/contracts/code_errors/higher_order_entrypoint.aes

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

test/contracts/code_errors/higher_order_entrypoint_return.aes

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

test/contracts/code_errors/higher_order_map_keys.aes

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

test/contracts/code_errors/higher_order_query_type.aes

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

test/contracts/code_errors/higher_order_response_type.aes

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

test/contracts/code_errors/higher_order_state.aes

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

test/contracts/code_errors/missing_definition.aes

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