[Ceres] Add Chain.network_id (#468)

* Add Chain.network_id

* Bump aebytecode version

.circleci/config.yml

@@ -3,7 +3,7 @@ version: 2.1
 executors:
   aebuilder:
     docker:
-      - image: aeternity/builder
+      - image: aeternity/builder:bionic-otp24
         user: builder
     working_directory: ~/aesophia
 

.github/workflows/docs-develop.yml

@@ -13,11 +13,7 @@ jobs:
       - 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
+      - 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: |

.github/workflows/docs-release.yml

@@ -13,11 +13,7 @@ jobs:
       - 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
+      - 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

.github/workflows/requirements.txt

@@ -1,4 +1,5 @@
-mkdocs==1.2.3
-mkdocs-simple-hooks==0.1.3
-mkdocs-material==7.1.9
-mike==1.0.1
+mkdocs==1.4.2
+mkdocs-simple-hooks==0.1.5
+mkdocs-material==9.0.9
+mike==1.1.2
+pygments==2.14.0

CHANGELOG.md

@@ -4,10 +4,100 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [CERES 8.0.0]
+### Added
+- Bitwise operations for integers: `band`, `bor`, `bxor`, `bnot`, `<<` and `>>`.
+- `Int.mulmod` - combined builtin operation for multiplication and modulus.
+- `Crypto.poseidon` - a ZK/SNARK-friendly hash function (over the BLS12-381 scalar field).
+- `Address.to_bytes` - convert an address to its binary representation (for hashing, etc.).
+- Raw data pointers added to AENS. In short we have introduced a new namespace
+  `AENSv2`; they contain types similar to the old `AENS`; `AENS.name` and
+  `AENS.pointee`, where the latter now has a constructor `DataPt(string)`. All
+  AENS actions have been moved to `AENSv2`, and `AENSv2.lookup` and
+  `AENSv2.update` consume and produce the new types. The old `AENS` namespace
+  only contains the old datatypes, that can be used to interface existing
+  contracts. Standard library `AENSCompat` is added to convert between old and
+  new pointers.
+- Introduce arbitrary sized binary arrays (type `bytes()`); adding `Bytes.split_any`,
+  `Bytes.to_fixed_size`, `Bytes.to_any_size`, `Bytes.size`, `String.to_bytes`,
+  and `Int.to_bytes`; and adjust `Bytes.concat` to allow both fixed and arbitrary
+  sized byte arrays.
+- `Chain.network_id` - a function to get hold of the Chain's network id.
+### Changed
+### Removed
+- `Bitwise.aes` standard library is removed - the builtin operations are superior.
+
 ## [Unreleased]
 ### Added
 ### Changed
 ### Removed
+### Fixed
+
+## [7.2.1]
+### Fixed
+- Fixed bugs with the newly added debugging symbols
+
+## [7.2.0]
+### Added
+- Toplevel compile-time constants
+  ```
+  namespace N =
+    let nc = 1
+  contract C =
+    let cc = 2
+  ```
+- API functions for encoding/decoding Sophia values to/from FATE.
+### Removed
+- Remove the mapping from variables to FATE registers from the compilation output.
+### Fixed
+- Warning about unused include when there is no include.
+
+## [7.1.0]
+### Added
+- Options to enable/disable certain optimizations.
+- The ability to call a different instance of the current contract
+  ```
+  contract Main =
+    entrypoint spend(x : int) : int = x
+    entrypoint f(c : Main) : int = c.spend(10)
+  ```
+- Return a mapping from variables to FATE registers in the compilation output.
+- Hole expression.
+### Changed
+- Type definitions serialised to ACI as `typedefs` field instead of `type_defs` to increase compatibility.
+- Check contracts and entrypoints modifiers when implementing interfaces.
+- Contracts can no longer be used as namespaces.
+- Do not show unused stateful warning for functions that call other contracts with a non-zero value argument.
+### Fixed
+- Typechecker crashes if Chain.create or Chain.clone are used without arguments.
+
+## [7.0.1]
+### Added
+- Add CONTRIBUTING.md file.
+### Changed
+- Update Sophia syntax docs to include missing information about existing syntax.
+### Fixed
+- [404](https://github.com/aeternity/aesophia/issues/404) Contract polymorphism crashes on non-obvious child contract typing.
+
+## [7.0.0]
+### Added
+- Added support for `EXIT` opcode via `exit : (string) => 'a` function (behaves same as `ABORT`, but consumes all gas).
+- Compiler warnings for the following: 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)
+  ```
+- Contract interfaces polymorphism
+### 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
@@ -332,7 +422,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Simplify calldata creation - instead of passing a compiled contract, simply
   pass a (stubbed) contract string.
 
-[Unreleased]: https://github.com/aeternity/aesophia/compare/v6.1.0...HEAD
+[Unreleased]: https://github.com/aeternity/aesophia/compare/v7.2.1...HEAD
+[7.2.1]: https://github.com/aeternity/aesophia/compare/v7.2.0...v7.2.1
+[7.2.0]: https://github.com/aeternity/aesophia/compare/v7.1.0...v7.2.0
+[7.1.0]: https://github.com/aeternity/aesophia/compare/v7.0.1...v7.1.0
+[7.0.1]: https://github.com/aeternity/aesophia/compare/v7.0.0...v7.0.1
+[7.0.0]: https://github.com/aeternity/aesophia/compare/v6.1.0...v7.0.0
 [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

CONTRIBUTING.md

@@ -0,0 +1,40 @@
+# Contributing to Sophia
+
+## Checklist For Creating New Pull Requests
+
+The following points should be considered before creating a new PR to the Sophia compiler.
+
+### Documentation
+
+- The [Changelog](CHANGELOG.md) file should be updated for all PRs.
+- If a PR introduces a new feature that is relevant to the users of the language, the [Sophia Features Documentation](docs/sophia_features.md) should be updated to describe the new feature.
+- If a PR introduces new syntax (e.g. changes in [aeso_syntax.erl](src/aeso_syntax.erl), [aeso_scan.erl](src/aeso_scan.erl), or [aeso_parser.erl](src/aeso_parser.erl)), the [Sophia Syntax Documentation](docs/sophia_syntax.md) should be updated to include the new syntax.
+- If a PR introduces a new library, the public interface of the new library should be fully documented in the [Sophia Standard Library Documentation](docs/sophia_stdlib.md).
+- If a PR introduces a new compiler option, the new option should be documented in the file
+[aeso_compiler.md](docs/aeso_compiler.md).
+
+### Tests
+
+- If a PR introduces new syntax (e.g. changes in [aeso_syntax.erl](src/aeso_syntax.erl), [aeso_scan.erl](src/aeso_scan.erl), or [aeso_parser.erl](src/aeso_parser.erl)), the contract [all_syntax.aes](test/contracts/all_syntax.aes) should be updated to include the new syntax.
+- If a PR fixes a bug, the code that replicates the bug should be added as a new passing test contract.
+- If a PR introduces a new feature, add tests for both successful and failing usage of that feature. In order to run the entire compilation pipeline and to avoid erroring during intermediate steps, failing tests should not be mixed with the successful ones.
+
+### Source Code
+
+- If a PR introduces new syntax (e.g. changes in [aeso_syntax.erl](src/aeso_syntax.erl), [aeso_scan.erl](src/aeso_scan.erl), or [aeso_parser.erl](src/aeso_parser.erl)), the following code should be updated to handle the new syntax:
+    - The function `aeso_syntax_utils:fold/4` in the file [aeso_syntax_utils.erl](src/aeso_syntax_utils.erl).
+    - Any related pretty printing function in the file [aeso_pretty.erl](src/aeso_pretty.erl), depending on the type of the newly added syntax.
+
+## Checklist For Creating a Release
+
+- Update the version in the file [aesophia.app.src](src/aesophia.app.src).
+- Update the version in the file [rebar.config](rebar.config).
+- In the [Changelog](CHANGELOG.md):
+    - Update the `Unreleased` changes to be under the new version.
+    - Update the version at the bottom of the file.
+- Commit and the changes and create a new PR (check the commit of [v6.1.0](https://github.com/aeternity/aesophia/commit/5ad5270e381f6e810d7b8b5cdc168d283e7a90bb) for reference).
+- Create a release after merging the new PR to `master` branch.
+- After releasing `aesophia`, refer to each of the following repositories and create new releases as well, using the new `aesophia` release:
+    - [aesophia_cli](https://github.com/aeternity/aesophia_cli)
+    - [aesophia_http](https://github.com/aeternity/aesophia_http)
+    - [aerepl](https://github.com/aeternity/aerepl)

README.md

@@ -14,6 +14,7 @@ The compiler is currently being used three places
 * [Features](docs/sophia_features.md)
 * [Standard library](docs/sophia_stdlib.md)
 * [Contract examples](docs/sophia_examples.md)
+* [Contributing](CONTRIBUTING.md)
 
 Additionally you can check out the [contracts section](https://github.com/aeternity/protocol/blob/master/contracts/contracts.md) of the æternity blockchain specification.
 

docs/aeso_aci.md

@@ -67,7 +67,7 @@ generates the following JSON structure representing the contract interface:
         }
       ]
     },
-    "type_defs": [
+    "typedefs": [
       {
         "name": "answers",
         "typedef": {
@@ -138,7 +138,7 @@ be included inside another contract.
              state =>
                  #{record =>
                        [#{name => <<"a">>,type => <<"Answers.answers">>}]},
-             type_defs =>
+             typedefs =>
                  [#{name => <<"answers">>,
                     typedef => #{<<"map">> => [<<"string">>,<<"int">>]},
                     vars => []}]}}]}

docs/aeso_compiler.md

@@ -49,11 +49,35 @@ 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
+The option `include_child_contract_symbols` includes the symbols of child contracts functions in the generated fate code. It is turned off by default to avoid making contracts bigger on chain.
+
+#### Options to control which compiler optimizations should run:
+
+By default all optimizations are turned on, to disable an optimization, it should be
+explicitly set to false and passed as a compiler option.
+
+List of optimizations:
+
+- optimize_inliner
+- optimize_inline_local_functions
+- optimize_bind_subexpressions
+- optimize_let_floating
+- optimize_simplifier
+- optimize_drop_unused_lets
+- optimize_push_consume
+- optimize_one_shot_var
+- optimize_write_to_dead_var
+- optimize_inline_switch_target
+- optimize_swap_push
+- optimize_swap_pop
+- optimize_swap_write
+- optimize_constant_propagation
+- optimize_prune_impossible_branches
+- optimize_single_successful_branch
+- optimize_inline_store
+- optimize_float_switch_bod
 
 #### check_call(ContractString, Options) -> CheckRet
 
@@ -66,15 +90,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/sophia_features.md

@@ -99,6 +99,9 @@ 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
 
@@ -131,6 +134,166 @@ main contract IntHolderFactory =
 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.
 
+### Contract interfaces and polymorphism
+
+Contracts can implement one or multiple interfaces, the contract has to define
+every entrypoint from the implemented interface and the entrypoints in both
+the contract and implemented interface should have compatible types.
+
+```
+contract interface Animal =
+  entrypoint sound : () => string
+
+ contract Cat : Animal =
+  entrypoint sound() = "Cat sound"
+```
+
+Contract interfaces can extend other interfaces. An extended interface has to
+declare all entrypoints from every parent interface. All the declarations in the extended
+interface must have types compatible with the declarations from the parent
+interface.
+
+```
+contract interface II =
+  entrypoint f : () => unit
+
+contract interface I : II =
+  entrypoint f : () => unit
+  entrypoint g : () => unit
+
+contract C : I =
+  entrypoint f() = ()
+  entrypoint g() = ()
+```
+
+It is only possible to implement (or extend) an interface that has been already
+defined earlier in the file (or in an included file). Therefore recursive
+interface implementation is not allowed in Sophia.
+
+```
+// The following code would show an error
+
+contract interface X : Z =
+     entrypoint x : () => int
+
+ contract interface Y : X =
+     entrypoint x : () => int
+     entrypoint y : () => int
+
+ contract interface Z : Y =
+     entrypoint x : () => int
+     entrypoint y : () => int
+     entrypoint z : () => int
+
+ contract C : Z =
+     entrypoint x() = 1
+     entrypoint y() = 1
+     entrypoint z() = 1
+```
+
+#### Adding or removing modifiers
+
+When a `contract` or a `contract interface` implements another `contract interface`, the `payable` and `stateful` modifiers can be kept or changed, both in the contract and in the entrypoints, according to the following rules:
+
+1. A `payable` contract or interface can implement a `payable` interface or a non-`payable` interface.
+2. A non-`payable` contract or interface can only implement a non-`payable` interface, and cannot implement a `payable` interface.
+3. A `payable` entrypoint can implement a `payable` entrypoint or a non-`payable` entrypoint.
+4. A non-`payable` entrypoint can only implement a non-`payable` entrypoint, and cannot implement a `payable` entrypoint.
+5. A non-`stateful` entrypoint can implement a `stateful` entrypoint or a non-`stateful` entrypoint.
+6. A `stateful` entrypoint can only implement a `stateful` entrypoint, and cannot implement a non-`stateful` entrypoint.
+
+#### Subtyping and variance
+
+Subtyping in Sophia follows common rules that take type variance into account. As described by [Wikipedia](https://en.wikipedia.org/wiki/Covariance_and_contravariance_(computer_science)), 
+
+>Variance refers to how subtyping between more complex types relates to subtyping between their components.
+
+This concept plays an important role in complex types such as tuples, `datatype`s and functions. Depending on the context, it can apply to positions in the structure of a type, or type parameters of generic types. There are four kinds of variances:
+
+- covariant
+- contravariant
+- invariant
+- bivariant
+
+A type is said to be on a "covariant" position when it describes output or a result of some computation. Analogously, position is "contravariant" when it is an input, or a parameter. Intuitively, when a part of the type is produced by values of it, it is covariant. When it is consumed, it is contravariant. When a type appears to be simultaneously input and output, it is described as invariant. If a type is neither of those (that is, it's unused) it's bivariant. Furthermore, whenever a complex type appears on a contravariant position, all its covariant components become contravariant and vice versa.
+
+Variance influences how subtyping is applied. Types on covariant positions are subtyped normally, while contravariant the opposite way. Invariant types have to be exactly the same in order for subtyping to work. Bivariant types are always compatible.
+
+A good example of where it matters can be pictured by subtyping of function types. Let us assume there is a contract interface `Animal` and two contracts that implement it: `Dog` and `Cat`.
+
+```sophia
+contract interface Animal =
+  entrypoint age : () => int
+  
+contract Dog : Animal =
+  entrypoint age() = // ...
+  entrypoint woof() = "woof"
+  
+contract Cat : Animal =
+  entrypoint age() = // ...
+  entrypoint meow() = "meow"
+```
+
+The assumption of this exercise is that cats do not bark (because `Cat` does not define the `woof` entrypoint). If subtyping rules were applied naively, that is if we let `Dog => Dog` be a subtype of `Animal => Animal`, the following code would break:
+
+```sophia
+let f : (Dog) => string  = d => d.woof()
+let g : (Animal) => string  = f
+let c : Cat = Chain.create()
+g(c)  // Cat barking!
+```
+
+That is because arguments of functions are contravariant, as opposed to return the type which is covariant. Because of that, the assignment of `f` to `g` is invalid - while `Dog` is a subtype of `Animal`, `Dog => string` is **not** a subtype of `Animal => string`. However, `Animal => string` **is** a subtype of `Dog => string`. More than that, `(Dog => Animal) => Dog` is a subtype of `(Animal => Dog) => Animal`.
+
+This has consequences on how user-defined generic types work. A type variable gains its variance from its role in the type definition as shown in the example:
+
+```sophia
+datatype co('a) = Co('a) // co is covariant on 'a
+datatype ct('a) = Ct('a => unit) // ct is contravariant on 'a
+datatype in('a) = In('a => 'a) // in is invariant on 'a
+datatype bi('a) = Bi // bi is bivariant on 'a
+```
+
+The following facts apply here:
+
+- `co('a)` is a subtype of `co('b)` when `'a` is a subtype of `'b`
+- `ct('a)` is a subtype of `ct('b)` when `'b` is a subtype of `'a`
+- `in('a)` is a subtype of `in('b)` when `'a` is equal to `'b`
+- `bi('a)` is a subtype of `bi('b)` always
+
+That altogether induce the following rules of subtyping in Sophia:
+
+- A function type `(Args1) => Ret1` is a subtype of `(Args2) => Ret2` when `Ret1`
+is a subtype of `Ret2` and each argument type from `Args2` is a subtype of its
+counterpart in `Args1`.
+
+- A list type `list(A)` is a subtype of `list(B)` if `A` is a subtype of `B`.
+
+- An option type `option(A)` is a subtype of `option(B)` if `A` is a subtype of `B`.
+
+- A map type `map(A1, A2)` is a subtype of `map(B1, B2)` if `A1` is a subtype
+of `B1`, and `A2` is a subtype of `B2`.
+
+- An oracle type `oracle(A1, A2)` is a subtype of `oracle(B1, B2)` if `B1` is
+a subtype of `A1`, and `A2` is a subtype of `B2`.
+
+- An oracle_query type `oracle_query(A1, A2)` is a subtype of `oracle_query(B1, B2)`
+if `A1` is a subtype of `B1`, and `A2` is a subtype of `B2`.
+
+- A user-defined datatype `t(Args1)` is a subtype of `t(Args2)`
+
+- When a user-defined type `t('a)` is covariant in `'a`, then `t(A)` is a
+subtype of `t(B)` when `A` is a subtype of `B`.
+
+- When a user-defined type `t('a)` is contravariant in `'a`, then `t(A)` is a
+subtype of `t(B)` when `B` is a subtype of `A`.
+
+- When a user-defined type `t('a)` is binvariant in `'a`, then `t(A)` is a
+subtype of `t(B)` when either `A` is a subtype of `B` or when `B` is a subtype
+of `A`.
+
+- When a user-defined type `t('a)` is invariant in `'a`, then `t(A)` can never be
+a subtype of `t(B)`.
 
 ## Mutable state
 
@@ -222,9 +385,6 @@ payable stateful entrypoint buy(to : address) =
     abort("Value too low")
 ```
 
-Note: In the æternity VM (AEVM) contracts and entrypoints were by default
-payable until the Lima release.
-
 ## Namespaces
 
 Code can be split into libraries using the `namespace` construct. Namespaces
@@ -400,9 +560,48 @@ Sophia has the following types:
 | oracle_query('a, 'b) | `oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY`                                                                             |
 | contract             | `ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ`                                                                              |
 
+## Hole expression
+
+Hole expressions, written as `???`, are expressions that are used as a placeholder. During compilation, the compiler will generate a type error indication the type of the hole expression.
+
+```
+include "List.aes"
+contract C =
+    entrypoint f() =
+        List.sum(List.map(???, [1,2,3]))
+```
+
+A hole expression found in the example above will generate the error `` Found a hole of type `(int) => int` ``. This says that the compiler expects a function from `int` to `int` in place of the `???` placeholder.
+
+## Constants
+
+Constants in Sophia are contract-level bindings that can be used in either contracts or namespaces. The value of a constant can be a literal, another constant, or arithmetic operations applied to other constants. Lists, tuples, maps, and records can also be used to define a constant as long as their elements are also constants.
+
+The following visibility rules apply to constants:
+*  Constants defined inside a contract are private in that contract. Thus, cannot be accessed through instances of their defining contract.
+* Constants defined inside a namespace are public. Thus, can be used in other contracts or namespaces.
+* Constants cannot be defined inside a contract interface.
+
+When a constant is shadowed, it can be accessed using its qualified name:
+
+```
+contract C =
+  let c = 1
+  entrypoint f() =
+    let c = 2
+    c + C.c  // the result is 3
+```
+
+The name of the constant must be an id; therefore, no pattern matching is allowed when defining a constant:
+
+```
+contract C
+  let x::y::_ = [1,2,3]  // this will result in an error
+```
+
 ## Arithmetic
 
-Sophia integers (`int`) are represented by 256-bit (AEVM) or arbitrary-sized (FATE) signed words and supports the following
+Sophia integers (`int`) are represented by arbitrary-sized signed words and support the following
 arithmetic operations:
 - addition (`x + y`)
 - subtraction (`x - y`)
@@ -411,22 +610,24 @@ arithmetic operations:
 - 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. On AEVM they behave as the corresponding
-operations on arbitrary-size integers and fail with `arithmetic_error` if the
-result cannot be represented by a 256-bit signed word. For example, `2 ^ 255`
-fails rather than wrapping around to -2²⁵⁵.
+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.
 
-The division and modulo operations also throw an arithmetic error if the
-second argument is zero.
+Sophia arbitrary-sized integers (FATE) also supports the following bitwise operations:
+- bitwise and (`x band y`)
+- bitwise or (`x bor y`)
+- bitwise xor (`x bxor y`)
+- bitwise not (`bnot x`)
+- arithmetic bitshift left (`x << n`)
+- arithmetic bitshift right (`x >> n`)
 
 ## 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).
 
-On the AEVM a bit field is represented by a 256-bit word and reading or writing
-a bit outside the 0..255 range fails with an `arithmetic_error`. On FATE a bit
-field can be of arbitrary size (but it is still represented by the
+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
@@ -868,6 +1069,16 @@ function require(b : bool, err : string) =
     if(!b) abort(err)
 ```
 
+Aside from that, there is an almost equivalent function `exit`
+
+```sophia
+exit(reason : string) : 'a
+```
+
+Just like `abort`, it breaks the execution with the given reason. The difference
+however is in the gas consumption — while `abort` returns unused gas, a call to
+`exit` burns it all.
+
 ## Delegation signature
 
 Some chain operations (`Oracle.<operation>` and `AENS.<operation>`) have an

docs/sophia_syntax.md

@@ -10,8 +10,9 @@ 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
+contract include let switch type record datatype if elif else function
+stateful payable true false mod public entrypoint private indexed namespace
+interface main using as for hiding
 ```
 
 ### Tokens
@@ -91,18 +92,31 @@ 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
+TopDecl ::= ['payable'] ['main'] 'contract' Con [Implement] '=' Block(Decl)
+          | 'contract' 'interface' Con [Implement] '=' Block(Decl)
+          | 'namespace' Con '=' Block(Decl)
+          | '@compiler' PragmaOp Version
+          | 'include' String
+          | Using
+
+Implement ::= ':' Sep1(Con, ',')
 
 Decl ::= 'type'     Id ['(' TVar* ')'] '=' TypeAlias
        | 'record'   Id ['(' TVar* ')'] '=' RecordType
        | 'datatype' Id ['(' TVar* ')'] '=' DataType
+       | 'let'      Id [':' Type]      '=' Expr
        | (EModifier* 'entrypoint' | FModifier* 'function') Block(FunDecl)
+       | Using
 
 FunDecl ::= Id ':' Type                             // Type signature
           | Id Args [':' Type] '=' Block(Stmt)      // Definition
+          | Id Args [':' Type] Block(GuardedDef)    // Guarded definitions
+
+GuardedDef ::= '|' Sep1(Expr, ',') '=' Block(Stmt)
+
+Using ::= 'using' Con ['as' Con] [UsingParts]
+UsingParts ::= 'for' '[' Sep1(Id, ',') ']'
+             | 'hiding' '[' Sep1(Id, ',') ']'
 
 PragmaOp ::= '<' | '=<' | '==' | '>=' | '>'
 Version  ::= Sep1(Int, '.')
@@ -172,12 +186,17 @@ Stmt ::= 'switch' '(' Expr ')' Block(Case)
        | 'elif' '(' Expr ')' Block(Stmt)
        | 'else' Block(Stmt)
        | 'let' LetDef
+       | Using
        | Expr
 
 LetDef ::= Id Args [':' Type] '=' Block(Stmt)   // Function definition
          | Pattern '=' Block(Stmt)              // Value definition
 
 Case    ::= Pattern '=>' Block(Stmt)
+          | Pattern Block(GuardedCase)
+
+GuardedCase ::= '|' Sep1(Expr, ',') '=>' Block(Stmt)
+
 Pattern ::= Expr
 ```
 
@@ -200,6 +219,7 @@ switch(f(x))
 
 ```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
@@ -214,10 +234,12 @@ Expr ::= '(' LamArgs ')' '=>' Block(Stmt)   // Anonymous function    (x) => x +
        | '[' Expr '..' Expr ']'             // List range            [1..n]
        | '{' Sep(FieldUpdate, ',') '}'      // Record or map value   {x = 0, y = 1}, {[key] = val}
        | '(' Expr ')'                       // Parens                (1 + 2) * 3
+       | '(' Expr '=' Expr ')'              // Assign pattern        (y = x::_)
        | 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
+       | '???'                              // Hole expression       1 + ???
 
 Generator ::= Pattern '<-' Expr   // Generator
             | 'if' '(' Expr ')'   // Guard
@@ -234,7 +256,8 @@ Path ::= Id                 // Record field
 
 BinOp ::= '||' | '&&' | '<' | '>' | '=<' | '>=' | '==' | '!='
         | '::' | '++' | '+' | '-' | '*' | '/' | 'mod' | '^'
-UnOp  ::= '-' | '!'
+        | 'band' | 'bor' | 'bxor' | '<<' | '>>' | '|>'
+UnOp  ::= '-' | '!' | 'bnot'
 ```
 
 ## Operators types
@@ -242,22 +265,29 @@ UnOp  ::= '-' | '!'
 | Operators | Type
 | --- | ---
 | `-` `+` `*` `/` `mod` `^` | arithmetic operators
-| `!` `&&` `\|\|` | logical operators
+| `!` `&&` `||` | logical operators
+| `band` `bor` `bxor` `bnot` `<<` `>>` | bitwise operators
 | `==` `!=` `<` `>` `=<` `>=` | comparison operators
 | `::` `++` | list operators
+| `|>` | functional operators
 
-## Operator precendences
+## Operator precedence
 
 In order of highest to lowest precedence.
 
 | Operators | Associativity
 | --- | ---
-| `!` | right
+| `!` `bnot`| right
 | `^` | left
 | `*` `/` `mod` | left
 | `-` (unary) | right
 | `+` `-` | left
+| `<<` `>>` | left
 | `::` `++` | right
 | `<` `>` `=<` `>=` `==` `!=` | none
+| `band` | left
+| `bxor` | left
+| `bor` | left
 | `&&` | right
-| `\|\|` | right
+| `||` | right
+| `|>` | left

priv/stdlib/AENSCompat.aes

@@ -0,0 +1,17 @@
+namespace AENSCompat =
+  // Translate old format to new format - always possible
+  function pointee_to_V2(p : AENS.pointee) : AENSv2.pointee =
+    switch(p)
+      AENS.AccountPt(a)  => AENSv2.AccountPt(a)
+      AENS.OraclePt(a)   => AENSv2.OraclePt(a)
+      AENS.ContractPt(a) => AENSv2.ContractPt(a)
+      AENS.ChannelPt(a)  => AENSv2.ChannelPt(a)
+
+  // Translate new format to old format - option type!
+  function pointee_from_V2(p2 : AENSv2.pointee) : option(AENS.pointee) =
+    switch(p2)
+      AENSv2.AccountPt(a)  => Some(AENS.AccountPt(a))
+      AENSv2.OraclePt(a)   => Some(AENS.OraclePt(a))
+      AENSv2.ContractPt(a) => Some(AENS.ContractPt(a))
+      AENSv2.ChannelPt(a)  => Some(AENS.ChannelPt(a))
+      AENSv2.DataPt(_)     => None

priv/stdlib/BLS12_381.aes

@@ -7,13 +7,13 @@ namespace BLS12_381 =
   record gt  = { x1 : fp, x2 : fp, x3 : fp, x4 : fp, x5 : fp, x6 : fp,
                  x7 : fp, x8 : fp, x9 : fp, x10 : fp, x11 : fp, x12 : fp }
 
-  function pairing_check(xs : list(g1), ys : list(g2)) =
-    switch((xs, ys))
+  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, xs : list(g1), ys : list(g2)) =
-    switch((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)

priv/stdlib/Bitwise.aes

@@ -1,136 +0,0 @@
-@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)
-
-  // Bitwise combined 'and' and 'not' of second argument for positive integers
-  // x 'bnand' y = x 'band' ('bnot' y)
-  // The tricky bit is that after negation the second argument has an infinite number of 1's
-  // use as many as needed!
-  //
-  // NOTE: this function is not symmetric!
-  private function ubnand(a, b) =
-    require(a >= 0 && b >= 0, "ubxor is only defined for non-negative integers")
-    ubnand__(a, b, 1, 0)
-
-  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/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)
 

priv/stdlib/List.aes

@@ -173,7 +173,7 @@ namespace List =
    if (n == 0) l
    else switch(l)
       []   => []
-      h::t => drop_(n-1, t)
+      _::t => drop_(n-1, t)
 
 /** Get the longest prefix of a list in which every element
  * matches predicate `p`
@@ -191,7 +191,7 @@ namespace List =
 /** Splits list into two lists of elements that respectively
  * match and don't match predicate `p`
  */
-  function partition(p : 'a => bool, l : list('a)) : (list('a) * list('a)) = switch(l)
+  function partition(p : 'a => bool, lst : list('a)) : (list('a) * list('a)) = switch(lst)
     []   => ([], [])
     h::t =>
       let (l, r) = partition(p, t)
@@ -313,4 +313,4 @@ namespace List =
   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)
+    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)

priv/stdlib/String.aes

@@ -1,5 +1,8 @@
 include "List.aes"
 namespace String =
+  // Gives a bytes() representation of the string
+  function to_bytes(s : string) : bytes() = StringInternal.to_bytes(s)
+
   // Computes the SHA3/Keccak hash of the string
   function sha3(s : string) : hash    = StringInternal.sha3(s)
   // Computes the SHA256 hash of the string.
@@ -53,21 +56,21 @@ namespace String =
 
   // Converts a decimal ("123", "-253") or a hexadecimal ("0xa2f", "-0xBBB") string
   // into an integer. If the string doesn't contain a valid number `None` is returned.
-  function to_int(s : string) : option(int) =
-    let s = StringInternal.to_list(s)
-    switch(is_prefix(['-'], s))
-      None    => to_int_pos(s)
+  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(s : list(char)) =
-    switch(is_prefix(['0', 'x'], s))
+  private function to_int_pos(chs : list(char)) =
+    switch(is_prefix(['0', 'x'], chs))
       None =>
-        to_int_(s, ch_to_int_10, 0, 10)
-      Some(s) =>
-        to_int_(s, ch_to_int_16, 0, 16)
+        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))]
@@ -84,8 +87,8 @@ namespace String =
     contains_(ix, str, substr) =
       switch(is_prefix(substr, str))
         None =>
-          let _ :: str = str
-          contains_(ix + 1, str, substr)
+          let _ :: tailstr = str
+          contains_(ix + 1, tailstr, substr)
         Some(_) =>
           Some(ix)
 
@@ -101,15 +104,15 @@ namespace String =
     to_int_(i :: is, value, x, b) =
       switch(value(i))
         None => None
-        Some(i) => to_int_(is, value, x * b + i, b)
+        Some(n) => to_int_(is, value, x * b + n, b)
 
-  private function ch_to_int_10(c) =
-    let c = Char.to_int(c)
+  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(c) =
-    let c = Char.to_int(c)
+  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)

rebar.config

@@ -2,11 +2,9 @@
 
 {erl_opts, [debug_info]}.
 
-{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git", {ref,"05dfd7f"}}}
-       , {getopt, "1.0.1"}
+{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git", {tag, "v3.4.0"}}}
        , {eblake2, "1.0.0"}
-       , {jsx, {git, "https://github.com/talentdeficit/jsx.git",
-                     {tag, "2.8.0"}}}
+       , {jsx, {git, "https://github.com/talentdeficit/jsx.git", {tag, "2.8.0"}}}
        ]}.
 
 {dialyzer, [
@@ -15,8 +13,8 @@
             {base_plt_apps, [erts, kernel, stdlib, crypto, mnesia]}
            ]}.
 
-{relx, [{release, {aesophia, "6.1.0"},
-         [aesophia, aebytecode, getopt]},
+{relx, [{release, {aesophia, "8.0.0"},
+         [aesophia, aebytecode]},
 
         {dev_mode, true},
         {include_erts, false},

rebar.lock

@@ -1,11 +1,11 @@
-{"1.1.0",
+{"1.2.0",
 [{<<"aebytecode">>,
   {git,"https://github.com/aeternity/aebytecode.git",
-       {ref,"05dfd7ffc7fb1e07ecc0b1e516da571f56d7dc8f"}},
+       {ref,"009e0361922037f978f9c0ef357d4d1be8559928"}},
   0},
  {<<"aeserialization">>,
   {git,"https://github.com/aeternity/aeserialization.git",
-       {ref,"47aaa8f5434b365c50a35bfd1490340b19241991"}},
+       {ref,"177bf604b2a05e940f92cf00e96e6e269e708245"}},
   1},
  {<<"base58">>,
   {git,"https://github.com/aeternity/erl-base58.git",
@@ -14,9 +14,9 @@
  {<<"eblake2">>,{pkg,<<"eblake2">>,<<"1.0.0">>},0},
  {<<"enacl">>,
   {git,"https://github.com/aeternity/enacl.git",
-       {ref,"26180f42c0b3a450905d2efd8bc7fd5fd9cece75"}},
+       {ref,"793ddb502f7fe081302e1c42227dca70b09f8e17"}},
   2},
- {<<"getopt">>,{pkg,<<"getopt">>,<<"1.0.1">>},0},
+ {<<"getopt">>,{pkg,<<"getopt">>,<<"1.0.1">>},1},
  {<<"jsx">>,
   {git,"https://github.com/talentdeficit/jsx.git",
        {ref,"3074d4865b3385a050badf7828ad31490d860df5"}},
@@ -24,5 +24,8 @@
 [
 {pkg_hash,[
  {<<"eblake2">>, <<"EC8AD20E438AAB3F2E8D5D118C366A0754219195F8A0F536587440F8F9BCF2EF">>},
- {<<"getopt">>, <<"C73A9FA687B217F2FF79F68A3B637711BB1936E712B521D8CE466B29CBF7808A">>}]}
+ {<<"getopt">>, <<"C73A9FA687B217F2FF79F68A3B637711BB1936E712B521D8CE466B29CBF7808A">>}]},
+{pkg_hash_ext,[
+ {<<"eblake2">>, <<"3C4D300A91845B25D501929A26AC2E6F7157480846FAB2347A4C11AE52E08A99">>},
+ {<<"getopt">>, <<"53E1AB83B9CEB65C9672D3E7A35B8092E9BDC9B3EE80721471A161C10C59959C">>}]}
 ].

src/aeso_aci.erl

@@ -70,7 +70,7 @@ do_contract_interface(Type, Contract, Options) when is_binary(Contract) ->
 do_contract_interface(Type, ContractString, Options) ->
     try
         Ast = aeso_compiler:parse(ContractString, Options),
-        {TypedAst, _} = aeso_ast_infer_types:infer(Ast, [dont_unfold | Options]),
+        {TypedAst, _, _} = aeso_ast_infer_types:infer(Ast, [dont_unfold | Options]),
         from_typed_ast(Type, TypedAst)
     catch
         throw:{error, Errors} -> {error, Errors}
@@ -83,7 +83,7 @@ from_typed_ast(Type, TypedAst) ->
         string -> do_render_aci_json(JArray)
     end.
 
-encode_contract(Contract = {Head, _, {con, _, Name}, _}) when ?IS_CONTRACT_HEAD(Head) ->
+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)) ],
@@ -91,7 +91,7 @@ encode_contract(Contract = {Head, _, {con, _, Name}, _}) when ?IS_CONTRACT_HEAD(
     {Es, Tdefs1} = lists:partition(FilterT(<<"event">>), Tdefs0),
     {Ss, Tdefs}  = lists:partition(FilterT(<<"state">>), Tdefs1),
 
-    C1 = C0#{type_defs => Tdefs},
+    C1 = C0#{typedefs => Tdefs},
 
     C2 = case Es of
              []                 -> C1;
@@ -111,7 +111,7 @@ encode_contract(Contract = {Head, _, {con, _, Name}, _}) when ?IS_CONTRACT_HEAD(
 encode_contract(Namespace = {namespace, _, {con, _, Name}, _}) ->
     Tdefs = [ encode_typedef(T) || T <- sort_decls(contract_types(Namespace)) ],
     #{namespace => #{name => encode_name(Name),
-                     type_defs => Tdefs}}.
+                     typedefs => Tdefs}}.
 
 %%  Encode a function definition. Currently we are only interested in
 %%  the interface and type.
@@ -234,7 +234,7 @@ do_render_aci_json(Json) ->
 decode_contract(#{contract := #{name := Name,
                                 kind := Kind,
                                 payable := Payable,
-                                type_defs := Ts0,
+                                typedefs := 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) ] ++
@@ -246,7 +246,7 @@ decode_contract(#{contract := #{name := Name,
                        end,
      io_lib:format("~s", [Name])," =\n",
      decode_tdefs(Ts), decode_funcs(Fs)];
-decode_contract(#{namespace := #{name := Name, type_defs := Ts}}) when Ts /= [] ->
+decode_contract(#{namespace := #{name := Name, typedefs := Ts}}) when Ts /= [] ->
     ["namespace ", io_lib:format("~s", [Name])," =\n",
      decode_tdefs(Ts)];
 decode_contract(_) -> [].
@@ -282,6 +282,8 @@ decode_type(#{list := [Et]}) ->
 decode_type(#{map := Ets}) ->
     Ts = decode_types(Ets),
     ["map",$(,lists:join(",", Ts),$)];
+decode_type(#{bytes := any}) ->
+    ["bytes()"];
 decode_type(#{bytes := Len}) ->
     ["bytes(", integer_to_list(Len), ")"];
 decode_type(#{variant := Ets}) ->
@@ -341,10 +343,12 @@ stateful(false) -> "".
 
 %% #contract{Ann, Con, [Declarations]}.
 
-contract_funcs({C, _, _, Decls}) when ?IS_CONTRACT_HEAD(C); C == namespace ->
+contract_funcs({C, _, _, _, Decls}) when ?IS_CONTRACT_HEAD(C) ->
     [ D || D <- Decls, is_fun(D)].
 
-contract_types({C, _, _, Decls}) when ?IS_CONTRACT_HEAD(C); C == namespace ->
+contract_types({namespace, _, _, Decls}) ->
+    [ D || D <- Decls, is_type(D) ];
+contract_types({C, _, _, _, Decls}) when ?IS_CONTRACT_HEAD(C) ->
     [ D || D <- Decls, is_type(D) ].
 
 is_fun({letfun, _, _, _, _, _}) -> true;

src/aeso_builtins.erl

@@ -1,684 +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
-        , bytes_to_raw_string/2
-        , 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, bytes_to_str_worker_x];
-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) -> simpl({binop, Op, operand(A), operand(B)}).
-
-%% We generate a lot of B * 8 for integer B from BSL and BSR.
-simpl({binop, '*', {integer, A}, {integer, B}}) when A >= 0, B >= 0, A * B < 1 bsl 256 ->
-    {integer, A * B};
-simpl(Op) -> Op.
-
-
-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_concat, A, B}       -> bfun(BF, builtin_bytes_concat(A, B));
-        {bytes_split, A, B}        -> bfun(BF, builtin_bytes_split(A, B));
-        bytes_to_str_worker        -> bfun(BF, builtin_bytes_to_str_worker());
-        bytes_to_str_worker_x      -> bfun(BF, builtin_bytes_to_str_worker_x());
-        string_reverse             -> bfun(BF, builtin_string_reverse());
-        string_reverse_            -> bfun(BF, builtin_string_reverse_())
-    end.
-
-%% 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}.
-
-%% Two versions of this helper function, worker for sections not even 16 bytes long
-%% and worker_x for the full sized chunks.
-builtin_bytes_to_str_worker_x() ->
-    <<Tab:256>> = <<"0123456789ABCDEF________________">>,
-    {[{"w", word}, {"offs", word}, {"acc", word}],
-     {ifte, ?EQ(offs, 16), {seq, [?V(acc), {inline_asm, [?A(?MSIZE), ?A(?MSTORE), ?A(?MSIZE)]}]},
-         ?LET(b,  ?BYTE(offs, w),
-         ?LET(lo, ?BYTE(?MOD(b, 16), Tab),
-         ?LET(hi, ?BYTE(op('bsr', 4 , b), Tab),
-         ?call(bytes_to_str_worker_x, [?V(w), ?ADD(offs, 1), ?ADD(?BSL(acc, 2), ?ADD(?BSL(hi, 1), lo))]))))
-     },
-     word}.
-
-builtin_bytes_to_str_worker() ->
-    <<Tab:256>> = <<"0123456789ABCDEF________________">>,
-    {[{"w", word}, {"offs", word}, {"acc", word}, {"stop", word}],
-     {ifte, ?EQ(stop, offs), {seq, [?BSL(acc, ?MUL(2, ?SUB(16, offs))), {inline_asm, [?A(?MSIZE), ?A(?MSTORE), ?A(?MSIZE)]}]},
-         ?LET(b,  ?BYTE(offs, w),
-         ?LET(lo, ?BYTE(?MOD(b, 16), Tab),
-         ?LET(hi, ?BYTE(op('bsr', 4 , b), Tab),
-         ?call(bytes_to_str_worker, [?V(w), ?ADD(offs, 1), ?ADD(?BSL(acc, 2), ?ADD(?BSL(hi, 1), lo)), ?V(stop)]))))
-     },
-     word}.
-
-builtin_bytes_to_str_body(Var, N) when N < 16 ->
-    [?call(bytes_to_str_worker, [?V(Var), ?I(0), ?I(0), ?I(N)])];
-builtin_bytes_to_str_body(Var, 16) ->
-    [?call(bytes_to_str_worker_x, [?V(Var), ?I(0), ?I(0)])];
-builtin_bytes_to_str_body(Var, N) when N < 32 ->
-    builtin_bytes_to_str_body(Var, 16) ++ [{inline_asm, [?A(?POP)]}] ++
-    [?call(bytes_to_str_worker, [?BSL(Var, 16), ?I(0), ?I(0), ?I(N - 16)])];
-builtin_bytes_to_str_body(Var, 32) ->
-    builtin_bytes_to_str_body(Var, 16) ++ [{inline_asm, [?A(?POP)]}] ++
-    [?call(bytes_to_str_worker_x, [?BSL(Var, 16), ?I(0), ?I(0)])];
-builtin_bytes_to_str_body(Var, N) when N > 32 ->
-    WholeWords = ((N + 31) div 32) - 1,
-    lists:append(
-    [ [?DEREF(w, ?ADD(Var, 32 * I), {seq, builtin_bytes_to_str_body(w, 32)}), {inline_asm, [?A(?POP)]}]
-      || I <- lists:seq(0, WholeWords - 1) ]) ++
-    [ ?DEREF(w, ?ADD(Var, 32 * WholeWords), {seq, builtin_bytes_to_str_body(w, N - WholeWords * 32)}) ].
-
-builtin_bytes_to_str(N) when N =< 32 ->
-    {[{"w", word}],
-     ?LET(ret, {inline_asm, [?A(?MSIZE)]},
-     {seq, [?I(N * 2), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]}] ++
-            builtin_bytes_to_str_body(w, N) ++
-            [{inline_asm, [?A(?POP)]}, ?V(ret)]}),
-     string};
-builtin_bytes_to_str(N) when N > 32 ->
-    {[{"p", pointer}],
-     ?LET(ret, {inline_asm, [?A(?MSIZE)]},
-     {seq, [?I(N * 2), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]}] ++
-            builtin_bytes_to_str_body(p, N) ++
-            [{inline_asm, [?A(?POP)]}, ?V(ret)]}),
-     string}.
-
-builtin_string_reverse() ->
-    {[{"s", string}],
-     ?DEREF(n, s,
-     ?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}.
-
-%% At most one word
-%% | ..... | ========= | ........ |
-%%    Offs ^ ^- Len -^   TotalLen ^
-bytes_slice(Offs, Len, TotalLen, Bytes) when TotalLen =< 32 ->
-    %% Bytes are packed into a single word
-    Masked =
-        case Offs of
-            0 -> Bytes;
-            _ -> ?MOD(Bytes, 1 bsl ((32 - Offs) * 8))
-        end,
-    Unpadded =
-        case 32 - (Offs + Len) of
-            0 -> Masked;
-            N -> ?BSR(Masked, N)
-        end,
-    case Len of
-        32 -> Unpadded;
-        _  -> ?BSL(Unpadded, 32 - Len)
-    end;
-bytes_slice(Offs, Len, TotalLen, Bytes) when TotalLen > 32 ->
-    %% Bytes is a pointer to memory. The VM can read at non-aligned addresses.
-    %% Might read one word more than necessary.
-    Word = op('!', Offs, Bytes),
-    case Len == 32 of
-        true -> Word;
-        _    -> ?BSL(?BSR(Word, 32 - Len), 32 - Len)
-    end.
-
-builtin_bytes_concat(A, B) ->
-    Type     = fun(N) when N =< 32 -> word; (_) -> pointer end,
-    MkBytes  = fun([W]) -> W;
-                  (Ws)  -> {tuple, Ws} end,
-    Words    = fun(N) -> (N + 31) div 32 end,
-    WordsRes = Words(A + B),
-    Word = fun(I) when 32 * (I + 1) =< A -> bytes_slice(I * 32, 32, A, ?V(a));
-              (I) when 32 * I < A ->
-                   Len = A rem 32,
-                   Hi  = bytes_slice(32 * I, Len, A, ?V(a)),
-                   Lo  = bytes_slice(0, min(32 - Len, B), B, ?V(b)),
-                   ?ADD(Hi, ?BSR(Lo, Len));
-              (I) ->
-                   Offs = 32 * I - A,
-                   Len  = min(32, B - Offs),
-                   bytes_slice(Offs, Len, B, ?V(b))
-           end,
-    Body =
-        case {A, B} of
-            {0, _} -> ?V(b);
-            {_, 0} -> ?V(a);
-            _      -> MkBytes([ Word(I) || I <- lists:seq(0, WordsRes - 1) ])
-        end,
-    {[{"a", Type(A)}, {"b", Type(B)}], Body, Type(A + B)}.
-
-builtin_bytes_split(A, B) ->
-    Type    = fun(N) when N =< 32 -> word; (_) -> pointer end,
-    MkBytes = fun([W]) -> W;
-                 (Ws)  -> {tuple, Ws} end,
-    Word    = fun(I, Max) ->
-                bytes_slice(I, min(32, Max - I), A + B, ?V(c))
-              end,
-    Body =
-        case {A, B} of
-            {0, _} -> [?I(0), ?V(c)];
-            {_, 0} -> [?V(c), ?I(0)];
-            _      -> [MkBytes([ Word(I, A)     || I <- lists:seq(0, A - 1, 32) ]),
-                       MkBytes([ Word(I, A + B) || I <- lists:seq(A, A + B - 1, 32) ])]
-        end,
-    {[{"c", Type(A + B)}], {tuple, Body}, {tuple, [Type(A), Type(B)]}}.
-
-bytes_to_raw_string(N, Term) when N =< 32 ->
-    {tuple, [?I(N), Term]};
-bytes_to_raw_string(N, Term) when N > 32 ->
-    Elem  = fun(I) -> #binop{op = '!', left = ?I(32 * I), right = ?V(bin)}
-            end,
-    Words = (N + 31) div 32,
-    ?LET(bin, Term, {tuple, [?I(N) | [Elem(I) || I <- lists:seq(0, Words - 1)]]}).
-

src/aeso_code_errors.erl

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

src/aeso_compiler.erl

@@ -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,14 +12,15 @@
         , file/2
         , from_string/2
         , check_call/4
-        , create_calldata/3  %% deprecated
+        , decode_value/4
+        , encode_value/4
+        , create_calldata/3
         , create_calldata/4
         , version/0
         , numeric_version/0
-        , sophia_type_to_typerep/1
-        , to_sophia_value/4  %% deprecated, need a backend
+        , to_sophia_value/4
         , to_sophia_value/5
-        , decode_calldata/3  %% deprecated
+        , decode_calldata/3
         , decode_calldata/4
         , parse/2
         , add_include_path/2
@@ -27,7 +28,6 @@
         ]).
 
 -include_lib("aebytecode/include/aeb_opcodes.hrl").
--include("aeso_icode.hrl").
 -include("aeso_utils.hrl").
 
 
@@ -35,13 +35,10 @@
                 | pp_ast
                 | pp_types
                 | pp_typed_ast
-                | pp_icode
                 | pp_assembler
-                | pp_bytecode
                 | no_code
                 | keep_included
                 | debug_mode
-                | {backend, aevm | fate}
                 | {include, {file_system, [string()]} |
                             {explicit_files, #{string() => binary()}}}
                 | {src_file, string()}
@@ -106,42 +103,24 @@ add_include_path(File, Options) ->
     end.
 
 -spec from_string(binary() | string(), options()) -> {ok, map()} | {error, [aeso_errors:error()]}.
-from_string(Contract, Options) ->
-    from_string(proplists:get_value(backend, Options, aevm), Contract, Options).
-
-from_string(Backend, ContractBin, Options) when is_binary(ContractBin) ->
-    from_string(Backend, binary_to_list(ContractBin), Options);
-from_string(Backend, ContractString, Options) ->
+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
         throw:{error, Errors} -> {error, Errors}
     end.
 
-from_string1(aevm, ContractString, Options) ->
-    #{ icode := Icode
-     , folded_typed_ast := FoldedTypedAst } = string_to_code(ContractString, Options),
-    TypeInfo  = extract_type_info(Icode),
-    Assembler = assemble(Icode, Options),
-    pp_assembler(aevm, Assembler, Options),
-    ByteCodeList = to_bytecode(Assembler, Options),
-    ByteCode = << << B:8 >> || B <- ByteCodeList >>,
-    pp_bytecode(ByteCode, Options),
-    {ok, Version} = version(),
-    Res = #{byte_code => ByteCode,
-            compiler_version => Version,
-            contract_source => ContractString,
-            type_info => TypeInfo,
-            abi_version => aeb_aevm_abi:abi_version(),
-            payable => maps:get(payable, Icode)
-           },
-    {ok, maybe_generate_aci(Res, FoldedTypedAst, Options)};
-from_string1(fate, ContractString, Options) ->
+from_string1(ContractString, Options) ->
     #{ fcode := FCode
-     , fcode_env := #{child_con_env := ChildContracts}
-     , folded_typed_ast := FoldedTypedAst } = string_to_code(ContractString, Options),
-    FateCode = aeso_fcode_to_fate:compile(ChildContracts, FCode, Options),
-    pp_assembler(fate, FateCode, Options),
+     , fcode_env := FCodeEnv
+     , folded_typed_ast := FoldedTypedAst
+     , warnings := Warnings } = string_to_code(ContractString, Options),
+    #{ child_con_env := ChildContracts } = FCodeEnv,
+    SavedFreshNames = maps:get(saved_fresh_names, FCodeEnv, #{}),
+    FateCode = aeso_fcode_to_fate:compile(ChildContracts, FCode, SavedFreshNames, Options),
+    pp_assembler(FateCode, Options),
     ByteCode = aeb_fate_code:serialize(FateCode, []),
     {ok, Version} = version(),
     Res = #{byte_code => ByteCode,
@@ -150,7 +129,8 @@ from_string1(fate, ContractString, Options) ->
             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)}.
 
@@ -168,29 +148,18 @@ string_to_code(ContractString, Options) ->
     Ast = parse(ContractString, Options),
     pp_sophia_code(Ast, Options),
     pp_ast(Ast, Options),
-    {TypeEnv, FoldedTypedAst, UnfoldedTypedAst} = aeso_ast_infer_types:infer(Ast, [return_env | Options]),
+    {TypeEnv, FoldedTypedAst, UnfoldedTypedAst, Warnings} = aeso_ast_infer_types:infer(Ast, [return_env | Options]),
     pp_typed_ast(UnfoldedTypedAst, Options),
-    case proplists:get_value(backend, Options, aevm) of
-        aevm ->
-            Icode = ast_to_icode(UnfoldedTypedAst, Options),
-            pp_icode(Icode, Options),
-            #{ icode => Icode
-             , unfolded_typed_ast => UnfoldedTypedAst
-             , folded_typed_ast => FoldedTypedAst
-             , type_env  => TypeEnv
-             , ast => Ast };
-        fate ->
-            {Env, Fcode} = aeso_ast_to_fcode:ast_to_fcode(UnfoldedTypedAst, [{original_src, ContractString}|Options]),
-            #{ fcode => Fcode
-             , fcode_env => Env
-             , unfolded_typed_ast => UnfoldedTypedAst
-             , folded_typed_ast => FoldedTypedAst
-             , type_env  => TypeEnv
-             , ast => Ast }
-    end.
+    {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
@@ -198,10 +167,8 @@ string_to_code(ContractString, Options) ->
 %% terms for the arguments.
 %% NOTE: Special treatment for "init" since it might be implicit and has
 %%       a special return type (typerep, T)
--spec check_call(string(), string(), [string()], options()) -> {ok, string(), {[Type], Type}, [term()]}
-                                                                   | {ok, string(), [term()]}
-                                                                   | {error, [aeso_errors:error()]}
-    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 == [] ->
@@ -217,54 +184,55 @@ check_call(Source, FunName, Args, Options) ->
     check_call1(Source, FunName, Args, Options).
 
 check_call1(ContractString0, FunName, Args, Options) ->
+    case add_extra_call(ContractString0, {call, FunName, Args}, Options) of
+        {ok, CallName, Code} ->
+            {def, _, _, FcodeArgs} = get_call_body(CallName, Code),
+            {ok, FunName, [ aeso_fcode_to_fate:term_to_fate(A) || A <- FcodeArgs ]};
+        Err = {error, _} ->
+            Err
+    end.
+
+add_extra_call(Contract0, Call, Options) ->
     try
-        case proplists:get_value(backend, Options, aevm) of
-            aevm ->
-                %% First check the contract without the __call function
-                #{ast := Ast} = string_to_code(ContractString0, Options),
-                ContractString = insert_call_function(Ast, ContractString0, ?CALL_NAME, FunName, Args),
-                #{unfolded_typed_ast := TypedAst,
-                  icode     := Icode} = string_to_code(ContractString, Options),
-                {ok, {FunName, {fun_t, _, _, ArgTypes, RetType}}} = get_call_type(TypedAst),
-                ArgVMTypes = [ aeso_ast_to_icode:ast_typerep(T, Icode) || T <- ArgTypes ],
-                RetVMType  = case RetType of
-                                 {id, _, "_"} -> any;
-                                 _            -> aeso_ast_to_icode:ast_typerep(RetType, Icode)
-                             end,
-                #{ functions := Funs } = Icode,
-                ArgIcode = get_arg_icode(Funs),
-                ArgTerms = [ icode_to_term(T, Arg) ||
-                               {T, Arg} <- lists:zip(ArgVMTypes, ArgIcode) ],
-                RetVMType1 =
-                    case FunName of
-                        "init" -> {tuple, [typerep, RetVMType]};
-                        _ -> RetVMType
-                    end,
-                {ok, FunName, {ArgVMTypes, RetVMType1}, ArgTerms};
-            fate ->
-                %% First check the contract without the __call function
-                #{ fcode := OrgFcode
-                 , 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(Ast, ContractString0, CallName, FunName, Args),
-                #{fcode := Fcode} = string_to_code(ContractString, Options),
-                CallArgs = arguments_of_body(CallName, FunName, Fcode),
-                {ok, FunName, CallArgs}
-        end
+        %% First check the contract without the __call function
+        #{fcode := OrgFcode
+        , fcode_env := #{child_con_env := ChildContracts}
+        , ast := Ast} = string_to_code(Contract0, 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)),
+        Contract = insert_call_function(Ast, Contract0, CallName, Call),
+        {ok, CallName, string_to_code(Contract, Options)}
     catch
         throw:{error, Errors} -> {error, Errors}
     end.
 
-arguments_of_body(CallName, _FunName, Fcode) ->
+get_call_body(CallName, #{fcode := Fcode}) ->
     #{body := Body} = maps:get({entrypoint, list_to_binary(CallName)}, maps:get(functions, Fcode)),
-    {def, _FName, Args} = Body,
-    %% FName is either {entrypoint, list_to_binary(FunName)} or 'init'
-    [ aeso_fcode_to_fate:term_to_fate(A) || A <- Args ].
+    Body.
+
+encode_value(Contract0, Type, Value, Options) ->
+    case add_extra_call(Contract0, {value, Type, Value}, Options) of
+        {ok, CallName, Code} ->
+            Body = get_call_body(CallName, Code),
+            {ok, aeb_fate_encoding:serialize(aeso_fcode_to_fate:term_to_fate(Body))};
+        Err = {error, _} ->
+            Err
+    end.
+
+decode_value(Contract0, Type, FateValue, Options) ->
+    case add_extra_call(Contract0, {type, Type}, Options) of
+        {ok, CallName, Code} ->
+            #{ unfolded_typed_ast := TypedAst
+             , type_env           := TypeEnv} = Code,
+            {ok, _, Type0} = get_decode_type(CallName, TypedAst),
+            Type1 = aeso_ast_infer_types:unfold_types_in_type(TypeEnv, Type0, [unfold_record_types, unfold_variant_types]),
+            fate_data_to_sophia_value(Type0, Type1, FateValue);
+        Err = {error, _} ->
+            Err
+    end.
 
 first_none_match(_CallName, _Hashes, []) ->
     error(unable_to_find_unique_call_name);
@@ -277,14 +245,31 @@ first_none_match(CallName, Hashes, [Char|Chars]) ->
     end.
 
 %% Add the __call function to a contract.
--spec insert_call_function(aeso_syntax:ast(), string(), string(), string(), [string()]) -> string().
-insert_call_function(Ast, Code, Call, FunName, Args) ->
+-spec insert_call_function(aeso_syntax:ast(), string(), string(),
+                           {call, string(), [string()]} | {value, string(), string()} | {type, string()}) -> string().
+insert_call_function(Ast, Code, Call, {call, FunName, Args}) ->
     Ind = last_contract_indent(Ast),
     lists:flatten(
         [ Code,
           "\n\n",
           lists:duplicate(Ind, " "),
           "stateful entrypoint ", Call, "() = ", FunName, "(", string:join(Args, ","), ")\n"
+        ]);
+insert_call_function(Ast, Code, Call, {value, Type, Value}) ->
+    Ind = last_contract_indent(Ast),
+    lists:flatten(
+        [ Code,
+          "\n\n",
+          lists:duplicate(Ind, " "),
+          "entrypoint ", Call, "() : ", Type, " = ", Value, "\n"
+        ]);
+insert_call_function(Ast, Code, Call, {type, Type}) ->
+    Ind = last_contract_indent(Ast),
+    lists:flatten(
+        [ Code,
+          "\n\n",
+          lists:duplicate(Ind, " "),
+          "entrypoint ", Call, "(val : ", Type, ") = val\n"
         ]).
 
 -spec insert_init_function(string(), options()) -> string().
@@ -299,36 +284,25 @@ insert_init_function(Code, Options) ->
 
 last_contract_indent(Decls) ->
     case lists:last(Decls) of
-        {_, _, _, [Decl | _]} -> aeso_syntax:get_ann(col, Decl, 1) - 1;
-        _                     -> 0
+        {_, _, _, _, [Decl | _]} -> aeso_syntax:get_ann(col, Decl, 1) - 1;
+        _                        -> 0
     end.
 
--spec to_sophia_value(string(), string(), ok | error | revert, aeb_aevm_data:data()) ->
-        {ok, aeso_syntax:expr()} | {error, [aeso_errors:error()]}.
+-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, [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, _} ->
-                    Msg = "Could not interpret the revert message\n",
-                    {error, [aeso_errors:new(data_error, Msg)]}
-            end;
-        fate ->
-            try aeb_fate_encoding:deserialize(Data) of
-                Err -> {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}}
-            catch _:_ ->
-                Msg = "Could not deserialize the revert message\n",
-                {error, [aeso_errors:new(data_error, Msg)]}
-            end
+to_sophia_value(_, _, revert, Data, _Options) ->
+    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],
@@ -338,74 +312,47 @@ to_sophia_value(ContractString, FunName, ok, Data, Options0) ->
         {ok, _, Type0} = get_decode_type(FunName, TypedAst),
         Type   = aeso_ast_infer_types:unfold_types_in_type(TypeEnv, Type0, [unfold_record_types, unfold_variant_types]),
 
-        case proplists:get_value(backend, Options, aevm) of
-            aevm ->
-                Icode  = maps:get(icode, Code),
-                VmType = aeso_ast_to_icode:ast_typerep(Type, Icode),
-                case aeb_heap:from_binary(VmType, Data) of
-                    {ok, VmValue} ->
-                        try
-                            {ok, aeso_vm_decode:from_aevm(VmType, Type, VmValue)}
-                        catch throw:cannot_translate_to_sophia ->
-                            Type0Str = prettypr:format(aeso_pretty:type(Type0)),
-                            Msg = io_lib:format("Cannot translate VM value ~p\n  of type ~p\n  to Sophia type ~s\n",
-                                                [Data, VmType, Type0Str]),
-                            {error, [aeso_errors:new(data_error, Msg)]}
-                        end;
-                    {error, _Err} ->
-                        Msg = io_lib:format("Failed to decode binary as type ~p\n", [VmType]),
-                        {error, [aeso_errors:new(data_error, Msg)]}
-                end;
-            fate ->
-                try
-                    {ok, aeso_vm_decode:from_fate(Type, aeb_fate_encoding:deserialize(Data))}
-                catch throw:cannot_translate_to_sophia ->
-                        Type1 = prettypr:format(aeso_pretty:type(Type0)),
-                        Msg = io_lib:format("Cannot translate FATE value ~p\n  of Sophia type ~s\n",
-                                            [aeb_fate_encoding:deserialize(Data), Type1]),
-                        {error, [aeso_errors:new(data_error, Msg)]};
-                      _:_ ->
-                        Type1 = prettypr:format(aeso_pretty:type(Type0)),
-                        Msg = io_lib:format("Failed to decode binary as type ~s\n", [Type1]),
-                        {error, [aeso_errors:new(data_error, Msg)]}
-               end
-        end
+        fate_data_to_sophia_value(Type0, Type, Data)
     catch
         throw:{error, Errors} -> {error, Errors}
     end.
 
+fate_data_to_sophia_value(Type, UnfoldedType, FateData) ->
+    try
+        {ok, aeso_vm_decode:from_fate(UnfoldedType, aeb_fate_encoding:deserialize(FateData))}
+    catch throw:cannot_translate_to_sophia ->
+            Type1 = prettypr:format(aeso_pretty:type(Type)),
+            Msg = io_lib:format("Cannot translate FATE value ~p\n  of Sophia type ~s",
+                                [aeb_fate_encoding:deserialize(FateData), Type1]),
+            {error, [aeso_errors:new(data_error, Msg)]};
+          _:_ ->
+            Type1 = prettypr:format(aeso_pretty:type(Type)),
+            Msg = io_lib:format("Failed to decode binary as type ~s", [Type1]),
+            {error, [aeso_errors:new(data_error, Msg)]}
+    end.
 
 -spec create_calldata(string(), string(), [string()]) ->
-                             {ok, binary(), aeb_aevm_data:type(), aeb_aevm_data:type()}
-                             | {error, [aeso_errors:error()]}.
+          {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, [aeso_errors:error()]}.
 create_calldata(Code, Fun, Args, Options0) ->
     Options = [no_code | Options0],
-    case proplists:get_value(backend, Options, aevm) of
-        aevm ->
-            case check_call(Code, Fun, Args, Options) of
-                {ok, FunName, {ArgTypes, RetType}, VMArgs} ->
-                    aeb_aevm_abi:create_calldata(FunName, VMArgs, ArgTypes, RetType);
-                {error, _} = Err -> Err
-            end;
-        fate ->
-            case check_call(Code, Fun, Args, Options) of
-                {ok, FunName, FateArgs} ->
-                    aeb_fate_abi:create_calldata(FunName, FateArgs);
-                {error, _} = Err -> Err
-            end
+    case check_call(Code, Fun, Args, Options) of
+        {ok, FunName, FateArgs} ->
+            aeb_fate_abi:create_calldata(FunName, FateArgs);
+        {error, _} = Err -> Err
     end.
 
 -spec decode_calldata(string(), string(), binary()) ->
-                             {ok, [aeso_syntax:type()], [aeso_syntax:expr()]}
-                             | {error, [aeso_errors:error()]}.
+          {ok, [aeso_syntax:type()], [aeso_syntax:expr()]}
+        | {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
@@ -418,75 +365,29 @@ decode_calldata(ContractString, FunName, Calldata, Options0) ->
         Type0         = {tuple_t, [], ArgTypes},
         %% user defined data types such as variants needed to match against
         Type          = aeso_ast_infer_types:unfold_types_in_type(TypeEnv, Type0, [unfold_record_types, unfold_variant_types]),
-        case proplists:get_value(backend, Options, aevm) of
-            aevm ->
-                Icode  = maps:get(icode, Code),
-                VmType = aeso_ast_to_icode:ast_typerep(Type, Icode),
-                case aeb_heap:from_binary({tuple, [word, VmType]}, Calldata) of
-                    {ok, {_, VmValue}} ->
-                        try
-                            {tuple, [], Values} = aeso_vm_decode:from_aevm(VmType, Type, VmValue),
-                            %% Values are Sophia expressions in AST format
-                            {ok, ArgTypes, Values}
-                        catch throw:cannot_translate_to_sophia ->
-                            Type0Str = prettypr:format(aeso_pretty:type(Type0)),
-                            Msg = io_lib:format("Cannot translate VM value ~p\n  of type ~p\n  to Sophia type ~s\n",
-                                                [VmValue, VmType, Type0Str]),
-                            {error, [aeso_errors:new(data_error, Msg)]}
-                        end;
-                    {error, _Err} ->
-                        Msg = io_lib:format("Failed to decode calldata as type ~p\n", [VmType]),
+        case aeb_fate_abi:decode_calldata(FunName, Calldata) of
+            {ok, FateArgs} ->
+                try
+                    {tuple_t, [], ArgTypes1} = Type,
+                    AstArgs = [ aeso_vm_decode:from_fate(ArgType, FateArg)
+                                || {ArgType, FateArg} <- lists:zip(ArgTypes1, FateArgs)],
+                    {ok, ArgTypes, AstArgs}
+                catch throw:cannot_translate_to_sophia ->
+                        Type0Str = prettypr:format(aeso_pretty:type(Type0)),
+                        Msg = io_lib:format("Cannot translate FATE value ~p\n  to Sophia type ~s",
+                                            [FateArgs, Type0Str]),
                         {error, [aeso_errors:new(data_error, Msg)]}
                 end;
-            fate ->
-                case aeb_fate_abi:decode_calldata(FunName, Calldata) of
-                    {ok, FateArgs} ->
-                        try
-                            {tuple_t, [], ArgTypes1} = Type,
-                            AstArgs = [ aeso_vm_decode:from_fate(ArgType, FateArg)
-                                        || {ArgType, FateArg} <- lists:zip(ArgTypes1, FateArgs)],
-                            {ok, ArgTypes, AstArgs}
-                        catch throw:cannot_translate_to_sophia ->
-                                Type0Str = prettypr:format(aeso_pretty:type(Type0)),
-                                Msg = io_lib:format("Cannot translate FATE value ~p\n  to Sophia type ~s\n",
-                                                    [FateArgs, Type0Str]),
-                                {error, [aeso_errors:new(data_error, Msg)]}
-                        end;
-                    {error, _} ->
-                        Msg = io_lib:format("Failed to decode calldata binary\n", []),
-                        {error, [aeso_errors:new(data_error, Msg)]}
-                end
+            {error, _} ->
+                Msg = io_lib:format("Failed to decode calldata binary", []),
+                {error, [aeso_errors:new(data_error, Msg)]}
         end
     catch
         throw:{error, Errors} -> {error, Errors}
     end.
 
-get_arg_icode(Funs) ->
-    case [ Args || {[_, ?CALL_NAME], _, _, {funcall, _, Args}, _} <- Funs ] of
-        [Args] -> Args;
-        []     -> error_missing_call_function()
-    end.
-
--dialyzer({nowarn_function, error_missing_call_function/0}).
-error_missing_call_function() ->
-    Msg = "Internal error: missing '__call'-function",
-    aeso_errors:throw(aeso_errors:new(internal_error, Msg)).
-
-get_call_type([{Contract, _, _, Defs}]) when ?IS_CONTRACT_HEAD(Contract) ->
-    case [ {lists:last(QFunName), FunType}
-          || {letfun, _, {id, _, ?CALL_NAME}, [], _Ret,
-                [{guarded, _, [], {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).
-
 -dialyzer({nowarn_function, get_decode_type/2}).
-get_decode_type(FunName, [{Contract, Ann, _, Defs}]) when ?IS_CONTRACT_HEAD(Contract) ->
+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,
@@ -496,8 +397,8 @@ get_decode_type(FunName, [{Contract, Ann, _, Defs}]) when ?IS_CONTRACT_HEAD(Cont
             case FunName of
                 "init" -> {ok, [], {tuple_t, [], []}};
                  _ ->
-                    Msg = io_lib:format("Function '~s' is missing in contract\n", [FunName]),
-                    Pos = aeso_code_errors:pos(Ann),
+                    Msg = io_lib:format("Function '~s' is missing in contract", [FunName]),
+                    Pos = aeso_errors:pos(Ann),
                     aeso_errors:throw(aeso_errors:new(data_error, Pos, Msg))
             end
     end;
@@ -505,87 +406,17 @@ 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(word, {unop, 'bnot', A}) ->
-    bnot icode_to_term(word, A);
-icode_to_term(word, {binop, 'bor', A, B}) ->
-    icode_to_term(word, A) bor icode_to_term(word, B);
-icode_to_term(word, {binop, 'bsl', A, B}) ->
-    icode_to_term(word, B) bsl icode_to_term(word, A);
-icode_to_term(word, {binop, 'band', A, B}) ->
-    icode_to_term(word, A) band icode_to_term(word, B);
-icode_to_term(typerep, _) ->
-    throw({todo, typerep});
-icode_to_term(T, V) ->
-    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_bytecode(C, Opts) ->  pp(C, Opts, pp_bytecode, fun aeb_disassemble:pp/1).
 
-pp_assembler(aevm, C, Opts) ->  pp(C, Opts, pp_assembler, fun aeb_asm:pp/1);
-pp_assembler(fate, C, Opts) ->  pp(C, Opts, pp_assembler, fun(Asm) -> io:format("~s", [aeb_fate_asm:pp(Asm)]) end).
+pp_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
@@ -598,31 +429,27 @@ pp(Code, Options, Option, PPFun) ->
 -spec validate_byte_code(map(), string(), options()) -> ok | {error, [aeso_errors:error()]}.
 validate_byte_code(#{ byte_code := ByteCode, payable := Payable }, Source, Options) ->
     Fail = fun(Err) -> {error, [aeso_errors:new(data_error, Err)]} end,
-    case proplists:get_value(backend, Options, aevm) of
-        B when B /= fate -> Fail(io_lib:format("Unsupported backend: ~s\n", [B]));
-        fate ->
-            try
-                FCode1 = ?protect(deserialize, aeb_fate_code:strip_init_function(aeb_fate_code:deserialize(ByteCode))),
-                {FCode2, SrcPayable} =
-                    ?protect(compile,
-                             begin
-                               {ok, #{ byte_code := SrcByteCode, payable := SrcPayable }} =
-                                    from_string1(fate, Source, Options),
-                               FCode = aeb_fate_code:deserialize(SrcByteCode),
-                               {aeb_fate_code:strip_init_function(FCode), SrcPayable}
-                             end),
-                case compare_fate_code(FCode1, FCode2) of
-                    ok when SrcPayable /= Payable ->
-                        Not = fun(true) -> ""; (false) -> " not" end,
-                        Fail(io_lib:format("Byte code contract is~s payable, but source code contract is~s.\n",
-                                           [Not(Payable), Not(SrcPayable)]));
-                    ok           -> ok;
-                    {error, Why} -> Fail(io_lib:format("Byte code does not match source code.\n~s", [Why]))
-                end
-            catch
-                throw:{deserialize, _}         -> Fail("Invalid byte code");
-                throw:{compile, {error, Errs}} -> {error, Errs}
-            end
+    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) ->
@@ -674,14 +501,6 @@ pp_fate_type(T) -> io_lib:format("~w", [T]).
 
 %% -------------------------------------------------------------------
 
--spec sophia_type_to_typerep(string()) -> {error, bad_type} | {ok, aeb_aevm_data:type()}.
-sophia_type_to_typerep(String) ->
-    Ast = aeso_parser:run_parser(aeso_parser:type(), String),
-    try aeso_ast_to_icode:ast_typerep(Ast) of
-        Type -> {ok, Type}
-    catch _:_ -> {error, bad_type}
-    end.
-
 -spec parse(string(), aeso_compiler:options()) -> none() | aeso_syntax:ast().
 parse(Text, Options) ->
     parse(Text, sets:new(), Options).

src/aeso_errors.erl

@@ -30,12 +30,16 @@
 
 -export([ err_msg/1
         , msg/1
+        , msg_oneline/1
         , new/2
         , new/3
         , new/4
+        , pos/1
         , pos/2
         , pos/3
         , pp/1
+        , pp_oneline/1
+        , pp_pos/1
         , to_json/1
         , throw/1
         , type/1
@@ -50,6 +54,12 @@ new(Type, Pos, Msg) ->
 new(Type, Pos, Msg, Ctxt) ->
     #err{ type = Type, pos = Pos, message = Msg, context = Ctxt }.
 
+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),
+    pos(File, Line, Col).
+
 pos(Line, Col) ->
     #pos{ line = Line, col = Col }.
 
@@ -65,10 +75,13 @@ throw(#err{} = Err) ->
     erlang:throw({error, [Err]}).
 
 msg(#err{ message = Msg, context = none }) -> Msg;
-msg(#err{ message = Msg, context = Ctxt }) -> Msg ++ Ctxt.
+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", [str_pos(Pos), msg(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]);
@@ -78,7 +91,12 @@ str_pos(#pos{file = F, line = L, col = C}) ->
 type(#err{ type = Type }) -> Type.
 
 pp(#err{ type = Kind, pos = Pos } = Err) ->
-    lists:flatten(io_lib:format("~s~s:\n~s", [pp_kind(Kind), pp_pos(Pos), msg(Err)])).
+    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";

src/aeso_fcode_to_fate.erl

@@ -9,7 +9,7 @@
 %%%-------------------------------------------------------------------
 -module(aeso_fcode_to_fate).
 
--export([compile/2, compile/3, term_to_fate/1, term_to_fate/2]).
+-export([compile/3, compile/4, term_to_fate/1, term_to_fate/2]).
 
 -ifdef(TEST).
 -export([optimize_fun/4, to_basic_blocks/1]).
@@ -45,7 +45,15 @@
 -define(s(N), {store, N}).
 -define(void, {var, 9999}).
 
--record(env, { contract, vars = [], locals = [], current_function, tailpos = true, child_contracts = #{}, options = []}).
+-record(env, { contract,
+               vars              = [],
+               locals            = [],
+               current_function,
+               tailpos           = true,
+               child_contracts   = #{},
+               saved_fresh_names = #{},
+               options           = [],
+               debug_info        = false }).
 
 %% -- Debugging --------------------------------------------------------------
 
@@ -64,21 +72,26 @@ debug(Tag, Options, Fun) ->
 
 -dialyzer({nowarn_function, [code_error/1]}).
 code_error(Err) ->
-    aeso_errors:throw(aeso_code_errors:format(Err)).
+    Pos = aeso_errors:pos(0, 0),
+    Msg = lists:flatten(io_lib:format("Unknown error: ~p\n", [Err])),
+    aeso_errors:throw(aeso_errors:new(code_error, Pos, Msg)).
 
 %% -- Main -------------------------------------------------------------------
 
 %% @doc Main entry point.
-compile(FCode, Options) ->
-    compile(#{}, FCode, Options).
-compile(ChildContracts, FCode, Options) ->
+compile(FCode, SavedFreshNames, Options) ->
+    compile(#{}, FCode, SavedFreshNames, Options).
+compile(ChildContracts, FCode, SavedFreshNames, Options) ->
     #{ contract_name := ContractName,
        functions     := Functions } = FCode,
-    SFuns  = functions_to_scode(ChildContracts, ContractName, Functions, Options),
+    SFuns  = functions_to_scode(ChildContracts, ContractName, Functions, SavedFreshNames, Options),
     SFuns1 = optimize_scode(SFuns, Options),
     FateCode = to_basic_blocks(SFuns1),
     ?debug(compile, Options, "~s\n", [aeb_fate_asm:pp(FateCode)]),
-    FateCode.
+    case proplists:get_value(include_child_contract_symbols, Options, false) of
+        false -> FateCode;
+        true  -> add_child_symbols(ChildContracts, FateCode)
+    end.
 
 make_function_id(X) ->
     aeb_fate_code:symbol_identifier(make_function_name(X)).
@@ -87,21 +100,31 @@ make_function_name(event)              -> <<"Chain.event">>;
 make_function_name({entrypoint, Name}) -> Name;
 make_function_name({local_fun, Xs})    -> list_to_binary("." ++ string:join(Xs, ".")).
 
-functions_to_scode(ChildContracts, ContractName, Functions, Options) ->
+add_child_symbols(ChildContracts, FateCode) ->
+    Funs = lists:flatten([ maps:keys(ChildFuns) || {_, #{functions := ChildFuns}} <- maps:to_list(ChildContracts) ]),
+    Symbols = maps:from_list([ {make_function_id(FName), make_function_name(FName)} || FName <- Funs ]),
+    aeb_fate_code:update_symbols(FateCode, Symbols).
+
+functions_to_scode(ChildContracts, ContractName, Functions, SavedFreshNames, Options) ->
     FunNames = maps:keys(Functions),
     maps:from_list(
-        [ {make_function_name(Name), function_to_scode(ChildContracts, ContractName, FunNames, Name, Attrs, Args, Body, Type, Options)}
+        [ {make_function_name(Name), function_to_scode(ChildContracts, ContractName, FunNames, Name, Attrs, Args, Body, Type, SavedFreshNames, Options)}
         || {Name, #{args   := Args,
                     body   := Body,
                     attrs  := Attrs,
                     return := Type}} <- maps:to_list(Functions)]).
 
-function_to_scode(ChildContracts, ContractName, Functions, Name, Attrs0, Args, Body, ResType, Options) ->
+function_to_scode(ChildContracts, ContractName, Functions, Name, Attrs0, Args, Body, ResType, SavedFreshNames, Options) ->
     {ArgTypes, ResType1} = typesig_to_scode(Args, ResType),
-    Attrs = Attrs0 -- [stateful], %% Only track private and payable from here.
-    Env = init_env(ChildContracts, ContractName, Functions, Name, Args, Options),
+    Attrs = [ A || A <- Attrs0, A == private orelse A == payable ],
+    Env = init_env(ChildContracts, ContractName, Functions, Name, Args, SavedFreshNames, Options),
+    ArgsNames = [ X || {X, _} <- lists:reverse(Env#env.vars) ],
+
+    %% DBG_LOC is added before the function body to make it possible to break
+    %% at the function signature
     SCode = to_scode(Env, Body),
-    {Attrs, {ArgTypes, ResType1}, SCode}.
+    DbgSCode = dbg_contract(Env) ++ dbg_loc(Env, Attrs0) ++ dbg_scoped_vars(Env, ArgsNames, SCode),
+    {Attrs, {ArgTypes, ResType1}, DbgSCode}.
 
 -define(tvars, '$tvars').
 
@@ -147,14 +170,16 @@ types_to_scode(Ts) -> lists:map(fun type_to_scode/1, Ts).
 
 %% -- Environment functions --
 
-init_env(ChildContracts, ContractName, FunNames, Name, Args, Options) ->
-    #env{ vars      = [ {X, {arg, I}} || {I, {X, _}} <- with_ixs(Args) ],
-          contract  = ContractName,
-          child_contracts = ChildContracts,
-          locals    = FunNames,
-          current_function = Name,
-          options = Options,
-          tailpos   = true }.
+init_env(ChildContracts, ContractName, FunNames, Name, Args, SavedFreshNames, Options) ->
+    #env{ vars              = [ {X, {arg, I}} || {I, {X, _}} <- with_ixs(Args) ],
+          contract          = ContractName,
+          child_contracts   = ChildContracts,
+          locals            = FunNames,
+          current_function  = Name,
+          options           = Options,
+          tailpos           = true,
+          saved_fresh_names = SavedFreshNames,
+          debug_info        = proplists:get_value(debug_info, Options, false) }.
 
 next_var(#env{ vars = Vars }) ->
     1 + lists:max([-1 | [J || {_, {var, J}} <- Vars]]).
@@ -176,20 +201,17 @@ lookup_var(#env{vars = Vars}, X) ->
 
 %% -- The compiler --
 
-lit_to_fate(Env, L) ->
-    case L of
-        {int, N}             -> aeb_fate_data:make_integer(N);
-        {string, S}          -> aeb_fate_data:make_string(S);
-        {bytes, B}           -> aeb_fate_data:make_bytes(B);
-        {bool, B}            -> aeb_fate_data:make_boolean(B);
-        {account_pubkey, K}  -> aeb_fate_data:make_address(K);
-        {contract_pubkey, K} -> aeb_fate_data:make_contract(K);
-        {oracle_pubkey, K}   -> aeb_fate_data:make_oracle(K);
-        {oracle_query_id, H} -> aeb_fate_data:make_oracle_query(H);
-        {contract_code, C}   ->
+serialize_contract_code(Env, C) ->
+    Cache = case get(contract_code_cache) of
+                undefined -> put(contract_code_cache, #{}), #{};
+                Res       -> Res
+            end,
+    case maps:get(C, Cache, none) of
+        none ->
             Options = Env#env.options,
-            FCode    = maps:get(C, Env#env.child_contracts),
-            FateCode = compile(Env#env.child_contracts, FCode, Options),
+            SavedFreshNames = Env#env.saved_fresh_names,
+            FCode = maps:get(C, Env#env.child_contracts),
+            FateCode = compile(Env#env.child_contracts, FCode, SavedFreshNames, Options),
             ByteCode = aeb_fate_code:serialize(FateCode, []),
             {ok, Version} = aeso_compiler:version(),
             OriginalSourceCode = proplists:get_value(original_src, Options, ""),
@@ -201,51 +223,66 @@ lit_to_fate(Env, L) ->
                      payable => maps:get(payable, FCode)
                    },
             Serialized = aeser_contract_code:serialize(Code),
-            aeb_fate_data:make_contract_bytearray(Serialized);
+            put(contract_code_cache, maps:put(C, Serialized, Cache)),
+            Serialized;
+        Serialized -> Serialized
+    end.
+
+lit_to_fate(Env, L) ->
+    case L of
+        {int, N}             -> aeb_fate_data:make_integer(N);
+        {string, S}          -> aeb_fate_data:make_string(S);
+        {bytes, B}           -> aeb_fate_data:make_bytes(B);
+        {bool, B}            -> aeb_fate_data:make_boolean(B);
+        {account_pubkey, K}  -> aeb_fate_data:make_address(K);
+        {contract_pubkey, K} -> aeb_fate_data:make_contract(K);
+        {oracle_pubkey, K}   -> aeb_fate_data:make_oracle(K);
+        {oracle_query_id, H} -> aeb_fate_data:make_oracle_query(H);
+        {contract_code, C}   -> aeb_fate_data:make_contract_bytearray(serialize_contract_code(Env, C));
         {typerep, T}         -> aeb_fate_data:make_typerep(type_to_scode(T))
      end.
 
 term_to_fate(E) -> term_to_fate(#env{}, #{}, E).
 term_to_fate(GlobEnv, E) -> term_to_fate(GlobEnv, #{}, E).
 
-term_to_fate(GlobEnv, _Env, {lit, L}) ->
+term_to_fate(GlobEnv, _Env, {lit, _, L}) ->
     lit_to_fate(GlobEnv, L);
 %% negative literals are parsed as 0 - N
-term_to_fate(_GlobEnv, _Env, {op, '-', [{lit, {int, 0}}, {lit, {int, N}}]}) ->
+term_to_fate(_GlobEnv, _Env, {op, _, '-', [{lit, _, {int, 0}}, {lit, _, {int, N}}]}) ->
     aeb_fate_data:make_integer(-N);
-term_to_fate(_GlobEnv, _Env, nil) ->
+term_to_fate(_GlobEnv, _Env, {nil, _}) ->
     aeb_fate_data:make_list([]);
-term_to_fate(GlobEnv, Env, {op, '::', [Hd, Tl]}) ->
+term_to_fate(GlobEnv, Env, {op, _, '::', [Hd, Tl]}) ->
     %% The Tl will translate into a list, because FATE lists are just lists
     [term_to_fate(GlobEnv, Env, Hd) | term_to_fate(GlobEnv, Env, Tl)];
-term_to_fate(GlobEnv, Env, {tuple, As}) ->
+term_to_fate(GlobEnv, Env, {tuple, _, As}) ->
     aeb_fate_data:make_tuple(list_to_tuple([ term_to_fate(GlobEnv, Env, A) || A<-As]));
-term_to_fate(GlobEnv, Env, {con, Ar, I, As}) ->
+term_to_fate(GlobEnv, Env, {con, _, Ar, I, As}) ->
     FateAs = [ term_to_fate(GlobEnv, Env, A) || A <- As ],
     aeb_fate_data:make_variant(Ar, I, list_to_tuple(FateAs));
-term_to_fate(_GlobEnv, _Env, {builtin, bits_all, []}) ->
+term_to_fate(_GlobEnv, _Env, {builtin, _, bits_all, []}) ->
     aeb_fate_data:make_bits(-1);
-term_to_fate(_GlobEnv, _Env, {builtin, bits_none, []}) ->
+term_to_fate(_GlobEnv, _Env, {builtin, _, bits_none, []}) ->
     aeb_fate_data:make_bits(0);
-term_to_fate(GlobEnv, _Env, {op, bits_set, [B, I]}) ->
+term_to_fate(GlobEnv, _Env, {op, _, bits_set, [B, I]}) ->
     {bits, N} = term_to_fate(GlobEnv, B),
     J         = term_to_fate(GlobEnv, I),
     {bits, N bor (1 bsl J)};
-term_to_fate(GlobEnv, _Env, {op, bits_clear, [B, I]}) ->
+term_to_fate(GlobEnv, _Env, {op, _, bits_clear, [B, I]}) ->
     {bits, N} = term_to_fate(GlobEnv, B),
     J         = term_to_fate(GlobEnv, I),
     {bits, N band bnot (1 bsl J)};
-term_to_fate(GlobEnv, Env, {'let', X, E, Body}) ->
+term_to_fate(GlobEnv, Env, {'let', _, X, E, Body}) ->
     Env1 = Env#{ X => term_to_fate(GlobEnv, Env, E) },
     term_to_fate(GlobEnv, Env1, Body);
-term_to_fate(_GlobEnv, Env, {var, X}) ->
+term_to_fate(_GlobEnv, Env, {var, _, X}) ->
     case maps:get(X, Env, undefined) of
         undefined -> throw(not_a_fate_value);
         V         -> V
     end;
-term_to_fate(_GlobEnv, _Env, {builtin, map_empty, []}) ->
+term_to_fate(_GlobEnv, _Env, {builtin, _, map_empty, []}) ->
     aeb_fate_data:make_map(#{});
-term_to_fate(GlobEnv, Env, {op, map_set, [M, K, V]}) ->
+term_to_fate(GlobEnv, Env, {op, _, map_set, [M, K, V]}) ->
     Map = term_to_fate(GlobEnv, Env, M),
     Map#{term_to_fate(GlobEnv, Env, K) => term_to_fate(GlobEnv, Env, V)};
 term_to_fate(_GlobEnv, _Env, _) ->
@@ -253,52 +290,59 @@ term_to_fate(_GlobEnv, _Env, _) ->
 
 to_scode(Env, T) ->
     try term_to_fate(Env, T) of
-        V -> [push(?i(V))]
+        V ->
+            FAnn = element(2, T),
+            [dbg_loc(Env, FAnn), push(?i(V))]
     catch throw:not_a_fate_value ->
         to_scode1(Env, T)
     end.
 
-to_scode1(Env, {lit, L}) ->
-    [push(?i(lit_to_fate(Env, L)))];
+to_scode1(Env, {lit, Ann, L}) ->
+    [ dbg_loc(Env, Ann), push(?i(lit_to_fate(Env, L))) ];
 
-to_scode1(_Env, nil) ->
-    [aeb_fate_ops:nil(?a)];
+to_scode1(Env, {nil, Ann}) ->
+    [ dbg_loc(Env, Ann), aeb_fate_ops:nil(?a) ];
 
-to_scode1(Env, {var, X}) ->
-    [push(lookup_var(Env, X))];
+to_scode1(Env, {var, Ann, X}) ->
+    [ dbg_loc(Env, Ann), push(lookup_var(Env, X)) ];
 
-to_scode1(Env, {con, Ar, I, As}) ->
+to_scode1(Env, {con, Ann, Ar, I, As}) ->
     N = length(As),
-    [[to_scode(notail(Env), A) || A <- As],
-     aeb_fate_ops:variant(?a, ?i(Ar), ?i(I), ?i(N))];
+    [ dbg_loc(Env, Ann),
+      [to_scode(notail(Env), A) || A <- As],
+      aeb_fate_ops:variant(?a, ?i(Ar), ?i(I), ?i(N)) ];
 
-to_scode1(Env, {tuple, As}) ->
+to_scode1(Env, {tuple, Ann, As}) ->
     N = length(As),
-    [[ to_scode(notail(Env), A) || A <- As ],
-     tuple(N)];
+    [ dbg_loc(Env, Ann),
+      [ to_scode(notail(Env), A) || A <- As ],
+      tuple(N) ];
 
-to_scode1(Env, {proj, E, I}) ->
-    [to_scode(notail(Env), E),
-     aeb_fate_ops:element_op(?a, ?i(I), ?a)];
+to_scode1(Env, {proj, Ann, E, I}) ->
+    [ dbg_loc(Env, Ann),
+      to_scode(notail(Env), E),
+      aeb_fate_ops:element_op(?a, ?i(I), ?a) ];
 
-to_scode1(Env, {set_proj, R, I, E}) ->
-    [to_scode(notail(Env), E),
-     to_scode(notail(Env), R),
-     aeb_fate_ops:setelement(?a, ?i(I), ?a, ?a)];
+to_scode1(Env, {set_proj, Ann, R, I, E}) ->
+    [ dbg_loc(Env, Ann),
+      to_scode(notail(Env), E),
+      to_scode(notail(Env), R),
+      aeb_fate_ops:setelement(?a, ?i(I), ?a, ?a) ];
 
-to_scode1(Env, {op, Op, Args}) ->
-    call_to_scode(Env, op_to_scode(Op), Args);
+to_scode1(Env, {op, Ann, Op, Args}) ->
+    [ dbg_loc(Env, Ann) | call_to_scode(Env, op_to_scode(Op), Args) ];
 
-to_scode1(Env, {'let', X, {var, Y}, Body}) ->
+to_scode1(Env, {'let', Ann, X, {var, _, Y}, Body}) ->
     Env1 = bind_var(X, lookup_var(Env, Y), Env),
-    to_scode(Env1, Body);
-to_scode1(Env, {'let', X, Expr, Body}) ->
+    [ dbg_loc(Env, Ann) | dbg_scoped_vars(Env1, [X], to_scode(Env1, Body)) ];
+to_scode1(Env, {'let', Ann, X, Expr, Body}) ->
     {I, Env1} = bind_local(X, Env),
-    [ to_scode(notail(Env), Expr),
-      aeb_fate_ops:store({var, I}, {stack, 0}),
-      to_scode(Env1, Body) ];
+    SCode = [ to_scode(notail(Env), Expr),
+              aeb_fate_ops:store({var, I}, {stack, 0}),
+              to_scode(Env1, Body) ],
+    [ dbg_loc(Env, Ann) | dbg_scoped_vars(Env1, [X], SCode) ];
 
-to_scode1(Env = #env{ current_function = Fun, tailpos = true }, {def, Fun, Args}) ->
+to_scode1(Env = #env{ current_function = Fun, tailpos = true, debug_info = false }, {def, Ann, Fun, Args}) ->
     %% Tail-call to current function, f(e0..en). Compile to
     %%      [ let xi = ei ]
     %%      [ STORE argi xi ]
@@ -311,61 +355,62 @@ to_scode1(Env = #env{ current_function = Fun, tailpos = true }, {def, Fun, Args}
                                 aeb_fate_ops:store({var, I}, ?a)],
                         {[I | Is], Acc1, Env2}
                     end, {[], [], Env}, Args),
-    [ Code,
+    [ dbg_loc(Env, Ann),
+      Code,
       [ aeb_fate_ops:store({arg, I}, {var, J})
         || {I, J} <- lists:zip(lists:seq(0, length(Vars) - 1),
                                lists:reverse(Vars)) ],
       loop ];
-to_scode1(Env, {def, Fun, Args}) ->
+to_scode1(Env, {def, Ann, Fun, Args}) ->
     FName = make_function_id(Fun),
     Lbl   = aeb_fate_data:make_string(FName),
-    call_to_scode(Env, local_call(Env, ?i(Lbl)), Args);
-to_scode1(Env, {funcall, Fun, Args}) ->
-    call_to_scode(Env, [to_scode(Env, Fun), local_call(Env, ?a)], Args);
+    [ dbg_loc(Env, Ann) | call_to_scode(Env, local_call(Env, ?i(Lbl)), Args) ];
+to_scode1(Env, {funcall, Ann, Fun, Args}) ->
+    [ dbg_loc(Env, Ann) | call_to_scode(Env, [to_scode(Env, Fun), local_call(Env, ?a)], Args) ];
 
-to_scode1(Env, {builtin, B, Args}) ->
-    builtin_to_scode(Env, B, Args);
+to_scode1(Env, {builtin, Ann, B, Args}) ->
+    [ dbg_loc(Env, Ann) | builtin_to_scode(Env, B, Args) ];
 
-to_scode1(Env, {remote, ArgsT, RetT, Ct, Fun, [Gas, Value, Protected | Args]}) ->
+to_scode1(Env, {remote, Ann, ArgsT, RetT, Ct, Fun, [Gas, Value, Protected | Args]}) ->
     Lbl = make_function_id(Fun),
     {ArgTypes, RetType0} = typesig_to_scode([{"_", T} || T <- ArgsT], RetT),
     ArgType = ?i(aeb_fate_data:make_typerep({tuple, ArgTypes})),
     RetType = ?i(aeb_fate_data:make_typerep(RetType0)),
-    case Protected of
-        {lit, {bool, false}} ->
+    SCode = case Protected of
+        {lit, _, {bool, false}} ->
             case Gas of
-                {builtin, call_gas_left, _} ->
+                {builtin, _, call_gas_left, _} ->
                     Call = aeb_fate_ops:call_r(?a, Lbl, ArgType, RetType, ?a),
                     call_to_scode(Env, Call, [Ct, Value | Args]);
                 _ ->
                     Call = aeb_fate_ops:call_gr(?a, Lbl, ArgType, RetType, ?a, ?a),
                     call_to_scode(Env, Call, [Ct, Value, Gas | Args])
             end;
-        {lit, {bool, true}} ->
+        {lit, _, {bool, true}} ->
             Call = aeb_fate_ops:call_pgr(?a, Lbl, ArgType, RetType, ?a, ?a, ?i(true)),
             call_to_scode(Env, Call, [Ct, Value, Gas | Args]);
         _ ->
             Call = aeb_fate_ops:call_pgr(?a, Lbl, ArgType, RetType, ?a, ?a, ?a),
             call_to_scode(Env, Call, [Ct, Value, Gas, Protected | Args])
-    end;
+    end,
+    [ dbg_loc(Env, Ann) | SCode ];
 
-to_scode1(_Env, {get_state, Reg}) ->
-    [push(?s(Reg))];
-to_scode1(Env, {set_state, Reg, Val}) ->
-    call_to_scode(Env, [{'STORE', ?s(Reg), ?a},
-                        tuple(0)], [Val]);
+to_scode1(Env, {get_state, Ann, Reg}) ->
+    [ dbg_loc(Env, Ann), push(?s(Reg)) ];
+to_scode1(Env, {set_state, Ann, Reg, Val}) ->
+    [ dbg_loc(Env, Ann) | call_to_scode(Env, [{'STORE', ?s(Reg), ?a}, tuple(0)], [Val]) ];
 
-to_scode1(Env, {closure, Fun, FVs}) ->
-    to_scode(Env, {tuple, [{lit, {string, make_function_id(Fun)}}, FVs]});
+to_scode1(Env, {closure, Ann, Fun, FVs}) ->
+    [ to_scode(Env, {tuple, Ann, [{lit, Ann, {string, make_function_id(Fun)}}, FVs]}) ];
 
-to_scode1(Env, {switch, Case}) ->
-    split_to_scode(Env, Case).
+to_scode1(Env, {switch, Ann, Case}) ->
+    [ dbg_loc(Env, Ann) | split_to_scode(Env, Case) ].
 
-local_call( Env, Fun) when Env#env.tailpos -> aeb_fate_ops:call_t(Fun);
-local_call(_Env, Fun)                      -> aeb_fate_ops:call(Fun).
+local_call( Env = #env{debug_info = false}, Fun) when Env#env.tailpos -> aeb_fate_ops:call_t(Fun);
+local_call(_Env, Fun)                                                 -> aeb_fate_ops:call(Fun).
 
-split_to_scode(Env, {nosplit, Expr}) ->
-    [switch_body, to_scode(Env, Expr)];
+split_to_scode(Env, {nosplit, Renames, Expr}) ->
+    [switch_body, dbg_scoped_vars(Env, Renames, to_scode(Env, Expr))];
 split_to_scode(Env, {split, {tuple, _}, X, Alts}) ->
     {Def, Alts1} = catchall_to_scode(Env, X, Alts),
     Arg = lookup_var(Env, X),
@@ -494,8 +539,18 @@ builtin_to_scode(Env, bytes_concat, [_, _] = Args) ->
     call_to_scode(Env, aeb_fate_ops:bytes_concat(?a, ?a, ?a), Args);
 builtin_to_scode(Env, bytes_split, [_, _] = Args) ->
     call_to_scode(Env, aeb_fate_ops:bytes_split(?a, ?a, ?a), Args);
+builtin_to_scode(Env, bytes_split_any, [_, _] = Args) ->
+    call_to_scode(Env, aeb_fate_ops:bytes_split_any(?a, ?a, ?a), Args);
+builtin_to_scode(Env, bytes_to_fixed_size, [_, _] = Args) ->
+    call_to_scode(Env, aeb_fate_ops:bytes_to_fixed_size(?a, ?a, ?a), Args);
+builtin_to_scode(Env, bytes_to_any_size, [A]) ->
+    [to_scode(Env, A)]; %% no_op!
+builtin_to_scode(Env, bytes_size, [_] = Args) ->
+    call_to_scode(Env, aeb_fate_ops:bytes_size(?a, ?a), Args);
 builtin_to_scode(Env, abort, [_] = Args) ->
     call_to_scode(Env, aeb_fate_ops:abort(?a), Args);
+builtin_to_scode(Env, exit, [_] = Args) ->
+    call_to_scode(Env, aeb_fate_ops:exit(?a), Args);
 builtin_to_scode(Env, chain_spend, [_, _] = Args) ->
     call_to_scode(Env, [aeb_fate_ops:spend(?a, ?a),
                         tuple(0)], Args);
@@ -513,6 +568,8 @@ builtin_to_scode(_Env, chain_difficulty, []) ->
     [aeb_fate_ops:difficulty(?a)];
 builtin_to_scode(_Env, chain_gas_limit, []) ->
     [aeb_fate_ops:gaslimit(?a)];
+builtin_to_scode(_Env, chain_network_id, []) ->
+    [aeb_fate_ops:network_id(?a)];
 builtin_to_scode(_Env, contract_balance, []) ->
     [aeb_fate_ops:balance(?a)];
 builtin_to_scode(_Env, contract_address, []) ->
@@ -587,7 +644,7 @@ builtin_to_scode(Env, chain_bytecode_hash, [_Addr] = Args) ->
 builtin_to_scode(Env, chain_clone,
                  [InitArgsT, GasCap, Value, Prot, Contract | InitArgs]) ->
     case GasCap of
-        {builtin, call_gas_left, _} ->
+        {builtin, _, call_gas_left, _} ->
             call_to_scode(Env, aeb_fate_ops:clone(?a, ?a, ?a, ?a),
                           [Contract, InitArgsT, Value, Prot | InitArgs]
                          );
@@ -620,6 +677,12 @@ op_to_scode('>=')              -> aeb_fate_ops:egt(?a, ?a, ?a);
 op_to_scode('==')              -> aeb_fate_ops:eq(?a, ?a, ?a);
 op_to_scode('!=')              -> aeb_fate_ops:neq(?a, ?a, ?a);
 op_to_scode('!')               -> aeb_fate_ops:not_op(?a, ?a);
+op_to_scode('bnot')            -> aeb_fate_ops:bin_not(?a, ?a);
+op_to_scode('band')            -> aeb_fate_ops:bin_and(?a, ?a, ?a);
+op_to_scode('bor')             -> aeb_fate_ops:bin_or(?a, ?a, ?a);
+op_to_scode('bxor')            -> aeb_fate_ops:bin_xor(?a, ?a, ?a);
+op_to_scode('<<')              -> aeb_fate_ops:bin_sl(?a, ?a, ?a);
+op_to_scode('>>')              -> aeb_fate_ops:bin_sr(?a, ?a, ?a);
 op_to_scode(map_get)           -> aeb_fate_ops:map_lookup(?a, ?a, ?a);
 op_to_scode(map_get_d)         -> aeb_fate_ops:map_lookup(?a, ?a, ?a, ?a);
 op_to_scode(map_set)           -> aeb_fate_ops:map_update(?a, ?a, ?a, ?a);
@@ -630,6 +693,7 @@ op_to_scode(map_member)        -> aeb_fate_ops:map_member(?a, ?a, ?a);
 op_to_scode(map_size)          -> aeb_fate_ops:map_size_(?a, ?a);
 op_to_scode(stringinternal_length)    -> aeb_fate_ops:str_length(?a, ?a);
 op_to_scode(stringinternal_concat)    -> aeb_fate_ops:str_join(?a, ?a, ?a);
+op_to_scode(stringinternal_to_bytes)  -> aeb_fate_ops:str_to_bytes(?a, ?a);
 op_to_scode(stringinternal_to_list)   -> aeb_fate_ops:str_to_list(?a, ?a);
 op_to_scode(stringinternal_from_list) -> aeb_fate_ops:str_from_list(?a, ?a);
 op_to_scode(stringinternal_to_lower)  -> aeb_fate_ops:str_to_lower(?a, ?a);
@@ -644,7 +708,10 @@ op_to_scode(bits_intersection) -> aeb_fate_ops:bits_and(?a, ?a, ?a);
 op_to_scode(bits_union)        -> aeb_fate_ops:bits_or(?a, ?a, ?a);
 op_to_scode(bits_difference)   -> aeb_fate_ops:bits_diff(?a, ?a, ?a);
 op_to_scode(address_to_str)    -> aeb_fate_ops:addr_to_str(?a, ?a);
+op_to_scode(address_to_bytes)  -> aeb_fate_ops:addr_to_bytes(?a, ?a);
 op_to_scode(int_to_str)        -> aeb_fate_ops:int_to_str(?a, ?a);
+op_to_scode(int_to_bytes)      -> aeb_fate_ops:int_to_bytes(?a, ?a, ?a);
+op_to_scode(int_mulmod)        -> aeb_fate_ops:mulmod(?a, ?a, ?a, ?a);
 op_to_scode(contract_to_address)         -> aeb_fate_ops:contract_to_address(?a, ?a);
 op_to_scode(address_to_contract)         -> aeb_fate_ops:address_to_contract(?a, ?a);
 op_to_scode(crypto_verify_sig)           -> aeb_fate_ops:verify_sig(?a, ?a, ?a, ?a);
@@ -654,6 +721,7 @@ op_to_scode(crypto_ecrecover_secp256k1)  -> aeb_fate_ops:ecrecover_secp256k1(?a,
 op_to_scode(crypto_sha3)                 -> aeb_fate_ops:sha3(?a, ?a);
 op_to_scode(crypto_sha256)               -> aeb_fate_ops:sha256(?a, ?a);
 op_to_scode(crypto_blake2b)              -> aeb_fate_ops:blake2b(?a, ?a);
+op_to_scode(crypto_poseidon)             -> aeb_fate_ops:poseidon(?a, ?a, ?a);
 op_to_scode(stringinternal_sha3)         -> aeb_fate_ops:sha3(?a, ?a);
 op_to_scode(stringinternal_sha256)       -> aeb_fate_ops:sha256(?a, ?a);
 op_to_scode(stringinternal_blake2b)      -> aeb_fate_ops:blake2b(?a, ?a);
@@ -689,12 +757,83 @@ push(A) -> {'STORE', ?a, A}.
 tuple(0) -> push(?i({tuple, {}}));
 tuple(N) -> aeb_fate_ops:tuple(?a, N).
 
+%% -- Debug info functions --
+
+dbg_contract(#env{debug_info = false}) ->
+    [];
+dbg_contract(#env{contract = Contract}) ->
+    [{'DBG_CONTRACT', {immediate, Contract}}].
+
+dbg_loc(#env{debug_info = false}, _) ->
+    [];
+dbg_loc(_Env, Ann) ->
+    File = case proplists:get_value(file, Ann, no_file) of
+                no_file -> "";
+                F       -> F
+            end,
+    Line = proplists:get_value(line, Ann, undefined),
+    case Line of
+        undefined -> [];
+        _         -> [{'DBG_LOC', {immediate, File}, {immediate, Line}}]
+    end.
+
+dbg_scoped_vars(#env{debug_info = false}, _, SCode) ->
+    SCode;
+dbg_scoped_vars(_Env, [], SCode) ->
+    SCode;
+dbg_scoped_vars(Env, [{SavedVarName, Var} | Rest], SCode) ->
+    dbg_scoped_vars(Env, Rest, dbg_scoped_var(Env, SavedVarName, Var, SCode));
+dbg_scoped_vars(Env = #env{saved_fresh_names = SavedFreshNames}, [Var | Rest], SCode) ->
+    SavedVarName = maps:get(Var, SavedFreshNames, Var),
+    dbg_scoped_vars(Env, Rest, dbg_scoped_var(Env, SavedVarName, Var, SCode)).
+
+dbg_scoped_var(Env, SavedVarName, Var, SCode) ->
+    case SavedVarName == "_" orelse is_fresh_name(SavedVarName) of
+        true ->
+            SCode;
+        false ->
+            Register = lookup_var(Env, Var),
+            Def      = [{'DBG_DEF',   {immediate, SavedVarName}, Register}],
+            Undef    = [{'DBG_UNDEF', {immediate, SavedVarName}, Register}],
+            Def ++ dbg_undef(Undef, SCode)
+    end.
+
+is_fresh_name([$% | _]) ->
+    true;
+is_fresh_name(_) ->
+    false.
+
+dbg_undef(_Undef, missing) ->
+    missing;
+dbg_undef(Undef, loop) ->
+    [Undef, loop];
+dbg_undef(Undef, switch_body) ->
+    [switch_body, Undef];
+dbg_undef(Undef, {switch, Arg, Type, Alts, Catch}) ->
+    NewAlts   = [ dbg_undef(Undef, Alt) || Alt <- Alts ],
+    NewCatch  = dbg_undef(Undef, Catch),
+    NewSwitch = {switch, Arg, Type, NewAlts, NewCatch},
+    NewSwitch;
+dbg_undef(Undef, SCode) when is_list(SCode) ->
+    lists:droplast(SCode) ++ [dbg_undef(Undef, lists:last(SCode))];
+dbg_undef(Undef, SCode) when is_tuple(SCode); is_atom(SCode) ->
+    [Mnemonic | _] =
+        case is_tuple(SCode) of
+            true  -> tuple_to_list(SCode);
+            false -> [SCode]
+        end,
+    Op = aeb_fate_opcodes:m_to_op(Mnemonic),
+    case aeb_fate_opcodes:end_bb(Op) of
+        true  -> [Undef, SCode];
+        false -> [SCode, Undef]
+    end.
+
 %% -- Phase II ---------------------------------------------------------------
 %%  Optimize
 
 optimize_scode(Funs, Options) ->
     maps:map(fun(Name, Def) -> optimize_fun(Funs, Name, Def, Options) end,
-             Funs).
+            Funs).
 
 flatten(missing) -> missing;
 flatten(Code)    -> lists:map(fun flatten_s/1, lists:flatten(Code)).
@@ -824,6 +963,10 @@ attributes(I) ->
         loop                                  -> Impure(pc, []);
         switch_body                           -> Pure(none, []);
         'RETURN'                              -> Impure(pc, []);
+        {'DBG_LOC', _, _}                     -> Impure(none, []);
+        {'DBG_DEF', _, _}                     -> Impure(none, []);
+        {'DBG_UNDEF', _, _}                   -> Impure(none, []);
+        {'DBG_CONTRACT', _}                   -> Impure(none, []);
         {'RETURNR', A}                        -> Impure(pc, A);
         {'CALL', A}                           -> Impure(?a, [A]);
         {'CALL_R', A, _, B, C, D}             -> Impure(?a, [A, B, C, D]);
@@ -851,6 +994,13 @@ attributes(I) ->
         {'DIV', A, B, C}                      -> Pure(A, [B, C]);
         {'MOD', A, B, C}                      -> Pure(A, [B, C]);
         {'POW', A, B, C}                      -> Pure(A, [B, C]);
+        {'MULMOD', A, B, C, D}                -> Pure(A, [B, C, D]);
+        {'BAND', A, B, C}                     -> Pure(A, [B, C]);
+        {'BOR', A, B, C}                      -> Pure(A, [B, C]);
+        {'BXOR', A, B, C}                     -> Pure(A, [B, C]);
+        {'BNOT', A, B}                        -> Pure(A, [B]);
+        {'BSL', A, B, C}                      -> Pure(A, [B, C]);
+        {'BSR', A, B, C}                      -> Pure(A, [B, C]);
         {'LT', A, B, C}                       -> Pure(A, [B, C]);
         {'GT', A, B, C}                       -> Pure(A, [B, C]);
         {'EQ', A, B, C}                       -> Pure(A, [B, C]);
@@ -881,9 +1031,11 @@ attributes(I) ->
         {'APPEND', A, B, C}                   -> Pure(A, [B, C]);
         {'STR_JOIN', A, B, C}                 -> Pure(A, [B, C]);
         {'INT_TO_STR', A, B}                  -> Pure(A, B);
+        {'INT_TO_BYTES', A, B, C}             -> Pure(A, [B, C]);
         {'ADDR_TO_STR', A, B}                 -> Pure(A, B);
         {'STR_REVERSE', A, B}                 -> Pure(A, B);
         {'STR_LENGTH', A, B}                  -> Pure(A, B);
+        {'STR_TO_BYTES', A, B}                -> Pure(A, B);
         {'INT_TO_ADDR', A, B}                 -> Pure(A, B);
         {'VARIANT', A, B, C, D}               -> Pure(A, [?a, B, C, D]);
         {'VARIANT_TEST', A, B, C}             -> Pure(A, [B, C]);
@@ -903,18 +1055,23 @@ attributes(I) ->
         {'SHA3', A, B}                        -> Pure(A, [B]);
         {'SHA256', A, B}                      -> Pure(A, [B]);
         {'BLAKE2B', A, B}                     -> Pure(A, [B]);
+        {'POSEIDON', A, B, C}                 -> Pure(A, [B, C]);
         {'VERIFY_SIG', A, B, C, D}            -> Pure(A, [B, C, D]);
         {'VERIFY_SIG_SECP256K1', A, B, C, D}  -> Pure(A, [B, C, D]);
         {'ECVERIFY_SECP256K1', A, B, C, D}    -> Pure(A, [B, C, D]);
         {'ECRECOVER_SECP256K1', A, B, C}      -> Pure(A, [B, C]);
         {'CONTRACT_TO_ADDRESS', A, B}         -> Pure(A, [B]);
         {'ADDRESS_TO_CONTRACT', A, B}         -> Pure(A, [B]);
+        {'ADDRESS_TO_BYTES', A, B}            -> Pure(A, [B]);
         {'AUTH_TX_HASH', A}                   -> Pure(A, []);
         {'AUTH_TX', A}                        -> Pure(A, []);
         {'BYTES_TO_INT', A, B}                -> Pure(A, [B]);
         {'BYTES_TO_STR', A, B}                -> Pure(A, [B]);
         {'BYTES_CONCAT', A, B, C}             -> Pure(A, [B, C]);
         {'BYTES_SPLIT', A, B, C}              -> Pure(A, [B, C]);
+        {'BYTES_SPLIT_ANY', A, B, C}          -> Pure(A, [B, C]);
+        {'BYTES_SIZE', A, B}                  -> Pure(A, B);
+        {'BYTES_TO_FIXED_SIZE', A, B, C}      -> Pure(A, [B, C]);
         {'ORACLE_CHECK', A, B, C, D}          -> Pure(A, [B, C, D]);
         {'ORACLE_CHECK_QUERY', A, B, C, D, E} -> Pure(A, [B, C, D, E]);
         {'IS_ORACLE', A, B}                   -> Pure(A, [B]);
@@ -935,6 +1092,7 @@ attributes(I) ->
         {'MICROBLOCK', A}                     -> Pure(A, []);
         {'DIFFICULTY', A}                     -> Pure(A, []);
         {'GASLIMIT', A}                       -> Pure(A, []);
+        {'NETWORK_ID', A}                     -> Pure(A, []);
         {'GAS', A}                            -> Pure(A, []);
         {'LOG0', A}                           -> Impure(none, [A]);
         {'LOG1', A, B}                        -> Impure(none, [A, B]);
@@ -1077,7 +1235,8 @@ simpl_top(I, Code, Options) ->
 simpl_top(0, I, Code, _Options) ->
     code_error({optimizer_out_of_fuel, I, Code});
 simpl_top(Fuel, I, Code, Options) ->
-    apply_rules(Fuel, rules(), I, Code, Options).
+    Rules = [R || R = {Rule, _} <- rules(), proplists:get_value(Rule, Options, true)],
+    apply_rules(Fuel, Rules, I, Code, Options).
 
 apply_rules(Fuel, Rules, I, Code, Options) ->
     Cons = fun(X, Xs) -> simpl_top(Fuel - 1, X, Xs, Options) end,
@@ -1104,29 +1263,29 @@ apply_rules_once([{RName, Rule} | Rules], I, Code) ->
 -define(RULE(Name), {Name, fun Name/2}).
 
 merge_rules() ->
-    [?RULE(r_push_consume),
-     ?RULE(r_one_shot_var),
-     ?RULE(r_write_to_dead_var),
-     ?RULE(r_inline_switch_target)
+    [?RULE(optimize_push_consume),
+     ?RULE(optimize_one_shot_var),
+     ?RULE(optimize_write_to_dead_var),
+     ?RULE(optimize_inline_switch_target)
     ].
 
 rules() ->
     merge_rules() ++
-    [?RULE(r_swap_push),
-     ?RULE(r_swap_pop),
-     ?RULE(r_swap_write),
-     ?RULE(r_constant_propagation),
-     ?RULE(r_prune_impossible_branches),
-     ?RULE(r_single_successful_branch),
-     ?RULE(r_inline_store),
-     ?RULE(r_float_switch_body)
+    [?RULE(optimize_swap_push),
+     ?RULE(optimize_swap_pop),
+     ?RULE(optimize_swap_write),
+     ?RULE(optimize_constant_propagation),
+     ?RULE(optimize_prune_impossible_branches),
+     ?RULE(optimize_single_successful_branch),
+     ?RULE(optimize_inline_store),
+     ?RULE(optimize_float_switch_body)
     ].
 
 %% Removing pushes that are immediately consumed.
-r_push_consume({i, Ann1, {'STORE', ?a, A}}, Code) ->
+optimize_push_consume({i, Ann1, {'STORE', ?a, A}}, Code) ->
     inline_push(Ann1, A, 0, Code, []);
 %% Writing directly to memory instead of going through the accumulator.
-r_push_consume({i, Ann1, I}, [{i, Ann2, {'STORE', R, ?a}} | Code]) ->
+optimize_push_consume({i, Ann1, I}, [{i, Ann2, {'STORE', R, ?a}} | Code]) ->
     IsPush =
         case op_view(I) of
             {_, ?a, _} -> true;
@@ -1138,7 +1297,7 @@ r_push_consume({i, Ann1, I}, [{i, Ann2, {'STORE', R, ?a}} | Code]) ->
         end,
     if IsPush -> {[{i, merge_ann(Ann1, Ann2), setelement(2, I, R)}], Code};
        true   -> false end;
-r_push_consume(_, _) -> false.
+optimize_push_consume(_, _) -> false.
 
 inline_push(Ann, Arg, Stack, [{i, _, switch_body} = AI | Code], Acc) ->
     {AI1, {i, Ann1, _}} = swap_instrs({i, Ann, {'STORE', ?a, Arg}}, AI),
@@ -1171,7 +1330,7 @@ split_stack_arg(N, [A | As], Acc) ->
     split_stack_arg(N1, As, [A | Acc]).
 
 %% Move PUSHes past non-stack instructions.
-r_swap_push(Push = {i, _, PushI}, [I | Code]) ->
+optimize_swap_push(Push = {i, _, PushI}, [I | Code]) ->
     case op_view(PushI) of
         {_, ?a, _} ->
             case independent(Push, I) of
@@ -1182,10 +1341,10 @@ r_swap_push(Push = {i, _, PushI}, [I | Code]) ->
             end;
         _ -> false
     end;
-r_swap_push(_, _) -> false.
+optimize_swap_push(_, _) -> false.
 
 %% Move non-stack instruction past POPs.
-r_swap_pop(IA = {i, _, I}, [JA = {i, _, J} | Code]) ->
+optimize_swap_pop(IA = {i, _, I}, [JA = {i, _, J} | Code]) ->
     case independent(IA, JA) of
         true ->
             case {op_view(I), op_view(J)} of
@@ -1193,7 +1352,7 @@ r_swap_pop(IA = {i, _, I}, [JA = {i, _, J} | Code]) ->
                 {_, false} -> false;
                 {{_, IR, IAs}, {_, RJ, JAs}} ->
                     NonStackI = not lists:member(?a, [IR | IAs]),
-                    %% RJ /= ?a to not conflict with r_swap_push
+                    %% RJ /= ?a to not conflict with optimize_swap_push
                     PopJ      = RJ /= ?a andalso lists:member(?a, JAs),
                     case NonStackI andalso PopJ of
                         false -> false;
@@ -1204,22 +1363,22 @@ r_swap_pop(IA = {i, _, I}, [JA = {i, _, J} | Code]) ->
             end;
         false -> false
     end;
-r_swap_pop(_, _) -> false.
+optimize_swap_pop(_, _) -> false.
 
 %% Match up writes to variables with instructions further down.
-r_swap_write(I = {i, _, _}, [J | Code]) ->
+optimize_swap_write(I = {i, _, _}, [J | Code]) ->
     case {var_writes(I), independent(I, J)} of
         {[_], true} ->
             {J1, I1} = swap_instrs(I, J),
-            r_swap_write([J1], I1, Code);
+            optimize_swap_write([J1], I1, Code);
         _ -> false
     end;
-r_swap_write(_, _) -> false.
+optimize_swap_write(_, _) -> false.
 
-r_swap_write(Pre, I, [{i, _, switch_body} = J | Code]) ->
+optimize_swap_write(Pre, I, [{i, _, switch_body} = J | Code]) ->
     {J1, I1} = swap_instrs(I, J),
-    r_swap_write([J1 | Pre], I1, Code);
-r_swap_write(Pre, I, Code0 = [J | Code]) ->
+    optimize_swap_write([J1 | Pre], I1, Code);
+optimize_swap_write(Pre, I, Code0 = [J | Code]) ->
     case apply_rules_once(merge_rules(), I, Code0) of
         {_Rule, New, Rest} ->
             {lists:reverse(Pre) ++ New, Rest};
@@ -1228,27 +1387,27 @@ r_swap_write(Pre, I, Code0 = [J | Code]) ->
                 false -> false;
                 true  ->
                     {J1, I1} = swap_instrs(I, J),
-                    r_swap_write([J1 | Pre], I1, Code)
+                    optimize_swap_write([J1 | Pre], I1, Code)
             end
     end;
-r_swap_write(_, _, _) -> false.
+optimize_swap_write(_, _, _) -> false.
 
 %% Precompute instructions with known values
-r_constant_propagation(Cons = {i, Ann1, {'CONS', R, X, Xs}}, [{i, Ann, {'IS_NIL', S, R}} | Code]) ->
+optimize_constant_propagation(Cons = {i, Ann1, {'CONS', R, X, Xs}}, [{i, Ann, {'IS_NIL', S, R}} | Code]) ->
     Store = {i, Ann, {'STORE', S, ?i(false)}},
     Cons1 = case R of
                 ?a -> {i, Ann1, {'CONS', ?void, X, Xs}};
                 _  -> Cons
             end,
     {[Cons1, Store], Code};
-r_constant_propagation(Nil = {i, Ann1, {'NIL', R}}, [{i, Ann, {'IS_NIL', S, R}} | Code]) ->
+optimize_constant_propagation(Nil = {i, Ann1, {'NIL', R}}, [{i, Ann, {'IS_NIL', S, R}} | Code]) ->
     Store = {i, Ann, {'STORE', S, ?i(true)}},
     Nil1 = case R of
                ?a -> {i, Ann1, {'NIL', ?void}};
                _  -> Nil
            end,
     {[Nil1, Store], Code};
-r_constant_propagation({i, Ann, I}, Code) ->
+optimize_constant_propagation({i, Ann, I}, Code) ->
     case op_view(I) of
         false -> false;
         {Op, R, As} ->
@@ -1262,7 +1421,7 @@ r_constant_propagation({i, Ann, I}, Code) ->
                     end
             end
     end;
-r_constant_propagation(_, _) -> false.
+optimize_constant_propagation(_, _) -> false.
 
 eval_op('ADD', [X, Y]) when is_integer(X), is_integer(Y) -> X + Y;
 eval_op('SUB', [X, Y]) when is_integer(X), is_integer(Y) -> X - Y;
@@ -1281,12 +1440,12 @@ eval_op('NOT', [false]) -> true;
 eval_op(_, _)           -> no_eval.   %% TODO: bits?
 
 %% Prune impossible branches from switches
-r_prune_impossible_branches({switch, ?i(V), Type, Alts, missing}, Code) ->
+optimize_prune_impossible_branches({switch, ?i(V), Type, Alts, missing}, Code) ->
     case pick_branch(Type, V, Alts) of
         false -> false;
         Alt   -> {Alt, Code}
     end;
-r_prune_impossible_branches({switch, ?i(V), boolean, [False, True] = Alts, Def}, Code) when V == true; V == false ->
+optimize_prune_impossible_branches({switch, ?i(V), boolean, [False, True] = Alts, Def}, Code) when V == true; V == false ->
     Alts1 = [if V -> missing; true -> False   end,
              if V -> True;    true -> missing end],
     case Alts == Alts1 of
@@ -1297,7 +1456,7 @@ r_prune_impossible_branches({switch, ?i(V), boolean, [False, True] = Alts, Def},
                 _                  -> {[{switch, ?i(V), boolean, Alts1, Def}], Code}
             end
     end;
-r_prune_impossible_branches(Variant = {i, _, {'VARIANT', R, ?i(_), ?i(Tag), ?i(_)}},
+optimize_prune_impossible_branches(Variant = {i, _, {'VARIANT', R, ?i(_), ?i(Tag), ?i(_)}},
                             [{switch, R, Type = {variant, _}, Alts, missing} | Code]) when is_integer(Tag) ->
     case {R, lists:nth(Tag + 1, Alts)} of
         {_, missing} ->
@@ -1313,7 +1472,7 @@ r_prune_impossible_branches(Variant = {i, _, {'VARIANT', R, ?i(_), ?i(Tag), ?i(_
                 false -> {Alt, Code}
             end
     end;
-r_prune_impossible_branches(_, _) -> false.
+optimize_prune_impossible_branches(_, _) -> false.
 
 pick_branch(boolean, V, [False, True]) when V == true; V == false ->
     Alt = if V -> True; true -> False end,
@@ -1326,7 +1485,7 @@ pick_branch(_Type, _V, _Alts) ->
 
 %% If there's a single branch that doesn't abort we can push the code for that
 %% out of the switch.
-r_single_successful_branch({switch, R, Type, Alts, Def}, Code) ->
+optimize_single_successful_branch({switch, R, Type, Alts, Def}, Code) ->
     case push_code_out_of_switch([Def | Alts]) of
         {_, none} -> false;
         {_, many} -> false;
@@ -1334,7 +1493,7 @@ r_single_successful_branch({switch, R, Type, Alts, Def}, Code) ->
         {[Def1 | Alts1], PushedOut} ->
             {[{switch, R, Type, Alts1, Def1} | PushedOut], Code}
     end;
-r_single_successful_branch(_, _) -> false.
+optimize_single_successful_branch(_, _) -> false.
 
 push_code_out_of_switch([]) -> {[], none};
 push_code_out_of_switch([Alt | Alts]) ->
@@ -1370,7 +1529,7 @@ does_abort({switch, _, _, Alts, Def}) ->
 does_abort(_) -> false.
 
 %% STORE R A, SWITCH R --> SWITCH A
-r_inline_switch_target({i, Ann, {'STORE', R, A}}, [{switch, R, Type, Alts, Def} | Code]) ->
+optimize_inline_switch_target({i, Ann, {'STORE', R, A}}, [{switch, R, Type, Alts, Def} | Code]) ->
     Ann1   =
         case is_reg(A) of
             true  -> Ann#{ live_out := ordsets:add_element(A, maps:get(live_out, Ann)) };
@@ -1389,18 +1548,18 @@ r_inline_switch_target({i, Ann, {'STORE', R, A}}, [{switch, R, Type, Alts, Def}
             end;
         _        -> false %% impossible
     end;
-r_inline_switch_target(_, _) -> false.
+optimize_inline_switch_target(_, _) -> false.
 
 %% Float switch-body to closest switch
-r_float_switch_body(I = {i, _, _}, [J = {i, _, switch_body} | Code]) ->
+optimize_float_switch_body(I = {i, _, _}, [J = {i, _, switch_body} | Code]) ->
     {J1, I1} = swap_instrs(I, J),
     {[], [J1, I1 | Code]};
-r_float_switch_body(_, _) -> false.
+optimize_float_switch_body(_, _) -> false.
 
 %% Inline stores
-r_inline_store({i, _, {'STORE', R, R}}, Code) ->
+optimize_inline_store({i, _, {'STORE', R, R}}, Code) ->
     {[], Code};
-r_inline_store(I = {i, _, {'STORE', R = {var, _}, A}}, Code) ->
+optimize_inline_store(I = {i, _, {'STORE', R = {var, _}, A}}, Code) ->
     %% Not when A is var unless updating the annotations properly.
     Inline = case A of
                  {arg, _}   -> true;
@@ -1408,13 +1567,13 @@ r_inline_store(I = {i, _, {'STORE', R = {var, _}, A}}, Code) ->
                  {store, _} -> true;
                  _          -> false
              end,
-    if Inline -> r_inline_store([I], false, R, A, Code);
+    if Inline -> optimize_inline_store([I], false, R, A, Code);
        true   -> false end;
-r_inline_store(_, _) -> false.
+optimize_inline_store(_, _) -> false.
 
-r_inline_store(Acc, Progress, R, A, [I = {i, _, switch_body} | Code]) ->
-    r_inline_store([I | Acc], Progress, R, A, Code);
-r_inline_store(Acc, Progress, R, A, [{i, Ann, I} | Code]) ->
+optimize_inline_store(Acc, Progress, R, A, [I = {i, _, switch_body} | Code]) ->
+    optimize_inline_store([I | Acc], Progress, R, A, Code);
+optimize_inline_store(Acc, Progress, R, A, [{i, Ann, I} | Code]) ->
     #{ write := W } = attributes(I),
     Inl = fun(X) when X == R -> A; (X) -> X end,
     case live_in(R, Ann) of
@@ -1434,14 +1593,14 @@ r_inline_store(Acc, Progress, R, A, [{i, Ann, I} | Code]) ->
             case lists:member(W, [R, A]) of
                 true when Progress1 -> {lists:reverse(Acc1), Code};
                 true                -> false;
-                false               -> r_inline_store(Acc1, Progress1, R, A, Code)
+                false               -> optimize_inline_store(Acc1, Progress1, R, A, Code)
             end
     end;
-r_inline_store(Acc, true, _, _, Code) -> {lists:reverse(Acc), Code};
-r_inline_store(_, false, _, _, _) -> false.
+optimize_inline_store(Acc, true, _, _, Code) -> {lists:reverse(Acc), Code};
+optimize_inline_store(_, false, _, _, _) -> false.
 
 %% Shortcut write followed by final read
-r_one_shot_var({i, Ann1, I}, [{i, Ann2, J} | Code]) ->
+optimize_one_shot_var({i, Ann1, I}, [{i, Ann2, J} | Code]) ->
     case op_view(I) of
         {Op, R = {var, _}, As} ->
             Copy = case J of
@@ -1455,11 +1614,11 @@ r_one_shot_var({i, Ann1, I}, [{i, Ann2, J} | Code]) ->
             end;
         _ -> false
     end;
-r_one_shot_var(_, _) -> false.
+optimize_one_shot_var(_, _) -> false.
 
 %% Remove writes to dead variables
-r_write_to_dead_var({i, _, {'STORE', ?void, ?a}}, _) -> false; %% Avoid looping
-r_write_to_dead_var({i, Ann, I}, Code) ->
+optimize_write_to_dead_var({i, _, {'STORE', ?void, ?a}}, _) -> false; %% Avoid looping
+optimize_write_to_dead_var({i, Ann, I}, Code) ->
     #{ pure := Pure } = attributes(I),
     case op_view(I) of
         {_Op, R, As} when R /= ?a, Pure ->
@@ -1472,9 +1631,10 @@ r_write_to_dead_var({i, Ann, I}, Code) ->
             end;
         _ -> false
     end;
-r_write_to_dead_var(_, _) -> false.
+optimize_write_to_dead_var(_, _) -> false.
 
 op_view({'ABORT', R}) -> {'ABORT', none, [R]};
+op_view({'EXIT', R}) -> {'EXIT', none, [R]};
 op_view(T) when is_tuple(T) ->
     [Op, R | As] = tuple_to_list(T),
     CheckReads = fun(Rs, X) -> case [] == Rs -- [dst, src] of true -> X; false -> false end end,
@@ -1541,7 +1701,23 @@ bb(_Name, Code) ->
     Blocks  = lists:flatmap(fun split_calls/1, Blocks1),
     Labels  = maps:from_list([ {Ref, I} || {I, {Ref, _}} <- with_ixs(Blocks) ]),
     BBs     = [ set_labels(Labels, B) || B <- Blocks ],
-    maps:from_list(BBs).
+    maps:from_list(dbg_loc_filter(BBs)).
+
+%% Filter DBG_LOC instructions to keep one instruction per line
+dbg_loc_filter(BBs) ->
+    dbg_loc_filter(BBs, [], [], sets:new()).
+
+dbg_loc_filter([], _, AllBlocks, _) ->
+    lists:reverse(AllBlocks);
+dbg_loc_filter([{I, []} | Rest], AllOps, AllBlocks, DbgLocs) ->
+    dbg_loc_filter(Rest, [], [{I, lists:reverse(AllOps)} | AllBlocks], DbgLocs);
+dbg_loc_filter([{I, [Op = {'DBG_LOC', _, _} | Ops]} | Rest], AllOps, AllBlocks, DbgLocs) ->
+    case sets:is_element(Op, DbgLocs) of
+        true  -> dbg_loc_filter([{I, Ops} | Rest], AllOps, AllBlocks, DbgLocs);
+        false -> dbg_loc_filter([{I, Ops} | Rest], [Op | AllOps], AllBlocks, sets:add_element(Op, DbgLocs))
+    end;
+dbg_loc_filter([{I, [Op | Ops]} | Rest], AllOps, AllBlocks, DbgLocs) ->
+    dbg_loc_filter([{I, Ops} | Rest], [Op | AllOps], AllBlocks, DbgLocs).
 
 %% -- Break up scode into basic blocks --
 

src/aeso_icode.erl

@@ -1,153 +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,
-         in_main_contract/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
-     , "char"              => Word
-     , "bits"              => Word
-     , "string"            => fun([]) -> string end
-     , "address"           => Word
-     , "hash"              => Word
-     , "unit"              => fun([]) -> {tuple, []} end
-     , "signature"         => fun([]) -> {tuple, [word, word]} end
-     , "oracle"            => fun([_, _]) -> word end
-     , "oracle_query"      => fun([_, _]) -> word end
-     , "list"              => fun([A]) -> {list, A} end
-     , "option"            => fun([A]) -> {variant, [[], [A]]} end
-     , "map"               => fun([K, V]) -> map_typerep(K, V) end
-     , ["Chain", "ttl"]    => fun([]) -> {variant, [[word], [word]]} end
-     , ["AENS", "pointee"] => fun([]) -> {variant, [[word], [word], [word]]} end
-     }.
-
-builtin_constructors() ->
-    #{ ["RelativeTTL"]     => 0
-     , ["FixedTTL"]        => 1
-     , ["None"]            => 0
-     , ["Some"]            => 1
-     , ["AccountPointee"]  => 0
-     , ["OraclePointee"]   => 1
-     , ["ContractPointee"] => 2
-     }.
-
-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 in_main_contract(icode()) -> boolean().
-in_main_contract(#{ namespace := {con, _, Main}, contract_name := Main }) -> true;
-in_main_contract(_Icode) -> false.
-
--spec get_namespace(icode()) -> false | aeso_syntax:con() | aeso_syntax:qcon().
-get_namespace(Icode) -> maps:get(namespace, Icode, false).
-
--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

@@ -15,7 +15,8 @@
          many/1, many1/1, sep/2, sep1/2,
          infixl/2, infixr/2]).
 
--export([current_file/0, set_current_file/1]).
+-export([current_file/0, set_current_file/1,
+         current_include_type/0, set_current_include_type/1]).
 
 %% -- Types ------------------------------------------------------------------
 
@@ -465,6 +466,13 @@ 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').

src/aeso_parser.erl

@@ -18,7 +18,8 @@
          run_parser/3]).
 
 -include("aeso_parse_lib.hrl").
--import(aeso_parse_lib, [current_file/0, set_current_file/1]).
+-import(aeso_parse_lib, [current_file/0, set_current_file/1,
+                         current_include_type/0, set_current_include_type/1]).
 
 -type parse_result() :: aeso_syntax:ast() | {aeso_syntax:ast(), sets:set(include_hash())} | none().
 
@@ -57,6 +58,7 @@ run_parser(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, {{Input, Pos}, _}} ->
@@ -94,17 +96,29 @@ decl() ->
     choice(
       %% Contract declaration
     [ ?RULE(token(main), keyword(contract),
-            con(), tok('='), maybe_block(decl()), {contract_main, _2, _3, _5})
+            con(), tok('='), maybe_block(decl()), {contract_main, _2, _3, [], _5})
+    , ?RULE(token(main), keyword(contract),
+            con(), tok(':'), comma_sep(con()), tok('='), maybe_block(decl()), {contract_main, _2, _3, _5, _7})
     , ?RULE(keyword(contract),
-            con(), tok('='), maybe_block(decl()), {contract_child, _1, _2, _4})
+            con(), tok('='), maybe_block(decl()), {contract_child, _1, _2, [], _4})
+    , ?RULE(keyword(contract),
+            con(), tok(':'), comma_sep(con()), tok('='), maybe_block(decl()), {contract_child, _1, _2, _4, _6})
     , ?RULE(keyword(contract), token(interface),
-            con(), tok('='), maybe_block(decl()), {contract_interface, _1, _3, _5})
+            con(), tok('='), maybe_block(decl()), {contract_interface, _1, _3, [], _5})
+    , ?RULE(keyword(contract), token(interface),
+            con(), tok(':'), comma_sep(con()), tok('='), maybe_block(decl()), {contract_interface, _1, _3, _5, _7})
     , ?RULE(token(payable), token(main), keyword(contract),
-            con(), tok('='), maybe_block(decl()), add_modifiers([_1], {contract_main, _3, _4, _6}))
+            con(), tok('='), maybe_block(decl()), add_modifiers([_1], {contract_main, _3, _4, [], _6}))
+    , ?RULE(token(payable), token(main), keyword(contract),
+            con(), tok(':'), comma_sep(con()), tok('='), maybe_block(decl()), add_modifiers([_1], {contract_main, _3, _4, _6, _8}))
     , ?RULE(token(payable), keyword(contract),
-            con(), tok('='), maybe_block(decl()), add_modifiers([_1], {contract_child, _2, _3, _5}))
+            con(), tok('='), maybe_block(decl()), add_modifiers([_1], {contract_child, _2, _3, [], _5}))
+    , ?RULE(token(payable), keyword(contract),
+            con(), tok(':'), comma_sep(con()), tok('='), maybe_block(decl()), add_modifiers([_1], {contract_child, _2, _3, _5, _7}))
     , ?RULE(token(payable), keyword(contract), token(interface),
-            con(), tok('='), maybe_block(decl()), add_modifiers([_1], {contract_interface, _2, _4, _6}))
+            con(), tok('='), maybe_block(decl()), add_modifiers([_1], {contract_interface, _2, _4, [], _6}))
+    , ?RULE(token(payable), keyword(contract), token(interface),
+            con(), tok(':'), comma_sep(con()), tok('='), maybe_block(decl()), add_modifiers([_1], {contract_interface, _2, _4, _6, _8}))
 
 
     , ?RULE(keyword(namespace), con(), tok('='), maybe_block(decl()), {namespace, _1, _2, _4})
@@ -250,10 +264,11 @@ type300() ->
 type400() ->
     choice(
     [?RULE(typeAtom(), optional(type_args()),
-          case _2 of
-            none       -> _1;
-            {ok, Args} -> {app_t, get_ann(_1), _1, Args}
-          end),
+          any_bytes(
+            case _2 of
+              none       -> _1;
+              {ok, Args} -> {app_t, get_ann(_1), _1, Args}
+            end)),
      ?RULE(id("bytes"), parens(token(int)),
            {bytes_t, get_ann(_1), element(3, _2)})
     ]).
@@ -306,33 +321,39 @@ expr() -> expr100().
 
 expr100() ->
     Expr100 = ?LAZY_P(expr100()),
-    Expr200 = ?LAZY_P(expr200()),
+    Expr150 = ?LAZY_P(expr150()),
     choice(
     [ ?RULE(lam_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())),
+    , {'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('&&')).
+expr300() -> infixr(expr325(), binop('&&')).
+expr325() -> infixl(expr350(), binop('bor')).
+expr350() -> infixl(expr375(), binop('bxor')).
+expr375() -> infixl(expr400(), binop('band')).
 expr400() -> infix(expr500(),  binop(['<', '>', '=<', '>=', '==', '!='])).
-expr500() -> infixr(expr600(), binop(['::', '++'])).
+expr500() -> infixr(expr550(), binop(['::', '++'])).
+expr550() -> infixl(expr600(), binop(['<<', '>>'])).
 expr600() -> infixl(expr650(), binop(['+', '-'])).
 expr650() -> ?RULE(many(token('-')), expr700(), prefixes(_1, _2)).
 expr700() -> infixl(expr750(), binop(['*', '/', mod])).
 expr750() -> infixl(expr800(), binop(['^'])).
-expr800() -> ?RULE(many(token('!')), expr900(), prefixes(_1, _2)).
+expr800() -> ?RULE(many(token('!')), expr850(), prefixes(_1, _2)).
+expr850() -> ?RULE(many(token('bnot')), expr900(), prefixes(_1, _2)).
 expr900() -> ?RULE(exprAtom(), many(elim()), elim(_1, _2)).
 
 exprAtom() ->
     ?LAZY_P(begin
         Expr = ?LAZY_P(expr()),
         choice(
-        [ id_or_addr(), con(), token(qid), token(qcon)
+        [ 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)))
@@ -344,9 +365,12 @@ exprAtom() ->
         , ?RULE(tok('['), Expr, binop('..'), Expr, tok(']'), _3(_2, _4))
         , ?RULE(keyword('('), comma_sep(Expr), tok(')'), tuple_e(_1, _2))
         , letpat()
+        , hole()
         ])
     end).
 
+hole() -> ?RULE(token('???'), {id, get_ann(_1), "???"}).
+
 comprehension_exp() ->
     ?LAZY_P(choice(
       [ comprehension_bind()
@@ -469,6 +493,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
@@ -523,7 +560,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}].
+pos_ann(Line, Col) ->
+    [ {file, current_file()}
+    , {include_type, current_include_type()}
+    , {line, Line}
+    , {col, Col} ].
 
 ann_pos(Ann) ->
     {proplists:get_value(file, Ann),
@@ -665,9 +706,15 @@ expand_includes([{include, Ann, {string, _SAnn, File}} | AST], Included, Acc, Op
             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, _} ->
@@ -746,3 +793,7 @@ auto_imports(L) when is_list(L) ->
 auto_imports(T) when is_tuple(T) ->
     auto_imports(tuple_to_list(T));
 auto_imports(_) -> [].
+
+any_bytes({id, Ann, "bytes"})                 -> {bytes_t, Ann, any};
+any_bytes({app_t, _, {id, Ann, "bytes"}, []}) -> {bytes_t, Ann, any};
+any_bytes(Type)                               -> Type.

src/aeso_pretty.erl

@@ -151,12 +151,16 @@ decl(D, Options) ->
     with_options(Options, fun() -> decl(D) end).
 
 -spec decl(aeso_syntax:decl()) -> doc().
-decl({Con, Attrs, C, Ds}) when ?IS_CONTRACT_HEAD(Con) ->
+decl({Con, Attrs, C, Is, Ds}) when ?IS_CONTRACT_HEAD(Con) ->
     Mod = fun({Mod, true}) when Mod == payable ->
                   text(atom_to_list(Mod));
              (_) -> empty() end,
+    ImplsList = case Is of
+                    [] -> [empty()];
+                    _  -> [text(":"), par(punctuate(text(","), lists:map(fun name/1, Is)), 0)]
+                end,
     block(follow( hsep(lists:map(Mod, Attrs) ++ [contract_head(Con)])
-                , hsep(name(C), text("="))), decls(Ds));
+                , hsep([name(C)] ++ ImplsList ++ [text("=")])), decls(Ds));
 decl({namespace, _, C, Ds}) ->
     block(follow(text("namespace"), hsep(name(C), text("="))), decls(Ds));
 decl({pragma, _, Pragma}) -> pragma(Pragma);
@@ -257,6 +261,8 @@ type(Type, Options) ->
     with_options(Options, fun() -> type(Type) end).
 
 -spec type(aeso_syntax:type()) -> doc().
+type(F = {fun_t, _, _, var_args, _}) ->
+    type(setelement(4, F, [var_args]));
 type({fun_t, _, Named, Args, Ret}) ->
     follow(hsep(args_type(Named ++ Args), text("=>")), type(Ret));
 type({type_sig, _, Named, Args, Ret}) ->
@@ -269,7 +275,9 @@ type({tuple_t, _, Args}) ->
     tuple_type(Args);
 type({args_t, _, Args}) ->
     args_type(Args);
-type({bytes_t, _, any}) -> text("bytes(_)");
+type({bytes_t, _, any}) -> text("bytes()");
+type({bytes_t, _, '_'}) -> text("bytes(_)");
+type({bytes_t, _, fixed}) -> text("bytes(_)");
 type({bytes_t, _, Len}) ->
     text(lists:concat(["bytes(", Len, ")"]));
 type({if_t, _, Id, Then, Else}) ->
@@ -284,7 +292,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(var_args) -> text("var_args").
 
 -spec args_type([aeso_syntax:type()]) -> doc().
 args_type(Args) ->
@@ -426,16 +436,22 @@ lc_bind(Let) ->
 bin_prec('..')   -> {  0,   0,   0};  %% Always printed inside '[ ]'
 bin_prec('=')    -> {  0,   0,   0};  %% Always printed inside '[ ]'
 bin_prec('@')    -> {  0,   0,   0};  %% Only in error messages
+bin_prec('|>')   -> {150, 150, 200};
 bin_prec('||')   -> {200, 300, 200};
-bin_prec('&&')   -> {300, 400, 300};
+bin_prec('&&')   -> {300, 325, 300};
+bin_prec('bor')  -> {325, 350, 325};
+bin_prec('bxor') -> {350, 375, 350};
+bin_prec('band') -> {375, 400, 375};
 bin_prec('<')    -> {400, 500, 500};
 bin_prec('>')    -> {400, 500, 500};
 bin_prec('=<')   -> {400, 500, 500};
 bin_prec('>=')   -> {400, 500, 500};
 bin_prec('==')   -> {400, 500, 500};
 bin_prec('!=')   -> {400, 500, 500};
-bin_prec('++')   -> {500, 600, 500};
-bin_prec('::')   -> {500, 600, 500};
+bin_prec('++')   -> {500, 550, 500};
+bin_prec('::')   -> {500, 550, 500};
+bin_prec('<<')   -> {550, 600, 550};
+bin_prec('>>')   -> {550, 600, 550};
 bin_prec('+')    -> {600, 600, 650};
 bin_prec('-')    -> {600, 600, 650};
 bin_prec('*')    -> {700, 700, 750};
@@ -445,7 +461,8 @@ bin_prec('^')    -> {750, 750, 800}.
 
 -spec un_prec(aeso_syntax:un_op()) -> {integer(), integer()}.
 un_prec('-')    -> {650, 650};
-un_prec('!')    -> {800, 800}.
+un_prec('!')    -> {800, 800};
+un_prec('bnot') -> {850, 850}.
 
 equals(Ann, A, B) ->
     {app, [{format, infix} | Ann], {'=', Ann}, [A, B]}.

src/aeso_scan.erl

@@ -45,7 +45,7 @@ lexer() ->
 
     Keywords = ["contract", "include", "let", "switch", "type", "record", "datatype", "if", "elif", "else", "function",
                 "stateful", "payable", "true", "false", "mod", "public", "entrypoint", "private", "indexed", "namespace",
-                "interface", "main", "using", "as", "for", "hiding"
+                "interface", "main", "using", "as", "for", "hiding", "band", "bor", "bxor", "bnot"
                ],
     KW = string:join(Keywords, "|"),
 

src/aeso_syntax.erl

@@ -10,10 +10,10 @@
 
 -export([get_ann/1, get_ann/2, get_ann/3, set_ann/2, qualify/2]).
 
--export_type([ann_line/0, ann_col/0, ann_origin/0, ann_format/0, ann/0]).
+-export_type([ann_file/0, ann_line/0, ann_col/0, ann_origin/0, ann_format/0, ann/0]).
 -export_type([name/0, id/0, con/0, qid/0, qcon/0, tvar/0, op/0]).
 -export_type([bin_op/0, un_op/0]).
--export_type([decl/0, letbind/0, typedef/0, pragma/0]).
+-export_type([decl/0, letbind/0, typedef/0, pragma/0, fundecl/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]).
@@ -24,9 +24,10 @@
 -type ann_col()    :: integer().
 -type ann_origin() :: system | user.
 -type ann_format() :: '?:' | hex | infix | prefix | elif.
+-type ann_file()   :: string() | no_file.
 
--type ann() :: [ {line, ann_line()} | {col, ann_col()} | {format, ann_format()} | {origin, ann_origin()}
-               | stateful | private | payable | main | interface].
+-type ann() :: [ {file, ann_file()} | {line, ann_line()} | {col, ann_col()} | {format, ann_format()} | {origin, ann_origin()}
+               | stateful | private | payable | main | interface | entrypoint].
 
 -type name() :: string().
 -type id()   :: {id,   ann(), name()}.
@@ -38,10 +39,11 @@
 -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()]}
+-type decl() :: {contract_main, ann(), con(), [con()], [decl()]}
+              | {contract_child, ann(), con(), [con()], [decl()]}
+              | {contract_interface, ann(), con(), [con()], [decl()]}
               | {namespace, ann(), con(), [decl()]}
+              | {include, ann(), {string, ann(), string()}}
               | {pragma, ann(), pragma()}
               | {type_decl, ann(), id(), [tvar()]} % Only for error msgs
               | {type_def, ann(), id(), [tvar()], typedef()}
@@ -105,8 +107,8 @@
 
 -type bin_op() :: '+' | '-' | '*' | '/' | mod | '^'
                 | '++' | '::' | '<' | '>' | '=<' | '>=' | '==' | '!='
-                | '||' | '&&' | '..'.
--type un_op() :: '-' | '!'.
+                | '||' | '&&' | '..' | 'band' | 'bor' | 'bxor' | '>>' | '<<' | '|>'.
+-type un_op() :: '-' | '!' | 'bnot'.
 
 -type expr()
     :: {lam, ann(), [arg()], expr()}

src/aeso_syntax_utils.erl

@@ -31,11 +31,13 @@
             | aeso_syntax:field(aeso_syntax:expr())
             | aeso_syntax:stmt().
 fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
+    ExprKind = if K == bind_expr -> bind_expr; true -> expr end,
+    TypeKind = if K == bind_type -> bind_type; true -> type end,
     Sum  = fun(Xs) -> lists:foldl(Plus, Zero, Xs) end,
     Same = fun(A) -> fold(Alg, Fun, K, A) end,
     Decl = fun(D) -> fold(Alg, Fun, decl, D) end,
-    Type = fun(T) -> fold(Alg, Fun, type, T) end,
-    Expr = fun(E) -> fold(Alg, Fun, expr, E) end,
+    Type = fun(T) -> fold(Alg, Fun, TypeKind, T) end,
+    Expr = fun(E) -> fold(Alg, Fun, ExprKind, E) end,
     BindExpr = fun(P) -> fold(Alg, Fun, bind_expr, P) end,
     BindType = fun(T) -> fold(Alg, Fun, bind_type, T) end,
     Top = Fun(K, X),
@@ -155,4 +157,3 @@ used(D) ->
                (_, _)             -> #{}
             end, decl, D)),
     lists:filter(NotBound, Xs).
-

src/aeso_vm_decode.erl

@@ -1,75 +1,15 @@
 %%%-------------------------------------------------------------------
 %%% @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"}, N0) ->
-    <<N:256/signed>> = <<N0:256>>,
-    if N < 0 -> {app, [{format, prefix}], {'-', []}, [{int, [], -N}]};
-       true  -> {int, [], N} end;
-from_aevm(word, {id, _, "bits"}, N0) ->
-    <<N:256/signed>> = <<N0:256>>,
-    make_bits(N);
-from_aevm(word, {id, _, "bool"}, N) -> {bool, [], N /= 0};
-from_aevm(word, {bytes_t, _, Len}, Val) when Len =< 32 ->
-    <<Bytes:Len/unit:8, _/binary>> = <<Val:32/unit:8>>,
-    {bytes, [], <<Bytes:Len/unit:8>>};
-from_aevm({tuple, _}, {bytes_t, _, Len}, Val) ->
-    {bytes, [], binary:part(<< <<W:32/unit:8>> || W <- tuple_to_list(Val) >>, 0, Len)};
-from_aevm(string, {id, _, "string"}, S) -> {string, [], S};
-from_aevm({list, VmType}, {app_t, _, {id, _, "list"}, [Type]}, List) ->
-    {list, [], [from_aevm(VmType, Type, X) || X <- List]};
-from_aevm({variant, [[], [VmType]]}, {app_t, _, {id, _, "option"}, [Type]}, Val) ->
-    case Val of
-        {variant, 0, []}  -> {con, [], "None"};
-        {variant, 1, [X]} -> {app, [], {con, [], "Some"}, [from_aevm(VmType, Type, X)]}
-    end;
-from_aevm({tuple, VmTypes}, {tuple_t, _, Types}, Val)
-        when length(VmTypes) == length(Types),
-             length(VmTypes) == tuple_size(Val) ->
-    {tuple, [], [from_aevm(VmType, Type, X)
-                 || {VmType, Type, X} <- lists:zip3(VmTypes, Types, tuple_to_list(Val))]};
-from_aevm({tuple, VmTypes}, {record_t, Fields}, Val)
-        when length(VmTypes) == length(Fields),
-             length(VmTypes) == tuple_size(Val) ->
-    {record, [], [ {field, [], [{proj, [], FName}], from_aevm(VmType, FType, X)}
-                   || {VmType, {field_t, _, FName, FType}, X} <- lists:zip3(VmTypes, Fields, tuple_to_list(Val)) ]};
-from_aevm({map, VmKeyType, VmValType}, {app_t, _, {id, _, "map"}, [KeyType, ValType]}, Map)
-        when is_map(Map) ->
-    {map, [], [ {from_aevm(VmKeyType, KeyType, Key),
-                 from_aevm(VmValType, ValType, Val)}
-                || {Key, Val} <- maps:to_list(Map) ]};
-from_aevm({variant, VmCons}, {variant_t, Cons}, {variant, Tag, Args})
-        when length(VmCons) == length(Cons),
-             length(VmCons) > Tag ->
-    VmTypes = lists:nth(Tag + 1, VmCons),
-    ConType = lists:nth(Tag + 1, Cons),
-    from_aevm(VmTypes, ConType, Args);
-from_aevm([], {constr_t, _, Con, []}, []) -> Con;
-from_aevm(VmTypes, {constr_t, _, Con, Types}, Args)
-        when length(VmTypes) == length(Types),
-             length(VmTypes) == length(Args) ->
-    {app, [], Con, [ from_aevm(VmType, Type, Arg)
-                     || {VmType, Type, Arg} <- lists:zip3(VmTypes, Types, Args) ]};
-from_aevm(_VmType, _Type, _Data) ->
-    throw(cannot_translate_to_sophia).
-
-
 -spec from_fate(aeso_syntax:type(), aeb_fate_data:fate_type()) -> aeso_syntax:expr().
 from_fate({id, _, "address"}, ?FATE_ADDRESS(Bin)) -> {account_pubkey, [], Bin};
 from_fate({app_t, _, {id, _, "oracle"}, _}, ?FATE_ORACLE(Bin)) -> {oracle_pubkey, [], Bin};
@@ -136,6 +76,8 @@ from_fate_builtin(QType, Val) ->
     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],
@@ -146,7 +88,7 @@ from_fate_builtin(QType, Val) ->
 
         {["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)]);
+                                  Chk(Map(Str, Qid(["AENS", "pointee"])), Ptrs)]);
 
         {["AENS", "pointee"], {variant, [1, 1, 1, 1], 0, {Addr}}} ->
             App(["AENS","AccountPt"], [Chk(Adr, Addr)]);
@@ -157,6 +99,21 @@ from_fate_builtin(QType, Val) ->
         {["AENS", "pointee"], {variant, [1, 1, 1, 1], 3, {Addr}}} ->
             App(["AENS","ChannelPt"], [Chk(Adr, Addr)]);
 
+        {["AENSv2", "name"], {variant, [3], 0, {Addr, TTL, Ptrs}}} ->
+            App(["AENSv2","Name"], [Chk(Adr, Addr), Chk(Qid(["Chain", "ttl"]), TTL),
+                                    Chk(Map(Str, Qid(["AENSv2", "pointee"])), Ptrs)]);
+
+        {["AENSv2", "pointee"], {variant, [1, 1, 1, 1, 1], 0, {Val}}} ->
+            App(["AENSv2","AccountPt"], [Chk(Adr, Val)]);
+        {["AENSv2", "pointee"], {variant, [1, 1, 1, 1, 1], 1, {Val}}} ->
+            App(["AENSv2","OraclePt"], [Chk(Adr, Val)]);
+        {["AENSv2", "pointee"], {variant, [1, 1, 1, 1, 1], 2, {Val}}} ->
+            App(["AENSv2","ContractPt"], [Chk(Adr, Val)]);
+        {["AENSv2", "pointee"], {variant, [1, 1, 1, 1, 1], 3, {Val}}} ->
+            App(["AENSv2","ChannelPt"], [Chk(Adr, Val)]);
+        {["AENSv2", "pointee"], {variant, [1, 1, 1, 1, 1], 4, {Val}}} ->
+            App(["AENSv2","DataPt"], [Chk(Str, Val)]);
+
         {["Chain", "ga_meta_tx"], {variant, [2], 0, {Addr, X}}} ->
             App(["Chain","GAMetaTx"], [Chk(Adr, Addr), Chk(Int, X)]);
 
@@ -208,6 +165,11 @@ from_fate_builtin(QType, Val) ->
         {["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.

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, "Compiler for Aeternity Sophia language"},
-  {vsn, "6.1.0"},
+  {vsn, "8.0.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() ->
@@ -72,55 +56,67 @@ 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 x(y : int) : string = \"hello\"\n" ],
+             "  entrypoint f(x : int) : string = \"hello\"\n" ],
 
-    {error, [Err1]} = aeso_compiler:to_sophia_value(Code, "x", ok, encode(12)),
-    ?assertEqual("Data error:\nFailed to decode binary as type string\n", aeso_errors:pp(Err1)),
-    {error, [Err2]} = aeso_compiler:to_sophia_value(Code, "x", ok, encode(12), [{backend, fate}]),
-    ?assertEqual("Data error:\nFailed to decode binary as type string\n", aeso_errors:pp(Err2)),
+    {error, [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, [Err3]} = aeso_compiler:to_sophia_value(Code, "x", revert, encode(12)),
-    ?assertEqual("Data error:\nCould not interpret the revert message\n", aeso_errors:pp(Err3)),
-    {error, [Err4]} = aeso_compiler:to_sophia_value(Code, "x", revert, encode(12), [{backend, fate}]),
-    ?assertEqual("Data error:\nCould not deserialize the revert message\n", aeso_errors:pp(Err4)),
+    {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 x(y : int) : string = \"hello\"\n" ],
+             "  entrypoint f(x : int) : string = \"hello\"\n" ],
 
-    ExpErr1 = "Type error at line 5, col 34:\nCannot unify int\n         and bool\n"
-              "when checking the application at line 5, column 34 of\n"
-              "  x : (int) => string\nto arguments\n  true : bool\n",
-    {error, [Err1]} = aeso_compiler:create_calldata(Code, "x", ["true"]),
+    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)),
-    {error, [Err2]} = aeso_compiler:create_calldata(Code, "x", ["true"], [{backend, fate}]),
-    ?assertEqual(ExpErr1, aeso_errors:pp(Err2)),
 
     ok.
 
 decode_calldata_neg_test() ->
     Code1 = [ "contract Foo =\n"
-              "  entrypoint x(y : int) : string = \"hello\"\n" ],
+              "  entrypoint f(x : int) : string = \"hello\"\n" ],
     Code2 = [ "contract Foo =\n"
-              "  entrypoint x(y : string) : int = 42\n" ],
+              "  entrypoint f(x : string) : int = 42\n" ],
 
-    {ok, CallDataAEVM} = aeso_compiler:create_calldata(Code1, "x", ["42"]),
-    {ok, CallDataFATE} = aeso_compiler:create_calldata(Code1, "x", ["42"], [{backend, fate}]),
+    {ok, CallDataFATE} = aeso_compiler:create_calldata(Code1, "f", ["42"]),
 
-    {error, [Err1]} = aeso_compiler:decode_calldata(Code2, "x", CallDataAEVM),
-    ?assertEqual("Data error:\nFailed to decode calldata as type {tuple,[string]}\n", aeso_errors:pp(Err1)),
-    {error, [Err2]} = aeso_compiler:decode_calldata(Code2, "x", <<1,2,3>>, [{backend, fate}]),
-    ?assertEqual("Data error:\nFailed to decode calldata binary\n", aeso_errors:pp(Err2)),
-    {error, [Err3]} = aeso_compiler:decode_calldata(Code2, "x", CallDataFATE, [{backend, fate}]),
-    ?assertEqual("Data error:\nCannot translate FATE value \"*\"\n  to Sophia type (string)\n", aeso_errors:pp(Err3)),
+    {error, [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, [Err4]} = aeso_compiler:decode_calldata(Code2, "y", CallDataAEVM),
-    ?assertEqual("Data error at line 1, col 1:\nFunction 'y' is missing in contract\n", aeso_errors:pp(Err4)),
-    {error, [Err5]} = aeso_compiler:decode_calldata(Code2, "y", CallDataFATE, [{backend, fate}]),
-    ?assertEqual("Data error at line 1, col 1:\nFunction 'y' is missing in contract\n", aeso_errors:pp(Err5)),
+    {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.
 
 
@@ -133,8 +129,7 @@ encode_decode_sophia_string(SophiaType, String) ->
            , "  datatype variant = Red | Blue(map(string, int))\n"
            , "  entrypoint foo : arg_type => arg_type\n" ],
     case aeso_compiler:check_call(lists:flatten(Code), "foo", [String], [no_code]) of
-        {ok, _, {[Type], _}, [Arg]} ->
-            io:format("Type ~p~n", [Type]),
+        {ok, _, [Arg]} ->
             Data = encode(Arg),
             case aeso_compiler:to_sophia_value(Code, "foo", ok, Data, [no_code]) of
                 {ok, Sophia} ->
@@ -150,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"],
-                                                        [?DUMMY_HASH_LIT, "ak_1111111111111111111111111111113AFEFpt5"]),
-    [?DUMMY_HASH_WORD, ?DUMMY_HASH_WORD] =
+    [{bytes, <<291:256>>}, {address, <<1110:256>>}] =
+        encode_decode_calldata("foo", ["bytes(32)", "address"],
+                               [?DUMMY_HASH_LIT, "ak_1111111111111111111111111111113AFEFpt5"]),
+    [{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"),
@@ -202,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]} =
-        aeso_compiler:check_call(Contract, "question", ["ok_111111111111111111111111111111ZrdqRz9",
-                                                        "oq_1111111111111111111111111111113AFEFpt5"], [no_code]),
+    ?assertEqual({ok, "question", [{oracle, <<291:256>>}, {oracle_query, <<1110:256>>}]},
+                 aeso_compiler:check_call(Contract, "question", ["ok_111111111111111111111111111111ZrdqRz9",
+                                                                 "oq_1111111111111111111111111111113AFEFpt5"], [no_code])),
 
     ok.
 
@@ -220,35 +217,26 @@ permissive_literals_fail_test() ->
     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}, no_code]),
-    ?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

@@ -21,7 +21,7 @@ test_cases(1) ->
 		 "  payable stateful entrypoint a(i : int) = i+1\n">>,
     MapACI = #{contract =>
 		   #{name => <<"C">>,
-		     type_defs => [],
+		     typedefs => [],
          payable => true,
          kind => contract_main,
 		     functions =>
@@ -43,7 +43,7 @@ test_cases(2) ->
     MapACI = #{contract =>
                    #{name => <<"C">>, payable => false,
                      kind => contract_main,
-                     type_defs =>
+                     typedefs =>
                          [#{name => <<"allan">>,
                             typedef => <<"int">>,
                             vars => []}],
@@ -76,7 +76,7 @@ test_cases(3) ->
 		     name => <<"C">>, payable => false, kind => contract_main,
          event => #{variant => [#{<<"SingleEventDefined">> => []}]},
          state => <<"unit">>,
-		     type_defs =>
+		     typedefs =>
              [#{name => <<"bert">>,
                 typedef =>
                     #{variant =>
@@ -108,7 +108,7 @@ aci_test_contract(Name) ->
                {error, ErrorStringJ} when is_binary(ErrorStringJ) -> error(ErrorStringJ);
                {error, ErrorJ} -> aeso_compiler_tests:print_and_throw(ErrorJ)
            end,
-    case aeso_compiler:from_string(String, [{aci, json}, {backend, fate} | Opts]) of
+    case aeso_compiler:from_string(String, [{aci, json} | Opts]) of
         {ok, #{aci := JSON1}} ->
             ?assertEqual(JSON, JSON1),
             io:format("JSON:\n~p\n", [JSON]),
@@ -127,7 +127,7 @@ check_stub(Stub, Options) ->
         Ast ->
             try
                 %% io:format("AST: ~120p\n", [Ast]),
-                aeso_ast_infer_types:infer(Ast, [])
+                aeso_ast_infer_types:infer(Ast, [no_code])
             catch throw:{type_errors, TE} ->
                 io:format("Type error:\n~s\n", [TE]),
                 error(TE);

test/aeso_calldata_tests.erl

@@ -19,19 +19,9 @@ 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,
+           FateExprs = ast_exprs(ContractString, Fun, Args),
            ParsedExprs = parse_args(Fun, Args),
-           [ ?assertEqual(ParsedExprs, AevmExprs) || AevmExprs /= undefined ],
-           [ ?assertEqual(ParsedExprs, FateExprs) || FateExprs /= undefined ],
+           ?assertEqual(ParsedExprs, FateExprs),
            ok
         end} || {ContractName, Fun, Args} <- compilable_contracts()].
 
@@ -39,27 +29,17 @@ calldata_aci_test_() ->
      [ {"Testing " ++ ContractName ++ " contract calling " ++ Fun,
         fun() ->
            ContractString       = aeso_test_utils:read_contract(ContractName),
-           {ok, ContractACIBin} = aeso_aci:contract_interface(string, ContractString),
+           {ok, ContractACIBin} = aeso_aci:contract_interface(string, ContractString, [no_code]),
            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,
+           FateExprs = ast_exprs(ContractACI, Fun, Args),
            ParsedExprs = parse_args(Fun, Args),
-           [ ?assertEqual(ParsedExprs, AevmExprs) || AevmExprs /= undefined ],
-           [ ?assertEqual(ParsedExprs, FateExprs) || FateExprs /= undefined ],
+           ?assertEqual(ParsedExprs, FateExprs),
            ok
         end} || {ContractName, Fun, Args} <- compilable_contracts()].
 
 parse_args(Fun, Args) ->
-    [{contract_main, _, _, [{letfun, _, _, _, _, [{guarded, _, [], {app, _, _, AST}}]}]}] =
+    [{contract_main, _, _, _, [{letfun, _, _, _, _, [{guarded, _, [], {app, _, _, AST}}]}]}] =
         aeso_parser:string("main contract Temp = function foo() = " ++ Fun ++ "(" ++ string:join(Args, ", ") ++ ")"),
     strip_ann(AST).
 
@@ -75,6 +55,8 @@ 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)),
@@ -159,8 +141,3 @@ compilable_contracts() ->
      {"stub", "foo", ["-42"]},
      {"payable", "foo", ["42"]}
     ].
-
-not_yet_compilable(fate) ->
-    [];
-not_yet_compilable(aevm) ->
-    ["funargs", "strings"].

test/aeso_parser_tests.erl

@@ -15,7 +15,7 @@ simple_contracts_test_() ->
             Text = "main contract Identity =\n"
                    "  function id(x) = x\n",
             ?assertMatch(
-                [{contract_main, _, {con, _, "Identity"},
+                [{contract_main, _, {con, _, "Identity"}, _,
                     [{letfun, _, {id, _, "id"}, [{id, _, "x"}], {id, _, "_"},
                         [{guarded, _, [], {id, _, "x"}}]}]}], parse_string(Text)),
             ok
@@ -53,7 +53,7 @@ simple_contracts_test_() ->
             %% associativity
             [ RightAssoc(Op) || Op <- ["||", "&&", "::", "++"] ],
             [ NonAssoc(Op)   || Op <- ["==", "!=", "<", ">", "=<", ">="] ],
-            [ LeftAssoc(Op)  || Op <- ["+", "-", "*", "/", "mod"] ],
+            [ LeftAssoc(Op)  || Op <- ["+", "-", "*", "/", "mod", "band", "bor", "bxor", "<<", ">>"] ],
 
             %% precedence
             [ Stronger(Op2, Op1) || [T1 , T2 | _] <- tails(Tiers), Op1 <- T1, Op2 <- T2 ],

test/aeso_scan_tests.erl

@@ -39,7 +39,8 @@ all_tokens() ->
     %% Symbols
     lists:map(Lit, [',', '.', ';', '|', ':', '(', ')', '[', ']', '{', '}']) ++
     %% Operators
-    lists:map(Lit, ['=', '==', '!=', '>', '<', '>=', '=<', '-', '+', '++', '*', '/', mod, ':', '::', '->', '=>', '||', '&&', '!']) ++
+    lists:map(Lit, ['=', '==', '!=', '>', '<', '>=', '=<', '-', '+', '++', '*', '/', mod,
+                    ':', '::', '->', '=>', '||', '&&', '!', 'band', 'bor', 'bxor', 'bnot' ,'<<', '>>']) ++
     %% Keywords
     lists:map(Lit, [contract, type, 'let', switch]) ++
     %% Comment token (not an actual token), just for tests

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/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/aens.aes

@@ -1,71 +1,82 @@
+contract C = entrypoint init() = ()
+
 // AENS tests
-contract AENSTest =
+main contract AENSTest =
 
   // Name resolution
 
   stateful entrypoint resolve_word(name : string, key : string) : option(address) =
-    AENS.resolve(name, key)
+    AENSv2.resolve(name, key)
 
   stateful entrypoint resolve_string(name : string, key : string) : option(string) =
-    AENS.resolve(name, key)
+    AENSv2.resolve(name, key)
+
+  stateful entrypoint resolve_contract(name : string, key : string) : option(C) =
+    AENSv2.resolve(name, key)
+
+  stateful entrypoint resolve_oracle(name : string, key : string) : option(oracle(int, int)) =
+    AENSv2.resolve(name, key)
+
+  stateful entrypoint resolve_oracle_query(name : string, key : string) : option(oracle_query(int, int)) =
+    AENSv2.resolve(name, key)
 
   // Transactions
 
   stateful entrypoint preclaim(addr  : address,     // Claim on behalf of this account (can be Contract.address)
-                             chash : hash) : unit = // Commitment hash
-    AENS.preclaim(addr, chash)
+                               chash : hash) : unit = // Commitment hash
+    AENSv2.preclaim(addr, chash)
 
   stateful entrypoint signedPreclaim(addr  : address, // Claim on behalf of this account (can be Contract.address)
                                    chash : hash,             // Commitment hash
                                    sign  : signature) : unit = // Signed by addr (if not Contract.address)
-    AENS.preclaim(addr, chash, signature = sign)
+    AENSv2.preclaim(addr, chash, signature = sign)
 
   stateful entrypoint claim(addr : address,
                           name : string,
                           salt : int,
                           name_fee : int) : unit =
-    AENS.claim(addr, name, salt, name_fee)
+    AENSv2.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, name_fee, signature = sign)
+    AENSv2.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)
+                             pointers   : option(map(string, AENSv2.pointee))) : unit =
+    AENSv2.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)),
+                                   pointers   : option(map(string, AENSv2.pointee)),
                                    sign       : signature) : unit =
-    AENS.update(owner, name, ttl, client_ttl, pointers, signature = sign)
+    AENSv2.update(owner, name, ttl, client_ttl, pointers, signature = sign)
 
 
   stateful entrypoint transfer(owner     : address,
                              new_owner : address,
                              name      : string) : unit =
-    AENS.transfer(owner, new_owner, name)
+    AENSv2.transfer(owner, new_owner, name)
 
   stateful entrypoint signedTransfer(owner     : address,
                                      new_owner : address,
                                      name      : string,
                                      sign      : signature) : unit =
-    AENS.transfer(owner, new_owner, name, signature = sign)
+    AENSv2.transfer(owner, new_owner, name, signature = sign)
 
   stateful entrypoint revoke(owner     : address,
                            name      : string) : unit =
-    AENS.revoke(owner, name)
+    AENSv2.revoke(owner, name)
 
   stateful entrypoint signedRevoke(owner     : address,
                                    name      : string,
                                    sign      : signature) : unit =
-    AENS.revoke(owner, name, signature = sign)
+    AENSv2.revoke(owner, name, signature = sign)

test/contracts/aens_update.aes

@@ -1,17 +1,30 @@
-contract AENSUpdate =
+include "Option.aes"
+include "AENSCompat.aes"
+contract interface OldAENSContract =
+  entrypoint set : (string, string, AENS.pointee) => unit
+  entrypoint lookup : (string, string) => AENS.pointee
+
+main 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 }))
+    let p1 : AENSv2.pointee = AENSv2.AccountPt(Call.caller)
+    let p2 : AENSv2.pointee = AENSv2.OraclePt(Call.caller)
+    let p3 : AENSv2.pointee = AENSv2.ContractPt(Call.caller)
+    let p4 : AENSv2.pointee = AENSv2.ChannelPt(Call.caller)
+    let p5 : AENSv2.pointee = AENSv2.DataPt("any something will do")
+    AENSv2.update(owner, name, None, None,
+                  Some({ ["account_pubkey"] = p1, ["oracle_pubkey"] = p2,
+                         ["contract_pubkey"] = p3, ["misc"] = p4, ["data"] = p5 }))
+
+  stateful entrypoint old_interaction(c : OldAENSContract, owner : address, name : string) =
+    let p : AENS.pointee = c.lookup(name, "key1")
+    AENSv2.update(owner, name, None, None, Some({ ["key1"] = AENSCompat.pointee_to_V2(p) }))
+    switch(AENSv2.lookup(name))
+      Some(AENSv2.Name(_, _, pt_map)) =>
+        c.set(name, "key2", Option.force(AENSCompat.pointee_from_V2(pt_map["key1"])))
 
   entrypoint get_ttl(name : string) =
-    switch(AENS.lookup(name))
-     Some(AENS.Name(_, FixedTTL(ttl), _)) => ttl
+    switch(AENSv2.lookup(name))
+     Some(AENSv2.Name(_, FixedTTL(ttl), _)) => ttl
 
   entrypoint expiry(o : oracle(int, int)) : int =
     Oracle.expiry(o)
-

test/contracts/all_syntax.aes

@@ -6,6 +6,7 @@
 namespace Ns =
   datatype d('a) = D | S(int) | M('a, list('a), int)
   private function fff() = 123
+  let const = 1
 
   stateful entrypoint
     f (1, x) = (_) => x
@@ -33,6 +34,8 @@ contract AllSyntax =
 
   type state = shakespeare(int)
 
+  let cc = "str"
+
   entrypoint init() = {
     johann = 1000,
     wolfgang = -10,
@@ -80,3 +83,4 @@ contract AllSyntax =
      let sh : shakespeare(shakespeare(int)) =
        {wolfgang = state}
      sh{wolfgang.wolfgang = sh.wolfgang} // comment
+     exit("hope you had fun reading this")

test/contracts/bad_aens_resolve.aes

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

test/contracts/bad_aens_resolve_using.aes

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

test/contracts/bad_bytes_to_x.aes

@@ -0,0 +1,5 @@
+// include "String.aes"
+contract BytesToX =
+  entrypoint fail1(b : bytes()) = Bytes.to_fixed_size(b)
+  entrypoint fail2(b : bytes(4)) = Bytes.to_fixed_size(b)
+  entrypoint fail3(b : bytes()) = Bytes.to_any_size(b)

test/contracts/bytes_misc.aes

@@ -0,0 +1,27 @@
+include "String.aes"
+contract BytesMisc =
+  entrypoint sizeFixed(b : bytes(4)) : int = Bytes.size(b)
+  entrypoint sizeAny(b : bytes()) : int = Bytes.size(b)
+  entrypoint int_to_bytes(i : int) : bytes() = Int.to_bytes(i, 16)
+
+  entrypoint test(b3 : bytes(3), b7 : bytes(7), bX : bytes, i : int, s : string) =
+    let bi = Int.to_bytes(i, 8)
+    let bs = String.to_bytes(s)
+
+    let b10 = Bytes.concat(b3, b7)
+
+    let (b4, b6 : bytes(6)) = Bytes.split(b10)
+
+    let Some((b8, b2)) = Bytes.split_any(bX, 8)
+
+    let bX7 = Bytes.concat(bX, b7)
+
+    let Some((b5, bX2)) = Bytes.split_any(bX7, 5)
+
+    let Some((b7b, b0)) = Bytes.split_any(bX, Bytes.size(b7))
+
+    let Some(b5b : bytes(5)) = Bytes.to_fixed_size(b5)
+
+    let (b1 : bytes(1), _) = Bytes.split(b5b)
+
+    [bi, bs, b0, Bytes.to_any_size(b1), b2, Bytes.to_any_size(b4), Bytes.to_any_size(b6), b7b, b8, bX2]

test/contracts/bytes_to_x.aes

@@ -6,3 +6,5 @@ contract BytesToX =
     String.concat(Bytes.to_str(b), Bytes.to_str(#ffff))
   entrypoint to_str_big(b : bytes(65)) : string =
     Bytes.to_str(b)
+  entrypoint to_fixed(b : bytes()) : option(bytes(4)) = Bytes.to_fixed_size(b)
+  entrypoint to_any(b : bytes(4)) = Bytes.to_any_size(b)

test/contracts/calling_child_contract_entrypoint.aes

@@ -0,0 +1,5 @@
+contract F =
+  entrypoint g() = 1
+
+main contract C =
+  entrypoint f() = F.g()

test/contracts/ceres.aes

@@ -0,0 +1,14 @@
+contract C =
+  entrypoint test() =
+    let a : int = 23
+    let b : int = 52
+    let c = a bor b
+    let d = c bxor b
+    let e = d band b
+    let f = bnot a
+    let g = f << 2
+    let h = g >> 2
+    let i = Int.mulmod(a, b, h)
+    let j = Crypto.poseidon(i, a)
+    let k : bytes(32) = Address.to_bytes(Call.origin)
+    (a bor b band c bxor a << bnot b >> a, k)

test/contracts/chain.aes

@@ -2,7 +2,8 @@
 
 contract ChainTest =
 
-  record state = { last_bf : address }
+  record state = { last_bf : address
+                 , nw_id   : string }
 
   function init() : state =
     {last_bf = Contract.address}
@@ -11,3 +12,6 @@ contract ChainTest =
 
   function save_coinbase() =
     put(state{last_bf = Chain.coinbase})
+
+  function save_network_id() =
+    put(state{nw_id = Chain.network_id})

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,51 +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 expiry() =
-    Oracle.expiry(state.oracle)
-
-  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/code_errors/missing_init_function.aes

@@ -1,3 +0,0 @@
-contract MissingInitFunction =
-  type state = int * int
-

test/contracts/complex_types.aes

@@ -1,16 +1,7 @@
 
-contract interface Remote =
-  entrypoint up_to       : (int)               => list(int)
-  entrypoint sum         : (list(int))         => int
-  entrypoint some_string : ()                  => string
-  entrypoint pair        : (int, string)       => int * string
-  entrypoint squares     : (int)               => list(int * int)
-  entrypoint filter_some : (list(option(int))) => list(int)
-  entrypoint all_some    : (list(option(int))) => option(list(int))
-
 contract ComplexTypes =
 
-  record state = { worker : Remote }
+  record state = { worker : ComplexTypes }
 
   entrypoint init(worker) = {worker = worker}
 

test/contracts/contract_types.aes

@@ -1,20 +0,0 @@
-
-contract OtherContract =
-
-  function multiply : (int, int) => int
-
-contract ThisContract =
-
-  record state = { server : OtherContract, n : int }
-
-  function init(server : OtherContract) =
-    { server = server, n = 2 }
-
-  function square() =
-    put(state{ n @ n = state.server.multiply(value = 100, n, n) })
-
-  function get_n() = state.n
-
-  function tip_server() =
-    Chain.spend(state.server.address, Call.value)
-

test/contracts/empty_record_definition.aes

@@ -0,0 +1,3 @@
+contract C =
+    record r = {}
+    entrypoint init() = ()

test/contracts/environment.aes

@@ -1,14 +1,9 @@
 
 // Testing primitives for accessing the block chain environment
-contract interface Interface =
-  entrypoint contract_address : () => address
-  entrypoint call_origin      : () => address
-  entrypoint call_caller      : () => address
-  entrypoint call_value       : () => int
 
 contract Environment =
 
-  record state = {remote : Interface}
+  record state = {remote : Environment}
 
   entrypoint init(remote) = {remote = remote}
 

test/contracts/erc20_token.aes

@@ -1,87 +0,0 @@
-contract ERC20Token =
-  record state = {
-    totalSupply : int,
-    decimals : int,
-    name : string,
-    symbol : string,
-    balances : map(address, int),
-    allowed : map(address, map(address,int)),
-    // Logs, remove when native Events are there
-    transfer_log : list((address,address,int)),
-    approval_log : list((address,address,int))}
-
-  // init(100000000, 10, "Token Name", "TKN")
-  public stateful function init(_totalSupply : int, _decimals : int, _name : string, _symbol : string ) = {
-    totalSupply = _totalSupply,
-    decimals = _decimals,
-    name = _name,
-    symbol = _symbol,
-    balances = {[Call.caller] = _totalSupply }, // creator gets all Tokens
-    allowed = {},
-    // Logs, remove when native Events are there
-    transfer_log = [],
-    approval_log = []}
-
-  public stateful function totalSupply() : int = state.totalSupply
-  public stateful function decimals() : int = state.decimals
-  public stateful function name() : string = state.name
-  public stateful function symbol() : string = state.symbol
-
-  public stateful function balanceOf(tokenOwner : address ) : int =
-    Map.lookup_default(tokenOwner, state.balances, 0)
-
-  public stateful function transfer(to : address, tokens : int) =
-    put( state{balances[Call.caller] = sub(state.balances[Call.caller], tokens) })
-    put( state{balances[to] = add(Map.lookup_default(to, state.balances, 0), tokens) })
-    transferEvent(Call.caller, to, tokens)
-    true
-
-  public stateful function approve(spender : address, tokens : int) =
-    // allowed[Call.caller] field must have a value!
-    ensure_allowed(Call.caller)
-    put( state{allowed[Call.caller][spender] = tokens} )
-    approvalEvent(Call.caller, spender, tokens)
-    true
-
-  public stateful function transferFrom(from : address, to : address, tokens : int) =
-    put( state{ balances[from] = sub(state.balances[from], tokens) })
-    put( state{ allowed[from][Call.caller] = sub(state.allowed[from][Call.caller], tokens) })
-    put( state{ balances[to] = add(balanceOf(to), tokens) })
-    transferEvent(from, to, tokens)
-    true
-
-  public function allowance(_owner : address, _spender : address) : int =
-    state.allowed[_owner][_spender]
-
-  public stateful function getTransferLog() : list((address,address,int)) =
-    state.transfer_log
-  public stateful function getApprovalLog() : list((address,address,int)) =
-    state.approval_log
-
-  //
-  // Private Functions
-  //
-
-  private function ensure_allowed(key : address) =
-    switch(Map.lookup(key, state.allowed))
-      None => put(state{allowed[key] = {}})
-      Some(_) => ()
-
-  private function transferEvent(from : address, to : address, tokens : int) =
-    let e = (from, to, tokens)
-    put( state{transfer_log = e :: state.transfer_log })
-    e
-
-  private function approvalEvent(from : address, to : address, tokens : int) =
-    let e = (from, to, tokens)
-    put( state{approval_log = e :: state.approval_log })
-    e
-
-  private function sub(_a : int, _b : int) : int =
-    require(_b =< _a, "Error")
-    _a - _b
-
-  private function add(_a : int, _b : int) : int =
-    let c : int = _a + _b
-    require(c >= _a, "Error")
-    c

test/contracts/exploits.aes

@@ -1,6 +0,0 @@
-
-contract Exploits =
-
-  // We'll hack the bytecode of this changing the return type to string.
-  function pair(n : int) = (n, 0)
-

test/contracts/hole_expression.aes

@@ -0,0 +1,13 @@
+include "List.aes"
+
+contract C =
+    entrypoint f() =
+        let ??? = true
+        let v = ???
+        let q = v == "str"
+        let xs = [1, 2, 3, 4]
+        switch (List.first(List.map(???, xs)))
+            Some(x) => x + 1
+            None    => 0
+
+    function g() = ???

test/contracts/init_error.aes

@@ -1,9 +0,0 @@
-contract Remote =
-  function missing : (int) => int
-
-contract Init_error =
-
-  record state = {value : int}
-
-  function init(r : Remote, x : int) =
-    {value = r.missing(x)}

test/contracts/local_poly_fail.aes

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

test/contracts/manual_stdlib_include.aes

@@ -1,4 +1,4 @@
-// This should include Lists.aes implicitly, since Option.aes does.
+include "List.aes"
 include "Option.aes"
 
 contract Test =

test/contracts/map_of_maps.aes

@@ -1,36 +0,0 @@
-
-contract MapOfMaps =
-
-  type board = map(int, map(int, string))
-  type map2('a, 'b, 'c) = map('a, map('b, 'c))
-
-  record state = { big1   : map2(string, string, string),
-                   big2   : map2(string, string, string),
-                   small1 : map(string, string),
-                   small2 : map(string, string)  }
-
-  private function empty_state() =
-    { big1   = {}, big2   = {},
-      small1 = {}, small2 = {} }
-
-  function init() = empty_state()
-
-  function setup_state() =
-    let small = {["key"] = "val"}
-    put({ big1 = {["one"] = small},
-          big2 = {["two"] = small},
-          small1 = small,
-          small2 = small })
-
-  // -- Garbage collection of inner map when outer map is garbage collected
-  function test1_setup() =
-    let inner = {["key"] = "val"}
-    put(empty_state() { big1 = {["one"] = inner} })
-
-  function test1_execute() =
-    put(state{ big1 = {} })
-
-  function test1_check() =
-    state.big1
-
-

test/contracts/maps_benchmark.aes

@@ -1,29 +0,0 @@
-
-contract MapUpdater =
-  function update_map : (int, string, map(int, string)) => map(int, string)
-
-contract Benchmark =
-
-  record state = { updater : MapUpdater,
-                   map     : map(int, string) }
-
-  function init(u, m) = { updater = u, map = m }
-
-  function set_updater(u) = put(state{ updater = u })
-
-  function update_map(k : int, v : string, m) = m{ [k] = v }
-
-  function update(a : int, b : int, v : string) =
-    if (a > b) ()
-    else
-      put(state{ map[a] = v })
-      update(a + 1, b, v)
-
-  function get(k) = state.map[k]
-  function noop() = ()
-
-  function benchmark(k, v) =
-    let m = state.updater.update_map(k, v, state.map)
-    put(state{ map = m })
-    m
-

test/contracts/minimal_init.aes

@@ -1,6 +0,0 @@
-contract MinimalInit =
-
-  record state = {foo : int}
-
-  function init() =
-    { foo = 0 }

test/contracts/missing_init_fun_alias_to_alias_to_type.aes

@@ -0,0 +1,3 @@
+contract AliasToAliasToType =
+  type alias = int * int
+  type state = alias

test/contracts/missing_init_fun_alias_to_type.aes

@@ -0,0 +1,2 @@
+contract AliasToType =
+  type state = int * int

test/contracts/missing_init_fun_state_unit.aes

@@ -0,0 +1,9 @@
+contract AliasToAliasToUnit =
+  type alias = unit
+  type state = alias
+
+contract AliasToUnit =
+  type state = unit
+
+main contract ImplicitState =
+    type sometype = int

test/contracts/multiplication_server.aes

@@ -1,7 +0,0 @@
-
-contract MultiplicationServer =
-
-  function multiply(x : int, y : int) =
-    switch(Call.value >= 100)
-      true => x * y
-

test/contracts/name_clash.aes

@@ -1,12 +1,5 @@
-
 contract NameClash =
 
-  entrypoint double_proto : () => int
-  entrypoint double_proto : () => int
-
-  entrypoint proto_and_def : int => int
-  entrypoint proto_and_def(n) = n + 1
-
   entrypoint double_def(x) = x
   entrypoint double_def(y) = 0
 
@@ -14,4 +7,4 @@ contract NameClash =
   entrypoint abort() : int = 0
   entrypoint require(b, err) = if(b) abort(err)
   entrypoint put(x) = x
-  entrypoint state(x, y) = x + y
+  entrypoint state(x, y) = x + y