Renaming and preparing to remove oracles (#985)

A few references to oracles still remain, but they have been removed as a feature, at least.

Reviewed-on: #985
Reviewed-by: Ulf Wiger <ulfwiger@qpq.swiss>
Co-authored-by: Craig Everett <zxq9@zxq9.com>
Co-committed-by: Craig Everett <zxq9@zxq9.com>

.circleci/config.yml

@@ -1,37 +0,0 @@
-version: 2.1
-
-executors:
-  aebuilder:
-    docker:
-      - image: aeternity/builder
-        user: builder
-    working_directory: ~/aesophia
-
-jobs:
-  build:
-    executor: aebuilder
-    steps:
-      - checkout
-      - restore_cache:
-          keys:
-            - dialyzer-cache-v2-{{ .Branch }}-{{ .Revision }}
-            - dialyzer-cache-v2-{{ .Branch }}-
-            - dialyzer-cache-v2-
-      - run:
-          name: Build
-          command: ./rebar3 compile
-      - run:
-          name: Static Analysis
-          command: ./rebar3 dialyzer
-      - run:
-          name: Eunit
-          command: ./rebar3 eunit
-      - run:
-          name: Common Tests
-          command: ./rebar3 ct
-      - save_cache:
-          key: dialyzer-cache-v2-{{ .Branch }}-{{ .Revision }}
-          paths:
-            - _build/default/rebar3_20.3.8_plt
-      - store_artifacts:
-          path: _build/test/logs

.docssite/hook.py

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

.docssite/mkdocs.yml

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

.docssite/overrides/main.html

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

.gitea/workflows/test.yaml

@@ -0,0 +1,14 @@
+name: Sophia Tests
+run-name: ${{ gitea.actor }} testing Sophia
+on: [push, workflow_dispatch]
+
+jobs:
+  tests:
+    runs-on: linux_amd64
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v4
+      - name: test
+        run: |
+          . /home/act_runner/.erts/27.2.1/activate
+          ./rebar3 eunit

.gitignore

@@ -1,5 +1,5 @@
 .rebar3
-_*
+_[^_]*
 .eunit
 *.o
 *.beam
@@ -18,4 +18,10 @@ _build
 rebar3.crashdump
 *.erl~
 *.aes~
-aesophia
+sophia
+.qcci
+current_counterexample.eqc
+test/contracts/test.aes
+__pycache__
+.docssite/docs/*.md
+.vscode

CHANGELOG.md

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

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)

Emakefile

@@ -0,0 +1 @@
+{"src/*",  [debug_info, {i, "include/"}, {outdir, "ebin/"}]}.

LICENSE

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

README.md

@@ -1,25 +1,35 @@
-# aesophia
+# The Sophia smart contract language
 
-This is the __sophia__ compiler for the æternity system which compiles contracts written in __sophia__ code to the æternity VM code.
+This is the __sophia__ compiler which compiles contracts written in __sophia__ to [FATE](https://git.qpq.swiss/QPQ-AG/protocol/src/branch/master/contracts/fate.md) instructions.
 
-For more information about æternity smart contracts and the sophia language see [Smart Contracts](https://github.com/aeternity/protocol/blob/master/contracts/contracts.md) and the [Sophia Language](https://github.com/aeternity/protocol/blob/master/contracts/sophia.md).
+The compiler is currently being used three places
+ - [The command line compiler](https://git.qpq.swiss/QPQ-AG/sophia_cli)
+ - [Desktop wallet](https://git.qpq.swiss/QPQ-AG/GajuDesk)
+ - In the [Gajumaru core node](https://git.qpq.swiss/QPQ-AG/gajumaru) tests
 
-It is an OTP application written in Erlang and is by default included in
-[the æternity node](https://github.com/aeternity/epoch). However, it can
-also be included in other systems to compile contracts coded in sophia which
-can then be loaded into the æternity system.
+## Documentation
+
+* [Introduction](docs/index.md)
+* [Syntax](docs/sophia_syntax.md)
+* [Features](docs/sophia_features.md)
+* [Standard library](docs/sophia_stdlib.md)
+* [Contract examples](docs/sophia_examples.md)
+* [Contributing](CONTRIBUTING.md)
+
+Additionally you can check out the [contracts section](https://git.qpq.swiss/QPQ-AG/protocol/src/branch/master/contracts) of the Gajumaru blockchain specification.
 
 ## Versioning
 
-`aesophia` has a version that is only loosely connected to the version of the
-Aeternity node - in principle they will share the major version but not
-minor/patch version. The `aesophia` compiler version MUST be bumped whenever
-there is a change in how byte code is generated, but it MAY also be bumped upon
-API changes etc.
+Versioning should follow the [semantic versioning](https://semver.org/spec/v2.0.0) guidelines. Id est, given a version number MAJOR.MINOR.PATCH, increment the:
+
+- MAJOR version when you make incompatible API changes
+- MINOR version when you add functionality in a backwards compatible manner
+- PATCH version when you make backwards compatible bug fixes
+
 
 ## Interface Modules
 
 The basic modules for interfacing the compiler:
 
-* [aeso_compiler: the Sophia compiler](./docs/aeso_compiler.md)
-* [aeso_aci: the ACI interface](./docs/aeso_aci.md)
+* [so_compiler: the Sophia compiler](docs/so_compiler.md)
+* [so_aci: the ACI interface](docs/so_aci.md)

docs/RELEASE-NOTES-2.0.0.md

@@ -1,16 +0,0 @@
-# About this release
-
-This is the `aesophia` compiler version 2.0.0. The main changes compared to version 1.2.0 are:
-
-* Add `Crypto.ecverify` to the compiler.
-* Add `Crypto.sha3`, `Crypto.blake2`, `Crypto.sha256`, `String.blake2` and
-  `String.sha256` to the compiler.
-* Add the `bits` type for working with bit fields in Sophia.
-* Use native bit shift operations in builtin functions, reducing gas cost.
-* Add Namespaces to Sophia in order to simplify using library contracts, etc.
-* Simplify calldata creation - instead of passing a compiled contract, simply
-  pass a (stubbed) contract string.
-* Add a missig type check on the `init` function - detects programmer errors earlier.
-* Improve type checking of `record` fields - generates more understandable error messages.
-* Improved, more coherent, error messages.
-* Add the ACI (Aeternity Contract Interface) generator.

docs/aeso_aci.md

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

docs/index.md

@@ -0,0 +1,9 @@
+# Introduction
+Sophia is a functional language designed for smart contract development.
+It is strongly typed and has restricted mutable state.
+
+Sophia is customized for smart contracts, which can be published to a blockchain.
+Thus some features of conventional languages (such as floating point arithmetic) are not present in Sophia,
+and some blockchain specific primitives, constructions and types have been added.
+
+The file extension used for Sophia source files is ".aes", reflecting Sophia's Aeternity heritage.

docs/so_aci.md

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

docs/so_compiler.md

@@ -1,8 +1,8 @@
-# aeso_compiler
+# so_compiler
 
 ### Module
 
-### aeso_compiler
+### so_compiler
 
 The Sophia compiler
 
@@ -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.md

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

docs/sophia_examples.md

@@ -0,0 +1,67 @@
+# Contract examples
+
+## Crowdfunding
+```sophia
+/*
+ * A simple crowd-funding example
+ */
+contract FundMe =
+
+  record spend_args = { recipient : address,
+                        amount    : int }
+
+  record state = { contributions : map(address, int),
+                   total         : int,
+                   beneficiary   : address,
+                   deadline      : int,
+                   goal          : int }
+
+  stateful function spend(args : spend_args) =
+    Chain.spend(args.recipient, args.amount)
+
+  entrypoint init(beneficiary, deadline, goal) : state =
+    { contributions = {},
+      beneficiary   = beneficiary,
+      deadline      = deadline,
+      total         = 0,
+      goal          = goal }
+
+  function is_contributor(addr) =
+    Map.member(addr, state.contributions)
+
+  stateful entrypoint contribute() =
+    if(Chain.block_height >= state.deadline)
+      spend({ recipient = Call.caller, amount = Call.value }) // Refund money
+      false
+    else
+      let amount =
+        switch(Map.lookup(Call.caller, state.contributions))
+          None    => Call.value
+          Some(n) => n + Call.value
+      put(state{ contributions[Call.caller] = amount,
+                 total @ tot = tot + Call.value })
+      true
+
+  stateful entrypoint withdraw() =
+    if(Chain.block_height < state.deadline)
+      abort("Cannot withdraw before deadline")
+    if(Call.caller == state.beneficiary)
+      withdraw_beneficiary()
+    elif(is_contributor(Call.caller))
+      withdraw_contributor()
+    else
+      abort("Not a contributor or beneficiary")
+
+  stateful function withdraw_beneficiary() =
+    require(state.total >= state.goal, "Project was not funded")
+    spend({recipient = state.beneficiary,
+           amount    = Contract.balance })
+
+  stateful function withdraw_contributor() =
+    if(state.total >= state.goal)
+      abort("Project was funded")
+    let to = Call.caller
+    spend({recipient = to,
+           amount    = state.contributions[to]})
+    put(state{ contributions @ c = Map.delete(to, c) })
+```

docs/sophia_syntax.md

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

include/aeso_heap.hrl

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

include/so_parse_lib.hrl

@@ -0,0 +1,27 @@
+
+-define(LET_P(X, P, Q), so_parse_lib:bind(P, fun(X) -> Q end)).
+-define(LAZY_P(P),      so_parse_lib:lazy(fun() -> P end)).
+-define(MEMO_P(P),      so_parse_lib:lazy(so_parse_lib:memoised(fun() -> P end))).
+
+-define(GUARD_P(G, P),
+    case G of
+        true  -> P;
+        false -> fail()
+    end).
+
+-define(RULE(A,                      Do), map(fun(_1) ->                               Do end, A                       )).
+-define(RULE(A, B,                   Do), map(fun({_1, _2}) ->                         Do end, {A, B}                  )).
+-define(RULE(A, B, C,                Do), map(fun({_1, _2, _3}) ->                     Do end, {A, B, C}               )).
+-define(RULE(A, B, C, D,             Do), map(fun({_1, _2, _3, _4}) ->                 Do end, {A, B, C, D}            )).
+-define(RULE(A, B, C, D, E,          Do), map(fun({_1, _2, _3, _4, _5}) ->             Do end, {A, B, C, D, E}         )).
+-define(RULE(A, B, C, D, E, F,       Do), map(fun({_1, _2, _3, _4, _5, _6}) ->         Do end, {A, B, C, D, E, F}      )).
+-define(RULE(A, B, C, D, E, F, G,    Do), map(fun({_1, _2, _3, _4, _5, _6, _7}) ->     Do end, {A, B, C, D, E, F, G}   )).
+-define(RULE(A, B, C, D, E, F, G, H, Do), map(fun({_1, _2, _3, _4, _5, _6, _7, _8}) -> Do end, {A, B, C, D, E, F, G, H})).
+
+-import(so_parse_lib,
+        [tok/1, tok/2, between/3, many/1, many1/1, sep/2, sep1/2,
+         infixl/1, infixr/1, choice/1, choice/2, return/1, layout/0,
+         fail/0, fail/1, fail/2, map/2, infixl/2, infixr/2, infixl1/2, infixr1/2,
+         left/2, right/2, optional/1]).
+
+

include/so_utils.hrl

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

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

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

priv/stdlib/Frac.aes

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

priv/stdlib/Func.aes

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

priv/stdlib/List.aes

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

priv/stdlib/ListInternal.aes

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

priv/stdlib/Option.aes

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

priv/stdlib/Pair.aes

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

priv/stdlib/Set.aes

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

priv/stdlib/String.aes

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

priv/stdlib/Triple.aes

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

rebar.config

@@ -2,26 +2,11 @@
 
 {erl_opts, [debug_info]}.
 
-{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git",
-                            {ref, "9041423"}}}
-       , {getopt, "1.0.1"}
-       , {jsx, {git, "https://github.com/talentdeficit/jsx.git",
-                     {tag, "2.8.0"}}}
-       ]}.
-
-{escript_incl_apps, [aesophia, aebytecode, getopt]}.
-{escript_main_app, aesophia}.
-{escript_name, aesophia}.
-{escript_emu_args, "%%! \n"}.
-{provider_hooks, [{post, [{compile, escriptize}]}]}.
-
-{post_hooks, [{"(linux|darwin|solaris|freebsd|netbsd|openbsd)",
-               escriptize,
-               "cp \"$REBAR_BUILD_DIR/bin/aesophia\" ./aesophia"},
-              {"win32",
-               escriptize,
-               "robocopy \"%REBAR_BUILD_DIR%/bin/\" ./ aesophia* "
-               "/njs /njh /nfl /ndl & exit /b 0"} % silence things
+{deps, [ {gmbytecode,
+          {git, "https://git.qpq.swiss/QPQ-AG/gmbytecode.git",
+          {ref, "97cea33be8f3a35d26055664da7aa59531ff5537"}}}
+       , {eblake2, "1.0.0"}
+       , {jsx, {git, "https://github.com/talentdeficit/jsx.git", {tag, "2.8.0"}}}
        ]}.
 
 {dialyzer, [
@@ -30,10 +15,11 @@
             {base_plt_apps, [erts, kernel, stdlib, crypto, mnesia]}
            ]}.
 
-{relx, [{release, {aesophia, "2.0.0"},
-         [aesophia, aebytecode, getopt]},
+{relx, [{release, {sophia, "9.0.0"},
+         [sophia, gmbytecode]},
 
         {dev_mode, true},
         {include_erts, false},
 
         {extended_start_script, true}]}.
+

rebar.lock

@@ -1,24 +1,30 @@
-{"1.1.0",
-[{<<"aebytecode">>,
-  {git,"https://github.com/aeternity/aebytecode.git",
-       {ref,"9041423906247a7267a5a94530307b19c4490e8c"}},
+{"1.2.0",
+[{<<"gmbytecode">>,
+  {git,"https://git.qpq.swiss/QPQ-AG/gmbytecode.git",
+       {ref, "97cea33be8f3a35d26055664da7aa59531ff5537"}},
   0},
- {<<"aeserialization">>,
-  {git,"https://github.com/aeternity/aeserialization.git",
-       {ref,"6dce265753af4e651f77746e77ea125145c85dd3"}},
+ {<<"gmserialization">>,
+  {git,"https://git.qpq.swiss/QPQ-AG/gmserialization.git",
+       {ref,"ac64e01b0f675c1a34c70a827062f381920742db"}},
   1},
  {<<"base58">>,
-  {git,"https://github.com/aeternity/erl-base58.git",
-       {ref,"60a335668a60328a29f9731b67c4a0e9e3d50ab6"}},
+  {git,"https://git.qpq.swiss/QPQ-AG/erl-base58.git",
+       {ref,"e6aa62eeae3d4388311401f06e4b939bf4e94b9c"}},
   2},
- {<<"eblake2">>,{pkg,<<"eblake2">>,<<"1.0.0">>},1},
- {<<"getopt">>,{pkg,<<"getopt">>,<<"1.0.1">>},0},
+ {<<"eblake2">>,
+  {git,"https://git.qpq.swiss/QPQ-AG/eblake2.git",
+       {ref,"b29d585b8760746142014884007eb8441a3b6a14"}},
+  0},
+ {<<"enacl">>,
+  {git,"https://git.qpq.swiss/QPQ-AG/enacl.git",
+       {ref,"4eb7ec70084ba7c87b1af8797c4c4e90c84f95a2"}},
+  2},
+ {<<"getopt">>,
+  {git,"https://git.qpq.swiss/QPQ-AG/getopt.git",
+       {ref,"dbab6262a2430809430deda9d8650f58f9d80898"}},
+  1},
  {<<"jsx">>,
   {git,"https://github.com/talentdeficit/jsx.git",
        {ref,"3074d4865b3385a050badf7828ad31490d860df5"}},
   0}]}.
-[
-{pkg_hash,[
- {<<"eblake2">>, <<"EC8AD20E438AAB3F2E8D5D118C366A0754219195F8A0F536587440F8F9BCF2EF">>},
- {<<"getopt">>, <<"C73A9FA687B217F2FF79F68A3B637711BB1936E712B521D8CE466B29CBF7808A">>}]}
-].
+

src/aeso_abi.erl

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

src/aeso_aci.erl

@@ -1,276 +0,0 @@
-%%%-------------------------------------------------------------------
-%%% @author Robert Virding
-%%% @copyright (C) 2017, Aeternity Anstalt
-%%% @doc
-%%%     ACI interface
-%%% @end
-%%% Created : 12 Dec 2017
-%%%-------------------------------------------------------------------
-
--module(aeso_aci).
-
--export([encode/1,encode/2,decode/1]).
-
-%% Define records for the various typed syntactic forms. These make
-%% the code easier but don't seem to exist elsewhere.
-
--record(contract, {ann,con,decls}).
-%% -record(namespace, {ann,con,decls}).
--record(letfun, {ann,id,args,type,body}).
--record(type_def, {ann,id,vars,typedef}).
-
--record(app_t, {ann,id,fields}).
--record(tuple_t, {ann,args}).
--record(record_t, {fields}).
--record(field_t, {ann,id,type}).
--record(alias_t, {type}).
--record(variant_t, {cons}).
--record(constr_t, {ann,con,args}).
--record(fun_t, {ann,named,args,type}).
-
--record(arg, {ann,id,type}).
--record(id, {ann,name}).
--record(con, {ann,name}).
--record(qid, {ann,names}).
--record(qcon, {ann,names}).
--record(tvar, {ann,name}).
-
-%% encode(ContractString) -> {ok,JSON} | {error,String}.
-%% encode(ContractString, Options) -> {ok,JSON} | {error,String}.
-%%  Build a JSON structure with lists and tuples, not maps, as this
-%%  allows us to order the fields in the contructed JSON string.
-
-encode(ContractString) -> encode(ContractString, []).
-
-encode(ContractString, Options) when is_binary(ContractString) ->
-    encode(binary_to_list(ContractString), Options);
-encode(ContractString, Options) ->
-    try
-        Ast = parse(ContractString, Options),
-        %%io:format("~p\n", [Ast]),
-        %% aeso_ast:pp(Ast),
-        TypedAst = aeso_ast_infer_types:infer(Ast, Options),
-        %% io:format("~p\n", [TypedAst]),
-        %% aeso_ast:pp_typed(TypedAst),
-        %% We find and look at the last contract.
-        Contract = lists:last(TypedAst),
-        Cname = contract_name(Contract),
-        Tdefs = [ encode_typedef(T) ||
-                    T <- sort_decls(contract_types(Contract)) ],
-        Fdefs = [ encode_func(F) || F <- sort_decls(contract_funcs(Contract)),
-                                    not is_private_func(F) ],
-        Jmap = [{<<"contract">>, [{<<"name">>, list_to_binary(Cname)},
-                                  {<<"type_defs">>, Tdefs},
-                                  {<<"functions">>, Fdefs}]}],
-        %% io:format("~p\n", [Jmap]),
-        {ok,jsx:encode(Jmap)}
-    catch
-        %% The compiler errors.
-        error:{parse_errors, Errors} ->
-            {error, join_errors("Parse errors", Errors, fun(E) -> E end)};
-        error:{type_errors, Errors} ->
-            {error, join_errors("Type errors", Errors, fun(E) -> E end)};
-        error:{code_errors, Errors} ->
-            {error, join_errors("Code errors", Errors,
-                                fun (E) -> io_lib:format("~p", [E]) end)}
-        %% General programming errors in the compiler just signal error.
-    end.
-
-join_errors(Prefix, Errors, Pfun) ->
-    Ess = [ Pfun(E) || E <- Errors ],
-    list_to_binary(string:join([Prefix|Ess], "\n")).
-
-encode_func(Fdef) ->
-    Name = function_name(Fdef),
-    Args = function_args(Fdef),
-    Type = function_type(Fdef),
-    [{<<"name">>, list_to_binary(Name)},
-     {<<"arguments">>, encode_args(Args)},
-     {<<"type">>, list_to_binary(encode_type(Type))},
-     {<<"stateful">>, is_stateful_func(Fdef)}].
-
-encode_args(Args) ->
-    [ encode_arg(A) || A <- Args ].
-
-encode_arg(#arg{id=Id,type=T}) ->
-    [{<<"name">>,list_to_binary(encode_type(Id))},
-     {<<"type">>,list_to_binary(encode_type(T))}].
-
-encode_types(Types) ->
-    [ encode_type(T) || T <- Types ].
-
-encode_type(#tvar{name=N}) -> N;
-encode_type(#id{name=N}) -> N;
-encode_type(#con{name=N}) -> N;
-encode_type(#qid{names=Ns}) ->
-    lists:join(".", Ns);
-encode_type(#qcon{names=Ns}) ->
-    lists:join(".", Ns);                        %?
-encode_type(#tuple_t{args=As}) ->
-    Eas = encode_types(As),
-    [$(,lists:join(",", Eas),$)];
-encode_type(#record_t{fields=Fs}) ->
-    Efs = encode_types(Fs),
-    [${,lists:join(",", Efs),$}];
-encode_type(#app_t{id=Id,fields=Fs}) ->
-    Name = encode_type(Id),
-    Efs = encode_types(Fs),
-    [Name,"(",lists:join(",", Efs),")"];
-encode_type(#field_t{id=Id,type=T}) ->
-    [encode_type(Id)," : ",encode_type(T)];
-encode_type(#variant_t{cons=Cs}) ->
-    Ecs = encode_types(Cs),
-    lists:join(" | ", Ecs);
-encode_type(#constr_t{con=C,args=As}) ->
-    Ec = encode_type(C),
-    Eas = encode_types(As),
-    [Ec,$(,lists:join(", ", Eas),$)];
-encode_type(#fun_t{args=As,type=T}) ->
-    Eas = encode_types(As),
-    Et = encode_type(T),
-    [$(,lists:join(", ", Eas),") => ",Et].
-
-encode_typedef(Type) ->
-    Name = typedef_name(Type),
-    Vars = typedef_vars(Type),
-    Def = typedef_def(Type),
-    [{<<"name">>, list_to_binary(Name)},
-     {<<"vars">>, encode_tvars(Vars)},
-     {<<"typedef">>, list_to_binary(encode_alias(Def))}].
-
-encode_tvars(Vars) ->
-    [ encode_tvar(V) || V <- Vars ].
-
-encode_tvar(#tvar{name=N}) ->
-    [{<<"name">>, list_to_binary(N)}].
-
-encode_alias(#alias_t{type=T}) ->
-    encode_type(T);
-encode_alias(A) -> encode_type(A).
-
-%% decode(JSON) -> ContractString.
-%%  Decode a JSON string and generate a suitable contract string which
-%%  can be included in a contract definition. We decode into a map
-%%  here as this is easier to work with and order is not important.
-
-decode(Json) ->
-    Map = jsx:decode(Json, [return_maps]),
-    %% io:format("~p\n", [Map]),
-    #{<<"contract">> := C} = Map,
-    list_to_binary(decode_contract(C)).
-
-decode_contract(#{<<"name">> := Name,
-                  <<"type_defs">> := _Ts,
-                  <<"functions">> := Fs}) ->
-    ["contract"," ",io_lib:format("~s", [Name])," =\n",
-     [],                                        %Don't include types yet.
-     %% decode_tdefs(Ts),
-     decode_funcs(Fs)].
-
-decode_funcs(Fs) -> [ decode_func(F) || F <- Fs ].
-
-decode_func(#{<<"name">> := <<"init">>}) -> [];
-decode_func(#{<<"name">> := Name,<<"arguments">> := As,<<"type">> := T}) ->
-    ["  function"," ",io_lib:format("~s", [Name])," : ",
-     decode_args(As)," => ",decode_type(T),$\n].
-
-decode_type(T) -> io_lib:format("~s", [T]).
-
-decode_args(As) ->
-    Das = [ decode_arg(A) || A <- As ],
-    [$(,lists:join(", ", Das),$)].
-
-decode_arg(#{<<"type">> := T}) -> decode_type(T).
-
-%% To keep dialyzer happy and quiet.
-%% decode_tdefs(Ts) -> [ decode_tdef(T) || T <- Ts ].
-%%
-%% decode_tdef(#{<<"name">> := Name,<<"vars">> := Vs,<<"typedef">> := T}) ->
-%%     ["  type"," ",io_lib:format("~s", [Name]),decode_tvars(Vs),
-%%      " = ",decode_type(T),$\n].
-%%
-%% decode_tvars([]) -> [];                         %No tvars, no parentheses
-%% decode_tvars(Vs) ->
-%%     Dvs = [ decode_tvar(V) || V <- Vs ],
-%%     [$(,lists:join(", ", Dvs),$)].
-%%
-%% decode_tvar(#{<<"name">> := N}) -> io_lib:format("~s", [N]).
-%%
-%% #contract{Ann, Con, [Declarations]}.
-
-contract_name(#contract{con=#con{name=N}}) -> N.
-
-contract_funcs(#contract{decls=Decls}) ->
-    [ D || D <- Decls, is_record(D, letfun) ].
-
-contract_types(#contract{decls=Decls}) ->
-    [ D || D <- Decls, is_record(D, type_def) ].
-
-%% To keep dialyzer happy and quiet.
-%% namespace_name(#namespace{con=#con{name=N}}) -> N.
-%%
-%% namespace_funcs(#namespace{decls=Decls}) ->
-%%     [ D || D <- Decls, is_record(D, letfun) ].
-%%
-%% namespace_types(#namespace{decls=Decls}) ->
-%%     [ D || D <- Decls, is_record(D, type_def) ].
-
-sort_decls(Ds) ->
-    Sort = fun (D1, D2) ->
-                   aeso_syntax:get_ann(line, D1, 0) =<
-                       aeso_syntax:get_ann(line, D2, 0)
-           end,
-    lists:sort(Sort, Ds).
-
-%% #letfun{Ann, Id, [Arg], Type, Typedef}.
-
-function_name(#letfun{id=#id{name=N}}) -> N.
-
-function_args(#letfun{args=Args}) -> Args.
-
-function_type(#letfun{type=Type}) -> Type.
-
-is_private_func(#letfun{ann=A}) -> aeso_syntax:get_ann(private, A, false).
-
-is_stateful_func(#letfun{ann=A}) -> aeso_syntax:get_ann(stateful, A, false).
-
-%% #type_def{Ann, Id, [Var], Typedef}.
-
-typedef_name(#type_def{id=#id{name=N}}) -> N.
-
-typedef_vars(#type_def{vars=Vars}) -> Vars.
-
-typedef_def(#type_def{typedef=Def}) -> Def.
-
-parse(Text, Options) ->
-    %% Try and return something sensible here!
-    case aeso_parser:string(Text, Options) of
-        %% Yay, it worked!
-        {ok, Contract} -> Contract;
-        %% Scan errors.
-        {error, {Pos, scan_error}} ->
-            parse_error(Pos, "scan error");
-        {error, {Pos, scan_error_no_state}} ->
-            parse_error(Pos, "scan error");
-        %% Parse errors.
-        {error, {Pos, parse_error, Error}} ->
-            parse_error(Pos, Error);
-        {error, {Pos, ambiguous_parse, As}} ->
-            ErrorString = io_lib:format("Ambiguous ~p", [As]),
-            parse_error(Pos, ErrorString);
-        %% Include error
-        {error, {Pos, include_error, File}} ->
-            parse_error(Pos, io_lib:format("could not find include file '~s'", [File]))
-    end.
-
-parse_error(Pos, ErrorString) ->
-    io:format("Error ~p ~p\n", [Pos,ErrorString]),
-    Error = io_lib:format("~s: ~s", [pos_error(Pos), ErrorString]),
-    error({parse_errors, [Error]}).
-
-pos_error({Line, Pos}) ->
-    io_lib:format("line ~p, column ~p", [Line, Pos]);
-pos_error({no_file, Line, Pos}) ->
-    pos_error({Line, Pos});
-pos_error({File, Line, Pos}) ->
-    io_lib:format("file ~s, line ~p, column ~p", [File, Line, Pos]).

src/aeso_ast_to_icode.erl

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

src/aeso_builtins.erl

@@ -1,500 +0,0 @@
-%%%-------------------------------------------------------------------
-%%% @copyright (C) 2018, Aeternity Anstalt
-%%% @doc
-%%%     Compiler builtin functions for Aeterinty Sophia language.
-%%% @end
-%%% Created : 20 Dec 2018
-%%%
-%%%-------------------------------------------------------------------
-
--module(aeso_builtins).
-
--export([ builtin_function/1
-        , check_event_type/1
-        , used_builtins/1 ]).
-
--import(aeso_ast_to_icode, [prim_call/5]).
-
--include_lib("aebytecode/include/aeb_opcodes.hrl").
--include("aeso_icode.hrl").
-
-used_builtins(#funcall{ function = #var_ref{ name = {builtin, Builtin} }, args = Args }) ->
-    lists:umerge(dep_closure([Builtin]), used_builtins(Args));
-used_builtins([H|T]) ->
-  lists:umerge(used_builtins(H), used_builtins(T));
-used_builtins(T) when is_tuple(T) ->
-  used_builtins(tuple_to_list(T));
-used_builtins(M) when is_map(M) ->
-  used_builtins(maps:to_list(M));
-used_builtins(_) -> [].
-
-builtin_deps(Builtin) ->
-    lists:usort(builtin_deps1(Builtin)).
-
-builtin_deps1({map_lookup_default, Type}) -> [{map_lookup, Type}];
-builtin_deps1({map_get, Type})            -> [{map_lookup, Type}];
-builtin_deps1(map_member)                 -> [{map_lookup, word}];
-builtin_deps1({map_upd, Type})            -> [{map_get, Type}, map_put];
-builtin_deps1({map_upd_default, Type})    -> [{map_lookup_default, Type}, map_put];
-builtin_deps1(map_from_list)              -> [map_put];
-builtin_deps1(str_equal)                  -> [str_equal_p];
-builtin_deps1(string_concat)              -> [string_concat_inner1, string_copy, string_shift_copy];
-builtin_deps1(int_to_str)                 -> [{baseX_int, 10}];
-builtin_deps1(addr_to_str)                -> [{baseX_int, 58}];
-builtin_deps1({baseX_int, X})             -> [{baseX_int_pad, X}];
-builtin_deps1({baseX_int_pad, X})         -> [{baseX_int_encode, X}];
-builtin_deps1({baseX_int_encode, X})      -> [{baseX_int_encode_, X}, {baseX_tab, X}, {baseX_digits, X}];
-builtin_deps1(string_reverse)             -> [string_reverse_];
-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(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, v(Ptr), [{{tuple, [v(Var)]}, Body}]}).
--define(NXT(Ptr), op('+', Ptr, 32)).
--define(NEG(A), op('/', A, {unop, '-', {integer, 1}})).
--define(BYTE(Ix, Word), op('byte', Ix, Word)).
-
--define(EQ(A, B), op('==', A, B)).
--define(LT(A, B), op('<', A, B)).
--define(GT(A, B), op('>', A, B)).
--define(ADD(A, B), op('+', A, B)).
--define(SUB(A, B), op('-', A, B)).
--define(MUL(A, B), op('*', A, B)).
--define(DIV(A, B), op('div', A, B)).
--define(MOD(A, B), op('mod', A, B)).
--define(EXP(A, B), op('^', A, B)).
--define(AND(A, B), op('&&', A, B)).
-
-%% Bit shift operations takes their arguments backwards!?
--define(BSL(X, B), op('bsl', ?MUL(B, 8), X)).
--define(BSR(X, B), op('bsr', ?MUL(B, 8), X)).
-
-op(Op, A, B) -> {binop, Op, operand(A), operand(B)}.
-
-operand(A) when is_atom(A) -> v(A);
-operand(I) when is_integer(I) -> {integer, I};
-operand(T) -> T.
-
-str_to_icode(String) when is_list(String) ->
-    str_to_icode(list_to_binary(String));
-str_to_icode(BinStr) ->
-    Cpts = [size(BinStr) | aeso_memory:binary_to_words(BinStr)],
-    #tuple{ cpts = [ #integer{value = X} || X <- Cpts ] }.
-
-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} of
-        {indexed, word}      -> ok;
-        {notindexed, string} -> ok;
-        {indexed, _}         -> error({EvtName, indexed_field_should_be_word, is, VMType});
-        {notindexed, _}      -> error({EvtName, payload_should_be_string, is, VMType})
-    end.
-
-bfun(B, {IArgs, IExpr, IRet}) ->
-    {{builtin, B}, [private], IArgs, IExpr, IRet}.
-
-builtin_function(BF) ->
-    case BF of
-        {event, EventT}            -> bfun(BF, builtin_event(EventT));
-        abort                      -> bfun(BF, builtin_abort());
-        {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));
-        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]};
-           ([V]) -> {seq, [V, {inline_asm, [A(?DUP1), A(?MLOAD),                  %% length, ptr
-                                            A(?SWAP1), A(?PUSH1), 32, A(?ADD)]}]} %% ptr+32, length
-        end,
-    Clause =
-        fun(_Tag, {con, _, Con}, IxTypes) ->
-            Types     = [ T || {_Ix, T} <- IxTypes ],
-            Indexed   = [ Var || {Var, {indexed, _Type}} <- lists:zip(ArgPats(Types), IxTypes) ],
-            EvtIndex  = {unop, 'sha3', str_to_icode(Con)},
-            {event, lists:reverse(Indexed) ++ [EvtIndex], Payload(ArgPats(Types) -- Indexed)}
-        end,
-    Pat = fun(Tag, Types) -> {tuple, [{integer, Tag} | ArgPats(Types)]} end,
-
-    {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,[]}}.
-
-%% 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 = 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_string_reverse() ->
-    {[{"s", string}],
-     ?DEREF(n, s,
-     ?LET(ret, {inline_asm, [?A(?MSIZE)]},
-         {seq, [?V(n), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
-                ?call(string_reverse_, [?NXT(s), ?I(0), ?I(31), ?SUB(?V(n), 1)]),
-                {inline_asm, [?A(?POP)]}, ?V(ret)]})),
-     word}.
-
-builtin_string_reverse_() ->
-    {[{"p", pointer}, {"x", word}, {"i1", word}, {"i2", word}],
-     {ifte, ?LT(i2, 0),
-         {seq, [?V(x), {inline_asm, [?A(?MSIZE), ?A(?MSTORE), ?A(?MSIZE)]}]},
-         ?LET(p1, ?ADD(p, ?MUL(?DIV(i2, 32), 32)),
-         ?DEREF(w, p1,
-         ?LET(b, ?BYTE(?MOD(i2, 32), w),
-         {ifte, ?LT(i1, 0),
-             {seq, [?V(x), {inline_asm, [?A(?MSIZE), ?A(?MSTORE)]},
-                    ?call(string_reverse_,
-                          [?V(p), ?BSL(b, 31), ?I(30), ?SUB(i2, 1)])]},
-             ?call(string_reverse_,
-                   [?V(p), ?ADD(x, ?BSL(b, i1)), ?SUB(i1, 1), ?SUB(i2, 1)])})))},
-     word}.
-
-builtin_addr_to_str() ->
-    {[{"a", word}], ?call({baseX_int, 58}, [?V(a)]), word}.
-

src/aeso_compiler.erl

@@ -1,518 +0,0 @@
-%%%-------------------------------------------------------------------
-%%% @author Happi (Erik Stenman)
-%%% @copyright (C) 2017, Aeternity Anstalt
-%%% @doc
-%%%     Compiler from Aeterinty Sophia language to the Aeternity VM, aevm.
-%%% @end
-%%% Created : 12 Dec 2017
-%%%-------------------------------------------------------------------
--module(aeso_compiler).
-
--export([ file/1
-        , file/2
-        , from_string/2
-        , check_call/4
-        , create_calldata/3
-        , version/0
-        , sophia_type_to_typerep/1
-        , to_sophia_value/4
-        , to_sophia_value/5
-        , decode_calldata/3
-        ]).
-
--include_lib("aebytecode/include/aeb_opcodes.hrl").
--include("aeso_icode.hrl").
-
-
--type option() :: pp_sophia_code
-                | pp_ast
-                | pp_types
-                | pp_typed_ast
-                | pp_icode
-                | pp_assembler
-                | pp_bytecode
-                | {include, {file_system, [string()]} |
-                            {explicit_files, #{string() => binary()}}}
-                | {src_file, string()}.
--type options() :: [option()].
-
--export_type([ option/0
-             , options/0
-             ]).
-
--spec version() -> {ok, binary()} | {error, term()}.
-version() ->
-    case lists:keyfind(aesophia, 1, application:loaded_applications()) of
-        false ->
-            case application:load(aesophia) of
-                ok ->
-                    case application:get_key(aesophia, vsn) of
-                        {ok, VsnString} ->
-                            {ok, list_to_binary(VsnString)};
-                        undefined ->
-                            {error, failed_to_load_aesophia}
-                    end;
-                Err = {error, _} ->
-                    Err
-            end;
-        {_App, _Des, VsnString} ->
-            {ok, list_to_binary(VsnString)}
-    end.
-
--spec file(string()) -> {ok, map()} | {error, binary()}.
-file(Filename) ->
-    Dir = filename:dirname(Filename),
-    {ok, Cwd} = file:get_cwd(),
-    file(Filename, [{include, {file_system, [Cwd, Dir]}}]).
-
--spec file(string(), options()) -> {ok, map()} | {error, binary()}.
-file(File, Options) ->
-    case read_contract(File) of
-        {ok, Bin} -> from_string(Bin, [{src_file, File} | Options]);
-        {error, Error} ->
-	    ErrorString = [File,": ",file:format_error(Error)],
-	    {error, join_errors("File errors", [ErrorString], fun(E) -> E end)}
-    end.
-
--spec from_string(binary() | string(), options()) -> {ok, map()} | {error, binary()}.
-from_string(ContractBin, Options) when is_binary(ContractBin) ->
-    from_string(binary_to_list(ContractBin), Options);
-from_string(ContractString, Options) ->
-    try
-        #{icode := Icode} = string_to_icode(ContractString, Options),
-        TypeInfo  = extract_type_info(Icode),
-        Assembler = assemble(Icode, Options),
-        pp_assembler(Assembler, Options),
-        ByteCodeList = to_bytecode(Assembler, Options),
-        ByteCode = << << B:8 >> || B <- ByteCodeList >>,
-        pp_bytecode(ByteCode, Options),
-        {ok, Version} = version(),
-        {ok, #{byte_code => ByteCode,
-               compiler_version => Version,
-               contract_source => ContractString,
-               type_info => TypeInfo
-              }}
-    catch
-        %% The compiler errors.
-        error:{parse_errors, Errors} ->
-            {error, join_errors("Parse errors", Errors, fun(E) -> E end)};
-        error:{type_errors, Errors} ->
-            {error, join_errors("Type errors", Errors, fun(E) -> E end)};
-        error:{code_errors, Errors} ->
-            {error, join_errors("Code errors", Errors,
-                                fun (E) -> io_lib:format("~p", [E]) end)}
-        %% General programming errors in the compiler just signal error.
-    end.
-
--spec string_to_icode(string(), [option() | permissive_address_literals]) -> map().
-string_to_icode(ContractString, Options0) ->
-    {InferOptions, Options} = lists:partition(fun(Opt) -> Opt == permissive_address_literals end, Options0),
-    Ast = parse(ContractString, Options),
-    pp_sophia_code(Ast, Options),
-    pp_ast(Ast, Options),
-    {TypeEnv, TypedAst} = aeso_ast_infer_types:infer(Ast, [return_env | InferOptions]),
-    pp_typed_ast(TypedAst, Options),
-    Icode = ast_to_icode(TypedAst, Options),
-    pp_icode(Icode, Options),
-    #{ typed_ast => TypedAst,
-       type_env  => TypeEnv,
-       icode     => Icode }.
-
-join_errors(Prefix, Errors, Pfun) ->
-    Ess = [ Pfun(E) || E <- Errors ],
-    list_to_binary(string:join([Prefix|Ess], "\n")).
-
--define(CALL_NAME,   "__call").
--define(DECODE_NAME, "__decode").
-
-%% Takes a string containing a contract with a declaration/prototype of a
-%% function (foo, say) and adds function __call() = foo(args) calling this
-%% function. Returns the name of the called functions, typereps and Erlang
-%% terms for the arguments.
-%% NOTE: Special treatment for "init" since it might be implicit and has
-%%       a special return type (typerep, T)
--spec check_call(string(), string(), [string()], options()) -> {ok, string(), {[Type], Type}, [term()]} | {error, term()}
-    when Type :: term().
-check_call(Source, "init" = FunName, Args, Options) ->
-    PatchFun = fun(T) -> {tuple, [typerep, T]} end,
-    case check_call(Source, FunName, Args, Options, PatchFun) of
-        Err = {error, _} when Args == [] ->
-            %% Try with default init-function
-            case check_call(insert_init_function(Source, Options), FunName, Args, Options, PatchFun) of
-                {error, _} -> Err; %% The first error is most likely better...
-                Res        -> Res
-            end;
-        Res ->
-            Res
-    end;
-check_call(Source, FunName, Args, Options) ->
-    PatchFun = fun(T) -> T end,
-    check_call(Source, FunName, Args, Options, PatchFun).
-
-check_call(ContractString0, FunName, Args, Options, PatchFun) ->
-    try
-        %% First check the contract without the __call function and no permissive literals
-        #{} = string_to_icode(ContractString0, Options),
-        ContractString = insert_call_function(ContractString0, FunName, Args, Options),
-        #{typed_ast := TypedAst,
-          icode     := Icode} = string_to_icode(ContractString, [permissive_address_literals | Options]),
-        {ok, {FunName, {fun_t, _, _, ArgTypes, RetType}}} = get_call_type(TypedAst),
-        ArgVMTypes = [ aeso_ast_to_icode:ast_typerep(T, Icode) || T <- ArgTypes ],
-        RetVMType  = case RetType of
-                         {id, _, "_"} -> any;
-                         _            -> aeso_ast_to_icode:ast_typerep(RetType, Icode)
-                     end,
-        #{ functions := Funs } = Icode,
-        ArgIcode = get_arg_icode(Funs),
-        ArgTerms = [ icode_to_term(T, Arg) ||
-                       {T, Arg} <- lists:zip(ArgVMTypes, ArgIcode) ],
-        {ok, FunName, {ArgVMTypes, PatchFun(RetVMType)}, ArgTerms}
-    catch
-        error:{parse_errors, Errors} ->
-            {error, join_errors("Parse errors", Errors, fun (E) -> E end)};
-        error:{type_errors, Errors} ->
-            {error, join_errors("Type errors", Errors, fun (E) -> E end)};
-        error:{badmatch, {error, missing_call_function}} ->
-            {error, join_errors("Type errors", ["missing __call function"],
-                                fun (E) -> E end)};
-        throw:Error ->                          %Don't ask
-            {error, join_errors("Code errors", [Error],
-                                fun (E) -> io_lib:format("~p", [E]) end)}
-    end.
-
-%% Add the __call function to a contract.
--spec insert_call_function(string(), string(), [string()], options()) -> string().
-insert_call_function(Code, FunName, Args, Options) ->
-    Ast = parse(Code, Options),
-    Ind = last_contract_indent(Ast),
-    lists:flatten(
-        [ Code,
-          "\n\n",
-          lists:duplicate(Ind, " "),
-          "function __call() = ", FunName, "(", string:join(Args, ","), ")\n"
-        ]).
-
--spec insert_init_function(string(), options()) -> string().
-insert_init_function(Code, Options) ->
-    Ast = parse(Code, Options),
-    Ind = last_contract_indent(Ast),
-    lists:flatten(
-        [ Code,
-          "\n\n",
-          lists:duplicate(Ind, " "), "function init() = ()\n"
-        ]).
-
-last_contract_indent(Decls) ->
-    case lists:last(Decls) of
-        {_, _, _, [Decl | _]} -> aeso_syntax:get_ann(col, Decl, 1) - 1;
-        _                     -> 0
-    end.
-
--spec to_sophia_value(string(), string(), ok | error | revert, aeso_sophia:data()) ->
-        {ok, aeso_syntax:expr()} | {error, term()}.
-to_sophia_value(ContractString, Fun, ResType, Data) ->
-    to_sophia_value(ContractString, Fun, ResType, Data, []).
-
--spec to_sophia_value(string(), string(), ok | error | revert, binary(), options()) ->
-        {ok, aeso_syntax:expr()} | {error, term()}.
-to_sophia_value(_, _, error, Err, _Options) ->
-    {ok, {app, [], {id, [], "error"}, [{string, [], Err}]}};
-to_sophia_value(_, _, revert, Data, _Options) ->
-    case aeso_heap:from_binary(string, Data) of
-        {ok, Err} -> {ok, {app, [], {id, [], "abort"}, [{string, [], Err}]}};
-        {error, _} = Err -> Err
-    end;
-to_sophia_value(ContractString, FunName, ok, Data, Options) ->
-    try
-        #{ typed_ast := TypedAst,
-           type_env  := TypeEnv,
-           icode     := Icode } = string_to_icode(ContractString, Options),
-        {ok, _, Type0} = get_decode_type(FunName, TypedAst),
-        Type   = aeso_ast_infer_types:unfold_types_in_type(TypeEnv, Type0, [unfold_record_types, unfold_variant_types]),
-        VmType = aeso_ast_to_icode:ast_typerep(Type, Icode),
-        case aeso_heap:from_binary(VmType, Data) of
-            {ok, VmValue} ->
-                try
-                    {ok, translate_vm_value(VmType, Type, VmValue)}
-                catch throw:cannot_translate_to_sophia ->
-                    Type0Str = prettypr:format(aeso_pretty:type(Type0)),
-                    {error, join_errors("Translation error", [lists:flatten(io_lib:format("Cannot translate VM value ~p\n  of type ~p\n  to Sophia type ~s\n",
-                                                                            [Data, VmType, Type0Str]))],
-                                        fun (E) -> E end)}
-                end;
-            {error, _Err} ->
-                {error, join_errors("Decode errors", [lists:flatten(io_lib:format("Failed to decode binary at type ~p", [VmType]))],
-                                    fun(E) -> E end)}
-        end
-    catch
-        error:{parse_errors, Errors} ->
-            {error, join_errors("Parse errors", Errors, fun (E) -> E end)};
-        error:{type_errors, Errors} ->
-            {error, join_errors("Type errors", Errors, fun (E) -> E end)};
-        error:{badmatch, {error, missing_function}} ->
-            {error, join_errors("Type errors", ["no function: '" ++ FunName ++ "'"],
-                                fun (E) -> E end)};
-        throw:Error ->                          %Don't ask
-            {error, join_errors("Code errors", [Error],
-                                fun (E) -> io_lib:format("~p", [E]) end)}
-    end.
-
-address_literal(N) -> {hash, [], <<N:256>>}.  % TODO
-
-%% TODO: somewhere else
--spec translate_vm_value(aeso_sophia:type(), aeso_syntax:type(), aeso_sophia:data()) -> aeso_syntax:expr().
-translate_vm_value(word,   {id, _, "address"},                     N) -> address_literal(N);
-translate_vm_value(word,   {app_t, _, {id, _, "oracle"}, _},       N) -> address_literal(N);
-translate_vm_value(word,   {app_t, _, {id, _, "oracle_query"}, _}, N) -> address_literal(N);
-translate_vm_value(word,   {id, _, "hash"},    N) -> {hash, [], <<N:256>>};
-translate_vm_value(word,   {id, _, "int"},     N) -> {int, [], N};
-translate_vm_value(word,   {id, _, "bits"},    N) -> error({todo, bits, N});
-translate_vm_value(word,   {id, _, "bool"},    N) -> {bool, [], N /= 0};
-translate_vm_value({tuple, [word, word]}, {id, _, "signature"}, {tuple, [Hi, Lo]}) ->
-    {hash, [], <<Hi:256, Lo:256>>};
-translate_vm_value(string, {id, _, "string"}, S) -> {string, [], S};
-translate_vm_value({list, VmType}, {app_t, _, {id, _, "list"}, [Type]}, List) ->
-    {list, [], [translate_vm_value(VmType, Type, X) || X <- List]};
-translate_vm_value({option, VmType}, {app_t, _, {id, _, "option"}, [Type]}, Val) ->
-    case Val of
-        none              -> {con, [], "None"};
-        {some, X}         -> {app, [], {con, [], "Some"}, [translate_vm_value(VmType, Type, X)]}
-    end;
-translate_vm_value({variant, [[], [VmType]]}, {app_t, _, {id, _, "option"}, [Type]}, Val) ->
-    case Val of
-        {variant, 0, []}  -> {con, [], "None"};
-        {variant, 1, [X]} -> {app, [], {con, [], "Some"}, [translate_vm_value(VmType, Type, X)]}
-    end;
-translate_vm_value({tuple, VmTypes}, {tuple_t, _, Types}, Val)
-        when length(VmTypes) == length(Types),
-             length(VmTypes) == tuple_size(Val) ->
-    {tuple, [], [translate_vm_value(VmType, Type, X)
-                 || {VmType, Type, X} <- lists:zip3(VmTypes, Types, tuple_to_list(Val))]};
-translate_vm_value({tuple, VmTypes}, {record_t, Fields}, Val)
-        when length(VmTypes) == length(Fields),
-             length(VmTypes) == tuple_size(Val) ->
-    {record, [], [ {field, [], [{proj, [], FName}], translate_vm_value(VmType, FType, X)}
-                   || {VmType, {field_t, _, FName, FType}, X} <- lists:zip3(VmTypes, Fields, tuple_to_list(Val)) ]};
-translate_vm_value({map, VmKeyType, VmValType}, {app_t, _, {id, _, "map"}, [KeyType, ValType]}, Map)
-        when is_map(Map) ->
-    {map, [], [ {translate_vm_value(VmKeyType, KeyType, Key),
-                 translate_vm_value(VmValType, ValType, Val)}
-                || {Key, Val} <- maps:to_list(Map) ]};
-translate_vm_value({variant, VmCons}, {variant_t, Cons}, {variant, Tag, Args})
-        when length(VmCons) == length(Cons),
-             length(VmCons) > Tag ->
-    VmTypes = lists:nth(Tag + 1, VmCons),
-    ConType = lists:nth(Tag + 1, Cons),
-    translate_vm_value(VmTypes, ConType, Args);
-translate_vm_value(VmTypes, {constr_t, _, Con, Types}, Args)
-        when length(VmTypes) == length(Types),
-             length(VmTypes) == length(Args) ->
-    {app, [], Con, [ translate_vm_value(VmType, Type, Arg)
-                     || {VmType, Type, Arg} <- lists:zip3(VmTypes, Types, Args) ]};
-translate_vm_value(_VmType, _Type, _Data) ->
-    throw(cannot_translate_to_sophia).
-
--spec create_calldata(string(), string(), [string()]) ->
-                             {ok, binary(), aeso_sophia:type(), aeso_sophia:type()}
-                             | {error, term()}.
-create_calldata(Code, Fun, Args) ->
-    case check_call(Code, Fun, Args, []) of
-        {ok, FunName, {ArgTypes, RetType}, VMArgs} ->
-            aeso_abi:create_calldata(FunName, VMArgs, ArgTypes, RetType);
-        {error, _} = Err -> Err
-    end.
-
--spec decode_calldata(string(), string(), binary()) ->
-                             {ok, [aeso_syntax:type()], [aeso_syntax:expr()]}
-                             | {error, term()}.
-decode_calldata(ContractString, FunName, Calldata) ->
-    try
-        #{ typed_ast := TypedAst,
-           type_env  := TypeEnv,
-           icode     := Icode } = string_to_icode(ContractString, []),
-        {ok, Args, _} = get_decode_type(FunName, TypedAst),
-        DropArg       = fun({arg, _, _, T}) -> T; (T) -> T end,
-        ArgTypes      = lists:map(DropArg, Args),
-        Type0         = {tuple_t, [], ArgTypes},
-        Type   = aeso_ast_infer_types:unfold_types_in_type(TypeEnv, Type0, [unfold_record_types, unfold_variant_types]),
-        VmType = aeso_ast_to_icode:ast_typerep(Type, Icode),
-        case aeso_heap:from_binary({tuple, [word, VmType]}, Calldata) of
-            {ok, {_, VmValue}} ->
-                try
-                    {tuple, [], Values} = translate_vm_value(VmType, Type, VmValue),
-                    {ok, ArgTypes, Values}
-                catch throw:cannot_translate_to_sophia ->
-                    Type0Str = prettypr:format(aeso_pretty:type(Type0)),
-                    {error, join_errors("Translation error", [lists:flatten(io_lib:format("Cannot translate VM value ~p\n  of type ~p\n  to Sophia type ~s\n",
-                                                                            [VmValue, VmType, Type0Str]))],
-                                        fun (E) -> E end)}
-                end;
-            {error, _Err} ->
-                {error, join_errors("Decode errors", [lists:flatten(io_lib:format("Failed to decode binary at type ~p", [VmType]))],
-                                    fun(E) -> E end)}
-        end
-    catch
-        error:{parse_errors, Errors} ->
-            {error, join_errors("Parse errors", Errors, fun (E) -> E end)};
-        error:{type_errors, Errors} ->
-            {error, join_errors("Type errors", Errors, fun (E) -> E end)};
-        error:{badmatch, {error, missing_function}} ->
-            {error, join_errors("Type errors", ["no function: '" ++ FunName ++ "'"],
-                                fun (E) -> E end)};
-        throw:Error ->                          %Don't ask
-            {error, join_errors("Code errors", [Error],
-                                fun (E) -> io_lib:format("~p", [E]) end)}
-    end.
-
-
-get_arg_icode(Funs) ->
-    case [ Args || {[_, ?CALL_NAME], _, _, {funcall, _, Args}, _} <- Funs ] of
-        [Args] -> Args;
-        []     -> error({missing_call_function, Funs})
-    end.
-
-get_call_type([{contract, _, _, Defs}]) ->
-    case [ {lists:last(QFunName), FunType}
-          || {letfun, _, {id, _, ?CALL_NAME}, [], _Ret,
-                {typed, _,
-                    {app, _,
-                        {typed, _, {qid, _, QFunName}, FunType}, _}, _}} <- Defs ] of
-        [Call] -> {ok, Call};
-        []     -> {error, missing_call_function}
-    end;
-get_call_type([_ | Contracts]) ->
-    %% The __call should be in the final contract
-    get_call_type(Contracts).
-
-get_decode_type(FunName, [{contract, _, _, Defs}]) ->
-    GetType = fun({letfun, _, {id, _, Name}, Args, Ret, _})               when Name == FunName -> [{Args, Ret}];
-                 ({fun_decl, _, {id, _, Name}, {fun_t, _, _, Args, Ret}}) when Name == FunName -> [{Args, Ret}];
-                 (_) -> [] end,
-    case lists:flatmap(GetType, Defs) of
-        [{Args, Ret}] -> {ok, Args, Ret};
-        []            -> {error, missing_function}
-    end;
-get_decode_type(FunName, [_ | Contracts]) ->
-    %% The __decode should be in the final contract
-    get_decode_type(FunName, Contracts).
-
-%% Translate an icode value (error if not value) to an Erlang term that can be
-%% consumed by aeso_heap:to_binary().
-icode_to_term(word, {integer, N}) -> N;
-icode_to_term(string, {tuple, [{integer, Len} | Words]}) ->
-    <<Str:Len/binary, _/binary>> = << <<W:256>> || {integer, W} <- Words >>,
-    Str;
-icode_to_term({list, T}, {list, Vs}) ->
-    [ icode_to_term(T, V) || V <- Vs ];
-icode_to_term({tuple, Ts}, {tuple, Vs}) ->
-    list_to_tuple(icodes_to_terms(Ts, Vs));
-icode_to_term({variant, Cs}, {tuple, [{integer, Tag} | Args]}) ->
-    Ts = lists:nth(Tag + 1, Cs),
-    {variant, Tag, icodes_to_terms(Ts, Args)};
-icode_to_term(T = {map, KT, VT}, M) ->
-    %% Maps are compiled to builtin and primop calls, so this gets a little hairy
-    case M of
-        {funcall, {var_ref, {builtin, map_put}}, [M1, K, V]} ->
-            Map = icode_to_term(T, M1),
-            Key = icode_to_term(KT, K),
-            Val = icode_to_term(VT, V),
-            Map#{ Key => Val };
-        #prim_call_contract{ address = {integer, 0},
-                             arg = {tuple, [{integer, ?PRIM_CALL_MAP_EMPTY}, _, _]} } ->
-            #{};
-        _ -> throw({todo, M})
-    end;
-icode_to_term(typerep, _) ->
-    throw({todo, typerep});
-icode_to_term(T, V) ->
-    throw({not_a_value, T, V}).
-
-icodes_to_terms(Ts, Vs) ->
-    [ icode_to_term(T, V) || {T, V} <- lists:zip(Ts, Vs) ].
-
-ast_to_icode(TypedAst, Options) ->
-    aeso_ast_to_icode:convert_typed(TypedAst, Options).
-
-assemble(Icode, Options) ->
-    aeso_icode_to_asm:convert(Icode, Options).
-
-
-to_bytecode(['COMMENT',_|Rest],_Options) ->
-    to_bytecode(Rest,_Options);
-to_bytecode([Op|Rest], Options) ->
-    [aeb_opcodes:m_to_op(Op)|to_bytecode(Rest, Options)];
-to_bytecode([], _) -> [].
-
-extract_type_info(#{functions := Functions} =_Icode) ->
-    ArgTypesOnly = fun(As) -> [ T || {_, T} <- As ] end,
-    TypeInfo = [aeso_abi:function_type_info(list_to_binary(lists:last(Name)),
-                                            ArgTypesOnly(Args), TypeRep)
-                || {Name, Attrs, Args,_Body, TypeRep} <- Functions,
-                   not is_tuple(Name),
-                   not lists:member(private, Attrs)
-               ],
-    lists:sort(TypeInfo).
-
-pp_sophia_code(C, Opts)->  pp(C, Opts, pp_sophia_code, fun(Code) ->
-                                io:format("~s\n", [prettypr:format(aeso_pretty:decls(Code))])
-                            end).
-pp_ast(C, Opts)      ->  pp(C, Opts, pp_ast, fun aeso_ast:pp/1).
-pp_typed_ast(C, Opts)->  pp(C, Opts, pp_typed_ast, fun aeso_ast:pp_typed/1).
-pp_icode(C, Opts)    ->  pp(C, Opts, pp_icode, fun aeso_icode:pp/1).
-pp_assembler(C, Opts)->  pp(C, Opts, pp_assembler, fun aeb_asm:pp/1).
-pp_bytecode(C, Opts) ->  pp(C, Opts, pp_bytecode, fun aeb_disassemble:pp/1).
-
-pp(Code, Options, Option, PPFun) ->
-    case proplists:lookup(Option, Options) of
-        {Option, true} ->
-            PPFun(Code);
-        none ->
-            ok
-    end.
-
-
-%% -------------------------------------------------------------------
-%% TODO: Tempoary parser hook below...
-
-sophia_type_to_typerep(String) ->
-    {ok, Ast} = aeso_parser:type(String),
-    try aeso_ast_to_icode:ast_typerep(Ast) of
-        Type -> {ok, Type}
-    catch _:_ -> {error, bad_type}
-    end.
-
-parse(Text, Options) ->
-    %% Try and return something sensible here!
-    case aeso_parser:string(Text, Options) of
-        %% Yay, it worked!
-        {ok, Contract} -> Contract;
-        %% Scan errors.
-        {error, {Pos, scan_error}} ->
-            parse_error(Pos, "scan error");
-        {error, {Pos, scan_error_no_state}} ->
-            parse_error(Pos, "scan error");
-        %% Parse errors.
-        {error, {Pos, parse_error, Error}} ->
-            parse_error(Pos, Error);
-        {error, {Pos, ambiguous_parse, As}} ->
-            ErrorString = io_lib:format("Ambiguous ~p", [As]),
-            parse_error(Pos, ErrorString);
-        %% Include error
-        {error, {Pos, include_error, File}} ->
-            parse_error(Pos, io_lib:format("could not find include file '~s'", [File]))
-    end.
-
-parse_error(Pos, ErrorString) ->
-    Error = io_lib:format("~s: ~s", [pos_error(Pos), ErrorString]),
-    error({parse_errors, [Error]}).
-
-read_contract(Name) ->
-    file:read_file(Name).
-
-pos_error({Line, Pos}) ->
-    io_lib:format("line ~p, column ~p", [Line, Pos]);
-pos_error({no_file, Line, Pos}) ->
-    pos_error({Line, Pos});
-pos_error({File, Line, Pos}) ->
-    io_lib:format("file ~s, line ~p, column ~p", [File, Line, Pos]).
-

src/aeso_constants.erl

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

src/aeso_heap.erl

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

src/aeso_icode.erl

@@ -1,135 +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,
-         enter_namespace/2,
-         get_namespace/1,
-         qualify/2,
-         set_functions/2,
-         map_typerep/2,
-         option_typerep/1,
-         get_constructor_tag/2]).
-
--export_type([icode/0]).
-
--include("aeso_icode.hrl").
-
--type type_def() :: fun(([aeso_sophia:type()]) -> aeso_sophia:type()).
-
--type bindings() :: any().
--type fun_dec() :: { string()
-                   , [modifier()]
-                   , arg_list()
-                   , expr()
-                   , aeso_sophia: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 => aeso_sophia:type()
-                  , event_type => aeso_sophia:type()
-                  , types => #{ type_name() => type_def() }
-                  , type_vars => #{ string() => aeso_sophia:type() }
-                  , constructors => #{ [string()] => integer() }  %% name to tag
-                  , options => [any()]
-                  }.
-
-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}.
-
-builtin_types() ->
-    Word = fun([]) -> word end,
-    #{ "bool"         => Word
-     , "int"          => Word
-     , "bits"         => Word
-     , "string"       => fun([]) -> string end
-     , "address"      => Word
-     , "hash"         => Word
-     , "signature"    => fun([]) -> {tuple, [word, word]} end
-     , "oracle"       => fun([_, _]) -> word end
-     , "oracle_query" => fun([_, _]) -> word end
-     , "list"         => fun([A]) -> {list, A} end
-     , "option"       => fun([A]) -> {variant, [[], [A]]} end
-     , "map"          => fun([K, V]) -> map_typerep(K, V) end
-     , ["Chain", "ttl"] => fun([]) -> {variant, [[word], [word]]} end
-     }.
-
-builtin_constructors() ->
-    #{ ["RelativeTTL"] => 0
-     , ["FixedTTL"]    => 1
-     , ["None"]        => 0
-     , ["Some"]        => 1 }.
-
-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_namespace(aeso_syntax:con() | aeso_syntax:qcon(), icode()) -> icode().
-set_namespace(NS, Icode) -> Icode#{ namespace => NS }.
-
--spec enter_namespace(aeso_syntax:con(), icode()) -> icode().
-enter_namespace(NS, Icode = #{ namespace := NS1 }) ->
-    Icode#{ namespace => aeso_syntax:qualify(NS1, NS) };
-enter_namespace(NS, Icode) ->
-    Icode#{ namespace => NS }.
-
--spec get_namespace(icode()) -> false | aeso_syntax:con() | aeso_syntax:qcon().
-get_namespace(Icode) -> maps:get(namespace, Icode, false).
-
--spec qualify(aeso_syntax:id() | aeso_syntax:con(), icode()) -> aeso_syntax:id() | aeso_syntax:qid() | aeso_syntax:con() | aeso_syntax:qcon().
-qualify(X, Icode) ->
-    case get_namespace(Icode) of
-        false -> X;
-        NS    -> aeso_syntax:qualify(NS, X)
-    end.
-
--spec set_functions([fun_dec()], icode()) -> icode().
-set_functions(NewFuns, Icode) ->
-    maps:put(functions, NewFuns, Icode).
-
--spec get_constructor_tag([string()], icode()) -> integer().
-get_constructor_tag(Name, #{constructors := Constructors}) ->
-    case maps:get(Name, Constructors, undefined) of
-        undefined -> error({undefined_constructor, Name});
-        Tag       -> Tag
-    end.
-

src/aeso_icode.hrl

@@ -1,68 +0,0 @@
-
--define(Type(), aeso_sophia:type()).
-
--define(TYPEREP_WORD_TAG,   0).
--define(TYPEREP_STRING_TAG, 1).
--define(TYPEREP_LIST_TAG,   2).
--define(TYPEREP_TUPLE_TAG,  3).
--define(TYPEREP_VARIANT_TAG, 4).
--define(TYPEREP_TYPEREP_TAG, 5).
--define(TYPEREP_MAP_TAG,     6).
--define(TYPEREP_FUN_TAG,     7).
-
--record(arg, {name::string(), type::?Type()}).
-
--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,981 +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>> = aeso_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_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_icode_to_fate.erl

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

src/aeso_memory.erl

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

src/aeso_parse_lib.hrl

@@ -1,25 +0,0 @@
-
--define(LET_P(X, P, Q), aeso_parse_lib:bind(P, fun(X) -> Q end)).
--define(LAZY_P(P),      aeso_parse_lib:lazy(fun() -> P end)).
--define(MEMO_P(P),      aeso_parse_lib:lazy(aeso_parse_lib:memoised(fun() -> P end))).
-
--define(GUARD_P(G, P),
-    case G of
-        true  -> P;
-        false -> fail()
-    end).
-
--define(RULE(A,                Do), map(fun(_1) ->                       Do end, A                 )).
--define(RULE(A, B,             Do), map(fun({_1, _2}) ->                 Do end, {A, B}            )).
--define(RULE(A, B, C,          Do), map(fun({_1, _2, _3}) ->             Do end, {A, B, C}         )).
--define(RULE(A, B, C, D,       Do), map(fun({_1, _2, _3, _4}) ->         Do end, {A, B, C, D}      )).
--define(RULE(A, B, C, D, E,    Do), map(fun({_1, _2, _3, _4, _5}) ->     Do end, {A, B, C, D, E}   )).
--define(RULE(A, B, C, D, E, F, Do), map(fun({_1, _2, _3, _4, _5, _6}) -> Do end, {A, B, C, D, E, F})).
-
--import(aeso_parse_lib,
-        [tok/1, tok/2, between/3, many/1, many1/1, sep/2, sep1/2,
-         infixl/1, infixr/1, choice/1, choice/2, return/1, layout/0,
-         fail/0, fail/1, map/2, infixl/2, infixr/2, infixl1/2, infixr1/2,
-         left/2, right/2, optional/1]).
-
-

src/aeso_parser.erl

@@ -1,518 +0,0 @@
-%%% File        : aeso_parser.erl
-%%% Author      : Ulf Norell
-%%% Description :
-%%% Created     : 1 Mar 2018 by Ulf Norell
--module(aeso_parser).
-
--export([string/1,
-         string/2,
-         type/1]).
-
--include("aeso_parse_lib.hrl").
-
--type parse_result() :: {ok, aeso_syntax:ast()}
-                      | {error, {aeso_parse_lib:pos(), atom(), term()}}
-                      | {error, {aeso_parse_lib:pos(), atom()}}.
-
--spec string(string()) -> parse_result().
-string(String) ->
-    string(String, []).
-
--spec string(string(), aeso_compiler:options()) -> parse_result().
-string(String, Opts) ->
-    case parse_and_scan(file(), String, Opts) of
-        {ok, AST} ->
-            expand_includes(AST, Opts);
-        Err = {error, _} ->
-            Err
-    end.
-
-type(String) ->
-    parse_and_scan(type(), String, []).
-
-parse_and_scan(P, S, Opts) ->
-    set_current_file(proplists:get_value(src_file, Opts, no_file)),
-    case aeso_scan:scan(S) of
-        {ok, Tokens} -> aeso_parse_lib:parse(P, Tokens);
-        Error        -> Error
-    end.
-
-%% -- Parsing rules ----------------------------------------------------------
-
-file() -> choice([], block(decl())).
-
-decl() ->
-    ?LAZY_P(
-    choice(
-      %% Contract declaration
-    [ ?RULE(keyword(contract),  con(), tok('='), maybe_block(decl()), {contract, _1, _2, _4})
-    , ?RULE(keyword(namespace), con(), tok('='), maybe_block(decl()), {namespace, _1, _2, _4})
-    , ?RULE(keyword(include),   str(), {include, _2})
-
-      %% Type declarations  TODO: format annotation for "type bla" vs "type bla()"
-    , ?RULE(keyword(type),     id(),                                          {type_decl, _1, _2, []})
-    , ?RULE(keyword(type),     id(), type_vars(),                             {type_decl, _1, _2, _3})
-    , ?RULE(keyword(type),     id(),              tok('='), typedef(type),    {type_def, _1, _2, [], _4})
-    , ?RULE(keyword(type),     id(), type_vars(), tok('='), typedef(type),    {type_def, _1, _2, _3, _5})
-    , ?RULE(keyword(record),   id(),              tok('='), typedef(record),  {type_def, _1, _2, [], _4})
-    , ?RULE(keyword(record),   id(), type_vars(), tok('='), typedef(record),  {type_def, _1, _2, _3, _5})
-    , ?RULE(keyword(datatype), id(),              tok('='), typedef(variant), {type_def, _1, _2, [], _4})
-    , ?RULE(keyword(datatype), id(), type_vars(), tok('='), typedef(variant), {type_def, _1, _2, _3, _5})
-
-      %% Function declarations
-    , ?RULE(modifiers(), keyword(function), id(), tok(':'), type(), add_modifiers(_1, {fun_decl, _2, _3, _5}))
-    , ?RULE(modifiers(), keyword(function), fundef(),               add_modifiers(_1, set_pos(get_pos(_2), _3)))
-    , ?RULE(keyword('let'),    valdef(),                            set_pos(get_pos(_1), _2))
-    ])).
-
-modifiers() ->
-    many(choice([token(stateful), token(public), token(private), token(internal)])).
-
-add_modifiers([], Node) -> Node;
-add_modifiers(Mods = [Tok | _], Node) ->
-    %% Set the position to the position of the first modifier. This is
-    %% important for code transformation tools (like what we do in
-    %% create_calldata) to be able to get the indentation of the declaration.
-    set_pos(get_pos(Tok),
-        lists:foldl(fun({Mod, _}, X) -> set_ann(Mod, true, X) end,
-                    Node, Mods)).
-
-%% -- Type declarations ------------------------------------------------------
-
-typedef(type)    -> ?RULE(type(),                   {alias_t, _1});
-typedef(record)  -> ?RULE(brace_list(field_type()), {record_t, _1});
-typedef(variant) -> ?RULE(constructors(),           {variant_t, _1}).
-
-constructors() ->
-    sep1(constructor(), tok('|')).
-
-constructor() ->    %% TODO: format for Con() vs Con
-    choice(?RULE(con(),              {constr_t, get_ann(_1), _1, []}),
-           ?RULE(con(), con_args(), {constr_t, get_ann(_1), _1, _2})).
-
-con_args()   -> paren_list(con_arg()).
-type_args()  -> paren_list(type()).
-field_type() -> ?RULE(id(), tok(':'), type(), {field_t, get_ann(_1), _1, _3}).
-
-con_arg()    -> choice(type(), ?RULE(keyword(indexed), type(), set_ann(indexed, true, _2))).
-
-%% -- Let declarations -------------------------------------------------------
-
-letdecl() ->
-    choice(
-        ?RULE(keyword('let'), letdef(),                             set_pos(get_pos(_1), _2)),
-        ?RULE(keyword('let'), tok(rec), sep1(letdef(), tok('and')), {letrec, _1, _3})).
-
-letdef() -> choice(valdef(), fundef()).
-
-valdef() ->
-    choice(
-        ?RULE(id(),                   tok('='), body(), {letval, [], _1, type_wildcard(), _3}),
-        ?RULE(id(), tok(':'), type(), tok('='), body(), {letval, [], _1, _3, _5})).
-
-fundef() ->
-    choice(
-    [ ?RULE(id(), args(),                   tok('='), body(), {letfun, [], _1, _2, type_wildcard(), _4})
-    , ?RULE(id(), args(), tok(':'), type(), tok('='), body(), {letfun, [], _1, _2, _4, _6})
-    ]).
-
-args() -> paren_list(arg()).
-
-arg() -> choice(
-    ?RULE(id(),                   {arg, get_ann(_1), _1, type_wildcard()}),
-    ?RULE(id(), tok(':'), type(), {arg, get_ann(_1), _1, _3})).
-
-%% -- Types ------------------------------------------------------------------
-
-type_vars() -> paren_list(tvar()).
-
-type() -> ?LAZY_P(type100()).
-
-type100() -> type200().
-
-type200() ->
-    ?RULE(many({fun_domain(), keyword('=>')}), type300(), fun_t(_1, _2)).
-
-type300() -> type400().
-
-type400() ->
-    ?RULE(typeAtom(), optional(type_args()),
-          case _2 of
-            none       -> _1;
-            {ok, Args} -> {app_t, get_ann(_1), _1, Args}
-          end).
-
-typeAtom() ->
-    ?LAZY_P(choice(
-    [ id(), token(con), token(qcon), token(qid), tvar()
-    , ?RULE(keyword('('), comma_sep(type()), tok(')'), tuple_t(_1, _2))
-    ])).
-
-fun_domain() -> ?RULE(?LAZY_P(type300()), fun_domain(_1)).
-
-%% -- Statements -------------------------------------------------------------
-
-body() ->
-    ?LET_P(Stmts, maybe_block(stmt()), block_e(Stmts)).
-
-stmt() ->
-    ?LAZY_P(choice(
-    [ expr()
-    , letdecl()
-    , {switch, keyword(switch), parens(expr()), maybe_block(branch())}
-    , {'if', keyword('if'), parens(expr()), body()}
-    , {elif, keyword(elif), parens(expr()), body()}
-    , {else, keyword(else), body()}
-    ])).
-
-branch() ->
-    ?RULE(pattern(), keyword('=>'), body(), {'case', _2, _1, _3}).
-
-pattern() ->
-    ?LET_P(E, expr500(), parse_pattern(E)).
-
-%% -- Expressions ------------------------------------------------------------
-
-expr() -> expr100().
-
-expr100() ->
-    Expr100 = ?LAZY_P(expr100()),
-    Expr200 = ?LAZY_P(expr200()),
-    choice(
-    [ ?RULE(args(), keyword('=>'), body(), {lam, _2, _1, _3})   %% TODO: better location
-    , {'if', keyword('if'), parens(Expr100), Expr200, right(tok(else), Expr100)}
-    , ?RULE(Expr200, optional(right(tok(':'), type())),
-            case _2 of
-                none       -> _1;
-                {ok, Type} -> {typed, get_ann(_1), _1, Type}
-            end)
-    ]).
-
-expr200() -> infixr(expr300(), binop('||')).
-expr300() -> infixr(expr400(), binop('&&')).
-expr400() -> infix(expr500(),  binop(['<', '>', '=<', '>=', '==', '!='])).
-expr500() -> infixr(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)).
-expr900() -> ?RULE(exprAtom(), many(elim()), elim(_1, _2)).
-
-exprAtom() ->
-    ?LAZY_P(begin
-        Expr = ?LAZY_P(expr()),
-        choice(
-        [ id(), con(), token(qid), token(qcon)
-        , token(hash), token(string), token(char)
-        , token(int)
-        , ?RULE(token(hex), set_ann(format, hex, setelement(1, _1, int)))
-        , {bool, keyword(true), true}
-        , {bool, keyword(false), false}
-        , ?RULE(brace_list(?LAZY_P(field_assignment())), record(_1))
-        , {list, [], bracket_list(Expr)}
-        , ?RULE(tok('['), Expr, binop('..'), Expr, tok(']'), _3(_2, _4))
-        , ?RULE(keyword('('), comma_sep(Expr), tok(')'), tuple_e(_1, _2))
-        ])
-    end).
-
-arg_expr() ->
-    ?LAZY_P(
-        choice([ ?RULE(id(), tok('='), expr(), {named_arg, [], _1, _3})
-               , expr() ])).
-
-elim() ->
-    ?LAZY_P(
-    choice(
-    [ {proj, keyword('.'), id()}
-    , ?RULE(paren_list(arg_expr()), {app, [], _1})
-    , ?RULE(keyword('{'), comma_sep(field_assignment()), tok('}'), {rec_upd, _1, _2})
-    , ?RULE(keyword('['), map_key(), keyword(']'), map_get(_1, _2))
-    ])).
-
-map_get(Ann, {map_key, Key})      -> {map_get, Ann, Key};
-map_get(Ann, {map_key, Key, Val}) -> {map_get, Ann, Key, Val}.
-
-map_key() ->
-    ?RULE(expr(), optional({tok('='), expr()}), map_key(_1, _2)).
-
-map_key(Key, none)           -> {map_key, Key};
-map_key(Key, {ok, {_, Val}}) -> {map_key, Key, Val}.
-
-elim(E, [])                              -> E;
-elim(E, [{proj, Ann, P} | Es])           -> elim({proj, Ann, E, P}, Es);
-elim(E, [{app, Ann, Args} | Es])         -> elim({app, Ann, E, Args}, Es);
-elim(E, [{rec_upd, Ann, Flds} | Es])     -> elim(record_update(Ann, E, Flds), Es);
-elim(E, [{map_get, Ann, Key} | Es])      -> elim({map_get, Ann, E, Key}, Es);
-elim(E, [{map_get, Ann, Key, Val} | Es]) -> elim({map_get, Ann, E, Key, Val}, Es).
-
-record_update(Ann, E, Flds) ->
-    {record_or_map(Flds), Ann, E, Flds}.
-
-record([]) -> {map, [], []};
-record(Fs) ->
-    case record_or_map(Fs) of
-        record -> {record, get_ann(hd(Fs)), Fs};
-        map    ->
-            Ann = get_ann(hd(Fs ++ [{empty, []}])), %% TODO: source location for empty maps
-            KV = fun({field, _, [{map_get, _, Key}], Val}) -> {Key, Val};
-                    ({field, _, LV, Id, _}) ->
-                        bad_expr_err("Cannot use '@' in map construction", infix(LV, {op, Ann, '@'}, Id));
-                    ({field, _, LV, _}) ->
-                        bad_expr_err("Cannot use nested fields or keys in map construction", LV) end,
-            {map, Ann, lists:map(KV, Fs)}
-    end.
-
-record_or_map(Fields) ->
-    Kind = fun(Fld) -> case element(3, Fld) of
-                [{proj, _, _}       | _] -> proj;
-                [{map_get, _, _}    | _] -> map_get;
-                [{map_get, _, _, _} | _] -> map_get
-           end end,
-    case lists:usort(lists:map(Kind, Fields)) of
-        [proj]    -> record;
-        [map_get] -> map;
-        _         ->
-            [{field, Ann, _, _} | _] = Fields,
-            bad_expr_err("Mixed record fields and map keys in", {record, Ann, Fields})
-    end.
-
-field_assignment() ->
-    ?RULE(lvalue(), optional({tok('@'), id()}), tok('='), expr(), field_assignment(get_ann(_3), _1, _2, _4)).
-
-field_assignment(Ann, LV, none, E) ->
-    {field, Ann, LV, E};
-field_assignment(Ann, LV, {ok, {_, Id}}, E) ->
-    {field, Ann, LV, Id, E}.
-
-lvalue() ->
-    ?RULE(lvalueAtom(), many(elim()), lvalue(elim(_1, _2))).
-
-lvalueAtom() ->
-    ?LAZY_P(choice([ id()
-                   , ?RULE(keyword('['), map_key(), keyword(']'), _2)
-                   ])).
-
-lvalue(E) -> lvalue(E, []).
-
-lvalue(X = {id, Ann, _}, LV)     -> [{proj, Ann, X} | LV];
-lvalue({map_key, K}, LV)         -> [{map_get, get_ann(K), K} | LV];
-lvalue({map_key, K, V}, LV)      -> [{map_get, get_ann(K), K, V} | LV];
-lvalue({proj, Ann, E, P}, LV)    -> lvalue(E, [{proj, Ann, P} | LV]);
-lvalue({map_get, Ann, E, K}, LV) -> lvalue(E, [{map_get, Ann, K} | LV]);
-lvalue({map_get, Ann, E, K, V}, LV) -> lvalue(E, [{map_get, Ann, K, V} | LV]);
-lvalue(E, _)                     -> bad_expr_err("Not a valid lvalue", E).
-
-infix(E, Op) ->
-    ?RULE(E, optional({Op, E}),
-    case _2 of
-        none -> _1;
-        {ok, {F, Arg}} -> F(_1, Arg)
-    end).
-
-binop(Op) when is_atom(Op) -> binop([Op]);
-binop(Ops) ->
-    ?RULE(choice([ token(Op) || Op <- Ops ]), fun(A, B) -> infix(A, _1, B) end).
-
-con()      -> token(con).
-id()       -> token(id).
-tvar()     -> token(tvar).
-str()      -> token(string).
-
-token(Tag) ->
-    ?RULE(tok(Tag),
-    case _1 of
-        {Tok, {Line, Col}}      -> {Tok, pos_ann(Line, Col)};
-        {Tok, {Line, Col}, Val} -> {Tok, pos_ann(Line, Col), Val}
-    end).
-
-%% -- Helpers ----------------------------------------------------------------
-
-keyword(K) -> ann(tok(K)).
-ann(P)     -> map(fun get_ann/1, P).
-
-block(P) ->
-    between(layout(), sep1(P, tok(vsemi)), tok(vclose)).
-
-maybe_block(P) ->
-    choice(block(P), [P]).
-
-parens(P)   -> between(tok('('), P, tok(')')).
-braces(P)   -> between(tok('{'), P, tok('}')).
-brackets(P) -> between(tok('['), P, tok(']')).
-comma_sep(P) -> sep(P, tok(',')).
-
-paren_list(P)   -> parens(comma_sep(P)).
-brace_list(P)   -> braces(comma_sep(P)).
-bracket_list(P) -> brackets(comma_sep(P)).
-
-%% -- Annotations ------------------------------------------------------------
-
--type ann()      :: aeso_syntax:ann().
--type ann_line() :: aeso_syntax:ann_line().
--type ann_col()  :: aeso_syntax:ann_col().
-
--spec pos_ann(ann_line(), ann_col()) -> ann().
-pos_ann(Line, Col) -> [{file, current_file()}, {line, Line}, {col, Col}].
-
-current_file() ->
-    get('$current_file').
-
-set_current_file(File) ->
-    put('$current_file', File).
-
-ann_pos(Ann) ->
-    {proplists:get_value(file, Ann),
-     proplists:get_value(line, Ann),
-     proplists:get_value(col, Ann)}.
-
-get_ann(Ann) when is_list(Ann) -> Ann;
-get_ann(Node) ->
-    case element(2, Node) of
-        {Line, Col} when is_integer(Line), is_integer(Col) -> pos_ann(Line, Col);
-        Ann -> Ann
-    end.
-
-get_ann(Key, Node) ->
-    proplists:get_value(Key, get_ann(Node)).
-
-set_ann(Key, Val, Node) ->
-    Ann = get_ann(Node),
-    setelement(2, Node, lists:keystore(Key, 1, Ann, {Key, Val})).
-
-get_pos(Node) ->
-    {current_file(), get_ann(line, Node), get_ann(col, Node)}.
-
-set_pos({F, L, C}, Node) ->
-    set_ann(file, F, set_ann(line, L, set_ann(col, C, Node))).
-
-infix(L, Op, R) -> set_ann(format, infix,  {app, get_ann(L), Op, [L, R]}).
-
-prefixes(Ops, E) -> lists:foldr(fun prefix/2, E, Ops).
-prefix(Op, E)    -> set_ann(format, prefix, {app, get_ann(Op), Op, [E]}).
-
-type_wildcard() ->
-    {id, [{origin, system}], "_"}.
-
-block_e(Stmts) ->
-    group_ifs(Stmts, []).
-
-group_ifs([], [Stmt]) -> return(Stmt);
-group_ifs([], Acc) ->
-    Stmts = [Stmt | _] = lists:reverse(Acc),
-    {block, get_ann(Stmt), Stmts};
-group_ifs([{'if', Ann, Cond, Then} | Stmts], Acc) ->
-    {Elses, Rest} = else_branches(Stmts, []),
-    group_ifs(Rest, [build_if(Ann, Cond, Then, Elses) | Acc]);
-group_ifs([{else, Ann, _} | _], _) ->
-    fail({Ann, "No matching 'if' for 'else'"});
-group_ifs([{elif, Ann, _, _} | _], _) ->
-    fail({Ann, "No matching 'if' for 'elif'"});
-group_ifs([Stmt | Stmts], Acc) ->
-    group_ifs(Stmts, [Stmt | Acc]).
-
-build_if(Ann, Cond, Then, [{elif, Ann1, Cond1, Then1} | Elses]) ->
-    {'if', Ann, Cond, Then,
-        set_ann(format, elif, build_if(Ann1, Cond1, Then1, Elses))};
-build_if(Ann, Cond, Then, [{else, _Ann, Else}]) ->
-    {'if', Ann, Cond, Then, Else};
-build_if(Ann, Cond, Then, []) ->
-    {'if', Ann, Cond, Then, {unit, [{origin, system}]}}.
-
-else_branches([Elif = {elif, _, _, _} | Stmts], Acc) ->
-    else_branches(Stmts, [Elif | Acc]);
-else_branches([Else = {else, _, _} | Stmts], Acc) ->
-    {lists:reverse([Else | Acc]), Stmts};
-else_branches(Stmts, Acc) ->
-    {lists:reverse(Acc), Stmts}.
-
-tuple_t(_Ann, [Type]) -> Type;  %% Not a tuple
-tuple_t(Ann, Types)   -> {tuple_t, Ann, Types}.
-
-fun_t(Domains, Type) ->
-    lists:foldr(fun({Dom, Ann}, T) -> {fun_t, Ann, [], Dom, T} end,
-                Type, Domains).
-
-tuple_e(Ann, [])      -> {unit, Ann};
-tuple_e(_Ann, [Expr]) -> Expr;  %% Not a tuple
-tuple_e(Ann, Exprs)   -> {tuple, Ann, Exprs}.
-
-%% TODO: not nice
-fun_domain({tuple_t, _, Args}) -> Args;
-fun_domain(T)                  -> [T].
-
--spec parse_pattern(aeso_syntax:expr()) -> aeso_parse_lib:parser(aeso_syntax:pat()).
-parse_pattern({app, Ann, Con = {'::', _}, Es}) ->
-    {app, Ann, Con, lists:map(fun parse_pattern/1, Es)};
-parse_pattern({app, Ann, Con = {con, _, _}, Es}) ->
-    {app, Ann, Con, lists:map(fun parse_pattern/1, Es)};
-parse_pattern({tuple, Ann, Es}) ->
-    {tuple, Ann, lists:map(fun parse_pattern/1, Es)};
-parse_pattern({list, Ann, Es}) ->
-    {list, Ann, lists:map(fun parse_pattern/1, Es)};
-parse_pattern({record, Ann, Fs}) ->
-    {record, Ann, lists:map(fun parse_field_pattern/1, Fs)};
-parse_pattern(E = {con, _, _})    -> E;
-parse_pattern(E = {id, _, _})     -> E;
-parse_pattern(E = {unit, _})      -> E;
-parse_pattern(E = {int, _, _})    -> E;
-parse_pattern(E = {bool, _, _})   -> E;
-parse_pattern(E = {hash, _, _})   -> E;
-parse_pattern(E = {string, _, _}) -> E;
-parse_pattern(E = {char, _, _})   -> E;
-parse_pattern(E) -> bad_expr_err("Not a valid pattern", E).
-
--spec parse_field_pattern(aeso_syntax:field(aeso_syntax:expr())) -> aeso_parse_lib:parser(aeso_syntax:field(aeso_syntax:pat())).
-parse_field_pattern({field, Ann, F, E}) ->
-    {field, Ann, F, parse_pattern(E)}.
-
-return_error({no_file, L, C}, Err) ->
-    fail(io_lib:format("~p:~p:\n~s", [L, C, Err]));
-return_error({F, L, C}, Err) ->
-    fail(io_lib:format("In ~s at ~p:~p:\n~s", [F, L, C, Err])).
-
--spec ret_doc_err(ann(), prettypr:document()) -> no_return().
-ret_doc_err(Ann, Doc) ->
-    return_error(ann_pos(Ann), prettypr:format(Doc)).
-
--spec bad_expr_err(string(), aeso_syntax:expr()) -> no_return().
-bad_expr_err(Reason, E) ->
-  ret_doc_err(get_ann(E),
-              prettypr:sep([prettypr:text(Reason ++ ":"),
-                            prettypr:nest(2, aeso_pretty:expr(E))])).
-
-%% -- Helper functions -------------------------------------------------------
-expand_includes(AST, Opts) ->
-    expand_includes(AST, [], Opts).
-
-expand_includes([], Acc, _Opts) ->
-    {ok, lists:reverse(Acc)};
-expand_includes([{include, S = {string, _, File}} | AST], Acc, Opts) ->
-    case read_file(File, Opts) of
-        {ok, Bin} ->
-            Opts1 = lists:keystore(src_file, 1, Opts, {src_file, File}),
-            case string(binary_to_list(Bin), Opts1) of
-                {ok, AST1} ->
-                    expand_includes(AST1 ++ AST, Acc, Opts);
-                Err = {error, _} ->
-                    Err
-            end;
-        {error, _} ->
-            {error, {get_pos(S), include_error, File}}
-    end;
-expand_includes([E | AST], Acc, Opts) ->
-    expand_includes(AST, [E | Acc], Opts).
-
-read_file(File, Opts) ->
-    case proplists:get_value(include, Opts, {explicit_files, #{}}) of
-        {file_system, Paths} ->
-            CandidateNames = [ filename:join(Dir, File) || Dir <- Paths ],
-            lists:foldr(fun(F, {error, _}) -> file:read_file(F);
-                           (_F, OK) -> OK end, {error, not_found}, CandidateNames);
-        {explicit_files, Files} ->
-            case maps:get(binary_to_list(File), Files, not_found) of
-                not_found -> {error, not_found};
-                Src       -> {ok, Src}
-            end
-    end.
-

src/aeso_scan.erl

@@ -1,126 +0,0 @@
-%%% -*- erlang-indent-level:4; indent-tabs-mode: nil -*-
-%%%-------------------------------------------------------------------
-%%% @copyright (C) 2017, Aeternity Anstalt
-%%% @doc The Sophia lexer.
-%%%
-%%% @end
-%%%-------------------------------------------------------------------
--module(aeso_scan).
-
--export([scan/1]).
-
--import(aeso_scan_lib, [token/1, token/2, symbol/0, skip/0,
-                        override/2, push/2, pop/1]).
-
-lexer() ->
-    DIGIT    = "[0-9]",
-    HEXDIGIT = "[0-9a-fA-F]",
-    LOWER    = "[a-z_]",
-    UPPER    = "[A-Z]",
-    CON      = [UPPER, "[a-zA-Z0-9_]*"],
-    INT      = [DIGIT, "+"],
-    HEX      = ["0x", HEXDIGIT, "+"],
-    HASH     = ["#", HEXDIGIT, "+"],
-    WS       = "[\\000-\\ ]+",
-    ID       = [LOWER, "[a-zA-Z0-9_']*"],
-    TVAR     = ["'", ID],
-    QID      = ["(", CON, "\\.)+", ID],
-    QCON     = ["(", CON, "\\.)+", CON],
-    OP       = "[=!<>+\\-*/:&|?~@^]+",
-    CHAR     = "'([^'\\\\]|(\\\\.))'",
-    STRING   = "\"([^\"\\\\]|(\\\\.))*\"",
-
-    CommentStart = {"/\\*", push(comment, skip())},
-    CommentRules =
-        [ CommentStart
-        , {"\\*/",        pop(skip())}
-        , {"[^/*]+|[/*]", skip()} ],
-
-    Keywords = ["contract", "include", "let", "rec", "switch", "type", "record", "datatype", "if", "elif", "else", "function",
-                "stateful", "true", "false", "and", "mod", "public", "private", "indexed", "internal", "namespace"],
-    KW = string:join(Keywords, "|"),
-
-    Rules =
-          %% Comments and whitespace
-        [ CommentStart
-        , {"//.*", skip()}
-        , {WS,     skip()}
-
-          %% Special characters
-        , {"\\.\\.|[,.;()\\[\\]{}]", symbol()}
-
-          %% Literals
-        , {CHAR,   token(char,   fun parse_char/1)}
-        , {STRING, token(string, fun parse_string/1)}
-        , {HEX,    token(hex,    fun parse_hex/1)}
-        , {INT,    token(int,    fun list_to_integer/1)}
-        , {HASH,   token(hash,   fun parse_hash/1)}
-
-          %% Identifiers (qualified first!)
-        , {QID,   token(qid,  fun(S) -> string:tokens(S, ".") end)}
-        , {QCON,  token(qcon, fun(S) -> string:tokens(S, ".") end)}
-        , {TVAR,  token(tvar)}
-        , override({ID, token(id)}, {KW, symbol()})    %% Keywords override identifiers. Need to
-        , {CON, token(con)}                            %% use override to avoid lexing "lettuce"
-                                                       %% as ['let', {id, "tuce"}].
-          %% Operators
-        , {OP, symbol()}
-        ],
-
-    [{code, Rules}, {comment, CommentRules}].
-
-scan(String) ->
-    Lexer = aeso_scan_lib:compile(lexer()),
-    aeso_scan_lib:string(Lexer, code, String).
-
-%% -- Helpers ----------------------------------------------------------------
-
-parse_string([$" | Chars]) ->
-    unescape(Chars).
-
-parse_char([$', $\\, Code, $']) ->
-    case Code of
-        $'  -> $';
-        $\\ -> $\\;
-        $b  -> $\b;
-        $e  -> $\e;
-        $f  -> $\f;
-        $n  -> $\n;
-        $r  -> $\r;
-        $t  -> $\t;
-        $v  -> $\v;
-        _   -> {error, "Bad control sequence: \\" ++ [Code]}
-    end;
-parse_char([$', C, $']) -> C.
-
-unescape(Str) -> unescape(Str, []).
-
-%% TODO: numeric escapes
-unescape([$"], Acc) ->
-    list_to_binary(lists:reverse(Acc));
-unescape([$\\, Code | Chars], Acc) ->
-    Ok = fun(C) -> unescape(Chars, [C | Acc]) end,
-    case Code of
-        $"  -> Ok($");
-        $\\ -> Ok($\\);
-        $b  -> Ok($\b);
-        $e  -> Ok($\e);
-        $f  -> Ok($\f);
-        $n  -> Ok($\n);
-        $r  -> Ok($\r);
-        $t  -> Ok($\t);
-        $v  -> Ok($\v);
-        _   -> error("Bad control sequence: \\" ++ [Code])  %% TODO
-    end;
-unescape([C | Chars], Acc) ->
-    unescape(Chars, [C | Acc]).
-
-parse_hex("0x" ++ Chars) -> list_to_integer(Chars, 16).
-
-parse_hash("#" ++ Chars) ->
-    N = list_to_integer(Chars, 16),
-    case length(Chars) > 64 of  %% 64 hex digits = 32 bytes
-        true  -> <<N:64/unit:8>>;   %% signature
-        false -> <<N:32/unit:8>>    %% address
-    end.
-

src/aeso_sophia.erl

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

src/aesophia.erl

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

src/so_aci.erl

@@ -0,0 +1,378 @@
+%%%-------------------------------------------------------------------
+%%% @author Robert Virding
+%%% @copyright (C) 2025, QPQ AG
+%%% @copyright (C) 2019, Aeternity Anstalt
+%%% @doc
+%%%     ACI interface
+%%% @end
+%%%-------------------------------------------------------------------
+
+-module(so_aci).
+-vsn("9.0.0").
+
+-export([ file/2
+        , file/3
+        , contract_interface/2
+        , contract_interface/3
+
+        , from_typed_ast/2
+
+        , render_aci_json/1
+
+        , json_encode_expr/1
+        , json_encode_type/1]).
+
+-include("so_utils.hrl").
+
+-type aci_type()  :: json | string.
+-type json()      :: jsx:json_term().
+-type json_text() :: binary().
+
+-export_type([aci_type/0]).
+
+%% External API
+-spec file(aci_type(), string()) -> {ok, json() | string()} | {error, term()}.
+file(Type, File) ->
+    file(Type, File, []).
+
+file(Type, File, Options0) ->
+    Options = so_compiler:add_include_path(File, Options0),
+    case file:read_file(File) of
+        {ok, BinCode} ->
+            do_contract_interface(Type, binary_to_list(BinCode), Options);
+        {error, _} = Err -> Err
+    end.
+
+-spec contract_interface(aci_type(), string()) ->
+    {ok, json() | string()} | {error, term()}.
+contract_interface(Type, ContractString) ->
+    contract_interface(Type, ContractString, []).
+
+-spec contract_interface(aci_type(), string(), [term()]) ->
+    {ok, json() | string()} | {error, term()}.
+contract_interface(Type, ContractString, CompilerOpts) ->
+    do_contract_interface(Type, ContractString, CompilerOpts).
+
+-spec render_aci_json(json() | json_text()) -> {ok, binary()}.
+render_aci_json(Json) ->
+    do_render_aci_json(Json).
+
+-spec json_encode_expr(so_syntax:expr()) -> json().
+json_encode_expr(Expr) ->
+    encode_expr(Expr).
+
+-spec json_encode_type(so_syntax:type()) -> json().
+json_encode_type(Type) ->
+    encode_type(Type).
+
+%% Internal functions
+do_contract_interface(Type, Contract, Options) when is_binary(Contract) ->
+    do_contract_interface(Type, binary_to_list(Contract), Options);
+do_contract_interface(Type, ContractString, Options) ->
+    try
+        Ast = so_compiler:parse(ContractString, Options),
+        {TypedAst, _, _} = so_ast_infer_types:infer(Ast, [dont_unfold | Options]),
+        from_typed_ast(Type, TypedAst)
+    catch
+        throw:{error, Errors} -> {error, Errors}
+    end.
+
+from_typed_ast(Type, TypedAst) ->
+    JArray = [ encode_contract(C) || C <- TypedAst ],
+    case Type of
+        json   -> {ok, JArray};
+        string -> do_render_aci_json(JArray)
+    end.
+
+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)) ],
+    FilterT = fun(N) -> fun(#{name := N1}) -> N == N1 end end,
+    {Es, Tdefs1} = lists:partition(FilterT(<<"event">>), Tdefs0),
+    {Ss, Tdefs}  = lists:partition(FilterT(<<"state">>), Tdefs1),
+
+    C1 = C0#{typedefs => Tdefs},
+
+    C2 = case Es of
+             []                 -> C1;
+             [#{typedef := ET}] -> C1#{event => ET}
+         end,
+
+    C3 = case Ss of
+             []                 -> C2;
+             [#{typedef := ST}] -> C2#{state => ST}
+         end,
+
+    Fdefs  = [ encode_function(F)
+               || F <- sort_decls(contract_funcs(Contract)),
+                  is_entrypoint(F) ],
+
+    #{contract => C3#{kind => Head, functions => Fdefs, payable => is_payable(Contract)}};
+encode_contract(Namespace = {namespace, _, {con, _, Name}, _}) ->
+    Tdefs = [ encode_typedef(T) || T <- sort_decls(contract_types(Namespace)) ],
+    #{namespace => #{name => encode_name(Name),
+                     typedefs => Tdefs}}.
+
+%%  Encode a function definition. Currently we are only interested in
+%%  the interface and type.
+encode_function(FDef = {letfun, _, {id, _, Name}, Args, Type, _}) ->
+    #{name      => encode_name(Name),
+      arguments => encode_args(Args),
+      returns   => encode_type(Type),
+      stateful  => is_stateful(FDef),
+      payable   => is_payable(FDef)};
+encode_function(FDecl = {fun_decl, _, {id, _, Name}, {fun_t, _, _, Args, Type}}) ->
+    #{name      => encode_name(Name),
+      arguments => encode_anon_args(Args),
+      returns   => encode_type(Type),
+      stateful  => is_stateful(FDecl),
+      payable   => is_payable(FDecl)}.
+
+encode_anon_args(Types) ->
+    Anons = [ list_to_binary("_" ++ integer_to_list(X)) || X <- lists:seq(1, length(Types))],
+    [ #{name => V, type => encode_type(T)}
+      || {V, T} <- lists:zip(Anons, Types) ].
+
+encode_args(Args) -> [ encode_arg(A) || A <- Args ].
+
+encode_arg({typed, _, Id, T}) ->
+    #{name => encode_type(Id),
+      type => encode_type(T)}.
+
+encode_typedef(Type) ->
+    Name = typedef_name(Type),
+    Vars = typedef_vars(Type),
+    Def  = typedef_def(Type),
+    #{name    => encode_name(Name),
+      vars    => encode_tvars(Vars),
+      typedef => encode_type(Def)}.
+
+encode_tvars(Vars) ->
+    [ #{name => encode_type(V)} || V <- Vars ].
+
+%% Encode type
+encode_type({tvar, _, N})         -> encode_name(N);
+encode_type({id, _, N})           -> encode_name(N);
+encode_type({con, _, N})          -> encode_name(N);
+encode_type({qid, _, Ns})         -> encode_name(lists:join(".", Ns));
+encode_type({qcon, _, Ns})        -> encode_name(lists:join(".", Ns));
+encode_type({tuple_t, _, As})     -> #{tuple => encode_types(As)};
+encode_type({bytes_t, _, Len})    -> #{bytes => Len};
+encode_type({record_t, Fs})       -> #{record => encode_type_fields(Fs)};
+encode_type({app_t, _, Id, Fs})   -> #{encode_type(Id) => encode_types(Fs)};
+encode_type({variant_t, Cs})      -> #{variant => encode_types(Cs)};
+encode_type({constr_t, _, C, As}) -> #{encode_type(C) => encode_types(As)};
+encode_type({alias_t, Type})      -> encode_type(Type);
+encode_type({fun_t, _, _, As, T}) -> #{function =>
+                                         #{arguments => encode_types(As),
+                                           returns => encode_type(T)}}.
+
+encode_types(Ts) -> [ encode_type(T) || T <- Ts ].
+
+encode_type_fields(Fs) -> [ encode_type_field(F) || F <- Fs ].
+
+encode_type_field({field_t, _, Id, T}) ->
+    #{name => encode_type(Id),
+      type => encode_type(T)}.
+
+encode_name(Name) when is_list(Name) ->
+    list_to_binary(Name);
+encode_name(Name) when is_binary(Name) ->
+    Name.
+
+%% Encode Expr
+encode_exprs(Es) -> [ encode_expr(E) || E <- Es ].
+
+encode_expr({id, _, N})     -> encode_name(N);
+encode_expr({con, _, N})    -> encode_name(N);
+encode_expr({qid, _, Ns})   -> encode_name(lists:join(".", Ns));
+encode_expr({qcon, _, Ns})  -> encode_name(lists:join(".", Ns));
+encode_expr({typed, _, E})  -> encode_expr(E);
+encode_expr({bool, _, B})   -> B;
+encode_expr({int, _, V})    -> V;
+encode_expr({string, _, S}) -> S;
+encode_expr({tuple, _, As}) -> encode_exprs(As);
+encode_expr({list, _, As})  -> encode_exprs(As);
+encode_expr({bytes, _, B})  ->
+    Digits = byte_size(B),
+    <<N:Digits/unit:8>> = B,
+    list_to_binary(lists:flatten(io_lib:format("#~*.16.0b", [Digits*2, N])));
+encode_expr({Lit, _, L}) when Lit == oracle_pubkey; Lit == oracle_query_id;
+                              Lit == contract_pubkey; Lit == account_pubkey;
+                              Lit == signature ->
+    gmser_api_encoder:encode(Lit, L);
+encode_expr({app, _, {'-', _}, [{int, _, N}]}) ->
+  encode_expr({int, [], -N});
+encode_expr({app, _, F, As}) ->
+    Ef = encode_expr(F),
+    Eas = encode_exprs(As),
+    #{Ef => Eas};
+encode_expr({record, _, Flds}) -> maps:from_list(encode_fields(Flds));
+encode_expr({map, _, KVs})     -> [ [encode_expr(K), encode_expr(V)] || {K, V} <- KVs ];
+encode_expr({Op,_Ann}) ->
+    error({encode_expr_todo, Op}).
+
+encode_fields(Flds) -> [ encode_field(F) || F <- Flds ].
+
+encode_field({field, _, [{proj, _, {id, _, Fld}}], Val}) ->
+    {encode_name(Fld), encode_expr(Val)}.
+
+do_render_aci_json(Json) ->
+    Contracts =
+        case Json of
+            JArray when is_list(JArray)  -> JArray;
+            JObject when is_map(JObject) -> [JObject];
+            JText when is_binary(JText)  ->
+                case jsx:decode(Json, [{labels, atom}, return_maps]) of
+                    JArray when is_list(JArray)  -> JArray;
+                    JObject when is_map(JObject) -> [JObject];
+                    _                            -> error(bad_aci_json)
+                end
+        end,
+    DecodedContracts = [ decode_contract(C) || C <- Contracts ],
+    {ok, list_to_binary(string:join(DecodedContracts, "\n"))}.
+
+decode_contract(#{contract := #{name := Name,
+                                kind := Kind,
+                                payable := Payable,
+                                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) ] ++
+         [ MkTDef(<<"event">>, maps:get(event, C)) || maps:is_key(event, C) ] ++ Ts0,
+    [payable(Payable), case Kind of
+                           contract_main -> "main contract ";
+                           contract_child -> "contract ";
+                           contract_interface -> "contract interface "
+                       end,
+     io_lib:format("~s", [Name])," =\n",
+     decode_tdefs(Ts), decode_funcs(Fs)];
+decode_contract(#{namespace := #{name := Name, typedefs := Ts}}) when Ts /= [] ->
+    ["namespace ", io_lib:format("~s", [Name])," =\n",
+     decode_tdefs(Ts)];
+decode_contract(_) -> [].
+
+decode_funcs(Fs) -> [ decode_func(F) || F <- Fs ].
+
+%% decode_func(#{name := init}) -> [];
+decode_func(#{name := Name, stateful:= Stateful, payable := Payable, arguments := As, returns := T}) ->
+    ["  ", payable(Payable), stateful(Stateful), "entrypoint ", io_lib:format("~s", [Name]), " : ",
+     decode_args(As), " => ", decode_type(T), $\n].
+
+decode_args(As) ->
+    Das = [ decode_arg(A) || A <- As ],
+    [$(,lists:join(", ", Das),$)].
+
+decode_arg(#{type := T}) -> decode_type(T).
+
+decode_types(Ets) ->
+    [ decode_type(Et) || Et <- Ets ].
+
+decode_type(#{tuple := Ets}) ->
+    Ts = decode_types(Ets),
+    case Ts of
+        [] -> ["unit"];
+        _ -> [$(,lists:join(" * ", Ts),$)]
+    end;
+decode_type(#{record := Efs}) ->
+    Fs = decode_fields(Efs),
+    [${,lists:join(",", Fs),$}];
+decode_type(#{list := [Et]}) ->
+    T = decode_type(Et),
+    ["list",$(,T,$)];
+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}) ->
+    Ts = decode_types(Ets),
+    lists:join(" | ", Ts);
+decode_type(#{function := #{arguments := Args, returns := R}}) ->
+    [decode_type(#{tuple => Args}), " => ", decode_type(R)];
+decode_type(Econs) when is_map(Econs) ->	%General constructor
+    [{Ec,Ets}] = maps:to_list(Econs),
+    AppName = decode_name(Ec),
+    AppArgs = decode_types(Ets),
+    case AppArgs of
+        [] -> [AppName];
+        _  -> [AppName,$(,lists:join(", ", AppArgs),$)]
+    end;
+decode_type(T) ->				%Just raw names.
+    decode_name(T).
+
+decode_name(En) when is_atom(En)   -> erlang:atom_to_list(En);
+decode_name(En) when is_binary(En) -> binary_to_list(En).
+
+decode_fields(Efs) ->
+    [ decode_field(Ef) || Ef <- Efs ].
+
+decode_field(#{name := En, type := Et}) ->
+    Name = decode_name(En),
+    Type = decode_type(Et),
+    [Name," : ",Type].
+
+%% decode_tdefs(Json) -> [TypeString].
+%%  Here we are only interested in the type definitions and ignore the
+%%  aliases. We find them as they always have variants.
+
+decode_tdefs(Ts) -> [ decode_tdef(T) || T <- Ts ].
+
+decode_tdef(#{name := Name, vars := Vs, typedef := T}) ->
+    TypeDef = decode_type(T),
+    DefType = decode_deftype(T),
+    ["  ", DefType, " ", decode_name(Name), decode_tvars(Vs), " = ", TypeDef, $\n].
+
+decode_deftype(#{record := _Efs}) -> "record";
+decode_deftype(#{variant := _})   -> "datatype";
+decode_deftype(_T)                      -> "type".
+
+decode_tvars([]) -> [];  %No tvars, no parentheses
+decode_tvars(Vs) ->
+    Dvs = [ decode_tvar(V) || V <- Vs ],
+    [$(,lists:join(", ", Dvs),$)].
+
+decode_tvar(#{name := N}) -> io_lib:format("~s", [N]).
+
+payable(true)  -> "payable ";
+payable(false) -> "".
+
+stateful(true)  -> "stateful ";
+stateful(false) -> "".
+
+%% #contract{Ann, Con, [Declarations]}.
+
+contract_funcs({C, _, _, _, Decls}) when ?IS_CONTRACT_HEAD(C) ->
+    [ D || D <- Decls, is_fun(D)].
+
+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;
+is_fun({fun_decl, _, _, _})     -> true;
+is_fun(_)                       -> false.
+
+is_type({type_def, _, _, _, _}) -> true;
+is_type(_)                      -> false.
+
+sort_decls(Ds) ->
+    Sort = fun (D1, D2) ->
+                   so_syntax:get_ann(line, D1, 0) =<
+                       so_syntax:get_ann(line, D2, 0)
+           end,
+    lists:sort(Sort, Ds).
+
+is_entrypoint(Node) -> so_syntax:get_ann(entrypoint, Node, false).
+is_stateful(Node) -> so_syntax:get_ann(stateful, Node, false).
+is_payable(Node) -> so_syntax:get_ann(payable, Node, false).
+
+typedef_name({type_def, _, {id, _, Name}, _, _}) -> Name.
+
+typedef_vars({type_def, _, _, Vars, _}) -> Vars.
+
+typedef_def({type_def, _, _, _, Def}) -> Def.

src/so_ast.erl

@@ -1,4 +1,5 @@
--module(aeso_ast).
+-module(so_ast).
+-vsn("9.0.0").
 
 -export([int/2,
          line/1,
@@ -17,11 +18,11 @@ line({symbol, Line, _}) -> Line.
 symbol_name({symbol, _, Name}) -> Name.
 
 pp(Ast) ->
-    String = prettypr:format(aeso_pretty:decls(Ast, [])),
+    String = prettypr:format(so_pretty:decls(Ast, [])),
     io:format("Ast:\n~s\n", [String]).
 
 pp_typed(TypedAst) ->
     %% io:format("Typed tree:\n~p\n",[TypedAst]),
-    String = prettypr:format(aeso_pretty:decls(TypedAst, [show_generated])),
+    String = prettypr:format(so_pretty:decls(TypedAst, [show_generated])),
     io:format("Type ast:\n~s\n",[String]).
 

src/so_compiler.erl

@@ -0,0 +1,526 @@
+%%%-------------------------------------------------------------------
+%%% @author Happi (Erik Stenman)
+%%% @copyright (C) 2025, QPQ AG
+%%% @copyright (C) 2017, Aeternity Anstalt
+%%% @doc
+%%%     Compiler from Sophia language to FATE.
+%%% @end
+%%%-------------------------------------------------------------------
+-module(so_compiler).
+-vsn("9.0.0").
+
+-export([ file/1
+        , file/2
+        , from_string/2
+        , check_call/4
+        , decode_value/4
+        , encode_value/4
+        , create_calldata/3
+        , create_calldata/4
+        , version/0
+        , numeric_version/0
+        , to_sophia_value/4
+        , to_sophia_value/5
+        , decode_calldata/3
+        , decode_calldata/4
+        , parse/2
+        , add_include_path/2
+        , validate_byte_code/3
+        ]).
+
+-include_lib("gmbytecode/include/gmb_opcodes.hrl").
+-include("so_utils.hrl").
+
+
+-type option() :: pp_sophia_code
+                | pp_ast
+                | pp_types
+                | pp_typed_ast
+                | pp_assembler
+                | no_code
+                | keep_included
+                | debug_mode
+                | {include, {file_system, [string()]} |
+                            {explicit_files, #{string() => binary()}}}
+                | {src_file, string()}
+                | {src_dir, string()}
+                | {aci, so_aci:aci_type()}.
+-type options() :: [option()].
+
+-export_type([ option/0
+             , options/0
+             ]).
+
+-spec version() -> {ok, binary()} | {error, term()}.
+version() ->
+    case lists:keyfind(sophia, 1, application:loaded_applications()) of
+        false ->
+            case application:load(sophia) of
+                ok ->
+                    case application:get_key(sophia, vsn) of
+                        {ok, VsnString} ->
+                            {ok, list_to_binary(VsnString)};
+                        undefined ->
+                            {error, failed_to_load_sophia}
+                    end;
+                Err = {error, _} ->
+                    Err
+            end;
+        {_App, _Des, VsnString} ->
+            {ok, list_to_binary(VsnString)}
+    end.
+
+-spec numeric_version() -> {ok, [non_neg_integer()]} | {error, term()}.
+numeric_version() ->
+    case version() of
+        {ok, Bin} ->
+            [NoSuf | _] = binary:split(Bin, <<"-">>),
+            Numbers     = binary:split(NoSuf, <<".">>, [global]),
+            {ok, [binary_to_integer(Num) || Num <- Numbers]};
+        {error, _} = Err ->
+            Err
+    end.
+
+-spec file(string()) -> {ok, map()} | {error, [so_errors:error()]}.
+file(Filename) ->
+    file(Filename, []).
+
+-spec file(string(), options()) -> {ok, map()} | {error, [so_errors:error()]}.
+file(File, Options0) ->
+    Options = add_include_path(File, Options0),
+    case read_contract(File) of
+        {ok, Bin} ->
+            SrcDir = so_utils:canonical_dir(filename:dirname(File)),
+            from_string(Bin, [{src_file, File}, {src_dir, SrcDir} | Options]);
+        {error, Error} ->
+            Msg = lists:flatten([File,": ",file:format_error(Error)]),
+            {error, [so_errors:new(file_error, Msg)]}
+    end.
+
+add_include_path(File, Options) ->
+    case lists:keymember(include, 1, Options) of
+        true  -> Options;
+        false ->
+            Dir = filename:dirname(File),
+            {ok, Cwd} = file:get_cwd(),
+            [{include, {file_system, [Cwd, so_utils:canonical_dir(Dir)]}} | Options]
+    end.
+
+-spec from_string(binary() | string(), options()) -> {ok, map()} | {error, [so_errors:error()]}.
+from_string(ContractBin, Options) when is_binary(ContractBin) ->
+    from_string(binary_to_list(ContractBin), Options);
+from_string(ContractString, Options) ->
+    try
+        from_string1(ContractString, Options)
+    catch
+        throw:{error, Errors} -> {error, Errors}
+    end.
+
+from_string1(ContractString, Options) ->
+    #{ fcode := FCode
+     , 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 = so_fcode_to_fate:compile(ChildContracts, FCode, SavedFreshNames, Options),
+    pp_assembler(FateCode, Options),
+    ByteCode = gmb_fate_code:serialize(FateCode, []),
+    {ok, Version} = version(),
+    Res = #{byte_code => ByteCode,
+            compiler_version => Version,
+            contract_source => ContractString,
+            type_info => [],
+            fate_code => FateCode,
+            abi_version => gmb_fate_abi:abi_version(),
+            payable => maps:get(payable, FCode),
+            warnings => Warnings
+           },
+    {ok, maybe_generate_aci(Res, FoldedTypedAst, Options)}.
+
+maybe_generate_aci(Result, FoldedTypedAst, Options) ->
+    case proplists:get_value(aci, Options) of
+        undefined ->
+            Result;
+        Type ->
+            {ok, Aci} = so_aci:from_typed_ast(Type, FoldedTypedAst),
+            maps:put(aci, Aci, Result)
+    end.
+
+-spec string_to_code(string(), options()) -> map().
+string_to_code(ContractString, Options) ->
+    Ast = parse(ContractString, Options),
+    pp_sophia_code(Ast, Options),
+    pp_ast(Ast, Options),
+    {TypeEnv, FoldedTypedAst, UnfoldedTypedAst, Warnings} = so_ast_infer_types:infer(Ast, [return_env | Options]),
+    pp_typed_ast(UnfoldedTypedAst, Options),
+    {Env, Fcode} = so_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").
+
+%% Takes a string containing a contract with a declaration/prototype of a
+%% function (foo, say) and adds function __call() = foo(args) calling this
+%% function. Returns the name of the called functions, typereps and Erlang
+%% terms for the arguments.
+%% 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(), [term()]}
+                                                             | {error, [so_errors:error()]}.
+check_call(Source, "init" = FunName, Args, Options) ->
+    case check_call1(Source, FunName, Args, Options) of
+        Err = {error, _} when Args == [] ->
+            %% Try with default init-function
+            case check_call1(insert_init_function(Source, Options), FunName, Args, Options) of
+                {error, _} -> Err; %% The first error is most likely better...
+                Res        -> Res
+            end;
+        Res ->
+            Res
+    end;
+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, [ so_fcode_to_fate:term_to_fate(A) || A <- FcodeArgs ]};
+        Err = {error, _} ->
+            Err
+    end.
+
+add_extra_call(Contract0, Call, Options) ->
+    try
+        %% First check the contract without the __call function
+        #{fcode := OrgFcode
+        , fcode_env := #{child_con_env := ChildContracts}
+        , ast := Ast} = string_to_code(Contract0, Options),
+        FateCode = so_fcode_to_fate:compile(ChildContracts, OrgFcode, #{}, []),
+        %% collect all hashes and compute the first name without hash collision to
+        SymbolHashes = maps:keys(gmb_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.
+
+get_call_body(CallName, #{fcode := Fcode}) ->
+    #{body := Body} = maps:get({entrypoint, list_to_binary(CallName)}, maps:get(functions, Fcode)),
+    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, gmb_fate_encoding:serialize(so_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} ->
+            #{ folded_typed_ast := TypedAst
+             , type_env         := TypeEnv} = Code,
+            {ok, _, Type0} = get_decode_type(CallName, TypedAst),
+            Type1 = so_ast_infer_types:unfold_types_in_type(TypeEnv, Type0,
+                                                              [ unfold_record_types
+                                                              , unfold_variant_types
+                                                              , not_unfold_system_alias_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);
+first_none_match(CallName, Hashes, [Char|Chars]) ->
+    case not lists:member(gmb_fate_code:symbol_identifier(list_to_binary(CallName)), Hashes) of
+        true ->
+            CallName;
+        false ->
+            first_none_match(?CALL_NAME++[Char], Hashes, Chars)
+    end.
+
+%% Add the __call function to a contract.
+-spec insert_call_function(so_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, ") : ", Type, " = val\n"
+        ]).
+
+-spec insert_init_function(string(), options()) -> string().
+insert_init_function(Code, Options) ->
+    Ast = parse(Code, Options),
+    Ind = last_contract_indent(Ast),
+    lists:flatten(
+        [ Code,
+          "\n\n",
+          lists:duplicate(Ind, " "), "entrypoint init() = ()\n"
+        ]).
+
+last_contract_indent(Decls) ->
+    case lists:last(Decls) of
+        {_, _, _, _, [Decl | _]} -> so_syntax:get_ann(col, Decl, 1) - 1;
+        _                        -> 0
+    end.
+
+-spec to_sophia_value(string(), string(), ok | error | revert, binary()) ->
+          {ok, so_syntax:expr()} | {error, [so_errors:error()]}.
+to_sophia_value(ContractString, Fun, ResType, Data) ->
+    to_sophia_value(ContractString, Fun, ResType, Data, []).
+-spec to_sophia_value(string(), string(), ok | error | revert, binary(), options()) ->
+        {ok, so_syntax:expr()} | {error, [so_errors:error()]}.
+to_sophia_value(_, _, error, Err, _Options) ->
+    {ok, {app, [], {id, [], "error"}, [{string, [], Err}]}};
+to_sophia_value(_, _, revert, Data, _Options) ->
+    try so_vm_decode:from_fate({id, [], "string"}, gmb_fate_encoding:deserialize(Data)) of
+        Err ->
+            {ok, {app, [], {id, [], "abort"}, [Err]}}
+    catch _:_ ->
+            Msg = "Could not deserialize the revert message",
+            {error, [so_errors:new(data_error, Msg)]}
+    end;
+to_sophia_value(ContractString, FunName, ok, Data, Options0) ->
+    Options = [no_code | Options0],
+    try
+        Code = string_to_code(ContractString, Options),
+        #{ folded_typed_ast := TypedAst, type_env := TypeEnv} = Code,
+        {ok, _, Type0} = get_decode_type(FunName, TypedAst),
+        Type = so_ast_infer_types:unfold_types_in_type(TypeEnv, Type0,
+                                                         [ unfold_record_types
+                                                         , unfold_variant_types
+                                                         , not_unfold_system_alias_types]),
+
+        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, so_vm_decode:from_fate(UnfoldedType, gmb_fate_encoding:deserialize(FateData))}
+    catch throw:cannot_translate_to_sophia ->
+            Type1 = prettypr:format(so_pretty:type(Type)),
+            Msg = io_lib:format("Cannot translate FATE value ~p\n  of Sophia type ~s",
+                                [gmb_fate_encoding:deserialize(FateData), Type1]),
+            {error, [so_errors:new(data_error, Msg)]};
+          _:_ ->
+            Type1 = prettypr:format(so_pretty:type(Type)),
+            Msg = io_lib:format("Failed to decode binary as type ~s", [Type1]),
+            {error, [so_errors:new(data_error, Msg)]}
+    end.
+
+-spec create_calldata(string(), string(), [string()]) ->
+          {ok, binary()} | {error, [so_errors:error()]}.
+create_calldata(Code, Fun, Args) ->
+    create_calldata(Code, Fun, Args, []).
+-spec create_calldata(string(), string(), [string()], [{atom(), any()}]) ->
+                             {ok, binary()} | {error, [so_errors:error()]}.
+create_calldata(Code, Fun, Args, Options0) ->
+    Options = [no_code | Options0],
+    case check_call(Code, Fun, Args, Options) of
+        {ok, FunName, FateArgs} ->
+            gmb_fate_abi:create_calldata(FunName, FateArgs);
+        {error, _} = Err -> Err
+    end.
+
+-spec decode_calldata(string(), string(), binary()) ->
+          {ok, [so_syntax:type()], [so_syntax:expr()]}
+        | {error, [so_errors:error()]}.
+decode_calldata(ContractString, FunName, Calldata) ->
+    decode_calldata(ContractString, FunName, Calldata, []).
+-spec decode_calldata(string(), string(), binary(), options()) ->
+          {ok, [so_syntax:type()], [so_syntax:expr()]}
+        | {error, [so_errors:error()]}.
+decode_calldata(ContractString, FunName, Calldata, Options0) ->
+    Options = [no_code | Options0],
+    try
+        Code = string_to_code(ContractString, Options),
+        #{ folded_typed_ast := TypedAst, type_env  := TypeEnv} = Code,
+
+        {ok, Args, _} = get_decode_type(FunName, TypedAst),
+        GetType       = fun({typed, _, _, T}) -> T; (T) -> T end,
+        ArgTypes      = lists:map(GetType, Args),
+        Type0         = {tuple_t, [], ArgTypes},
+        %% user defined data types such as variants needed to match against
+        Type          = so_ast_infer_types:unfold_types_in_type(TypeEnv, Type0,
+                                                                  [ unfold_record_types
+                                                                  , unfold_variant_types
+                                                                  , not_unfold_system_alias_types]),
+        case gmb_fate_abi:decode_calldata(FunName, Calldata) of
+            {ok, FateArgs} ->
+                try
+                    {tuple_t, [], ArgTypes1} = Type,
+                    AstArgs = [ so_vm_decode:from_fate(ArgType, FateArg)
+                                || {ArgType, FateArg} <- lists:zip(ArgTypes1, FateArgs)],
+                    {ok, ArgTypes, AstArgs}
+                catch throw:cannot_translate_to_sophia ->
+                        Type0Str = prettypr:format(so_pretty:type(Type0)),
+                        Msg = io_lib:format("Cannot translate FATE value ~p\n  to Sophia type ~s",
+                                            [FateArgs, Type0Str]),
+                        {error, [so_errors:new(data_error, Msg)]}
+                end;
+            {error, _} ->
+                Msg = io_lib:format("Failed to decode calldata binary", []),
+                {error, [so_errors:new(data_error, Msg)]}
+        end
+    catch
+        throw:{error, Errors} -> {error, Errors}
+    end.
+
+-dialyzer({nowarn_function, get_decode_type/2}).
+get_decode_type(FunName, [{Contract, Ann, _, _, Defs}]) when ?IS_CONTRACT_HEAD(Contract) ->
+    GetType = fun({letfun, _, {id, _, Name}, Args, Ret, _})               when Name == FunName -> [{Args, Ret}];
+                 ({fun_decl, _, {id, _, Name}, {fun_t, _, _, Args, Ret}}) when Name == FunName -> [{Args, Ret}];
+                 (_) -> [] end,
+    case lists:flatmap(GetType, Defs) of
+        [{Args, Ret}] -> {ok, Args, Ret};
+        []            ->
+            case FunName of
+                "init" -> {ok, [], {tuple_t, [], []}};
+                 _ ->
+                    Msg = io_lib:format("Function '~s' is missing in contract", [FunName]),
+                    Pos = so_errors:pos(Ann),
+                    so_errors:throw(so_errors:new(data_error, Pos, Msg))
+            end
+    end;
+get_decode_type(FunName, [_ | Contracts]) ->
+    %% The __decode should be in the final contract
+    get_decode_type(FunName, Contracts).
+
+pp_sophia_code(C, Opts)->  pp(C, Opts, pp_sophia_code, fun(Code) ->
+                                io:format("~s\n", [prettypr:format(so_pretty:decls(Code))])
+                            end).
+pp_ast(C, Opts)      ->  pp(C, Opts, pp_ast, fun so_ast:pp/1).
+pp_typed_ast(C, Opts)->  pp(C, Opts, pp_typed_ast, fun so_ast:pp_typed/1).
+
+pp_assembler(C, Opts) ->  pp(C, Opts, pp_assembler, fun(Asm) -> io:format("~s", [gmb_fate_asm:pp(Asm)]) end).
+
+pp(Code, Options, Option, PPFun) ->
+    case proplists:lookup(Option, Options) of
+        {Option1, true} when Option1 =:= Option ->
+            PPFun(Code);
+        none ->
+            ok
+    end.
+
+%% -- Byte code validation ---------------------------------------------------
+
+-define(protect(Tag, Code), fun() -> try Code catch _:Err1 -> throw({Tag, Err1}) end end()).
+
+-spec validate_byte_code(map(), string(), options()) -> ok | {error, [so_errors:error()]}.
+validate_byte_code(#{ byte_code := ByteCode, payable := Payable }, Source, Options) ->
+    Fail = fun(Err) -> {error, [so_errors:new(data_error, Err)]} end,
+    try
+        FCode1 = ?protect(deserialize, gmb_fate_code:strip_init_function(gmb_fate_code:deserialize(ByteCode))),
+        {FCode2, SrcPayable} =
+            ?protect(compile,
+                     begin
+                         {ok, #{ byte_code := SrcByteCode, payable := SrcPayable }} =
+                             from_string1(Source, Options),
+                         FCode = gmb_fate_code:deserialize(SrcByteCode),
+                         {gmb_fate_code:strip_init_function(FCode), SrcPayable}
+                     end),
+        case compare_fate_code(FCode1, FCode2) of
+            ok when SrcPayable /= Payable ->
+                Not = fun(true) -> ""; (false) -> " not" end,
+                Fail(io_lib:format("Byte code contract is~s payable, but source code contract is~s.\n",
+                                   [Not(Payable), Not(SrcPayable)]));
+            ok           -> ok;
+            {error, Why} -> Fail(io_lib:format("Byte code does not match source code.\n~s", [Why]))
+        end
+    catch
+        throw:{deserialize, _}         -> Fail("Invalid byte code");
+        throw:{compile, {error, Errs}} -> {error, Errs}
+    end.
+
+compare_fate_code(FCode1, FCode2) ->
+    Funs1 = gmb_fate_code:functions(FCode1),
+    Funs2 = gmb_fate_code:functions(FCode2),
+    Syms1 = gmb_fate_code:symbols(FCode1),
+    Syms2 = gmb_fate_code:symbols(FCode2),
+    FunHashes1 = maps:keys(Funs1),
+    FunHashes2 = maps:keys(Funs2),
+    case FunHashes1 == FunHashes2 of
+        false ->
+            InByteCode   = [ binary_to_list(maps:get(H, Syms1)) || H <- FunHashes1 -- FunHashes2 ],
+            InSourceCode = [ binary_to_list(maps:get(H, Syms2)) || H <- FunHashes2 -- FunHashes1 ],
+            Msg = [ io_lib:format("- Functions in the byte code but not in the source code:\n"
+                                  "    ~s\n", [string:join(InByteCode, ", ")]) || InByteCode /= [] ] ++
+                  [ io_lib:format("- Functions in the source code but not in the byte code:\n"
+                                  "    ~s\n", [string:join(InSourceCode, ", ")]) || InSourceCode /= [] ],
+            {error, Msg};
+        true ->
+            case lists:append([ compare_fate_fun(maps:get(H, Syms1), Fun1, Fun2)
+                                || {{H, Fun1}, {_, Fun2}} <- lists:zip(maps:to_list(Funs1),
+                                                                       maps:to_list(Funs2)) ]) of
+                [] -> ok;
+                Errs -> {error, Errs}
+            end
+    end.
+
+compare_fate_fun(_Name, Fun, Fun) -> [];
+compare_fate_fun(Name, {Attr, Type, _}, {Attr, Type, _}) ->
+    [io_lib:format("- The implementation of the function ~s is different.\n", [Name])];
+compare_fate_fun(Name, {Attr1, Type, _}, {Attr2, Type, _}) ->
+    [io_lib:format("- The attributes of the function ~s differ:\n"
+                   "    Byte code:   ~s\n"
+                   "    Source code: ~s\n",
+                   [Name, string:join([ atom_to_list(A) || A <- Attr1 ], ", "),
+                          string:join([ atom_to_list(A) || A <- Attr2 ], ", ")])];
+compare_fate_fun(Name, {_, Type1, _}, {_, Type2, _}) ->
+    [io_lib:format("- The type of the function ~s differs:\n"
+                   "    Byte code:   ~s\n"
+                   "    Source code: ~s\n",
+                   [Name, pp_fate_sig(Type1), pp_fate_sig(Type2)])].
+
+pp_fate_sig({[Arg], Res}) ->
+    io_lib:format("~s => ~s", [pp_fate_type(Arg), pp_fate_type(Res)]);
+pp_fate_sig({Args, Res}) ->
+    io_lib:format("(~s) => ~s", [string:join([pp_fate_type(Arg) || Arg <- Args], ", "), pp_fate_type(Res)]).
+
+pp_fate_type(T) -> io_lib:format("~w", [T]).
+
+%% -------------------------------------------------------------------
+
+-spec parse(string(), so_compiler:options()) -> none() | so_syntax:ast().
+parse(Text, Options) ->
+    parse(Text, sets:new(), Options).
+
+-spec parse(string(), sets:set(), so_compiler:options()) -> none() | so_syntax:ast().
+parse(Text, Included, Options) ->
+    so_parser:string(Text, Included, Options).
+
+read_contract(Name) ->
+    file:read_file(Name).

src/so_errors.erl

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

src/so_parse_lib.erl

@@ -1,20 +1,25 @@
 %%% -*- erlang-indent-level:4; indent-tabs-mode: nil -*-
 %%%-------------------------------------------------------------------
+%%% @copyright (C) 2025, QPQ AG
 %%% @copyright (C) 2018, Aeternity Anstalt
 %%% @doc Parser combinators for the Sophia parser. Based on
 %%%      Koen Claessen. 2004. Parallel Parsing Processes. J. Functional
 %%%      Programming 14, 6 (November 2004)
 %%% @end
 %%%-------------------------------------------------------------------
--module(aeso_parse_lib).
+-module(so_parse_lib).
+-vsn("9.0.0").
 
 -export([parse/2,
-         return/1, fail/0, fail/1, map/2, bind/2,
+         return/1, fail/0, fail/1, fail/2, map/2, bind/2,
          lazy/1, choice/1, choice/2, tok/1, layout/0,
          left/2, right/2, between/3, optional/1,
          many/1, many1/1, sep/2, sep1/2,
          infixl/2, infixr/2]).
 
+-export([current_file/0, set_current_file/1, current_dir/0, set_current_dir/1,
+         current_include_type/0, set_current_include_type/1]).
+
 %% -- Types ------------------------------------------------------------------
 
 -export_type([parser/1, parser_expr/1, pos/0, token/0, tokens/0]).
@@ -24,16 +29,16 @@
 -type tokens() :: [token()].
 -type error()  :: {pos(), string() | no_error}.
 
--define(lazy(F),     {aeso_parse_lazy, F}).
--define(fail(Err),   {aeso_parse_fail, Err}).
--define(choice(Ps),  {aeso_parse_choice, Ps}).
--define(bind(P, F),  {aeso_parse_bind, P, F}).
--define(right(P, Q), {aeso_parse_right, P, Q}).
--define(left(P, Q),  {aeso_parse_left, P, Q}).
--define(map(F, P),   {aeso_parse_map, F, P}).
--define(layout,       aeso_parse_layout).
--define(tok(Atom),   {aeso_parse_tok, Atom}).
--define(return(X),   {aeso_parse_return, X}).
+-define(lazy(F),     {so_parse_lazy, F}).
+-define(fail(Err),   {so_parse_fail, Err}).
+-define(choice(Ps),  {so_parse_choice, Ps}).
+-define(bind(P, F),  {so_parse_bind, P, F}).
+-define(right(P, Q), {so_parse_right, P, Q}).
+-define(left(P, Q),  {so_parse_left, P, Q}).
+-define(map(F, P),   {so_parse_map, F, P}).
+-define(layout,       so_parse_layout).
+-define(tok(Atom),   {so_parse_tok, Atom}).
+-define(return(X),   {so_parse_return, X}).
 
 %% Type synonyms since you can't have function types as macro arguments for some reason.
 -type delayed(A)         :: fun(() -> A).
@@ -72,25 +77,31 @@
                     %%   first argument. I.e. no backtracking to the second argument if the first
                     %%   fails.
 
+trampoline({bounce, Cont}) when is_function(Cont, 0) ->
+    trampoline(Cont());
+trampoline(Res) ->
+    Res.
+-define(BOUNCE(X), {bounce, fun() -> X end}).
+
 %% Apply a parser to its continuation. This compiles a parser to its low-level representation.
 -spec apply_p(parser(A), fun((A) -> parser1(B))) -> parser1(B).
 apply_p(?lazy(F), K)           -> apply_p(F(), K);
 apply_p(?fail(Err), _)         -> {fail, Err};
-apply_p(?choice([P | Ps]), K)  -> lists:foldl(fun(Q, R) -> choice1(apply_p(Q, K), R) end,
-                                             apply_p(P, K), Ps);
+apply_p(?choice([P | Ps]), K)  -> lists:foldl(fun(Q, R) -> choice1(trampoline(apply_p(Q, K)), R) end,
+                                              trampoline(apply_p(P, K)), Ps);
 apply_p(?bind(P, F), K)        -> apply_p(P, fun(X) -> apply_p(F(X), K) end);
 apply_p(?right(P, Q), K)       -> apply_p(P, fun(_) -> apply_p(Q, K) end);
 apply_p(?left(P, Q), K)        -> apply_p(P, fun(X) -> apply_p(Q, fun(_) -> K(X) end) end);
 apply_p(?map(F, P), K)         -> apply_p(P, fun(X) -> K(F(X)) end);
 apply_p(?layout, K)            -> {layout, K, {fail, {expected, layout_block}}};
 apply_p(?tok(Atom), K)         -> {tok_bind, #{Atom => K}};
-apply_p(?return(X), K)         -> K(X);
+apply_p(?return(X), K)         -> ?BOUNCE(K(X));
 apply_p([P | Q], K)            -> apply_p(P, fun(H) -> apply_p(Q, fun(T) -> K([H | T]) end) end);
 apply_p(T, K) when is_tuple(T) -> apply_p(tuple_to_list(T), fun(Xs) -> K(list_to_tuple(Xs)) end);
 apply_p(M, K) when is_map(M) ->
     {Keys, Ps} = lists:unzip(maps:to_list(M)),
     apply_p(Ps, fun(Vals) -> K(maps:from_list(lists:zip(Keys, Vals))) end);
-apply_p(X, K) -> K(X).
+apply_p(X, K) -> ?BOUNCE(K(X)).
 
 %% -- Primitive combinators --------------------------------------------------
 
@@ -98,6 +109,10 @@ apply_p(X, K) -> K(X).
 -spec lazy(fun(() -> parser(A))) -> parser(A).
 lazy(Delayed) -> ?lazy(Delayed).
 
+%% @doc A parser that always fails at a known location.
+-spec fail(pos(), term()) -> parser(none()).
+fail(Pos, Err) -> ?fail({Pos, Err}).
+
 %% @doc A parser that always fails.
 -spec fail(term()) -> parser(none()).
 fail(Err) -> ?fail(Err).
@@ -154,8 +169,8 @@ layout() -> ?layout.
 %% @doc Parse a sequence of tokens using a parser. Fails if the parse is ambiguous.
 -spec parse(parser(A), tokens()) -> {ok, A} | {error, term()}.
 parse(P, S) ->
-  case parse1(apply_p(P, fun(X) -> {return_plus, X, {fail, no_error}} end), S) of
-    {[], {Pos, Err}} -> {error, {Pos, parse_error, flatten_error(Err)}};
+  case parse1(trampoline(apply_p(P, fun(X) -> {return_plus, X, {fail, no_error}} end)), S) of
+    {[], {Pos, Err}} -> {error, {add_current_file(Pos), parse_error, flatten_error(Err)}};
     {[A], _}         -> {ok, A};
     {As, _}          -> {error, {{1, 1}, ambiguous_parse, As}}
   end.
@@ -235,7 +250,7 @@ col(T)  when is_tuple(T) -> element(2, pos(T)).
 
 %% If both parsers want the next token we grab it and merge the continuations.
 choice1({tok_bind, Map1}, {tok_bind, Map2}) ->
-    {tok_bind, merge_with(fun(F, G) -> fun(T) -> choice1(F(T), G(T)) end end, Map1, Map2)};
+    {tok_bind, merge_with(fun(F, G) -> fun(T) -> choice1(trampoline(F(T)), trampoline(G(T))) end end, Map1, Map2)};
 
 %% If both parsers fail we combine the error messages. If only one fails we discard it.
 choice1({fail, E1}, {fail, E2})             -> {fail, add_error(E1, E2)};
@@ -249,7 +264,7 @@ choice1(P, {return_plus, X, Q})             -> {return_plus, X, choice1(P, Q)};
 %% If both sides want a layout block we combine them. If only one side wants a layout block we
 %% will commit to a layout block is there is one.
 choice1({layout, F, P}, {layout, G, Q})     ->
-    {layout, fun(N) -> choice1(F(N), G(N)) end, choice1(P, Q)};
+    {layout, fun(N) -> choice1(trampoline(F(N)), trampoline(G(N))) end, choice1(P, Q)};
 choice1({layout, F, P}, Q)                  -> {layout, F, choice1(P, Q)};
 choice1(P, {layout, G, Q})                  -> {layout, G, choice1(P, Q)}.
 
@@ -272,6 +287,8 @@ parse1(P, S) ->
 %% The main work horse. Returns a list of possible parses and an error message in case parsing
 %% fails.
 -spec parse1(parser1(A), #ts{}, [A], term()) -> {[A], error()}.
+parse1({bounce, F}, Ts, Acc, Err) ->
+    parse1(F(), Ts, Acc, Err);
 parse1({tok_bind, Map}, Ts, Acc, Err) ->
     case next_token(Ts) of
         {T, Ts1} ->
@@ -285,7 +302,7 @@ parse1({tok_bind, Map}, Ts, Acc, Err) ->
                     %%            y + y)(4)
                     case maps:get(vclose, Map, '$not_found') of
                         '$not_found' ->
-                            {Acc, unexpected_token_error(Ts, T)};
+                            {Acc, unexpected_token_error(Ts, maps:keys(Map), T)};
                         F ->
                             VClose = {vclose, pos(T)},
                             Ts2    = pop_layout(VClose, Ts#ts{ last = VClose }),
@@ -322,12 +339,52 @@ current_pos(#ts{ tokens   = [T | _] }) -> pos(T);
 current_pos(#ts{ last     = T })       -> end_pos(pos(T)).
 
 -spec mk_error(#ts{}, term()) -> error().
+mk_error(_Ts, {Pos, Err}) ->
+    {Pos, Err};
 mk_error(Ts, Err) ->
     {current_pos(Ts), Err}.
 
 -spec unexpected_token_error(#ts{}, token()) -> error().
 unexpected_token_error(Ts, T) ->
-    mk_error(Ts, io_lib:format("Unexpected token ~p", [tag(T)])).
+    unexpected_token_error(Ts, [], T).
+
+unexpected_token_error(Ts, Expect, {Tag, _}) when Tag == vclose; Tag == vsemi ->
+    Braces = [')', ']', '}'],
+    Fix    = case lists:filter(fun(T) -> lists:member(T, Braces) end, Expect) of
+                 []      -> " Probable causes:\n"
+                            "  - something is missing in the previous statement, or\n"
+                            "  - this line should be indented more.";
+                 [T | _] -> io_lib:format(" Did you forget a ~p?", [T])
+             end,
+    Msg = io_lib:format("Unexpected indentation.~s", [Fix]),
+    mk_error(Ts, Msg);
+unexpected_token_error(Ts, Expect, T) ->
+    ExpectCon = lists:member(con, Expect),
+    ExpectId  = lists:member(id,  Expect),
+    Fix = case T of
+              {id, _,  X}   when ExpectCon, hd(X) /= $_ -> io_lib:format(" Did you mean ~s?", [mk_upper(X)]);
+              {con, _, X}   when ExpectId               -> io_lib:format(" Did you mean ~s?", [mk_lower(X)]);
+              {qcon, _, Xs} when ExpectCon              -> io_lib:format(" Did you mean ~s?", [lists:last(Xs)]);
+              {qid, _,  Xs} when ExpectId               -> io_lib:format(" Did you mean ~s?", [lists:last(Xs)]);
+              _ -> ""
+          end,
+    mk_error(Ts, io_lib:format("Unexpected ~s.~s", [describe(T), Fix])).
+
+mk_upper([C | Rest]) -> string:to_upper([C]) ++ Rest.
+mk_lower([C | Rest]) -> string:to_lower([C]) ++ Rest.
+
+
+describe({id, _, X})     -> io_lib:format("identifier ~s", [X]);
+describe({con, _, X})    -> io_lib:format("identifier ~s", [X]);
+describe({qid, _, Xs})   -> io_lib:format("qualified identifier ~s", [string:join(Xs, ".")]);
+describe({qcon, _, Xs})  -> io_lib:format("qualified identifier ~s", [string:join(Xs, ".")]);
+describe({tvar, _, X})   -> io_lib:format("type variable ~s", [X]);
+describe({char, _, _})   -> "character literal";
+describe({string, _, _}) -> "string literal";
+describe({hex, _, _})    -> "integer literal";
+describe({int, _, _})    -> "integer literal";
+describe({bytes, _, _})  -> "bytes literal";
+describe(T)              -> io_lib:format("token '~s'", [tag(T)]).
 
 %% Get the next token from a token stream. Inserts layout tokens if necessary.
 -spec next_token(#ts{}) -> false | {token(), #ts{}}.
@@ -411,3 +468,27 @@ merge_with(Fun, Map1, Map2) ->
                         end, Map2, maps:to_list(Map1))
     end.
 
+%% Current include type
+current_include_type() ->
+    get('$current_include_type').
+
+set_current_include_type(IncludeType) ->
+    put('$current_include_type', IncludeType).
+
+%% Current source file
+current_file() ->
+    get('$current_file').
+
+set_current_file(File) ->
+    put('$current_file', File).
+
+%% Current source directory
+current_dir() ->
+    get('$current_dir').
+
+set_current_dir(File) ->
+    put('$current_dir', File).
+
+add_current_file({L, C}) -> {current_file(), L, C};
+add_current_file(Pos)    -> Pos.
+

src/so_parser.erl

@@ -0,0 +1,824 @@
+%%% File        : so_parser.erl
+%%% Author      : Ulf Norell
+%%% Description :
+%%% Created     : 1 Mar 2018 by Ulf Norell
+-module(so_parser).
+-vsn("9.0.0").
+-compile({no_auto_import,[map_get/2]}).
+
+-export([string/1,
+         string/2,
+         string/3,
+         auto_imports/1,
+         hash_include/2,
+         decl/0,
+         type/0,
+         body/0,
+         maybe_block/1,
+         run_parser/2,
+         run_parser/3]).
+
+-include("so_parse_lib.hrl").
+-import(so_parse_lib, [current_file/0, set_current_file/1,
+                         current_dir/0, set_current_dir/1,
+                         current_include_type/0, set_current_include_type/1]).
+
+-type parse_result() :: so_syntax:ast() | {so_syntax:ast(), sets:set(include_hash())} | none().
+
+-type include_hash() :: {string(), binary()}.
+
+
+escape_errors({ok, Ok}) ->
+    Ok;
+escape_errors({error, Err}) ->
+    parse_error(Err).
+
+-spec string(string()) -> parse_result().
+string(String) ->
+    string(String, sets:new(), []).
+
+-spec string(string(), so_compiler:options()) -> parse_result().
+string(String, Opts) ->
+    case lists:keyfind(src_file, 1, Opts) of
+        {src_file, File} -> string(String, sets:add_element(File, sets:new()), Opts);
+        false -> string(String, sets:new(), Opts)
+    end.
+
+-spec string(string(), sets:set(include_hash()), so_compiler:options()) -> parse_result().
+string(String, Included, Opts) ->
+    AST = run_parser(file(), String, Opts),
+    case expand_includes(AST, Included, Opts) of
+        {ok, AST1}   -> AST1;
+        {error, Err} -> parse_error(Err)
+    end.
+
+
+run_parser(P, Inp) ->
+    escape_errors(parse_and_scan(P, Inp, [])).
+run_parser(P, Inp, Opts) ->
+    escape_errors(parse_and_scan(P, Inp, Opts)).
+
+parse_and_scan(P, S, Opts) ->
+    set_current_file(proplists:get_value(src_file, Opts, no_file)),
+    set_current_dir(proplists:get_value(src_dir, Opts, no_file)),
+    set_current_include_type(proplists:get_value(include_type, Opts, none)),
+    case so_scan:scan(S) of
+        {ok, Tokens} -> so_parse_lib:parse(P, Tokens);
+        {error, {{Input, Pos}, _}} ->
+            {error, {Pos, scan_error, Input}}
+    end.
+
+-dialyzer({nowarn_function, parse_error/1}).
+parse_error(Err) ->
+    so_errors:throw(mk_error(Err)).
+
+mk_p_err(Pos, Msg) ->
+    so_errors:new(parse_error, mk_pos(Pos), lists:flatten(Msg)).
+
+mk_error({Pos, scan_error, Input}) ->
+    mk_p_err(Pos, io_lib:format("Lexical error on input: ~s\n", [Input]));
+mk_error({Pos, parse_error, Err}) ->
+    Msg = io_lib:format("~s\n", [Err]),
+    mk_p_err(Pos, Msg);
+mk_error({Pos, ambiguous_parse, As}) ->
+    Msg = io_lib:format("Ambiguous parse result: ~p\n", [As]),
+    mk_p_err(Pos, Msg);
+mk_error({Pos, include_error, File}) ->
+    Msg = io_lib:format("Couldn't find include file '~s'\n", [File]),
+    mk_p_err(Pos, Msg).
+
+mk_pos({Line, Col})       -> so_errors:pos(Line, Col);
+mk_pos({File, Line, Col}) -> so_errors:pos(File, Line, Col).
+
+%% -- Parsing rules ----------------------------------------------------------
+
+file() -> choice([], block(decl())).
+
+decl() ->
+    ?LAZY_P(
+    choice(
+      %% Contract declaration
+    [ ?RULE(token(main), keyword(contract),
+            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})
+    , ?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})
+    , ?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}))
+    , ?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}))
+    , ?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}))
+    , ?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})
+    , ?RULE(keyword(include),   str(), {include, get_ann(_1), _2})
+    , using()
+    , pragma()
+
+      %% Type declarations  TODO: format annotation for "type bla" vs "type bla()"
+    , ?RULE(keyword(type),     id(),                                          {type_decl, _1, _2, []})
+    , ?RULE(keyword(type),     id(), type_vars(),                             {type_decl, _1, _2, _3})
+    , ?RULE(keyword(type),     id(),              tok('='), typedef(type),    {type_def, _1, _2, [], _4})
+    , ?RULE(keyword(type),     id(), type_vars(), tok('='), typedef(type),    {type_def, _1, _2, _3, _5})
+    , ?RULE(keyword(record),   id(),              tok('='), typedef(record),  {type_def, _1, _2, [], _4})
+    , ?RULE(keyword(record),   id(), type_vars(), tok('='), typedef(record),  {type_def, _1, _2, _3, _5})
+    , ?RULE(keyword(datatype), id(),              tok('='), typedef(variant), {type_def, _1, _2, [], _4})
+    , ?RULE(keyword(datatype), id(), type_vars(), tok('='), typedef(variant), {type_def, _1, _2, _3, _5})
+
+      %% Function declarations
+    , ?RULE(modifiers(), fun_or_entry(), maybe_block(fundef_or_decl()), fun_block(_1, _2, _3))
+    , ?RULE(keyword('let'), valdef(), set_pos(get_pos(_1), _2))
+    ])).
+
+fun_block(Mods, Kind, [Decl]) ->
+    add_modifiers(Mods, Kind, set_pos(get_pos(Kind), Decl));
+fun_block(Mods, Kind, Decls) ->
+    {block, get_ann(Kind), [ add_modifiers(Mods, Kind, Decl) || Decl <- Decls ]}.
+
+fundef_or_decl() ->
+    choice([?RULE(id(), tok(':'), type(), {fun_decl, get_ann(_1), _1, _3}),
+            fundef()]).
+
+using() ->
+    Alias = {keyword(as), con()},
+    For = ?RULE(keyword(for), bracket_list(id()), {for, _2}),
+    Hiding = ?RULE(keyword(hiding), bracket_list(id()), {hiding, _2}),
+    ?RULE(keyword(using), con(), optional(Alias), optional(choice(For, Hiding)), using(get_ann(_1), _2, _3, _4)).
+
+using(Ann, Con, none, none) ->
+    {using, Ann, Con, none, none};
+using(Ann, Con, {ok, {_, Alias}}, none) ->
+    {using, Ann, Con, Alias, none};
+using(Ann, Con, none, {ok, List}) ->
+    {using, Ann, Con, none, List};
+using(Ann, Con, {ok, {_, Alias}}, {ok, List}) ->
+    {using, Ann, Con, Alias, List}.
+
+pragma() ->
+    Op = choice([token(T) || T <- ['<', '=<', '==', '>=', '>']]),
+    ?RULE(tok('@'), id("compiler"), Op, version(), {pragma, get_ann(_1), {compiler, element(1, _3), _4}}).
+
+version() ->
+    ?RULE(token(int), many({tok('.'), token(int)}), mk_version(_1, _2)).
+
+mk_version({int, _, Maj}, Rest) ->
+    [Maj | [N || {_, {int, _, N}} <- Rest]].
+
+fun_or_entry() ->
+    choice([?RULE(keyword(function),   {function,   _1}),
+            ?RULE(keyword(entrypoint), {entrypoint, _1})]).
+
+modifiers() ->
+    many(choice([token(stateful), token(payable), token(private), token(public)])).
+
+add_modifiers(Mods, Entry = {entrypoint, _}, Node) ->
+    add_modifiers(Mods ++ [Entry], Node);
+add_modifiers(Mods, {function, _}, Node) ->
+    add_modifiers(Mods, Node).
+
+add_modifiers([], Node) -> Node;
+add_modifiers(Mods = [Tok | _], Node) ->
+    %% Set the position to the position of the first modifier. This is
+    %% important for code transformation tools (like what we do in
+    %% create_calldata) to be able to get the indentation of the declaration.
+    set_pos(get_pos(Tok),
+        lists:foldl(fun({Mod, _}, X) -> set_ann(Mod, true, X) end,
+                    Node, Mods)).
+
+%% -- Type declarations ------------------------------------------------------
+
+typedef(type)    -> ?RULE(type(),                   {alias_t, _1});
+typedef(record)  -> ?RULE(brace_list(field_type()), {record_t, _1});
+typedef(variant) -> ?RULE(constructors(),           {variant_t, _1}).
+
+constructors() ->
+    sep1(constructor(), tok('|')).
+
+constructor() ->    %% TODO: format for Con() vs Con
+    choice(?RULE(con(),             {constr_t, get_ann(_1), _1, []}),
+           ?RULE(con(), con_args(), {constr_t, get_ann(_1), _1, _2})).
+
+con_args()   -> paren_list(con_arg()).
+type_args()  -> paren_list(type()).
+field_type() -> ?RULE(id(), tok(':'), type(), {field_t, get_ann(_1), _1, _3}).
+
+con_arg()    -> choice(type(), ?RULE(keyword(indexed), type(), set_ann(indexed, true, _2))).
+
+%% -- Let declarations -------------------------------------------------------
+
+letdecl() ->
+    ?RULE(keyword('let'), letdef(), set_pos(get_pos(_1), _2)).
+
+letdef() -> choice(valdef(), fundef()).
+
+valdef() ->
+    ?RULE(pattern(), tok('='), body(), {letval, [], _1, _3}).
+
+guarded_fundefs() ->
+    choice(
+    [ ?RULE(keyword('='), body(), [{guarded, _1, [], _2}])
+    , maybe_block(?RULE(keyword('|'), comma_sep(expr()), tok('='), body(), {guarded, _1, _2, _4}))
+    ]).
+
+fundef() ->
+    choice(
+    [ ?RULE(id(), args(),                   guarded_fundefs(), {letfun, get_ann(_1), _1, _2, type_wildcard(get_ann(_1)), _3})
+    , ?RULE(id(), args(), tok(':'), type(), guarded_fundefs(), {letfun, get_ann(_1), _1, _2, _4, _5})
+    ]).
+
+args() -> paren_list(pattern()).
+lam_args() -> paren_list(arg()).
+
+arg() -> choice(
+    ?RULE(id(),                   {arg, get_ann(_1), _1, type_wildcard(get_ann(_1))}),
+    ?RULE(id(), tok(':'), type(), {arg, get_ann(_1), _1, _3})).
+
+letpat() ->
+    ?RULE(keyword('('), id(), tok('='), pattern(), tok(')'), {letpat, get_ann(_1), _2, _4}).
+
+%% -- Types ------------------------------------------------------------------
+
+type_vars() -> paren_list(tvar()).
+
+type() -> ?LAZY_P(type100()).
+
+type100() -> type200().
+
+type200() ->
+    ?RULE(many({type300(), keyword('=>')}), type300(), fun_t(_1, _2)).
+
+type300() ->
+    ?RULE(sep1(type400(), tok('*')), tuple_t(get_ann(lists:nth(1, _1)), _1)).
+
+type400() ->
+    choice(
+    [?RULE(typeAtom(), optional(type_args()),
+          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)})
+    ]).
+
+typeAtom() ->
+    ?LAZY_P(choice(
+    [ parens(type())
+    , args_t()
+    , id(), token(con), token(qcon), token(qid), tvar()
+    ])).
+
+args_t() ->
+    ?LAZY_P(choice(
+    [ ?RULE(tok('('), tok(')'), {args_t, get_ann(_1), []})
+      %% Singleton case handled separately
+    , ?RULE(tok('('), type(), tok(','), sep1(type(), tok(',')), tok(')'), {args_t, get_ann(_1), [_2|_4]})
+    ])).
+
+%% -- Statements -------------------------------------------------------------
+
+body() ->
+    ?LET_P(Stmts, maybe_block(stmt()), block_e(Stmts)).
+
+stmt() ->
+    ?LAZY_P(choice(
+    [ using()
+    , expr()
+    , letdecl()
+    , {switch, keyword(switch), parens(expr()), maybe_block(branch())}
+    , {'if', keyword('if'), parens(expr()), body()}
+    , {elif, keyword(elif), parens(expr()), body()}
+    , {'else', keyword('else'), body()}
+    ])).
+
+branch() ->
+    ?RULE(pattern(), guarded_branches(), {'case', get_ann(lists:nth(1, _2)), _1, _2}).
+
+guarded_branches() ->
+    choice(
+    [ ?RULE(keyword('=>'), body(), [{guarded, _1, [], _2}])
+    , maybe_block(?RULE(tok('|'), comma_sep(expr()), keyword('=>'), body(), {guarded, _3, _2, _4}))
+    ]).
+
+pattern() ->
+    ?LET_P(E, expr(), parse_pattern(E)).
+
+%% -- Expressions ------------------------------------------------------------
+
+expr() -> expr100().
+
+expr100() ->
+    Expr100 = ?LAZY_P(expr100()),
+    Expr150 = ?LAZY_P(expr150()),
+    choice(
+    [ ?RULE(lam_args(), keyword('=>'), body(), {lam, _2, _1, _3})   %% TODO: better location
+    , {'if', keyword('if'), parens(Expr100), Expr150, right(tok('else'), Expr100)}
+    , ?RULE(Expr150, optional(right(tok(':'), type())),
+            case _2 of
+                none       -> _1;
+                {ok, Type} -> {typed, get_ann(_1), _1, Type}
+            end)
+    ]).
+
+expr150() -> infixl(expr200(), binop('|>')).
+expr200() -> infixr(expr300(), binop('||')).
+expr300() -> infixr(expr325(), binop('&&')).
+expr325() -> infixl(expr350(), binop('bor')).
+expr350() -> infixl(expr375(), binop('bxor')).
+expr375() -> infixl(expr400(), binop('band')).
+expr400() -> infix(expr500(),  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('!')), 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), binop_as_lam()
+        , token(bytes), token(string), token(char)
+        , token(int)
+        , ?RULE(token(hex), set_ann(format, hex, setelement(1, _1, int)))
+        , {bool, keyword(true), true}
+        , {bool, keyword(false), false}
+        , ?LET_P(Fs, brace_list(?LAZY_P(field_assignment())), record(Fs))
+        , {list, [], bracket_list(Expr)}
+        , ?RULE(keyword('['), Expr, token('|'), comma_sep(comprehension_exp()), tok(']'), list_comp_e(_1, _2, _4))
+        , ?RULE(tok('['), Expr, binop('..'), Expr, tok(']'), _3(_2, _4))
+        , ?RULE(keyword('('), comma_sep(Expr), tok(')'), tuple_e(_1, _2))
+        , letpat()
+        , hole()
+        ])
+    end).
+
+hole() -> ?RULE(token('???'), {id, get_ann(_1), "???"}).
+
+comprehension_exp() ->
+    ?LAZY_P(choice(
+      [ comprehension_bind()
+      , letdecl()
+      , comprehension_if()
+      ])).
+
+comprehension_if() ->
+    ?RULE(keyword('if'), parens(expr()), {comprehension_if, _1, _2}).
+
+comprehension_bind() ->
+    ?RULE(pattern(), tok('<-'), expr(), {comprehension_bind, _1, _3}).
+
+arg_expr() ->
+    ?LAZY_P(
+        choice([ ?RULE(id(), tok('='), expr(), {named_arg, [], _1, _3})
+               , expr() ])).
+
+elim() ->
+    ?LAZY_P(
+    choice(
+    [ {proj, keyword('.'), id()}
+    , ?RULE(paren_list(arg_expr()), {app, [], _1})
+    , ?RULE(keyword('{'), comma_sep(field_assignment()), tok('}'), {rec_upd, _1, _2})
+    , ?RULE(keyword('['), map_key(), keyword(']'), map_get(_1, _2))
+    ])).
+
+map_get(Ann, {map_key, Key})      -> {map_get, Ann, Key};
+map_get(Ann, {map_key, Key, Val}) -> {map_get, Ann, Key, Val}.
+
+map_key() ->
+    ?RULE(expr(), optional({tok('='), expr()}), map_key(_1, _2)).
+
+map_key(Key, none)           -> {map_key, Key};
+map_key(Key, {ok, {_, Val}}) -> {map_key, Key, Val}.
+
+elim(E, [])                              -> E;
+elim(E, [{proj, Ann, P} | Es])           -> elim({proj, Ann, E, P}, Es);
+elim(E, [{app, _Ann, Args} | Es])        -> elim({app, so_syntax:get_ann(E), E, Args}, Es);
+elim(E, [{rec_upd, Ann, Flds} | Es])     -> elim(record_update(Ann, E, Flds), Es);
+elim(E, [{map_get, Ann, Key} | Es])      -> elim({map_get, Ann, E, Key}, Es);
+elim(E, [{map_get, Ann, Key, Val} | Es]) -> elim({map_get, Ann, E, Key, Val}, Es).
+
+record_update(Ann, E, Flds) ->
+    {record_or_map(Flds), Ann, E, Flds}.
+
+record([]) -> {map, [], []};
+record(Fs) ->
+    case record_or_map(Fs) of
+        record ->
+            Fld = fun({field, _, [_], _} = F) -> F;
+                     ({field, Ann, LV, Id, _}) ->
+                         bad_expr_err("Cannot use '@' in record construction", infix({lvalue, Ann, LV}, {'@', Ann}, Id));
+                     ({field, Ann, LV, _}) ->
+                         bad_expr_err("Cannot use nested fields or keys in record construction", {lvalue, Ann, LV}) end,
+            {record, get_ann(hd(Fs)), lists:map(Fld, Fs)};
+        map    ->
+            Ann = get_ann(hd(Fs ++ [{empty, []}])), %% TODO: source location for empty maps
+            KV = fun({field, _, [{map_get, _, Key}], Val}) -> {Key, Val};
+                    ({field, FAnn, LV, Id, _}) ->
+                        bad_expr_err("Cannot use '@' in map construction", infix({lvalue, FAnn, LV}, {'@', Ann}, Id));
+                    ({field, FAnn, LV, _}) ->
+                        bad_expr_err("Cannot use nested fields or keys in map construction", {lvalue, FAnn, LV}) end,
+            {map, Ann, lists:map(KV, Fs)};
+        record_or_map_error ->
+            {record_or_map_error, get_ann(hd(Fs)), Fs}
+    end.
+
+record_or_map(Fields) ->
+    Kind = fun(Fld) -> case element(3, Fld) of
+                [{proj, _, _}       | _] -> proj;
+                [{map_get, _, _}    | _] -> map_get;
+                [{map_get, _, _, _} | _] -> map_get
+           end end,
+    case lists:usort(lists:map(Kind, Fields)) of
+        [proj]    -> record;
+        [map_get] -> map;
+        _         -> record_or_map_error %% Defer error until type checking
+    end.
+
+field_assignment() ->
+    ?RULE(lvalue(), optional({tok('@'), id()}), tok('='), expr(), field_assignment(get_ann(_3), _1, _2, _4)).
+
+field_assignment(Ann, LV, none, E) ->
+    {field, Ann, LV, E};
+field_assignment(Ann, LV, {ok, {_, Id}}, E) ->
+    {field, Ann, LV, Id, E}.
+
+lvalue() ->
+    ?RULE(lvalueAtom(), many(elim()), lvalue(elim(_1, _2))).
+
+lvalueAtom() ->
+    ?LAZY_P(choice([ id()
+                   , ?RULE(keyword('['), map_key(), keyword(']'), _2)
+                   ])).
+
+lvalue(E) -> lvalue(E, []).
+
+lvalue(X = {id, Ann, _}, LV)     -> [{proj, Ann, X} | LV];
+lvalue({map_key, K}, LV)         -> [{map_get, get_ann(K), K} | LV];
+lvalue({map_key, K, V}, LV)      -> [{map_get, get_ann(K), K, V} | LV];
+lvalue({proj, Ann, E, P}, LV)    -> lvalue(E, [{proj, Ann, P} | LV]);
+lvalue({map_get, Ann, E, K}, LV) -> lvalue(E, [{map_get, Ann, K} | LV]);
+lvalue({map_get, Ann, E, K, V}, LV) -> lvalue(E, [{map_get, Ann, K, V} | LV]);
+lvalue(E, _)                     -> bad_expr_err("Not a valid lvalue", E).
+
+infix(E, Op) ->
+    ?RULE(E, optional({Op, E}),
+    case _2 of
+        none -> _1;
+        {ok, {F, Arg}} -> F(_1, Arg)
+    end).
+
+binop(Op) when is_atom(Op) -> binop([Op]);
+binop(Ops) ->
+    ?RULE(choice([ token(Op) || Op <- Ops ]), fun(A, B) -> infix(A, _1, B) end).
+
+con()      -> token(con).
+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
+        {Tok, {Line, Col}}      -> {Tok, pos_ann(Line, Col)};
+        {Tok, {Line, Col}, Val} -> {Tok, pos_ann(Line, Col), Val}
+    end).
+
+id(Id) ->
+    ?LET_P({id, A, X} = Y, id(),
+           if X == Id -> Y;
+              true    -> fail({A, "expected '" ++ Id ++ "'"})
+           end).
+
+id_or_addr() ->
+    ?RULE(id(), parse_addr_literal(_1)).
+
+parse_addr_literal(Id = {id, Ann, Name}) ->
+    case lists:member(lists:sublist(Name, 3), ["ak_", "ok_", "oq_", "ct_", "sg_"]) of
+        false -> Id;
+        true  ->
+            try gmser_api_encoder:decode(list_to_binary(Name)) of
+                {Type, Bin} -> {Type, Ann, Bin}
+            catch _:_ ->
+                Id
+            end
+    end.
+
+%% -- Helpers ----------------------------------------------------------------
+
+keyword(K) -> ann(tok(K)).
+ann(P)     -> map(fun get_ann/1, P).
+
+block(P) ->
+    between(layout(), sep1(P, tok(vsemi)), tok(vclose)).
+
+maybe_block(P) ->
+    choice(block(P), [P]).
+
+parens(P)   -> between(tok('('), P, tok(')')).
+braces(P)   -> between(tok('{'), P, tok('}')).
+brackets(P) -> between(tok('['), P, tok(']')).
+comma_sep(P) -> sep(P, tok(',')).
+
+paren_list(P)   -> parens(comma_sep(P)).
+brace_list(P)   -> braces(comma_sep(P)).
+bracket_list(P) -> brackets(comma_sep(P)).
+
+%% -- Annotations ------------------------------------------------------------
+
+-type ann()      :: so_syntax:ann().
+-type ann_line() :: so_syntax:ann_line().
+-type ann_col()  :: so_syntax:ann_col().
+
+-spec pos_ann(ann_line(), ann_col()) -> ann().
+pos_ann(Line, Col) ->
+    [ {file, current_file()}
+    , {dir, current_dir()}
+    , {include_type, current_include_type()}
+    , {line, Line}
+    , {col, Col} ].
+
+ann_pos(Ann) ->
+    {proplists:get_value(file, Ann),
+     proplists:get_value(line, Ann),
+     proplists:get_value(col, Ann)}.
+
+get_ann(Ann) when is_list(Ann) -> Ann;
+get_ann(Node) ->
+    case element(2, Node) of
+        {Line, Col} when is_integer(Line), is_integer(Col) -> pos_ann(Line, Col);
+        Ann -> Ann
+    end.
+
+get_ann(Key, Node) ->
+    proplists:get_value(Key, get_ann(Node)).
+
+set_ann(Key, Val, Node) ->
+    Ann = get_ann(Node),
+    setelement(2, Node, lists:keystore(Key, 1, Ann, {Key, Val})).
+
+get_pos(Node) ->
+    {current_file(), get_ann(line, Node), get_ann(col, Node)}.
+
+set_pos({F, L, C}, Node) ->
+    set_ann(file, F, set_ann(line, L, set_ann(col, C, Node))).
+
+infix(L, Op, R) -> set_ann(format, infix,  {app, get_ann(L), Op, [L, R]}).
+
+prefixes(Ops, E) -> lists:foldr(fun prefix/2, E, Ops).
+prefix(Op, E)    -> set_ann(format, prefix, {app, get_ann(Op), Op, [E]}).
+
+type_wildcard(Ann) ->
+    {id, [{origin, system} | Ann], "_"}.
+
+block_e(Stmts) ->
+    group_ifs(Stmts, []).
+
+group_ifs([], [Stmt]) -> return(Stmt);
+group_ifs([], Acc) ->
+    Stmts = [Stmt | _] = lists:reverse(Acc),
+    {block, get_ann(Stmt), Stmts};
+group_ifs([{'if', Ann, Cond, Then} | Stmts], Acc) ->
+    {Elses, Rest} = else_branches(Stmts, []),
+    group_ifs(Rest, [build_if(Ann, Cond, Then, Elses) | Acc]);
+group_ifs([{'else', Ann, _} | _], _) ->
+    fail({Ann, "No matching 'if' for 'else'"});
+group_ifs([{elif, Ann, _, _} | _], _) ->
+    fail({Ann, "No matching 'if' for 'elif'"});
+group_ifs([Stmt | Stmts], Acc) ->
+    group_ifs(Stmts, [Stmt | Acc]).
+
+build_if(Ann, Cond, Then, [{elif, Ann1, Cond1, Then1} | Elses]) ->
+    {'if', Ann, Cond, Then,
+        set_ann(format, elif, build_if(Ann1, Cond1, Then1, Elses))};
+build_if(Ann, Cond, Then, [{'else', _Ann, Else}]) ->
+    {'if', Ann, Cond, Then, Else};
+build_if(Ann, Cond, Then, []) ->
+    {'if', Ann, Cond, Then, {tuple, [{origin, system}], []}}.
+
+else_branches([Elif = {elif, _, _, _} | Stmts], Acc) ->
+    else_branches(Stmts, [Elif | Acc]);
+else_branches([Else = {'else', _, _} | Stmts], Acc) ->
+    {lists:reverse([Else | Acc]), Stmts};
+else_branches(Stmts, Acc) ->
+    {lists:reverse(Acc), Stmts}.
+
+tuple_t(_Ann, [Type]) -> Type;  %% Not a tuple
+tuple_t(Ann, Types)   -> {tuple_t, Ann, Types}.
+
+fun_t(Domains, Type) ->
+    lists:foldr(fun({{args_t, _, Dom}, Ann}, T) -> {fun_t, Ann, [], Dom, T};
+                    ({Dom, Ann}, T)             -> {fun_t, Ann, [], [Dom], T} end,
+                Type, Domains).
+
+tuple_e(_Ann, [Expr]) -> Expr;  %% Not a tuple
+tuple_e(Ann, Exprs)   -> {tuple, Ann, Exprs}.
+
+list_comp_e(Ann, Expr, Binds) -> {list_comp, Ann, Expr, Binds}.
+
+-spec parse_pattern(so_syntax:expr()) -> so_parse_lib:parser(so_syntax:pat()).
+parse_pattern({letpat, Ann, Id, Pat}) ->
+    {letpat, Ann, Id, parse_pattern(Pat)};
+parse_pattern({app, Ann, Con = {'::', _}, Es}) ->
+    {app, Ann, Con, lists:map(fun parse_pattern/1, Es)};
+parse_pattern({app, Ann, {'-', _}, [{int, _, N}]}) ->
+    {int, Ann, -N};
+parse_pattern({app, Ann, Con = {Tag, _, _}, Es}) when Tag == con; Tag == qcon ->
+    {app, Ann, Con, lists:map(fun parse_pattern/1, Es)};
+parse_pattern({tuple, Ann, Es}) ->
+    {tuple, Ann, lists:map(fun parse_pattern/1, Es)};
+parse_pattern({list, Ann, Es}) ->
+    {list, Ann, lists:map(fun parse_pattern/1, Es)};
+parse_pattern({record, Ann, Fs}) ->
+    {record, Ann, lists:map(fun parse_field_pattern/1, Fs)};
+parse_pattern({typed, Ann, E, Type}) ->
+    {typed, Ann, parse_pattern(E), Type};
+parse_pattern(E = {con, _, _})    -> E;
+parse_pattern(E = {qcon, _, _})   -> E;
+parse_pattern(E = {id, _, _})     -> E;
+parse_pattern(E = {int, _, _})    -> E;
+parse_pattern(E = {bool, _, _})   -> E;
+parse_pattern(E = {bytes, _, _})  -> E;
+parse_pattern(E = {string, _, _}) -> E;
+parse_pattern(E = {char, _, _})   -> E;
+parse_pattern(E) -> bad_expr_err("Not a valid pattern", E).
+
+-spec parse_field_pattern(so_syntax:field(so_syntax:expr())) -> so_parse_lib:parser(so_syntax:field(so_syntax:pat())).
+parse_field_pattern({field, Ann, F, E}) ->
+    {field, Ann, F, parse_pattern(E)}.
+
+-spec ret_doc_err(ann(), prettypr:document()) -> so_parse_lib:parser(none()).
+ret_doc_err(Ann, Doc) ->
+    fail(ann_pos(Ann), prettypr:format(Doc)).
+
+-spec bad_expr_err(string(), so_syntax:expr()) -> so_parse_lib:parser(none()).
+bad_expr_err(Reason, E) ->
+  ret_doc_err(get_ann(E),
+              prettypr:sep([prettypr:text(Reason ++ ":"),
+                            prettypr:nest(2, so_pretty:expr(E))])).
+
+%% -- Helper functions -------------------------------------------------------
+
+expand_includes(AST, Included, Opts) ->
+    Ann  = [{origin, system}],
+    AST1 = [ {include, Ann, {string, Ann, File}}
+             || File <- lists:usort(auto_imports(AST)) ] ++ AST,
+    expand_includes(AST1, Included, [], Opts).
+
+expand_includes([], Included, Acc, Opts) ->
+    case lists:member(keep_included, Opts) of
+        false ->
+            {ok, lists:reverse(Acc)};
+        true ->
+            {ok, {lists:reverse(Acc), Included}}
+    end;
+expand_includes([{include, Ann, {string, _SAnn, File}} | AST], Included, Acc, Opts) ->
+    case get_include_code(File, Ann, Opts) of
+        {ok, AbsDir, Code} ->
+            Hashed = hash_include(File, Code),
+            case sets:is_element(Hashed, Included) of
+                false ->
+                    SrcFile = proplists:get_value(src_file, Opts, no_file),
+                    IncludeType = case proplists:get_value(file, Ann) of
+                                      SrcFile -> direct;
+                                      _       -> indirect
+                                  end,
+                    Opts1 = lists:keystore(src_file, 1, Opts, {src_file, File}),
+                    Opts2 = lists:keystore(src_dir, 1, Opts1, {src_dir, AbsDir}),
+                    Opts3 = lists:keystore(include_type, 1, Opts2, {include_type, IncludeType}),
+                    Included1 = sets:add_element(Hashed, Included),
+                    case parse_and_scan(file(), Code, Opts3) of
+                        {ok, AST1} ->
+                            expand_includes(AST1 ++ AST, Included1, Acc, Opts);
+                        Err = {error, _} ->
+                            Err
+                    end;
+                true ->
+                    expand_includes(AST, Included, Acc, Opts)
+            end;
+        Err = {error, _} ->
+            Err
+    end;
+expand_includes([E | AST], Included, Acc, Opts) ->
+    expand_includes(AST, Included, [E | Acc], Opts).
+
+read_file(File, Opts) ->
+    case proplists:get_value(include, Opts, {explicit_files, #{}}) of
+        {file_system, Paths} ->
+            lists:foldr(fun(Path, {error, _}) -> read_file_(Path, File);
+                           (_Path, OK)        -> OK end, {error, not_found}, Paths);
+        {explicit_files, Files} ->
+            case maps:get(binary_to_list(File), Files, not_found) of
+                not_found -> {error, not_found};
+                Src       -> {ok, File, Src}
+            end;
+        escript ->
+            try
+                Escript        = escript:script_name(),
+                {ok, Sections} = escript:extract(Escript, []),
+                Archive        = proplists:get_value(archive, Sections),
+                FileName       = binary_to_list(filename:join([sophia, priv, stdlib, File])),
+                case zip:extract(Archive, [{file_list, [FileName]}, memory]) of
+                    {ok, [{_, Src}]} -> {ok, escript, Src};
+                    _                -> {error, not_found}
+                end
+            catch _:_ ->
+                {error, not_found}
+            end
+    end.
+
+read_file_(Path, File) ->
+    AbsFile = filename:join(Path, File),
+    case file:read_file(AbsFile) of
+        {ok, Bin} -> {ok, so_utils:canonical_dir(filename:dirname(AbsFile)), Bin};
+        Err       -> Err
+    end.
+
+stdlib_options() ->
+    StdLibDir = so_stdlib:stdlib_include_path(),
+    case filelib:is_dir(StdLibDir) of
+        true  -> [{include, {file_system, [StdLibDir]}}];
+        false -> [{include, escript}]
+    end.
+
+get_include_code(File, Ann, Opts) ->
+    %% Temporarily extend include paths with the directory of the current file
+    Opts1 = include_current_file_dir(Opts, Ann),
+    case {read_file(File, Opts1), read_file(File, stdlib_options())} of
+        {{ok, Dir, Bin}, {ok, _}} ->
+            case filename:basename(File) == File of
+                true -> { error
+                        , fail( ann_pos(Ann)
+                              , "Illegal redefinition of standard library " ++ binary_to_list(File))};
+                %% If a path is provided then the stdlib takes lower priority
+                false -> {ok, Dir, binary_to_list(Bin)}
+            end;
+        {_, {ok, _, Bin}} ->
+            {ok, stdlib, binary_to_list(Bin)};
+        {{ok, Dir, Bin}, _} ->
+            {ok, Dir, binary_to_list(Bin)};
+        {_, _} ->
+            {error, {ann_pos(Ann), include_error, File}}
+    end.
+
+include_current_file_dir(Opts, Ann) ->
+    case {proplists:get_value(dir, Ann, undefined),
+          proplists:get_value(include, Opts, undefined)} of
+        {undefined, _} -> Opts;
+        {CurrDir, {file_system, Paths}} ->
+            case lists:member(CurrDir, Paths) of
+                false -> [{include, {file_system, [CurrDir | Paths]}} | Opts];
+                true  -> Opts
+            end;
+        {_, _} -> Opts
+    end.
+
+-spec hash_include(string() | binary(), string()) -> include_hash().
+hash_include(File, Code) when is_binary(File) ->
+    hash_include(binary_to_list(File), Code);
+hash_include(File, Code) when is_list(File) ->
+    {filename:basename(File), crypto:hash(sha256, Code)}.
+
+auto_imports({comprehension_bind, _, _}) -> [<<"ListInternal.aes">>];
+auto_imports({'..', _})                  -> [<<"ListInternal.aes">>];
+auto_imports(L) when is_list(L) ->
+    lists:flatmap(fun auto_imports/1, L);
+auto_imports(T) when is_tuple(T) ->
+    auto_imports(tuple_to_list(T));
+auto_imports(_) -> [].
+
+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/so_pretty.erl

@@ -1,11 +1,13 @@
 %%% -*- erlang-indent-level:4; indent-tabs-mode: nil -*-
 %%%-------------------------------------------------------------------
+%%% @copyright (C) 2025, QPQ AG
 %%% @copyright (C) 2017, Aeternity Anstalt
 %%% @doc Pretty printer for Sophia.
 %%%
 %%% @end
 %%%-------------------------------------------------------------------
--module(aeso_pretty).
+-module(so_pretty).
+-vsn("9.0.0").
 
 -import(prettypr, [text/1, sep/1, above/2, beside/2, nest/2, empty/0]).
 
@@ -13,6 +15,8 @@
 
 -export_type([options/0]).
 
+-include("so_utils.hrl").
+
 -type doc() :: prettypr:document().
 -type options() :: [{indent, non_neg_integer()} | show_generated].
 
@@ -22,11 +26,11 @@
 
 %% -- Options ----------------------------------------------------------------
 
--define(aeso_pretty_opts, aeso_pretty_opts).
+-define(so_pretty_opts, so_pretty_opts).
 
 -spec options() -> options().
 options() ->
-    case get(?aeso_pretty_opts) of
+    case get(?so_pretty_opts) of
         undefined -> [];
         Opts      -> Opts
     end.
@@ -43,9 +47,9 @@ indent() -> option(indent, 2).
 
 -spec with_options(options(), fun(() -> A)) -> A.
 with_options(Options, Fun) ->
-    put(?aeso_pretty_opts, Options),
+    put(?so_pretty_opts, Options),
     Res = Fun(),
-    erase(?aeso_pretty_opts),
+    erase(?so_pretty_opts),
     Res.
 
 %% -- Pretty printing helpers ------------------------------------------------
@@ -123,56 +127,87 @@ record(Ds) ->
 equals(A, B) -> follow(hsep(A, text("=")), B).
 
 %% typed(A, B) -> A : B.
--spec typed(doc(), aeso_syntax:type()) -> doc().
+-spec typed(doc(), so_syntax:type()) -> doc().
 typed(A, Type) ->
-    case aeso_syntax:get_ann(origin, Type) == system andalso
+    case so_syntax:get_ann(origin, Type) == system andalso
          not show_generated() of
         true  -> A;
         false -> follow(hsep(A, text(":")), type(Type))
     end.
 
+contract_head(contract_main)      -> text("main contract");
+contract_head(contract_child)     -> text("contract");
+contract_head(contract_interface) -> text("contract interface").
+
 %% -- Exports ----------------------------------------------------------------
 
--spec decls([aeso_syntax:decl()], options()) -> doc().
+-spec decls([so_syntax:decl()], options()) -> doc().
 decls(Ds, Options) ->
     with_options(Options, fun() -> decls(Ds) end).
 
--spec decls([aeso_syntax:decl()]) -> doc().
+-spec decls([so_syntax:decl()]) -> doc().
 decls(Ds) -> above([ decl(D) || D <- Ds ]).
 
--spec decl(aeso_syntax:decl(), options()) -> doc().
+-spec decl(so_syntax:decl(), options()) -> doc().
 decl(D, Options) ->
     with_options(Options, fun() -> decl(D) end).
 
--spec decl(aeso_syntax:decl()) -> doc().
-decl({contract, _, C, Ds}) ->
-    block(follow(text("contract"), hsep(name(C), text("="))), decls(Ds));
+-spec decl(so_syntax:decl()) -> doc().
+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)] ++ ImplsList ++ [text("=")])), decls(Ds));
 decl({namespace, _, C, Ds}) ->
     block(follow(text("namespace"), hsep(name(C), text("="))), decls(Ds));
+decl({pragma, _, Pragma}) -> pragma(Pragma);
 decl({type_decl, _, T, Vars}) -> typedecl(alias_t, T, Vars);
 decl({type_def, _, T, Vars, Def}) ->
     Kind = element(1, Def),
     equals(typedecl(Kind, T, Vars), typedef(Def));
-decl({fun_decl, _, F, T}) ->
-    hsep(text("function"), typed(name(F), T));
-decl(D = {letfun, Attrs, _, _, _, _}) ->
-    Mod = fun({Mod, true}) when Mod == private; Mod == internal; Mod == public; Mod == stateful ->
+decl({fun_decl, Ann, F, T}) ->
+    Mod = fun({Mod, true}) when Mod == private; Mod == stateful; Mod == payable ->
                   text(atom_to_list(Mod));
              (_) -> empty() end,
-    hsep(lists:map(Mod, Attrs) ++ [letdecl("function", D)]);
-decl(D = {letval, _, _, _, _})    -> letdecl("let", D);
-decl(D = {letrec, _, _})          -> letdecl("let", D).
+    Fun = case so_syntax:get_ann(entrypoint, Ann, false) of
+            true  -> text("entrypoint");
+            false -> text("function")
+          end,
+    hsep(lists:map(Mod, Ann) ++ [Fun, typed(name(F), T)]);
+decl(D = {letfun, Attrs, _, _, _, _}) ->
+    Mod = fun({Mod, true}) when Mod == private; Mod == stateful; Mod == payable ->
+                            text(atom_to_list(Mod));
+             (_) -> empty() end,
+    Fun = case so_syntax:get_ann(entrypoint, Attrs, false) of
+              true  -> "entrypoint";
+              false -> "function"
+          end,
+    hsep(lists:map(Mod, Attrs) ++ [letdecl(Fun, D)]);
+decl({fun_clauses, Ann, Name, Type, Clauses}) ->
+    above([ decl(D) || D <- [{fun_decl, Ann, Name, Type} | Clauses] ]);
+decl(D = {letval, _, _, _}) -> letdecl("let", D);
+decl({block, _, Ds}) ->
+    above([ decl(D) || D <- Ds ]).
 
--spec expr(aeso_syntax:expr(), options()) -> doc().
+-spec pragma(so_syntax:pragma()) -> doc().
+pragma({compiler, Op, Ver}) ->
+    text("@compiler " ++ atom_to_list(Op) ++ " " ++ string:join([integer_to_list(N) || N <- Ver], ".")).
+
+-spec expr(so_syntax:expr(), options()) -> doc().
 expr(E, Options) ->
     with_options(Options, fun() -> expr(E) end).
 
--spec expr(aeso_syntax:expr()) -> doc().
+-spec expr(so_syntax:expr()) -> doc().
 expr(E) -> expr_p(0, E).
 
 %% -- Not exported -----------------------------------------------------------
 
--spec name(aeso_syntax:id() | aeso_syntax:qid() | aeso_syntax:con() | aeso_syntax:qcon() | aeso_syntax:tvar()) -> doc().
+-spec name(so_syntax:id() | so_syntax:qid() | so_syntax:con() | so_syntax:qcon() | so_syntax:tvar()) -> doc().
 name({id, _,   Name})  -> text(Name);
 name({con, _,  Name})  -> text(Name);
 name({qid, _,  Names}) -> text(string:join(Names, "."));
@@ -180,22 +215,22 @@ name({qcon, _, Names}) -> text(string:join(Names, "."));
 name({tvar, _, Name})  -> text(Name);
 name({typed, _, Name, _}) -> name(Name).
 
--spec letdecl(string(), aeso_syntax:letbind()) -> doc().
-letdecl(Let, {letval, _, F, T, E}) ->
-    block_expr(0, hsep([text(Let), typed(name(F), T), text("=")]), E);
-letdecl(Let, {letfun, _, F, Args, T, E}) ->
-    block_expr(0, hsep([text(Let), typed(beside(name(F), args(Args)), T), text("=")]), E);
-letdecl(Let, {letrec, _, [D | Ds]}) ->
-    hsep(text(Let), above([ letdecl("rec", D) | [ letdecl("and", D1) || D1 <- Ds ] ])).
+-spec letdecl(string(), so_syntax:letbind()) -> doc().
+letdecl(Let, {letval, _, P, E}) ->
+    block_expr(0, hsep([text(Let), expr(P), text("=")]), E);
+letdecl(Let, {letfun, _, F, Args, T, [GuardedBody]}) ->
+    beside(hsep([text(Let), typed(beside(name(F), expr({tuple, [], Args})), T)]), guarded_body(GuardedBody, "="));
+letdecl(Let, {letfun, _, F, Args, T, GuardedBodies}) ->
+    block(hsep([text(Let), typed(beside(name(F), expr({tuple, [], Args})), T)]), above(lists:map(fun(GB) -> guarded_body(GB, "=") end, GuardedBodies))).
 
--spec args([aeso_syntax:arg()]) -> doc().
+-spec args([so_syntax:arg()]) -> doc().
 args(Args) ->
     tuple(lists:map(fun arg/1, Args)).
 
--spec arg(aeso_syntax:arg()) -> doc().
+-spec arg(so_syntax:arg()) -> doc().
 arg({arg, _, X, T}) -> typed(name(X), T).
 
--spec typedecl(alias_t | record_t | variant_t, aeso_syntax:id(), [aeso_syntax:tvar()]) -> doc().
+-spec typedecl(alias_t | record_t | variant_t, so_syntax:id(), [so_syntax:tvar()]) -> doc().
 typedecl(Kind, T, Vars) ->
     KW = case Kind of
             alias_t -> text("type");
@@ -208,34 +243,47 @@ typedecl(Kind, T, Vars) ->
                 tuple(lists:map(fun name/1, Vars)))
     end.
 
--spec typedef(aeso_syntax:typedef()) -> doc().
+-spec typedef(so_syntax:typedef()) -> doc().
 typedef({alias_t, Type})           -> type(Type);
 typedef({record_t, Fields})        ->
     record(lists:map(fun field_t/1, Fields));
 typedef({variant_t, Constructors}) ->
     par(punctuate(text(" |"), lists:map(fun constructor_t/1, Constructors))).
 
--spec constructor_t(aeso_syntax:constructor_t()) -> doc().
+-spec constructor_t(so_syntax:constructor_t()) -> doc().
 constructor_t({constr_t, _, C, []}) -> name(C);
-constructor_t({constr_t, _, C, Args}) -> beside(name(C), tuple_type(Args)).
+constructor_t({constr_t, _, C, Args}) -> beside(name(C), args_type(Args)).
 
--spec field_t(aeso_syntax:field_t()) -> doc().
+-spec field_t(so_syntax:field_t()) -> doc().
 field_t({field_t, _, Name, Type}) ->
     typed(name(Name), Type).
 
--spec type(aeso_syntax:type(), options()) -> doc().
+-spec type(so_syntax:type(), options()) -> doc().
 type(Type, Options) ->
     with_options(Options, fun() -> type(Type) end).
 
--spec type(aeso_syntax:type()) -> doc().
+-spec type(so_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}) ->
     follow(hsep(tuple_type(Named ++ Args), text("=>")), type(Ret));
 type({app_t, _, Type, []}) ->
     type(Type);
 type({app_t, _, Type, Args}) ->
-    beside(type(Type), tuple_type(Args));
+    beside(type(Type), args_type(Args));
 type({tuple_t, _, Args}) ->
     tuple_type(Args);
+type({args_t, _, Args}) ->
+    args_type(Args);
+type({bytes_t, _, any}) -> text("bytes()");
+type({bytes_t, _, '_'}) -> text("bytes(_)");
+type({bytes_t, _, fixed}) -> text("bytes(_)");
+type({bytes_t, _, Len}) ->
+    text(lists:concat(["bytes(", Len, ")"]));
+type({if_t, _, Id, Then, Else}) ->
+    beside(text("if"), args_type([Id, Then, Else]));
 type({named_arg_t, _, Name, Type, _Default}) ->
     %% Drop the default value
     %% follow(hsep(typed(name(Name), Type), text("=")), expr(Default));
@@ -246,22 +294,33 @@ 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);
 
--spec tuple_type([aeso_syntax:type()]) -> doc().
-tuple_type(Args) ->
+type(var_args) -> text("var_args").
+
+-spec args_type([so_syntax:type()]) -> doc().
+args_type(Args) ->
     tuple(lists:map(fun type/1, Args)).
 
--spec arg_expr(aeso_syntax:arg_expr()) -> doc().
-arg_expr({named_arg, _, Name, E}) ->
-    follow(hsep(expr(Name), text("=")), expr(E));
-arg_expr(E) -> expr(E).
+-spec tuple_type([so_syntax:type()]) -> doc().
+tuple_type([]) ->
+    text("unit");
+tuple_type(Factors) ->
+    beside(
+      [ text("(")
+      , par(punctuate(text(" *"), lists:map(fun type/1, Factors)), 0)
+      , text(")")
+      ]).
 
--spec expr_p(integer(), aeso_syntax:expr()) -> doc().
+-spec expr_p(integer(), so_syntax:arg_expr()) -> doc().
+expr_p(P, {letpat, _, Id, Pat}) ->
+    paren(P > 100, follow(hsep(expr(Id), text("=")), expr(Pat)));
+expr_p(P, {named_arg, _, Name, E}) ->
+    paren(P > 100, follow(hsep(expr(Name), text("=")), expr(E)));
 expr_p(P, {lam, _, Args, E}) ->
     paren(P > 100, follow(hsep(args(Args), text("=>")), expr_p(100, E)));
 expr_p(P, If = {'if', Ann, Cond, Then, Else}) ->
-    Format   = aeso_syntax:get_ann(format, If),
+    Format   = so_syntax:get_ann(format, If),
     if  Format == '?:' ->
             paren(P > 100,
                 follow(expr_p(200, Cond),
@@ -278,6 +337,8 @@ expr_p(_, {tuple, _, Es}) ->
     tuple(lists:map(fun expr/1, Es));
 expr_p(_, {list, _, Es}) ->
     list(lists:map(fun expr/1, Es));
+expr_p(_, {list_comp, _, E, Binds}) ->
+    list([follow(expr(E), hsep(text("|"), par(punctuate(text(","), lists:map(fun lc_bind/1, Binds)), 0)), 0)]);
 expr_p(_, {record, _, Fs}) ->
     record(lists:map(fun field/1, Fs));
 expr_p(_, {map, Ann, KVs}) ->
@@ -302,7 +363,7 @@ expr_p(P, {assign, _, LV, E}) ->
 expr_p(_, {app, _, {'..', _}, [A, B]}) ->
     list([infix(0, '..', A, B)]);
 expr_p(P, E = {app, _, F = {Op, _}, Args}) when is_atom(Op) ->
-    case {aeso_syntax:get_ann(format, E), Args} of
+    case {so_syntax:get_ann(format, E), Args} of
         {infix, [A, B]} -> infix(P, Op, A, B);
         {prefix, [A]}   -> prefix(P, Op, A);
         _               -> app(P, F, Args)
@@ -313,22 +374,38 @@ expr_p(P, {app, _, F, Args}) ->
     app(P, F, Args);
 %% -- Constants
 expr_p(_, E = {int, _, N}) ->
-    S = case aeso_syntax:get_ann(format, E) of
+    S = case so_syntax:get_ann(format, E) of
             hex -> "0x" ++ integer_to_list(N, 16);
             _   -> integer_to_list(N)
            end,
     text(S);
 expr_p(_, {bool, _, B}) -> text(atom_to_list(B));
-expr_p(_, {hash, _, <<N:256>>}) -> text("#" ++ integer_to_list(N, 16));
+expr_p(_, {bytes, _, Bin}) ->
+    Digits = byte_size(Bin),
+    <<N:Digits/unit:8>> = Bin,
+    text(lists:flatten(io_lib:format("#~*.16.0b", [Digits*2, N])));
 expr_p(_, {hash, _, <<N:512>>}) -> text("#" ++ integer_to_list(N, 16));
-expr_p(_, {unit, _}) -> text("()");
-expr_p(_, {string, _, S}) -> term(binary_to_list(S));
+expr_p(_, {Type, _, Bin})
+    when Type == account_pubkey;
+         Type == contract_pubkey;
+         Type == oracle_pubkey;
+         Type == oracle_query_id;
+         Type == signature ->
+    text(binary_to_list(gmser_api_encoder:encode(Type, Bin)));
+expr_p(_, {string, _, <<>>}) -> text("\"\"");
+expr_p(_, {string, _, S}) ->
+    text(io_lib:format("\"~s\"", [binary_to_list(S)]));
 expr_p(_, {char, _, C}) ->
     case C of
         $' -> text("'\\''");
         $" -> text("'\"'");
-        _  -> S = lists:flatten(io_lib:format("~p", [[C]])),
-              text("'" ++ tl(lists:droplast(S)) ++ "'")
+        _ when C < 16#80 ->
+            S = lists:flatten(io_lib:format("~p", [[C]])),
+            text("'" ++ tl(lists:droplast(S)) ++ "'");
+        _  ->
+            S = lists:flatten(
+                  io_lib:format("'~ts'", [list_to_binary(so_scan:utf8_encode([C]))])),
+            text(S)
     end;
 %% -- Names
 expr_p(_, E = {id, _, _})   -> name(E);
@@ -344,26 +421,40 @@ stmt_p({'if', _, Cond, Then}) ->
     block_expr(200, beside(text("if"), paren(expr(Cond))), Then);
 stmt_p({elif, _, Cond, Then}) ->
     block_expr(200, beside(text("elif"), paren(expr(Cond))), Then);
-stmt_p({else, Else}) ->
+stmt_p({'else', Else}) ->
     HideGenerated = not show_generated(),
-    case aeso_syntax:get_ann(origin, Else) of
+    case so_syntax:get_ann(origin, Else) of
         system when HideGenerated -> empty();
         _ -> block_expr(200, text("else"), Else)
     end.
 
--spec bin_prec(aeso_syntax:bin_op()) -> {integer(), integer(), integer()}.
+lc_bind({comprehension_bind, P, E}) ->
+    follow(hsep(expr(P), text("<-")), expr(E));
+lc_bind({comprehension_if, _, E}) ->
+    beside([text("if("), expr(E), text(")")]);
+lc_bind(Let) ->
+    letdecl("let", Let).
+
+-spec bin_prec(so_syntax:bin_op()) -> {integer(), integer(), integer()}.
 bin_prec('..')   -> {  0,   0,   0};  %% Always printed inside '[ ]'
 bin_prec('=')    -> {  0,   0,   0};  %% Always printed inside '[ ]'
+bin_prec('@')    -> {  0,   0,   0};  %% Only in error messages
+bin_prec('|>')   -> {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};
@@ -371,14 +462,15 @@ bin_prec('/')    -> {700, 700, 750};
 bin_prec(mod)    -> {700, 700, 750};
 bin_prec('^')    -> {750, 750, 800}.
 
--spec un_prec(aeso_syntax:un_op()) -> {integer(), integer()}.
+-spec un_prec(so_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]}.
 
--spec infix(integer(), aeso_syntax:bin_op(), aeso_syntax:expr(), aeso_syntax:expr()) -> doc().
+-spec infix(integer(), so_syntax:bin_op(), so_syntax:expr(), so_syntax:expr()) -> doc().
 infix(P, Op, A, B) ->
     {Top, L, R} = bin_prec(Op),
     paren(P > Top,
@@ -392,7 +484,7 @@ prefix(P, Op, A) ->
 app(P, F, Args) ->
     paren(P > 900,
     beside(expr_p(900, F),
-           tuple(lists:map(fun arg_expr/1, Args)))).
+           tuple(lists:map(fun expr/1, Args)))).
 
 field({field, _, LV, E}) ->
     follow(hsep(lvalue(LV), text("=")), expr(E));
@@ -412,8 +504,18 @@ elim1(Proj={proj, _, _})      -> beside(text("."), elim(Proj));
 elim1(Get={map_get, _, _})    -> elim(Get);
 elim1(Get={map_get, _, _, _}) -> elim(Get).
 
-alt({'case', _, Pat, Body}) ->
-    block_expr(0, hsep(expr_p(500, Pat), text("=>")), Body).
+alt({'case', _, Pat, [GuardedBody]}) ->
+    beside(expr(Pat), guarded_body(GuardedBody, "=>"));
+alt({'case', _, Pat, GuardedBodies}) ->
+    block(expr(Pat), above(lists:map(fun(GB) -> guarded_body(GB, "=>") end, GuardedBodies))).
+
+guarded_body({guarded, _, Guards, Body}, Then) ->
+    block_expr(0, hsep(guards(Guards), text(Then)), Body).
+
+guards([]) ->
+    text("");
+guards(Guards) ->
+    hsep([text(" |"), par(punctuate(text(","), lists:map(fun expr/1, Guards)), 0)]).
 
 block_expr(_, Header, {block, _, Ss}) ->
     block(Header, statements(Ss));
@@ -423,20 +525,16 @@ block_expr(P, Header, E) ->
 statements(Stmts) ->
     above([ statement(S) || S <- Stmts ]).
 
-statement(S = {letval, _, _, _, _})    -> letdecl("let", S);
+statement(S = {letval, _, _, _})       -> letdecl("let", S);
 statement(S = {letfun, _, _, _, _, _}) -> letdecl("let", S);
-statement(S = {letrec, _, _})          -> letdecl("let", S);
 statement(E) -> expr(E).
 
 get_elifs(Expr) -> get_elifs(Expr, []).
 
 get_elifs(If = {'if', Ann, Cond, Then, Else}, Elifs) ->
-    case aeso_syntax:get_ann(format, If) of
+    case so_syntax:get_ann(format, If) of
         elif -> get_elifs(Else, [{elif, Ann, Cond, Then} | Elifs]);
         _    -> {lists:reverse(Elifs), If}
     end;
-get_elifs(Else, Elifs) -> {lists:reverse(Elifs), {else, Else}}.
-
-fmt(Fmt, Args) -> text(lists:flatten(io_lib:format(Fmt, Args))).
-term(X) -> fmt("~p", [X]).
+get_elifs(Else, Elifs) -> {lists:reverse(Elifs), {'else', Else}}.
 

src/so_scan.erl

@@ -0,0 +1,145 @@
+%%% -*- erlang-indent-level:4; indent-tabs-mode: nil -*-
+%%%-------------------------------------------------------------------
+%%% @copyright (C) 2025, QPQ AG
+%%% @copyright (C) 2017, Aeternity Anstalt
+%%% @doc The Sophia lexer.
+%%%
+%%% @end
+%%%-------------------------------------------------------------------
+-module(so_scan).
+-vsn("9.0.0").
+
+-export([scan/1, utf8_encode/1]).
+
+-import(so_scan_lib, [token/1, token/2, symbol/0, skip/0,
+                        override/2, push/2, pop/1]).
+
+lexer() ->
+    Number   = fun(Digit) -> [Digit, "+(_", Digit, "+)*"] end,
+    DIGIT    = "[0-9]",
+    HEXDIGIT = "[0-9a-fA-F]",
+    LOWER    = "[a-z_]",
+    UPPER    = "[A-Z]",
+    CON      = [UPPER, "[a-zA-Z0-9_]*"],
+    INT      = Number(DIGIT),
+    HEX      = ["0x", Number(HEXDIGIT)],
+    BYTES    = ["#", Number(HEXDIGIT)],
+    WS       = "[\\000-\\ ]+",
+    ID       = [LOWER, "[a-zA-Z0-9_']*"],
+    TVAR     = ["'", ID],
+    QID      = ["(", CON, "\\.)+", ID],
+    QCON     = ["(", CON, "\\.)+", CON],
+    OP       = "[=!<>+\\-*/:&|?~@^]+",
+    %% Five cases for a character
+    %%  * 1 7-bit ascii, not \ or '
+    %%  * 2-4 8-bit values (UTF8)
+    %%  * \ followed by a known modifier [aernrtv]
+    %%  * \xhh
+    %%  * \x{hhh...}
+    CHAR     = "'(([\\x00-\\x26\\x28-\\x5b\\x5d-\\x7f])|([\\x00-\\xff][\\x80-\\xff]{1,3})|(\\\\[befnrtv'\\\\])|(\\\\x[0-9a-fA-F]{2,2})|(\\\\x\\{[0-9a-fA-F]*\\}))'",
+    STRING   = "\"([^\"\\\\]|(\\\\.))*\"",
+
+    CommentStart = {"/\\*", push(comment, skip())},
+    CommentRules =
+        [ CommentStart
+        , {"\\*/",        pop(skip())}
+        , {"[^/*]+|[/*]", skip()} ],
+
+    Keywords = ["contract", "include", "let", "switch", "type", "record", "datatype", "if", "elif", "else", "function",
+                "stateful", "payable", "true", "false", "mod", "public", "entrypoint", "private", "indexed", "namespace",
+                "interface", "main", "using", "as", "for", "hiding", "band", "bor", "bxor", "bnot"
+               ],
+    KW = string:join(Keywords, "|"),
+
+    Rules =
+          %% Comments and whitespace
+        [ CommentStart
+        , {"//.*", skip()}
+        , {WS,     skip()}
+
+          %% Special characters
+        , {"\\.\\.|[,.;()\\[\\]{}]", symbol()}
+
+          %% Literals
+        , {CHAR,   token(char,   fun parse_char/1)}
+        , {STRING, token(string, fun parse_string/1)}
+        , {HEX,    token(hex,    fun parse_hex/1)}
+        , {INT,    token(int,    fun parse_int/1)}
+        , {BYTES,  token(bytes,  fun parse_bytes/1)}
+
+          %% Identifiers (qualified first!)
+        , {QID,   token(qid,  fun(S) -> string:tokens(S, ".") end)}
+        , {QCON,  token(qcon, fun(S) -> string:tokens(S, ".") end)}
+        , {TVAR,  token(tvar)}
+        , override({ID, token(id)}, {KW, symbol()})    %% Keywords override identifiers. Need to
+        , {CON, token(con)}                            %% use override to avoid lexing "lettuce"
+                                                       %% as ['let', {id, "tuce"}].
+          %% Operators
+        , {OP, symbol()}
+        ],
+
+    [{code, Rules}, {comment, CommentRules}].
+
+scan(String) ->
+    Lexer = so_scan_lib:compile(lexer()),
+    so_scan_lib:string(Lexer, code, String).
+
+%% -- Helpers ----------------------------------------------------------------
+
+parse_string([$" | Chars]) ->
+    unicode:characters_to_nfc_binary(unescape(Chars)).
+
+parse_char([$' | Chars]) ->
+    case unicode:characters_to_nfc_list(unescape($', Chars, [])) of
+        [Char] -> Char;
+        _Bad   -> {error, "Bad character literal: '" ++ Chars}
+    end.
+
+utf8_encode(Cs) ->
+    binary_to_list(unicode:characters_to_binary(Cs)).
+
+unescape(Str) -> unescape($", Str, []).
+
+unescape(Delim, [Delim], Acc) ->
+    list_to_binary(lists:reverse(Acc));
+unescape(Delim, [$\\, $x, ${ | Chars ], Acc) ->
+    {Ds, [_ | Cs]} = lists:splitwith(fun($}) -> false ; (_) -> true end, Chars),
+    C = list_to_integer(Ds, 16),
+    Utf8Cs = binary_to_list(unicode:characters_to_binary([C])),
+    unescape(Delim, Cs, [Utf8Cs | Acc]);
+unescape(Delim, [$\\, $x, D1, D2 | Chars ], Acc) ->
+    C = list_to_integer([D1, D2], 16),
+    Utf8Cs = binary_to_list(unicode:characters_to_binary([C])),
+    unescape(Delim, Chars, [Utf8Cs | Acc]);
+unescape(Delim, [$\\, Code | Chars], Acc) ->
+    Ok = fun(C) -> unescape(Delim, Chars, [C | Acc]) end,
+    case Code of
+        Delim -> Ok(Delim);
+        $\\ -> Ok($\\);
+        $b  -> Ok($\b);
+        $e  -> Ok($\e);
+        $f  -> Ok($\f);
+        $n  -> Ok($\n);
+        $r  -> Ok($\r);
+        $t  -> Ok($\t);
+        $v  -> Ok($\v);
+        _   -> error("Bad control sequence: \\" ++ [Code])  %% TODO
+    end;
+unescape(Delim, [C | Chars], Acc) ->
+    unescape(Delim, Chars, [C | Acc]).
+
+strip_underscores(S) ->
+    lists:filter(fun(C) -> C /= $_ end, S).
+
+parse_hex("0x" ++ S) ->
+    list_to_integer(strip_underscores(S), 16).
+
+parse_int(S) ->
+    list_to_integer(strip_underscores(S)).
+
+parse_bytes("#" ++ S0) ->
+    S      = strip_underscores(S0),
+    N      = list_to_integer(S, 16),
+    Digits = (length(S) + 1) div 2,
+    <<N:Digits/unit:8>>.
+

src/so_scan_lib.erl

@@ -1,10 +1,12 @@
 %%% -*- erlang-indent-level:4; indent-tabs-mode: nil -*-
 %%%-------------------------------------------------------------------
+%%% @copyright (C) 2025, QPQ AG
 %%% @copyright (C) 2017, Aeternity Anstalt
 %%% @doc A customisable lexer.
 %%% @end
 %%%-------------------------------------------------------------------
--module(aeso_scan_lib).
+-module(so_scan_lib).
+-vsn("9.0.0").
 
 -export([compile/1, string/3,
          token/1, token/2, symbol/0, skip/0,

src/so_stdlib.erl

@@ -0,0 +1,18 @@
+%%%-------------------------------------------------------------------
+%%% @author Radosław Rowicki
+%%% @copyright (C) 2025, QPQ AG
+%%% @copyright (C) 2019, Aeternity Anstalt
+%%% @doc
+%%%     Standard library for Sophia
+%%% @end
+%%%-------------------------------------------------------------------
+
+-module(so_stdlib).
+-vsn("9.0.0").
+
+-export([stdlib_include_path/0]).
+
+stdlib_include_path() ->
+    {file, BEAM} = code:is_loaded(?MODULE),
+    filename:join(filename:dirname(filename:dirname(BEAM)), "priv/stdlib").
+

src/so_syntax.erl

@@ -1,19 +1,21 @@
 %%% -*- erlang-indent-level:4; indent-tabs-mode: nil -*-
 %%%-------------------------------------------------------------------
+%%% @copyright (C) 2025, QPQ AG
 %%% @copyright (C) 2017, Aeternity Anstalt
 %%% @doc Sophia abstract syntax types.
 %%%
 %%% @end
 %%%-------------------------------------------------------------------
 
--module(aeso_syntax).
+-module(so_syntax).
+-vsn("9.0.0").
 
 -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]).
+-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,8 +26,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()}].
+-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()}.
@@ -34,17 +38,39 @@
 -type qcon() :: {qcon, ann(), [name()]}.
 -type tvar() :: {tvar, ann(), name()}.
 
--type decl() :: {contract, ann(), con(), [decl()]}
+-type namespace_alias() :: none | con().
+-type namespace_parts() :: none | {for, [id()]} | {hiding, [id()]}.
+
+-type decl() :: {contract_main, ann(), con(), [con()], [decl()]}
+              | {contract_child, ann(), con(), [con()], [decl()]}
+              | {contract_interface, ann(), con(), [con()], [decl()]}
               | {namespace, ann(), con(), [decl()]}
-              | {type_decl, ann(), id(), [tvar()]}
+              | {include, ann(), {string, ann(), string()}}
+              | {pragma, ann(), pragma()}
+              | {type_decl, ann(), id(), [tvar()]} % Only for error msgs
               | {type_def, ann(), id(), [tvar()], typedef()}
-              | {fun_decl, ann(), id(), type()}
-              | letbind().
+              | {fun_clauses, ann(), id(), type(), [letfun() | fundecl()]}
+              | {block, ann(), [decl()]}
+              | {using, ann(), con(), namespace_alias(), namespace_parts()}
+              | fundecl()
+              | letfun()
+              | letval(). % Only for error msgs
+
+-type compiler_version() :: [non_neg_integer()].
+
+-type pragma() :: {compiler, '==' | '<' | '>' | '=<' | '>=', compiler_version()}.
+
+-type guard() :: expr().
+-type guarded_expr() :: {guarded, ann(), [guard()], expr()}.
+
+-type letval()  :: {letval, ann(), pat(), expr()}.
+-type letfun()  :: {letfun, ann(), id(), [pat()], type(), [guarded_expr(),...]}.
+-type letpat()  :: {letpat, ann(), id(), pat()}.
+-type fundecl() :: {fun_decl, ann(), id(), type()}.
 
 -type letbind()
-    :: {letval, ann(), id(), type(), expr()}
-     | {letfun, ann(), id(), [arg()], type(), expr()}
-     | {letrec, ann(), [letbind()]}.
+    :: letfun()
+     | letval().
 
 -type arg() :: {arg, ann(), id(), type()}.
 
@@ -60,6 +86,8 @@
 -type type() :: {fun_t, ann(), [named_arg_t()], [type()], type()}
               | {app_t, ann(), type(), [type()]}
               | {tuple_t, ann(), [type()]}
+              | {args_t, ann(), [type()]}   %% old tuple syntax, old for error messages
+              | {bytes_t, ann(), integer() | any}
               | id()  | qid()
               | con() | qcon()  %% contracts
               | tvar().
@@ -69,8 +97,12 @@
 -type constant()
     :: {int, ann(), integer()}
      | {bool, ann(), true | false}
-     | {hash, ann(), binary()}
-     | {unit, ann()}
+     | {bytes, ann(), binary()}
+     | {account_pubkey, ann(), binary()}
+     | {contract_pubkey, ann(), binary()}
+     | {oracle_pubkey, ann(), binary()}
+     | {oracle_query_id, ann(), binary()}
+     | {signature, ann(), binary()}
      | {string, ann(), binary()}
      | {char, ann(), integer()}.
 
@@ -78,8 +110,8 @@
 
 -type bin_op() :: '+' | '-' | '*' | '/' | mod | '^'
                 | '++' | '::' | '<' | '>' | '=<' | '>=' | '==' | '!='
-                | '||' | '&&' | '..'.
--type un_op() :: '-' | '!'.
+                | '||' | '&&' | '..' | 'band' | 'bor' | 'bxor' | '>>' | '<<' | '|>'.
+-type un_op() :: '-' | '!' | 'bnot'.
 
 -type expr()
     :: {lam, ann(), [arg()], expr()}
@@ -89,17 +121,24 @@
      | {proj, ann(), expr(), id()}
      | {tuple, ann(), [expr()]}
      | {list, ann(), [expr()]}
+     | {list_comp, ann(), expr(), [comprehension_exp()]}
      | {typed, ann(), expr(), type()}
-     | {record, ann(), [field(expr())]}
-     | {record, ann(), expr(), [field(expr())]} %% record update
-     | {map, ann(), expr(), [field(expr())]}    %% map update
+     | {record_or_map(), ann(), [field(expr())]}
+     | {record_or_map(), ann(), expr(), [field(expr())]} %% record/map update
      | {map, ann(), [{expr(), expr()}]}
      | {map_get, ann(), expr(), expr()}
      | {map_get, ann(), expr(), expr(), expr()}
      | {block, ann(), [stmt()]}
      | {op(), ann()}
      | id() | qid() | con() | qcon()
-     | constant().
+     | constant()
+     | letpat().
+
+-type record_or_map() :: record | map | record_or_map_error.
+
+-type comprehension_exp() :: [ {comprehension_bind, pat(), expr()}
+                             | {comprehension_if, ann(), expr()}
+                             | letbind() ].
 
 -type arg_expr() :: expr() | {named_arg, ann(), id(), expr()}.
 
@@ -114,7 +153,7 @@
 -type stmt() :: letbind()
               | expr().
 
--type alt() :: {'case', ann(), pat(), expr()}.
+-type alt() :: {'case', ann(), pat(), [guarded_expr(),...]}.
 
 -type lvalue() :: nonempty_list(elim()).
 
@@ -125,7 +164,9 @@
 -type pat() :: {app, ann(), con() | op(), [pat()]}
              | {tuple, ann(), [pat()]}
              | {list, ann(), [pat()]}
+             | {typed, ann(), pat(), type()}
              | {record, ann(), [field(pat())]}
+             | letpat()
              | constant()
              | con()
              | id().
@@ -145,4 +186,3 @@ get_ann(Key, Node, Default) ->
 qualify({con, Ann, N}, X)             -> qualify({qcon, Ann, [N]}, X);
 qualify({qcon, _, NS}, {con, Ann, C}) -> {qcon, Ann, NS ++ [C]};
 qualify({qcon, _, NS}, {id, Ann, X})  -> {qid, Ann, NS ++ [X]}.
-

src/so_syntax_utils.erl

@@ -1,12 +1,14 @@
 %%%-------------------------------------------------------------------
+%%% @copyright (C) 2025, QPQ AG
 %%% @copyright (C) 2018, Aeternity Anstalt
 %%% @doc
 %%%     Sophia syntax utilities.
 %%% @end
 %%%-------------------------------------------------------------------
--module(aeso_syntax_utils).
+-module(so_syntax_utils).
+-vsn("9.0.0").
 
--export([used_ids/1, used_types/1, used/1]).
+-export([used_ids/1, used_ids/2, used_types/2, used/1]).
 
 -record(alg, {zero, plus, scoped}).
 
@@ -17,45 +19,41 @@
 -type kind() :: decl | type | bind_type | expr | bind_expr.
 
 -spec fold(alg(A), fun((kind(), _) -> A), kind(), E | [E]) -> A
-    when E :: aeso_syntax:decl()
-            | aeso_syntax:typedef()
-            | aeso_syntax:field_t()
-            | aeso_syntax:constructor_t()
-            | aeso_syntax:type()
-            | aeso_syntax:expr()
-            | aeso_syntax:pat()
-            | aeso_syntax:arg()
-            | aeso_syntax:alt()
-            | aeso_syntax:elim()
-            | aeso_syntax:arg_expr()
-            | aeso_syntax:field(aeso_syntax:expr())
-            | aeso_syntax:stmt().
+    when E :: so_syntax:decl()
+            | so_syntax:typedef()
+            | so_syntax:field_t()
+            | so_syntax:constructor_t()
+            | so_syntax:type()
+            | so_syntax:expr()
+            | so_syntax:pat()
+            | so_syntax:arg()
+            | so_syntax:alt()
+            | so_syntax:elim()
+            | so_syntax:arg_expr()
+            | so_syntax:field(so_syntax:expr())
+            | so_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),
-    Bound = fun LB ({letval, _, Y, _, _})    -> BindExpr(Y);
-                LB ({letfun, _, F, _, _, _}) -> BindExpr(F);
-                LB ({letrec, _, Ds})         -> Sum(lists:map(LB, Ds));
-                LB (_)                       -> Zero
-            end,
     Rec = case X of
             %% lists (bound things in head scope over tail)
             [A | As]                      -> Scoped(Same(A), Same(As));
             %% decl()
             {contract, _, _, Ds}          -> Decl(Ds);
             {namespace, _, _, Ds}         -> Decl(Ds);
-            {type_decl, _, I, _}     -> BindType(I);
             {type_def, _, I, _, D}        -> Plus(BindType(I), Decl(D));
             {fun_decl, _, _, T}           -> Type(T);
-            {letval, _, F, T, E}     -> Sum([BindExpr(F), Type(T), Expr(E)]);
-            {letfun, _, F, Xs, T, E} -> Sum([BindExpr(F), Type(T), Scoped(BindExpr(Xs), Expr(E))]);
-            {letrec, _, Ds}          -> Plus(Bound(Ds), Decl(Ds));
+            {letval, _, P, E}             -> Scoped(BindExpr(P), Expr(E));
+            {letfun, _, F, Xs, T, GEs} -> Sum([BindExpr(F), Type(T), Expr(Xs ++ GEs)]);
+            {fun_clauses, _, _, T, Cs}    -> Sum([Type(T) | [Decl(C) || C <- Cs]]);
             %% typedef()
             {alias_t, T}    -> Type(T);
             {record_t, Fs}  -> Type(Fs);
@@ -77,6 +75,15 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
             {proj, _, E, _}        -> Expr(E);
             {tuple, _, As}         -> Expr(As);
             {list, _, As}          -> Expr(As);
+            {list_comp, _, Y, []}  -> Expr(Y);
+            {list_comp, A, Y, [{comprehension_bind, I, E}|R]} ->
+                Plus(Expr(E), Scoped(BindExpr(I), Expr({list_comp, A, Y, R})));
+            {list_comp, A, Y, [{comprehension_if, _, E}|R]} ->
+                Plus(Expr(E), Expr({list_comp, A, Y, R}));
+            {list_comp, A, Y, [D = {letval, _, Pat, _} | R]} ->
+                Plus(Decl(D), Scoped(BindExpr(Pat), Expr({list_comp, A, Y, R})));
+            {list_comp, A, Y, [D = {letfun, _, F, _, _, _} | R]} ->
+                Plus(Decl(D), Scoped(BindExpr(F), Expr({list_comp, A, Y, R})));
             {typed, _, E, T}       -> Plus(Expr(E), Type(T));
             {record, _, Fs}        -> Expr(Fs);
             {record, _, E, Fs}     -> Expr([E | Fs]);
@@ -85,13 +92,15 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
             {map_get, _, A, B}     -> Expr([A, B]);
             {map_get, _, A, B, C}  -> Expr([A, B, C]);
             {block, _, Ss}         -> Expr(Ss);
+            {letpat, _, X, P}      -> Plus(BindExpr(X), Expr(P));
+            {guarded, _, Gs, E}    -> Expr([E | Gs]);
             %% field()
             {field, _, LV, E}    -> Expr([LV, E]);
             {field, _, LV, _, E} -> Expr([LV, E]);
             %% arg()
-            {arg, _, X, T} -> Plus(Expr(X), Type(T));
+            {arg, _, Y, T} -> Plus(BindExpr(Y), Type(T));
             %% alt()
-            {'case', _, P, E} -> Scoped(BindExpr(P), Expr(E));
+            {'case', _, P, GEs} -> Scoped(BindExpr(P), Expr(GEs));
             %% elim()
             {proj, _, _}    -> Zero;
             {map_get, _, E} -> Expr(E);
@@ -103,30 +112,44 @@ fold(Alg = #alg{zero = Zero, plus = Plus, scoped = Scoped}, Fun, K, X) ->
 
 %% Name dependencies
 
+%% Used ids, top level
 used_ids(E) ->
-    [ X || {term, [X]} <- used(E) ].
+    used_ids([], E).
 
-used_types(T) ->
-    [ X || {type, [X]} <- used(T) ].
+%% Used ids, top level or in (current) namespace
+used_ids(Ns, E) ->
+    [ lists:last(Xs) || {{term, Xs}, _} <- used(E), in_ns(Xs, Ns) ].
+
+in_ns([_], _) -> true;
+in_ns(Xs, Ns) -> lists:droplast(Xs) == Ns.
+
+used_types([Top] = _CurrentNS, T) ->
+    F = fun({{type, [X]}, _}) -> [X];
+           ({{type, [Top1, X]}, _}) when Top1 == Top -> [X];
+           (_) -> []
+        end,
+    lists:flatmap(F, used(T)).
 
 -type entity() :: {term, [string()]}
                 | {type, [string()]}
                 | {namespace, [string()]}.
 
--spec entity_alg() -> alg([entity()]).
+-spec entity_alg() -> alg(#{entity() => so_syntax:ann()}).
 entity_alg() ->
     IsBound = fun({K, _}) -> lists:member(K, [bound_term, bound_type]) end,
     Unbind  = fun(bound_term) -> term; (bound_type) -> type end,
+    Remove  = fun(Keys, Map) -> maps:without(Keys, Map) end,
     Scoped = fun(Xs, Ys) ->
-                {Bound, Others} = lists:partition(IsBound, Ys),
+                Bound  = [E || E <- maps:keys(Xs), IsBound(E)],
                 Bound1 = [ {Unbind(Tag), X} || {Tag, X} <- Bound ],
-                lists:umerge(Xs -- Bound1, Others)
+                Others = Remove(Bound1, Ys),
+                maps:merge(Remove(Bound, Xs), Others)
             end,
-    #alg{ zero   = []
-        , plus   = fun lists:umerge/2
+    #alg{ zero   = #{}
+        , plus   = fun maps:merge/2
         , scoped = Scoped }.
 
--spec used(_) -> [entity()].
+-spec used(_) -> [{entity(), so_syntax:ann()}].
 used(D) ->
     Kind = fun(expr)      -> term;
               (bind_expr) -> bound_term;
@@ -134,14 +157,13 @@ used(D) ->
               (bind_type) -> bound_type
            end,
     NS = fun(Xs) -> {namespace, lists:droplast(Xs)} end,
-    NotBound = fun({Tag, _}) -> not lists:member(Tag, [bound_term, bound_type]) end,
+    NotBound = fun({{Tag, _}, _}) -> not lists:member(Tag, [bound_term, bound_type]) end,
     Xs =
-        fold(entity_alg(),
-            fun(K, {id,   _, X})  -> [{Kind(K), [X]}];
-               (K, {qid,  _, Xs}) -> [{Kind(K), Xs}, NS(Xs)];
-               (K, {con,  _, X})  -> [{Kind(K), [X]}];
-               (K, {qcon, _, Xs}) -> [{Kind(K), Xs}, NS(Xs)];
-               (_, _)             -> []
-            end, decl, D),
+        maps:to_list(fold(entity_alg(),
+            fun(K, {id,   Ann, X})  -> #{{Kind(K), [X]} => Ann};
+               (K, {qid,  Ann, Xs}) -> #{{Kind(K), Xs}  => Ann, NS(Xs) => Ann};
+               (K, {con,  Ann, X})  -> #{{Kind(K), [X]} => Ann};
+               (K, {qcon, Ann, Xs}) -> #{{Kind(K), Xs}  => Ann, NS(Xs) => Ann};
+               (_, _)             -> #{}
+            end, decl, D)),
     lists:filter(NotBound, Xs).
-

src/so_utils.erl

@@ -1,15 +1,29 @@
 %%%-------------------------------------------------------------------
+%%% @copyright (C) 2025, QPQ AG
 %%% @copyright (C) 2018, Aeternity Anstalt
 %%% @doc
 %%%     Sophia utility functions.
 %%% @end
 %%%-------------------------------------------------------------------
--module(aeso_utils).
+-module(so_utils).
+-vsn("9.0.0").
 
--export([scc/1]).
+-export([scc/1, canonical_dir/1]).
 
 -export_type([graph/1]).
 
+%% -- Simplistic canonical directory
+%% Note: no attempts to be 100% complete
+
+canonical_dir(Dir) ->
+    {ok, Cwd} = file:get_cwd(),
+    AbsName = filename:absname(Dir),
+    RelAbsName = filename:join(tl(filename:split(AbsName))),
+    case filelib:safe_relative_path(RelAbsName, Cwd) of
+        unsafe -> AbsName;
+        Simplified -> filename:absname(Simplified, "")
+    end.
+
 %% -- Topological sort
 
 -type graph(Node) :: #{Node => [Node]}. %% List of incoming edges (dependencies).

src/so_vm_decode.erl

@@ -0,0 +1,194 @@
+%%%-------------------------------------------------------------------
+%%% @copyright (C) 2025, QPQ AG
+%%% @copyright (C) 2017, Aeternity Anstalt
+%%% @doc Decoding fate data to AST
+%%% @end
+%%%-------------------------------------------------------------------
+
+-module(so_vm_decode).
+-vsn("9.0.0").
+
+-export([ from_fate/2 ]).
+
+-include_lib("gmbytecode/include/gmb_fate_data.hrl").
+
+-spec from_fate(so_syntax:type(), gmb_fate_data:fate_type()) -> so_syntax:expr().
+from_fate({id, _, "address"}, ?FATE_ADDRESS(Bin)) -> {account_pubkey, [], Bin};
+from_fate({id, _, "signature"}, ?FATE_BYTES(Bin)) -> {signature, [], Bin};
+from_fate({id, _, "hash"}, ?FATE_BYTES(Bin)) -> {bytes, [], Bin};
+from_fate({id, _, "unit"}, ?FATE_UNIT) -> {tuple, [], []};
+from_fate({con, _, _Name},  ?FATE_CONTRACT(Bin)) -> {contract_pubkey, [], Bin};
+from_fate({bytes_t, _, any}, ?FATE_BYTES(Bin)) -> make_any_bytes(Bin);
+from_fate({bytes_t, _, N},  ?FATE_BYTES(Bin)) when byte_size(Bin) == N -> {bytes, [], Bin};
+from_fate({id, _, "bits"},  ?FATE_BITS(N)) -> make_bits(N);
+from_fate({id, _, "int"},     N) when is_integer(N) ->
+    if N < 0 -> {app, [{format, prefix}], {'-', []}, [{int, [], -N}]};
+       true  -> {int, [], N} end;
+from_fate({id, _, "bool"},    B) when is_boolean(B) -> {bool, [], B};
+from_fate({id, _, "string"}, S) when is_binary(S) -> {string, [], S};
+from_fate({app_t, _, {id, _, "list"}, [Type]}, List) when is_list(List) ->
+    {list, [], [from_fate(Type, X) || X <- List]};
+from_fate({app_t, _, {id, _, "option"}, [Type]}, Val) ->
+    case Val of
+        {variant, [0, 1], 0, {}}  -> {con, [], "None"};
+        {variant, [0, 1], 1, {X}} -> {app, [], {con, [], "Some"}, [from_fate(Type, X)]}
+    end;
+from_fate({tuple_t, _, []}, ?FATE_UNIT) ->
+     {tuple, [], []};
+from_fate({tuple_t, _, Types}, ?FATE_TUPLE(Val))
+        when length(Types) == tuple_size(Val) ->
+    {tuple, [], [from_fate(Type, X)
+                 || {Type, X} <- lists:zip(Types, tuple_to_list(Val))]};
+from_fate({record_t, [{field_t, _, FName, FType}]}, Val) ->
+    {record, [], [{field, [], [{proj, [], FName}], from_fate(FType, Val)}]};
+from_fate({record_t, Fields}, ?FATE_TUPLE(Val))
+        when length(Fields) == tuple_size(Val) ->
+    {record, [], [ {field, [], [{proj, [], FName}], from_fate(FType, X)}
+                   || {{field_t, _, FName, FType}, X} <- lists:zip(Fields, tuple_to_list(Val)) ]};
+from_fate({app_t, _, {id, _, "map"}, [KeyType, ValType]}, Map)
+        when is_map(Map) ->
+    {map, [], [ {from_fate(KeyType, Key),
+                 from_fate(ValType, Val)}
+                || {Key, Val} <- maps:to_list(Map) ]};
+from_fate({variant_t, Cons}, {variant, Ar, Tag, Args})
+        when length(Cons) > Tag ->
+    ConType = lists:nth(Tag + 1, Cons),
+    Arity = lists:nth(Tag + 1, Ar),
+    case tuple_to_list(Args) of
+        ArgList when length(ArgList) == Arity ->
+            from_fate(ConType, ArgList);
+        _ -> throw(cannot_translate_to_sophia)
+    end;
+from_fate({constr_t, _, Con, []}, []) -> Con;
+from_fate({constr_t, _, Con, Types}, Args)
+        when length(Types) == length(Args) ->
+    {app, [], Con, [ from_fate(Type, Arg)
+                     || {Type, Arg} <- lists:zip(Types, Args) ]};
+from_fate({qid, _, QType}, Val) ->
+    from_fate_builtin(QType, Val);
+from_fate(_Type, _Data) ->
+    throw(cannot_translate_to_sophia).
+
+
+from_fate_builtin(QType, Val) ->
+    Con = fun([Name | _] = Names) when is_list(Name) -> {qcon, [], Names};
+             (Name) -> {con, [], Name} end,
+    App = fun(Name, []) -> Con(Name);
+             (Name, Value) -> {app, [], Con(Name), Value} end,
+    Chk = fun(Type, Value) -> from_fate(Type, Value) end,
+    Int = {id, [], "int"},
+    Str = {id, [], "string"},
+    Adr = {id, [], "address"},
+    Hsh = {bytes_t, [], 32},
+    I32 = {bytes_t, [], 32},
+    I48 = {bytes_t, [], 48},
+    Bts = {bytes_t, [], any},
+    Qid = fun(Name) -> {qid, [], Name} end,
+    Map = fun(KT, VT) -> {app_t, [], {id, [], "map"}, [KT, VT]} end,
+    ChainTxArities = [3, 0, 0, 0, 0, 0, 1, 1, 1, 2, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 2, 0],
+
+    case {QType, Val} of
+        {["Chain", "ttl"], {variant, [1, 1], 0, {X}}} -> App("RelativeTTL", [Chk(Int, X)]);
+        {["Chain", "ttl"], {variant, [1, 1], 1, {X}}} -> App("FixedTTL", [Chk(Int, X)]);
+
+        {["AENS", "name"], {variant, [3], 0, {Addr, TTL, Ptrs}}} ->
+            App(["AENS","Name"], [Chk(Adr, Addr), Chk(Qid(["Chain", "ttl"]), TTL),
+                                  Chk(Map(Str, Qid(["AENS", "pointee"])), Ptrs)]);
+
+        {["AENS", "pointee"], {variant, [1, 1, 1, 1], 0, {Addr}}} ->
+            App(["AENS","AccountPt"], [Chk(Adr, Addr)]);
+        {["AENS", "pointee"], {variant, [1, 1, 1, 1], 1, {Addr}}} ->
+            App(["AENS","OraclePt"], [Chk(Adr, Addr)]);
+        {["AENS", "pointee"], {variant, [1, 1, 1, 1], 2, {Addr}}} ->
+            App(["AENS","ContractPt"], [Chk(Adr, Addr)]);
+        {["AENS", "pointee"], {variant, [1, 1, 1, 1], 3, {Addr}}} ->
+            App(["AENS","ChannelPt"], [Chk(Adr, Addr)]);
+
+        {["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, {Value}}} ->
+            App(["AENSv2","AccountPt"], [Chk(Adr, Value)]);
+        {["AENSv2", "pointee"], {variant, [1, 1, 1, 1, 1], 1, {Value}}} ->
+            App(["AENSv2","OraclePt"], [Chk(Adr, Value)]);
+        {["AENSv2", "pointee"], {variant, [1, 1, 1, 1, 1], 2, {Value}}} ->
+            App(["AENSv2","ContractPt"], [Chk(Adr, Value)]);
+        {["AENSv2", "pointee"], {variant, [1, 1, 1, 1, 1], 3, {Value}}} ->
+            App(["AENSv2","ChannelPt"], [Chk(Adr, Value)]);
+        {["AENSv2", "pointee"], {variant, [1, 1, 1, 1, 1], 4, {Value}}} ->
+            App(["AENSv2","DataPt"], [Chk(Bts, Value)]);
+
+        {["Chain", "ga_meta_tx"], {variant, [2], 0, {Addr, X}}} ->
+            App(["Chain","GAMetaTx"], [Chk(Adr, Addr), Chk(Int, X)]);
+
+        {["Chain", "paying_for_tx"], {variant, [2], 0, {Addr, X}}} ->
+            App(["Chain","PayingForTx"], [Chk(Adr, Addr), Chk(Int, X)]);
+
+        {["Chain", "base_tx"], {variant, ChainTxArities, 0, {Addr, Fee, Payload}}} ->
+            App(["Chain","SpendTx"], [Chk(Adr, Addr), Chk(Int, Fee), Chk(Str, Payload)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 1, {}}} ->
+            App(["Chain","OracleRegisterTx"], []);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 2, {}}} ->
+            App(["Chain","OracleQueryTx"], []);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 3, {}}} ->
+            App(["Chain","OracleResponseTx"], []);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 4, {}}} ->
+            App(["Chain","OracleExtendTx"], []);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 5, {}}} ->
+            App(["Chain","NamePreclaimTx"], []);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 6, {Name}}} ->
+            App(["Chain","NameClaimTx"], [Chk(Str, Name)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 7, {NameHash}}} ->
+            App(["Chain","NameUpdateTx"], [Chk(Hsh, NameHash)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 8, {NameHash}}} ->
+            App(["Chain","NameRevokeTx"], [Chk(Hsh, NameHash)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 9, {NewOwner, NameHash}}} ->
+            App(["Chain","NameTransferTx"], [Chk(Adr, NewOwner), Chk(Hsh, NameHash)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 10, {Addr}}} ->
+            App(["Chain","ChannelCreateTx"], [Chk(Adr, Addr)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 11, {Addr, Amount}}} ->
+            App(["Chain","ChannelDepositTx"], [Chk(Adr, Addr), Chk(Int, Amount)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 12, {Addr, Amount}}} ->
+            App(["Chain","ChannelWithdrawTx"], [Chk(Adr, Addr), Chk(Int, Amount)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 13, {Addr}}} ->
+            App(["Chain","ChannelForceProgressTx"], [Chk(Adr, Addr)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 14, {Addr}}} ->
+            App(["Chain","ChannelCloseMutualTx"], [Chk(Adr, Addr)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 15, {Addr}}} ->
+            App(["Chain","ChannelCloseSoloTx"], [Chk(Adr, Addr)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 16, {Addr}}} ->
+            App(["Chain","ChannelSlashTx"], [Chk(Adr, Addr)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 17, {Addr}}} ->
+            App(["Chain","ChannelSettleTx"], [Chk(Adr, Addr)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 18, {Addr}}} ->
+            App(["Chain","ChannelSnapshotSoloTx"], [Chk(Adr, Addr)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 19, {Amount}}} ->
+            App(["Chain","ContractCreateTx"], [Chk(Int, Amount)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 20, {Addr, Amount}}} ->
+            App(["Chain","ContractCallTx"], [Chk(Adr, Addr), Chk(Int, Amount)]);
+        {["Chain", "base_tx"], {variant, ChainTxArities, 21, {}}} ->
+            App(["Chain","GAAttachTx"], []);
+
+        {["MCL_BLS12_381", "fp"], X} ->
+            App(["MCL_BLS12_381", "fp"], [Chk(I32, X)]);
+        {["MCL_BLS12_381", "fr"], X} ->
+            App(["MCL_BLS12_381", "fr"], [Chk(I48, X)]);
+
+        _ ->
+            throw(cannot_translate_to_sophia)
+    end.
+
+make_bits(N) ->
+    Id = fun(F) -> {qid, [], ["Bits", F]} end,
+    if N < 0 -> make_bits(Id("clear"), Id("all"), 0, bnot N);
+       true  -> make_bits(Id("set"), Id("none"), 0, N) end.
+
+make_bits(_Set, Zero, _I, 0) -> Zero;
+make_bits(Set, Zero, I, N) when 0 == N rem 2 ->
+    make_bits(Set, Zero, I + 1, N div 2);
+make_bits(Set, Zero, I, N) ->
+    {app, [], Set, [make_bits(Set, Zero, I + 1, N div 2), {int, [], I}]}.
+
+make_any_bytes(Bin) ->
+  {app, [], {qid, [], ["Bytes", "to_any_size"]}, [{bytes, [], Bin}]}.

src/so_warnings.erl

@@ -0,0 +1,32 @@
+-module(so_warnings).
+-vsn("9.0.0").
+
+-record(warn, { pos     :: so_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(so_errors:pos(0, 0), Msg).
+
+new(Pos, Msg) ->
+    #warn{ pos = Pos, message = Msg }.
+
+warn_to_err(Kind, #warn{ pos = Pos, message = Msg }) ->
+    so_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", [so_errors:pp_pos(Pos), Msg])).

src/sophia.app.src

@@ -1,14 +1,14 @@
-{application, aesophia,
- [{description, "Contract Language for aeternity"},
-  {vsn, "2.0.0"},
+{application, sophia,
+ [{description, "Compiler for Sophia language"},
+  {vsn, "9.0.0"},
   {registered, []},
   {applications,
    [kernel,
     stdlib,
     jsx,
     syntax_tools,
-    getopt,
-    aebytecode
+    gmbytecode,
+    eblake2
    ]},
   {env,[]},
   {modules, []},

test/aeso_abi_tests.erl

@@ -1,184 +0,0 @@
--module(aeso_abi_tests).
-
--include_lib("eunit/include/eunit.hrl").
--compile(export_all).
-
--define(SANDBOX(Code), sandbox(fun() -> Code end)).
-
-sandbox(Code) ->
-    Parent = self(),
-    Tag    = make_ref(),
-    {Pid, Ref} = spawn_monitor(fun() -> Parent ! {Tag, Code()} end),
-    receive
-        {Tag, Res} -> erlang:demonitor(Ref, [flush]), {ok, Res};
-        {'DOWN', Ref, process, Pid, Reason} -> {error, Reason}
-    after 100 ->
-        exit(Pid, kill),
-        {error, loop}
-    end.
-
-malicious_from_binary_test() ->
-    CircularList = from_words([32, 1, 32]), %% Xs = 1 :: Xs
-    {ok, {error, circular_references}}   = ?SANDBOX(aeso_heap:from_binary({list, word}, CircularList)),
-    {ok, {error, {binary_too_short, _}}} = ?SANDBOX(aeso_heap:from_binary(word, <<1, 2, 3, 4>>)),
-    ok.
-
-from_words(Ws) ->
-    << <<(from_word(W))/binary>> || W <- Ws >>.
-
-from_word(W) when is_integer(W) ->
-    <<W:256>>;
-from_word(S) when is_list(S) ->
-    Len = length(S),
-    Bin = <<(list_to_binary(S))/binary, 0:(32 - Len)/unit:8>>,
-    <<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),
-    ok.
-
-encode_decode_sophia_test() ->
-    Check = fun(Type, Str) -> case {encode_decode_sophia_string(Type, Str), Str} of
-                                {X, X} -> ok;
-                                Other -> Other
-                              end end,
-    ok = Check("int", "42"),
-    ok = Check("bool", "true"),
-    ok = Check("bool", "false"),
-    ok = Check("string", "\"Hello\""),
-    ok = Check("(string, list(int), option(bool))",
-               "(\"Hello\", [1, 2, 3], Some(true))"),
-    ok = Check("variant", "Blue({[\"x\"] = 1})"),
-    ok = Check("r", "{x = (\"foo\", 0), y = Red}"),
-    ok.
-
-encode_decode_sophia_string(SophiaType, String) ->
-    io:format("String ~p~n", [String]),
-    Code = [ "contract MakeCall =\n"
-           , "  type arg_type = ", SophiaType, "\n"
-           , "  type an_alias('a) = (string, 'a)\n"
-           , "  record r = {x : an_alias(int), y : variant}\n"
-           , "  datatype variant = Red | Blue(map(string, int))\n"
-           , "  function foo : arg_type => arg_type\n" ],
-    case aeso_compiler:check_call(lists:flatten(Code), "foo", [String], []) of
-        {ok, _, {[Type], _}, [Arg]} ->
-            io:format("Type ~p~n", [Type]),
-            Data = encode(Arg),
-            case aeso_compiler:to_sophia_value(Code, "foo", ok, Data) of
-                {ok, Sophia} ->
-                    lists:flatten(io_lib:format("~s", [prettypr:format(aeso_pretty:expr(Sophia))]));
-                {error, Err} ->
-                    io:format("~s\n", [Err]),
-                    {error, Err}
-            end;
-        {error, Err} ->
-            io:format("~s\n", [Err]),
-            {error, Err}
-    end.
-
-calldata_test() ->
-    [42, <<"foobar">>] = encode_decode_calldata("foo", ["int", "string"], ["42", "\"foobar\""]),
-    Map = #{ <<"a">> => 4 },
-    [{variant, 1, [Map]}, {{<<"b">>, 5}, {variant, 0, []}}] =
-        encode_decode_calldata("foo", ["variant", "r"], ["Blue({[\"a\"] = 4})", "{x = (\"b\", 5), y = Red}"]),
-    [16#123, 16#456] = encode_decode_calldata("foo", ["hash", "address"], ["#123", "#456"]),
-    ok.
-
-calldata_init_test() ->
-    encode_decode_calldata("init", ["int"], ["42"], {tuple, [typerep, word]}),
-
-    Code = parameterized_contract("foo", ["int"]),
-    encode_decode_calldata_(Code, "init", [], {tuple, [typerep, {tuple, []}]}).
-
-calldata_indent_test() ->
-    Test = fun(Extra) ->
-            encode_decode_calldata_(
-                parameterized_contract(Extra, "foo", ["int"]),
-                "foo", ["42"], word)
-           end,
-    Test("  stateful function bla() = ()"),
-    Test("  type x = int"),
-    Test("  private function bla : int => int"),
-    Test("  public stateful function bla(x : int) =\n"
-         "    x + 1"),
-    Test("  stateful private function bla(x : int) : int =\n"
-         "    x + 1"),
-    ok.
-
-parameterized_contract(FunName, Types) ->
-    parameterized_contract([], FunName, Types).
-
-parameterized_contract(ExtraCode, FunName, Types) ->
-    lists:flatten(
-        ["contract Dummy =\n",
-         ExtraCode, "\n",
-         "  type an_alias('a) = (string, 'a)\n"
-         "  record r = {x : an_alias(int), y : variant}\n"
-         "  datatype variant = Red | Blue(map(string, int))\n"
-         "  function ", FunName, " : (", string:join(Types, ", "), ") => int\n" ]).
-
-oracle_test() ->
-    Contract =
-        "contract OracleTest =\n"
-        "  function question(o, q : oracle_query(list(string), option(int))) =\n"
-        "    Oracle.get_question(o, q)\n",
-    {ok, _, {[word, word], {list, string}}, [16#123, 16#456]} =
-        aeso_compiler:check_call(Contract, "question", ["#123", "#456"], []),
-    ok.
-
-permissive_literals_fail_test() ->
-    Contract =
-        "contract OracleTest =\n"
-        "  function haxx(o : oracle(list(string), option(int))) =\n"
-        "    Chain.spend(o, 1000000)\n",
-        {error, <<"Type errors\nCannot unify", _/binary>>} =
-            aeso_compiler:check_call(Contract, "haxx", ["#123"], []),
-    ok.
-
-encode_decode_calldata(FunName, Types, Args) ->
-    encode_decode_calldata(FunName, Types, Args, word).
-
-encode_decode_calldata(FunName, Types, Args, RetType) ->
-    Code = parameterized_contract(FunName, Types),
-    encode_decode_calldata_(Code, FunName, Args, RetType).
-
-encode_decode_calldata_(Code, FunName, Args, RetVMType) ->
-    {ok, Calldata, CalldataType, RetVMType1} = aeso_compiler:create_calldata(Code, FunName, Args),
-    ?assertEqual(RetVMType1, RetVMType),
-    {ok, {_Hash, ArgTuple}} = aeso_heap:from_binary(CalldataType, Calldata),
-    case FunName of
-        "init" ->
-            ok;
-        _ ->
-            {ok, _ArgTypes, ValueASTs} = aeso_compiler:decode_calldata(Code, FunName, Calldata),
-            Values = [ prettypr:format(aeso_pretty:expr(V)) || V <- ValueASTs ],
-            ?assertMatch({X, X}, {Args, Values})
-    end,
-    tuple_to_list(ArgTuple).
-
-encode_decode(T, D) ->
-    ?assertEqual(D, decode(T, encode(D))),
-    D.
-
-encode(D) ->
-    aeso_heap:to_binary(D).
-
-decode(T,B) ->
-    {ok, D} = aeso_heap:from_binary(T, B),
-    D.

test/aeso_aci_tests.erl

@@ -1,45 +0,0 @@
--module(aeso_aci_tests).
-
--include_lib("eunit/include/eunit.hrl").
-
-
-do_test() ->
-    test_contract(1),
-    test_contract(2).
-
-test_contract(N) ->
-    {Contract,DecACI} = test_cases(N),
-    {ok,Enc} = aeso_aci:encode(Contract),
-    ?assertEqual(DecACI, jsx:decode(Enc)).
-
-test_cases(1) ->
-    Contract = <<"contract C =\n"
-		 "  function a(i : int) = i+1\n">>,
-    DecodedACI = [{<<"contract">>,
-		   [{<<"name">>,<<"C">>},
-		    {<<"type_defs">>,[]},
-		    {<<"functions">>,
-		     [[{<<"name">>,<<"a">>},
-		       {<<"arguments">>,
-			[[{<<"name">>,<<"i">>},{<<"type">>,<<"int">>}]]},
-		       {<<"type">>,<<"int">>},
-		       {<<"stateful">>,false}]]}]}],
-    {Contract,DecodedACI};
-
-test_cases(2) ->
-    Contract = <<"contract C =\n"
-		 "  type allan = int\n"
-		 "  function a(i : allan) = i+1\n">>,
-    DecodedACI = [{<<"contract">>,
-		   [{<<"name">>,<<"C">>},
-		    {<<"type_defs">>,
-		     [[{<<"name">>,<<"allan">>},
-		       {<<"vars">>,[]},
-		       {<<"typedef">>,<<"int">>}]]},
-		    {<<"functions">>,
-		     [[{<<"name">>,<<"a">>},
-		       {<<"arguments">>,
-			[[{<<"name">>,<<"i">>},{<<"type">>,<<"int">>}]]},
-		       {<<"type">>,<<"int">>},
-		       {<<"stateful">>,false}]]}]}],
-    {Contract,DecodedACI}.

test/aeso_compiler_tests.erl

@@ -1,221 +0,0 @@
-%%% -*- erlang-indent-level:4; indent-tabs-mode: nil -*-
-%%%-------------------------------------------------------------------
-%%% @copyright (C) 2018, Aeternity Anstalt
-%%% @doc Test Sophia language compiler.
-%%%
-%%% @end
-%%%-------------------------------------------------------------------
-
--module(aeso_compiler_tests).
-
--include_lib("eunit/include/eunit.hrl").
-
-%%  Very simply test compile the given contracts. Only basic checks
-%%  are made on the output, just that it is a binary which indicates
-%%  that the compilation worked.
-simple_compile_test_() ->
-     [ {"Testing the " ++ ContractName ++ " contract",
-        fun() ->
-            #{byte_code := ByteCode,
-              contract_source := _,
-              type_info := _} = compile(ContractName),
-            ?assertMatch(Code when is_binary(Code), ByteCode)
-        end} || ContractName <- compilable_contracts() ] ++
-     [ {"Testing error messages of " ++ ContractName,
-        fun() ->
-            case compile(ContractName) of
-                <<"Type errors\n", ErrorString/binary>> ->
-                    check_errors(lists:sort(ExpectedErrors), ErrorString);
-                <<"Parse errors\n", ErrorString/binary>> ->
-                    check_errors(lists:sort(ExpectedErrors), ErrorString)
-            end
-        end} ||
-            {ContractName, ExpectedErrors} <- failing_contracts() ] ++
-     [ {"Testing include with explicit files",
-        fun() ->
-            FileSystem = maps:from_list(
-                [ begin
-                    {ok, Bin} = file:read_file(filename:join([aeso_test_utils:contract_path(), File])),
-                    {File, Bin}
-                  end || File <- ["included.aes", "../contracts/included2.aes"] ]),
-            #{byte_code := Code1} = compile("include", [{include, {explicit_files, FileSystem}}]),
-            #{byte_code := Code2} = compile("include"),
-            ?assertMatch(true, Code1 == Code2)
-        end} ] ++
-     [ {"Testing deadcode elimination",
-        fun() ->
-            #{ byte_code := NoDeadCode } = compile("nodeadcode"),
-            #{ byte_code := DeadCode   } = compile("deadcode"),
-            SizeNoDeadCode = byte_size(NoDeadCode),
-            SizeDeadCode   = byte_size(DeadCode),
-            ?assertMatch({_, _, true}, {SizeDeadCode, SizeNoDeadCode, SizeDeadCode + 40 < SizeNoDeadCode}),
-            ok
-        end} ].
-
-check_errors(Expect, ErrorString) ->
-    %% This removes the final single \n as well.
-    Actual = binary:split(<<ErrorString/binary,$\n>>, <<"\n\n">>, [global,trim]),
-    case {Expect -- Actual, Actual -- Expect} of
-        {[], Extra}   -> ?assertMatch({unexpected, []}, {unexpected, Extra});
-        {Missing, []} -> ?assertMatch({missing, []}, {missing, Missing});
-        {Missing, Extra} -> ?assertEqual(Missing, Extra)
-    end.
-
-compile(Name) ->
-    compile(Name, [{include, {file_system, [aeso_test_utils:contract_path()]}}]).
-
-compile(Name, Options) ->
-    String = aeso_test_utils:read_contract(Name),
-    case aeso_compiler:from_string(String, [{src_file, Name} | Options]) of
-        {ok, Map}            -> Map;
-        {error, ErrorString} -> ErrorString
-    end.
-
-%% compilable_contracts() -> [ContractName].
-%%  The currently compilable contracts.
-
-compilable_contracts() ->
-    ["complex_types",
-     "counter",
-     "dutch_auction",
-     "environment",
-     "factorial",
-     "fundme",
-     "identity",
-     "maps",
-     "oracles",
-     "remote_call",
-     "simple",
-     "simple_storage",
-     "spend_test",
-     "stack",
-     "test",
-     "builtin_bug",
-     "builtin_map_get_bug",
-     "nodeadcode",
-     "deadcode",
-     "variant_types",
-     "state_handling",
-     "events",
-     "include",
-     "basic_auth"
-    ].
-
-%% Contracts that should produce type errors
-
-failing_contracts() ->
-    [ {"name_clash",
-       [<<"Duplicate definitions of abort at\n"
-          "  - (builtin location)\n"
-          "  - line 14, column 3">>,
-        <<"Duplicate definitions of double_def at\n"
-          "  - line 10, column 3\n"
-          "  - line 11, column 3">>,
-        <<"Duplicate definitions of double_proto at\n"
-          "  - line 4, column 3\n"
-          "  - line 5, column 3">>,
-        <<"Duplicate definitions of proto_and_def at\n"
-          "  - line 7, column 3\n"
-          "  - line 8, column 3">>,
-        <<"Duplicate definitions of put at\n"
-          "  - (builtin location)\n"
-          "  - line 15, column 3">>,
-        <<"Duplicate definitions of state at\n"
-          "  - (builtin location)\n"
-          "  - line 16, column 3">>]}
-    , {"type_errors",
-       [<<"Unbound variable zz at line 17, column 21">>,
-        <<"Cannot unify int\n"
-          "         and list(int)\n"
-          "when checking the application at line 26, column 9 of\n"
-          "  (::) : (int, list(int)) => list(int)\n"
-          "to arguments\n"
-          "  x : int\n"
-          "  x : int">>,
-        <<"Cannot unify string\n"
-          "         and int\n"
-          "when checking the assignment of the field\n"
-          "  x : map(string, string) (at line 9, column 46)\n"
-          "to the old value __x and the new value\n"
-          "  __x {[\"foo\"] @ x = x + 1} : map(string, int)">>,
-        <<"Cannot unify int\n"
-          "         and string\n"
-          "when checking the type of the expression at line 34, column 45\n"
-          "  1 : int\n"
-          "against the expected type\n"
-          "  string">>,
-        <<"Cannot unify string\n"
-          "         and int\n"
-          "when checking the type of the expression at line 34, column 50\n"
-          "  \"bla\" : string\n"
-          "against the expected type\n"
-          "  int">>,
-        <<"Cannot unify string\n"
-          "         and int\n"
-          "when checking the type of the expression at line 32, column 18\n"
-          "  \"x\" : string\n"
-          "against the expected type\n"
-          "  int">>,
-        <<"Cannot unify string\n"
-          "         and int\n"
-          "when checking the type of the expression at line 11, column 56\n"
-          "  \"foo\" : string\n"
-          "against the expected type\n"
-          "  int">>,
-        <<"Cannot unify int\n"
-          "         and string\n"
-          "when comparing the types of the if-branches\n"
-          "  - w : int (at line 38, column 13)\n"
-          "  - z : string (at line 39, column 10)">>,
-        <<"Not a record type: string\n"
-          "arising from the projection of the field y (at line 22, column 38)">>,
-        <<"Not a record type: string\n"
-          "arising from an assignment of the field y (at line 21, column 42)">>,
-        <<"Not a record type: string\n"
-          "arising from an assignment of the field y (at line 20, column 38)">>,
-        <<"Not a record type: string\n"
-          "arising from an assignment of the field y (at line 19, column 35)">>,
-        <<"Ambiguous record type with field y (at line 13, column 25) could be one of\n"
-          "  - r (at line 4, column 10)\n"
-          "  - r' (at line 5, column 10)">>,
-        <<"Repeated name x in pattern\n"
-          "  x :: x (at line 26, column 7)">>,
-        <<"No record type with fields y, z (at line 14, column 22)">>,
-        <<"The field z is missing when constructing an element of type r2 (at line 15, column 24)">>,
-        <<"Record type r2 does not have field y (at line 15, column 22)">>]}
-    , {"init_type_error",
-       [<<"Cannot unify string\n"
-          "         and map(int, int)\n"
-          "when checking that 'init' returns a value of type 'state' at line 7, column 3">>]}
-    , {"missing_state_type",
-       [<<"Cannot unify string\n"
-          "         and ()\n"
-          "when checking that 'init' returns a value of type 'state' at line 5, column 3">>]}
-    , {"missing_fields_in_record_expression",
-       [<<"The field x is missing when constructing an element of type r('a) (at line 7, column 40)">>,
-        <<"The field y is missing when constructing an element of type r(int) (at line 8, column 40)">>,
-        <<"The fields y, z are missing when constructing an element of type r('1) (at line 6, column 40)">>]}
-    , {"namespace_clash",
-       [<<"The contract Call (at line 4, column 10) has the same name as a namespace at (builtin location)">>]}
-    , {"bad_events",
-        [<<"The payload type int (at line 10, column 30) should be string">>,
-         <<"The payload type alias_address (at line 12, column 30) equals address but it should be string">>,
-         <<"The indexed type string (at line 9, column 25) is not a word type">>,
-         <<"The indexed type alias_string (at line 11, column 25) equals string which is not a word type">>]}
-    , {"bad_events2",
-        [<<"The event constructor BadEvent1 (at line 9, column 7) has too many non-indexed values (max 1)">>,
-         <<"The event constructor BadEvent2 (at line 10, column 7) has too many indexed values (max 3)">>,
-         <<"The event constructor BadEvent3 (at line 11, column 7) has too many non-indexed values (max 1)">>,
-         <<"The payload type address (at line 11, column 17) should be string">>,
-         <<"The payload type int (at line 11, column 26) should be string">>]}
-    , {"type_clash",
-        [<<"Cannot unify int\n"
-           "         and string\n"
-           "when checking the record projection at line 12, column 40\n"
-           "  r.foo : (gas : int, value : int) => Remote.themap\n"
-           "against the expected type\n"
-           "  (gas : int, value : int) => map(string, int)">>]}
-    , {"bad_include_and_ns",
-        [<<"Include of 'included.aes' at line 2, column 11\nnot allowed, include only allowed at top level.">>,
-         <<"Nested namespace not allowed\nNamespace 'Foo' at line 3, column 13 not defined at top level.">>]}
-    ].

test/aeso_eunit_SUITE.erl

@@ -1,22 +0,0 @@
--module(aeso_eunit_SUITE).
-
--compile([export_all, nowarn_export_all]).
-
--include_lib("common_test/include/ct.hrl").
-
-all() ->
-    [{group, eunit}].
-
-groups() ->
-    [{eunit, [], [ aeso_scan_tests
-                 , aeso_parser_tests
-                 , aeso_compiler_tests
-                 , aeso_abi_tests
-		 , aeso_aci_tests
-                 ]}].
-
-aeso_scan_tests(_Config)   -> ok = eunit:test(aeso_scan_tests).
-aeso_parser_tests(_Config) -> ok = eunit:test(aeso_parser_tests).
-aeso_compiler_tests(_Config) -> ok = eunit:test(aeso_compiler_tests).
-aeso_abi_tests(_Config) -> ok = eunit:test(aeso_abi_tests).
-aeso_aci_tests(_Config) -> ok = eunit:test(aeso_aci_tests).

test/contracts/05_greeter.aes

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

test/contracts/Makefile

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

test/contracts/__call.aes

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

test/contracts/abort_test.aes

@@ -1,31 +0,0 @@
-// A simple test of the abort built-in function.
-
-contract AbortTest =
-
-  record state = { value : int }
-
-  public function init(v : int) =
-    { value = v }
-
-  // Aborting
-  public function do_abort(v : int, s : string) : () =
-    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) => ()
-  function get_value : () => int
-  function put_value : (int) => ()
-  function get_values : () => list(int)
-  function put_values : (int) => ()
-
-contract AbortTestInt =
-
-  record state = {r : Interface, value : int}
-
-  public function init(r : Interface, value : int) =
-    {r = r, value = value}
-
-  // Aborting
-  public function do_abort(v : int, s : string) =
-    put_value(v)
-    state.r.do_abort(v + 100, s)
-
-  // Accessing the value
-  public function put_value(v : int) = put(state{value = v})
-  public function get_value() = state.value
-  public function get_values() : list(int) =
-    state.value :: state.r.get_values()
-  public function put_values(v : int) =
-    put_value(v)
-    state.r.put_values(v + 1000)

test/contracts/address_chain.aes

@@ -0,0 +1,21 @@
+contract interface Remote =
+  entrypoint main_fun : (int) => unit
+
+contract AddrChain =
+  entrypoint is_c(a : address) =
+    Address.is_contract(a)
+
+//   entrypoint get_c(a : address) : option(Remote) =
+//     Address.get_contract(a)
+
+//   entrypoint h_to_i(h : hash) : int =
+//     Hash.to_int(h)
+
+//   entrypoint a_to_i(a : address) : int =
+//     Address.to_int(a) mod 10 ^ 16
+
+  entrypoint c_creator() : address =
+    Contract.creator
+
+  entrypoint is_payable(a : address) : bool =
+    Address.is_payable(a)

test/contracts/address_literals.aes

@@ -0,0 +1,12 @@
+
+contract interface Remote =
+  entrypoint foo : () => unit
+
+contract AddressLiterals =
+  entrypoint addr() : address =
+    ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt
+  entrypoint contr() : Remote =
+    ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ
+  entrypoint contr_addr() : Remote =
+    Address.to_contract(addr())
+

test/contracts/aens.aes

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

test/contracts/aens_update.aes

@@ -0,0 +1,29 @@
+include "Option.aes"
+include "String.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, b : bytes(2)) =
+    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(String.to_bytes("any something will do"))
+    let p6 : AENSv2.pointee = AENSv2.DataPt(Int.to_bytes(1345, 4))
+    AENSv2.update(owner, name, None, None,
+                  Some({ ["account_pubkey"] = p1,
+                         ["contract_pubkey"] = p3, ["misc"] = p4, ["data"] = p5, ["data2"] = p6 }))
+
+  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(AENSv2.lookup(name))
+     Some(AENSv2.Name(_, FixedTTL(ttl), _)) => ttl

test/contracts/aeproof.aes

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

test/contracts/all_syntax.aes

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

test/contracts/ambiguous_main.aes

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

test/contracts/assign_pattern_to_pattern.aes

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

test/contracts/assign_patterns.aes

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

test/contracts/bad_address_literals.aes

@@ -0,0 +1,17 @@
+
+contract interface Remote =
+  entrypoint foo : () => unit
+
+contract AddressLiterals =
+  entrypoint addr1() : bytes(32) =
+    ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt
+  entrypoint addr2() : Remote =
+    ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt
+
+  entrypoint contr1() : address =
+    ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ
+  entrypoint contr3() : bytes(32) =
+    ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ
+  entrypoint contr4() : address =
+    Address.to_contract(Contract.address)
+

test/contracts/bad_aens_resolve.aes

@@ -0,0 +1,9 @@
+contract BadAENSresolve =
+
+  type t('a) = option(list('a))
+
+  function fail() : t(int) =
+    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_arity.aes

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

test/contracts/bad_bytes_concat.aes

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

test/contracts/bad_bytes_split.aes

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