Add constrained_t to fold

Co-authored-by: Radosław Rowicki <35342116+radrow@users.noreply.github.com>

.circleci/config.yml

@@ -3,11 +3,20 @@ version: 2.1
 executors:
   aebuilder:
     docker:
-      - image: aeternity/builder
+      - image: aeternity/builder:xenial-otp21
         user: builder
     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:
@@ -35,3 +44,10 @@ jobs:
             - _build/default/rebar3_20.3.8_plt
       - store_artifacts:
           path: _build/test/logs
+
+workflows:
+  version: 2
+  build_test:
+    jobs:
+      - build
+      - verify_rebar_lock

.docssite/hook.py

@@ -0,0 +1,7 @@
+import glob
+import shutil
+
+def pre_build(**kwargs):
+  for file in glob.glob('../docs/*.md'):
+    shutil.copy(file, 'docs')
+  shutil.copy('../CHANGELOG.md', 'docs')

.docssite/mkdocs.yml

@@ -0,0 +1,55 @@
+site_name: æternity Sophia Language
+plugins:
+  - search
+  - mkdocs-simple-hooks:
+      hooks:
+        on_pre_build: 'hook:pre_build'
+repo_url: 'https://github.com/aeternity/aesophia'
+edit_uri: ''
+
+extra:
+  version:
+    provider: mike
+
+theme:
+  favicon: favicon.png
+  name: material
+  custom_dir: overrides
+  language: en
+  palette:
+    - scheme: default
+      primary: pink
+      accent: pink
+      toggle:
+        icon: material/weather-night
+        name: Switch to dark mode
+    - scheme: slate
+      primary: pink
+      accent: pink
+      toggle:
+        icon: material/weather-sunny
+        name: Switch to light mode
+  features:
+    - content.tabs.link
+    - search.highlight
+    - search.share
+    - search.suggest
+
+  # Don't include MkDocs' JavaScript
+  include_search_page: false
+  search_index_only: true
+
+markdown_extensions:
+  - admonition
+  - pymdownx.highlight
+  - pymdownx.superfences
+  - toc:
+      toc_depth: 3
+
+nav:
+  - Introduction: index.md
+  - Syntax: sophia_syntax.md
+  - Features: sophia_features.md
+  - Standard library: sophia_stdlib.md
+  - Contract examples: sophia_examples.md
+  - Changelog: CHANGELOG.md

.docssite/overrides/main.html

@@ -0,0 +1,8 @@
+{% extends "base.html" %}
+
+{% block outdated %}
+  You're not viewing the latest version.
+  <a href="{{ '../' ~ base_url }}">
+    <strong>Click here to go to latest.</strong>
+  </a>
+{% endblock %}

.github/workflows/docs-develop.yml

@@ -0,0 +1,25 @@
+name: Publish development docs
+on:
+  push:
+    branches: ['master']
+      
+jobs:
+  main:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-python@v2
+        with:
+          python-version: 3.8
+      - uses: actions/cache@v2
+        with:
+          path: ~/.cache/pip3
+          key: ${{ runner.os }}-pip-${{ hashFiles('.github/workflows/requirements.txt') }}
+      - run: pip3 install -r .github/workflows/requirements.txt -U
+      - run: git config --global user.email "github-action@users.noreply.github.com"
+      - run: git config --global user.name "GitHub Action"
+      - run: |
+          cd .docssite
+          mike deploy --push master

.github/workflows/docs-release.yml

@@ -0,0 +1,26 @@
+name: Publish release docs
+on:
+  release:
+    types: [released]
+      
+jobs:
+  main:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-python@v2
+        with:
+          python-version: 3.8
+      - uses: actions/cache@v2
+        with:
+          path: ~/.cache/pip3
+          key: ${{ runner.os }}-pip-${{ hashFiles('.github/workflows/requirements.txt') }}
+      - run: pip3 install -r .github/workflows/requirements.txt -U
+      - run: git config --global user.email "github-action@users.noreply.github.com"
+      - run: git config --global user.name "GitHub Action"
+      - run: echo "RELEASE_VERSION=${GITHUB_REF:10}" >> $GITHUB_ENV
+      - run: |
+          cd .docssite
+          mike deploy --push --update-aliases $RELEASE_VERSION latest

.github/workflows/requirements.txt

@@ -0,0 +1,5 @@
+mkdocs==1.2.4
+mkdocs-simple-hooks==0.1.3
+mkdocs-material==7.1.9
+mike==1.0.1
+pygments==2.11.2

.gitignore

@@ -21,3 +21,6 @@ rebar3.crashdump
 aesophia
 .qcci
 current_counterexample.eqc
+test/contracts/test.aes
+__pycache__
+.docssite/docs/*.md

CHANGELOG.md

@@ -6,13 +6,216 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 ### Added
-- Added the `[a..b]` language construct, returning the list of numbers between
-  `a` and `b` (inclusive). Returns the empty list if `a` > `b`.
+- Compiler warnings for the follwing: shadowing, negative spends, division by zero, unused functions, unused includes, unused stateful annotations, unused variables, unused parameters, unused user-defined type, dead return value.
+- The pipe operator |>
+  ```
+  [1, 2, 3] |> List.first |> Option.is_some  // Option.is_some(List.first([1, 2, 3]))
+  ```
+- Allow binary operators to be used as lambdas
+  ```
+  function sum(l : list(int)) : int = foldl((+), 0, l)
+  function logical_and(x, y) = (&&)(x, y)
+  ```
+- Add comparable typevar constraints (`ord` and `eq`)
+  ```
+  lt : 'a is ord ; ('a, 'a) => bool
+  lt(x, y) = x < y
+
+  is_eq : 'a is eq ; ('a, 'a) => bool
+  is_eq(x, y) = x == y
+  ```
 ### Changed
+- Error messages have been restructured (less newlines) to provide more unified errors. Also `pp_oneline/1` has been added.
+- Ban empty record definitions (e.g. `record r = {}` would give an error).
+### Removed
+- Support for AEVM has been entirely wiped
+
+## [6.1.0] - 2021-10-20
+### Added
+- `Bitwise` stdlib
+- `Set` stdlib
+- `Option.force_msg`
+- Loading namespaces into the current scope (e.g. `using Pair`)
+- Assign patterns to variables (e.g. `let x::(t = y::_) = [1, 2, 3, 4]` where `t == [2, 3, 4]`)
+- Add builtin types (`AENS.name, AENS.pointee, Chain.ttl, Chain.base_tx, Chain.ga_meta_tx, Chain.paying_for_tx`) to
+  the calldata and result decoder
+- Patterns guards
+  ```
+  switch(x)
+    a::[] | a > 10 => 1
+    _              => 2
+  ```
+  ```
+  function
+    f(a::[]) | a > 10 = 1
+    f(_)              = 2
+  ```
+### Changed
+- Fixed the ACI renderer, it shouldn't drop the `stateful` modifier
+
+## [6.0.2] 2021-07-05
+### Changed
+- `List.from_to_step` now forbids non-positive step (this change does
+  *not* alter the behavior of the previously deployed contracts)
+- Fixed leaking state between contracts
+
+## [6.0.1] 2021-06-24
+### Changed
+- Fixed a bug in calldata encoding for contracts containing multiple contracts
+- Fixed a missing `include` in the `Frac` standard library
+
+## [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
 
-## [4.0.0-rc1] - 2019-08-22
+## [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.
@@ -29,6 +232,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   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,
@@ -136,8 +353,16 @@ 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/v4.0.0-rc1...HEAD
-[4.0.0-rc1]: https://github.com/aeternity/aesophia/compare/v3.2.0...v4.0.0-rc1
+[Unreleased]: https://github.com/aeternity/aesophia/compare/v6.1.0...HEAD
+[6.1.0]: https://github.com/aeternity/aesophia/compare/v6.0.2...v6.1.0
+[6.0.2]: https://github.com/aeternity/aesophia/compare/v6.0.1...v6.0.2
+[6.0.1]: https://github.com/aeternity/aesophia/compare/v6.0.0...v6.0.1
+[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

LICENSE

@@ -1,6 +1,6 @@
 ISC License
 
-Copyright (c) 2017, aeternity developers
+Copyright (c) 2017, æternity developers
 
 Permission to use, copy, modify, and/or distribute this software for any
 purpose with or without fee is hereby granted, provided that the above

README.md

@@ -1,25 +1,34 @@
 # aesophia
 
-This is the __sophia__ compiler for the æternity system which compiles contracts written in __sophia__ code to the æternity VM code.
+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.
 
-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).
+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 [æternity node](https://github.com/aeternity/aeternity) tests
 
-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.
+## Documentation
+
+* [Introduction](docs/index.md)
+* [Syntax](docs/sophia_syntax.md)
+* [Features](docs/sophia_features.md)
+* [Standard library](docs/sophia_stdlib.md)
+* [Contract examples](docs/sophia_examples.md)
+
+Additionally you can check out the [contracts section](https://github.com/aeternity/protocol/blob/master/contracts/contracts.md) of the æternity blockchain specification.
 
 ## Versioning
 
-`aesophia` has a version that is only loosely connected to the version of the
-Aeternity node - in principle they will share the major version but not
-minor/patch version. The `aesophia` compiler version MUST be bumped whenever
-there is a change in how byte code is generated, but it MAY also be bumped upon
-API changes etc.
+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
+
 
 ## Interface Modules
 
 The basic modules for interfacing the compiler:
 
-* [aeso_compiler: the Sophia compiler](./docs/aeso_compiler.md)
-* [aeso_aci: the ACI interface](./docs/aeso_aci.md)
+* [aeso_compiler: the Sophia compiler](docs/aeso_compiler.md)
+* [aeso_aci: the ACI interface](docs/aeso_aci.md)

docs/aeso_compiler.md

@@ -49,12 +49,8 @@ The **pp_** options all print to standard output the following:
 
 `pp_typed_ast` - print the AST with type information at each node
 
-`pp_icode` - print the internal code structure
-
 `pp_assembler` - print the generated assembler code
 
-`pp_bytecode` - print the bytecode instructions
-
 #### check_call(ContractString, Options) -> CheckRet
 
 Types
@@ -66,15 +62,6 @@ Type = term()
 ```
 Check a call in contract through the `__call` function.
 
-#### sophia_type_to_typerep(String) -> TypeRep
-
-Types
-``` erlang
- {ok,TypeRep} | {error, badtype}
-```
-
-Get the type representation of a type declaration.
-
 #### version() -> {ok, Version} | {error, term()}
 
 Types

docs/index.md

@@ -0,0 +1,12 @@
+# Introduction
+Sophia is a functional language designed for smart contract development. It is strongly typed and has
+restricted mutable state.
+
+Sophia is customized for smart contracts, which can be published
+to a blockchain. Thus some features of conventional
+languages, such as floating point arithmetic, are not present in Sophia, and
+some [æternity blockchain](https://aeternity.com) specific primitives, constructions and types have been added.
+
+!!! Note
+    - For rapid prototyping of smart contracts check out [AEstudio](https://studio.aepps.com/)!
+    - For playing around and diving deeper into the language itself check out the [REPL](https://repl.aeternity.io/)!

docs/sophia.md

@@ -0,0 +1 @@
+This file has been moved [here](sophia_features.md)

docs/sophia_examples.md

@@ -0,0 +1,73 @@
+# Contract examples
+
+## Crowdfunding
+```sophia
+/*
+ * A simple crowd-funding example
+ */
+contract FundMe =
+
+  record spend_args = { recipient : address,
+                        amount    : int }
+
+  record state = { contributions : map(address, int),
+                   total         : int,
+                   beneficiary   : address,
+                   deadline      : int,
+                   goal          : int }
+
+  stateful function spend(args : spend_args) =
+    Chain.spend(args.recipient, args.amount)
+
+  entrypoint init(beneficiary, deadline, goal) : state =
+    { contributions = {},
+      beneficiary   = beneficiary,
+      deadline      = deadline,
+      total         = 0,
+      goal          = goal }
+
+  function is_contributor(addr) =
+    Map.member(addr, state.contributions)
+
+  stateful entrypoint contribute() =
+    if(Chain.block_height >= state.deadline)
+      spend({ recipient = Call.caller, amount = Call.value }) // Refund money
+      false
+    else
+      let amount =
+        switch(Map.lookup(Call.caller, state.contributions))
+          None    => Call.value
+          Some(n) => n + Call.value
+      put(state{ contributions[Call.caller] = amount,
+                 total @ tot = tot + Call.value })
+      true
+
+  stateful entrypoint withdraw() =
+    if(Chain.block_height < state.deadline)
+      abort("Cannot withdraw before deadline")
+    if(Call.caller == state.beneficiary)
+      withdraw_beneficiary()
+    elif(is_contributor(Call.caller))
+      withdraw_contributor()
+    else
+      abort("Not a contributor or beneficiary")
+
+  stateful function withdraw_beneficiary() =
+    require(state.total >= state.goal, "Project was not funded")
+    spend({recipient = state.beneficiary,
+           amount    = Contract.balance })
+
+  stateful function withdraw_contributor() =
+    if(state.total >= state.goal)
+      abort("Project was funded")
+    let to = Call.caller
+    spend({recipient = to,
+           amount    = state.contributions[to]})
+    put(state{ contributions @ c = Map.delete(to, c) })
+```
+
+## Repositories
+This is a list with repositories that include smart contracts written in Sophia:
+
+- [aepp-sophia-examples](https://github.com/aeternity/aepp-sophia-examples)
+    - A repository that contains lots of different examples. The functionality of these examples is - to some extent - also covered by tests written in JavaScript.

docs/sophia_features.md

@@ -0,0 +1,925 @@
+# Features
+## Contracts
+
+The main unit of code in Sophia is the *contract*.
+
+- A contract implementation, or simply a contract, is the code for a
+  smart contract and consists of a list of types, entrypoints and local
+  functions. Only the entrypoints can be called from outside the contract.
+- A contract instance is an entity living on the block chain (or in a state
+  channel). Each instance has an address that can be used to call its
+  entrypoints, either from another contract or in a call transaction.
+- A contract may define a type `state` encapsulating its local
+  state. When creating a new contract the `init` entrypoint is executed and the
+  state is initialized to its return value.
+
+The language offers some primitive functions to interact with the blockchain and contracts.
+Please refer to the [Chain](sophia_stdlib.md#chain), [Contract](sophia_stdlib.md#contract)
+and the [Call](sophia_stdlib.md#call) namespaces in the documentation.
+
+### Calling other contracts
+
+To call a function in another contract you need the address to an instance of
+the contract. The type of the address must be a contract type, which consists
+of a number of type definitions and entrypoint declarations. For instance,
+
+```sophia
+// A contract type
+contract interface VotingType =
+  entrypoint vote : string => unit
+```
+
+Now given contract address of type `VotingType` you can call the `vote`
+entrypoint of that contract:
+
+```sophia
+contract VoteTwice =
+  entrypoint voteTwice(v : VotingType, alt : string) =
+    v.vote(alt)
+    v.vote(alt)
+```
+
+Contract calls take two optional named arguments `gas : int` and `value : int`
+that lets you set a gas limit and provide tokens to a contract call. If omitted
+the defaults are no gas limit and no tokens. Suppose there is a fee for voting:
+
+```sophia
+  entrypoint voteTwice(v : VotingType, fee : int, alt : string) =
+    v.vote(value = fee, alt)
+    v.vote(value = fee, alt)
+```
+
+Named arguments can be given in any order.
+
+Note that reentrant calls are not permitted. In other words, when calling
+another contract it cannot call you back (directly or indirectly).
+
+To construct a value of a contract type you can give a contract address literal
+(for instance `ct_2gPXZnZdKU716QBUFKaT4VdBZituK93KLvHJB3n4EnbrHHw4Ay`), or
+convert an account address to a contract address using `Address.to_contract`.
+Note that if the contract does not exist, or it doesn't have the entrypoint, or
+the type of the entrypoint does not match the stated contract type, the call
+fails.
+
+To recover the underlying `address` of a contract instance there is a field
+`address : address`. For instance, to send tokens to the voting contract (given that it is payable)
+without calling it you can write
+
+```sophia
+  entrypoint pay(v : VotingType, amount : int) =
+    Chain.spend(v.address, amount)
+```
+
+### 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`).
+
+The protected argument must be a literal boolean, and when set to `true`
+changes the type of the contract call, wrapping the result in an `option` type.
+If the call fails the result is `None`, otherwise it's `Some(r)` where `r` is
+the return value of the call.
+
+```sophia
+contract interface VotingType =
+  entrypoint : vote : string => unit
+
+contract Voter =
+  entrypoint tryVote(v : VotingType, alt : string) =
+    switch(v.vote(alt, protected = true) : option(unit))
+      None    => "Voting failed"
+      Some(_) => "Voting successful"
+```
+
+Any gas that was consumed by the contract call before the failure stays
+consumed, which means that in order to protect against the remote contract
+running out of gas it is necessary to set a gas limit using the `gas` argument.
+However, note that errors that would normally consume all the gas in the
+transaction still only uses up the gas spent running the contract.
+
+Any side effects (state change, token transfers, etc.) made by a failing
+protected call is rolled back, just like they would be in the unprotected case.
+
+
+### Contract factories and child contracts
+
+Since the version 6.0.0 Sophia supports deploying contracts by other
+contracts. This can be done in two ways:
+
+- Contract cloning via [`Chain.clone`](sophia_stdlib.md#clone)
+- Direct deploy via [`Chain.create`](sophia_stdlib.md#create)
+
+These functions take variable number of arguments that must match the created
+contract's `init` function. Beside that they take some additional named
+arguments – please refer to their documentation for the details.
+
+While `Chain.clone` requires only a `contract interface` and a living instance
+of a given contract on the chain, `Chain.create` needs a full definition of a
+to-create contract defined by the standard `contract` syntax, for example
+
+```sophia
+contract IntHolder =
+  type state = int
+  entrypoint init(x) = x
+  entrypoint get() = state
+
+main contract IntHolderFactory =
+  stateful entrypoint new(x : int) : IntHolder =
+    let ih = Chain.create(x) : IntHolder
+    ih
+```
+
+In case of a presence of child contracts (`IntHolder` in this case), the main
+contract must be pointed out with the `main` keyword as shown in the example.
+
+
+## Mutable state
+
+Sophia does not have arbitrary mutable state, but only a limited form of state
+associated with each contract instance.
+
+- Each contract defines a type `state` encapsulating its mutable state.
+  The type `state` defaults to the `unit`.
+- The initial state of a contract is computed by the contract's `init`
+  function. The `init` function is *pure* and returns the initial state as its
+  return value.
+  If the type `state` is `unit`, the `init` function defaults to returning the value `()`.
+  At contract creation time, the `init` function is executed and
+  its result is stored as the contract state.
+- The value of the state is accessible from inside the contract
+  through an implicitly bound variable `state`.
+- State updates are performed by calling a function `put : state => unit`.
+- Aside from the `put` function (and similar functions for transactions
+  and events), the language is purely functional.
+- Functions modifying the state need to be annotated with the `stateful` keyword (see below).
+
+To make it convenient to update parts of a deeply nested state Sophia
+provides special syntax for map/record updates.
+
+### Stateful functions
+
+Top-level functions and entrypoints must be annotated with the
+`stateful` keyword to be allowed to affect the state of the running contract.
+For instance,
+
+```sophia
+  stateful entrypoint set_state(s : state) =
+    put(s)
+```
+
+Without the `stateful` annotation the compiler does not allow the call to
+`put`. A `stateful` annotation is required to
+
+* Use a stateful primitive function. These are
+  - `put`
+  - `Chain.spend`
+  - `Oracle.register`
+  - `Oracle.query`
+  - `Oracle.respond`
+  - `Oracle.extend`
+  - `AENS.preclaim`
+  - `AENS.claim`
+  - `AENS.transfer`
+  - `AENS.revoke`
+  - `AENS.update`
+* Call a `stateful` function in the current contract
+* Call another contract with a non-zero `value` argument.
+
+A `stateful` annotation *is not* required to
+
+* Read the contract state.
+* Issue an event using the `event` function.
+* Call another contract with `value = 0`, even if the called function is stateful.
+
+## Payable
+
+### Payable contracts
+
+A concrete contract is by default *not* payable. Any attempt at spending to such
+a contract (either a `Chain.spend` or a normal spend transaction) will fail. If a
+contract shall be able to receive funds in this way it has to be declared `payable`:
+
+```sophia
+// A payable contract
+payable contract ExampleContract =
+  stateful entrypoint do_stuff() = ...
+```
+
+If in doubt, it is possible to check if an address is payable using
+`Address.is_payable(addr)`.
+
+### Payable entrypoints
+
+A contract entrypoint is by default *not* payable. Any call to such a function
+(either a [Remote call](#calling-other-contracts) or a contract call transaction)
+that has a non-zero `value` will fail. Contract entrypoints that should be called
+with a non-zero value should be declared `payable`.
+
+```sophia
+payable stateful entrypoint buy(to : address) =
+  if(Call.value > 42)
+    transfer_item(to)
+  else
+    abort("Value too low")
+```
+
+## Namespaces
+
+Code can be split into libraries using the `namespace` construct. Namespaces
+can appear at the top-level and can contain type and function definitions, but
+not entrypoints. Outside the namespace you can refer to the (non-private) names
+by qualifying them with the namespace (`Namespace.name`).
+For example,
+
+```sophia
+namespace Library =
+  type number = int
+  function inc(x : number) : number = x + 1
+
+contract MyContract =
+  entrypoint plus2(x) : Library.number =
+    Library.inc(Library.inc(x))
+```
+
+Functions in namespaces have access to the same environment (including the
+`Chain`, `Call`, and `Contract`, builtin namespaces) as function in a contract,
+with the exception of `state`, `put` and `Chain.event` since these are
+dependent on the specific state and event types of the contract.
+
+To avoid mentioning the namespace every time it is used, Sophia allows
+including the namespace in the current scope with the `using` keyword:
+```
+include "Pair.aes"
+using Pair
+contract C =
+  type state = int
+  entrypoint init() =
+    let p = (1, 2)
+    fst(p)  // this is the same as Pair.fst(p)
+```
+
+It is also possible to make an alias for the namespace with the `as` keyword:
+```
+include "Pair.aes"
+contract C =
+  using Pair as P
+  type state = int
+  entrypoint init() =
+    let p = (1, 2)
+    P.fst(p)  // this is the same as Pair.fst(p)
+```
+
+Having the same alias for multiple namespaces is possible and it allows
+referening functions that are defined in different namespaces and have
+different names with the same alias:
+```
+namespace Xa = function f() = 1
+namespace Xb = function g() = 2
+contract Cntr =
+  using Xa as A
+  using Xb as A
+  type state = int
+  entrypoint init() = A.f() + A.g()
+```
+
+Note that using functions with the same name would result in an ambiguous name
+error:
+```
+namespace Xa = function f() = 1
+namespace Xb = function f() = 2
+contract Cntr =
+  using Xa as A
+  using Xb as A
+  type state = int
+
+  // the next line has an error because f is defined in both Xa and Xb
+  entrypoint init() = A.f()
+```
+
+Importing specific parts of a namespace or hiding these parts can also be
+done like this:
+```
+using Pair for [fst, snd]       // this will only import fst and snd
+using Triple hiding [fst, snd]  // this will import everything except for fst and snd
+```
+
+Note that it is possible to use a namespace in the top level of the file, in the
+contract level, namespace level, or in the function level.
+
+## Splitting code over multiple files
+
+Code from another file can be included in a contract using an `include`
+statement. These must appear at the top-level (outside the main contract). The
+included file can contain one or more namespaces and abstract contracts. For
+example, if the file `library.aes` contains
+
+```sophia
+namespace Library =
+  function inc(x) = x + 1
+```
+
+you can use it from another file using an `include`:
+
+```sophia
+include "library.aes"
+contract MyContract =
+  entrypoint plus2(x) = Library.inc(Library.inc(x))
+```
+
+This behaves as if the contents of `library.aes` was textually inserted into
+the file, except that error messages will refer to the original source
+locations. The language will try to include each file at most one time automatically,
+so even cyclic includes should be working without any special tinkering.
+
+## Standard library
+
+Sophia offers [standard library](sophia_stdlib.md) which exposes some
+primitive operations and some higher level utilities. The builtin
+namespaces like `Chain`, `Contract`, `Map`
+are included by default and are supported internally by the compiler.
+Others like `List`, `Frac`, `Option` need to be manually included using the
+`include` directive. For example
+```sophia
+include "List.aes"
+include "Pair.aes"
+-- Map is already there!
+
+namespace C =
+  entrypoint keys(m : map('a, 'b)) : list('a) =
+    List.map(Pair.fst, (Map.to_list(m)))
+```
+
+## Types
+Sophia has the following types:
+
+| Type                 | Description                                                                                 | Example                                                                       |
+|----------------------|---------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------|
+| int                  | A 2-complement integer                                                                      | ```-1```                                                                      |
+| char                 | A single character                                                                          | ```'c'```                                                                     |
+| address              | æternity address, 32 bytes                                                                  | ```Call.origin``` ```ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt``` |
+| bool                 | A Boolean                                                                                   | ```true```                                                                    |
+| bits                 | A bit field                                                                                 | ```Bits.none```                                                               |
+| bytes(n)             | A byte array with `n` bytes                                                                 | ```#fedcba9876543210```                                                       |
+| string               | An array of bytes                                                                           | ```"Foo"```                                                                   |
+| list                 | A homogeneous immutable singly linked list.                                                 | ```[1, 2, 3]```                                                               |
+| ('a, 'b) => 'c       | A function. Parentheses can be skipped if there is only one argument                        | ```(x : int, y : int) => x + y```                                             |
+| tuple                | An ordered heterogeneous array                                                              | ```(42, "Foo", true)```                                                       |
+| record               | An immutable key value store with fixed key names and typed values                          | ``` record balance = { owner: address, value: int } ```                       |
+| map                  | An immutable key value store with dynamic mapping of keys of one type to values of one type | ```type accounts = map(string, address)```                                    |
+| option('a)           | An optional value either None or Some('a)                                                   | ```Some(42)```                                                                |
+| state                | A user defined type holding the contract state                                              | ```record state = { owner: address, magic_key: bytes(4) }```                  |
+| event                | An append only list of blockchain events (or log entries)                                   | ```datatype event = EventX(indexed int, string)```                            |
+| hash                 | A 32-byte hash - equivalent to `bytes(32)`                                                  |                                                                               |
+| signature            | A signature - equivalent to `bytes(64)`                                                     |                                                                               |
+| Chain.ttl            | Time-to-live (fixed height or relative to current block)                                    | ```FixedTTL(1050)``` ```RelativeTTL(50)```                                    |
+| oracle('a, 'b)       | And oracle answering questions of type 'a with answers of type 'b                           | ```Oracle.register(acct, qfee, ttl)```                                        |
+| oracle_query('a, 'b) | A specific oracle query                                                                     | ```Oracle.query(o, q, qfee, qttl, rttl)```                                    |
+| contract             | A user defined, typed, contract address                                                     | ```function call_remote(r : RemoteContract) = r.fun()```                      |
+
+## Literals
+| Type                 | Constant/Literal example(s)                                                                                                         |
+| ----------           | -------------------------------                                                                                                     |
+| int                  | `-1`, `2425`, `4598275923475723498573485768`                                                                                        |
+| address              | `ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt`                                                                             |
+| bool                 | `true`, `false`                                                                                                                     |
+| bits                 | `Bits.none`, `Bits.all`                                                                                                             |
+| bytes(8)             | `#fedcba9876543210`                                                                                                                 |
+| string               | `"This is a string"`                                                                                                                |
+| list                 | `[1, 2, 3]`, `[(true, 24), (false, 19), (false, -42)]`                                                                              |
+| tuple                | `(42, "Foo", true)`                                                                                                                 |
+| record               | `{ owner = Call.origin, value = 100000000 }`                                                                                        |
+| map                  | `{["foo"] = 19, ["bar"] = 42}`, `{}`                                                                                                |
+| option(int)          | `Some(42)`, `None`                                                                                                                  |
+| state                | `state{ owner = Call.origin, magic_key = #a298105f }`                                                                               |
+| event                | `EventX(0, "Hello")`                                                                                                                |
+| hash                 | `#000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f`                                                                 |
+| signature            | `#000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f` |
+| Chain.ttl            | `FixedTTL(1050)`, `RelativeTTL(50)`                                                                                                 |
+| oracle('a, 'b)       | `ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5`                                                                             |
+| oracle_query('a, 'b) | `oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY`                                                                             |
+| contract             | `ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ`                                                                              |
+
+## Arithmetic
+
+Sophia integers (`int`) are represented by arbitrary-sized signed words and support the following
+arithmetic operations:
+- addition (`x + y`)
+- subtraction (`x - y`)
+- multiplication (`x * y`)
+- division (`x / y`), truncated towards zero
+- remainder (`x mod y`), satisfying `y * (x / y) + x mod y == x` for non-zero `y`
+- exponentiation (`x ^ y`)
+
+All operations are *safe* with respect to overflow and underflow. 
+The division and modulo operations throw an arithmetic error if the
+right-hand operand is zero.
+
+## Bit fields
+
+Sophia integers do not support bit arithmetic. Instead there is a separate
+type `bits`. See the standard library [documentation](sophia_stdlib.md#bits).
+
+A bit field can be of arbitrary size (but it is still represented by the
+corresponding integer, so setting very high bits can be expensive).
+
+## Type aliases
+
+Type aliases can be introduced with the `type` keyword and can be
+parameterized. For instance
+
+```sophia
+type number = int
+type string_map('a) = map(string, 'a)
+```
+
+A type alias and its definition can be used interchangeably. Sophia does not support
+higher-kinded types, meaning that following type alias is invalid: `type wrap('f, 'a) = 'f('a)`
+
+## Algebraic data types
+
+Sophia supports algebraic data types (variant types) and pattern matching. Data
+types are declared by giving a list of constructors with
+their respective arguments. For instance,
+
+```sophia
+datatype one_or_both('a, 'b) = Left('a) | Right('b) | Both('a, 'b)
+```
+
+Elements of data types can be pattern matched against, using the `switch` construct:
+
+```sophia
+function get_left(x : one_or_both('a, 'b)) : option('a) =
+  switch(x)
+    Left(x)    => Some(x)
+    Right(_)   => None
+    Both(x, _) => Some(x)
+```
+
+or directly in the left-hand side:
+```sophia
+function
+  get_left : one_or_both('a, 'b) => option('a)
+  get_left(Left(x))    = Some(x)
+  get_left(Right(_))   = None
+  get_left(Both(x, _)) = Some(x)
+```
+
+*NOTE: Data types cannot currently be recursive.*
+
+Sophia also supports the assignment of patterns to variables:
+```sophia
+function f(x) = switch(x)
+  h1::(t = h2::_) => (h1 + h2)::t  // same as `h1::h2::k => (h1 + h2)::h2::k`
+  _ => x
+
+function g(p : int * option(int)) : int =
+  let (a, (o = Some(b))) = p  // o is equal to Pair.snd(p)
+  b
+```
+
+Guards are boolean expressions that can be used on patterns in both switch
+statements and functions definitions. If a guard expression evaluates to
+`true`, then the corresponding body will be used. Otherwise, the next pattern
+will be checked:
+
+```sophia
+function get_left_if_positive(x : one_or_both(int, 'b)) : option(int) =
+  switch(x)
+    Left(x)    | x > 0 => Some(x)
+    Both(x, _) | x > 0 => Some(x)
+    _                  => None
+```
+
+```sophia
+function
+  get_left_if_positive : one_or_both(int, 'b) => option(int)
+  get_left_if_positive(Left(x))    | x > 0 = Some(x)
+  get_left_if_positive(Both(x, _)) | x > 0 = Some(x)
+  get_left_if_positive(_)                  = None
+```
+
+Guards cannot be stateful even when used inside a stateful function.
+
+## Comparable types
+
+Only certain types are allowed to be compared by equality (`==`, `!=`) and
+inequality (`<`, `>`, `=<`, `>=`). For instance, while it is legal to compare
+integers, comparing functions would lead to an error:
+
+```
+function f() = 
+  f == f  // type error
+```
+
+The rules apply as follows:
+
+- All types that are comparable by inequality are also comparable by equality.
+- The builtin types `bool`, `int`, `char`, `bits`, `bytes`, `string`, `unit`,
+  `hash`, `address` and `signature` are comparable by inequality (and thus by
+  equality).
+- The composite types `list`, `option`, and tuples are comparable by
+  equality/inequality if their type parameters are comparable by
+  equality/inequality.
+- The composite types `map`, `oracle`, and `oracle_query` are comparable by
+  equality if their type parameters are comparable by equality.
+- User-defined records and datatypes are comparable by equality if their type
+  parameters are comparable by equality.
+- Smart contracts are comparable by equality.
+- User-declared type variables are comparable according to the [type
+  constraints](#type-constraints) given in the function signature.
+
+In all other cases the types are not comparable.
+
+### Type constraints
+
+Polymorphic types are not declared as comparable by default. If the user
+specifies the type signature for a function, they need to manually declare type
+constraints in order to allow the variables to be compared. This can only be
+done if the type declaration is separated from the function definition. The
+constraints have to be prepended to the type declaration and separated with a
+semicolon:
+
+```
+
+function eq(x : 'a, y : 'a) = x == y  // Type error, 'a is not comparable
+
+function
+  eq : 'a is eq ; ('a, 'a) => bool
+  eq(x, y) = x == y                   // Compiles
+
+function eq(x, y) = x == y            // Compiles as the constraints are inferred
+```
+
+Currently only two constraints are allowed: `eq` for equality and `ord` for
+inequality. Declaring a type as `ord` automatically implies `eq`.
+
+## Lists
+
+A Sophia list is a dynamically sized, homogenous, immutable, singly
+linked list. A list is constructed with the syntax `[1, 2, 3]`. The
+elements of a list can be any of datatype but they must have the same
+type. The type of lists with elements of type `'e` is written
+`list('e)`. For example we can have the following lists:
+
+```sophia
+[1, 33, 2, 666]                                                   : list(int)
+[(1, "aaa"), (10, "jjj"), (666, "the beast")]                     : list(int * string)
+[{[1] = "aaa", [10] = "jjj"}, {[5] = "eee", [666] = "the beast"}] : list(map(int, string))
+```
+
+New elements can be prepended to the front of a list with the `::`
+operator. So `42 :: [1, 2, 3]` returns the list `[42, 1, 2, 3]`. The
+concatenation operator `++` appends its second argument to its first
+and returns the resulting list. So concatenating two lists
+`[1, 22, 33] ++ [10, 18, 55]` returns the list `[1, 22, 33, 10, 18, 55]`.
+
+Sophia supports list comprehensions known from languages like Python, Haskell or Erlang.
+Example syntax:
+```sophia
+[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]
+```
+
+Lists can be constructed using the range syntax using special `..` operator:
+```sophia
+[1..4] == [1,2,3,4]
+```
+The ranges are always ascending and have step equal to 1.
+
+
+Please refer to the [standard library](sophia_stdlib.md#list) for the predefined functionalities.
+
+## Maps and records
+
+A Sophia record type is given by a fixed set of fields with associated,
+possibly different, types. For instance
+```sophia
+  record account = { name    : string,
+                     balance : int,
+                     history : list(transaction) }
+```
+
+Maps, on the other hand, can contain an arbitrary number of key-value bindings,
+but of a fixed type. The type of maps with keys of type `'k` and values of type
+`'v` is written `map('k, 'v)`. The key type can be any type that does not
+contain a map or a function type.
+
+Please refer to the [standard library](sophia_stdlib.md#map) for the predefined functionalities.
+
+### Constructing maps and records
+
+A value of record type is constructed by giving a value for each of the fields.
+For the example above,
+```sophia
+  function new_account(name) =
+    {name = name, balance = 0, history = []}
+```
+Maps are constructed similarly, with keys enclosed in square brackets
+```sophia
+  function example_map() : map(string, int) =
+    {["key1"] = 1, ["key2"] = 2}
+```
+The empty map is written `{}`.
+
+### Accessing values
+
+Record fields access is written `r.f` and map lookup `m[k]`. For instance,
+```sophia
+  function get_balance(a : address, accounts : map(address, account)) =
+    accounts[a].balance
+```
+Looking up a non-existing key in a map results in contract execution failing. A
+default value to return for non-existing keys can be provided using the syntax
+`m[k = default]`. See also `Map.member` and `Map.lookup` below.
+
+### Updating a value
+
+Record field updates are written `r{f = v}`. This creates a new record value
+which is the same as `r`, but with the value of the field `f` replaced by `v`.
+Similarly, `m{[k] = v}` constructs a map with the same values as `m` except
+that `k` maps to `v`. It makes no difference if `m` has a mapping for `k` or
+not.
+
+It is possible to give a name to the old value of a field or mapping in an
+update: instead of `acc{ balance = acc.balance + 100 }` it is possible to write
+`acc{ balance @ b = b + 100 }`, binding `b` to `acc.balance`. When giving a
+name to a map value (`m{ [k] @ x = v }`), the corresponding key must be present
+in the map or execution fails, but a default value can be provided:
+`m{ [k = default] @ x = v }`. In this case `x` is bound to `default` if
+`k` is not in the map.
+
+Updates can be nested:
+```sophia
+function clear_history(a : address, accounts : map(address, account)) : map(address, account) =
+  accounts{ [a].history = [] }
+```
+This is equivalent to `accounts{ [a] @ acc = acc{ history = [] } }` and thus
+requires `a` to be present in the accounts map. To have `clear_history` create
+an account if `a` is not in the map you can write (given a function `empty_account`):
+```sophia
+  accounts{ [a = empty_account()].history = [] }
+```
+
+### Map implementation
+
+Internally in the VM maps are implemented as hash maps and support fast lookup
+and update. Large maps can be stored in the contract state and the size of the
+map does not contribute to the gas costs of a contract call reading or updating
+it.
+
+## Strings
+
+There is a builtin type `string`, which can be seen as an array of bytes.
+Strings can be compared for equality (`==`, `!=`), used as keys in maps and
+records, and used in builtin functions `String.length`, `String.concat` and
+the hash functions described below.
+
+Please refer to the `String` [library documentation](sophia_stdlib.md#string).
+
+## Chars
+
+There is a builtin type `char` (the underlying representation being an integer),
+mainly used to manipulate strings via `String.to_list`/`String.from_list`.
+
+Characters can also be introduced as character literals (`'x', '+', ...).
+
+Please refer to the `Char` [library documentation](sophia_stdlib.md#char).
+
+## Byte arrays
+
+Byte arrays are fixed size arrays of 8-bit integers. They are described in hexadecimal system,
+for example the literal `#cafe` creates a two-element array of bytes `ca` (202) and `fe` (254)
+and thus is a value of type `bytes(2)`.
+
+Please refer to the `Bytes` [library documentation](sophia_stdlib.md#bytes).
+
+## Cryptographic builtins
+
+Libraries [Crypto](sophia_stdlib.md#crypto) and [String](sophia_stdlib.md#string) provide functions to
+hash objects, verify signatures etc. The `hash` is a type alias for `bytes(32)`.
+
+## Authorization interface
+
+When a Generalized account is authorized, the authorization function needs
+access to the transaction and the transaction hash for the wrapped transaction. (A `GAMetaTx`
+wrapping a transaction.) The transaction and the transaction hash is available in the primitive
+`Auth.tx` and `Auth.tx_hash` respectively, they are *only* available during authentication if invoked by a
+normal contract call they return `None`.
+
+## Oracle interface
+You can attach an oracle to the current contract and you can interact with oracles
+through the Oracle interface.
+
+For a full description of how Oracle works see
+[Oracles](https://github.com/aeternity/protocol/blob/master/oracles/oracles.md#oracles).
+For a functionality documentation refer to the [standard library](sophia_stdlib.md#oracle).
+
+### Example
+
+Example for an oracle answering questions of type `string` with answers of type `int`:
+```sophia
+contract Oracles =
+
+  stateful entrypoint registerOracle(acct : address,
+                                     sign : signature,   // Signed network id + oracle address + contract address
+                                     qfee : int,
+                                     ttl  : Chain.ttl) : oracle(string, int) =
+     Oracle.register(acct, signature = sign, qfee, ttl)
+
+  entrypoint queryFee(o : oracle(string, int)) : int =
+    Oracle.query_fee(o)
+
+  payable stateful entrypoint createQuery(o    : oracle_query(string, int),
+                                          q    : string,
+                                          qfee : int,
+                                          qttl : Chain.ttl,
+                                          rttl : int) : oracle_query(string, int) =
+    require(qfee =< Call.value, "insufficient value for qfee")
+    Oracle.query(o, q, qfee, qttl, RelativeTTL(rttl))
+
+  stateful entrypoint extendOracle(o   : oracle(string, int),
+                                   ttl : Chain.ttl) : unit =
+    Oracle.extend(o, ttl)
+
+  stateful entrypoint signExtendOracle(o    : oracle(string, int),
+                                       sign : signature,   // Signed network id + oracle address + contract address
+                                       ttl  : Chain.ttl) : unit =
+    Oracle.extend(o, signature = sign, ttl)
+
+  stateful entrypoint respond(o    : oracle(string, int),
+                              q    : oracle_query(string, int),
+                              sign : signature,        // Signed network id + oracle query id + contract address
+                              r    : int) =
+    Oracle.respond(o, q, signature = sign, r)
+
+  entrypoint getQuestion(o : oracle(string, int),
+                         q : oracle_query(string, int)) : string =
+    Oracle.get_question(o, q)
+
+  entrypoint hasAnswer(o : oracle(string, int),
+                       q : oracle_query(string, int)) =
+    switch(Oracle.get_answer(o, q))
+      None    => false
+      Some(_) => true
+
+  entrypoint getAnswer(o : oracle(string, int),
+                       q : oracle_query(string, int)) : option(int) =
+    Oracle.get_answer(o, q)
+```
+
+### Sanity checks
+
+When an Oracle literal is passed to a contract, no deep checks are performed.
+For extra safety [Oracle.check](sophia_stdlib.md#check) and [Oracle.check_query](sophia_stdlib.md#check_query)
+functions are provided.
+
+## AENS interface
+
+Contracts can interact with the
+[æternity naming system](https://github.com/aeternity/protocol/blob/master/AENS.md).
+For this purpose the [AENS](sophia_stdlib.md#aens) library was exposed.
+
+### Example
+
+In this example we assume that the name `name` already exists, and is owned by
+an account with address `addr`. In order to allow a contract `ct` to handle
+`name` the account holder needs to create a
+[signature](#delegation-signature) `sig` of `addr | name.hash | ct.address`.
+
+Armed with this information we can for example write a function that extends
+the name if it expires within 1000 blocks:
+```sophia
+  stateful entrypoint extend_if_necessary(addr : address, name : string, sig : signature) =
+    switch(AENS.lookup(name))
+      None => ()
+      Some(AENS.Name(_, FixedTTL(expiry), _)) =>
+        if(Chain.block_height + 1000 > expiry)
+          AENS.update(addr, name, Some(RelativeTTL(50000)), None, None, signature = sig)
+```
+
+And we can write functions that adds and removes keys from the pointers of the
+name:
+```sophia
+  stateful entrypoint add_key(addr : address, name : string, key : string,
+                              pt : AENS.pointee, sig : signature) =
+    switch(AENS.lookup(name))
+      None => ()
+      Some(AENS.Name(_, _, ptrs)) =>
+        AENS.update(addr, name, None, None, Some(ptrs{[key] = pt}), signature = sig)
+
+  stateful entrypoint delete_key(addr : address, name : string,
+                                 key : string, sig : signature) =
+    switch(AENS.lookup(name))
+      None => ()
+      Some(AENS.Name(_, _, ptrs)) =>
+        let ptrs = Map.delete(key, ptrs)
+        AENS.update(addr, name, None, None, Some(ptrs), signature = sig)
+```
+
+*Note:* From the Iris hardfork more strict rules apply for AENS pointers, when
+a Sophia contract lookup or update (bad) legacy pointers, the bad keys are
+automatically removed so they will not appear in the pointers map.
+
+## Events
+
+Sophia contracts log structured messages to an event log in the resulting
+blockchain transaction. The event log is quite similar to [Events in
+Solidity](https://solidity.readthedocs.io/en/v0.4.24/contracts.html#events).
+Events are further discussed in the [protocol](https://github.com/aeternity/protocol/blob/master/contracts/events.md).
+
+
+To use events a contract must declare a datatype `event`, and events are then
+logged using the `Chain.event` function:
+
+```sophia
+  datatype event
+    = Event1(int, int, string)
+    | Event2(string, address)
+
+  Chain.event(e : event) : unit
+```
+
+The event can have 0-3 *indexed* fields, and an optional *payload* field. A
+field is indexed if it fits in a 32-byte word, i.e.
+- `bool`
+- `int`
+- `bits`
+- `address`
+- `oracle(_, _)`
+- `oracle_query(_, _)`
+- contract types
+- `bytes(n)` for `n` ≤ 32, in particular `hash`
+
+The payload field must be either a string or a byte array of more than 32 bytes.
+The fields can appear in any order.
+
+*NOTE:* Indexing is not part of the core æternity node.
+
+Events are emitted by using the `Chain.event` function. The following function
+will emit one Event of each kind in the example.
+
+```sophia
+  entrypoint emit_events() : () =
+    Chain.event(Event1(42, 34, "foo"))
+    Chain.event(Event2("This is not indexed", Contract.address))
+```
+
+### Argument order
+
+It is only possible to have one (1) `string` parameter in the event, but it can
+be placed in any position (and its value will end up in the `data` field), i.e.
+```sophia
+AnotherEvent(string, indexed address)
+
+...
+
+Chain.event(AnotherEvent("This is not indexed", Contract.address))
+```
+would yield exactly the same result in the example above!
+
+## Compiler pragmas
+
+To enforce that a contract is only compiled with specific versions of the
+Sophia compiler, you can give one or more `@compiler` pragmas at the
+top-level (typically at the beginning) of a file. For instance, to enforce that
+a contract is compiled with version 4.3 of the compiler you write
+
+```sophia
+@compiler >= 4.3
+@compiler <  4.4
+```
+
+Valid operators in compiler pragmas are `<`, `=<`, `==`, `>=`, and `>`. Version
+numbers are given as a sequence of non-negative integers separated by dots.
+Trailing zeros are ignored, so `4.0.0 == 4`. If a constraint is violated an
+error is reported and compilation fails.
+
+## Exceptions
+
+Contracts can fail with an (uncatchable) exception using the built-in function
+
+```sophia
+abort(reason : string) : 'a
+```
+
+Calling abort causes the top-level call transaction to return an error result
+containing the `reason` string. Only the gas used up to and including the abort
+call is charged. This is different from termination due to a crash which
+consumes all available gas.
+
+For convenience the following function is also built-in:
+
+```sophia
+function require(b : bool, err : string) =
+    if(!b) abort(err)
+```
+
+## Delegation signature
+
+Some chain operations (`Oracle.<operation>` and `AENS.<operation>`) have an
+optional delegation signature. This is typically used when a user/accounts
+would like to allow a contract to act on it's behalf. The exact data to be
+signed varies for the different operations, but in all cases you should prepend
+the signature data with the `network_id` (`ae_mainnet` for the æternity mainnet, etc.).

docs/sophia_syntax.md

@@ -0,0 +1,267 @@
+# Syntax
+
+## Lexical syntax
+
+### Comments
+
+Single line comments start with `//` and block comments are enclosed in `/*`
+and `*/` and can be nested.
+
+### Keywords
+
+```
+contract elif else entrypoint false function if import include let mod namespace
+private payable stateful switch true type record datatype main interface
+```
+
+### Tokens
+
+- `Id = [a-z_][A-Za-z0-9_']*` identifiers start with a lower case letter.
+- `Con = [A-Z][A-Za-z0-9_']*` constructors start with an upper case letter.
+- `QId = (Con\.)+Id` qualified identifiers (e.g. `Map.member`)
+- `QCon = (Con\.)+Con` qualified constructor
+- `TVar = 'Id` type variable (e.g `'a`, `'b`)
+- `Int = [0-9]+(_[0-9]+)*|0x[0-9A-Fa-f]+(_[0-9A-Fa-f]+)*` integer literal with optional `_` separators
+- `Bytes = #[0-9A-Fa-f]+(_[0-9A-Fa-f]+)*` byte array literal with optional `_` separators
+- `String` string literal enclosed in `"` with escape character `\`
+- `Char` character literal enclosed in `'` with escape character `\`
+- `AccountAddress` base58-encoded 32 byte account pubkey with `ak_` prefix
+- `ContractAddress` base58-encoded 32 byte contract address with `ct_` prefix
+- `OracleAddress` base58-encoded 32 byte oracle address with `ok_` prefix
+- `OracleQueryId` base58-encoded 32 byte oracle query id with `oq_` prefix
+
+Valid string escape codes are
+
+| Escape        |       ASCII |   |
+|---------------|-------------|---|
+| `\b`          |           8 |   |
+| `\t`          |           9 |   |
+| `\n`          |          10 |   |
+| `\v`          |          11 |   |
+| `\f`          |          12 |   |
+| `\r`          |          13 |   |
+| `\e`          |          27 |   |
+| `\xHexDigits` | *HexDigits* |   |
+
+
+See the [identifier encoding scheme](https://github.com/aeternity/protocol/blob/master/node/api/api_encoding.md) for the
+details on the base58 literals.
+
+## Layout blocks
+
+Sophia uses Python-style layout rules to group declarations and statements. A
+layout block with more than one element must start on a separate line and be
+indented more than the currently enclosing layout block. Blocks with a single
+element can be written on the same line as the previous token.
+
+Each element of the block must share the same indentation and no part of an
+element may be indented less than the indentation of the block. For instance
+
+```sophia
+contract Layout =
+  function foo() = 0  // no layout
+  function bar() =    // layout block starts on next line
+    let x = foo()     // indented more than 2 spaces
+    x
+     + 1              // the '+' is indented more than the 'x'
+```
+
+## Notation
+
+In describing the syntax below, we use the following conventions:
+
+- Upper-case identifiers denote non-terminals (like `Expr`) or terminals with
+  some associated value (like `Id`).
+- Keywords and symbols are enclosed in single quotes: `'let'` or `'='`.
+- Choices are separated by vertical bars: `|`.
+- Optional elements are enclosed in `[` square brackets `]`.
+- `(` Parentheses `)` are used for grouping.
+- Zero or more repetitions are denoted by a postfix `*`, and one or more
+  repetitions by a `+`.
+- `Block(X)` denotes a layout block of `X`s.
+- `Sep(X, S)` is short for `[X (S X)*]`, i.e. a possibly empty sequence of `X`s
+  separated by `S`s.
+- `Sep1(X, S)` is short for `X (S X)*`, i.e. same as `Sep`, but must not be empty.
+
+
+## Declarations
+
+A Sophia file consists of a sequence of *declarations* in a layout block.
+
+```c
+File ::= Block(TopDecl)
+
+TopDecl ::= ['payable'] 'contract' Con '=' Block(Decl)
+       | 'namespace' Con '=' Block(Decl)
+       | '@compiler' PragmaOp Version
+       | 'include' String
+
+Decl ::= 'type'     Id ['(' TVar* ')'] '=' TypeAlias
+       | 'record'   Id ['(' TVar* ')'] '=' RecordType
+       | 'datatype' Id ['(' TVar* ')'] '=' DataType
+       | (EModifier* 'entrypoint' | FModifier* 'function') Block(FunDecl)
+
+FunDecl ::= Id ':' Type                             // Type signature
+          | Id Args [':' Type] '=' Block(Stmt)      // Definition
+
+PragmaOp ::= '<' | '=<' | '==' | '>=' | '>'
+Version  ::= Sep1(Int, '.')
+
+EModifier ::= 'payable' | 'stateful'
+FModifier ::= 'stateful' | 'private'
+
+Args ::= '(' Sep(Pattern, ',') ')'
+```
+
+Contract declarations must appear at the top-level.
+
+For example,
+```sophia
+contract Test =
+  type t = int
+  entrypoint add (x : t, y : t) = x + y
+```
+
+There are three forms of type declarations: type aliases (declared with the
+`type` keyword), record type definitions (`record`) and data type definitions
+(`datatype`):
+
+```c
+TypeAlias  ::= Type
+RecordType ::= '{' Sep(FieldType, ',') '}'
+DataType   ::= Sep1(ConDecl, '|')
+
+FieldType  ::= Id ':' Type
+ConDecl    ::= Con ['(' Sep1(Type, ',') ')']
+```
+
+For example,
+```sophia
+record   point('a) = {x : 'a, y : 'a}
+datatype shape('a) = Circle(point('a), 'a) | Rect(point('a), point('a))
+type     int_shape = shape(int)
+```
+
+## Types
+
+```c
+Type ::= Domain '=>' Type             // Function type
+       | Type '(' Sep(Type, ',') ')'  // Type application
+       | '(' Type ')'                 // Parens
+       | 'unit' | Sep(Type, '*')      // Tuples
+       | Id | QId | TVar
+
+Domain ::= Type                       // Single argument
+         | '(' Sep(Type, ',') ')'     // Multiple arguments
+```
+
+The function type arrow associates to the right.
+
+Example,
+```sophia
+'a => list('a) => (int * list('a))
+```
+
+## Statements
+
+Function bodies are blocks of *statements*, where a statement is one of the following
+
+```c
+Stmt ::= 'switch' '(' Expr ')' Block(Case)
+       | 'if' '(' Expr ')' Block(Stmt)
+       | 'elif' '(' Expr ')' Block(Stmt)
+       | 'else' Block(Stmt)
+       | 'let' LetDef
+       | Expr
+
+LetDef ::= Id Args [':' Type] '=' Block(Stmt)   // Function definition
+         | Pattern '=' Block(Stmt)              // Value definition
+
+Case    ::= Pattern '=>' Block(Stmt)
+Pattern ::= Expr
+```
+
+`if` statements can be followed by zero or more `elif` statements and an optional final `else` statement. For example,
+
+```sophia
+let x : int = 4
+switch(f(x))
+  None => 0
+  Some(y) =>
+    if(y > 10)
+      "too big"
+    elif(y < 3)
+      "too small"
+    else
+      "just right"
+```
+
+## Expressions
+
+```c
+Expr ::= '(' LamArgs ')' '=>' Block(Stmt)   // Anonymous function    (x) => x + 1
+       | '(' BinOp ')'                      // Operator lambda       (+)
+       | 'if' '(' Expr ')' Expr 'else' Expr // If expression         if(x < y) y else x
+       | Expr ':' Type                      // Type annotation       5 : int
+       | Expr BinOp Expr                    // Binary operator       x + y
+       | UnOp Expr                          // Unary operator        ! b
+       | Expr '(' Sep(Expr, ',') ')'        // Application           f(x, y)
+       | Expr '.' Id                        // Projection            state.x
+       | Expr '[' Expr ']'                  // Map lookup            map[key]
+       | Expr '{' Sep(FieldUpdate, ',') '}' // Record or map update  r{ fld[key].x = y }
+       | '[' Sep(Expr, ',') ']'             // List                  [1, 2, 3]
+       | '[' Expr '|' Sep(Generator, ',') ']'
+                                            // List comprehension    [k | x <- [1], if (f(x)), let k = x+1]
+       | '[' Expr '..' Expr ']'             // List range            [1..n]
+       | '{' Sep(FieldUpdate, ',') '}'      // Record or map value   {x = 0, y = 1}, {[key] = val}
+       | '(' Expr ')'                       // Parens                (1 + 2) * 3
+       | Id | Con | QId | QCon              // Identifiers           x, None, Map.member, AELib.Token
+       | Int | Bytes | String | Char        // Literals              123, 0xff, #00abc123, "foo", '%'
+       | AccountAddress | ContractAddress   // Chain identifiers
+       | OracleAddress | OracleQueryId      // Chain identifiers
+
+Generator ::= Pattern '<-' Expr   // Generator
+            | 'if' '(' Expr ')'   // Guard
+            | LetDef              // Definition
+
+LamArgs ::= '(' Sep(LamArg, ',') ')'
+LamArg  ::= Id [':' Type]
+
+FieldUpdate ::= Path '=' Expr
+Path ::= Id                 // Record field
+       | '[' Expr ']'       // Map key
+       | Path '.' Id        // Nested record field
+       | Path '[' Expr ']'  // Nested map key
+
+BinOp ::= '||' | '&&' | '<' | '>' | '=<' | '>=' | '==' | '!='
+        | '::' | '++' | '+' | '-' | '*' | '/' | 'mod' | '^'
+        | '|>'
+UnOp  ::= '-' | '!'
+```
+
+## Operators types
+
+| Operators | Type
+| --- | ---
+| `-` `+` `*` `/` `mod` `^` | arithmetic operators
+| `!` `&&` `\|\|` | logical operators
+| `==` `!=` `<` `>` `=<` `>=` | comparison operators
+| `::` `++` | list operators
+| `\|>` | functional operators
+
+## Operator precendences
+
+In order of highest to lowest precedence.
+
+| Operators | Associativity
+| --- | ---
+| `!` | right
+| `^` | left
+| `*` `/` `mod` | left
+| `-` (unary) | right
+| `+` `-` | left
+| `::` `++` | right
+| `<` `>` `=<` `>=` `==` `!=` | none
+| `&&` | right
+| `\|\|` | right
+| `\|>` | left

priv/stdlib/BLS12_381.aes

@@ -0,0 +1,68 @@
+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(us : list(g1), vs : list(g2)) =
+    switch((us, vs))
+      ([], []) => true
+      (x :: xs, y :: ys) => pairing_check_(pairing(x, y), xs, ys)
+
+  function pairing_check_(acc : gt, us : list(g1), vs : list(g2)) =
+    switch((us, vs))
+      ([], []) => 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/Bitwise.aes

@@ -0,0 +1,126 @@
+@compiler >= 4.3
+
+namespace Bitwise =
+
+  // bit shift 'x' right 'n' postions
+  function bsr(n : int, x : int) : int =
+    let step = 2^n
+    let res  = x / step
+    if (x >= 0 || x mod step == 0)
+      res
+    else
+      res - 1
+
+  // bit shift 'x' left 'n' positions
+  function bsl(n : int, x : int) : int =
+    x * 2^n
+
+  // bit shift 'x' left 'n' positions, limit at 'lim' bits
+  function bsli(n : int, x : int, lim : int) : int =
+    (x * 2^n) mod (2^lim)
+
+  // bitwise 'and' for arbitrary precision integers
+  function band(a : int, b : int) : int =
+      if (a >= 0 && b >= 0)
+        uband_(a, b)
+      elif (b >= 0)
+        ubnand_(b, -1 - a)
+      elif (a >= 0)
+        ubnand_(a, -1 - b)
+      else
+        -1 - ubor_(-1 - a, -1 - b)
+
+  // bitwise 'or' for arbitrary precision integers
+  function
+    bor : (int, int) => int
+    bor(0, b) = b
+    bor(a, 0) = a
+    bor(a : int, b : int) : int =
+      if (a >= 0 && b >= 0)
+        ubor_(a, b)
+      elif (b >= 0)
+        -1 - ubnand_(-1 - a, b)
+      elif (a >= 0)
+        -1 - ubnand_(-1 - b, a)
+      else
+        -1 - uband_(-1 - a, -1 - b)
+
+  // bitwise 'xor' for arbitrary precision integers
+  function
+    bxor : (int, int) => int
+    bxor(0, b) = b
+    bxor(a, 0) = a
+    bxor(a, b) =
+      if (a >= 0 && b >= 0)
+        ubxor_(a, b)
+      elif (b >= 0)
+        -1 - ubxor_(-1 - a, b)
+      elif (a >= 0)
+        -1 - ubxor_(a, -1 - b)
+      else
+        ubxor_(-1 - a, -1 - b)
+
+  // bitwise 'not' for arbitrary precision integers
+  function bnot(a : int) = bxor(a, -1)
+
+  // Bitwise 'and' for non-negative integers
+  function uband(a : int, b : int) : int =
+    require(a >= 0 && b >= 0, "uband is only defined for non-negative integers")
+    switch((a, b))
+      (0, _) => 0
+      (_, 0) => 0
+      _      => uband__(a, b, 1, 0)
+
+  private function uband_(a, b) = uband__(a, b, 1, 0)
+
+  private function
+    uband__(0, b, val, acc) = acc
+    uband__(a, 0, val, acc) = acc
+    uband__(a, b, val, acc) =
+      switch (a mod 2 + b mod 2)
+        2 => uband__(a / 2, b / 2, val * 2, acc + val)
+        _ => uband__(a / 2, b / 2, val * 2, acc)
+
+  // Bitwise 'or' for non-negative integers
+  function ubor(a, b) =
+    require(a >= 0 && b >= 0, "ubor is only defined for non-negative integers")
+    switch((a, b))
+      (0, _) => b
+      (_, 0) => a
+      _      => ubor__(a, b, 1, 0)
+
+  private function ubor_(a, b) = ubor__(a, b, 1, 0)
+
+  private function
+    ubor__(0, 0, val, acc) = acc
+    ubor__(a, b, val, acc) =
+      switch (a mod 2 + b mod 2)
+        0 => ubor__(a / 2, b / 2, val * 2, acc)
+        _ => ubor__(a / 2, b / 2, val * 2, acc + val)
+
+  //Bitwise 'xor' for non-negative integers
+  function
+    ubxor : (int, int) => int
+    ubxor(0, b) = b
+    ubxor(a, 0) = a
+    ubxor(a, b) =
+      require(a >= 0 && b >= 0, "ubxor is only defined for non-negative integers")
+      ubxor__(a, b, 1, 0)
+
+  private function ubxor_(a, b) = ubxor__(a, b, 1, 0)
+
+  private function
+    ubxor__(0, 0, val, acc) = acc
+    ubxor__(a, b, val, acc) =
+      switch(a mod 2 + b mod 2)
+        1 => ubxor__(a / 2, b / 2, val * 2, acc + val)
+        _ => ubxor__(a / 2, b / 2, val * 2, acc)
+
+  private function ubnand_(a, b) = ubnand__(a, b, 1, 0)
+
+  private function
+    ubnand__(0, b, val, acc) = acc
+    ubnand__(a, b, val, acc) =
+      switch((a mod 2, b mod 2))
+        (1, 0) => ubnand__(a / 2, b / 2, val * 2, acc + val)
+        _      => ubnand__(a / 2, b / 2, val * 2, acc)

priv/stdlib/Frac.aes

@@ -0,0 +1,185 @@
+include "String.aes"
+
+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

@@ -2,7 +2,7 @@ namespace Func =
 
   function id(x : 'a) : 'a = x
 
-  function const(x : 'a) : 'b => 'a = (y) => x
+  function const(x : 'a) : 'b => 'a = (_) => x
 
   function flip(f : ('a, 'b) => 'c) : ('b, 'a) => 'c = (b, a) => f(a, b)
 
@@ -12,35 +12,66 @@ namespace Func =
 
   function rapply(x : 'a, f : 'a => 'b) : 'b = f(x)
 
-  /* The Z combinator - replacement for local and anonymous recursion.
+/** 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))
 
-  function curry2(f : ('a, 'b) => 'c) : 'a => ('b => 'c) =
+/** 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) => 'd) : 'a => ('b => ('c => 'd)) =
+  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)
 
-  function uncurry2(f : 'a => ('b => 'c)) : ('a, 'b) => 'c =
+/** Opposite of curry. Gross
+ */
+  function uncurry2(f : 'a => ('b => 'x)) : ('a, 'b) => 'x =
     (x, y) => f(x)(y)
-  function uncurry3(f : 'a => ('b => ('c => 'd))) : ('a, 'b, 'c) => 'd =
+  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)
 
-  function tuplify2(f : ('a, 'b) => 'c) : (('a * 'b)) => 'c =
+/** 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) => 'd) : 'a * 'b * 'c => 'd =
+  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)
 
-  function untuplify2(f : 'a * 'b => 'c) : ('a, 'b) => 'c =
+/** Opposite of tuplify
+ */
+  function untuplify2(f : 'a * 'b => 'x) : ('a, 'b) => 'x =
     (x, y) => f((x, y))
-  function untuplify3(f : 'a * 'b * 'c => 'd) : ('a, 'b, 'c) => 'd =
+  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

@@ -19,26 +19,50 @@ namespace List =
     [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 : 'a is eq; ('a, list('a)) => bool
+    contains(e, l) = 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)
 
-  function find_indices(p : 'a => bool, l : list('a)) : list(int) = find_indices_(p, l, 0, [])
+/** 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
-                                , acc : list(int)
                                 ) : list(int) = switch(l)
-    []   => reverse(acc)
-    h::t => find_indices_(p, t, n+1, if(p(h)) n::acc else acc)
+    []   => []
+    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)
+  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("Out of index get")
+  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)
 
 
@@ -48,32 +72,55 @@ namespace List =
     _::t => length_(t, acc + 1)
 
 
-  /* Unsafe. Replaces `n`th element of `l` with `e`. Crashes on over/underflow */
+/** 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) =
+    require(s > 0, "List.from_to_step: non-positive step")
+    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), acc : 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) reverse(e::acc) ++ t
-             else replace_at_(n-1, e, t, h::acc)
+     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 */
+/** Unsafe. Adds `e` to `l` to be its `n`th element. Crashes on over/underflow
+ */
   function insert_at(n : int, e : 'a, l : list('a)) : list('a) =
-    if(n<0) abort("insert_at underflow") else insert_at_(n, e, l, [])
-  private function insert_at_(n : int, e : 'a, l : list('a), acc : list('a)) : list('a) =
-   if (n == 0) reverse(e::acc) ++ l
+    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 => insert_at_(n-1, e, t, h::acc)
+     h::t => h::insert_at_(n-1, e, t)
 
-  function insert_by(f : (('a, 'a) => bool), x : 'a, l : list('a)) : list('a) =
+/** 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]
-      (e :: l') =>
-        if(f(x, e))
-          e :: insert_by(f, x, l')
+      h::t =>
+        if(cmp(x, h)) // x < h
+          x::l
         else
-          x :: l
+          h::insert_by(cmp, x, t)
+
 
   function foldr(cons : ('a, 'b) => 'b, nil : 'b, l : list('a)) : 'b = switch(l)
     []   => nil
@@ -83,68 +130,78 @@ namespace List =
     []   => acc
     h::t => foldl(rcons, rcons(acc, h), t)
 
-  function foreach(f : 'a => unit, l : list('a)) : unit =
+  function foreach(l : list('a), f : 'a => unit) : unit =
     switch(l)
      []    => ()
-     e :: l' =>
+     e::l' =>
        f(e)
-       foreach(f, l')
+       foreach(l', f)
 
-  function reverse(l : list('a)) : list('a) = foldl((lst, el) => el :: lst, [], l)
+  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) = map_(f, l, [])
-  private function map_(f : 'a => 'b, l : list('a), acc : list('b)) : list('b) = switch(l)
-    []   => reverse(acc)
-    h::t => map_(f, t, f(h)::acc)
+  function 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) = filter_(p, l, [])
-  private function filter_(p : 'a => bool, l : list('a), acc : list('a)) : list('a) = switch(l)
-    []   => reverse(acc)
-    h::t => filter_(p, t, if(p(h)) h::acc else acc)
+  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 `n` first elements */
+/** 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), acc : list('a)) : list('a) =
-    if(n == 0) reverse(acc)
-    else switch(l)
-      []   => reverse(acc)
-      h::t => take_(n-1, t, h::acc)
-
-  /* Drop `n` first elements */
-  function drop(n : int, l : list('a)) : list('a) =
-   if(n < 0) abort("Drop negative number of elements")
-   elif (n == 0) l
+    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 => drop(n-1, t)
+      h::t => h::take_(n-1, t)
 
-  /* Get the longest prefix of a list in which every element matches predicate `p` */
-  function take_while(p : 'a => bool, l : list('a)) : list('a) = take_while_(p, l, [])
-  private function take_while_(p : 'a => bool, l : list('a), acc : list('a)) : list('a) = switch(l)
-    []   => reverse(acc)
-    h::t => if(p(h)) take_while_(p, t, h::acc) else reverse(acc)
+/** Drop 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)
+      []   => []
+      _::t => drop_(n-1, t)
 
-  /* Drop elements from `l` until `p` holds */
+/** 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)) = partition_(p, l, [], [])
-  private function partition_( p : 'a => bool
-                             , l : list('a)
-                             , acc_t : list('a)
-                             , acc_f : list('a)
-                             ) : (list('a) * list('a)) = switch(l)
-    []   => (reverse(acc_t), reverse(acc_f))
-    h::t => if(p(h)) partition_(p, t, h::acc_t, acc_f) else partition_(p, t, acc_t, h::acc_f)
+/** Splits list into two lists of elements that respectively
+ * match and don't match predicate `p`
+ */
+  function partition(p : 'a => bool, lst : list('a)) : (list('a) * list('a)) = switch(lst)
+    []   => ([], [])
+    h::t =>
+      let (l, r) = partition(p, t)
+      if(p(h)) (h::l, r) else (l, h::r)
 
-
-  function concats(ll : list(list('a))) : list('a) = foldr((l1, l2) => l1 ++ l2, [], ll)
+  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
@@ -154,49 +211,108 @@ namespace List =
     []   => false
     h::t => if(p(h)) true else any(p, t)
 
-  function sum(l : list(int)) : int = foldl ((a, b) => a + b, 0, l)
+  function sum(l : list(int)) : int = switch(l)
+    []   => 0
+    h::t => h + sum(t)
 
-  function product(l : list(int)) : int = foldl((a, b) => a * b, 1, l)
+  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 longer tail. */
-  function zip_with(f : ('a, 'b) => 'c, l1 : list('a), l2 : list('b)) : list('c) = zip_with_(f, l1, l2, [])
-  private function zip_with_( f : ('a, 'b) => 'c
+/** 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)
-                            , acc : list('c)
                             ) : list('c) = switch ((l1, l2))
-    (h1::t1, h2::t2) => zip_with_(f, t1, t2, f(h1, h2)::acc)
-    _ => reverse(acc)
+    (h1::t1, h2::t2) => f(h1, h2)::zip_with(f, t1, t2)
+    _ => []
 
-  /* Zips two lists into list of pairs. Drops longer tail. */
+/** 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) = unzip_(l, [], [])
-  private function unzip_( l     : list('a * 'b)
-                         , acc_l : list('a)
-                         , acc_r : list('b)
-                         ) : (list('a) * list('b)) = switch(l)
-    []               => (reverse(acc_l), reverse(acc_r))
-    (left, right)::t => unzip_(t, left::acc_l, right::acc_r)
+  function unzip(l : list('a * 'b)) : (list('a) * list('b)) = switch(l)
+    []          => ([], [])
+    (h1, h2)::t =>
+      let (t1, t2) = unzip(t)
+      (h1::t1, h2::t2)
 
 
-  // TODO: Improve?
-  function sort(lesser_cmp : ('a, 'a) => bool, l : list('a)) : list('a) = switch(l)
+  /** 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)
     []   => []
-    h::t => switch (partition((x) => lesser_cmp(x, h), t))
-      (lesser, bigger) => sort(lesser_cmp, lesser) ++ h::sort(lesser_cmp, bigger)
-
-
-  function intersperse(delim : 'a, l : list('a)) : list('a) = intersperse_(delim, l, [])
-  private function intersperse_(delim : 'a, l : list('a), acc : list('a)) : list('a) = switch(l)
-    []   => reverse(acc)
-    [e]  => reverse(e::acc)
-    h::t => intersperse_(delim, t, delim::h::acc)
-
-
-  function enumerate(l : list('a)) : list(int * 'a) = enumerate_(l, 0, [])
-  private function enumerate_(l : list('a), n : int, acc : list(int * 'a)) : list(int * 'a) = switch(l)
-    []   => reverse(acc)
-    h::t => enumerate_(t, n + 1, (n, h)::acc)
+    [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

@@ -2,8 +2,8 @@ namespace ListInternal =
 
   // -- Flatmap ----------------------------------------------------------------
 
-  function flat_map(f : 'a => list('b), xs : list('a)) : list('b) =
-    switch(xs)
+  function flat_map(f : 'a => list('b), lst : list('a)) : list('b) =
+    switch(lst)
       []      => []
       x :: xs => f(x) ++ flat_map(f, xs)
 

priv/stdlib/Option.aes

@@ -1,5 +1,3 @@
-include "List.aes"
-
 namespace Option =
 
   function is_none(o : option('a)) : bool = switch(o)
@@ -10,16 +8,33 @@ namespace Option =
     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)
 
-  function force(o : option('a)) : 'a = default(abort("Forced None value"), o)
+/** Assume it is `Some`
+ */
+  function force(o : option('a)) : 'a = switch(o)
+    None    => abort("Forced None value")
+    Some(x) => x
 
-  function on_elem(f : 'a => unit, o : option('a)) : unit = match((), f, o)
+/** Assume it is `Some` with custom error message
+ */
+  function force_msg(o : option('a), err : string) : 'a = switch(o)
+    None    => abort(err)
+    Some(x) => x
+
+  function
+    contains : 'a is eq; ('a, option('a)) => bool
+    contains(e, o) = 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
@@ -40,10 +55,14 @@ namespace Option =
     (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)
@@ -53,24 +72,33 @@ namespace Option =
     None => []
     Some(x) => [x]
 
-  function filter_options(l : list(option('a))) : list('a) = filter_options_(l, [])
-  private function filter_options_(l : list (option('a)), acc : list('a)) : list('a) = switch(l)
-    []         => List.reverse(acc)
-    None::t    => filter_options_(t, acc)
-    Some(x)::t => filter_options_(t, x::acc)
+/** 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)
 
-  function seq_options(l : list (option('a))) : option (list('a)) = seq_options_(l, [])
-  private function seq_options_(l : list (option('a)), acc : list('a)) : option(list('a)) = switch(l)
-    []         => Some(List.reverse(acc))
-    None::t    => None
-    Some(x)::t => seq_options_(t, x::acc)
+/** 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

@@ -6,12 +6,18 @@ namespace Pair =
   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))
 

priv/stdlib/Set.aes

@@ -0,0 +1,51 @@
+include "List.aes"
+include "Option.aes"
+include "Pair.aes"
+
+namespace Set =
+  record set('a) = { to_map : map('a, unit) }
+
+  function new() : set('a) =
+    { to_map = {} }
+
+  function member(e : 'a, s : set('a)) : bool =
+    Map.member(e, s.to_map)
+
+  function insert(e : 'a, s : set('a)) : set('a) =
+    { to_map = s.to_map{[e] = ()} }
+
+  function delete(e : 'a, s : set('a)) : set('a) =
+    { to_map = Map.delete(e, s.to_map) }
+
+  function size(s : set('a)) : int =
+    Map.size(s.to_map)
+
+  function to_list(s : set('a)) : list('a) =
+    List.map(Pair.fst, Map.to_list(s.to_map))
+
+  function from_list(l : list('a)) : set('a) =
+    { to_map = Map.from_list(List.map((x) => (x, ()), l)) }
+
+  function filter(p : 'a => bool, s : set('a)) : set('a) =
+    from_list(List.filter(p, to_list(s)))
+
+  function fold(f : ('a, 'b) => 'b, acc : 'b, s : set('a)) : 'b =
+    List.foldr(f, acc, to_list(s))
+
+  function subtract(s1 : set('a), s2 : set('a)) : set('a) =
+    filter((x) => !member(x, s2), s1)
+
+  function intersection(s1 : set('a), s2 : set('a)) : set('a) =
+    filter((x) => member(x, s2), s1)
+
+  function intersection_list(sets : list(set('a))) : set('a) =
+    List.foldr(
+      intersection,
+      Option.default(new(), List.first(sets)),
+      Option.default([], List.tail(sets)))
+
+  function union(s1 : set('a), s2 : set('a)) : set('a) =
+    from_list(to_list(s1) ++ to_list(s2))
+
+  function union_list(sets : list(set('a))) : set('a) =
+    List.foldr(union, new(), sets)

priv/stdlib/String.aes

@@ -0,0 +1,118 @@
+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(str : string) : option(int) =
+    let lst = StringInternal.to_list(str)
+    switch(is_prefix(['-'], lst))
+      None    => to_int_pos(lst)
+      Some(s) => switch(to_int_pos(s))
+                   None => None
+                   Some(x) => Some(-x)
+
+  // Private helper functions below
+  private function to_int_pos(chs : list(char)) =
+    switch(is_prefix(['0', 'x'], chs))
+      None =>
+        to_int_(chs, ch_to_int_10, 0, 10)
+      Some(str) =>
+        to_int_(str, 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 _ :: tailstr = str
+          contains_(ix + 1, tailstr, substr)
+        Some(_) =>
+          Some(ix)
+
+  private function
+    is_prefix : (list(char), list(char)) => option(list(char))
+    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 :: ints, value, x, b) =
+      switch(value(i))
+        None => None
+        Some(i) => to_int_(ints, value, x * b + i, b)
+
+  private function ch_to_int_10(ch) =
+    let c = Char.to_int(ch)
+    if(c >= 48 && c =< 57) Some(c - 48)
+    else None
+
+  private function ch_to_int_16(ch) =
+    let c = Char.to_int(ch)
+    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

@@ -10,15 +10,23 @@ namespace Triple =
     (_, _, 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
@@ -29,9 +37,13 @@ namespace Triple =
   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,7 +2,7 @@
 
 {erl_opts, [debug_info]}.
 
-{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git", {ref,"10cc127"}}}
+{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git", {ref,"0699f35"}}}
        , {getopt, "1.0.1"}
        , {eblake2, "1.0.0"}
        , {jsx, {git, "https://github.com/talentdeficit/jsx.git",
@@ -15,7 +15,7 @@
             {base_plt_apps, [erts, kernel, stdlib, crypto, mnesia]}
            ]}.
 
-{relx, [{release, {aesophia, "4.0.0-rc1"},
+{relx, [{release, {aesophia, "6.1.0"},
          [aesophia, aebytecode, getopt]},
 
         {dev_mode, true},

rebar.lock

@@ -1,17 +1,21 @@
 {"1.1.0",
 [{<<"aebytecode">>,
   {git,"https://github.com/aeternity/aebytecode.git",
-       {ref,"10cc1278831ad7e90138533466ceef4bcafd74a9"}},
+       {ref,"0699f35b0398bac6cd4468da654d608375bd853d"}},
   0},
  {<<"aeserialization">>,
   {git,"https://github.com/aeternity/aeserialization.git",
-       {ref,"816bf994ffb5cee218c3f22dc5fea296c9e0882e"}},
+       {ref,"47aaa8f5434b365c50a35bfd1490340b19241991"}},
   1},
  {<<"base58">>,
   {git,"https://github.com/aeternity/erl-base58.git",
        {ref,"60a335668a60328a29f9731b67c4a0e9e3d50ab6"}},
   2},
  {<<"eblake2">>,{pkg,<<"eblake2">>,<<"1.0.0">>},0},
+ {<<"enacl">>,
+  {git,"https://github.com/aeternity/enacl.git",
+       {ref,"26180f42c0b3a450905d2efd8bc7fd5fd9cece75"}},
+  2},
  {<<"getopt">>,{pkg,<<"getopt">>,<<"1.0.1">>},0},
  {<<"jsx">>,
   {git,"https://github.com/talentdeficit/jsx.git",

src/aeso_aci.erl

@@ -14,15 +14,21 @@
         , contract_interface/2
         , contract_interface/3
 
+        , from_typed_ast/2
+
         , render_aci_json/1
 
         , json_encode_expr/1
         , json_encode_type/1]).
 
+-include("aeso_utils.hrl").
+
 -type aci_type()  :: json | string.
 -type json()      :: jsx:json_term().
 -type json_text() :: binary().
 
+-export_type([aci_type/0]).
+
 %% External API
 -spec file(aci_type(), string()) -> {ok, json() | string()} | {error, term()}.
 file(Type, File) ->
@@ -64,32 +70,20 @@ do_contract_interface(Type, Contract, Options) when is_binary(Contract) ->
 do_contract_interface(Type, ContractString, Options) ->
     try
         Ast = aeso_compiler:parse(ContractString, Options),
-        %% io:format("~p\n", [Ast]),
-        TypedAst = aeso_ast_infer_types:infer(Ast, [dont_unfold]),
-        %% io:format("~p\n", [TypedAst]),
-        JArray = [ encode_contract(C) || C <- TypedAst ],
+        {TypedAst, _, _} = aeso_ast_infer_types:infer(Ast, [dont_unfold | Options]),
+        from_typed_ast(Type, TypedAst)
+    catch
+        throw:{error, Errors} -> {error, Errors}
+    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
-    catch
-        %% The compiler errors.
-        error:{parse_errors, Errors} ->
-            {error, join_errors("Parse errors", Errors, fun(E) -> E end)};
-        error:{type_errors, Errors} ->
-            {error, join_errors("Type errors", Errors, fun(E) -> E end)};
-        error:{code_errors, Errors} ->
-            {error, join_errors("Code errors", Errors,
-                                fun (E) -> io_lib:format("~p", [E]) end)}
-        %% General programming errors in the compiler just signal error.
     end.
 
-join_errors(Prefix, Errors, Pfun) ->
-    Ess = [ Pfun(E) || E <- Errors ],
-    list_to_binary(string:join([Prefix|Ess], "\n")).
-
-encode_contract(Contract = {contract, _, {con, _, Name}, _}) ->
+encode_contract(Contract = {Head, _, {con, _, Name}, _}) when ?IS_CONTRACT_HEAD(Head) ->
     C0 = #{name => encode_name(Name)},
 
     Tdefs0 = [ encode_typedef(T) || T <- sort_decls(contract_types(Contract)) ],
@@ -113,7 +107,7 @@ encode_contract(Contract = {contract, _, {con, _, Name}, _}) ->
                || F <- sort_decls(contract_funcs(Contract)),
                   is_entrypoint(F) ],
 
-    #{contract => C3#{functions => Fdefs, payable => is_payable(Contract)}};
+    #{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),
@@ -141,7 +135,7 @@ encode_anon_args(Types) ->
 
 encode_args(Args) -> [ encode_arg(A) || A <- Args ].
 
-encode_arg({arg, _, Id, T}) ->
+encode_arg({typed, _, Id, T}) ->
     #{name => encode_type(Id),
       type => encode_type(T)}.
 
@@ -206,6 +200,8 @@ encode_expr({bytes, _, B})  ->
 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),
@@ -236,13 +232,19 @@ do_render_aci_json(Json) ->
     {ok, list_to_binary(string:join(DecodedContracts, "\n"))}.
 
 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), "contract ", io_lib:format("~s", [Name])," =\n",
+    [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",
@@ -252,8 +254,8 @@ decode_contract(_) -> [].
 decode_funcs(Fs) -> [ decode_func(F) || F <- Fs ].
 
 %% decode_func(#{name := init}) -> [];
-decode_func(#{name := Name, payable := Payable, arguments := As, returns := T}) ->
-    ["  ", payable(Payable), "entrypoint ", io_lib:format("~s", [Name]), " : ",
+decode_func(#{name := Name, stateful:= Stateful, payable := Payable, arguments := As, returns := T}) ->
+    ["  ", payable(Payable), stateful(Stateful), "entrypoint ", io_lib:format("~s", [Name]), " : ",
      decode_args(As), " => ", decode_type(T), $\n].
 
 decode_args(As) ->
@@ -334,12 +336,15 @@ decode_tvar(#{name := N}) -> io_lib:format("~s", [N]).
 payable(true)  -> "payable ";
 payable(false) -> "".
 
+stateful(true)  -> "stateful ";
+stateful(false) -> "".
+
 %% #contract{Ann, Con, [Declarations]}.
 
-contract_funcs({C, _, _, Decls}) when C == contract; C == namespace ->
+contract_funcs({C, _, _, Decls}) when ?IS_CONTRACT_HEAD(C); C == namespace ->
     [ D || D <- Decls, is_fun(D)].
 
-contract_types({C, _, _, Decls}) when C == contract; C == namespace ->
+contract_types({C, _, _, Decls}) when ?IS_CONTRACT_HEAD(C); C == namespace ->
     [ D || D <- Decls, is_type(D) ].
 
 is_fun({letfun, _, _, _, _, _}) -> true;

src/aeso_ast_to_icode.erl

@@ -1,916 +0,0 @@
-%%%-------------------------------------------------------------------
-%%% @author Happi (Erik Stenman)
-%%% @copyright (C) 2017, Aeternity Anstalt
-%%% @doc
-%%%     Compiler from Aeterinty Sophia language to the Aeternity VM, aevm.
-%%% @end
-%%% Created : 21 Dec 2017
-%%%
-%%%-------------------------------------------------------------------
--module(aeso_ast_to_icode).
-
--export([ast_typerep/1, ast_typerep/2, type_value/1,
-         convert_typed/2, prim_call/5]).
-
--include_lib("aebytecode/include/aeb_opcodes.hrl").
--include("aeso_icode.hrl").
-
--spec convert_typed(aeso_syntax:ast(), list()) -> aeso_icode:icode().
-convert_typed(TypedTree, Options) ->
-    {Payable, Name} =
-        case lists:last(TypedTree) of
-            {contract, Attrs, {con, _, Con}, _} ->
-                {proplists:get_value(payable, Attrs, false), Con};
-            _ ->
-                gen_error(last_declaration_must_be_contract)
-           end,
-    NewIcode = aeso_icode:set_payable(Payable,
-                   aeso_icode:set_name(Name, aeso_icode:new(Options))),
-    Icode    = code(TypedTree, NewIcode, Options),
-    deadcode_elimination(Icode).
-
-code([{contract, _Attribs, Con, Code}|Rest], Icode, Options) ->
-    NewIcode = contract_to_icode(Code, aeso_icode:set_namespace(Con, Icode)),
-    code(Rest, NewIcode, Options);
-code([{namespace, _Ann, Name, Code}|Rest], Icode, Options) ->
-    %% TODO: nested namespaces
-    NewIcode = contract_to_icode(Code, aeso_icode:set_namespace(Name, Icode)),
-    code(Rest, NewIcode, Options);
-code([], Icode, Options) ->
-    add_default_init_function(add_builtins(Icode), Options).
-
-%% Generate error on correct format.
-
-gen_error(Error) ->
-    error({code_errors, [Error]}).
-
-%% Create default init function (only if state is unit).
-add_default_init_function(Icode = #{functions := Funs, state_type := State}, Options) ->
-    NoCode        = proplists:get_value(no_code, Options, false),
-    {_, _, QInit} = aeso_icode:qualify({id, [], "init"}, Icode),
-    case lists:keymember(QInit, 1, Funs) of
-        true -> Icode;
-        false when NoCode -> Icode;
-        false when State /= {tuple, []} ->
-            gen_error(missing_init_function);
-        false ->
-            Type  = {tuple, [typerep, {tuple, []}]},
-            Value = #tuple{ cpts = [type_value({tuple, []}), {tuple, []}] },
-            DefaultInit = {QInit, [], [], Value, Type},
-            Icode#{ functions => [DefaultInit | Funs] }
-    end.
-
--spec contract_to_icode(aeso_syntax:ast(), aeso_icode:icode()) ->
-                               aeso_icode:icode().
-contract_to_icode([{namespace, _, Name, Defs} | Rest], Icode) ->
-    NS = aeso_icode:get_namespace(Icode),
-    Icode1 = contract_to_icode(Defs, aeso_icode:enter_namespace(Name, Icode)),
-    contract_to_icode(Rest, aeso_icode:set_namespace(NS, Icode1));
-contract_to_icode([{type_def, _Attrib, Id = {id, _, Name}, Args, Def} | Rest],
-                  Icode = #{ types := Types, constructors := Constructors }) ->
-    TypeDef = make_type_def(Args, Def, Icode),
-    NewConstructors =
-        case Def of
-            {variant_t, Cons} ->
-                Tags = lists:seq(0, length(Cons) - 1),
-                GetName = fun({constr_t, _, C, _}) -> C end,
-                QName = fun(Con) -> {_, _, Xs} = aeso_icode:qualify(GetName(Con), Icode), Xs end,
-                maps:from_list([ {QName(Con), Tag} || {Tag, Con} <- lists:zip(Tags, Cons) ]);
-            _ -> #{}
-        end,
-    {_, _, TName} = aeso_icode:qualify(Id, Icode),
-    Icode1 = Icode#{ types := Types#{ TName => TypeDef },
-                     constructors := maps:merge(Constructors, NewConstructors) },
-    Icode2 = case Name of
-                "state" when Args == [] -> Icode1#{ state_type => ast_typerep(Def, Icode) };
-                "state"                 -> gen_error(state_type_cannot_be_parameterized);
-                "event" when Args == [] -> Icode1#{ event_type => Def };
-                "event"                 -> gen_error(event_type_cannot_be_parameterized);
-                _                       -> Icode1
-             end,
-    contract_to_icode(Rest, Icode2);
-contract_to_icode([{letfun, Attrib, Name, Args, _What, Body={typed,_,_,T}}|Rest], Icode) ->
-    FunAttrs = [ stateful || proplists:get_value(stateful, Attrib, false) ] ++
-               [ payable  || proplists:get_value(payable, Attrib, false) ] ++
-               [ private  || is_private(Attrib, Icode) ],
-    %% TODO: Handle types
-    FunName = ast_id(Name),
-    %% TODO: push funname to env
-    FunArgs = ast_args(Args, [], Icode),
-    %% TODO: push args to env
-    {FunBody, TypeRep} =
-        case FunName of
-            "init" ->
-                %% Pair the initial state with a typerep for the state (TODO: until we have the state type in some contract metadata)
-                #{ state_type := StateType } = Icode,
-                {#tuple{ cpts = [type_value(StateType), ast_body(Body, Icode)] },
-                 {tuple, [typerep, ast_typerep(T, Icode)]}};
-            _ -> {ast_body(Body, Icode), ast_typerep(T, Icode)}
-        end,
-    QName    = aeso_icode:qualify(Name, Icode),
-    NewIcode = ast_fun_to_icode(ast_id(QName), FunAttrs, FunArgs, FunBody, TypeRep, Icode),
-    contract_to_icode(Rest, NewIcode);
-contract_to_icode([], Icode) -> Icode;
-contract_to_icode([{fun_decl, _, _, _} | Code], Icode) ->
-    contract_to_icode(Code, Icode);
-contract_to_icode([Decl | Code], Icode) ->
-    io:format("Unhandled declaration: ~p\n", [Decl]),
-    contract_to_icode(Code, Icode).
-
-ast_id({id, _, Id}) -> Id;
-ast_id({qid, _, Id}) -> Id.
-
-ast_args([{arg, _, Name, Type}|Rest], Acc, Icode) ->
-    ast_args(Rest, [{ast_id(Name), ast_type(Type, Icode)}| Acc], Icode);
-ast_args([], Acc, _Icode) -> lists:reverse(Acc).
-
-ast_type(T, Icode) ->
-    ast_typerep(T, Icode).
-
--define(id_app(Fun, Args, ArgTypes, OutType),
-    {app, _, {typed, _, {id, _, Fun}, {fun_t, _, _, ArgTypes, OutType}}, Args}).
-
--define(qid_app(Fun, Args, ArgTypes, OutType),
-    {app, _, {typed, _, {qid, _, Fun}, {fun_t, _, _, ArgTypes, OutType}}, Args}).
-
--define(oracle_t(Q, R), {app_t, _, {id, _, "oracle"}, [Q, R]}).
--define(query_t(Q, R),  {app_t, _, {id, _, "oracle_query"}, [Q, R]}).
--define(option_t(A),    {app_t, _, {id, _, "option"}, [A]}).
--define(map_t(K, V),    {app_t, _, {id, _, "map"}, [K, V]}).
-
-ast_body(?qid_app(["Chain","spend"], [To, Amount], _, _), Icode) ->
-    prim_call(?PRIM_CALL_SPEND, ast_body(Amount, Icode), [ast_body(To, Icode)], [word], {tuple, []});
-
-ast_body(?qid_app([Con, "Chain", "event"], [Event], _, _), Icode = #{ contract_name := Con }) ->
-    aeso_builtins:check_event_type(Icode),
-    builtin_call({event, maps:get(event_type, Icode)}, [ast_body(Event, Icode)]);
-
-%% Chain environment
-ast_body(?qid_app(["Chain", "balance"], [Address], _, _), Icode) ->
-    #prim_balance{ address = ast_body(Address, Icode) };
-ast_body(?qid_app(["Chain", "block_hash"], [Height], _, _), Icode) ->
-    builtin_call(block_hash, [ast_body(Height, Icode)]);
-ast_body(?qid_app(["Call", "gas_left"], [], _, _), _Icode) ->
-    prim_gas_left;
-ast_body({qid, _, ["Contract", "address"]}, _Icode)      -> prim_contract_address;
-ast_body({qid, _, ["Contract", "creator"]}, _Icode)      -> prim_contract_creator;
-ast_body({qid, _, ["Contract", "balance"]}, _Icode)      -> #prim_balance{ address = prim_contract_address };
-ast_body({qid, _, ["Call",     "origin"]}, _Icode)       -> prim_call_origin;
-ast_body({qid, _, ["Call",     "caller"]}, _Icode)       -> prim_caller;
-ast_body({qid, _, ["Call",     "value"]}, _Icode)        -> prim_call_value;
-ast_body({qid, _, ["Call",     "gas_price"]}, _Icode)    -> prim_gas_price;
-ast_body({qid, _, ["Chain",    "coinbase"]}, _Icode)     -> prim_coinbase;
-ast_body({qid, _, ["Chain",    "timestamp"]}, _Icode)    -> prim_timestamp;
-ast_body({qid, _, ["Chain",    "block_height"]}, _Icode) -> prim_block_height;
-ast_body({qid, _, ["Chain",    "difficulty"]}, _Icode)   -> prim_difficulty;
-ast_body({qid, _, ["Chain",    "gas_limit"]}, _Icode)    -> prim_gas_limit;
-%% TODO: eta expand!
-ast_body({qid, _, ["Chain", "balance"]}, _Icode) ->
-    gen_error({underapplied_primitive, 'Chain.balance'});
-ast_body({qid, _, ["Chain", "block_hash"]}, _Icode) ->
-    gen_error({underapplied_primitive, 'Chain.block_hash'});
-ast_body({qid, _, ["Chain", "spend"]}, _Icode) ->
-    gen_error({underapplied_primitive, 'Chain.spend'});
-
-%% State
-ast_body({qid, _, [Con, "state"]}, #{ contract_name := Con }) -> prim_state;
-ast_body(?qid_app([Con, "put"], [NewState], _, _), Icode = #{ contract_name := Con }) ->
-    #prim_put{ state = ast_body(NewState, Icode) };
-ast_body({qid, _, [Con, "put"]}, #{ contract_name := Con }) ->
-    gen_error({underapplied_primitive, put});   %% TODO: eta
-
-%% Abort
-ast_body(?id_app("abort", [String], _, _), Icode) ->
-    builtin_call(abort, [ast_body(String, Icode)]);
-ast_body(?id_app("require", [Bool, String], _, _), Icode) ->
-    builtin_call(require, [ast_body(Bool, Icode), ast_body(String, Icode)]);
-
-%% Authentication
-ast_body({qid, _, ["Auth", "tx_hash"]}, _Icode) ->
-    prim_call(?PRIM_CALL_AUTH_TX_HASH, #integer{value = 0},
-              [], [], aeso_icode:option_typerep(word));
-
-%% Oracles
-ast_body(?qid_app(["Oracle", "register"], Args, _, ?oracle_t(QType, RType)), Icode) ->
-    {Sign, [Acct, QFee, TTL]} = get_signature_arg(Args),
-    prim_call(?PRIM_CALL_ORACLE_REGISTER, #integer{value = 0},
-              [ast_body(Acct, Icode), ast_body(Sign, Icode), ast_body(QFee, Icode), ast_body(TTL, Icode),
-               ast_type_value(QType, Icode), ast_type_value(RType, Icode)],
-              [word, sign_t(), word, ttl_t(Icode), typerep, typerep], word);
-
-ast_body(?qid_app(["Oracle", "query_fee"], [Oracle], _, _), Icode) ->
-    prim_call(?PRIM_CALL_ORACLE_QUERY_FEE, #integer{value = 0},
-              [ast_body(Oracle, Icode)], [word], word);
-
-ast_body(?qid_app(["Oracle", "query"], [Oracle, Q, QFee, QTTL, RTTL], [_, QType, _, _, _], _), Icode) ->
-    prim_call(?PRIM_CALL_ORACLE_QUERY, ast_body(QFee, Icode),
-              [ast_body(Oracle, Icode), ast_body(Q, Icode), ast_body(QTTL, Icode), ast_body(RTTL, Icode)],
-              [word, ast_type(QType, Icode), ttl_t(Icode), ttl_t(Icode)], word);
-
-ast_body(?qid_app(["Oracle", "extend"], Args, _, _), Icode) ->
-    {Sign, [Oracle, TTL]} = get_signature_arg(Args),
-    prim_call(?PRIM_CALL_ORACLE_EXTEND, #integer{value = 0},
-              [ast_body(Oracle, Icode), ast_body(Sign, Icode), ast_body(TTL, Icode)],
-              [word, sign_t(), ttl_t(Icode)], {tuple, []});
-
-ast_body(?qid_app(["Oracle", "respond"], Args, [_, _, RType], _), Icode) ->
-    {Sign, [Oracle, Query, R]} = get_signature_arg(Args),
-    prim_call(?PRIM_CALL_ORACLE_RESPOND, #integer{value = 0},
-              [ast_body(Oracle, Icode), ast_body(Query, Icode), ast_body(Sign, Icode), ast_body(R, Icode)],
-              [word, word, sign_t(), ast_type(RType, Icode)], {tuple, []});
-
-ast_body(?qid_app(["Oracle", "get_question"], [Oracle, Q], [_, ?query_t(QType, _)], _), Icode) ->
-    prim_call(?PRIM_CALL_ORACLE_GET_QUESTION, #integer{value = 0},
-              [ast_body(Oracle, Icode), ast_body(Q, Icode)], [word, word], ast_type(QType, Icode));
-
-ast_body(?qid_app(["Oracle", "get_answer"], [Oracle, Q], [_, ?query_t(_, RType)], _), Icode) ->
-    prim_call(?PRIM_CALL_ORACLE_GET_ANSWER, #integer{value = 0},
-              [ast_body(Oracle, Icode), ast_body(Q, Icode)], [word, word], aeso_icode:option_typerep(ast_type(RType, Icode)));
-
-ast_body(?qid_app(["Oracle", "check"], [Oracle], [?oracle_t(Q, R)], _), Icode) ->
-    prim_call(?PRIM_CALL_ORACLE_CHECK, #integer{value = 0},
-              [ast_body(Oracle, Icode), ast_type_value(Q, Icode), ast_type_value(R, Icode)],
-              [word, typerep, typerep], word);
-
-ast_body(?qid_app(["Oracle", "check_query"], [Oracle, Query], [_, ?query_t(Q, R)], _), Icode) ->
-    prim_call(?PRIM_CALL_ORACLE_CHECK_QUERY, #integer{value = 0},
-              [ast_body(Oracle, Icode), ast_body(Query, Icode),
-               ast_type_value(Q, Icode), ast_type_value(R, Icode)],
-              [word, typerep, typerep], word);
-
-ast_body({qid, _, ["Oracle", "register"]}, _Icode)     -> gen_error({underapplied_primitive, 'Oracle.register'});
-ast_body({qid, _, ["Oracle", "query"]}, _Icode)        -> gen_error({underapplied_primitive, 'Oracle.query'});
-ast_body({qid, _, ["Oracle", "extend"]}, _Icode)       -> gen_error({underapplied_primitive, 'Oracle.extend'});
-ast_body({qid, _, ["Oracle", "respond"]}, _Icode)      -> gen_error({underapplied_primitive, 'Oracle.respond'});
-ast_body({qid, _, ["Oracle", "query_fee"]}, _Icode)    -> gen_error({underapplied_primitive, 'Oracle.query_fee'});
-ast_body({qid, _, ["Oracle", "get_answer"]}, _Icode)   -> gen_error({underapplied_primitive, 'Oracle.get_answer'});
-ast_body({qid, _, ["Oracle", "get_question"]}, _Icode) -> gen_error({underapplied_primitive, 'Oracle.get_question'});
-
-%% Name service
-ast_body(?qid_app(["AENS", "resolve"], [Name, Key], _, ?option_t(Type)), Icode) ->
-    case is_monomorphic(Type) of
-        true ->
-            case ast_type(Type, Icode) of
-                T when T == word; T == string -> ok;
-                _ -> gen_error({invalid_result_type, 'AENS.resolve', Type})
-            end,
-            prim_call(?PRIM_CALL_AENS_RESOLVE, #integer{value = 0},
-                      [ast_body(Name, Icode), ast_body(Key, Icode), ast_type_value(Type, Icode)],
-                      [string, string, typerep], aeso_icode:option_typerep(ast_type(Type, Icode)));
-        false ->
-            gen_error({unresolved_result_type, 'AENS.resolve', Type})
-    end;
-
-ast_body(?qid_app(["AENS", "preclaim"], Args, _, _), Icode) ->
-    {Sign, [Addr, CHash]} = get_signature_arg(Args),
-    prim_call(?PRIM_CALL_AENS_PRECLAIM, #integer{value = 0},
-              [ast_body(Addr, Icode), ast_body(CHash, Icode), ast_body(Sign, Icode)],
-              [word, word, sign_t()], {tuple, []});
-
-ast_body(?qid_app(["AENS", "claim"], Args, _, _), Icode) ->
-    {Sign, [Addr, Name, Salt]} = get_signature_arg(Args),
-    prim_call(?PRIM_CALL_AENS_CLAIM, #integer{value = 0},
-              [ast_body(Addr, Icode), ast_body(Name, Icode), ast_body(Salt, Icode), ast_body(Sign, Icode)],
-              [word, string, word, sign_t()], {tuple, []});
-
-ast_body(?qid_app(["AENS", "transfer"], Args, _, _), Icode) ->
-    {Sign, [FromAddr, ToAddr, Name]} = get_signature_arg(Args),
-    prim_call(?PRIM_CALL_AENS_TRANSFER, #integer{value = 0},
-              [ast_body(FromAddr, Icode), ast_body(ToAddr, Icode), ast_body(Name, Icode), ast_body(Sign, Icode)],
-              [word, word, word, sign_t()], {tuple, []});
-
-ast_body(?qid_app(["AENS", "revoke"], Args, _, _), Icode) ->
-    {Sign, [Addr, Name]} = get_signature_arg(Args),
-    prim_call(?PRIM_CALL_AENS_REVOKE, #integer{value = 0},
-              [ast_body(Addr, Icode), ast_body(Name, Icode), ast_body(Sign, Icode)],
-              [word, word, sign_t()], {tuple, []});
-
-ast_body({qid, _, ["AENS", "resolve"]}, _Icode)  -> gen_error({underapplied_primitive, 'AENS.resolve'});
-ast_body({qid, _, ["AENS", "preclaim"]}, _Icode) -> gen_error({underapplied_primitive, 'AENS.preclaim'});
-ast_body({qid, _, ["AENS", "claim"]}, _Icode)    -> gen_error({underapplied_primitive, 'AENS.claim'});
-ast_body({qid, _, ["AENS", "transfer"]}, _Icode) -> gen_error({underapplied_primitive, 'AENS.transfer'});
-ast_body({qid, _, ["AENS", "revoke"]}, _Icode)   -> gen_error({underapplied_primitive, 'AENS.revoke'});
-
-%% Maps
-
-%% -- map lookup  m[k]
-ast_body({map_get, _, Map, Key}, Icode) ->
-    {_, ValType} = check_monomorphic_map(Map, Icode),
-    Fun = {map_get, ast_typerep(ValType, Icode)},
-    builtin_call(Fun, [ast_body(Map, Icode), ast_body(Key, Icode)]);
-%% -- map lookup_default  m[k = v]
-ast_body({map_get, _, Map, Key, Val}, Icode) ->
-    {_, ValType} = check_monomorphic_map(Map, Icode),
-    Fun = {map_lookup_default, ast_typerep(ValType, Icode)},
-    builtin_call(Fun, [ast_body(Map, Icode), ast_body(Key, Icode), ast_body(Val, Icode)]);
-
-%% -- lookup functions
-ast_body(?qid_app(["Map", "lookup"], [Key, Map], _, _), Icode) ->
-    map_get(Key, Map, Icode);
-ast_body(?qid_app(["Map", "lookup_default"], [Key, Map, Val], _, _), Icode) ->
-    {_, ValType} = check_monomorphic_map(Map, Icode),
-    Fun = {map_lookup_default, ast_typerep(ValType, Icode)},
-    builtin_call(Fun, [ast_body(Map, Icode), ast_body(Key, Icode), ast_body(Val, Icode)]);
-ast_body(?qid_app(["Map", "member"], [Key, Map], _, _), Icode) ->
-    builtin_call(map_member, [ast_body(Map, Icode), ast_body(Key, Icode)]);
-ast_body(?qid_app(["Map", "size"], [Map], _, _), Icode) ->
-    builtin_call(map_size, [ast_body(Map, Icode)]);
-ast_body(?qid_app(["Map", "delete"], [Key, Map], _, _), Icode) ->
-    map_del(Key, Map, Icode);
-
-%% -- map conversion to/from list
-ast_body(App = ?qid_app(["Map", "from_list"], [List], _, MapType), Icode) ->
-    Ann = aeso_syntax:get_ann(App),
-    {KeyType, ValType} = check_monomorphic_map(Ann, MapType, Icode),
-    builtin_call(map_from_list, [ast_body(List, Icode), map_empty(KeyType, ValType, Icode)]);
-
-ast_body(?qid_app(["Map", "to_list"], [Map], _, _), Icode) ->
-    map_tolist(Map, Icode);
-
-ast_body({qid, _, ["Map", "from_list"]}, _Icode) -> gen_error({underapplied_primitive, 'Map.from_list'});
-%% ast_body({qid, _, ["Map", "to_list"]}, _Icode)   -> gen_error({underapplied_primitive, 'Map.to_list'});
-ast_body({qid, _, ["Map", "lookup"]}, _Icode)    -> gen_error({underapplied_primitive, 'Map.lookup'});
-ast_body({qid, _, ["Map", "lookup_default"]}, _Icode)    -> gen_error({underapplied_primitive, 'Map.lookup_default'});
-ast_body({qid, _, ["Map", "member"]}, _Icode)    -> gen_error({underapplied_primitive, 'Map.member'});
-
-%% -- map construction { k1 = v1, k2 = v2 }
-ast_body({typed, Ann, {map, _, KVs}, MapType}, Icode) ->
-    {KeyType, ValType} = check_monomorphic_map(Ann, MapType, Icode),
-    lists:foldr(fun({K, V}, Map) ->
-                    builtin_call(map_put, [Map, ast_body(K, Icode), ast_body(V, Icode)])
-                end, map_empty(KeyType, ValType, Icode), KVs);
-
-%% -- map update       m { [k] = v } or m { [k] @ x = f(x) } or m { [k = v] @ x = f(x) }
-ast_body({map, _, Map, []}, Icode) -> ast_body(Map, Icode);
-ast_body({map, _, Map, [Upd]}, Icode) ->
-    case Upd of
-        {field, _, [{map_get, _, Key}], Val} ->
-            map_put(Key, Val, Map, Icode);
-        {field_upd, _, [{map_get, _, Key}], ValFun} ->
-            map_upd(Key, ValFun, Map, Icode);
-        {field_upd, _, [{map_get, _, Key, Val}], ValFun} ->
-            map_upd(Key, Val, ValFun, Map, Icode)
-    end;
-ast_body({map, Ann, Map, [Upd | Upds]}, Icode) ->
-    ast_body({map, Ann, {map, Ann, Map, [Upd]}, Upds}, Icode);
-
-%% Crypto
-ast_body(?qid_app(["Crypto", "verify_sig"], [Msg, PK, Sig], _, _), Icode) ->
-    prim_call(?PRIM_CALL_CRYPTO_VERIFY_SIG, #integer{value = 0},
-              [ast_body(Msg, Icode), ast_body(PK, Icode), ast_body(Sig, Icode)],
-              [word, word, sign_t()], word);
-
-ast_body(?qid_app(["Crypto", "verify_sig_secp256k1"], [Msg, PK, Sig], _, _), Icode) ->
-    prim_call(?PRIM_CALL_CRYPTO_VERIFY_SIG_SECP256K1, #integer{value = 0},
-              [ast_body(Msg, Icode), ast_body(PK, Icode), ast_body(Sig, Icode)],
-              [bytes_t(32), bytes_t(64), bytes_t(64)], word);
-
-ast_body(?qid_app(["Crypto", "ecverify_secp256k1"], [Msg, Addr, Sig], _, _), Icode) ->
-    prim_call(?PRIM_CALL_CRYPTO_ECVERIFY_SECP256K1, #integer{value = 0},
-              [ast_body(Msg, Icode), ast_body(Addr, Icode), ast_body(Sig, Icode)],
-              [word, bytes_t(20), bytes_t(65)], word);
-
-ast_body(?qid_app(["Crypto", "ecrecover_secp256k1"], [Msg, Sig], _, _), Icode) ->
-    prim_call(?PRIM_CALL_CRYPTO_ECRECOVER_SECP256K1, #integer{value = 0},
-              [ast_body(Msg, Icode), ast_body(Sig, Icode)],
-              [word, bytes_t(65)], aeso_icode:option_typerep(bytes_t(20)));
-
-ast_body(?qid_app(["Crypto", "sha3"], [Term], [Type], _), Icode) ->
-    generic_hash_primop(?PRIM_CALL_CRYPTO_SHA3, Term, Type, Icode);
-ast_body(?qid_app(["Crypto", "sha256"], [Term], [Type], _), Icode) ->
-    generic_hash_primop(?PRIM_CALL_CRYPTO_SHA256, Term, Type, Icode);
-ast_body(?qid_app(["Crypto", "blake2b"], [Term], [Type], _), Icode) ->
-    generic_hash_primop(?PRIM_CALL_CRYPTO_BLAKE2B, Term, Type, Icode);
-ast_body(?qid_app(["String", "sha256"], [String], _, _), Icode) ->
-    string_hash_primop(?PRIM_CALL_CRYPTO_SHA256_STRING, String, Icode);
-ast_body(?qid_app(["String", "blake2b"], [String], _, _), Icode) ->
-    string_hash_primop(?PRIM_CALL_CRYPTO_BLAKE2B_STRING, String, Icode);
-
-%% Strings
-%% -- String length
-ast_body(?qid_app(["String", "length"], [String], _, _), Icode) ->
-    builtin_call(string_length, [ast_body(String, Icode)]);
-
-%% -- String concat
-ast_body(?qid_app(["String", "concat"], [String1, String2], _, _), Icode) ->
-    builtin_call(string_concat, [ast_body(String1, Icode), ast_body(String2, Icode)]);
-
-%% -- String hash (sha3)
-ast_body(?qid_app(["String", "sha3"], [String], _, _), Icode) ->
-    #unop{ op = 'sha3', rand = ast_body(String, Icode) };
-
-%% -- Bits
-ast_body(?qid_app(["Bits", Fun], Args, _, _), Icode)
-        when Fun == "test"; Fun == "set"; Fun == "clear";
-             Fun == "union"; Fun == "intersection"; Fun == "difference" ->
-    C  = fun(N) when is_integer(N) -> #integer{ value = N };
-            (X) -> X end,
-    Bin = fun(O) -> fun(A, B) -> #binop{ op = O, left = C(A), right = C(B) } end end,
-    And = Bin('band'),
-    Or  = Bin('bor'),
-    Bsl = fun(A, B) -> (Bin('bsl'))(B, A) end, %% flipped arguments
-    Bsr = fun(A, B) -> (Bin('bsr'))(B, A) end,
-    Neg = fun(A) -> #unop{ op = 'bnot', rand = C(A) } end,
-    case [Fun | [ ast_body(Arg, Icode) || Arg <- Args ]] of
-        ["test", Bits, Ix]     -> And(Bsr(Bits, Ix), 1);
-        ["set", Bits, Ix]      -> Or(Bits, Bsl(1, Ix));
-        ["clear", Bits, Ix]    -> And(Bits, Neg(Bsl(1, Ix)));
-        ["union", A, B]        -> Or(A, B);
-        ["intersection", A, B] -> And(A, B);
-        ["difference", A, B]   -> And(A, Neg(And(A, B)))
-    end;
-ast_body({qid, _, ["Bits", "none"]}, _Icode) ->
-    #integer{ value = 0 };
-ast_body({qid, _, ["Bits", "all"]}, _Icode) ->
-    #integer{ value = 1 bsl 256 - 1 };
-ast_body(?qid_app(["Bits", "sum"], [Bits], _, _), Icode) ->
-    builtin_call(popcount, [ast_body(Bits, Icode), #integer{ value = 0 }]);
-
-%% -- Conversion
-ast_body(?qid_app(["Int", "to_str"], [Int], _, _), Icode) ->
-    builtin_call(int_to_str, [ast_body(Int, Icode)]);
-
-ast_body(?qid_app(["Address", "to_str"], [Addr], _, _), Icode) ->
-    builtin_call(addr_to_str, [ast_body(Addr, Icode)]);
-ast_body(?qid_app(["Address", "is_oracle"], [Addr], _, _), Icode) ->
-    prim_call(?PRIM_CALL_ADDR_IS_ORACLE, #integer{value = 0},
-              [ast_body(Addr, Icode)], [word], word);
-ast_body(?qid_app(["Address", "is_contract"], [Addr], _, _), Icode) ->
-    prim_call(?PRIM_CALL_ADDR_IS_CONTRACT, #integer{value = 0},
-              [ast_body(Addr, Icode)], [word], word);
-ast_body(?qid_app(["Address", "is_payable"], [Addr], _, _), Icode) ->
-    prim_call(?PRIM_CALL_ADDR_IS_PAYABLE, #integer{value = 0},
-              [ast_body(Addr, Icode)], [word], word);
-
-ast_body(?qid_app(["Bytes", "to_int"], [Bytes], _, _), Icode) ->
-    {typed, _, _, {bytes_t, _, N}} = Bytes,
-    builtin_call({bytes_to_int, N}, [ast_body(Bytes, Icode)]);
-ast_body(?qid_app(["Bytes", "to_str"], [Bytes], _, _), Icode) ->
-    {typed, _, _, {bytes_t, _, N}} = Bytes,
-    builtin_call({bytes_to_str, N}, [ast_body(Bytes, Icode)]);
-
-%% Other terms
-ast_body({id, _, Name}, _Icode) ->
-    #var_ref{name = Name};
-ast_body({qid, _, Name}, _Icode) ->
-    #var_ref{name = Name};
-ast_body({bool, _, Bool}, _Icode) ->        %BOOL as ints
-    Value = if Bool -> 1 ; true -> 0 end,
-    #integer{value = Value};
-ast_body({int, _, Value}, _Icode) ->
-    #integer{value = Value};
-ast_body({bytes, _, Bin}, _Icode) ->
-    case aeb_memory:binary_to_words(Bin) of
-        [Word] -> #integer{value = Word};
-        Words  -> #tuple{cpts = [#integer{value = W} || W <- Words]}
-    end;
-ast_body({Key, _, Bin}, _Icode) when Key == account_pubkey;
-                                     Key == contract_pubkey;
-                                     Key == oracle_pubkey;
-                                     Key == oracle_query_id ->
-    <<Value:32/unit:8>> = Bin,
-    #integer{value = Value};
-ast_body({string,_,Bin}, _Icode) ->
-    Cpts = [size(Bin) | aeb_memory:binary_to_words(Bin)],
-    #tuple{cpts = [#integer{value=X} || X <- Cpts]};
-ast_body({tuple,_,Args}, Icode) ->
-    #tuple{cpts = [ast_body(A, Icode) || A <- Args]};
-ast_body({list,_,Args}, Icode) ->
-    #list{elems = [ast_body(A, Icode) || A <- Args]};
-%% Typed contract calls
-ast_body({proj, _, {typed, _, Addr, {con, _, _}}, {id, _, "address"}}, Icode) ->
-    ast_body(Addr, Icode);  %% Values of contract types _are_ addresses.
-ast_body({app, _, {typed, _, {proj, _, {typed, _, Addr, {con, _, Contract}}, {id, _, FunName}},
-                             {fun_t, _, NamedT, ArgsT, OutT}}, Args0}, Icode) ->
-    NamedArgs = [Arg || Arg = {named_arg, _, _, _} <- Args0],
-    Args      = Args0 -- NamedArgs,
-    ArgOpts   = [ {Name, ast_body(Value, Icode)}   || {named_arg,   _, {id, _, Name}, Value} <- NamedArgs ],
-    Defaults  = [ {Name, ast_body(Default, Icode)} || {named_arg_t, _, {id, _, Name}, _, Default} <- NamedT ],
-    %% TODO: eta expand
-    length(Args) /= length(ArgsT) andalso
-        gen_error({underapplied_contract_call,
-                   string:join([Contract, FunName], ".")}),
-    ArgsI = [ ast_body(Arg, Icode) || Arg <- Args ],
-    ArgType = ast_typerep({tuple_t, [], ArgsT}),
-    Gas    = proplists:get_value("gas",   ArgOpts ++ Defaults),
-    Value  = proplists:get_value("value", ArgOpts ++ Defaults),
-    OutType = ast_typerep(OutT, Icode),
-    <<TypeHash:256>> = aeb_aevm_abi:function_type_hash(list_to_binary(FunName), ArgType, OutType),
-    %% The function is represented by its type hash (which includes the name)
-    Fun    = #integer{value = TypeHash},
-    #prim_call_contract{
-        address  = ast_body(Addr, Icode),
-        gas      = Gas,
-        value    = Value,
-        arg      = #tuple{cpts = [Fun, #tuple{ cpts = ArgsI }]},
-       %% The type check is implicitly done by using the type hash as the
-       %% entrypoint on the callee side.
-        type_hash= #integer{value = 0}
-      };
-ast_body({proj, _, {typed, _, _, {con, _, Contract}}, {id, _, FunName}}, _Icode) ->
-    gen_error({underapplied_contract_call,
-               string:join([Contract, FunName], ".")});
-
-ast_body({con, _, Name}, Icode) ->
-    Tag = aeso_icode:get_constructor_tag([Name], Icode),
-    #tuple{cpts = [#integer{value = Tag}]};
-ast_body({qcon, _, Name}, Icode) ->
-    Tag = aeso_icode:get_constructor_tag(Name, Icode),
-    #tuple{cpts = [#integer{value = Tag}]};
-ast_body({app, _, {typed, _, {con, _, Name}, _}, Args}, Icode) ->
-    Tag = aeso_icode:get_constructor_tag([Name], Icode),
-    #tuple{cpts = [#integer{value = Tag} | [ ast_body(Arg, Icode) || Arg <- Args ]]};
-ast_body({app, _, {typed, _, {qcon, _, Name}, _}, Args}, Icode) ->
-    Tag = aeso_icode:get_constructor_tag(Name, Icode),
-    #tuple{cpts = [#integer{value = Tag} | [ ast_body(Arg, Icode) || Arg <- Args ]]};
-ast_body({app, _, {'..', _}, [A, B]}, Icode) ->
-    #funcall
-    { function = #var_ref{ name = ["ListInternal", "from_to"] }
-    , args     = [ast_body(A, Icode), ast_body(B, Icode)] };
-ast_body({app,As,Fun,Args}, Icode) ->
-    case aeso_syntax:get_ann(format, As) of
-        infix  ->
-            {Op, _} = Fun,
-            [A, B]  = Args,
-            ast_binop(Op, As, A, B, Icode);
-        prefix ->
-            {Op, _} = Fun,
-            [A]     = Args,
-            #unop{op = Op, rand = ast_body(A, Icode)};
-        _ ->
-            #funcall{function=ast_body(Fun, Icode),
-                     args=[ast_body(A, Icode) || A <- Args]}
-    end;
-ast_body({list_comp, _, Yield, []}, Icode) ->
-    #list{elems = [ast_body(Yield, Icode)]};
-ast_body({list_comp, As, Yield, [{comprehension_bind, {typed, Arg, ArgType}, BindExpr}|Rest]}, Icode) ->
-    #funcall
-        { function = #var_ref{ name = ["ListInternal", "flat_map"] }
-        , args =
-              [ #lambda{ args=[#arg{name = ast_id(Arg), type = ast_type(ArgType, Icode)}]
-                       , body = ast_body({list_comp, As, Yield, Rest}, Icode)
-                       }
-              , ast_body(BindExpr, Icode)
-              ]
-        };
-ast_body({list_comp, As, Yield, [{comprehension_if, AsIF, Cond}|Rest]}, Icode) ->
-    ast_body({'if', AsIF, Cond, {list_comp, As, Yield, Rest}, {list, As, []}}, Icode);
-ast_body({list_comp, As, Yield, [LV = {letval, _, _, _, _}|Rest]}, Icode) ->
-    ast_body({block, As, [LV, {list_comp, As, Yield, Rest}]}, Icode);
-ast_body({list_comp, As, Yield, [LF = {letfun, _, _, _, _, _}|Rest]}, Icode) ->
-    ast_body({block, As, [LF, {list_comp, As, Yield, Rest}]}, Icode);
-ast_body({'if',_,Dec,Then,Else}, Icode) ->
-    #ifte{decision = ast_body(Dec, Icode)
-         ,then     = ast_body(Then, Icode)
-         ,else     = ast_body(Else, Icode)};
-ast_body({switch,_,A,Cases}, Icode) ->
-    %% let's assume the parser has already ensured that only valid
-    %% patterns appear in cases.
-    #switch{expr=ast_body(A, Icode),
-            cases=[{ast_body(Pat, Icode),ast_body(Body, Icode)}
-              || {'case',_,Pat,Body} <- Cases]};
-ast_body({block,As,[{letval,_,Pat,_,E}|Rest]}, Icode) ->
-    #switch{expr=ast_body(E, Icode),
-            cases=[{ast_body(Pat, Icode),ast_body({block,As,Rest}, Icode)}]};
-ast_body({block, As, [{letfun, Ann, F, Args, _Type, Expr} | Rest]}, Icode) ->
-    ast_body({block, As, [{letval, Ann, F, unused, {lam, Ann, Args, Expr}} | Rest]}, Icode);
-ast_body({block,_,[]}, _Icode) ->
-    #tuple{cpts=[]};
-ast_body({block,_,[E]}, Icode) ->
-    ast_body(E, Icode);
-ast_body({block,As,[E|Rest]}, Icode) ->
-    #switch{expr=ast_body(E, Icode),
-            cases=[{#var_ref{name="_"},ast_body({block,As,Rest}, Icode)}]};
-ast_body({lam,_,Args,Body}, Icode) ->
-    #lambda{args=[#arg{name = ast_id(P), type = ast_type(T, Icode)} || {arg,_,P,T} <- Args],
-            body=ast_body(Body, Icode)};
-ast_body({typed,_,{record,Attrs,Fields},{record_t,DefFields}}, Icode) ->
-    %% Compile as a tuple with the fields in the order they appear in the definition.
-    NamedField = fun({field, _, [{proj, _, {id, _, Name}}], E}) -> {Name, E} end,
-    NamedFields = lists:map(NamedField, Fields),
-    #tuple{cpts =
-               [case proplists:get_value(Name, NamedFields) of
-                    undefined ->
-                        Line = aeso_syntax:get_ann(line, Attrs),
-                        #missing_field{format = "Missing field in record: ~s (on line ~p)\n",
-                        args = [Name,Line]};
-                    E ->
-                        ast_body(E, Icode)
-                end
-                || {field_t,_,{id,_,Name},_} <- DefFields]};
-ast_body({typed,_,{record,Attrs,_Fields},T}, _Icode) ->
-    gen_error({record_has_bad_type,Attrs,T});
-ast_body({proj,_,{typed,_,Record,{record_t,Fields}},{id,_,FieldName}}, Icode) ->
-    [Index] = [I
-              || {I,{field_t,_,{id,_,Name},_}} <-
-                  lists:zip(lists:seq(1,length(Fields)),Fields),
-              Name==FieldName],
-    #binop{op = '!', left = #integer{value = 32*(Index-1)}, right = ast_body(Record, Icode)};
-ast_body({record, Attrs, {typed, _, Record, RecType={record_t, Fields}}, Update}, Icode) ->
-    UpdatedName = fun({field, _,     [{proj, _, {id, _, Name}}], _}) -> Name;
-                     ({field_upd, _, [{proj, _, {id, _, Name}}], _}) -> Name
-                  end,
-    UpdatedNames = lists:map(UpdatedName, Update),
-    Rec = {typed, Attrs, {id, Attrs, "_record"}, RecType},
-    CompileUpdate =
-        fun(Fld={field, _, _, _}) -> Fld;
-           ({field_upd, Ann, LV=[{proj, Ann1, P}], Fun}) ->
-            {field, Ann, LV, {app, Ann, Fun, [{proj, Ann1, Rec, P}]}}
-        end,
-
-    #switch{expr=ast_body(Record, Icode),
-            cases=[{#var_ref{name = "_record"},
-                ast_body({typed, Attrs,
-                      {record, Attrs,
-                      lists:map(CompileUpdate, Update) ++
-                    [{field, Attrs, [{proj, Attrs, {id, Attrs, Name}}],
-                        {proj, Attrs, Rec, {id, Attrs, Name}}}
-                        || {field_t, _, {id, _, Name}, _} <- Fields,
-                          not lists:member(Name, UpdatedNames)]},
-                      RecType}, Icode)}
-              ]};
-ast_body({typed, _, Body, _}, Icode) ->
-    ast_body(Body, Icode).
-
-ast_binop(Op, Ann, {typed, _, A, Type}, B, Icode)
-    when Op == '=='; Op == '!=';
-         Op == '<';  Op == '>';
-         Op == '<='; Op == '=<'; Op == '>=' ->
-    Monomorphic = is_monomorphic(Type),
-    case ast_typerep(Type, Icode) of
-        _ when not Monomorphic ->
-            gen_error({cant_compare_polymorphic_type, Ann, Op, Type});
-        word   -> #binop{op = Op, left = ast_body(A, Icode), right = ast_body(B, Icode)};
-        OtherType ->
-            Neg = case Op of
-                    '==' -> fun(X) -> X end;
-                    '!=' -> fun(X) -> #unop{ op = '!', rand = X } end;
-                    _    -> gen_error({cant_compare, Ann, Op, Type})
-                  end,
-            Args = [ast_body(A, Icode), ast_body(B, Icode)],
-            Builtin =
-                case OtherType of
-                    string ->
-                        builtin_call(str_equal, Args);
-                    {tuple, Types} ->
-                        case lists:usort(Types) of
-                            [word] ->
-                                builtin_call(str_equal_p, [ #integer{value = 32 * length(Types)} | Args]);
-                            _ -> gen_error({cant_compare, Ann, Op, Type})
-                        end;
-                    _ ->
-                        gen_error({cant_compare, Ann, Op, Type})
-                end,
-            Neg(Builtin)
-    end;
-ast_binop('++', _, A, B, Icode) ->
-    builtin_call(list_concat, [ast_body(A, Icode), ast_body(B, Icode)]);
-ast_binop(Op, _, A, B, Icode) ->
-    #binop{op = Op, left = ast_body(A, Icode), right = ast_body(B, Icode)}.
-
-check_monomorphic_map({typed, Ann, _, MapType}, Icode) ->
-    check_monomorphic_map(Ann, MapType, Icode).
-
-check_monomorphic_map(Ann, Type = ?map_t(KeyType, ValType), Icode) ->
-    case is_monomorphic(KeyType) of
-        true  ->
-            case has_maps(ast_type(KeyType, Icode)) of
-                false -> {KeyType, ValType};
-                true  -> gen_error({cant_use_map_as_map_keys, Ann, Type})
-            end;
-        false -> gen_error({cant_compile_map_with_polymorphic_keys, Ann, Type})
-    end.
-
-map_empty(KeyType, ValType, Icode) ->
-    prim_call(?PRIM_CALL_MAP_EMPTY, #integer{value = 0},
-              [ast_type_value(KeyType, Icode),
-               ast_type_value(ValType, Icode)],
-              [typerep, typerep], word).
-
-map_get(Key, Map = {typed, Ann, _, MapType}, Icode) ->
-    {_KeyType, ValType} = check_monomorphic_map(Ann, MapType, Icode),
-    builtin_call({map_lookup, ast_type(ValType, Icode)}, [ast_body(Map, Icode), ast_body(Key, Icode)]).
-
-map_put(Key, Val, Map, Icode) ->
-    builtin_call(map_put, [ast_body(Map, Icode), ast_body(Key, Icode), ast_body(Val, Icode)]).
-
-map_del(Key, Map, Icode) ->
-    prim_call(?PRIM_CALL_MAP_DELETE, #integer{value = 0},
-              [ast_body(Map, Icode), ast_body(Key, Icode)],
-              [word, word], word).
-
-map_tolist(Map, Icode) ->
-    {KeyType, ValType} = check_monomorphic_map(Map, Icode),
-    prim_call(?PRIM_CALL_MAP_TOLIST, #integer{value = 0},
-              [ast_body(Map, Icode)],
-              [word], {list, {tuple, [ast_type(KeyType, Icode), ast_type(ValType, Icode)]}}).
-
-map_upd(Key, ValFun, Map = {typed, Ann, _, MapType}, Icode) ->
-    {_, ValType} = check_monomorphic_map(Ann, MapType, Icode),
-    FunName = {map_upd, ast_type(ValType, Icode)},
-    Args    = [ast_body(Map, Icode), ast_body(Key, Icode), ast_body(ValFun, Icode)],
-    builtin_call(FunName, Args).
-
-map_upd(Key, Default, ValFun, Map = {typed, Ann, _, MapType}, Icode) ->
-    {_, ValType} = check_monomorphic_map(Ann, MapType, Icode),
-    FunName = {map_upd_default, ast_type(ValType, Icode)},
-    Args    = [ast_body(Map, Icode), ast_body(Key, Icode), ast_body(Default, Icode), ast_body(ValFun, Icode)],
-    builtin_call(FunName, Args).
-
-is_monomorphic({tvar, _, _}) -> false;
-is_monomorphic([H|T]) ->
-  is_monomorphic(H) andalso is_monomorphic(T);
-is_monomorphic(T) when is_tuple(T) ->
-  is_monomorphic(tuple_to_list(T));
-is_monomorphic(_) -> true.
-
-%% Implemented as a contract call to the contract with address 0.
-prim_call(Prim, Amount, Args, ArgTypes, OutType) ->
-    TypeHash =
-        case aeb_primops:op_needs_type_check(Prim) of
-            true ->
-                PrimBin = binary:encode_unsigned(Prim),
-                ArgType = {tuple, ArgTypes},
-                <<TH:256>> = aeb_aevm_abi:function_type_hash(PrimBin, ArgType, OutType),
-                TH;
-            false ->
-                0
-        end,
-    #prim_call_contract{ gas      = prim_gas_left,
-                         address  = #integer{ value = ?PRIM_CALLS_CONTRACT },
-                         value    = Amount,
-                         arg      = #tuple{cpts = [#integer{ value = Prim }| Args]},
-                         type_hash= #integer{value = TypeHash}
-                       }.
-
-generic_hash_primop(PrimOp, Term, Type, Icode) ->
-    ArgType   = ast_type(Type, Icode),
-    TypeValue = type_value(ArgType),
-    prim_call(PrimOp, #integer{value = 0},
-        [TypeValue, ast_body(Term, Icode)],
-        [typerep, ArgType], word).
-
-string_hash_primop(PrimOp, String, Icode) ->
-    prim_call(PrimOp, #integer{value = 0}, [ast_body(String, Icode)], [string], word).
-
-make_type_def(Args, Def, Icode = #{ type_vars := TypeEnv }) ->
-    TVars = [ X || {tvar, _, X} <- Args ],
-    fun(Types) ->
-        TypeEnv1 = maps:from_list(lists:zip(TVars, Types)),
-        ast_typerep(Def, Icode#{ type_vars := maps:merge(TypeEnv, TypeEnv1) })
-    end.
-
--spec ast_typerep(aeso_syntax:type()) -> aeb_aevm_data:type().
-ast_typerep(Type) -> ast_typerep(Type, aeso_icode:new([])).
-
-ast_typerep({id, _, Name}, Icode) ->
-    lookup_type_id(Name, [], Icode);
-ast_typerep({qid, _, Name}, Icode) ->
-    lookup_type_id(Name, [], Icode);
-ast_typerep({con, _, _}, _) ->
-    word;   %% Contract type
-ast_typerep({bytes_t, _, Len}, _) ->
-    bytes_t(Len);
-ast_typerep({app_t, _, {I, _, Name}, Args}, Icode) when I =:= id; I =:= qid ->
-    ArgReps = [ ast_typerep(Arg, Icode) || Arg <- Args ],
-    lookup_type_id(Name, ArgReps, Icode);
-ast_typerep({tvar,_,A}, #{ type_vars := TypeVars }) ->
-    case maps:get(A, TypeVars, undefined) of
-        undefined -> word; %% We serialize type variables just as addresses in the originating VM.
-        Type      -> Type
-    end;
-ast_typerep({tuple_t,_,Cpts}, Icode) ->
-    {tuple, [ast_typerep(C, Icode) || C<-Cpts]};
-ast_typerep({record_t,Fields}, Icode) ->
-    {tuple, [ begin
-                {field_t, _, _, T} = Field,
-                ast_typerep(T, Icode)
-              end || Field <- Fields]};
-ast_typerep({fun_t,_,_,_,_}, _Icode) ->
-    function;
-ast_typerep({alias_t, T}, Icode) -> ast_typerep(T, Icode);
-ast_typerep({variant_t, Cons}, Icode) ->
-    {variant, [ begin
-                  {constr_t, _, _, Args} = Con,
-                  [ ast_typerep(Arg, Icode) || Arg <- Args ]
-                end || Con <- Cons ]}.
-
-ttl_t(Icode) ->
-    ast_typerep({qid, [], ["Chain", "ttl"]}, Icode).
-
-sign_t() -> bytes_t(64).
-bytes_t(Len) when Len =< 32 -> word;
-bytes_t(Len)                -> {tuple, lists:duplicate((31 + Len) div 32, word)}.
-
-get_signature_arg(Args0) ->
-    NamedArgs = [Arg || Arg = {named_arg, _, _, _} <- Args0],
-    Args      = Args0 -- NamedArgs,
-
-    DefaultVal = {tuple, [], [{int, [], 0}, {int, [], 0}]},
-    Sig =
-        case NamedArgs of
-            []                       -> DefaultVal;
-            [{named_arg, _, _, Val}] -> Val
-        end,
-    {Sig, Args}.
-
-lookup_type_id(Name, Args, #{ types := Types }) ->
-    case maps:get(Name, Types, undefined) of
-        undefined -> gen_error({undefined_type, Name});
-        TDef      -> TDef(Args)
-    end.
-
-ast_type_value(T, Icode) ->
-    type_value(ast_type(T, Icode)).
-
-type_value(word)   ->
-    #tuple{ cpts = [#integer{ value = ?TYPEREP_WORD_TAG }] };
-type_value(string) ->
-    #tuple{ cpts = [#integer{ value = ?TYPEREP_STRING_TAG }] };
-type_value(typerep) ->
-    #tuple{ cpts = [#integer{ value = ?TYPEREP_TYPEREP_TAG }] };
-type_value({list, A}) ->
-    #tuple{ cpts = [#integer{ value = ?TYPEREP_LIST_TAG }, type_value(A)] };
-type_value({tuple, As}) ->
-    #tuple{ cpts = [#integer{ value = ?TYPEREP_TUPLE_TAG },
-                    #list{ elems = [ type_value(A) || A <- As ] }] };
-type_value({variant, Cs}) ->
-    #tuple{ cpts = [#integer{ value = ?TYPEREP_VARIANT_TAG },
-                    #list{ elems = [ #list{ elems = [ type_value(A) || A <- As ] } || As <- Cs ] }] };
-type_value({map, K, V}) ->
-    #tuple{ cpts = [#integer{ value = ?TYPEREP_MAP_TAG },
-                    type_value(K), type_value(V)] }.
-
-%% As abort is a built-in in the future it will be illegal to for
-%% users to define abort. For the time being strip away all user
-%% defined abort functions.
-
-ast_fun_to_icode("abort", _Atts, _Args, _Body, _TypeRep, Icode) ->
-    %% Strip away all user defined abort functions.
-    Icode;
-ast_fun_to_icode(Name, Attrs, Args, Body, TypeRep, #{functions := Funs} = Icode) ->
-    NewFuns = [{Name, Attrs, Args, Body, TypeRep}| Funs],
-    aeso_icode:set_functions(NewFuns, Icode).
-
-has_maps({map, _, _})   -> true;
-has_maps(word)          -> false;
-has_maps(string)        -> false;
-has_maps(typerep)       -> false;
-has_maps({list, T})     -> has_maps(T);
-has_maps({tuple, Ts})   -> lists:any(fun has_maps/1, Ts);
-has_maps({variant, Cs}) -> lists:any(fun has_maps/1, lists:append(Cs)).
-
-%% A function is private if not an 'entrypoint', or if it's not defined in the
-%% main contract name space. (NOTE: changes when we introduce inheritance).
-is_private(Ann, #{ contract_name := MainContract } = Icode) ->
-    {_, _, CurrentNamespace} = aeso_icode:get_namespace(Icode),
-    not proplists:get_value(entrypoint, Ann, false) orelse
-    MainContract /= CurrentNamespace.
-
-%% -------------------------------------------------------------------
-%% Builtins
-%% -------------------------------------------------------------------
-
-builtin_call(Builtin, Args) ->
-    #funcall{ function = #var_ref{ name = {builtin, Builtin} },
-              args = Args }.
-
-add_builtins(Icode = #{functions := Funs}) ->
-    Builtins = aeso_builtins:used_builtins(Funs),
-    Icode#{functions := [ aeso_builtins:builtin_function(B) || B <- Builtins ] ++ Funs}.
-
-
-%% -------------------------------------------------------------------
-%% Deadcode elimination
-%% -------------------------------------------------------------------
-
-deadcode_elimination(Icode = #{ functions := Funs }) ->
-    PublicNames = [ Name || {Name, Ann, _, _, _} <- Funs, not lists:member(private, Ann) ],
-    ArgsToPat   = fun(Args) -> [ #var_ref{ name = X } || {X, _} <- Args ] end,
-    Defs        = maps:from_list([ {Name, {binder, ArgsToPat(Args), Body}} || {Name, _, Args, Body, _} <- Funs ]),
-    UsedNames   = chase_names(Defs, PublicNames, #{}),
-    UsedFuns    = [ Def || Def = {Name, _, _, _, _} <- Funs, maps:is_key(Name, UsedNames) ],
-    Icode#{ functions := UsedFuns }.
-
-chase_names(_Defs, [], Used) -> Used;
-chase_names(Defs, [X | Xs], Used) ->
-                              %% can happen when compiling __call contracts
-    case maps:is_key(X, Used) orelse not maps:is_key(X, Defs) of
-        true  -> chase_names(Defs, Xs, Used); %% already chased
-        false ->
-            Def  = maps:get(X, Defs),
-            Vars = maps:keys(free_vars(Def)),
-            chase_names(Defs, Vars ++ Xs, Used#{ X => true })
-    end.
-
-free_vars(#var_ref{ name = X }) -> #{ X => true };
-free_vars(#arg{ name = X }) -> #{ X => true };
-free_vars({binder, Pat, Body}) ->
-    maps:without(maps:keys(free_vars(Pat)), free_vars(Body));
-free_vars(#switch{ expr = E, cases = Cases }) ->
-    free_vars([E | [{binder, P, B} || {P, B} <- Cases]]);
-free_vars(#lambda{ args = Xs, body = E }) ->
-    free_vars({binder, Xs, E});
-free_vars(T) when is_tuple(T) -> free_vars(tuple_to_list(T));
-free_vars([H | T]) -> maps:merge(free_vars(H), free_vars(T));
-free_vars(_) -> #{}.

src/aeso_builtins.erl

@@ -1,577 +0,0 @@
-%%%-------------------------------------------------------------------
-%%% @copyright (C) 2018, Aeternity Anstalt
-%%% @doc
-%%%     Compiler builtin functions for Aeterinty Sophia language.
-%%% @end
-%%% Created : 20 Dec 2018
-%%%
-%%%-------------------------------------------------------------------
-
--module(aeso_builtins).
-
--export([ builtin_function/1
-        , check_event_type/1
-        , used_builtins/1 ]).
-
--import(aeso_ast_to_icode, [prim_call/5]).
-
--include_lib("aebytecode/include/aeb_opcodes.hrl").
--include("aeso_icode.hrl").
-
-used_builtins(#funcall{ function = #var_ref{ name = {builtin, Builtin} }, args = Args }) ->
-    lists:umerge(dep_closure([Builtin]), used_builtins(Args));
-used_builtins([H|T]) ->
-  lists:umerge(used_builtins(H), used_builtins(T));
-used_builtins(T) when is_tuple(T) ->
-  used_builtins(tuple_to_list(T));
-used_builtins(M) when is_map(M) ->
-  used_builtins(maps:to_list(M));
-used_builtins(_) -> [].
-
-builtin_deps(Builtin) ->
-    lists:usort(builtin_deps1(Builtin)).
-
-builtin_deps1({map_lookup_default, Type}) -> [{map_lookup, Type}];
-builtin_deps1({map_get, Type})            -> [{map_lookup, Type}];
-builtin_deps1(map_member)                 -> [{map_lookup, word}];
-builtin_deps1({map_upd, Type})            -> [{map_get, Type}, map_put];
-builtin_deps1({map_upd_default, Type})    -> [{map_lookup_default, Type}, map_put];
-builtin_deps1(map_from_list)              -> [map_put];
-builtin_deps1(str_equal)                  -> [str_equal_p];
-builtin_deps1(string_concat)              -> [string_concat_inner1, string_copy, string_shift_copy];
-builtin_deps1(int_to_str)                 -> [{baseX_int, 10}];
-builtin_deps1(addr_to_str)                -> [{baseX_int, 58}];
-builtin_deps1({baseX_int, X})             -> [{baseX_int_pad, X}];
-builtin_deps1({baseX_int_pad, X})         -> [{baseX_int_encode, X}];
-builtin_deps1({baseX_int_encode, X})      -> [{baseX_int_encode_, X}, {baseX_tab, X}, {baseX_digits, X}];
-builtin_deps1({bytes_to_str, _})          -> [bytes_to_str_worker];
-builtin_deps1(string_reverse)             -> [string_reverse_];
-builtin_deps1(require)                    -> [abort];
-builtin_deps1(_)                          -> [].
-
-dep_closure(Deps) ->
-    case lists:umerge(lists:map(fun builtin_deps/1, Deps)) of
-        []    -> Deps;
-        Deps1 -> lists:umerge(Deps, dep_closure(Deps1))
-    end.
-
-%% Helper functions/macros
-v(X) when is_atom(X) -> v(atom_to_list(X));
-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(NXT(Ptr), op('+', Ptr, 32)).
--define(NEG(A), op('/', A, {unop, '-', {integer, 1}})).
--define(BYTE(Ix, Word), op('byte', Ix, Word)).
-
--define(EQ(A, B), op('==', A, B)).
--define(LT(A, B), op('<', A, B)).
--define(GT(A, B), op('>', A, B)).
--define(ADD(A, B), op('+', A, B)).
--define(SUB(A, B), op('-', A, B)).
--define(MUL(A, B), op('*', A, B)).
--define(DIV(A, B), op('div', A, B)).
--define(MOD(A, B), op('mod', A, B)).
--define(EXP(A, B), op('^', A, B)).
--define(AND(A, B), op('&&', A, B)).
-
-%% Bit shift operations takes their arguments backwards!?
--define(BSL(X, B), op('bsl', ?MUL(B, 8), X)).
--define(BSR(X, B), op('bsr', ?MUL(B, 8), X)).
-
-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.
-
-check_event_type(Icode) ->
-    case maps:get(event_type, Icode) of
-        {variant_t, Cons} ->
-            check_event_type(Cons, Icode);
-        _ ->
-            error({event_should_be_variant_type})
-    end.
-
-check_event_type(Evts, Icode) ->
-    [ check_event_type(Name, Ix, T, Icode)
-      || {constr_t, Ann, {con, _, Name}, Types} <- Evts,
-         {Ix, T} <- lists:zip(aeso_syntax:get_ann(indices, Ann), Types) ].
-
-check_event_type(EvtName, Ix, Type, Icode) ->
-    VMType =
-        try
-           aeso_ast_to_icode:ast_typerep(Type, Icode)
-        catch _:_ ->
-            error({EvtName, could_not_resolve_type, Type})
-        end,
-    case {Ix, VMType, Type} of
-        {indexed, word, _}      -> ok;
-        {notindexed, string, _} -> ok;
-        {notindexed, _, {bytes_t, _, N}} when N > 32 -> ok;
-        {indexed, _, _}         -> error({EvtName, indexed_field_should_be_word, is, VMType});
-        {notindexed, _, _}      -> error({EvtName, payload_should_be_string, is, VMType})
-    end.
-
-bfun(B, {IArgs, IExpr, IRet}) ->
-    {{builtin, B}, [private], IArgs, IExpr, IRet}.
-
-builtin_function(BF) ->
-    case BF of
-        {event, EventT}            -> bfun(BF, builtin_event(EventT));
-        abort                      -> bfun(BF, builtin_abort());
-        block_hash                 -> bfun(BF, builtin_block_hash());
-        require                    -> bfun(BF, builtin_require());
-        {map_lookup, Type}         -> bfun(BF, builtin_map_lookup(Type));
-        map_put                    -> bfun(BF, builtin_map_put());
-        map_delete                 -> bfun(BF, builtin_map_delete());
-        map_size                   -> bfun(BF, builtin_map_size());
-        {map_get, Type}            -> bfun(BF, builtin_map_get(Type));
-        {map_lookup_default, Type} -> bfun(BF, builtin_map_lookup_default(Type));
-        map_member                 -> bfun(BF, builtin_map_member());
-        {map_upd, Type}            -> bfun(BF, builtin_map_upd(Type));
-        {map_upd_default, Type}    -> bfun(BF, builtin_map_upd_default(Type));
-        map_from_list              -> bfun(BF, builtin_map_from_list());
-        list_concat                -> bfun(BF, builtin_list_concat());
-        string_length              -> bfun(BF, builtin_string_length());
-        string_concat              -> bfun(BF, builtin_string_concat());
-        string_concat_inner1       -> bfun(BF, builtin_string_concat_inner1());
-        string_copy                -> bfun(BF, builtin_string_copy());
-        string_shift_copy          -> bfun(BF, builtin_string_shift_copy());
-        str_equal_p                -> bfun(BF, builtin_str_equal_p());
-        str_equal                  -> bfun(BF, builtin_str_equal());
-        popcount                   -> bfun(BF, builtin_popcount());
-        int_to_str                 -> bfun(BF, builtin_int_to_str());
-        addr_to_str                -> bfun(BF, builtin_addr_to_str());
-        {baseX_int, X}             -> bfun(BF, builtin_baseX_int(X));
-        {baseX_digits, X}          -> bfun(BF, builtin_baseX_digits(X));
-        {baseX_tab, X}             -> bfun(BF, builtin_baseX_tab(X));
-        {baseX_int_pad, X}         -> bfun(BF, builtin_baseX_int_pad(X));
-        {baseX_int_encode, X}      -> bfun(BF, builtin_baseX_int_encode(X));
-        {baseX_int_encode_, X}     -> bfun(BF, builtin_baseX_int_encode_(X));
-        {bytes_to_int, N}          -> bfun(BF, builtin_bytes_to_int(N));
-        {bytes_to_str, N}          -> bfun(BF, builtin_bytes_to_str(N));
-        bytes_to_str_worker        -> bfun(BF, builtin_bytes_to_str_worker());
-        string_reverse             -> bfun(BF, builtin_string_reverse());
-        string_reverse_            -> bfun(BF, builtin_string_reverse_())
-    end.
-
-%% Event primitive (dependent on Event type)
-%%
-%% We need to switch on the event and prepare the correct #event for icode_to_asm
-%% NOTE: we assume all errors are already checked!
-builtin_event(EventT) ->
-    A         = fun(X) -> aeb_opcodes:mnemonic(X) end,
-    VIx       = fun(Ix) -> v(lists:concat(["v", Ix])) end,
-    ArgPats   = fun(Ts) -> [ VIx(Ix) || Ix <- lists:seq(0, length(Ts) - 1) ] end,
-    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)}]}
-        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)}
-        end,
-    Pat = fun(Tag, Types) -> {tuple, [{integer, Tag} | ArgPats(Types)]} end,
-
-    {variant_t, Cons} = EventT,
-    Tags              = lists:seq(0, length(Cons) - 1),
-
-    {[{"e", event}],
-     {switch, v(e),
-         [{Pat(Tag, Types), Clause(Tag, Con, lists:zip(aeso_syntax:get_ann(indices, Ann), Types))}
-          || {Tag, {constr_t, Ann, Con, Types}} <- lists:zip(Tags, Cons) ]},
-     {tuple, []}}.
-
-%% Abort primitive.
-builtin_abort() ->
-    A = fun(X) -> aeb_opcodes:mnemonic(X) end,
-    {[{"s", string}],
-     {inline_asm, [A(?PUSH1),0,  %% Push a dummy 0 for the first arg
-                   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),
-    {[{"m", word}, {"k", word}],
-     prim_call(?PRIM_CALL_MAP_GET, #integer{value = 0},
-               [#var_ref{name = "m"}, #var_ref{name = "k"}],
-               [word, word], Ret),
-     Ret}.
-
-builtin_map_put() ->
-    %% We don't need the types for put.
-    {[{"m", word}, {"k", word}, {"v", word}],
-     prim_call(?PRIM_CALL_MAP_PUT, #integer{value = 0},
-               [v(m), v(k), v(v)], [word, word, word], word),
-     word}.
-
-builtin_map_delete() ->
-    {[{"m", word}, {"k", word}],
-     prim_call(?PRIM_CALL_MAP_DELETE, #integer{value = 0},
-               [v(m), v(k)], [word, word], word),
-     word}.
-
-builtin_map_size() ->
-    {[{"m", word}],
-     prim_call(?PRIM_CALL_MAP_SIZE, #integer{value = 0},
-               [v(m)], [word], word),
-     word}.
-
-%% Map builtins
-builtin_map_get(Type) ->
-    %% function map_get(m, k) =
-    %%   switch(map_lookup(m, k))
-    %%     Some(v) => v
-    {[{"m", word}, {"k", word}],
-     {switch, ?call({map_lookup, Type}, [v(m), v(k)]), [{option_some(v(v)), v(v)}]},
-     Type}.
-
-builtin_map_lookup_default(Type) ->
-    %% function map_lookup_default(m, k, default) =
-    %%   switch(map_lookup(m, k))
-    %%     None    => default
-    %%     Some(v) => v
-    {[{"m", word}, {"k", word}, {"default", Type}],
-     {switch, ?call({map_lookup, Type}, [v(m), v(k)]),
-         [{option_none(),     v(default)},
-          {option_some(v(v)), v(v)}]},
-     Type}.
-
-builtin_map_member() ->
-    %% function map_member(m, k) : bool =
-    %%   switch(Map.lookup(m, k))
-    %%     None => false
-    %%     _    => true
-    {[{"m", word}, {"k", word}],
-     {switch, ?call({map_lookup, word}, [v(m), v(k)]),
-         [{option_none(), {integer, 0}},
-          {{var_ref, "_"}, {integer, 1}}]},
-     word}.
-
-builtin_map_upd(Type) ->
-    %% function map_upd(map, key, fun) =
-    %%   map_put(map, key, fun(map_get(map, key)))
-    {[{"map", word}, {"key", word}, {"valfun", word}],
-     ?call(map_put,
-        [v(map), v(key),
-         #funcall{ function = v(valfun),
-                   args     = [?call({map_get, Type}, [v(map), v(key)])] }]),
-     word}.
-
-builtin_map_upd_default(Type) ->
-    %% function map_upd(map, key, val, fun) =
-    %%   map_put(map, key, fun(map_lookup_default(map, key, val)))
-    {[{"map", word}, {"key", word}, {"val", word}, {"valfun", word}],
-     ?call(map_put,
-        [v(map), v(key),
-         #funcall{ function = v(valfun),
-                   args     = [?call({map_lookup_default, Type}, [v(map), v(key), v(val)])] }]),
-     word}.
-
-builtin_map_from_list() ->
-    %% function map_from_list(xs, acc) =
-    %%   switch(xs)
-    %%     [] => acc
-    %%     (k, v) :: xs => map_from_list(xs, acc { [k] = v })
-    {[{"xs", {list, {tuple, [word, word]}}}, {"acc", word}],
-     {switch, v(xs),
-        [{{list, []}, v(acc)},
-         {{binop, '::', {tuple, [v(k), v(v)]}, v(ys)},
-          ?call(map_from_list,
-            [v(ys), ?call(map_put, [v(acc), v(k), v(v)])])}]},
-     word}.
-
-%% list_concat
-%%
-%% Concatenates two lists.
-builtin_list_concat() ->
-    {[{"l1", {list, word}}, {"l2", {list, word}}],
-     {switch, v(l1),
-        [{{list, []}, v(l2)},
-         {{binop, '::', v(hd), v(tl)},
-          {binop, '::', v(hd), ?call(list_concat, [v(tl), v(l2)])}}
-        ]
-     },
-     word}.
-
-builtin_string_length() ->
-    %% function length(str) =
-    %%   switch(str)
-    %%      {n} -> n  // (ab)use the representation
-    {[{"s", string}],
-     ?DEREF(n, s, ?V(n)),
-     word}.
-
-%% str_concat - concatenate two strings
-%%
-%% Unless the second string is the empty string, a new string is created at the
-%% top of the Heap and the address to it is returned. The tricky bit is when
-%% the words from the second string has to be shifted to fit next to the first
-%% string.
-builtin_string_concat() ->
-    {[{"s1", string}, {"s2", string}],
-     ?DEREF(n1, s1,
-     ?DEREF(n2, s2,
-        {ifte, ?EQ(n1, 0),
-            ?V(s2), %% First string is empty return second string
-            {ifte, ?EQ(n2, 0),
-                ?V(s1), %% Second string is empty return first string
-                ?LET(ret, {inline_asm, [?A(?MSIZE)]},
-                    {seq, [?ADD(n1, n2), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]}, %% Store total len
-                           ?call(string_concat_inner1, [?V(n1), ?NXT(s1), ?V(n2), ?NXT(s2)]),
-                           {inline_asm, [?A(?POP)]}, %% Discard fun ret val
-                           ?V(ret)                   %% Put the actual return value
-                          ]})}
-        }
-     )),
-     word}.
-
-builtin_string_concat_inner1() ->
-    %% Copy all whole words from the first string, and set up for word fusion
-    %% Special case when the length of the first string is divisible by 32.
-    {[{"n1", word}, {"p1", pointer}, {"n2", word}, {"p2", pointer}],
-     ?LET(w1, ?call(string_copy, [?V(n1), ?V(p1)]),
-        ?LET(nx, ?MOD(n1, 32),
-        {ifte, ?EQ(nx, 0),
-            ?LET(w2, ?call(string_copy, [?V(n2), ?V(p2)]),
-                {seq, [?V(w2), {inline_asm, [?A(?MSIZE), ?A(?MSTORE), ?A(?MSIZE)]}]}),
-            ?call(string_shift_copy, [?V(nx), ?V(w1), ?V(n2), ?V(p2)])
-        })),
-     word}.
-
-builtin_string_copy() ->
-    {[{"n", word}, {"p", pointer}],
-     ?DEREF(w, p,
-        {ifte, ?GT(n, 31),
-            {seq, [?V(w), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
-                   ?call(string_copy, [?SUB(n, 32), ?NXT(p)])]},
-            ?V(w)
-        }),
-     word}.
-
-builtin_string_shift_copy() ->
-    {[{"off", word}, {"dst", word}, {"n", word}, {"p", pointer}],
-     ?DEREF(w, p,
-        {seq, [?ADD(dst, ?BSR(w, off)), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
-               {ifte, ?GT(n, ?SUB(32, off)),
-                    ?call(string_shift_copy, [?V(off), ?BSL(w, ?SUB(32, off)), ?SUB(n, 32), ?NXT(p)]),
-                    {inline_asm, [?A(?MSIZE)]}}]
-        }),
-     word}.
-
-builtin_str_equal_p() ->
-    %% function str_equal_p(n, p1, p2) =
-    %%   if(n =< 0) true
-    %%   else
-    %%      let w1 = *p1
-    %%      let w2 = *p2
-    %%      w1 == w2 && str_equal_p(n - 32, p1 + 32, p2 + 32)
-    {[{"n", word}, {"p1", pointer}, {"p2", pointer}],
-     {ifte, ?LT(n, 1),
-         ?I(1),
-         ?DEREF(w1, p1,
-         ?DEREF(w2, p2,
-             ?AND(?EQ(w1, w2),
-                  ?call(str_equal_p, [?SUB(n, 32), ?NXT(p1), ?NXT(p2)]))))},
-     word}.
-
-builtin_str_equal() ->
-    %% function str_equal(s1, s2) =
-    %%   let n1 = length(s1)
-    %%   let n2 = length(s2)
-    %%   n1 == n2 && str_equal_p(n1, s1 + 32, s2 + 32)
-    {[{"s1", string}, {"s2", string}],
-     ?DEREF(n1, s1,
-     ?DEREF(n2, s2,
-         ?AND(?EQ(n1, n2), ?call(str_equal_p, [?V(n1), ?NXT(s1), ?NXT(s2)]))
-     )),
-     word}.
-
-%% Count the number of 1s in a bit field.
-builtin_popcount() ->
-    %% function popcount(bits, acc) =
-    %%   if (bits == 0) acc
-    %%   else popcount(bits bsr 1, acc + bits band 1)
-    {[{"bits", word}, {"acc", word}],
-     {ifte, ?EQ(bits, 0),
-        ?V(acc),
-        ?call(popcount, [op('bsr', 1, bits), ?ADD(acc, op('band', bits, 1))])
-     }, word}.
-
-builtin_int_to_str() ->
-    {[{"i", word}], ?call({baseX_int, 10}, [?V(i)]), word}.
-
-builtin_baseX_tab(_X = 10) ->
-    {[{"ix", word}], ?ADD($0, ix), word};
-builtin_baseX_tab(_X = 58) ->
-    <<Fst32:256>> = <<"123456789ABCDEFGHJKLMNPQRSTUVWXY">>,
-    <<Lst26:256>> = <<"Zabcdefghijkmnopqrstuvwxyz", 0:48>>,
-    {[{"ix", word}],
-     {ifte, ?LT(ix, 32),
-         ?BYTE(ix, Fst32),
-         ?BYTE(?SUB(ix, 32), Lst26)
-     },
-     word}.
-
-builtin_baseX_int(X) ->
-    {[{"w", word}],
-     ?LET(ret, {inline_asm, [?A(?MSIZE)]},
-        {seq, [?call({baseX_int_pad, X}, [?V(w), ?I(0), ?I(0)]), {inline_asm, [?A(?POP)]}, ?V(ret)]}),
-     word}.
-
-builtin_baseX_int_pad(X = 10) ->
-    {[{"src", word}, {"ix", word}, {"dst", word}],
-     {ifte, ?LT(src, 0),
-        ?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),
-         ?call({baseX_int_encode, X}, [?V(src), ?V(ix), ?V(dst)]),
-         ?call({baseX_int_pad, X}, [?V(src), ?ADD(ix, 1), ?ADD(dst, ?BSL($1, ?SUB(31, ix)))])},
-     word}.
-
-builtin_baseX_int_encode(X) ->
-    {[{"src", word}, {"ix", word}, {"dst", word}],
-     ?LET(n, ?call({baseX_digits, X}, [?V(src), ?I(0)]),
-        {seq, [?ADD(n, ?ADD(ix, 1)), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
-               ?call({baseX_int_encode_, X}, [?V(src), ?V(dst), ?EXP(X, n), ?V(ix)])]}),
-     word}.
-
-builtin_baseX_int_encode_(X) ->
-    {[{"src", word}, {"dst", word}, {"fac", word}, {"ix", word}],
-     {ifte, ?EQ(fac, 0),
-         {seq, [?V(dst), {inline_asm, [?A(?MSIZE), ?A(?MSTORE), ?A(?MSIZE)]}]},
-         {ifte, ?EQ(ix, 32),
-              %% We've filled a word, write it and start on new word
-              {seq, [?V(dst), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
-                     ?call({baseX_int_encode_, X}, [?V(src), ?I(0), ?V(fac), ?I(0)])]},
-              ?call({baseX_int_encode_, X},
-                    [?MOD(src, fac), ?ADD(dst, ?BSL(?call({baseX_tab, X}, [?DIV(src, fac)]), ?SUB(31, ix))),
-                     ?DIV(fac, X), ?ADD(ix, 1)])}
-     },
-     word}.
-
-builtin_baseX_digits(X) ->
-    {[{"x0", word}, {"dgts", word}],
-     ?LET(x1, ?DIV(x0, X),
-        {ifte, ?EQ(x1, 0), ?V(dgts), ?call({baseX_digits, X}, [?V(x1), ?ADD(dgts, 1)])}),
-     word}.
-
-builtin_bytes_to_int(32) ->
-    {[{"w", word}], ?V(w), word};
-builtin_bytes_to_int(N) when N < 32 ->
-    {[{"w", word}], ?BSR(w, 32 - N), word};
-builtin_bytes_to_int(N) when N > 32 ->
-    LastFullWord = N div 32 - 1,
-    Body = case N rem 32 of
-                0 -> ?DEREF(n, ?ADD(b, LastFullWord * 32), ?V(n));
-                R ->
-                    ?DEREF(hi, ?ADD(b, LastFullWord * 32),
-                    ?DEREF(lo, ?ADD(b, (LastFullWord + 1) * 32),
-                    ?ADD(?BSR(lo, 32 - R), ?BSL(hi, R))))
-           end,
-    {[{"b", pointer}], Body, word}.
-
-builtin_bytes_to_str_worker() ->
-    <<Tab:256>> = <<"0123456789ABCDEF________________">>,
-    {[{"w", word}, {"offs", word}, {"acc", word}],
-     {seq, [{ifte, ?AND(?GT(offs, 0), ?EQ(0, ?MOD(offs, 16))),
-                    {seq, [?V(acc), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]}]},
-                    {inline_asm, []}},
-            {ifte, ?EQ(offs, 32), {inline_asm, [?A(?MSIZE)]},
-                ?LET(b,  ?BYTE(offs, w),
-                ?LET(lo, ?BYTE(?MOD(b, 16), Tab),
-                ?LET(hi, ?BYTE(op('bsr', 4 , b), Tab),
-                ?call(bytes_to_str_worker,
-                      [?V(w), ?ADD(offs, 1), ?ADD(?BSL(acc, 2), ?ADD(?BSL(hi, 1), lo))]))))
-            }
-           ]},
-     word}.
-
-builtin_bytes_to_str(N) when N =< 32 ->
-    {[{"w", word}],
-     ?LET(ret, {inline_asm, [?A(?MSIZE)]},
-     {seq, [?I(N * 2), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
-            ?call(bytes_to_str_worker, [?V(w), ?I(0), ?I(0)]),
-            {inline_asm, [?A(?POP)]},
-            ?V(ret)]}),
-     string};
-builtin_bytes_to_str(N) when N > 32 ->
-    Work = fun(I) ->
-            [?DEREF(w, ?ADD(p, 32 * I), ?call(bytes_to_str_worker, [?V(w), ?I(0), ?I(0)])),
-             {inline_asm, [?A(?POP)]}]
-           end,
-    {[{"p", pointer}],
-     ?LET(ret, {inline_asm, [?A(?MSIZE)]},
-     {seq, [?I(N * 2), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]}] ++
-           lists:append([ Work(I) || I <- lists:seq(0, (N + 31) div 32 - 1) ]) ++
-           [?V(ret)]}),
-     string}.
-
-builtin_string_reverse() ->
-    {[{"s", string}],
-     ?DEREF(n, s,
-     ?LET(ret, {inline_asm, [?A(?MSIZE)]},
-         {seq, [?V(n), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
-                ?call(string_reverse_, [?NXT(s), ?I(0), ?I(31), ?SUB(?V(n), 1)]),
-                {inline_asm, [?A(?POP)]}, ?V(ret)]})),
-     word}.
-
-builtin_string_reverse_() ->
-    {[{"p", pointer}, {"x", word}, {"i1", word}, {"i2", word}],
-     {ifte, ?LT(i2, 0),
-         {seq, [?V(x), {inline_asm, [?A(?MSIZE), ?A(?MSTORE), ?A(?MSIZE)]}]},
-         ?LET(p1, ?ADD(p, ?MUL(?DIV(i2, 32), 32)),
-         ?DEREF(w, p1,
-         ?LET(b, ?BYTE(?MOD(i2, 32), w),
-         {ifte, ?LT(i1, 0),
-             {seq, [?V(x), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
-                    ?call(string_reverse_,
-                          [?V(p), ?BSL(b, 31), ?I(30), ?SUB(i2, 1)])]},
-             ?call(string_reverse_,
-                   [?V(p), ?ADD(x, ?BSL(b, i1)), ?SUB(i1, 1), ?SUB(i2, 1)])})))},
-     word}.
-
-builtin_addr_to_str() ->
-    {[{"a", word}], ?call({baseX_int, 58}, [?V(a)]), word}.
-

src/aeso_code_errors.erl

@@ -0,0 +1,94 @@
+%%%-------------------------------------------------------------------
+%%% @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'",
+                        [Kind, C]),
+    mk_err(pos(Decl), Msg);
+format({missing_init_function, Con}) ->
+    Msg = io_lib:format("Missing init function for the contract '~s'.", [pp_expr(Con)]),
+    Cxt = "The 'init' function can only be omitted if the state type is 'unit'.",
+    mk_err(pos(Con), Msg, Cxt);
+format({missing_definition, Id}) ->
+    Msg = io_lib:format("Missing definition of function '~s'.", [pp_expr(Id)]),
+    mk_err(pos(Id), Msg);
+format({parameterized_state, Decl}) ->
+    Msg = "The state type cannot be parameterized.",
+    mk_err(pos(Decl), Msg);
+format({parameterized_event, Decl}) ->
+    Msg = "The event type cannot be parameterized.",
+    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.",
+                        [ThingS, Name, Bad]),
+    case Why of
+        higher_order -> mk_err(pos(Ann), Msg)
+    end;
+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).",
+                        [pp_type(2, T)]),
+    mk_err(pos(Ann), Msg);
+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", [pp_type(2, Type)]),
+    Cxt = io_lib:format("The ~s type must not be ~s.", [What, WhyS]),
+    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

@@ -2,7 +2,7 @@
 %%% @author Happi (Erik Stenman)
 %%% @copyright (C) 2017, Aeternity Anstalt
 %%% @doc
-%%%     Compiler from Aeterinty Sophia language to the Aeternity VM, aevm.
+%%%     Compiler from Aeterinty Sophia language to FATE.
 %%% @end
 %%% Created : 12 Dec 2017
 %%%-------------------------------------------------------------------
@@ -12,34 +12,35 @@
         , file/2
         , from_string/2
         , check_call/4
-        , create_calldata/3  %% deprecated
+        , create_calldata/3
         , create_calldata/4
         , version/0
-        , sophia_type_to_typerep/1
-        , to_sophia_value/4  %% deprecated, need a backend
+        , numeric_version/0
+        , to_sophia_value/4
         , to_sophia_value/5
-        , decode_calldata/3  %% deprecated
+        , decode_calldata/3
         , decode_calldata/4
         , parse/2
         , add_include_path/2
+        , validate_byte_code/3
         ]).
 
 -include_lib("aebytecode/include/aeb_opcodes.hrl").
--include("aeso_icode.hrl").
+-include("aeso_utils.hrl").
 
 
 -type option() :: pp_sophia_code
                 | pp_ast
                 | pp_types
                 | pp_typed_ast
-                | pp_icode
                 | pp_assembler
-                | pp_bytecode
                 | no_code
-                | {backend, aevm | fate}
+                | keep_included
+                | debug_mode
                 | {include, {file_system, [string()]} |
                             {explicit_files, #{string() => binary()}}}
-                | {src_file, string()}.
+                | {src_file, string()}
+                | {aci, aeso_aci:aci_type()}.
 -type options() :: [option()].
 
 -export_type([ option/0
@@ -65,18 +66,29 @@ version() ->
             {ok, list_to_binary(VsnString)}
     end.
 
--spec file(string()) -> {ok, map()} | {error, binary()}.
+-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()]}.
 file(Filename) ->
     file(Filename, []).
 
--spec file(string(), options()) -> {ok, map()} | {error, binary()}.
+-spec file(string(), options()) -> {ok, map()} | {error, [aeso_errors:error()]}.
 file(File, Options0) ->
     Options = add_include_path(File, Options0),
     case read_contract(File) of
         {ok, Bin} -> from_string(Bin, [{src_file, File} | Options]);
         {error, Error} ->
-	    ErrorString = [File,": ",file:format_error(Error)],
-	    {error, join_errors("File errors", [ErrorString], fun(E) -> E end)}
+            Msg = lists:flatten([File,": ",file:format_error(Error)]),
+            {error, [aeso_errors:new(file_error, Msg)]}
     end.
 
 add_include_path(File, Options) ->
@@ -88,84 +100,62 @@ add_include_path(File, Options) ->
             [{include, {file_system, [Cwd, Dir]}} | Options]
     end.
 
--spec from_string(binary() | string(), options()) -> {ok, map()} | {error, binary()}.
-from_string(Contract, Options) ->
-    from_string(proplists:get_value(backend, Options, aevm), Contract, Options).
-
-from_string(Backend, ContractBin, Options) when is_binary(ContractBin) ->
-    from_string(Backend, binary_to_list(ContractBin), Options);
-from_string(Backend, ContractString, Options) ->
+-spec from_string(binary() | string(), options()) -> {ok, map()} | {error, [aeso_errors:error()]}.
+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)
+        from_string1(ContractString, Options)
     catch
-        %% The compiler errors.
-        error:{parse_errors, Errors} ->
-            {error, join_errors("Parse errors", Errors, fun(E) -> E end)};
-        error:{type_errors, Errors} ->
-            {error, join_errors("Type errors", Errors, fun(E) -> E end)};
-        error:{code_errors, Errors} ->
-            {error, join_errors("Code errors", Errors,
-                                fun (E) -> io_lib:format("~p", [E]) end)}
-        %% General programming errors in the compiler just signal error.
+        throw:{error, Errors} -> {error, Errors}
     end.
 
-from_string1(aevm, ContractString, Options) ->
-    #{icode := Icode} = string_to_code(ContractString, Options),
-    TypeInfo  = extract_type_info(Icode),
-    Assembler = assemble(Icode, Options),
-    pp_assembler(Assembler, Options),
-    ByteCodeList = to_bytecode(Assembler, Options),
-    ByteCode = << << B:8 >> || B <- ByteCodeList >>,
-    pp_bytecode(ByteCode, Options),
-    {ok, Version} = version(),
-    {ok, #{byte_code => ByteCode,
-           compiler_version => Version,
-           contract_source => ContractString,
-           type_info => TypeInfo,
-           abi_version => aeb_aevm_abi:abi_version(),
-           payable => maps:get(payable, Icode)
-          }};
-from_string1(fate, ContractString, Options) ->
-    #{fcode := FCode} = string_to_code(ContractString, Options),
-    FateCode = aeso_fcode_to_fate:compile(FCode, Options),
+from_string1(ContractString, Options) ->
+    #{ fcode := FCode
+     , fcode_env := #{child_con_env := ChildContracts}
+     , folded_typed_ast := FoldedTypedAst
+     , warnings := Warnings } = string_to_code(ContractString, Options),
+    FateCode = aeso_fcode_to_fate:compile(ChildContracts, FCode, Options),
+    pp_assembler(FateCode, Options),
     ByteCode = aeb_fate_code:serialize(FateCode, []),
     {ok, Version} = version(),
-    {ok, #{byte_code => ByteCode,
+    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)
-          }}.
+            payable => maps:get(payable, FCode),
+            warnings => Warnings
+           },
+    {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) ->
     Ast = parse(ContractString, Options),
     pp_sophia_code(Ast, Options),
     pp_ast(Ast, Options),
-    {TypeEnv, TypedAst} = aeso_ast_infer_types:infer(Ast, [return_env]),
-    pp_typed_ast(TypedAst, Options),
-    case proplists:get_value(backend, Options, aevm) of
-        aevm ->
-            Icode = ast_to_icode(TypedAst, Options),
-            pp_icode(Icode, Options),
-            #{ icode => Icode,
-               typed_ast => TypedAst,
-               type_env  => TypeEnv};
-        fate ->
-            Fcode = aeso_ast_to_fcode:ast_to_fcode(TypedAst, Options),
-            #{ fcode => Fcode,
-               typed_ast => TypedAst,
-               type_env  => TypeEnv}
-    end.
-
-join_errors(Prefix, Errors, Pfun) ->
-    Ess = [ Pfun(E) || E <- Errors ],
-    list_to_binary(string:join([Prefix|Ess], "\n")).
+    {TypeEnv, FoldedTypedAst, UnfoldedTypedAst, Warnings} = aeso_ast_infer_types:infer(Ast, [return_env | Options]),
+    pp_typed_ast(UnfoldedTypedAst, Options),
+    {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
+    ,  warnings => Warnings }.
 
 -define(CALL_NAME,   "__call").
--define(DECODE_NAME, "__decode").
 
 %% Takes a string containing a contract with a declaration/prototype of a
 %% function (foo, say) and adds function __call() = foo(args) calling this
@@ -173,10 +163,8 @@ join_errors(Prefix, Errors, Pfun) ->
 %% terms for the arguments.
 %% NOTE: Special treatment for "init" since it might be implicit and has
 %%       a special return type (typerep, T)
--spec check_call(string(), string(), [string()], options()) -> {ok, string(), {[Type], Type}, [term()]}
-                                                                   | {ok, string(), [term()]}
-                                                                   | {error, term()}
-    when Type :: term().
+-spec check_call(string(), string(), [string()], options()) -> {ok, string(), [term()]}
+                                                             | {error, [aeso_errors:error()]}.
 check_call(Source, "init" = FunName, Args, Options) ->
     case check_call1(Source, FunName, Args, Options) of
         Err = {error, _} when Args == [] ->
@@ -193,53 +181,22 @@ check_call(Source, FunName, Args, Options) ->
 
 check_call1(ContractString0, FunName, Args, Options) ->
     try
-        case proplists:get_value(backend, Options, aevm) of
-            aevm ->
         %% First check the contract without the __call function
-                #{} = string_to_code(ContractString0, Options),
-                ContractString = insert_call_function(ContractString0, ?CALL_NAME, FunName, Args, Options),
-                #{typed_ast := TypedAst,
-                  icode     := Icode} = string_to_code(ContractString, Options),
-                {ok, {FunName, {fun_t, _, _, ArgTypes, RetType}}} = get_call_type(TypedAst),
-                ArgVMTypes = [ aeso_ast_to_icode:ast_typerep(T, Icode) || T <- ArgTypes ],
-                RetVMType  = case RetType of
-                                 {id, _, "_"} -> any;
-                                 _            -> aeso_ast_to_icode:ast_typerep(RetType, Icode)
-                             end,
-                #{ functions := Funs } = Icode,
-                ArgIcode = get_arg_icode(Funs),
-                ArgTerms = [ icode_to_term(T, Arg) ||
-                               {T, Arg} <- lists:zip(ArgVMTypes, ArgIcode) ],
-                RetVMType1 =
-                    case FunName of
-                        "init" -> {tuple, [typerep, RetVMType]};
-                        _ -> RetVMType
-                    end,
-                {ok, FunName, {ArgVMTypes, RetVMType1}, ArgTerms};
-            fate ->
-                %% First check the contract without the __call function
-                #{fcode := OrgFcode} = string_to_code(ContractString0, Options),
-                FateCode = aeso_fcode_to_fate:compile(OrgFcode, []),
+        #{fcode := OrgFcode
+        , fcode_env := #{child_con_env := ChildContracts}
+        , ast := Ast} = string_to_code(ContractString0, Options),
+        FateCode = aeso_fcode_to_fate:compile(ChildContracts, OrgFcode, []),
         %% collect all hashes and compute the first name without hash collision to
         SymbolHashes = maps:keys(aeb_fate_code:symbols(FateCode)),
         CallName = first_none_match(?CALL_NAME, SymbolHashes,
                                     lists:seq($1, $9) ++ lists:seq($A, $Z) ++ lists:seq($a, $z)),
-                ContractString = insert_call_function(ContractString0, CallName, FunName, Args, Options),
+        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
     catch
-        error:{parse_errors, Errors} ->
-            {error, join_errors("Parse errors", Errors, fun (E) -> E end)};
-        error:{type_errors, Errors} ->
-            {error, join_errors("Type errors", Errors, fun (E) -> E end)};
-        error:{badmatch, {error, missing_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)}
+        throw:{error, Errors} -> {error, Errors}
     end.
 
 arguments_of_body(CallName, _FunName, Fcode) ->
@@ -259,9 +216,8 @@ first_none_match(CallName, Hashes, [Char|Chars]) ->
     end.
 
 %% Add the __call function to a contract.
--spec insert_call_function(string(), string(), string(), [string()], options()) -> string().
-insert_call_function(Code, Call, FunName, Args, Options) ->
-    Ast = parse(Code, Options),
+-spec insert_call_function(aeso_syntax:ast(), string(), string(), string(), [string()]) -> string().
+insert_call_function(Ast, Code, Call, FunName, Args) ->
     Ind = last_contract_indent(Ast),
     lists:flatten(
         [ Code,
@@ -286,144 +242,80 @@ last_contract_indent(Decls) ->
         _                     -> 0
     end.
 
--spec to_sophia_value(string(), string(), ok | error | revert, aeb_aevm_data:data()) ->
-        {ok, aeso_syntax:expr()} | {error, term()}.
+-spec to_sophia_value(string(), string(), ok | error | revert, binary()) ->
+          {ok, aeso_syntax:expr()} | {error, [aeso_errors:error()]}.
 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, term()}.
+        {ok, aeso_syntax:expr()} | {error, [aeso_errors:error()]}.
 to_sophia_value(_, _, error, Err, _Options) ->
     {ok, {app, [], {id, [], "error"}, [{string, [], Err}]}};
-to_sophia_value(_, _, revert, Data, Options) ->
-    case proplists:get_value(backend, Options, aevm) of
-        aevm ->
-            case aeb_heap:from_binary(string, Data) of
-                {ok, Err} -> {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}};
-                {error, _} = Err -> Err
-            end;
-        fate ->
-            Err = aeb_fate_encoding:deserialize(Data),
-            {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}}
+to_sophia_value(_, _, revert, Data, _Options) ->
+    try aeso_vm_decode:from_fate({id, [], "string"}, aeb_fate_encoding:deserialize(Data)) of
+        Err ->
+            {ok, {app, [], {id, [], "abort"}, [Err]}}
+    catch _:_ ->
+            Msg = "Could not deserialize the revert message",
+            {error, [aeso_errors:new(data_error, Msg)]}
     end;
 to_sophia_value(ContractString, FunName, ok, Data, Options0) ->
     Options = [no_code | Options0],
     try
         Code = string_to_code(ContractString, Options),
-        #{ typed_ast := TypedAst, type_env  := TypeEnv} = Code,
+        #{ unfolded_typed_ast := TypedAst, type_env  := TypeEnv} = Code,
         {ok, _, Type0} = get_decode_type(FunName, TypedAst),
         Type   = aeso_ast_infer_types:unfold_types_in_type(TypeEnv, Type0, [unfold_record_types, unfold_variant_types]),
 
-        case proplists:get_value(backend, Options, aevm) of
-            aevm ->
-                Icode  = maps:get(icode, Code),
-                VmType = aeso_ast_to_icode:ast_typerep(Type, Icode),
-                case aeb_heap:from_binary(VmType, Data) of
-                    {ok, VmValue} ->
-                        try
-                            {ok, aeso_vm_decode:from_aevm(VmType, Type, VmValue)}
-                        catch throw:cannot_translate_to_sophia ->
-                            Type0Str = prettypr:format(aeso_pretty:type(Type0)),
-                            {error, join_errors("Translation error", [lists:flatten(io_lib:format("Cannot translate VM value ~p\n  of type ~p\n  to Sophia type ~s\n",
-                                                                                    [Data, VmType, Type0Str]))],
-                                                fun (E) -> E end)}
-                        end;
-                    {error, _Err} ->
-                        {error, join_errors("Decode errors", [lists:flatten(io_lib:format("Failed to decode binary at type ~p", [VmType]))],
-                                            fun(E) -> E end)}
-                end;
-            fate ->
         try
             {ok, aeso_vm_decode:from_fate(Type, aeb_fate_encoding:deserialize(Data))}
         catch throw:cannot_translate_to_sophia ->
-                   {error, join_errors("Translation error",
-                                       [lists:flatten(io_lib:format("Cannot translate fate value ~p\n of Sophia type ~s\n",
-                                                                    [aeb_fate_encoding:deserialize(Data), Type]))],
-                                       fun (E) -> E end)};
-                     _:R ->
-                   {error, iolist_to_binary(io_lib:format("Decode error ~p: ~p\n", [R, erlang:get_stacktrace()]))}
-               end
+                Type1 = prettypr:format(aeso_pretty:type(Type0)),
+                Msg = io_lib:format("Cannot translate FATE value ~p\n  of Sophia type ~s",
+                                    [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", [Type1]),
+                {error, [aeso_errors:new(data_error, Msg)]}
         end
     catch
-        error:{parse_errors, Errors} ->
-            {error, join_errors("Parse errors", Errors, fun (E) -> E end)};
-        error:{type_errors, Errors} ->
-            {error, join_errors("Type errors", Errors, fun (E) -> E end)};
-        error:{badmatch, {error, missing_function}} ->
-            {error, join_errors("Type errors", ["no function: '" ++ FunName ++ "'"],
-                                fun (E) -> E end)};
-        throw:Error ->                          %Don't ask
-            {error, join_errors("Code errors", [Error],
-                                fun (E) -> io_lib:format("~p", [E]) end)}
+        throw:{error, Errors} -> {error, Errors}
     end.
 
-
 -spec create_calldata(string(), string(), [string()]) ->
-                             {ok, binary(), aeb_aevm_data:type(), aeb_aevm_data:type()}
-                             | {error, term()}.
+          {ok, binary()} | {error, [aeso_errors:error()]}.
 create_calldata(Code, Fun, Args) ->
-    create_calldata(Code, Fun, Args, [{backend, aevm}]).
-
+    create_calldata(Code, Fun, Args, []).
 -spec create_calldata(string(), string(), [string()], [{atom(), any()}]) ->
-                             {ok, binary()}
-                             | {error, term()}.
+                             {ok, binary()} | {error, [aeso_errors:error()]}.
 create_calldata(Code, Fun, Args, Options0) ->
     Options = [no_code | Options0],
-    case proplists:get_value(backend, Options, aevm) of
-        aevm ->
-            case check_call(Code, Fun, Args, Options) of
-                {ok, FunName, {ArgTypes, RetType}, VMArgs} ->
-                    aeb_aevm_abi:create_calldata(FunName, VMArgs, ArgTypes, RetType);
-                {error, _} = Err -> Err
-            end;
-        fate ->
     case check_call(Code, Fun, Args, Options) of
         {ok, FunName, FateArgs} ->
             aeb_fate_abi:create_calldata(FunName, FateArgs);
         {error, _} = Err -> Err
-            end
     end.
 
 -spec decode_calldata(string(), string(), binary()) ->
           {ok, [aeso_syntax:type()], [aeso_syntax:expr()]}
-                             | {error, term()}.
+        | {error, [aeso_errors:error()]}.
 decode_calldata(ContractString, FunName, Calldata) ->
-    decode_calldata(ContractString, FunName, Calldata, [{backend, aevm}]).
-
+    decode_calldata(ContractString, FunName, Calldata, []).
+-spec decode_calldata(string(), string(), binary(), options()) ->
+          {ok, [aeso_syntax:type()], [aeso_syntax:expr()]}
+        | {error, [aeso_errors:error()]}.
 decode_calldata(ContractString, FunName, Calldata, Options0) ->
     Options = [no_code | Options0],
     try
         Code = string_to_code(ContractString, Options),
-        #{ typed_ast := TypedAst, type_env  := TypeEnv} = Code,
+        #{ unfolded_typed_ast := TypedAst, type_env  := TypeEnv} = Code,
 
         {ok, Args, _} = get_decode_type(FunName, TypedAst),
-        DropArg       = fun({arg, _, _, T}) -> T; (T) -> T end,
-        ArgTypes      = lists:map(DropArg, Args),
+        GetType       = fun({typed, _, _, T}) -> T; (T) -> T end,
+        ArgTypes      = lists:map(GetType, Args),
         Type0         = {tuple_t, [], ArgTypes},
         %% user defined data types such as variants needed to match against
         Type          = aeso_ast_infer_types:unfold_types_in_type(TypeEnv, Type0, [unfold_record_types, unfold_variant_types]),
-        case proplists:get_value(backend, Options, aevm) of
-            aevm ->
-                Icode  = maps:get(icode, Code),
-                VmType = aeso_ast_to_icode:ast_typerep(Type, Icode),
-                case aeb_heap:from_binary({tuple, [word, VmType]}, Calldata) of
-                    {ok, {_, VmValue}} ->
-                        try
-                            {tuple, [], Values} = aeso_vm_decode:from_aevm(VmType, Type, VmValue),
-                            %% Values are Sophia expressions in AST format
-                            {ok, ArgTypes, Values}
-                        catch throw:cannot_translate_to_sophia ->
-                                Type0Str = prettypr:format(aeso_pretty:type(Type0)),
-                                {error, join_errors("Translation error",
-                                                    [lists:flatten(io_lib:format("Cannot translate VM value ~p\n  of type ~p\n  to Sophia type ~s\n",
-                                                                                 [VmValue, VmType, Type0Str]))],
-                                                    fun (E) -> E end)}
-                        end;
-                    {error, _Err} ->
-                        {error, join_errors("Decode errors", [lists:flatten(io_lib:format("Failed to decode binary at type ~p", [VmType]))],
-                                            fun(E) -> E end)}
-                end;
-            fate ->
         case aeb_fate_abi:decode_calldata(FunName, Calldata) of
             {ok, FateArgs} ->
                 try
@@ -433,49 +325,20 @@ decode_calldata(ContractString, FunName, Calldata, Options0) ->
                     {ok, ArgTypes, AstArgs}
                 catch throw:cannot_translate_to_sophia ->
                         Type0Str = prettypr:format(aeso_pretty:type(Type0)),
-                                {error, join_errors("Translation error",
-                                                    [lists:flatten(io_lib:format("Cannot translate fate value ~p\n of Sophia type ~s\n",
-                                                                                 [FateArgs, Type0Str]))],
-                                                    fun (E) -> E end)}
+                        Msg = io_lib:format("Cannot translate FATE value ~p\n  to Sophia type ~s",
+                                            [FateArgs, Type0Str]),
+                        {error, [aeso_errors:new(data_error, Msg)]}
                 end;
             {error, _} ->
-                        {error, join_errors("Decode errors", ["Failed to decode binary"],
-                                            fun(E) -> E end)}
-                end
+                Msg = io_lib:format("Failed to decode calldata binary", []),
+                {error, [aeso_errors:new(data_error, Msg)]}
         end
     catch
-        error:{parse_errors, Errors} ->
-            {error, join_errors("Parse errors", Errors, fun (E) -> E end)};
-        error:{type_errors, Errors} ->
-            {error, join_errors("Type errors", Errors, fun (E) -> E end)};
-        error:{badmatch, {error, missing_function}} ->
-            {error, join_errors("Type errors", ["no function: '" ++ FunName ++ "'"],
-                                fun (E) -> E end)};
-        throw:Error ->                          %Don't ask
-            {error, join_errors("Code errors", [Error],
-                                fun (E) -> io_lib:format("~p", [E]) end)}
+        throw:{error, Errors} -> {error, Errors}
     end.
 
-get_arg_icode(Funs) ->
-    case [ Args || {[_, ?CALL_NAME], _, _, {funcall, _, Args}, _} <- Funs ] of
-        [Args] -> Args;
-        []     -> error({missing_call_function, Funs})
-    end.
-
-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}
-    end;
-get_call_type([_ | Contracts]) ->
-    %% The __call should be in the final contract
-    get_call_type(Contracts).
-
-get_decode_type(FunName, [{contract, _, _, Defs}]) ->
+-dialyzer({nowarn_function, get_decode_type/2}).
+get_decode_type(FunName, [{Contract, Ann, _, Defs}]) when ?IS_CONTRACT_HEAD(Contract) ->
     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,
@@ -484,135 +347,118 @@ get_decode_type(FunName, [{contract, _, _, Defs}]) ->
         []            ->
             case FunName of
                 "init" -> {ok, [], {tuple_t, [], []}};
-                 _ -> {error, missing_function}
+                 _ ->
+                    Msg = io_lib:format("Function '~s' is missing in contract", [FunName]),
+                    Pos = aeso_code_errors:pos(Ann),
+                    aeso_errors:throw(aeso_errors:new(data_error, Pos, Msg))
             end
     end;
 get_decode_type(FunName, [_ | Contracts]) ->
     %% The __decode should be in the final contract
     get_decode_type(FunName, Contracts).
 
-%% Translate an icode value (error if not value) to an Erlang term that can be
-%% consumed by 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({list, T}, {list, Vs}) ->
-    [ icode_to_term(T, V) || V <- Vs ];
-icode_to_term({tuple, Ts}, {tuple, Vs}) ->
-    list_to_tuple(icodes_to_terms(Ts, Vs));
-icode_to_term({variant, Cs}, {tuple, [{integer, Tag} | Args]}) ->
-    Ts = lists:nth(Tag + 1, Cs),
-    {variant, Tag, icodes_to_terms(Ts, Args)};
-icode_to_term(T = {map, KT, VT}, M) ->
-    %% Maps are compiled to builtin and primop calls, so this gets a little hairy
-    case M of
-        {funcall, {var_ref, {builtin, map_put}}, [M1, K, V]} ->
-            Map = icode_to_term(T, M1),
-            Key = icode_to_term(KT, K),
-            Val = icode_to_term(VT, V),
-            Map#{ Key => Val };
-        #prim_call_contract{ address = {integer, 0},
-                             arg = {tuple, [{integer, ?PRIM_CALL_MAP_EMPTY}, _, _]} } ->
-            #{};
-        _ -> throw({todo, M})
-    end;
-icode_to_term(typerep, _) ->
-    throw({todo, typerep});
-icode_to_term(T, V) ->
-    throw({not_a_value, T, V}).
-
-icodes_to_terms(Ts, Vs) ->
-    [ icode_to_term(T, V) || {T, V} <- lists:zip(Ts, Vs) ].
-
-ast_to_icode(TypedAst, Options) ->
-    aeso_ast_to_icode:convert_typed(TypedAst, Options).
-
-assemble(Icode, Options) ->
-    aeso_icode_to_asm:convert(Icode, Options).
-
-
-to_bytecode(['COMMENT',_|Rest],_Options) ->
-    to_bytecode(Rest,_Options);
-to_bytecode([Op|Rest], Options) ->
-    [aeb_opcodes:m_to_op(Op)|to_bytecode(Rest, Options)];
-to_bytecode([], _) -> [].
-
-extract_type_info(#{functions := Functions} =_Icode) ->
-    ArgTypesOnly = fun(As) -> [ T || {_, T} <- As ] end,
-    Payable = fun(Attrs) -> proplists:get_value(payable, Attrs, false) end,
-    TypeInfo = [aeb_aevm_abi:function_type_info(list_to_binary(lists:last(Name)),
-                                            Payable(Attrs), ArgTypesOnly(Args), TypeRep)
-                || {Name, Attrs, Args,_Body, TypeRep} <- Functions,
-                   not is_tuple(Name),
-                   not lists:member(private, Attrs)
-               ],
-    lists:sort(TypeInfo).
-
 pp_sophia_code(C, Opts)->  pp(C, Opts, pp_sophia_code, fun(Code) ->
                                 io:format("~s\n", [prettypr:format(aeso_pretty:decls(Code))])
                             end).
 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(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} ->
+        {Option1, true} when Option1 =:= Option ->
             PPFun(Code);
         none ->
             ok
     end.
 
-%% -------------------------------------------------------------------
+%% -- Byte code validation ---------------------------------------------------
 
-sophia_type_to_typerep(String) ->
-    {ok, Ast} = aeso_parser:type(String),
-    try aeso_ast_to_icode:ast_typerep(Ast) of
-        Type -> {ok, Type}
-    catch _:_ -> {error, bad_type}
+-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,
+    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(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.
 
+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]).
+
+%% -------------------------------------------------------------------
+
 -spec parse(string(), aeso_compiler:options()) -> none() | aeso_syntax:ast().
 parse(Text, Options) ->
     parse(Text, sets:new(), Options).
 
 -spec parse(string(), sets:set(), aeso_compiler:options()) -> none() | aeso_syntax:ast().
 parse(Text, Included, Options) ->
-    %% Try and return something sensible here!
-    case aeso_parser:string(Text, Included, 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_error(aeso_parse_lib:pos(), string()) -> none().
-parse_error(Pos, ErrorString) ->
-    Error = io_lib:format("~s: ~s", [pos_error(Pos), ErrorString]),
-    error({parse_errors, [Error]}).
+    aeso_parser:string(Text, Included, Options).
 
 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

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

src/aeso_errors.erl

@@ -0,0 +1,123 @@
+%%%-------------------------------------------------------------------
+%%% @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
+        , msg_oneline/1
+        , new/2
+        , new/3
+        , new/4
+        , pos/2
+        , pos/3
+        , pp/1
+        , pp_oneline/1
+        , pp_pos/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 ++ "\n" ++ Ctxt.
+
+msg_oneline(#err{ message = Msg, context = none }) -> Msg;
+msg_oneline(#err{ message = Msg, context = Ctxt }) -> Msg ++ " - " ++ Ctxt.
+
+err_msg(#err{ pos = Pos } = Err) ->
+    lists:flatten(io_lib:format("~s~s\n", [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\n", [pp_kind(Kind), pp_pos(Pos), msg(Err)])).
+
+pp_oneline(#err{ type = Kind, pos = Pos } = Err) ->
+    Msg = msg_oneline(Err),
+    OneLineMsg = re:replace(Msg, "[\s\\n]+", " ", [global]),
+    lists:flatten(io_lib:format("~s~s: ~s", [pp_kind(Kind), pp_pos(Pos), OneLineMsg])).
+
+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

@@ -1,143 +0,0 @@
-%%%-------------------------------------------------------------------
-%%% @author Happi (Erik Stenman)
-%%% @copyright (C) 2017, Aeternity Anstalt
-%%% @doc
-%%%     Intermediate Code for Aeterinty Sophia language.
-%%% @end
-%%% Created : 21 Dec 2017
-%%%
-%%%-------------------------------------------------------------------
--module(aeso_icode).
-
--export([new/1,
-         pp/1,
-         set_name/2,
-         set_namespace/2,
-         set_payable/2,
-         enter_namespace/2,
-         get_namespace/1,
-         qualify/2,
-         set_functions/2,
-         map_typerep/2,
-         option_typerep/1,
-         get_constructor_tag/2]).
-
--export_type([icode/0]).
-
--include("aeso_icode.hrl").
-
--type type_def() :: fun(([aeb_aevm_data:type()]) -> aeb_aevm_data:type()).
-
--type bindings() :: any().
--type fun_dec() :: { string()
-                   , [modifier()]
-                   , arg_list()
-                   , expr()
-                   , aeb_aevm_data:type()}.
-
--type modifier() :: private | stateful.
-
--type type_name() :: string() | [string()].
-
--type icode() :: #{ contract_name => string()
-                  , functions => [fun_dec()]
-                  , namespace => aeso_syntax:con() | aeso_syntax:qcon()
-                  , env => [bindings()]
-                  , state_type => aeb_aevm_data:type()
-                  , event_type => aeb_aevm_data:type()
-                  , types => #{ type_name() => type_def() }
-                  , type_vars => #{ string() => aeb_aevm_data:type() }
-                  , constructors => #{ [string()] => integer() }  %% name to tag
-                  , options => [any()]
-                  , payable => boolean()
-                  }.
-
-pp(Icode) ->
-    %% TODO: Actually do *Pretty* printing.
-    io:format("~p~n", [Icode]).
-
--spec new([any()]) -> icode().
-new(Options) ->
-    #{ contract_name => ""
-     , functions => []
-     , env => new_env()
-       %% Default to unit type for state and event
-     , state_type => {tuple, []}
-     , event_type => {tuple, []}
-     , types => builtin_types()
-     , type_vars => #{}
-     , constructors => builtin_constructors()
-     , options => Options
-     , payable => false }.
-
-builtin_types() ->
-    Word = fun([]) -> word end,
-    #{ "bool"         => Word
-     , "int"          => 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
-     }.
-
-builtin_constructors() ->
-    #{ ["RelativeTTL"] => 0
-     , ["FixedTTL"]    => 1
-     , ["None"]        => 0
-     , ["Some"]        => 1 }.
-
-map_typerep(K, V) ->
-    {map, K, V}.
-
-option_typerep(A) ->
-    {variant, [[], [A]]}.
-
-new_env() ->
-    [].
-
--spec set_name(string(), icode()) -> icode().
-set_name(Name, Icode) ->
-    maps:put(contract_name, Name, Icode).
-
--spec set_payable(boolean(), icode()) -> icode().
-set_payable(Payable, Icode) ->
-    maps:put(payable, Payable, Icode).
-
--spec set_namespace(aeso_syntax:con() | aeso_syntax:qcon(), icode()) -> icode().
-set_namespace(NS, Icode) -> Icode#{ namespace => NS }.
-
--spec enter_namespace(aeso_syntax:con(), icode()) -> icode().
-enter_namespace(NS, Icode = #{ namespace := NS1 }) ->
-    Icode#{ namespace => aeso_syntax:qualify(NS1, NS) };
-enter_namespace(NS, Icode) ->
-    Icode#{ namespace => NS }.
-
--spec get_namespace(icode()) -> false | aeso_syntax:con() | aeso_syntax:qcon().
-get_namespace(Icode) -> maps:get(namespace, Icode, false).
-
--spec qualify(aeso_syntax:id() | aeso_syntax:con(), icode()) -> aeso_syntax:id() | aeso_syntax:qid() | aeso_syntax:con() | aeso_syntax:qcon().
-qualify(X, Icode) ->
-    case get_namespace(Icode) of
-        false -> X;
-        NS    -> aeso_syntax:qualify(NS, X)
-    end.
-
--spec set_functions([fun_dec()], icode()) -> icode().
-set_functions(NewFuns, Icode) ->
-    maps:put(functions, NewFuns, Icode).
-
--spec get_constructor_tag([string()], icode()) -> integer().
-get_constructor_tag(Name, #{constructors := Constructors}) ->
-    case maps:get(Name, Constructors, undefined) of
-        undefined -> error({undefined_constructor, Name});
-        Tag       -> Tag
-    end.
-

src/aeso_icode.hrl

@@ -1,59 +0,0 @@
-
--include_lib("aebytecode/include/aeb_typerep_def.hrl").
-
--record(arg, {name::string(), type::?Type()}).
-
--type expr() :: term().
--type arg() :: #arg{name::string(), type::?Type()}.
--type arg_list() :: [arg()].
-
--record(fun_dec, { name :: string()
-                 , args :: arg_list()
-                 , body :: expr()}).
-
--record(var_ref, { name :: string() | list(string()) | {builtin, atom() | tuple()}}).
-
--record(prim_call_contract,
-    { gas      :: expr()
-    , address  :: expr()
-    , value    :: expr()
-    , arg      :: expr()
-    , type_hash:: expr()
-    }).
-
--record(prim_balance,    { address :: expr() }).
--record(prim_block_hash, { height :: expr() }).
--record(prim_put,        { state :: expr() }).
-
--record(integer, {value :: integer()}).
-
--record(tuple,   {cpts  :: [expr()]}).
-
--record(list,    {elems :: [expr()]}).
-
--record(unop,    { op   :: term()
-                 , rand :: expr()}).
-
--record(binop,   { op   :: term()
-                 , left :: expr()
-                 , right :: expr()}).
-
--record(ifte,    { decision :: expr()
-                 , then :: expr()
-                 , else :: expr()}).
-
--record(switch,  { expr  :: expr()
-                 , cases :: [{expr(),expr()}]}).
-
--record(funcall, { function :: expr()
-                 , args     :: [expr()]}).
-
--record(lambda,  { args :: arg_list(),
-                   body :: expr()}).
-
--record(missing_field, { format :: string()
-                       , args   :: [term()]}).
-
--record(seq, {exprs :: [expr()]}).
-
--record(event, {topics :: [expr()], payload :: expr()}).

src/aeso_icode_to_asm.erl

@@ -1,983 +0,0 @@
-%%%-------------------------------------------------------------------
-%%% @author Happi (Erik Stenman)
-%%% @copyright (C) 2017, Aeternity Anstalt
-%%% @doc
-%%%     Translator from Aesophia Icode to Aevm Assebly
-%%% @end
-%%% Created : 21 Dec 2017
-%%%
-%%%-------------------------------------------------------------------
--module(aeso_icode_to_asm).
-
--export([convert/2]).
-
--include_lib("aebytecode/include/aeb_opcodes.hrl").
--include("aeso_icode.hrl").
-
-i(Code) -> aeb_opcodes:mnemonic(Code).
-
-%% We don't track purity or statefulness in the type checker yet.
-is_stateful({FName, _, _, _, _}) -> lists:last(FName) /= "init".
-
-is_public({_Name, Attrs, _Args, _Body, _Type}) -> not lists:member(private, Attrs).
-
-convert(#{ contract_name := _ContractName
-         , state_type := StateType
-         , functions := Functions
-              },
-        _Options) ->
-    %% Create a function dispatcher
-    DispatchFun = {"_main", [], [{"arg", "_"}],
-                   {switch, {var_ref, "arg"},
-                    [{{tuple, [fun_hash(Fun),
-                               {tuple, make_args(Args)}]},
-                      icode_seq([ hack_return_address(Fun, length(Args) + 1) ] ++
-                                [ {funcall, {var_ref, FName}, make_args(Args)}]
-                               )}
-                     || Fun={FName, _, Args, _,_TypeRep} <- Functions, is_public(Fun) ]},
-                   word},
-    NewFunctions = Functions ++ [DispatchFun],
-    %% Create a function environment
-    Funs = [{Name, length(Args), make_ref()}
-            || {Name, _Attrs, Args, _Body, _Type} <- NewFunctions],
-    %% Create dummy code to call the main function with one argument
-    %% taken from the stack
-    StopLabel = make_ref(),
-    StatefulStopLabel = make_ref(),
-    MainFunction = lookup_fun(Funs, "_main"),
-
-    StateTypeValue = aeso_ast_to_icode:type_value(StateType),
-
-    DispatchCode = [%% push two return addresses to stop, one for stateful
-                    %% functions and one for non-stateful functions.
-                    push_label(StatefulStopLabel),
-                    push_label(StopLabel),
-                    %% The calldata is already on the stack when we start. Put
-                    %% it on top (also reorders StatefulStop and Stop).
-                    swap(2),
-
-                    jump(MainFunction),
-                    jumpdest(StatefulStopLabel),
-
-                    %% We need to encode the state type and put it
-                    %% underneath the return value.
-                    assemble_expr(Funs, [], nontail, StateTypeValue), %% StateT Ret
-                    swap(1),                                          %% Ret StateT
-
-                    %% We should also change the state value at address 0 to a
-                    %% pointer to the state value (to allow 0 to represent an
-                    %% unchanged state).
-                    i(?MSIZE),             %% Ptr
-                    push(0), i(?MLOAD),    %% Val Ptr
-                    i(?MSIZE), i(?MSTORE), %% Ptr   Mem[Ptr] := Val
-                    push(0), i(?MSTORE),   %%       Mem[0]   := Ptr
-
-                    %% The pointer to the return value is on top of
-                    %% the stack, but the return instruction takes two
-                    %% stack arguments.
-                    push(0),
-                    i(?RETURN),
-                    jumpdest(StopLabel),
-                    %% Set state pointer to 0 to indicate that we didn't change state
-                    push(0), dup(1), i(?MSTORE),
-                    %% Same as StatefulStopLabel above
-                    push(0),
-                    i(?RETURN)
-                   ],
-    %% Code is a deep list of instructions, containing labels and
-    %% references to them. Labels take the form {'JUMPDEST', Ref}, and
-    %% references take the form {push_label, Ref}, which is translated
-    %% into a PUSH instruction.
-    Code = [assemble_function(Funs, Name, Args, Body)
-            || {Name, _, Args, Body, _Type} <- NewFunctions],
-    resolve_references(
-        [%% i(?COMMENT), "CONTRACT: " ++ ContractName,
-         DispatchCode,
-         Code]).
-
-%% Generate error on correct format.
-
-gen_error(Error) ->
-    error({code_errors, [Error]}).
-
-make_args(Args) ->
-    [{var_ref, [I-1 + $a]} || I <- lists:seq(1, length(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),
-    {integer, Hash}.
-
-%% Expects two return addresses below N elements on the stack. Picks the top
-%% one for stateful functions and the bottom one for non-stateful.
-hack_return_address(Fun, N) ->
-    case is_stateful(Fun) of
-        true  -> {inline_asm, [i(?MSIZE)]};
-        false ->
-            {inline_asm,     %% X1 .. XN State NoState
-             [ dup(N + 2)    %% NoState X1 .. XN State NoState
-             , swap(N + 1)   %% State X1 .. XN NoState NoState
-             ]}  %% Top of the stack will be discarded.
-    end.
-
-assemble_function(Funs, Name, Args, Body) ->
-    [jumpdest(lookup_fun(Funs, Name)),
-     assemble_expr(Funs, lists:reverse(Args), tail, Body),
-     %% swap return value and first argument
-     pop_args(length(Args)),
-     swap(1),
-     i(?JUMP)].
-
-%% {seq, Es} - should be "one" operation in terms of stack content
-%% i.e. after the `seq` there should be one new element on the stack.
-assemble_expr(Funs, Stack, Tail, {seq, [E]}) ->
-    assemble_expr(Funs, Stack, Tail, E);
-assemble_expr(Funs, Stack, Tail, {seq, [E | Es]}) ->
-    [assemble_expr(Funs, Stack, nontail, E),
-     assemble_expr(Funs, Stack, Tail, {seq, Es})];
-assemble_expr(_Funs, _Stack, _Tail, {inline_asm, Code}) ->
-    Code;   %% Unsafe! Code should take care to respect the stack!
-assemble_expr(Funs, Stack, _TailPosition, {var_ref, Id}) ->
-    case lists:keymember(Id, 1, Stack) of
-        true ->
-            dup(lookup_var(Id, Stack));
-        false ->
-            %% Build a closure
-            %% When a top-level fun is called directly, we do not
-            %% reach this case.
-            Eta = make_ref(),
-            Continue = make_ref(),
-            [i(?MSIZE),
-             push_label(Eta),
-             dup(2),
-             i(?MSTORE),
-             jump(Continue),
-             %% the code of the closure
-             jumpdest(Eta),
-             %% pop the pointer to the function
-             pop(1),
-             jump(lookup_fun(Funs, Id)),
-             jumpdest(Continue)]
-    end;
-assemble_expr(_, _, _, {missing_field, Format, Args}) ->
-    io:format(Format, Args),
-    gen_error(missing_field);
-assemble_expr(_Funs, _Stack, _, {integer, N}) ->
-    push(N);
-assemble_expr(Funs, Stack, _, {tuple, Cpts}) ->
-    %% We build tuples right-to-left, so that the first write to the
-    %% tuple extends the memory size. Because we use ?MSIZE as the
-    %% heap pointer, we must allocate the tuple AFTER computing the
-    %% first element.
-    %% We store elements into the tuple as soon as possible, to avoid
-    %% keeping them for a long time on the stack.
-    case lists:reverse(Cpts) of
-        [] ->
-            i(?MSIZE);
-        [Last|Rest] ->
-            [assemble_expr(Funs, Stack, nontail, Last),
-             %% allocate the tuple memory
-             i(?MSIZE),
-             %% compute address of last word
-             push(32 * (length(Cpts) - 1)), i(?ADD),
-             %% Stack: <last-value> <pointer>
-             %% Write value to memory (allocates the tuple)
-             swap(1), dup(2), i(?MSTORE),
-             %% Stack: pointer to last word written
-             [[%% Update pointer to next word to be written
-               push(32), swap(1), i(?SUB),
-               %% Compute element
-               assemble_expr(Funs, [pointer|Stack], nontail, A),
-               %% Write element to memory
-               dup(2), i(?MSTORE)]
-               %% And we leave a pointer to the last word written on
-               %% the stack
-              || A <- Rest]]
-            %% The pointer to the entire tuple is on the stack
-    end;
-assemble_expr(_Funs, _Stack, _, {list, []}) ->
-    %% Use Erik's value of -1 for []
-    [push(0), i(?NOT)];
-assemble_expr(Funs, Stack, _, {list, [A|B]}) ->
-    assemble_expr(Funs, Stack, nontail, {tuple, [A, {list, B}]});
-assemble_expr(Funs, Stack, _, {unop, '!', A}) ->
-    case A of
-        {binop, Logical, _, _} when Logical=='&&'; Logical=='||' ->
-            assemble_expr(Funs, Stack, nontail, {ifte, A, {integer, 0}, {integer, 1}});
-        _ ->
-            [assemble_expr(Funs, Stack, nontail, A),
-             i(?ISZERO)
-            ]
-    end;
-assemble_expr(Funs, Stack, _, {event, Topics, Payload}) ->
-    [assemble_exprs(Funs, Stack, Topics ++ [Payload]),
-     case length(Topics) of
-        0 -> i(?LOG0);
-        1 -> i(?LOG1);
-        2 -> i(?LOG2);
-        3 -> i(?LOG3);
-        4 -> i(?LOG4)
-     end, i(?MSIZE)];
-assemble_expr(Funs, Stack, _, {unop, Op, A}) ->
-    [assemble_expr(Funs, Stack, nontail, A),
-     assemble_prefix(Op)];
-assemble_expr(Funs, Stack, Tail, {binop, '&&', A, B}) ->
-    assemble_expr(Funs, Stack, Tail, {ifte, A, B, {integer, 0}});
-assemble_expr(Funs, Stack, Tail, {binop, '||', A, B}) ->
-    assemble_expr(Funs, Stack, Tail, {ifte, A, {integer, 1}, B});
-assemble_expr(Funs, Stack, Tail, {binop, '::', A, B}) ->
-    %% Take advantage of optimizations in tuple construction.
-    assemble_expr(Funs, Stack, Tail, {tuple, [A, B]});
-assemble_expr(Funs, Stack, _, {binop, Op, A, B}) ->
-    %% EEVM binary instructions take their first argument from the top
-    %% of the stack, so to get operands on the stack in the right
-    %% order, we evaluate from right to left.
-    [assemble_expr(Funs, Stack, nontail, B),
-     assemble_expr(Funs, [dummy|Stack], nontail, A),
-     assemble_infix(Op)];
-assemble_expr(Funs, Stack, _, {lambda, Args, Body}) ->
-    Function = make_ref(),
-    FunBody  = make_ref(),
-    Continue = make_ref(),
-    NoMatch  = make_ref(),
-    FreeVars = free_vars({lambda, Args, Body}),
-    {NewVars, MatchingCode} = assemble_pattern(FunBody, NoMatch, {tuple, [{var_ref, "_"}|FreeVars]}),
-    BodyCode = assemble_expr(Funs, NewVars ++ lists:reverse([ {Arg#arg.name, Arg#arg.type} || Arg <- Args ]), tail, Body),
-    [assemble_expr(Funs, Stack, nontail, {tuple, [{label, Function}|FreeVars]}),
-     jump(Continue), %% will be optimized away
-     jumpdest(Function),
-     %% A pointer to the closure is on the stack
-     MatchingCode,
-     jumpdest(FunBody),
-     BodyCode,
-     pop_args(length(Args)+length(NewVars)),
-     swap(1),
-     i(?JUMP),
-     jumpdest(NoMatch), %% dead code--raise an exception just in case
-     push(0),
-     i(?NOT),
-     i(?MLOAD),
-     i(?STOP),
-     jumpdest(Continue)];
-assemble_expr(_, _, _, {label, Label}) ->
-    push_label(Label);
-assemble_expr(Funs, Stack, nontail, {funcall, Fun, Args}) ->
-    Return = make_ref(),
-    %% This is the obvious code:
-    %%   [{push_label, Return},
-    %%    assemble_exprs(Funs, [return_address|Stack], Args++[Fun]),
-    %%    'JUMP',
-    %%    {'JUMPDEST', Return}];
-    %% Its problem is that it stores the return address on the stack
-    %% while the arguments are computed, which is unnecessary. To
-    %% avoid that, we compute the last argument FIRST, and replace it
-    %% with the return address using a SWAP.
-    %%
-    %% assemble_function leaves the code pointer of the function to
-    %% call on top of the stack, and--if the function is not a
-    %% top-level name--a pointer to its tuple of free variables. In
-    %% either case a JUMP is the right way to call it.
-    case Args of
-        [] ->
-            [push_label(Return),
-             assemble_function(Funs, [return_address|Stack], Fun),
-             i(?JUMP),
-             jumpdest(Return)];
-        _ ->
-            {Init, [Last]} = lists:split(length(Args) - 1, Args),
-            [assemble_exprs(Funs, Stack, [Last|Init]),
-             %% Put the return address in the right place, which also
-             %% reorders the args correctly.
-             push_label(Return),
-             swap(length(Args)),
-             assemble_function(Funs, [dummy || _ <- Args] ++ [return_address|Stack], Fun),
-             i(?JUMP),
-             jumpdest(Return)]
-    end;
-assemble_expr(Funs, Stack, tail, {funcall, Fun, Args}) ->
-    IsTopLevel = is_top_level_fun(Stack, Fun),
-    %% If the fun is not top-level, then it may refer to local
-    %% variables and must be computed before stack shuffling.
-    ArgsAndFun = Args++[Fun || not IsTopLevel],
-    ComputeArgsAndFun = assemble_exprs(Funs, Stack, ArgsAndFun),
-    %% Copy arguments back down the stack to the start of the frame
-    ShuffleSpec = lists:seq(length(ArgsAndFun), 1, -1) ++ [discard || _ <- Stack],
-    Shuffle = shuffle_stack(ShuffleSpec),
-    [ComputeArgsAndFun, Shuffle,
-     if IsTopLevel ->
-             %% still need to compute function
-             assemble_function(Funs, [], Fun);
-        true ->
-             %% need to unpack a closure
-             [dup(1), i(?MLOAD)]
-     end,
-     i(?JUMP)];
-assemble_expr(Funs, Stack, Tail, {ifte, Decision, Then, Else}) ->
-    %% This compilation scheme introduces a lot of labels and
-    %% jumps. Unnecessary ones are removed later in
-    %% resolve_references.
-    Close = make_ref(),
-    ThenL = make_ref(),
-    ElseL = make_ref(),
-    [assemble_decision(Funs, Stack, Decision, ThenL, ElseL),
-     jumpdest(ElseL),
-     assemble_expr(Funs, Stack, Tail, Else),
-     jump(Close),
-     jumpdest(ThenL),
-     assemble_expr(Funs, Stack, Tail, Then),
-     jumpdest(Close)
-    ];
-assemble_expr(Funs, Stack, Tail, {switch, A, Cases}) ->
-    Close = make_ref(),
-    [assemble_expr(Funs, Stack, nontail, A),
-     assemble_cases(Funs, Stack, Tail, Close, Cases),
-     {'JUMPDEST', Close}];
-%% State primitives
-%%  (A pointer to) the contract state is stored at address 0.
-assemble_expr(_Funs, _Stack, _Tail, prim_state) ->
-    [push(0), i(?MLOAD)];
-assemble_expr(Funs, Stack, _Tail, #prim_put{ state = State }) ->
-    [assemble_expr(Funs, Stack, nontail, State),
-     push(0), i(?MSTORE),   %% We need something for the unit value on the stack,
-     i(?MSIZE)];            %% MSIZE is the cheapest instruction.
-%% 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) ->
-    [i(?CALLER)];
-assemble_expr(_Funs, _Stack, _Tail, prim_call_value) ->
-    [i(?CALLVALUE)];
-assemble_expr(_Funs, _Stack, _Tail, prim_gas_price) ->
-    [i(?GASPRICE)];
-assemble_expr(_Funs, _Stack, _Tail, prim_gas_left) ->
-    [i(?GAS)];
-assemble_expr(_Funs, _Stack, _Tail, prim_coinbase) ->
-    [i(?COINBASE)];
-assemble_expr(_Funs, _Stack, _Tail, prim_timestamp) ->
-    [i(?TIMESTAMP)];
-assemble_expr(_Funs, _Stack, _Tail, prim_block_height) ->
-    [i(?NUMBER)];
-assemble_expr(_Funs, _Stack, _Tail, prim_difficulty) ->
-    [i(?DIFFICULTY)];
-assemble_expr(_Funs, _Stack, _Tail, prim_gas_limit) ->
-    [i(?GASLIMIT)];
-assemble_expr(Funs, Stack, _Tail, #prim_balance{ address = Addr }) ->
-    [assemble_expr(Funs, Stack, nontail, Addr),
-     i(?BALANCE)];
-assemble_expr(Funs, Stack, _Tail, #prim_block_hash{ height = Height }) ->
-    [assemble_expr(Funs, Stack, nontail, Height),
-     i(?BLOCKHASH)];
-assemble_expr(Funs, Stack, _Tail,
-              #prim_call_contract{ gas      = Gas
-                                 , address  = To
-                                 , value    = Value
-                                 , arg      = Arg
-                                 , type_hash= TypeHash
-                                 }) ->
-    %% ?CALL takes (from the top)
-    %%   Gas, To, Value, Arg, TypeHash, _OOffset,_OSize
-    %% So assemble these in reverse order.
-    [ assemble_exprs(Funs, Stack, [ {integer, 0}, {integer, 0}, TypeHash
-                                  , Arg, Value, To, Gas ])
-    , i(?CALL)
-    ].
-
-
-assemble_exprs(_Funs, _Stack, []) ->
-    [];
-assemble_exprs(Funs, Stack, [E|Es]) ->
-    [assemble_expr(Funs, Stack, nontail, E),
-     assemble_exprs(Funs, [dummy|Stack], Es)].
-
-assemble_decision(Funs, Stack, {binop, '&&', A, B}, Then, Else) ->
-    Label = make_ref(),
-    [assemble_decision(Funs, Stack, A, Label, Else),
-     jumpdest(Label),
-     assemble_decision(Funs, Stack, B, Then, Else)];
-assemble_decision(Funs, Stack, {binop, '||', A, B}, Then, Else) ->
-    Label = make_ref(),
-    [assemble_decision(Funs, Stack, A, Then, Label),
-     jumpdest(Label),
-     assemble_decision(Funs, Stack, B, Then, Else)];
-assemble_decision(Funs, Stack, {unop, '!', A}, Then, Else) ->
-    assemble_decision(Funs, Stack, A, Else, Then);
-assemble_decision(Funs, Stack, {ifte, A, B, C}, Then, Else) ->
-    TrueL  = make_ref(),
-    FalseL = make_ref(),
-    [assemble_decision(Funs, Stack, A, TrueL, FalseL),
-     jumpdest(TrueL),  assemble_decision(Funs, Stack, B, Then, Else),
-     jumpdest(FalseL), assemble_decision(Funs, Stack, C, Then, Else)];
-assemble_decision(Funs, Stack, Decision, Then, Else) ->
-    [assemble_expr(Funs, Stack, nontail, Decision),
-     jump_if(Then), jump(Else)].
-
-%% Entered with value to switch on on top of the stack
-%% Evaluate selected case, then jump to Close with result on the
-%% stack.
-assemble_cases(_Funs, _Stack, _Tail, _Close, []) ->
-    %% No match! What should be do? There's no real way to raise an
-    %% exception, except consuming all the gas.
-    %% There should not be enough gas to do this:
-    [push(1), i(?NOT),
-     i(?MLOAD),
-     %% now stop, so that jump optimizer realizes we will not fall
-     %% through this code.
-     i(?STOP)];
-assemble_cases(Funs, Stack, Tail, Close, [{Pattern, Body}|Cases]) ->
-    Succeed = make_ref(),
-    Fail = make_ref(),
-    {NewVars, MatchingCode} =
-        assemble_pattern(Succeed, Fail, Pattern),
-    %% In the code that follows, if this is NOT the last case, then we
-    %% save the value being switched on, and discard it on
-    %% success. The code is simpler if this IS the last case.
-    [[dup(1) || Cases /= []],   %% save value for next case, if there is one
-     MatchingCode,
-     jumpdest(Succeed),
-     %% Discard saved value, if we saved one
-     [case NewVars of
-          [] ->
-              pop(1);
-          [_] ->
-              %% Special case for peep-hole optimization
-              pop_args(1);
-          _ ->
-              [swap(length(NewVars)), pop(1)]
-      end
-      || Cases/=[]],
-     assemble_expr(Funs,
-                   case Cases of
-                       [] -> NewVars;
-                       _  -> reorder_vars(NewVars)
-                   end
-                   ++Stack, Tail, Body),
-     %% If the Body makes a tail call, then we will not return
-     %% here--but it doesn't matter, because
-     %% (a) the NewVars will be popped before the tailcall
-     %% (b) the code below will be deleted since it is dead
-     pop_args(length(NewVars)),
-     jump(Close),
-     jumpdest(Fail),
-     assemble_cases(Funs, Stack, Tail, Close, Cases)].
-
-%% Entered with value to match on top of the stack.
-%% Generated code removes value, and
-%%   - jumps to Fail if no match, or
-%%   - binds variables, leaves them on the stack, and jumps to Succeed
-%% Result is a list of variables to add to the stack, and the matching
-%% code.
-assemble_pattern(Succeed, Fail, {integer, N}) ->
-    {[], [push(N),
-         i(?EQ),
-         jump_if(Succeed),
-         jump(Fail)]};
-assemble_pattern(Succeed, _Fail, {var_ref, "_"}) ->
-    {[], [i(?POP), jump(Succeed)]};
-assemble_pattern(Succeed, Fail, {missing_field, _, _}) ->
-    %% Missing record fields are quite ok in patterns.
-    assemble_pattern(Succeed, Fail, {var_ref, "_"});
-assemble_pattern(Succeed, _Fail, {var_ref, Id}) ->
-    {[{Id, "_"}], jump(Succeed)};
-assemble_pattern(Succeed, _Fail, {tuple, []}) ->
-    {[], [pop(1), jump(Succeed)]};
-assemble_pattern(Succeed, Fail, {tuple, [A]}) ->
-    %% Treat this case specially, because we don't need to save the
-    %% pointer to the tuple.
-    {AVars, ACode} = assemble_pattern(Succeed, Fail, A),
-    {AVars, [i(?MLOAD),
-            ACode]};
-assemble_pattern(Succeed, Fail, {tuple, [A|B]}) ->
-    %% Entered with the address of the tuple on the top of the
-    %% stack. We will duplicate the address before matching on A.
-    Continue = make_ref(),  %% the label for matching B
-    Pop1Fail = make_ref(),  %% pop 1 word and goto Fail
-    PopNFail = make_ref(),  %% pop length(AVars) words and goto Fail
-    {AVars, ACode} =
-        assemble_pattern(Continue, Pop1Fail, A),
-    {BVars, BCode} =
-        assemble_pattern(Succeed, PopNFail, {tuple, B}),
-    {BVars ++ reorder_vars(AVars),
-     [%% duplicate the pointer so we don't lose it when we match on A
-      dup(1),
-      i(?MLOAD),
-      ACode,
-      jumpdest(Continue),
-      %% Bring the pointer to the top of the stack--this reorders AVars!
-      swap(length(AVars)),
-      push(32),
-      i(?ADD),
-      BCode,
-      case AVars of
-          [] ->
-              [jumpdest(Pop1Fail), pop(1),
-               jumpdest(PopNFail),
-               jump(Fail)];
-          _ ->
-              [{'JUMPDEST', PopNFail}, pop(length(AVars)-1),
-               {'JUMPDEST', Pop1Fail}, pop(1),
-               {push_label, Fail}, 'JUMP']
-      end]};
-assemble_pattern(Succeed, Fail, {list, []}) ->
-    %% [] is represented by -1.
-    {[], [push(1),
-          i(?ADD),
-          jump_if(Fail),
-          jump(Succeed)]};
-assemble_pattern(Succeed, Fail, {list, [A|B]}) ->
-    assemble_pattern(Succeed, Fail, {binop, '::', A, {list, B}});
-assemble_pattern(Succeed, Fail, {binop, '::', A, B}) ->
-    %% Make sure it's not [], then match as tuple.
-    NotNil = make_ref(),
-    {Vars, Code} = assemble_pattern(Succeed, Fail, {tuple, [A, B]}),
-    {Vars, [dup(1), push(1), i(?ADD),   %% Check for [] without consuming the value
-            jump_if(NotNil),            %% so it's still there when matching the tuple.
-            pop(1),                     %% It was [] so discard the saved value.
-            jump(Fail),
-            jumpdest(NotNil),
-            Code]}.
-
-%% When Vars are on the stack, with a value we want to discard
-%% below them, then we swap the top variable with that value and pop.
-%% This reorders the variables on the stack, as follows:
-reorder_vars([]) ->
-    [];
-reorder_vars([V|Vs]) ->
-    Vs ++ [V].
-
-assemble_prefix('sha3') -> [i(?DUP1), i(?MLOAD),          %% length, ptr
-                            i(?SWAP1), push(32), i(?ADD), %% ptr+32, length
-                            i(?SHA3)];
-assemble_prefix('-') -> [push(0), i(?SUB)];
-assemble_prefix('bnot') -> i(?NOT).
-
-assemble_infix('+')    -> i(?ADD);
-assemble_infix('-')    -> i(?SUB);
-assemble_infix('*')    -> i(?MUL);
-assemble_infix('/')    -> i(?SDIV);
-assemble_infix('div')  -> i(?DIV);
-assemble_infix('mod')  -> i(?MOD);
-assemble_infix('^')    -> i(?EXP);
-assemble_infix('bor')  -> i(?OR);
-assemble_infix('band') -> i(?AND);
-assemble_infix('bxor') -> i(?XOR);
-assemble_infix('bsl')  -> i(?SHL);
-assemble_infix('bsr')  -> i(?SHR);
-assemble_infix('<')    -> i(?SLT);    %% comparisons are SIGNED
-assemble_infix('>')    -> i(?SGT);
-assemble_infix('==')   -> i(?EQ);
-assemble_infix('<=')   -> [i(?SGT), i(?ISZERO)];
-assemble_infix('=<')   -> [i(?SGT), i(?ISZERO)];
-assemble_infix('>=')   -> [i(?SLT), i(?ISZERO)];
-assemble_infix('!=')   -> [i(?EQ), i(?ISZERO)];
-assemble_infix('!')    -> [i(?ADD), i(?MLOAD)];
-assemble_infix('byte') -> i(?BYTE).
-%% assemble_infix('::') -> [i(?MSIZE), write_word(0), write_word(1)].
-
-%% a function may either refer to a top-level function, in which case
-%% we fetch the code label from Funs, or it may be a lambda-expression
-%% (including a top-level function passed as a parameter). In the
-%% latter case, the function value is a pointer to a tuple of the code
-%% pointer and the free variables: we keep the pointer and push the
-%% code pointer onto the stack. In either case, we are ready to enter
-%% the function with JUMP.
-assemble_function(Funs, Stack, Fun) ->
-    case is_top_level_fun(Stack, Fun) of
-        true ->
-            {var_ref, Name} = Fun,
-            {push_label, lookup_fun(Funs, Name)};
-        false ->
-            [assemble_expr(Funs, Stack, nontail, Fun),
-             dup(1),
-             i(?MLOAD)]
-    end.
-
-free_vars(V={var_ref, _}) ->
-    [V];
-free_vars({switch, E, Cases}) ->
-    lists:umerge(free_vars(E),
-                 lists:umerge([free_vars(Body)--free_vars(Pattern)
-                               || {Pattern, Body} <- Cases]));
-free_vars({lambda, Args, Body}) ->
-    free_vars(Body) -- [{var_ref, Arg#arg.name} || Arg <- Args];
-free_vars(T) when is_tuple(T) ->
-    free_vars(tuple_to_list(T));
-free_vars([H|T]) ->
-    lists:umerge(free_vars(H), free_vars(T));
-free_vars(_) ->
-    [].
-
-
-
-%% shuffle_stack reorders the stack, for example before a tailcall. It is called
-%% with a description of the current stack, and how the final stack
-%% should appear. The argument is a list containing
-%%   a NUMBER for each element that should be kept, the number being
-%%     the position this element should occupy in the final stack
-%%   discard, for elements that can be discarded.
-%% The positions start at 1, referring to the variable to be placed at
-%% the bottom of the stack, and ranging up to the size of the final stack.
-shuffle_stack([]) ->
-    [];
-shuffle_stack([discard|Stack]) ->
-    [i(?POP) | shuffle_stack(Stack)];
-shuffle_stack([N|Stack]) ->
-    case length(Stack) + 1 - N of
-        0 ->
-            %% the job should be finished
-            CorrectStack = lists:seq(N - 1, 1, -1),
-            CorrectStack = Stack,
-            [];
-        MoveBy ->
-            {Pref, [_|Suff]} = lists:split(MoveBy - 1, Stack),
-            [swap(MoveBy) | shuffle_stack([lists:nth(MoveBy, Stack) | Pref ++ [N|Suff]])]
-    end.
-
-
-
-lookup_fun(Funs, Name) ->
-    case [Ref || {Name1, _, Ref} <- Funs,
-                 Name == Name1] of
-        [Ref] -> Ref;
-        []    -> gen_error({undefined_function, Name})
-    end.
-
-is_top_level_fun(Stack, {var_ref, Id}) ->
-    not lists:keymember(Id, 1, Stack);
-is_top_level_fun(_, _) ->
-    false.
-
-lookup_var(Id, Stack) ->
-    lookup_var(1, Id, Stack).
-
-lookup_var(N, Id, [{Id, _Type}|_]) ->
-    N;
-lookup_var(N, Id, [_|Stack]) ->
-    lookup_var(N + 1, Id, Stack);
-lookup_var(_, Id, []) ->
-    gen_error({var_not_in_scope, Id}).
-
-%% Smart instruction generation
-
-%% TODO: handle references to the stack beyond depth 16. Perhaps the
-%% best way is to repush variables that will be needed in
-%% subexpressions before evaluating he subexpression... i.e. fix the
-%% problem in assemble_expr, rather than here. A fix here would have
-%% to save the top elements of the stack in memory, duplicate the
-%% targetted element, and then repush the values from memory.
-dup(N) when 1 =< N, N =< 16 ->
-    i(?DUP1 + N - 1).
-
-push(N) ->
-    Bytes = binary:encode_unsigned(N),
-    true = size(Bytes) =< 32,
-    [i(?PUSH1 + size(Bytes) - 1) |
-     binary_to_list(Bytes)].
-
-%% Pop N values from UNDER the top element of the stack.
-%% This is a pseudo-instruction so peephole optimization can
-%% combine pop_args(M), pop_args(N) to pop_args(M+N)
-pop_args(0) ->
-    [];
-pop_args(N) ->
-    {pop_args, N}.
-%%    [swap(N), pop(N)].
-
-pop(N) ->
-    [i(?POP) || _ <- lists:seq(1, N)].
-
-swap(0) ->
-    %% Doesn't exist, but is logically a no-op.
-    [];
-swap(N) when 1 =< N, N =< 16 ->
-    i(?SWAP1 + N - 1).
-
-jumpdest(Label)   -> {i(?JUMPDEST), Label}.
-push_label(Label) -> {push_label, Label}.
-
-jump(Label)    -> [push_label(Label), i(?JUMP)].
-jump_if(Label) -> [push_label(Label), i(?JUMPI)].
-
-%% ICode utilities (TODO: move to separate module)
-
-icode_noname() -> #var_ref{name = "_"}.
-
-icode_seq([A]) -> A;
-icode_seq([A | As]) ->
-    icode_seq(A, icode_seq(As)).
-
-icode_seq(A, B) ->
-    #switch{ expr = A, cases = [{icode_noname(), B}] }.
-
-%% Stack: <N elements> ADDR
-%% Write elements at addresses ADDR, ADDR+32, ADDR+64...
-%% Stack afterwards: ADDR
-% write_words(N) ->
-%      [write_word(I) || I <- lists:seq(N-1, 0, -1)].
-
-%% Unused at the moment. Comment out to please dialyzer.
-%% write_word(I) ->
-%%     [%% Stack: elements e ADDR
-%%        swap(1),
-%%        dup(2),
-%%        %% Stack: elements ADDR e ADDR
-%%        push(32*I),
-%%        i(?ADD),
-%%        %% Stack: elements ADDR e ADDR+32I
-%%        i(?MSTORE)].
-
-%% Resolve references, and convert code from deep list to flat list.
-%% List elements are:
-%%   Opcodes
-%%   Byte values
-%%   {'JUMPDEST', Ref}   -- assembles to ?JUMPDEST and sets Ref
-%%   {push_label, Ref}  -- assembles to ?PUSHN address bytes
-
-%% For now, we assemble all code addresses as three bytes.
-
-resolve_references(Code) ->
-    Peephole = peep_hole(lists:flatten(Code)),
-    %% WARNING: Optimizing jumps reorders the code and deletes
-    %% instructions. When debugging the assemble_ functions, it can be
-    %% useful to replace the next line by:
-    %% Instrs = lists:flatten(Code),
-    %% thus disabling the optimization.
-    OptimizedJumps = optimize_jumps(Peephole),
-    Instrs = lists:reverse(peep_hole_backwards(lists:reverse(OptimizedJumps))),
-    Labels = define_labels(0, Instrs),
-    lists:flatten([use_labels(Labels, I) || I <- Instrs]).
-
-define_labels(Addr, [{'JUMPDEST', Lab}|More]) ->
-    [{Lab, Addr}|define_labels(Addr + 1, More)];
-define_labels(Addr, [{push_label, _}|More]) ->
-    define_labels(Addr + 4, More);
-define_labels(Addr, [{pop_args, N}|More]) ->
-    define_labels(Addr + N + 1, More);
-define_labels(Addr, [_|More]) ->
-    define_labels(Addr + 1, More);
-define_labels(_, []) ->
-    [].
-
-use_labels(_, {'JUMPDEST', _}) ->
-    'JUMPDEST';
-use_labels(Labels, {push_label, Ref}) ->
-    case proplists:get_value(Ref, Labels) of
-        undefined ->
-            gen_error({undefined_label, Ref});
-        Addr when is_integer(Addr) ->
-            [i(?PUSH3),
-             Addr div 65536, (Addr div 256) rem 256, Addr rem 256]
-    end;
-use_labels(_, {pop_args, N}) ->
-    [swap(N), pop(N)];
-use_labels(_, I) ->
-    I.
-
-%% Peep-hole optimization.
-%% The compilation of conditionals can introduce jumps depending on
-%% constants 1 and 0. These are removed by peep-hole optimization.
-
-peep_hole(['PUSH1', 0, {push_label, _}, 'JUMPI'|More]) ->
-    peep_hole(More);
-peep_hole(['PUSH1', 1, {push_label, Lab}, 'JUMPI'|More]) ->
-    [{push_label, Lab}, 'JUMP'|peep_hole(More)];
-peep_hole([{pop_args, M}, {pop_args, N}|More]) when M + N =< 16 ->
-    peep_hole([{pop_args, M + N}|More]);
-peep_hole([I|More]) ->
-    [I|peep_hole(More)];
-peep_hole([]) ->
-    [].
-
-%% Peep-hole optimization on reversed instructions lists.
-
-peep_hole_backwards(Code) ->
-    NewCode = peep_hole_backwards1(Code),
-    if Code == NewCode -> Code;
-       true            -> peep_hole_backwards(NewCode)
-    end.
-
-peep_hole_backwards1(['ADD', 0, 'PUSH1'|Code]) ->
-    peep_hole_backwards1(Code);
-peep_hole_backwards1(['POP', UnOp|Code]) when UnOp=='MLOAD';UnOp=='ISZERO';UnOp=='NOT' ->
-    peep_hole_backwards1(['POP'|Code]);
-peep_hole_backwards1(['POP', BinOp|Code]) when
-    %% TODO: more binary operators
-    BinOp=='ADD';BinOp=='SUB';BinOp=='MUL';BinOp=='SDIV' ->
-    peep_hole_backwards1(['POP', 'POP'|Code]);
-peep_hole_backwards1(['POP', _, 'PUSH1'|Code]) ->
-    peep_hole_backwards1(Code);
-peep_hole_backwards1([I|Code]) ->
-    [I|peep_hole_backwards1(Code)];
-peep_hole_backwards1([]) ->
-    [].
-
-%% Jump optimization:
-%%   Replaces a jump to a jump with a jump to the final destination
-%%   Moves basic blocks to eliminate an unconditional jump to them.
-
-%% The compilation of conditionals generates a lot of labels and
-%% jumps, some of them unnecessary. This optimization phase reorders
-%% code so that as many jumps as possible can be eliminated, and
-%% replaced by just falling through to the destination label. This
-%% both optimizes the code generated by conditionals, and converts one
-%% call of a function into falling through into its code--so it
-%% reorders code quite aggressively. Function returns are indirect
-%% jumps, however, and are never optimized away.
-
-%% IMPORTANT: since execution begins at address zero, then the first
-%% block of code must never be moved elsewhere. The code below has
-%% this property, because it processes blocks from left to right, and
-%% because the first block does not begin with a label, and so can
-%% never be jumped to--hence no code can be inserted before it.
-
-%% The optimization works by taking one block of code at a time, and
-%% then prepending blocks that jump directly to it, and appending
-%% blocks that it jumps directly to, resulting in a jump-free sequence
-%% that is as long as possible. To do so, we store blocks in the form
-%% {OptionalLabel, Body, OptionalJump} which represents the code block
-%% OptionalLabel++Body++OptionalJump; the optional parts are the empty
-%% list of instructions if not present.  Two blocks can be merged if
-%% the first ends in an OptionalJump to the OptionalLabel beginning
-%% the second; the OptionalJump can then be removed (and the
-%% OptionalLabel if there are no other references to it--this happens
-%% during dead code elimination.
-
-%% TODO: the present implementation is QUADRATIC, because we search
-%% repeatedly for matching blocks to merge with the first one, storing
-%% the blocks in a list. A near linear time implementation could use
-%% two ets tables, one keyed on the labels, and the other keyed on the
-%% final jumps.
-
-optimize_jumps(Code) ->
-    JJs = jumps_to_jumps(Code),
-    ShortCircuited = [short_circuit_jumps(JJs, Instr) || Instr <- Code],
-    NoDeadCode = eliminate_dead_code(ShortCircuited),
-    MovedCode = merge_blocks(moveable_blocks(NoDeadCode)),
-    %% Moving code may have made some labels superfluous.
-    eliminate_dead_code(MovedCode).
-
-
-jumps_to_jumps([{'JUMPDEST', Label}, {push_label, Target}, 'JUMP'|More]) ->
-    [{Label, Target}|jumps_to_jumps(More)];
-jumps_to_jumps([{'JUMPDEST', Label}, {'JUMPDEST', Target}|More]) ->
-    [{Label, Target}|jumps_to_jumps([{'JUMPDEST', Target}|More])];
-jumps_to_jumps([_|More]) ->
-    jumps_to_jumps(More);
-jumps_to_jumps([]) ->
-    [].
-
-short_circuit_jumps(JJs, {push_label, Lab}) ->
-    case proplists:get_value(Lab, JJs) of
-        undefined ->
-            {push_label, Lab};
-        Target ->
-            %% I wonder if this will ever loop infinitely?
-            short_circuit_jumps(JJs, {push_label, Target})
-    end;
-short_circuit_jumps(_JJs, Instr) ->
-    Instr.
-
-eliminate_dead_code(Code) ->
-    Jumps = lists:usort([Lab || {push_label, Lab} <- Code]),
-    NewCode = live_code(Jumps, Code),
-    if Code==NewCode ->
-            Code;
-       true ->
-            eliminate_dead_code(NewCode)
-    end.
-
-live_code(Jumps, ['JUMP'|More]) ->
-    ['JUMP'|dead_code(Jumps, More)];
-live_code(Jumps, ['STOP'|More]) ->
-    ['STOP'|dead_code(Jumps, More)];
-live_code(Jumps, [{'JUMPDEST', Lab}|More]) ->
-    case lists:member(Lab, Jumps) of
-        true ->
-            [{'JUMPDEST', Lab}|live_code(Jumps, More)];
-        false ->
-            live_code(Jumps, More)
-    end;
-live_code(Jumps, [I|More]) ->
-    [I|live_code(Jumps, More)];
-live_code(_, []) ->
-    [].
-
-dead_code(Jumps, [{'JUMPDEST', Lab}|More]) ->
-    case lists:member(Lab, Jumps) of
-        true ->
-            [{'JUMPDEST', Lab}|live_code(Jumps, More)];
-        false ->
-            dead_code(Jumps, More)
-    end;
-dead_code(Jumps, [_I|More]) ->
-    dead_code(Jumps, More);
-dead_code(_, []) ->
-    [].
-
-%% Split the code into "moveable blocks" that control flow only
-%% reaches via jumps.
-moveable_blocks([]) ->
-    [];
-moveable_blocks([I]) ->
-    [[I]];
-moveable_blocks([Jump|More]) when Jump=='JUMP'; Jump=='STOP' ->
-    [[Jump]|moveable_blocks(More)];
-moveable_blocks([I|More]) ->
-    [Block|MoreBlocks] = moveable_blocks(More),
-    [[I|Block]|MoreBlocks].
-
-%% Merge blocks to eliminate jumps where possible.
-merge_blocks(Blocks) ->
-    BlocksAndTargets = [label_and_jump(B) || B <- Blocks],
-    [I || {Pref, Body, Suff} <- merge_after(BlocksAndTargets),
-          I <- Pref++Body++Suff].
-
-%% Merge the first block with other blocks that come after it
-merge_after(All=[{Label, Body, [{push_label, Target}, 'JUMP']}|BlocksAndTargets]) ->
-    case [{B, J} || {[{'JUMPDEST', L}], B, J} <- BlocksAndTargets,
-                   L == Target] of
-        [{B, J}|_] ->
-            merge_after([{Label, Body ++ [{'JUMPDEST', Target}] ++ B, J}|
-                         lists:delete({[{'JUMPDEST', Target}], B, J},
-                                      BlocksAndTargets)]);
-        [] ->
-            merge_before(All)
-    end;
-merge_after(All) ->
-    merge_before(All).
-
-%% The first block cannot be merged with any blocks that it jumps
-%% to... but maybe it can be merged with a block that jumps to it!
-merge_before([Block={[{'JUMPDEST', Label}], Body, Jump}|BlocksAndTargets]) ->
-    case [{L, B, T} || {L, B, [{push_label, T}, 'JUMP']} <- BlocksAndTargets,
-                     T == Label] of
-        [{L, B, T}|_] ->
-            merge_before([{L, B ++ [{'JUMPDEST', Label}] ++ Body, Jump}
-                          |lists:delete({L, B, [{push_label, T}, 'JUMP']}, BlocksAndTargets)]);
-        _ ->
-            [Block | merge_after(BlocksAndTargets)]
-    end;
-merge_before([Block|BlocksAndTargets]) ->
-    [Block | merge_after(BlocksAndTargets)];
-merge_before([]) ->
-    [].
-
-%% Convert each block to a PREFIX, which is a label or empty, a
-%% middle, and a SUFFIX which is a JUMP to a label, or empty.
-label_and_jump(B) ->
-    {Label, B1} = case B of
-                     [{'JUMPDEST', L}|More1] ->
-                         {[{'JUMPDEST', L}], More1};
-                     _ ->
-                         {[], B}
-                 end,
-    {Target, B2} = case lists:reverse(B1) of
-                      ['JUMP', {push_label, T}|More2] ->
-                          {[{push_label, T}, 'JUMP'], lists:reverse(More2)};
-                      _ ->
-                          {[], B1}
-                  end,
-    {Label, B2, Target}.

src/aeso_parse_lib.erl

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

@@ -14,12 +14,14 @@
 -define(RULE(A, B, C,                Do), map(fun({_1, _2, _3}) ->                     Do end, {A, B, C}               )).
 -define(RULE(A, B, C, D,             Do), map(fun({_1, _2, _3, _4}) ->                 Do end, {A, B, C, D}            )).
 -define(RULE(A, B, C, D, E,          Do), map(fun({_1, _2, _3, _4, _5}) ->             Do end, {A, B, C, D, E}         )).
--define(RULE(A, B, C, D, E, F, Do), map(fun({_1, _2, _3, _4, _5, _6}) -> Do end, {A, B, C, D, E, F})).
+-define(RULE(A, B, C, D, E, F,       Do), map(fun({_1, _2, _3, _4, _5, _6}) ->         Do end, {A, B, C, D, E, F}      )).
+-define(RULE(A, B, C, D, E, F, G,    Do), map(fun({_1, _2, _3, _4, _5, _6, _7}) ->     Do end, {A, B, C, D, E, F, G}   )).
+-define(RULE(A, B, C, D, E, F, G, H, Do), map(fun({_1, _2, _3, _4, _5, _6, _7, _8}) -> Do end, {A, B, C, D, E, F, G, H})).
 
 -import(aeso_parse_lib,
         [tok/1, tok/2, between/3, many/1, many1/1, sep/2, sep1/2,
          infixl/1, infixr/1, choice/1, choice/2, return/1, layout/0,
-         fail/0, fail/1, map/2, infixl/2, infixr/2, infixl1/2, infixr1/2,
+         fail/0, fail/1, fail/2, map/2, infixl/2, infixr/2, infixl1/2, infixr1/2,
          left/2, right/2, optional/1]).
 
 

src/aeso_parser.erl

@@ -3,21 +3,34 @@
 %%% 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,
-         type/1]).
+         decl/0,
+         type/0,
+         body/0,
+         maybe_block/1,
+         run_parser/2,
+         run_parser/3]).
 
 -include("aeso_parse_lib.hrl").
+-import(aeso_parse_lib, [current_file/0, set_current_file/1,
+                         current_include_type/0, set_current_include_type/1]).
 
--type parse_result() :: {ok, aeso_syntax:ast()}
-                      | {error, {aeso_parse_lib:pos(), atom(), term()}}
-                      | {error, {aeso_parse_lib:pos(), atom()}}.
+-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).
+
 -spec string(string()) -> parse_result().
 string(String) ->
     string(String, sets:new(), []).
@@ -31,23 +44,49 @@ string(String, Opts) ->
 
 -spec string(string(), sets:set(include_hash()), aeso_compiler:options()) -> parse_result().
 string(String, Included, Opts) ->
-    case parse_and_scan(file(), String, Opts) of
-        {ok, AST} ->
-            expand_includes(AST, Included, Opts);
-        Err = {error, _} ->
-            Err
+    AST = run_parser(file(), String, Opts),
+    case expand_includes(AST, Included, Opts) of
+        {ok, AST1}   -> AST1;
+        {error, Err} -> parse_error(Err)
     end.
 
-type(String) ->
-    parse_and_scan(type(), String, []).
+
+run_parser(P, Inp) ->
+    escape_errors(parse_and_scan(P, Inp, [])).
+run_parser(P, Inp, Opts) ->
+    escape_errors(parse_and_scan(P, Inp, Opts)).
 
 parse_and_scan(P, S, Opts) ->
     set_current_file(proplists:get_value(src_file, Opts, no_file)),
+    set_current_include_type(proplists:get_value(include_type, Opts, none)),
     case aeso_scan:scan(S) of
         {ok, Tokens} -> aeso_parse_lib:parse(P, Tokens);
-        Error        -> Error
+        {error, {{Input, Pos}, _}} ->
+            {error, {Pos, scan_error, Input}}
     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())).
@@ -56,10 +95,24 @@ decl() ->
     ?LAZY_P(
     choice(
       %% Contract declaration
-    [ ?RULE(keyword(contract),  con(), tok('='), maybe_block(decl()), {contract, _1, _2, _4})
-    , ?RULE(token(payable),     keyword(contract), con(), tok('='), maybe_block(decl()), add_modifiers([_1], {contract, _2, _3, _5}))
+    [ ?RULE(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(namespace), con(), tok('='), maybe_block(decl()), {namespace, _1, _2, _4})
     , ?RULE(keyword(include),   str(), {include, get_ann(_1), _2})
+    , using()
+    , pragma()
 
       %% Type declarations  TODO: format annotation for "type bla" vs "type bla()"
     , ?RULE(keyword(type),     id(),                                          {type_decl, _1, _2, []})
@@ -72,11 +125,54 @@ decl() ->
     , ?RULE(keyword(datatype), id(), type_vars(), tok('='), typedef(variant), {type_def, _1, _2, _3, _5})
 
       %% Function declarations
-    , ?RULE(modifiers(), fun_or_entry(), id(), tok(':'), type(), add_modifiers(_1, _2, {fun_decl, get_ann(_2), _3, _5}))
-    , ?RULE(modifiers(), fun_or_entry(), fundef(),               add_modifiers(_1, _2, set_pos(get_pos(get_ann(_2)), _3)))
+    , ?RULE(modifiers(), fun_or_entry(), maybe_block(fundef_or_decl()), fun_block(_1, _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 ]}.
+
+typevar_constraint() ->
+    ?RULE(tvar(), keyword(is), id(), {constraint, get_ann(_1), _1, _3}).
+
+typevars_constraints() ->
+    ?RULE(comma_sep1(typevar_constraint()), tok(';'), _1).
+
+fundecl() ->
+    choice([?RULE(id(), tok(':'), typevars_constraints(), type(),
+                  {fun_decl, get_ann(_1), _1, {constrained_t, get_ann(_1), _3, _4}}),
+            ?RULE(id(), tok(':'), type(), {fun_decl, get_ann(_1), _1, _3})]).
+
+fundef_or_decl() ->
+    choice([fundecl(), fundef()]).
+
+using() ->
+    Alias = {keyword(as), con()},
+    For = ?RULE(keyword(for), bracket_list(id()), {for, _2}),
+    Hiding = ?RULE(keyword(hiding), bracket_list(id()), {hiding, _2}),
+    ?RULE(keyword(using), con(), optional(Alias), optional(choice(For, Hiding)), using(get_ann(_1), _2, _3, _4)).
+
+using(Ann, Con, none, none) ->
+    {using, Ann, Con, none, none};
+using(Ann, Con, {ok, {_, Alias}}, none) ->
+    {using, Ann, Con, Alias, none};
+using(Ann, Con, none, {ok, List}) ->
+    {using, Ann, Con, none, List};
+using(Ann, Con, {ok, {_, Alias}}, {ok, List}) ->
+    {using, Ann, Con, Alias, List}.
+
+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})]).
@@ -125,22 +221,30 @@ letdecl() ->
 letdef() -> choice(valdef(), fundef()).
 
 valdef() ->
+    ?RULE(pattern(), tok('='), body(), {letval, [], _1, _3}).
+
+guarded_fundefs() ->
     choice(
-        ?RULE(id(),                   tok('='), body(), {letval, [], _1, type_wildcard(), _3}),
-        ?RULE(id(), tok(':'), type(), tok('='), body(), {letval, [], _1, _3, _5})).
+    [ ?RULE(keyword('='), body(), [{guarded, _1, [], _2}])
+    , maybe_block(?RULE(keyword('|'), comma_sep(expr()), tok('='), body(), {guarded, _1, _2, _4}))
+    ]).
 
 fundef() ->
     choice(
-    [ ?RULE(id(), args(),                   tok('='), body(), {letfun, [], _1, _2, type_wildcard(), _4})
-    , ?RULE(id(), args(), tok(':'), type(), tok('='), body(), {letfun, [], _1, _2, _4, _6})
+    [ ?RULE(id(), args(),                   guarded_fundefs(), {letfun, get_ann(_1), _1, _2, type_wildcard(get_ann(_1)), _3})
+    , ?RULE(id(), args(), tok(':'), type(), guarded_fundefs(), {letfun, get_ann(_1), _1, _2, _4, _5})
     ]).
 
-args() -> paren_list(arg()).
+args() -> paren_list(pattern()).
+lam_args() -> paren_list(arg()).
 
 arg() -> choice(
-    ?RULE(id(),                   {arg, get_ann(_1), _1, type_wildcard()}),
+    ?RULE(id(),                   {arg, get_ann(_1), _1, type_wildcard(get_ann(_1))}),
     ?RULE(id(), tok(':'), type(), {arg, get_ann(_1), _1, _3})).
 
+letpat() ->
+    ?RULE(keyword('('), id(), tok('='), pattern(), tok(')'), {letpat, get_ann(_1), _2, _4}).
+
 %% -- Types ------------------------------------------------------------------
 
 type_vars() -> paren_list(tvar()).
@@ -187,7 +291,8 @@ body() ->
 
 stmt() ->
     ?LAZY_P(choice(
-    [ expr()
+    [ using()
+    , expr()
     , letdecl()
     , {switch, keyword(switch), parens(expr()), maybe_block(branch())}
     , {'if', keyword('if'), parens(expr()), body()}
@@ -196,10 +301,16 @@ stmt() ->
     ])).
 
 branch() ->
-    ?RULE(pattern(), keyword('=>'), body(), {'case', _2, _1, _3}).
+    ?RULE(pattern(), guarded_branches(), {'case', get_ann(lists:nth(1, _2)), _1, _2}).
+
+guarded_branches() ->
+    choice(
+    [ ?RULE(keyword('=>'), body(), [{guarded, _1, [], _2}])
+    , maybe_block(?RULE(tok('|'), comma_sep(expr()), keyword('=>'), body(), {guarded, _3, _2, _4}))
+    ]).
 
 pattern() ->
-    ?LET_P(E, expr500(), parse_pattern(E)).
+    ?LET_P(E, expr(), parse_pattern(E)).
 
 %% -- Expressions ------------------------------------------------------------
 
@@ -207,17 +318,18 @@ expr() -> expr100().
 
 expr100() ->
     Expr100 = ?LAZY_P(expr100()),
-    Expr200 = ?LAZY_P(expr200()),
+    Expr150 = ?LAZY_P(expr150()),
     choice(
-    [ ?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())),
+    [ ?RULE(lam_args(), keyword('=>'), body(), {lam, _2, _1, _3})   %% TODO: better location
+    , {'if', keyword('if'), parens(Expr100), Expr150, right(tok(else), Expr100)}
+    , ?RULE(Expr150, optional(right(tok(':'), type())),
             case _2 of
                 none       -> _1;
                 {ok, Type} -> {typed, get_ann(_1), _1, Type}
             end)
     ]).
 
+expr150() -> infixl(expr200(), binop('|>')).
 expr200() -> infixr(expr300(), binop('||')).
 expr300() -> infixr(expr400(), binop('&&')).
 expr400() -> infix(expr500(),  binop(['<', '>', '=<', '>=', '==', '!='])).
@@ -233,7 +345,7 @@ exprAtom() ->
     ?LAZY_P(begin
         Expr = ?LAZY_P(expr()),
         choice(
-        [ id_or_addr(), con(), token(qid), token(qcon)
+        [ id_or_addr(), con(), token(qid), token(qcon), binop_as_lam()
         , token(bytes), token(string), token(char)
         , token(int)
         , ?RULE(token(hex), set_ann(format, hex, setelement(1, _1, int)))
@@ -244,6 +356,7 @@ exprAtom() ->
         , ?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))
+        , letpat()
         ])
     end).
 
@@ -258,7 +371,7 @@ comprehension_if() ->
     ?RULE(keyword('if'), parens(expr()), {comprehension_if, _1, _2}).
 
 comprehension_bind() ->
-    ?RULE(id(), tok('<-'), expr(), {comprehension_bind, _1, _3}).
+    ?RULE(pattern(), tok('<-'), expr(), {comprehension_bind, _1, _3}).
 
 arg_expr() ->
     ?LAZY_P(
@@ -285,7 +398,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, Ann, E, Args}, Es);
+elim(E, [{app, _Ann, Args} | Es])        -> elim({app, aeso_syntax:get_ann(E), 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).
@@ -310,7 +423,9 @@ record(Fs) ->
                         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)}
+            {map, Ann, lists:map(KV, Fs)};
+        record_or_map_error ->
+            {record_or_map_error, get_ann(hd(Fs)), Fs}
     end.
 
 record_or_map(Fields) ->
@@ -322,9 +437,7 @@ record_or_map(Fields) ->
     case lists:usort(lists:map(Kind, Fields)) of
         [proj]    -> record;
         [map_get] -> map;
-        _         ->
-            [{field, Ann, _, _} | _] = Fields,
-            bad_expr_err("Mixed record fields and map keys in", {record, Ann, Fields})
+        _         -> record_or_map_error %% Defer error until type checking
     end.
 
 field_assignment() ->
@@ -369,6 +482,19 @@ id()       -> token(id).
 tvar()     -> token(tvar).
 str()      -> token(string).
 
+binop_as_lam() ->
+    BinOps = ['&&', '||',
+              '+', '-', '*', '/', '^', 'mod',
+              '==', '!=', '<', '>', '<=', '=<', '>=',
+              '::', '++', '|>'],
+    OpToLam = fun(Op = {_, Ann}) ->
+                  IdL = {id, Ann, "l"},
+                  IdR = {id, Ann, "r"},
+                  Arg = fun(Id) -> {arg, Ann, Id, type_wildcard(Ann)} end,
+                  {lam, Ann, [Arg(IdL), Arg(IdR)], infix(IdL, Op, IdR)}
+              end,
+    ?RULE(parens(choice(lists:map(fun token/1, BinOps))), OpToLam(_1)).
+
 token(Tag) ->
     ?RULE(tok(Tag),
     case _1 of
@@ -379,7 +505,7 @@ token(Tag) ->
 id(Id) ->
     ?LET_P({id, A, X} = Y, id(),
            if X == Id -> Y;
-              true    -> fail({A, "expected 'bytes'"})
+              true    -> fail({A, "expected '" ++ Id ++ "'"})
            end).
 
 id_or_addr() ->
@@ -411,6 +537,7 @@ parens(P)   -> between(tok('('), P, tok(')')).
 braces(P)   -> between(tok('{'), P, tok('}')).
 brackets(P) -> between(tok('['), P, tok(']')).
 comma_sep(P) -> sep(P, tok(',')).
+comma_sep1(P) -> sep1(P, tok(',')).
 
 paren_list(P)   -> parens(comma_sep(P)).
 brace_list(P)   -> braces(comma_sep(P)).
@@ -423,13 +550,11 @@ bracket_list(P) -> brackets(comma_sep(P)).
 -type ann_col()  :: aeso_syntax:ann_col().
 
 -spec pos_ann(ann_line(), ann_col()) -> ann().
-pos_ann(Line, Col) -> [{file, current_file()}, {line, Line}, {col, Col}].
-
-current_file() ->
-    get('$current_file').
-
-set_current_file(File) ->
-    put('$current_file', File).
+pos_ann(Line, Col) ->
+    [ {file, current_file()}
+    , {include_type, current_include_type()}
+    , {line, Line}
+    , {col, Col} ].
 
 ann_pos(Ann) ->
     {proplists:get_value(file, Ann),
@@ -461,8 +586,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() ->
-    {id, [{origin, system}], "_"}.
+type_wildcard(Ann) ->
+    {id, [{origin, system} | Ann], "_"}.
 
 block_e(Stmts) ->
     group_ifs(Stmts, []).
@@ -510,9 +635,13 @@ tuple_e(Ann, Exprs)   -> {tuple, Ann, Exprs}.
 list_comp_e(Ann, Expr, Binds) -> {list_comp, Ann, Expr, Binds}.
 
 -spec parse_pattern(aeso_syntax:expr()) -> aeso_parse_lib:parser(aeso_syntax:pat()).
+parse_pattern({letpat, Ann, Id, Pat}) ->
+    {letpat, Ann, Id, parse_pattern(Pat)};
 parse_pattern({app, Ann, Con = {'::', _}, Es}) ->
     {app, Ann, Con, lists:map(fun parse_pattern/1, Es)};
-parse_pattern({app, Ann, Con = {con, _, _}, Es}) ->
+parse_pattern({app, Ann, {'-', _}, [{int, _, N}]}) ->
+    {int, Ann, -N};
+parse_pattern({app, Ann, Con = {Tag, _, _}, Es}) when Tag == con; Tag == qcon ->
     {app, Ann, Con, lists:map(fun parse_pattern/1, Es)};
 parse_pattern({tuple, Ann, Es}) ->
     {tuple, Ann, lists:map(fun parse_pattern/1, Es)};
@@ -520,7 +649,10 @@ 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 = {int, _, _})    -> E;
 parse_pattern(E = {bool, _, _})   -> E;
@@ -533,14 +665,9 @@ parse_pattern(E) -> bad_expr_err("Not a valid pattern", E).
 parse_field_pattern({field, Ann, F, E}) ->
     {field, Ann, F, parse_pattern(E)}.
 
-return_error({no_file, L, C}, Err) ->
-    fail(io_lib:format("~p:~p:\n~s", [L, C, Err]));
-return_error({F, L, C}, Err) ->
-    fail(io_lib:format("In ~s at ~p:~p:\n~s", [F, L, C, Err])).
-
 -spec ret_doc_err(ann(), prettypr:document()) -> aeso_parse_lib:parser(none()).
 ret_doc_err(Ann, Doc) ->
-    return_error(ann_pos(Ann), prettypr:format(Doc)).
+    fail(ann_pos(Ann), prettypr:format(Doc)).
 
 -spec bad_expr_err(string(), aeso_syntax:expr()) -> aeso_parse_lib:parser(none()).
 bad_expr_err(Reason, E) ->
@@ -556,17 +683,28 @@ expand_includes(AST, Included, Opts) ->
              || File <- lists:usort(auto_imports(AST)) ] ++ AST,
     expand_includes(AST1, Included, [], Opts).
 
-expand_includes([], _Included, Acc, _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 ->
+                    SrcFile = proplists:get_value(src_file, Opts, no_file),
+                    IncludeType = case proplists:get_value(file, Ann) of
+                                      SrcFile -> direct;
+                                      _       -> indirect
+                                  end,
                     Opts1 = lists:keystore(src_file, 1, Opts, {src_file, File}),
+                    Opts2 = lists:keystore(include_type, 1, Opts1, {include_type, IncludeType}),
                     Included1 = sets:add_element(Hashed, Included),
-                    case parse_and_scan(file(), Code, Opts1) of
+                    case parse_and_scan(file(), Code, Opts2) of
                         {ok, AST1} ->
                             expand_includes(AST1 ++ AST, Included1, Acc, Opts);
                         Err = {error, _} ->
@@ -591,16 +729,39 @@ 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() ->
-    [{include, {file_system, [aeso_stdlib:stdlib_include_path()]}}].
+    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, _}, {ok,_ }} ->
-            return_error(ann_pos(Ann), "Illegal redefinition of standard library " ++ File);
+        {{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}, _} ->

src/aeso_pretty.erl

@@ -13,6 +13,8 @@
 
 -export_type([options/0]).
 
+-include("aeso_utils.hrl").
+
 -type doc() :: prettypr:document().
 -type options() :: [{indent, non_neg_integer()} | show_generated].
 
@@ -131,6 +133,10 @@ 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().
@@ -145,22 +151,30 @@ decl(D, Options) ->
     with_options(Options, fun() -> decl(D) end).
 
 -spec decl(aeso_syntax:decl()) -> doc().
-decl({contract, _, C, Ds}) ->
-    block(follow(text("contract"), hsep(name(C), text("="))), decls(Ds));
+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({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(Fun, typed(name(F), T));
+    hsep(lists:map(Mod, Ann) ++ [Fun, typed(name(F), T)]);
 decl(D = {letfun, Attrs, _, _, _, _}) ->
-    Mod = fun({Mod, true}) when Mod == private; Mod == stateful ->
+    Mod = fun({Mod, true}) when Mod == private; Mod == stateful; Mod == payable ->
                             text(atom_to_list(Mod));
              (_) -> empty() end,
     Fun = case aeso_syntax:get_ann(entrypoint, Attrs, false) of
@@ -168,7 +182,15 @@ decl(D = {letfun, Attrs, _, _, _, _}) ->
               false -> "function"
           end,
     hsep(lists:map(Mod, Attrs) ++ [letdecl(Fun, D)]);
-decl(D = {letval, _, _, _, _}) -> letdecl("let", 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], ".")).
 
 -spec expr(aeso_syntax:expr(), options()) -> doc().
 expr(E, Options) ->
@@ -188,10 +210,12 @@ name({tvar, _, Name})  -> text(Name);
 name({typed, _, Name, _}) -> name(Name).
 
 -spec letdecl(string(), aeso_syntax:letbind()) -> doc().
-letdecl(Let, {letval, _, F, T, E}) ->
-    block_expr(0, hsep([text(Let), typed(name(F), T), text("=")]), E);
-letdecl(Let, {letfun, _, F, Args, T, E}) ->
-    block_expr(0, hsep([text(Let), typed(beside(name(F), args(Args)), T), text("=")]), E).
+letdecl(Let, {letval, _, P, E}) ->
+    block_expr(0, hsep([text(Let), expr(P), text("=")]), E);
+letdecl(Let, {letfun, _, F, Args, T, [GuardedBody]}) ->
+    beside(hsep([text(Let), typed(beside(name(F), expr({tuple, [], Args})), T)]), guarded_body(GuardedBody, "="));
+letdecl(Let, {letfun, _, F, Args, T, GuardedBodies}) ->
+    block(hsep([text(Let), typed(beside(name(F), expr({tuple, [], Args})), T)]), above(lists:map(fun(GB) -> guarded_body(GB, "=") end, GuardedBodies))).
 
 -spec args([aeso_syntax:arg()]) -> doc().
 args(Args) ->
@@ -248,6 +272,8 @@ type({args_t, _, 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));
@@ -258,7 +284,9 @@ type(T = {id, _, _})   -> name(T);
 type(T = {qid, _, _})  -> name(T);
 type(T = {con, _, _})  -> name(T);
 type(T = {qcon, _, _}) -> name(T);
-type(T = {tvar, _, _}) -> name(T).
+type(T = {tvar, _, _}) -> name(T);
+type({constrained_t, _, Cs, T}) ->
+    beside([name(T), text(" is "), tuple(lists:map(fun expr/1, Cs))]).
 
 -spec args_type([aeso_syntax:type()]) -> doc().
 args_type(Args) ->
@@ -274,12 +302,11 @@ tuple_type(Factors) ->
       , 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:expr()) -> doc().
+-spec expr_p(integer(), aeso_syntax:arg_expr()) -> doc().
+expr_p(P, {letpat, _, Id, Pat}) ->
+    paren(P > 100, follow(hsep(expr(Id), text("=")), expr(Pat)));
+expr_p(P, {named_arg, _, Name, E}) ->
+    paren(P > 100, follow(hsep(expr(Name), text("=")), expr(E)));
 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}) ->
@@ -300,6 +327,8 @@ 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}) ->
@@ -353,13 +382,19 @@ expr_p(_, {Type, _, Bin})
          Type == oracle_query_id ->
     text(binary_to_list(aeser_api_encoder:encode(Type, Bin)));
 expr_p(_, {string, _, <<>>}) -> text("\"\"");
-expr_p(_, {string, _, S}) -> term(binary_to_list(S));
+expr_p(_, {string, _, S}) ->
+    text(io_lib:format("\"~s\"", [binary_to_list(S)]));
 expr_p(_, {char, _, C}) ->
     case C of
         $' -> text("'\\''");
         $" -> text("'\"'");
-        _  -> S = lists:flatten(io_lib:format("~p", [[C]])),
-              text("'" ++ tl(lists:droplast(S)) ++ "'")
+        _ 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)
     end;
 %% -- Names
 expr_p(_, E = {id, _, _})   -> name(E);
@@ -382,6 +417,13 @@ 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 '[ ]'
@@ -424,7 +466,7 @@ prefix(P, Op, A) ->
 app(P, F, Args) ->
     paren(P > 900,
     beside(expr_p(900, F),
-           tuple(lists:map(fun arg_expr/1, Args)))).
+           tuple(lists:map(fun expr/1, Args)))).
 
 field({field, _, LV, E}) ->
     follow(hsep(lvalue(LV), text("=")), expr(E));
@@ -444,8 +486,18 @@ elim1(Proj={proj, _, _})      -> beside(text("."), elim(Proj));
 elim1(Get={map_get, _, _})    -> elim(Get);
 elim1(Get={map_get, _, _, _}) -> elim(Get).
 
-alt({'case', _, Pat, Body}) ->
-    block_expr(0, hsep(expr_p(500, Pat), text("=>")), Body).
+alt({'case', _, Pat, [GuardedBody]}) ->
+    beside(expr(Pat), guarded_body(GuardedBody, "=>"));
+alt({'case', _, Pat, GuardedBodies}) ->
+    block(expr(Pat), above(lists:map(fun(GB) -> guarded_body(GB, "=>") end, GuardedBodies))).
+
+guarded_body({guarded, _, Guards, Body}, Then) ->
+    block_expr(0, hsep(guards(Guards), text(Then)), Body).
+
+guards([]) ->
+    text("");
+guards(Guards) ->
+    hsep([text(" |"), par(punctuate(text(","), lists:map(fun expr/1, Guards)), 0)]).
 
 block_expr(_, Header, {block, _, Ss}) ->
     block(Header, statements(Ss));
@@ -455,7 +507,7 @@ 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(E) -> expr(E).
 
@@ -468,6 +520,3 @@ 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,27 +7,34 @@
 %%%-------------------------------------------------------------------
 -module(aeso_scan).
 
--export([scan/1]).
+-export([scan/1, utf8_encode/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      = [DIGIT, "+"],
-    HEX      = ["0x", HEXDIGIT, "+"],
-    BYTES    = ["#", HEXDIGIT, "+"],
+    INT      = Number(DIGIT),
+    HEX      = ["0x", Number(HEXDIGIT)],
+    BYTES    = ["#", Number(HEXDIGIT)],
     WS       = "[\\000-\\ ]+",
     ID       = [LOWER, "[a-zA-Z0-9_']*"],
     TVAR     = ["'", ID],
     QID      = ["(", CON, "\\.)+", ID],
     QCON     = ["(", CON, "\\.)+", CON],
     OP       = "[=!<>+\\-*/:&|?~@^]+",
-    CHAR     = "'([^'\\\\]|(\\\\.))'",
+    %% 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]*\\}))'",
     STRING   = "\"([^\"\\\\]|(\\\\.))*\"",
 
     CommentStart = {"/\\*", push(comment, skip())},
@@ -37,7 +44,9 @@ lexer() ->
         , {"[^/*]+|[/*]", skip()} ],
 
     Keywords = ["contract", "include", "let", "switch", "type", "record", "datatype", "if", "elif", "else", "function",
-                "stateful", "payable", "true", "false", "mod", "public", "entrypoint", "private", "indexed", "namespace"],
+                "stateful", "payable", "true", "false", "mod", "public", "entrypoint", "private", "indexed", "namespace",
+                "interface", "main", "using", "as", "for", "hiding", "is"
+               ],
     KW = string:join(Keywords, "|"),
 
     Rules =
@@ -53,7 +62,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 list_to_integer/1)}
+        , {INT,    token(int,    fun parse_int/1)}
         , {BYTES,  token(bytes,  fun parse_bytes/1)}
 
           %% Identifiers (qualified first!)
@@ -76,32 +85,34 @@ scan(String) ->
 %% -- Helpers ----------------------------------------------------------------
 
 parse_string([$" | Chars]) ->
-    unescape(Chars).
+    unicode:characters_to_nfc_binary(unescape(Chars)).
 
-parse_char([$', $\\, Code, $']) ->
-    case Code of
-        $'  -> $';
-        $\\ -> $\\;
-        $b  -> $\b;
-        $e  -> $\e;
-        $f  -> $\f;
-        $n  -> $\n;
-        $r  -> $\r;
-        $t  -> $\t;
-        $v  -> $\v;
-        _   -> {error, "Bad control sequence: \\" ++ [Code]}
-    end;
-parse_char([$', C, $']) -> C.
+parse_char([$' | Chars]) ->
+    case unicode:characters_to_nfc_list(unescape($', Chars, [])) of
+        [Char] -> Char;
+        _Bad   -> {error, "Bad character literal: '" ++ Chars}
+    end.
 
-unescape(Str) -> unescape(Str, []).
+utf8_encode(Cs) ->
+    binary_to_list(unicode:characters_to_binary(Cs)).
 
-%% TODO: numeric escapes
-unescape([$"], Acc) ->
+unescape(Str) -> unescape($", Str, []).
+
+unescape(Delim, [Delim], Acc) ->
     list_to_binary(lists:reverse(Acc));
-unescape([$\\, Code | Chars], Acc) ->
-    Ok = fun(C) -> unescape(Chars, [C | Acc]) end,
+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,
     case Code of
-        $"  -> Ok($");
+        Delim -> Ok(Delim);
         $\\ -> Ok($\\);
         $b  -> Ok($\b);
         $e  -> Ok($\e);
@@ -112,13 +123,21 @@ unescape([$\\, Code | Chars], Acc) ->
         $v  -> Ok($\v);
         _   -> error("Bad control sequence: \\" ++ [Code])  %% TODO
     end;
-unescape([C | Chars], Acc) ->
-    unescape(Chars, [C | Acc]).
+unescape(Delim, [C | Chars], Acc) ->
+    unescape(Delim, Chars, [C | Acc]).
 
-parse_hex("0x" ++ Chars) -> list_to_integer(Chars, 16).
+strip_underscores(S) ->
+    lists:filter(fun(C) -> C /= $_ end, S).
 
-parse_bytes("#" ++ Chars) ->
-    N      = list_to_integer(Chars, 16),
-    Digits = (length(Chars) + 1) div 2,
+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,
     <<N:Digits/unit:8>>.
 

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]).
+-export_type([decl/0, letbind/0, typedef/0, pragma/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,7 +25,8 @@
 -type ann_origin() :: system | user.
 -type ann_format() :: '?:' | hex | infix | prefix | elif.
 
--type ann() :: [{line, ann_line()} | {col, ann_col()} | {format, ann_format()} | {origin, ann_origin()} | stateful | private].
+-type ann() :: [ {line, ann_line()} | {col, ann_col()} | {format, ann_format()} | {origin, ann_origin()}
+               | stateful | private | payable | main | interface].
 
 -type name() :: string().
 -type id()   :: {id,   ann(), name()}.
@@ -34,16 +35,38 @@
 -type qcon() :: {qcon, ann(), [name()]}.
 -type tvar() :: {tvar, ann(), name()}.
 
--type decl() :: {contract, ann(), con(), [decl()]}
+-type namespace_alias() :: none | con().
+-type namespace_parts() :: none | {for, [id()]} | {hiding, [id()]}.
+
+-type decl() :: {contract_main, ann(), con(), [decl()]}
+              | {contract_child, ann(), con(), [decl()]}
+              | {contract_interface, ann(), con(), [decl()]}
               | {namespace, ann(), con(), [decl()]}
-              | {type_decl, ann(), id(), [tvar()]}
+              | {pragma, ann(), pragma()}
+              | {type_decl, ann(), id(), [tvar()]} % Only for error msgs
               | {type_def, ann(), id(), [tvar()], typedef()}
-              | {fun_decl, ann(), id(), type()}
-              | letbind().
+              | {fun_clauses, ann(), id(), type(), [letfun() | fundecl()]}
+              | {block, ann(), [decl()]}
+              | {using, ann(), con(), namespace_alias(), namespace_parts()}
+              | fundecl()
+              | letfun()
+              | letval(). % Only for error msgs
+
+-type compiler_version() :: [non_neg_integer()].
+
+-type pragma() :: {compiler, '==' | '<' | '>' | '=<' | '>=', compiler_version()}.
+
+-type guard() :: expr().
+-type guarded_expr() :: {guarded, ann(), [guard()], expr()}.
+
+-type letval()  :: {letval, ann(), pat(), expr()}.
+-type letfun()  :: {letfun, ann(), id(), [pat()], type(), [guarded_expr(),...]}.
+-type letpat()  :: {letpat, ann(), id(), pat()}.
+-type fundecl() :: {fun_decl, ann(), id(), type()}.
 
 -type letbind()
-    :: {letval, ann(), id(), type(), expr()}
-     | {letfun, ann(), id(), [arg()], type(), expr()}.
+    :: letfun()
+     | letval().
 
 -type arg() :: {arg, ann(), id(), type()}.
 
@@ -56,11 +79,14 @@
 
 -type constructor_t() :: {constr_t, ann(), con(), [type()]}.
 
+-type tvar_constraint() :: {constraint, ann(), tvar(), id()}.
+
 -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}
+              | {constrained_t, ann(), [tvar_constraint()], type()}
               | id()  | qid()
               | con() | qcon()  %% contracts
               | tvar().
@@ -95,18 +121,20 @@
      | {list, ann(), [expr()]}
      | {list_comp, ann(), expr(), [comprehension_exp()]}
      | {typed, ann(), expr(), type()}
-     | {record, ann(), [field(expr())]}
-     | {record, ann(), expr(), [field(expr())]} %% record update
-     | {map, ann(), expr(), [field(expr())]}    %% map update
+     | {record_or_map(), ann(), [field(expr())]}
+     | {record_or_map(), ann(), expr(), [field(expr())]} %% record/map update
      | {map, ann(), [{expr(), expr()}]}
      | {map_get, ann(), expr(), expr()}
      | {map_get, ann(), expr(), expr(), expr()}
      | {block, ann(), [stmt()]}
      | {op(), ann()}
      | id() | qid() | con() | qcon()
-     | constant().
+     | constant()
+     | letpat().
 
--type comprehension_exp() :: [ {comprehension_bind, id(), expr()}
+-type record_or_map() :: record | map | record_or_map_error.
+
+-type comprehension_exp() :: [ {comprehension_bind, pat(), expr()}
                              | {comprehension_if, ann(), expr()}
                              | letbind() ].
 
@@ -123,7 +151,7 @@
 -type stmt() :: letbind()
               | expr().
 
--type alt() :: {'case', ann(), pat(), expr()}.
+-type alt() :: {'case', ann(), pat(), [guarded_expr(),...]}.
 
 -type lvalue() :: nonempty_list(elim()).
 
@@ -134,7 +162,9 @@
 -type pat() :: {app, ann(), con() | op(), [pat()]}
              | {tuple, ann(), [pat()]}
              | {list, ann(), [pat()]}
+             | {typed, ann(), pat(), type()}
              | {record, ann(), [field(pat())]}
+             | letpat()
              | constant()
              | con()
              | id().

src/aeso_syntax_utils.erl

@@ -45,11 +45,11 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
             %% decl()
             {contract, _, _, Ds}          -> Decl(Ds);
             {namespace, _, _, Ds}         -> Decl(Ds);
-            {type_decl, _, I, _}     -> BindType(I);
             {type_def, _, I, _, D}        -> Plus(BindType(I), Decl(D));
             {fun_decl, _, _, T}           -> Type(T);
-            {letval, _, F, T, E}     -> Sum([BindExpr(F), Type(T), Expr(E)]);
-            {letfun, _, F, Xs, T, E} -> Sum([BindExpr(F), Type(T), Expr(Xs ++ [E])]);
+            {letval, _, P, E}             -> Scoped(BindExpr(P), Expr(E));
+            {letfun, _, F, Xs, T, GEs} -> Sum([BindExpr(F), Type(T), Expr(Xs ++ GEs)]);
+            {fun_clauses, _, _, T, Cs}    -> Sum([Type(T) | [Decl(C) || C <- Cs]]);
             %% typedef()
             {alias_t, T}    -> Type(T);
             {record_t, Fs}  -> Type(Fs);
@@ -61,6 +61,7 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
             {fun_t, _, Named, Args, Ret} -> Type([Named, Args, Ret]);
             {app_t, _, T, Ts}            -> Type([T | Ts]);
             {tuple_t, _, Ts}             -> Type(Ts);
+            {constrained_t, _, _, T}     -> Type(T);
             %% named_arg_t()
             {named_arg_t, _, _, T, E} -> Plus(Type(T), Expr(E));
             %% expr()
@@ -76,8 +77,8 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
                 Plus(Expr(E), Scoped(BindExpr(I), Expr({list_comp, A, Y, R})));
             {list_comp, A, Y, [{comprehension_if, _, E}|R]} ->
                 Plus(Expr(E), Expr({list_comp, A, Y, R}));
-            {list_comp, A, Y, [D = {letval, _, F, _, _} | R]} ->
-                Plus(Decl(D), Scoped(BindExpr(F), Expr({list_comp, A, Y, R})));
+            {list_comp, A, Y, [D = {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));
@@ -88,13 +89,15 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
             {map_get, _, A, B}     -> Expr([A, B]);
             {map_get, _, A, B, C}  -> Expr([A, B, C]);
             {block, _, Ss}         -> Expr(Ss);
+            {letpat, _, X, P}      -> Plus(BindExpr(X), Expr(P));
+            {guarded, _, Gs, E}    -> Expr([E | Gs]);
             %% field()
             {field, _, LV, E}    -> Expr([LV, E]);
             {field, _, LV, _, E} -> Expr([LV, E]);
             %% arg()
             {arg, _, Y, T} -> Plus(BindExpr(Y), Type(T));
             %% alt()
-            {'case', _, P, E} -> Scoped(BindExpr(P), Expr(E));
+            {'case', _, P, GEs} -> Scoped(BindExpr(P), Expr(GEs));
             %% elim()
             {proj, _, _}    -> Zero;
             {map_get, _, E} -> Expr(E);

src/aeso_utils.hrl

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

src/aeso_vm_decode.erl

@@ -1,77 +1,25 @@
 %%%-------------------------------------------------------------------
 %%% @copyright (C) 2017, Aeternity Anstalt
-%%% @doc Decoding aevm and fate data to AST
-%%%
+%%% @doc Decoding fate data to AST
 %%% @end
 %%%-------------------------------------------------------------------
 
 -module(aeso_vm_decode).
 
--export([ from_aevm/3, from_fate/2 ]).
+-export([ from_fate/2 ]).
 
 -include_lib("aebytecode/include/aeb_fate_data.hrl").
 
-address_literal(Type, N) -> {Type, [], <<N:256>>}.
-
--spec from_aevm(aeb_aevm_data:type(), aeso_syntax:type(), aeb_aevm_data:data()) -> aeso_syntax:expr().
-from_aevm(word, {id, _, "address"},                     N) -> address_literal(account_pubkey, N);
-from_aevm(word, {app_t, _, {id, _, "oracle"}, _},       N) -> address_literal(oracle_pubkey, N);
-from_aevm(word, {app_t, _, {id, _, "oracle_query"}, _}, N) -> address_literal(oracle_query_id, N);
-from_aevm(word, {con, _, _Name},                        N) -> address_literal(contract_pubkey, N);
-from_aevm(word, {id, _, "int"},     N) -> <<N1:256/signed>> = <<N:256>>, {int, [], N1};
-from_aevm(word, {id, _, "bits"},    N) -> error({todo, bits, N});
-from_aevm(word, {id, _, "bool"},    N) -> {bool, [], N /= 0};
-from_aevm(word, {bytes_t, _, Len}, Val) when Len =< 32 ->
-    <<Bytes:Len/unit:8, _/binary>> = <<Val:32/unit:8>>,
-    {bytes, [], <<Bytes:Len/unit:8>>};
-from_aevm({tuple, _}, {bytes_t, _, Len}, Val) ->
-    {bytes, [], binary:part(<< <<W:32/unit:8>> || W <- tuple_to_list(Val) >>, 0, Len)};
-from_aevm(string, {id, _, "string"}, S) -> {string, [], S};
-from_aevm({list, VmType}, {app_t, _, {id, _, "list"}, [Type]}, List) ->
-    {list, [], [from_aevm(VmType, Type, X) || X <- List]};
-from_aevm({variant, [[], [VmType]]}, {app_t, _, {id, _, "option"}, [Type]}, Val) ->
-    case Val of
-        {variant, 0, []}  -> {con, [], "None"};
-        {variant, 1, [X]} -> {app, [], {con, [], "Some"}, [from_aevm(VmType, Type, X)]}
-    end;
-from_aevm({tuple, VmTypes}, {tuple_t, _, Types}, Val)
-        when length(VmTypes) == length(Types),
-             length(VmTypes) == tuple_size(Val) ->
-    {tuple, [], [from_aevm(VmType, Type, X)
-                 || {VmType, Type, X} <- lists:zip3(VmTypes, Types, tuple_to_list(Val))]};
-from_aevm({tuple, VmTypes}, {record_t, Fields}, Val)
-        when length(VmTypes) == length(Fields),
-             length(VmTypes) == tuple_size(Val) ->
-    {record, [], [ {field, [], [{proj, [], FName}], from_aevm(VmType, FType, X)}
-                   || {VmType, {field_t, _, FName, FType}, X} <- lists:zip3(VmTypes, Fields, tuple_to_list(Val)) ]};
-from_aevm({map, VmKeyType, VmValType}, {app_t, _, {id, _, "map"}, [KeyType, ValType]}, Map)
-        when is_map(Map) ->
-    {map, [], [ {from_aevm(VmKeyType, KeyType, Key),
-                 from_aevm(VmValType, ValType, Val)}
-                || {Key, Val} <- maps:to_list(Map) ]};
-from_aevm({variant, VmCons}, {variant_t, Cons}, {variant, Tag, Args})
-        when length(VmCons) == length(Cons),
-             length(VmCons) > Tag ->
-    VmTypes = lists:nth(Tag + 1, VmCons),
-    ConType = lists:nth(Tag + 1, Cons),
-    from_aevm(VmTypes, ConType, Args);
-from_aevm(VmTypes, {constr_t, _, Con, Types}, Args)
-        when length(VmTypes) == length(Types),
-             length(VmTypes) == length(Args) ->
-    {app, [], Con, [ from_aevm(VmType, Type, Arg)
-                     || {VmType, Type, Arg} <- lists:zip3(VmTypes, Types, Args) ]};
-from_aevm(_VmType, _Type, _Data) ->
-    throw(cannot_translate_to_sophia).
-
-
 -spec from_fate(aeso_syntax:type(), aeb_fate_data:fate_type()) -> aeso_syntax:expr().
 from_fate({id, _, "address"}, ?FATE_ADDRESS(Bin)) -> {account_pubkey, [], Bin};
 from_fate({app_t, _, {id, _, "oracle"}, _}, ?FATE_ORACLE(Bin)) -> {oracle_pubkey, [], Bin};
 from_fate({app_t, _, {id, _, "oracle_query"}, _}, ?FATE_ORACLE_Q(Bin)) -> {oracle_query_id, [], Bin};
 from_fate({con, _, _Name},  ?FATE_CONTRACT(Bin)) -> {contract_pubkey, [], Bin};
 from_fate({bytes_t, _, N},  ?FATE_BYTES(Bin)) when byte_size(Bin) == N -> {bytes, [], Bin};
-from_fate({id, _, "bits"},  ?FATE_BITS(Bin)) -> error({todo, bits, Bin});
-from_fate({id, _, "int"},     N) when is_integer(N) -> {int, [], N};
+from_fate({id, _, "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) ->
@@ -87,6 +35,8 @@ 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)}
@@ -105,9 +55,118 @@ from_fate({variant_t, Cons}, {variant, Ar, Tag, Args})
             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({qid, _, QType}, Val) ->
+    from_fate_builtin(QType, Val);
 from_fate(_Type, _Data) ->
     throw(cannot_translate_to_sophia).
+
+
+from_fate_builtin(QType, Val) ->
+    Con = fun([Name | _] = Names) when is_list(Name) -> {qcon, [], Names};
+             (Name) -> {con, [], Name} end,
+    App = fun(Name, []) -> Con(Name);
+             (Name, Value) -> {app, [], Con(Name), Value} end,
+    Chk = fun(Type, Value) -> from_fate(Type, Value) end,
+    Int = {id, [], "int"},
+    Str = {id, [], "string"},
+    Adr = {id, [], "address"},
+    Hsh = {bytes_t, [], 32},
+    I32 = {bytes_t, [], 32},
+    I48 = {bytes_t, [], 48},
+    Qid = fun(Name) -> {qid, [], Name} end,
+    Map = fun(KT, VT) -> {app_t, [], {id, [], "map"}, [KT, VT]} end,
+    ChainTxArities = [3, 0, 0, 0, 0, 0, 1, 1, 1, 2, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 2, 0],
+
+    case {QType, Val} of
+        {["Chain", "ttl"], {variant, [1, 1], 0, {X}}} -> App("RelativeTTL", [Chk(Int, X)]);
+        {["Chain", "ttl"], {variant, [1, 1], 1, {X}}} -> App("FixedTTL", [Chk(Int, X)]);
+
+        {["AENS", "name"], {variant, [3], 0, {Addr, TTL, Ptrs}}} ->
+            App(["AENS","Name"], [Chk(Adr, Addr), Chk(Qid(["Chain", "ttl"]), TTL),
+                              Chk(Map(Str, Qid(["AENS", "pointee"])), Ptrs)]);
+
+        {["AENS", "pointee"], {variant, [1, 1, 1, 1], 0, {Addr}}} ->
+            App(["AENS","AccountPt"], [Chk(Adr, Addr)]);
+        {["AENS", "pointee"], {variant, [1, 1, 1, 1], 1, {Addr}}} ->
+            App(["AENS","OraclePt"], [Chk(Adr, Addr)]);
+        {["AENS", "pointee"], {variant, [1, 1, 1, 1], 2, {Addr}}} ->
+            App(["AENS","ContractPt"], [Chk(Adr, Addr)]);
+        {["AENS", "pointee"], {variant, [1, 1, 1, 1], 3, {Addr}}} ->
+            App(["AENS","ChannelPt"], [Chk(Adr, Addr)]);
+
+        {["Chain", "ga_meta_tx"], {variant, [2], 0, {Addr, X}}} ->
+            App(["Chain","GAMetaTx"], [Chk(Adr, Addr), Chk(Int, X)]);
+
+        {["Chain", "paying_for_tx"], {variant, [2], 0, {Addr, X}}} ->
+            App(["Chain","PayingForTx"], [Chk(Adr, Addr), Chk(Int, X)]);
+
+        {["Chain", "base_tx"], {variant, ChainTxArities, 0, {Addr, Fee, Payload}}} ->
+            App(["Chain","SpendTx"], [Chk(Adr, Addr), Chk(Int, Fee), Chk(Str, Payload)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 1, {}}} ->
+            App(["Chain","OracleRegisterTx"], []);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 2, {}}} ->
+            App(["Chain","OracleQueryTx"], []);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 3, {}}} ->
+            App(["Chain","OracleResponseTx"], []);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 4, {}}} ->
+            App(["Chain","OracleExtendTx"], []);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 5, {}}} ->
+            App(["Chain","NamePreclaimTx"], []);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 6, {Name}}} ->
+            App(["Chain","NameClaimTx"], [Chk(Str, Name)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 7, {NameHash}}} ->
+            App(["Chain","NameUpdateTx"], [Chk(Hsh, NameHash)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 8, {NameHash}}} ->
+            App(["Chain","NameRevokeTx"], [Chk(Hsh, NameHash)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 9, {NewOwner, NameHash}}} ->
+            App(["Chain","NameTransferTx"], [Chk(Adr, NewOwner), Chk(Hsh, NameHash)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 10, {Addr}}} ->
+            App(["Chain","ChannelCreateTx"], [Chk(Adr, Addr)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 11, {Addr, Amount}}} ->
+            App(["Chain","ChannelDepositTx"], [Chk(Adr, Addr), Chk(Int, Amount)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 12, {Addr, Amount}}} ->
+            App(["Chain","ChannelWithdrawTx"], [Chk(Adr, Addr), Chk(Int, Amount)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 13, {Addr}}} ->
+            App(["Chain","ChannelForceProgressTx"], [Chk(Adr, Addr)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 14, {Addr}}} ->
+            App(["Chain","ChannelCloseMutualTx"], [Chk(Adr, Addr)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 15, {Addr}}} ->
+            App(["Chain","ChannelCloseSoloTx"], [Chk(Adr, Addr)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 16, {Addr}}} ->
+            App(["Chain","ChannelSlashTx"], [Chk(Adr, Addr)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 17, {Addr}}} ->
+            App(["Chain","ChannelSettleTx"], [Chk(Adr, Addr)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 18, {Addr}}} ->
+            App(["Chain","ChannelSnapshotSoloTx"], [Chk(Adr, Addr)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 19, {Amount}}} ->
+            App(["Chain","ContractCreateTx"], [Chk(Int, Amount)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 20, {Addr, Amount}}} ->
+            App(["Chain","ContractCallTx"], [Chk(Adr, Addr), Chk(Int, Amount)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 21, {}}} ->
+            App(["Chain","GAAttachTx"], []);
+
+        {["MCL_BLS12_381", "fp"], X} ->
+            App(["MCL_BLS12_381", "fp"], [Chk(I32, X)]);
+        {["MCL_BLS12_381", "fr"], X} ->
+            App(["MCL_BLS12_381", "fr"], [Chk(I48, X)]);
+
+        _ ->
+            throw(cannot_translate_to_sophia)
+    end.
+
+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/aeso_warnings.erl

@@ -0,0 +1,31 @@
+-module(aeso_warnings).
+
+-record(warn, { pos     :: aeso_errors:pos()
+              , message :: iolist()
+              }).
+
+-opaque warning() :: #warn{}.
+
+-export_type([warning/0]).
+
+-export([ new/1
+        , new/2
+        , warn_to_err/2
+        , sort_warnings/1
+        , pp/1
+        ]).
+
+new(Msg) ->
+    new(aeso_errors:pos(0, 0), Msg).
+
+new(Pos, Msg) ->
+    #warn{ pos = Pos, message = Msg }.
+
+warn_to_err(Kind, #warn{ pos = Pos, message = Msg }) ->
+    aeso_errors:new(Kind, Pos, lists:flatten(Msg)).
+
+sort_warnings(Warnings) ->
+    lists:sort(fun(W1, W2) -> W1#warn.pos =< W2#warn.pos end, Warnings).
+
+pp(#warn{ pos = Pos, message = Msg }) ->
+    lists:flatten(io_lib:format("Warning~s:\n~s", [aeso_errors:pp_pos(Pos), Msg])).

src/aesophia.app.src

@@ -1,6 +1,6 @@
 {application, aesophia,
- [{description, "Contract Language for aeternity"},
-  {vsn, "4.0.0-rc1"},
+ [{description, "Compiler for Aeternity Sophia language"},
+  {vsn, "6.1.0"},
   {registered, []},
   {applications,
    [kernel,

test/aeso_abi_tests.erl

@@ -5,7 +5,6 @@
 
 -define(SANDBOX(Code), sandbox(fun() -> Code end)).
 -define(DUMMY_HASH_WORD, 16#123).
--define(DUMMY_HASH, <<0:30/unit:8, 127, 119>>). %% 16#123
 -define(DUMMY_HASH_LIT, "#0000000000000000000000000000000000000000000000000000000000000123").
 
 sandbox(Code) ->
@@ -20,12 +19,6 @@ sandbox(Code) ->
         {error, loop}
     end.
 
-malicious_from_binary_test() ->
-    CircularList = from_words([32, 1, 32]), %% Xs = 1 :: Xs
-    {ok, {error, circular_references}}   = ?SANDBOX(aeb_heap:from_binary({list, word}, CircularList)),
-    {ok, {error, {binary_too_short, _}}} = ?SANDBOX(aeb_heap:from_binary(word, <<1, 2, 3, 4>>)),
-    ok.
-
 from_words(Ws) ->
     << <<(from_word(W))/binary>> || W <- Ws >>.
 
@@ -37,23 +30,14 @@ from_word(S) when is_list(S) ->
     <<Len:256, Bin/binary>>.
 
 encode_decode_test() ->
-    encode_decode(word, 42),
-    42 = encode_decode(word, 42),
-    -1 = encode_decode(signed_word, -1),
-    <<"Hello world">> = encode_decode(string, <<"Hello world">>),
-    {} = encode_decode({tuple, []}, {}),
-    {42} = encode_decode({tuple, [word]}, {42}),
-    {42, 0} = encode_decode({tuple, [word, word]}, {42, 0}),
-    [] = encode_decode({list, word}, []),
-    [32] = encode_decode({list, word}, [32]),
-    none = encode_decode({option, word}, none),
-    {some, 1} = encode_decode({option, word}, {some, 1}),
-    string = encode_decode(typerep, string),
-    word = encode_decode(typerep, word),
-    {list, word} = encode_decode(typerep, {list, word}),
-    {tuple, [word]} = encode_decode(typerep, {tuple, [word]}),
-    1 = encode_decode(word, 1),
-    0 = encode_decode(word, 0),
+    Tests =
+        [42, 1, 0 -1, <<"Hello">>,
+         {tuple, {}}, {tuple, {42}}, {tuple, {21, 37}},
+         [], [42], [21, 37],
+         {variant, [0, 1], 0, {}}, {variant, [0, 1], 1, {42}}, {variant, [2], 0, {21, 37}},
+         {typerep, string}, {typerep, integer}, {typerep, {list, integer}}, {typerep, {tuple, [integer]}}
+        ],
+    [?assertEqual(Test, encode_decode(Test)) || Test <- Tests],
     ok.
 
 encode_decode_sophia_test() ->
@@ -62,7 +46,7 @@ encode_decode_sophia_test() ->
                                 Other -> Other
                               end end,
     ok = Check("int", "42"),
-    ok = Check("int", "-42"),
+    ok = Check("int", "- 42"),
     ok = Check("bool", "true"),
     ok = Check("bool", "false"),
     ok = Check("string", "\"Hello\""),
@@ -72,6 +56,70 @@ encode_decode_sophia_test() ->
     ok = Check("r", "{x = (\"foo\", 0), y = Red}"),
     ok.
 
+to_sophia_value_mcl_bls12_381_test() ->
+    Code = "include \"BLS12_381.aes\"\n"
+           "contract C =\n"
+           "  entrypoint test_bls12_381_fp(x : int) = BLS12_381.int_to_fp(x)\n"
+           "  entrypoint test_bls12_381_fr(x : int) = BLS12_381.int_to_fr(x)\n"
+           "  entrypoint test_bls12_381_g1(x : int) = BLS12_381.mk_g1(x, x, x)\n",
+
+    Opts = [{backend, fate}],
+
+    CallValue32 = aeb_fate_encoding:serialize({bytes, <<20:256>>}),
+    CallValue48 = aeb_fate_encoding:serialize({bytes, <<55:384>>}),
+    CallValueTp = aeb_fate_encoding:serialize({tuple, {{bytes, <<15:256>>}, {bytes, <<160:256>>}, {bytes, <<1234:256>>}}}),
+
+    {ok,     _} = aeso_compiler:to_sophia_value(Code, "test_bls12_381_fp", ok, CallValue32, Opts),
+    {error,  _} = aeso_compiler:to_sophia_value(Code, "test_bls12_381_fp", ok, CallValue48, Opts),
+    {ok,     _} = aeso_compiler:to_sophia_value(Code, "test_bls12_381_fr", ok, CallValue48, Opts),
+    {error,  _} = aeso_compiler:to_sophia_value(Code, "test_bls12_381_fr", ok, CallValue32, Opts),
+    {ok,     _} = aeso_compiler:to_sophia_value(Code, "test_bls12_381_g1", ok, CallValueTp, Opts),
+
+    ok.
+
+to_sophia_value_neg_test() ->
+    Code = [ "contract Foo =\n"
+             "  entrypoint f(x : int) : string = \"hello\"\n" ],
+
+    {error, [Err1]} = aeso_compiler:to_sophia_value(Code, "f", ok, encode(12)),
+    ?assertEqual("Data error:\nCannot translate FATE value 12\n  of Sophia type string\n", aeso_errors:pp(Err1)),
+
+    {error, [Err2]} = aeso_compiler:to_sophia_value(Code, "f", revert, encode(12)),
+    ?assertEqual("Data error:\nCould not deserialize the revert message\n", aeso_errors:pp(Err2)),
+    ok.
+
+encode_calldata_neg_test() ->
+    Code = [ "contract Foo =\n"
+             "  entrypoint f(x : int) : string = \"hello\"\n" ],
+
+    ExpErr1 = "Type error at line 5, col 34:\nCannot unify `int` and `bool`\n"
+              "when checking the application of\n"
+              "  `f : (int) => string`\n"
+              "to arguments\n"
+              "  `true : bool`\n",
+    {error, [Err1]} = aeso_compiler:create_calldata(Code, "f", ["true"]),
+    ?assertEqual(ExpErr1, aeso_errors:pp(Err1)),
+
+    ok.
+
+decode_calldata_neg_test() ->
+    Code1 = [ "contract Foo =\n"
+              "  entrypoint f(x : int) : string = \"hello\"\n" ],
+    Code2 = [ "contract Foo =\n"
+              "  entrypoint f(x : string) : int = 42\n" ],
+
+    {ok, CallDataFATE} = aeso_compiler:create_calldata(Code1, "f", ["42"]),
+
+    {error, [Err1]} = aeso_compiler:decode_calldata(Code2, "f", <<1,2,3>>),
+    ?assertEqual("Data error:\nFailed to decode calldata binary\n", aeso_errors:pp(Err1)),
+    {error, [Err2]} = aeso_compiler:decode_calldata(Code2, "f", CallDataFATE),
+    ?assertEqual("Data error:\nCannot translate FATE value \"*\"\n  to Sophia type (string)\n", aeso_errors:pp(Err2)),
+
+    {error, [Err3]} = aeso_compiler:decode_calldata(Code2, "x", CallDataFATE),
+    ?assertEqual("Data error at line 1, col 1:\nFunction 'x' is missing in contract\n", aeso_errors:pp(Err3)),
+    ok.
+
+
 encode_decode_sophia_string(SophiaType, String) ->
     io:format("String ~p~n", [String]),
     Code = [ "contract MakeCall =\n"
@@ -80,11 +128,10 @@ encode_decode_sophia_string(SophiaType, String) ->
            , "  record r = {x : an_alias(int), y : variant}\n"
            , "  datatype variant = Red | Blue(map(string, int))\n"
            , "  entrypoint foo : arg_type => arg_type\n" ],
-    case aeso_compiler:check_call(lists:flatten(Code), "foo", [String], []) of
-        {ok, _, {[Type], _}, [Arg]} ->
-            io:format("Type ~p~n", [Type]),
+    case aeso_compiler:check_call(lists:flatten(Code), "foo", [String], [no_code]) of
+        {ok, _, [Arg]} ->
             Data = encode(Arg),
-            case aeso_compiler:to_sophia_value(Code, "foo", ok, Data, []) of
+            case aeso_compiler:to_sophia_value(Code, "foo", ok, Data, [no_code]) of
                 {ok, Sophia} ->
                     lists:flatten(io_lib:format("~s", [prettypr:format(aeso_pretty:expr(Sophia))]));
                 {error, Err} ->
@@ -98,30 +145,32 @@ encode_decode_sophia_string(SophiaType, String) ->
 
 calldata_test() ->
     [42, <<"foobar">>] = encode_decode_calldata("foo", ["int", "string"], ["42", "\"foobar\""]),
-    Map = #{ <<"a">> => 4 },
-    [{variant, 1, [Map]}, {{<<"b">>, 5}, {variant, 0, []}}] =
+    [{variant, [0,1], 1, {#{ <<"a">> := 4 }}}, {tuple, {{tuple, {<<"b">>, 5}}, {variant, [0,1], 0, {}}}}] =
         encode_decode_calldata("foo", ["variant", "r"], ["Blue({[\"a\"] = 4})", "{x = (\"b\", 5), y = Red}"]),
-    [?DUMMY_HASH_WORD, 16#456] = encode_decode_calldata("foo", ["bytes(32)", "address"],
+    [{bytes, <<291:256>>}, {address, <<1110:256>>}] =
+        encode_decode_calldata("foo", ["bytes(32)", "address"],
                                [?DUMMY_HASH_LIT, "ak_1111111111111111111111111111113AFEFpt5"]),
-    [?DUMMY_HASH_WORD, ?DUMMY_HASH_WORD] =
+    [{bytes, <<291:256>>}, {bytes, <<291:256>>}] =
         encode_decode_calldata("foo", ["bytes(32)", "hash"], [?DUMMY_HASH_LIT, ?DUMMY_HASH_LIT]),
 
-    [119, {0, 0}] = encode_decode_calldata("foo", ["int", "signature"], ["119", [$# | lists:duplicate(128, $0)]]),
+    [119, {bytes, <<0:64/unit:8>>}] = encode_decode_calldata("foo", ["int", "signature"], ["119", [$# | lists:duplicate(128, $0)]]),
 
-    [16#456] = encode_decode_calldata("foo", ["Remote"], ["ct_1111111111111111111111111111113AFEFpt5"]),
+    [{contract, <<1110:256>>}] = encode_decode_calldata("foo", ["Remote"], ["ct_1111111111111111111111111111113AFEFpt5"]),
 
     ok.
 
 calldata_init_test() ->
-    encode_decode_calldata("init", ["int"], ["42"], {tuple, [typerep, word]}),
+    encode_decode_calldata("init", ["int"], ["42"]),
 
     Code = parameterized_contract("foo", ["int"]),
-    encode_decode_calldata_(Code, "init", [], {tuple, [typerep, {tuple, []}]}).
+    encode_decode_calldata_(Code, "init", []),
+
+    ok.
 
 calldata_indent_test() ->
     Test = fun(Extra) ->
             Code = parameterized_contract(Extra, "foo", ["int"]),
-            encode_decode_calldata_(Code, "foo", ["42"], word)
+            encode_decode_calldata_(Code, "foo", ["42"])
            end,
     Test("  stateful entrypoint bla() = ()"),
     Test("  type x = int"),
@@ -138,7 +187,7 @@ parameterized_contract(ExtraCode, FunName, Types) ->
     lists:flatten(
         ["contract Remote =\n"
          "  entrypoint bla : () => unit\n\n"
-         "contract Dummy =\n",
+         "main contract Dummy =\n",
          ExtraCode, "\n",
          "  type an_alias('a) = string * 'a\n"
          "  record r = {x : an_alias(int), y : variant}\n"
@@ -150,9 +199,9 @@ oracle_test() ->
         "contract OracleTest =\n"
         "  entrypoint question(o, q : oracle_query(list(string), option(int))) =\n"
         "    Oracle.get_question(o, q)\n",
-    {ok, _, {[word, word], {list, string}}, [16#123, 16#456]} =
+    ?assertEqual({ok, "question", [{oracle, <<291:256>>}, {oracle_query, <<1110:256>>}]},
                  aeso_compiler:check_call(Contract, "question", ["ok_111111111111111111111111111111ZrdqRz9",
-                                                        "oq_1111111111111111111111111111113AFEFpt5"], []),
+                                                                 "oq_1111111111111111111111111111113AFEFpt5"], [no_code])),
 
     ok.
 
@@ -161,40 +210,33 @@ permissive_literals_fail_test() ->
         "contract OracleTest =\n"
         "  stateful entrypoint haxx(o : oracle(list(string), option(int))) =\n"
         "    Chain.spend(o, 1000000)\n",
-        {error, <<"Type errors\nCannot unify", _/binary>>} =
+    {error, [Err]} =
         aeso_compiler:check_call(Contract, "haxx", ["#123"], []),
+    ?assertMatch("Type error at line 3, col 5:\nCannot unify" ++ _, aeso_errors:pp(Err)),
+    ?assertEqual(type_error, aeso_errors:type(Err)),
     ok.
 
 encode_decode_calldata(FunName, Types, Args) ->
-    encode_decode_calldata(FunName, Types, Args, word).
-
-encode_decode_calldata(FunName, Types, Args, RetType) ->
     Code = parameterized_contract(FunName, Types),
-    encode_decode_calldata_(Code, FunName, Args, RetType).
+    encode_decode_calldata_(Code, FunName, Args).
 
-encode_decode_calldata_(Code, FunName, Args, RetVMType) ->
+encode_decode_calldata_(Code, FunName, Args) ->
     {ok, Calldata} = aeso_compiler:create_calldata(Code, FunName, Args, []),
-    {ok, _, {ArgTypes, RetType}, _} = aeso_compiler:check_call(Code, FunName, Args, [{backend, aevm}]),
-    ?assertEqual(RetType, RetVMType),
-    CalldataType = {tuple, [word, {tuple, ArgTypes}]},
-    {ok, {_Hash, ArgTuple}} = aeb_heap:from_binary(CalldataType, Calldata),
+    {ok, _, _} = aeso_compiler:check_call(Code, FunName, Args, [no_code]),
     case FunName of
         "init" ->
-            ok;
+            [];
         _ ->
-            {ok, _ArgTypes, ValueASTs} = aeso_compiler:decode_calldata(Code, FunName, Calldata, []),
-            Values = [ prettypr:format(aeso_pretty:expr(V)) || V <- ValueASTs ],
-            ?assertMatch({X, X}, {Args, Values})
-    end,
-    tuple_to_list(ArgTuple).
+            {ok, FateArgs} = aeb_fate_abi:decode_calldata(FunName, Calldata),
+            FateArgs
+    end.
 
-encode_decode(T, D) ->
-    ?assertEqual(D, decode(T, encode(D))),
+encode_decode(D) ->
+    ?assertEqual(D, decode(encode(D))),
     D.
 
 encode(D) ->
-    aeb_heap:to_binary(D).
+    aeb_fate_encoding:serialize(D).
 
-decode(T,B) ->
-    {ok, D} = aeb_heap:from_binary(T, B),
-    D.
+decode(B) ->
+    aeb_fate_encoding:deserialize(B).

test/aeso_aci_tests.erl

@@ -11,7 +11,10 @@ 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)).
+    ?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).
 
 test_cases(1) ->
     Contract = <<"payable contract C =\n"
@@ -20,6 +23,7 @@ test_cases(1) ->
 		   #{name => <<"C">>,
 		     type_defs => [],
          payable => true,
+         kind => contract_main,
 		     functions =>
 			 [#{name => <<"a">>,
 			    arguments =>
@@ -28,16 +32,17 @@ test_cases(1) ->
 			    returns => <<"int">>,
 			    stateful => true,
                             payable  => true}]}},
-    DecACI = <<"payable contract C =\n"
-	       "  payable entrypoint a : (int) => int\n">>,
+    DecACI = <<"payable main contract C =\n"
+	       "  payable stateful entrypoint a : (int) => int\n">>,
     {Contract,MapACI,DecACI};
 
 test_cases(2) ->
-    Contract = <<"contract C =\n"
+    Contract = <<"main 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">>,
@@ -50,12 +55,12 @@ test_cases(2) ->
                             returns => <<"int">>,
                             stateful => false,
                             payable  => false}]}},
-    DecACI = <<"contract C =\n"
+    DecACI = <<"main contract C =\n"
                "  type allan = int\n"
                "  entrypoint a : (C.allan) => int\n">>,
     {Contract,MapACI,DecACI};
 test_cases(3) ->
-    Contract = <<"contract C =\n"
+    Contract = <<"main contract C =\n"
                  "  type state = unit\n"
                  "  datatype event = SingleEventDefined\n"
                  "  datatype bert('a) = Bin('a)\n"
@@ -68,7 +73,7 @@ test_cases(3) ->
                            #{<<"C.bert">> => [<<"string">>]}}],
                 name => <<"a">>,returns => <<"int">>,
                 stateful => false, payable  => false}],
-		     name => <<"C">>, payable => false,
+		     name => <<"C">>, payable => false, kind => contract_main,
          event => #{variant => [#{<<"SingleEventDefined">> => []}]},
          state => <<"unit">>,
 		     type_defs =>
@@ -77,14 +82,14 @@ test_cases(3) ->
                     #{variant =>
                           [#{<<"Bin">> => [<<"'a">>]}]},
                 vars => [#{name => <<"'a">>}]}]}},
-    DecACI = <<"contract C =\n"
+    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,MapACI,DecACI}.
 
-%% Rounttrip
+%% Roundtrip
 aci_test_() ->
     [{"Testing ACI generation for " ++ ContractName,
       fun() -> aci_test_contract(ContractName) end}
@@ -94,32 +99,43 @@ all_contracts() -> aeso_compiler_tests:compilable_contracts().
 
 aci_test_contract(Name) ->
     String = aeso_test_utils:read_contract(Name),
-    Opts   = [{include, {file_system, [aeso_test_utils:contract_path()]}}],
-    {ok, JSON} = aeso_aci:contract_interface(json, String, Opts),
-
+    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} | 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.
+            ok;
+        {error, ErrorString} when is_binary(ErrorString) -> error(ErrorString);
+        {error, Error} -> aeso_compiler_tests:print_and_throw(Error)
+    end.
 
 check_stub(Stub, Options) ->
-    case aeso_parser:string(binary_to_list(Stub), Options) of
-        {ok, Ast} ->
+    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 _:{type_errors, TE} ->
+            catch throw:{type_errors, TE} ->
                 io:format("Type error:\n~s\n", [TE]),
                 error(TE);
                   _:R ->
                 io:format("Error: ~p\n", [R]),
                 error(R)
-            end;
-        {error, E} ->
-            io:format("Error: ~p\n", [E]),
-            error({parse_error, E})
+            end
+    catch throw:{error, Errs} ->
+        _ = [ io:format("~s\n", [aeso_errors:pp(E)]) || E <- Errs ],
+        error({parse_errors, Errs})
     end.
-

test/aeso_calldata_tests.erl

@@ -19,21 +19,10 @@ calldata_test_() ->
      [ {"Testing " ++ ContractName ++ " contract calling " ++ Fun,
         fun() ->
            ContractString = aeso_test_utils:read_contract(ContractName),
-           AevmExprs =
-              case not lists:member(ContractName, not_yet_compilable(aevm)) of
-                  true -> ast_exprs(ContractString, Fun, Args, [{backend, aevm}]);
-                  false -> undefined
-              end,
-           FateExprs =
-              case not lists:member(ContractName, not_yet_compilable(fate)) of
-                  true -> ast_exprs(ContractString, Fun, Args, [{backend, fate}]);
-                  false -> undefined
-              end,
-           case FateExprs == undefined orelse AevmExprs == undefined of
-               true -> ok;
-               false ->
-                   ?assertEqual(FateExprs, AevmExprs)
-           end
+           FateExprs = ast_exprs(ContractString, Fun, Args),
+           ParsedExprs = parse_args(Fun, Args),
+           ?assertEqual(ParsedExprs, FateExprs),
+           ok
         end} || {ContractName, Fun, Args} <- compilable_contracts()].
 
 calldata_aci_test_() ->
@@ -43,29 +32,36 @@ calldata_aci_test_() ->
            {ok, ContractACIBin} = aeso_aci:contract_interface(string, ContractString),
            ContractACI = binary_to_list(ContractACIBin),
            io:format("ACI:\n~s\n", [ContractACIBin]),
-           AevmExprs =
-              case not lists:member(ContractName, not_yet_compilable(aevm)) of
-                  true -> ast_exprs(ContractACI, Fun, Args, [{backend, aevm}]);
-                  false -> undefined
-              end,
-           FateExprs =
-              case not lists:member(ContractName, not_yet_compilable(fate)) of
-                  true -> ast_exprs(ContractACI, Fun, Args, [{backend, fate}]);
-                  false -> undefined
-              end,
-           case FateExprs == undefined orelse AevmExprs == undefined of
-               true -> ok;
-               false ->
-                   ?assertEqual(FateExprs, AevmExprs)
-           end
+           FateExprs = ast_exprs(ContractACI, Fun, Args),
+           ParsedExprs = parse_args(Fun, Args),
+           ?assertEqual(ParsedExprs, FateExprs),
+           ok
         end} || {ContractName, Fun, Args} <- compilable_contracts()].
 
+parse_args(Fun, Args) ->
+    [{contract_main, _, _, [{letfun, _, _, _, _, [{guarded, _, [], {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) ->
+    ast_exprs(ContractString, Fun, Args, []).
 ast_exprs(ContractString, Fun, Args, Opts) ->
     {ok, Data} = (catch aeso_compiler:create_calldata(ContractString, Fun, Args, Opts)),
     {ok, _Types, Exprs} = (catch aeso_compiler:decode_calldata(ContractString, Fun, Data, Opts)),
     ?assert(is_list(Exprs)),
-    Exprs.
+    strip_ann(Exprs).
 
 check_errors(Expect, ErrorString) ->
     %% This removes the final single \n as well.
@@ -85,7 +81,9 @@ compilable_contracts() ->
      {"maps", "init", []},
      {"funargs", "menot", ["false"]},
      {"funargs", "append", ["[\"false\", \" is\", \" not\", \" true\"]"]},
-     %% TODO {"funargs", "bitsum", ["Bits.all"]},
+     {"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"
@@ -96,7 +94,28 @@ compilable_contracts() ->
      {"funargs", "traffic_light", ["Green"]},
      {"funargs", "traffic_light", ["Pantone(12)"]},
      {"funargs", "tuples", ["()"]},
-     %% TODO {"funargs", "due", ["FixedTTL(1020)"]},
+     {"funargs", "due", ["FixedTTL(1020)"]},
+     {"funargs", "singleton_rec", ["{x = 1000}"]},
+     {"funargs", "aens_name", ["AENS.Name(ak_2dATVcZ9KJU5a8hdsVtTv21pYiGWiPbmVcU1Pz72FFqpk9pSRR, RelativeTTL(100), {[\"pt1\"] = AENS.AccountPt(ak_2dATVcZ9KJU5a8hdsVtTv21pYiGWiPbmVcU1Pz72FFqpk9pSRR)})"]},
+     {"funargs", "aens_pointee", ["AENS.AccountPt(ak_2dATVcZ9KJU5a8hdsVtTv21pYiGWiPbmVcU1Pz72FFqpk9pSRR)"]},
+     {"funargs", "aens_pointee", ["AENS.OraclePt(ak_2dATVcZ9KJU5a8hdsVtTv21pYiGWiPbmVcU1Pz72FFqpk9pSRR)"]},
+     {"funargs", "aens_pointee", ["AENS.ContractPt(ak_2dATVcZ9KJU5a8hdsVtTv21pYiGWiPbmVcU1Pz72FFqpk9pSRR)"]},
+     {"funargs", "aens_pointee", ["AENS.ChannelPt(ak_2dATVcZ9KJU5a8hdsVtTv21pYiGWiPbmVcU1Pz72FFqpk9pSRR)"]},
+     {"funargs", "chain_ga_meta_tx", ["Chain.GAMetaTx(ak_2dATVcZ9KJU5a8hdsVtTv21pYiGWiPbmVcU1Pz72FFqpk9pSRR, 42)"]},
+     {"funargs", "chain_paying_for_tx", ["Chain.PayingForTx(ak_2dATVcZ9KJU5a8hdsVtTv21pYiGWiPbmVcU1Pz72FFqpk9pSRR, 42)"]},
+     {"funargs", "chain_base_tx", ["Chain.SpendTx(ak_2dATVcZ9KJU5a8hdsVtTv21pYiGWiPbmVcU1Pz72FFqpk9pSRR, 42,\"foo\")"]},
+     {"funargs", "chain_base_tx", ["Chain.ContractCreateTx(12234)"]},
+     {"funargs", "chain_base_tx", ["Chain.ContractCallTx(ak_2dATVcZ9KJU5a8hdsVtTv21pYiGWiPbmVcU1Pz72FFqpk9pSRR, 12234)"]},
+     {"funargs", "chain_base_tx", ["Chain.OracleRegisterTx"]},
+     {"funargs", "chain_base_tx", ["Chain.OracleQueryTx"]},
+     {"funargs", "chain_base_tx", ["Chain.OracleResponseTx"]},
+     {"funargs", "chain_base_tx", ["Chain.OracleExtendTx"]},
+     {"funargs", "chain_base_tx", ["Chain.NamePreclaimTx"]},
+     {"funargs", "chain_base_tx", ["Chain.NameClaimTx(\"acoolname.chain\")"]},
+     {"funargs", "chain_base_tx", ["Chain.NameUpdateTx(#ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)"]},
+     {"funargs", "chain_base_tx", ["Chain.NameRevokeTx(#ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)"]},
+     {"funargs", "chain_base_tx", ["Chain.NameTransferTx(ak_2dATVcZ9KJU5a8hdsVtTv21pYiGWiPbmVcU1Pz72FFqpk9pSRR, #ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)"]},
+     {"funargs", "chain_base_tx", ["Chain.GAAttachTx"]},
      {"variant_types", "init", []},
      {"basic_auth", "init", []},
      {"address_literals", "init", []},
@@ -122,8 +141,3 @@ compilable_contracts() ->
      {"stub", "foo", ["-42"]},
      {"payable", "foo", ["42"]}
     ].
-
-not_yet_compilable(fate) ->
-    [];
-not_yet_compilable(aevm) ->
-    [].

test/aeso_parser_tests.erl

@@ -4,18 +4,20 @@
 
 -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 = "contract Identity =\n"
+            Text = "main contract Identity =\n"
                    "  function id(x) = x\n",
             ?assertMatch(
-                [{contract, _, {con, _, "Identity"},
-                    [{letfun, _, {id, _, "id"}, [{arg, _, {id, _, "x"}, {id, _, "_"}}], {id, _, "_"},
-                        {id, _, "x"}}]}], parse_string(Text)),
+                [{contract_main, _, {con, _, "Identity"},
+                    [{letfun, _, {id, _, "id"}, [{id, _, "x"}], {id, _, "_"},
+                        [{guarded, _, [], {id, _, "x"}}]}]}], parse_string(Text)),
             ok
        end},
       {"Operator precedence test.",
@@ -30,7 +32,7 @@ simple_contracts_test_() ->
                     end,
             Parse = fun(S) ->
                     try remove_line_numbers(parse_expr(S))
-                    catch _:_ -> ?assertMatch(ok, {parse_fail, S}) end
+                    catch _:_ -> ?assertMatch(ok, id({parse_fail, S})) end
                 end,
             CheckParens = fun(Expr) ->
                     ?assertEqual(Parse(NoPar(Expr)), Parse(Par(Expr)))
@@ -38,8 +40,7 @@ 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) ->
-                            OpAtom = list_to_atom(Op),
-                            ?assertError({error, {_, parse_error, _}},
+                            ?assertThrow({error, [_]},
                                          parse_expr(NoPar({a, Op, {b, Op, c}}))) end,
             Stronger = fun(Op1, Op2) ->
                     CheckParens({{a, Op1, b}, Op2, c}),
@@ -62,7 +63,8 @@ simple_contracts_test_() ->
      %% Parse tests of example contracts
      [ {lists:concat(["Parse the ", Contract, " contract."]),
         fun() -> roundtrip_contract(Contract) end}
-        || Contract <- [counter, voting, all_syntax, '05_greeter', aeproof, multi_sig, simple_storage, fundme, dutch_auction] ]
+        || Contract <- [counter, voting, all_syntax, '05_greeter', aeproof,
+                        multi_sig, simple_storage, fundme, dutch_auction, utf8] ]
     }.
 
 parse_contract(Name) ->
@@ -74,20 +76,17 @@ roundtrip_contract(Name) ->
 parse_string(Text) -> parse_string(Text, []).
 
 parse_string(Text, Opts) ->
-    case aeso_parser:string(Text, Opts) of
-        {ok, Contract} -> Contract;
-        Err -> error(Err)
-    end.
+    aeso_parser:string(Text, Opts).
 
 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(Text1),
+    Contract1 = parse_string(aeso_scan:utf8_encode(Text1)),
     NoSrcLoc  = remove_line_numbers(Contract),
     NoSrcLoc1 = remove_line_numbers(Contract1),
     ?assertMatch(NoSrcLoc, diff(NoSrcLoc, NoSrcLoc1)).

test/contracts/05_greeter.aes

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

test/contracts/Makefile

@@ -1,15 +0,0 @@
-
-## Requires ocaml >= 4.02, < 4.06
-## and reason-3.0.0 (opam install reason).
-
-default : voting_test
-
-%.ml : %.re
-	refmt -p ml $< > $@
-
-
-voting_test : rte.ml voting.ml voting_test.ml
-	ocamlopt -o $@ $^
-
-clean :
-	rm -f *.cmi *.cmx *.ml *.o voting_test

test/contracts/__call.aes

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

test/contracts/abort_test.aes

@@ -1,31 +0,0 @@
-// A simple test of the abort built-in function.
-
-contract AbortTest =
-
-  record state = { value : int }
-
-  public function init(v : int) =
-    { value = v }
-
-  // Aborting
-  public function do_abort(v : int, s : string) : unit =
-    put_value(v)
-    revert_abort(s)
-
-  // Accessing the value
-  public function get_value() = state.value
-  public function put_value(v : int) = put(state{value = v})
-  public function get_values() : list(int) = [state.value]
-  public function put_values(v : int) = put(state{value = v})
-
-  // Some basic statistics
-  public function get_stats(acct : address) =
-    ( Contract.balance, Chain.balance(acct) )
-
-  // Abort functions.
-  private function revert_abort(s : string) =
-    abort(s)
-
-  // This is still legal but will be stripped out.
-  // TODO: This function confuses the type inference, so it cannot be present.
-  //private function abort(s : string) = 42

test/contracts/abort_test_int.aes

@@ -1,27 +0,0 @@
-contract Interface =
-  function do_abort : (int, string) => unit
-  function get_value : () => int
-  function put_value : (int) => unit
-  function get_values : () => list(int)
-  function put_values : (int) => unit
-
-contract AbortTestInt =
-
-  record state = {r : Interface, value : int}
-
-  public function init(r : Interface, value : int) =
-    {r = r, value = value}
-
-  // Aborting
-  public function do_abort(v : int, s : string) =
-    put_value(v)
-    state.r.do_abort(v + 100, s)
-
-  // Accessing the value
-  public function put_value(v : int) = put(state{value = v})
-  public function get_value() = state.value
-  public function get_values() : list(int) =
-    state.value :: state.r.get_values()
-  public function put_values(v : int) =
-    put_value(v)
-    state.r.put_values(v + 1000)

test/contracts/address_chain.aes

@@ -1,5 +1,5 @@
-contract Remote =
-  entrypoint main : (int) => unit
+contract interface Remote =
+  entrypoint main_fun : (int) => unit
 
 contract AddrChain =
   type o_type = oracle(string, map(string, int))

test/contracts/address_literals.aes

@@ -1,5 +1,5 @@
 
-contract Remote =
+contract interface Remote =
   entrypoint foo : () => unit
 
 contract AddressLiterals =
@@ -11,4 +11,6 @@ contract AddressLiterals =
     oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY
   entrypoint contr() : Remote =
     ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ
+  entrypoint contr_addr() : Remote =
+    Address.to_contract(addr())
 

test/contracts/aens.aes

@@ -22,16 +22,33 @@ contract AENSTest =
 
   stateful entrypoint claim(addr : address,
                           name : string,
-                          salt : int) : unit =
-    AENS.claim(addr, name, salt)
+                          salt : int,
+                          name_fee : int) : unit =
+    AENS.claim(addr, name, salt, name_fee)
 
   stateful entrypoint signedClaim(addr : address,
                                 name : string,
                                 salt : int,
+                                name_fee : int,
                                 sign : signature) : unit =
-    AENS.claim(addr, name, salt, signature = sign)
+    AENS.claim(addr, name, salt, name_fee, signature = sign)
+
+
+  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)
+
+  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)
 
-  // TODO: update() -- how to handle pointers?
 
   stateful entrypoint transfer(owner     : address,
                              new_owner : address,
@@ -52,4 +69,3 @@ contract AENSTest =
                                    name      : string,
                                    sign      : signature) : unit =
     AENS.revoke(owner, name, signature = sign)
-

test/contracts/aens_update.aes

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

@@ -1,44 +1,82 @@
 // 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
     */
-  function foo : _
+  stateful function foo : _
+  entrypoint bar : int => (int * 'a)
+
 
 contract AllSyntax =
 
-  type typeDecl = int
-  type paramTypeDecl('a, 'b) = (('a, 'b) => 'b) => list('a) => 'b => 'b
+  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)
 
-  record nestedRecord = { x : int }
-  record recordType = { z : nestedRecord, y : int }
-  datatype variantType('a) = None | Some('a)
+  type state = shakespeare(int)
 
-  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)
+  entrypoint init() = {
+    johann = 1000,
+    wolfgang = -10,
 
-  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 :: _) => ()
+/* 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 = () }
 
-  let hash : address = #01ab0fff11
-  let b = false
-  let qcon = Mod.Con
-  let str = "blabla\nfoo"
-  let chr = '"'
+  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)
 
+     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 sh : shakespeare(shakespeare(int)) =
+       {wolfgang = state}
+     sh{wolfgang.wolfgang = sh.wolfgang} // comment

test/contracts/ambiguous_main.aes

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

test/contracts/assign_pattern_to_pattern.aes

@@ -0,0 +1,4 @@
+contract AssignPatternToPattern =
+    entrypoint f() =
+        let x::(t::z = y) = [1, 2, 3]
+        (x + t)::y

test/contracts/assign_patterns.aes

@@ -0,0 +1,16 @@
+include "List.aes"
+
+contract AssignPatterns =
+
+  entrypoint test() = foo([1, 0, 2], (2, Some(3)), Some([4, 5]))
+
+  entrypoint foo(xs : list(int), p : int * option(int), some : option(list(int))) =
+    let x::(t = y::_)  = xs
+    let z::_ = t
+
+    let (a, (o = Some(b)))  = p
+
+    let Some((f = g::_)) = some
+    g + List.get(1, f)
+
+    x + y + z + a + b

test/contracts/bad_address_literals.aes

@@ -1,5 +1,5 @@
 
-contract Remote =
+contract interface Remote =
   entrypoint foo : () => unit
 
 contract AddressLiterals =
@@ -30,4 +30,6 @@ contract AddressLiterals =
     ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ
   entrypoint contr3() : bytes(32) =
     ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ
+  entrypoint contr4() : address =
+    Address.to_contract(Contract.address)
 

test/contracts/bad_arity.aes

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

test/contracts/bad_bytes_concat.aes

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

test/contracts/bad_bytes_split.aes

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

test/contracts/bad_function_block.aes

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

test/contracts/bad_number_of_args.aes

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

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

test/contracts/bad_records.aes

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

test/contracts/bad_state.aes

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

test/contracts/bad_top_level_decl.aes

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

test/contracts/bad_unnamed_map_update_default.aes

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

test/contracts/basic_auth.aes

@@ -15,3 +15,5 @@ contract BasicAuth =
   entrypoint to_sign(h : hash, n : int) =
     Crypto.blake2b((h, n))
 
+  entrypoint weird_string() : string =
+    "\x19Weird String\x42\nMore\n"

test/contracts/basic_auth_tx.aes

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

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

test/contracts/bytes_to_x.aes

@@ -1,4 +1,4 @@
-
+include "String.aes"
 contract BytesToX =
 
   entrypoint to_int(b : bytes(42)) : int = Bytes.to_int(b)

test/contracts/calling_init_function.aes

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

test/contracts/channel_env.aes

@@ -1,8 +0,0 @@
-contract ChannelEnv =
-  public function coinbase() : address = Chain.coinbase
-
-  public function timestamp() : int = Chain.timestamp
-
-  public function block_height() : int = Chain.block_height
-
-  public function difficulty() : int = Chain.difficulty

test/contracts/channel_on_chain_contract_name_resolution.aes

@@ -1,7 +0,0 @@
-contract ChannelOnChainContractNameResolution =
-
-  public function can_resolve(name: string, key: string) : bool =
-    switch(AENS.resolve(name, key) : option(string))
-      None           => false
-      Some(_address) => true
-

test/contracts/channel_on_chain_contract_oracle.aes

@@ -1,48 +0,0 @@
-contract ChannelOnChainContractOracle =
-
-  type query_t  = string
-  type answer_t = string
-  type oracle_id = oracle(query_t, answer_t)
-  type query_id = oracle_query(query_t, answer_t)
-
-  record state = { oracle        : oracle_id,
-                   question      : string,
-                   bets          : map(string, address)
-                   }
-
-
-  public function init(oracle: oracle_id, question: string) : state =
-    { oracle   = oracle,
-      question = question,
-      bets     = {}
-      }
-
-  public stateful function place_bet(answer: string) = 
-    switch(Map.lookup(answer, state.bets))
-      None =>
-        put(state{ bets = state.bets{[answer] = Call.caller}})
-        "ok"
-      Some(_value) =>
-        "bet_already_taken"
-
-  public function query_fee() =
-    Oracle.query_fee(state.oracle)
-
-  public function get_question(q: query_id) =
-    Oracle.get_question(state.oracle, q)
-
-  public stateful function resolve(q: query_id) =
-    switch(Oracle.get_answer(state.oracle, q))
-      None         =>
-        "no response"
-      Some(result) => 
-        if(state.question == Oracle.get_question(state.oracle, q))
-            switch(Map.lookup(result, state.bets))
-              None         =>
-                "no winning bet"
-              Some(winner) =>
-                Chain.spend(winner, Contract.balance)
-                "ok"
-        else
-          "different question"
-

test/contracts/channel_remote_on_chain_contract_name_resolution.aes

@@ -1,9 +0,0 @@
-contract Remote =
-  function get : () => int
-  function can_resolve : (string, string) => bool
-
-contract RemoteCall =
-
-    function remote_resolve(r : Remote, name: string, key: string) : bool =
-        r.can_resolve(name, key)
-

test/contracts/chess.aes

@@ -1,51 +0,0 @@
-
-contract Chess =
-
-  type board = map(int, map(int, string))
-  type state = board
-
-  private function get_row(r, m : board) =
-    Map.lookup_default(r, m, {})
-
-  private function set_piece(r, c, p, m : board) =
-    m { [r] = get_row(r, m) { [c] = p } }
-
-  private function get_piece(r, c, m : board) =
-    Map.lookup(c, get_row(r, m))
-
-  private function from_list(xs, m : board) =
-    switch(xs)
-      []              => m
-      (r, c, p) :: xs => from_list(xs, set_piece(r, c, p, m))
-
-  function init() =
-    from_list([ (2, 1, "white pawn"),   (7, 1, "black pawn")
-              , (2, 2, "white pawn"),   (7, 2, "black pawn")
-              , (2, 3, "white pawn"),   (7, 3, "black pawn")
-              , (2, 4, "white pawn"),   (7, 4, "black pawn")
-              , (2, 5, "white pawn"),   (7, 5, "black pawn")
-              , (2, 6, "white pawn"),   (7, 6, "black pawn")
-              , (2, 7, "white pawn"),   (7, 7, "black pawn")
-              , (2, 8, "white pawn"),   (7, 8, "black pawn")
-              , (1, 1, "white rook"),   (8, 1, "black rook")
-              , (1, 2, "white knight"), (8, 2, "black knight")
-              , (1, 3, "white bishop"), (8, 3, "black bishop")
-              , (1, 4, "white queen"),  (8, 4, "black queen")
-              , (1, 5, "white king"),   (8, 5, "black king")
-              , (1, 6, "white bishop"), (8, 6, "black bishop")
-              , (1, 7, "white knight"), (8, 7, "black knight")
-              , (1, 8, "white rook"),   (8, 8, "black rook")
-              ], {})
-
-  function piece(r, c) = get_piece(r, c, state)
-
-  function move_piece(r, c, r1, c1) =
-    switch(piece(r, c))
-      Some(p) => put(set_piece(r1, c1, p, state))
-
-  function destroy_piece(r, c) =
-    put(state{ [r] = Map.delete(c, get_row(r, state)) })
-
-  function delete_row(r) =
-    put(Map.delete(r, state))
-

test/contracts/child_contract_init_bug.aes

@@ -0,0 +1,8 @@
+contract Identity =
+  record state = {foo: int, bar: string}
+  entrypoint init() = {foo = 0, bar = ""}
+
+main contract IdentityService =
+  stateful entrypoint createNewIdentity() : Identity =
+    put(())
+    Chain.create()

test/contracts/clone.aes

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

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

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

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