Meta update

* Fix tvar string generation

* Add check for number of tvars in a single type signature

The number of tvars is limited by serialization (u8) to 255

* Added a comment in CHANGELOG

* Docs fixes

* Adding docs about the limitation on number of tvars

* Limit is 256, not 255

* Update CHANGELOG.md

Co-authored-by: Gaith Hallak <gaithhallak@gmail.com>

---------

Co-authored-by: Gaith Hallak <gaithhallak@gmail.com>

.github/workflows/requirements.txt

@@ -2,4 +2,4 @@ mkdocs==1.4.2
 mkdocs-simple-hooks==0.1.5
 mkdocs-material==9.0.9
 mike==1.1.2
-pygments==2.14.0
+pygments==2.17.2

.gitignore

@@ -24,3 +24,4 @@ current_counterexample.eqc
 test/contracts/test.aes
 __pycache__
 .docssite/docs/*.md
+.vscode

CHANGELOG.md

@@ -6,6 +6,73 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [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
+
+## [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 =
@@ -13,8 +80,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   contract C =
     let cc = 2
   ```
-### Changed
+- 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.
 
@@ -388,7 +456,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Simplify calldata creation - instead of passing a compiled contract, simply
   pass a (stubbed) contract string.
 
-[Unreleased]: https://github.com/aeternity/aesophia/compare/v7.1.0...HEAD
+[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

Emakefile

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

docs/aeso_compiler.md

@@ -53,8 +53,6 @@ The **pp_** options all print to standard output the following:
 
 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.
 
-The option `debug_info` includes information related to debugging in the compiler output. Currently this option only includes the mapping from variables to registers.
-
 #### Options to control which compiler optimizations should run:
 
 By default all optimizations are turned on, to disable an optimization, it should be

docs/sophia_features.md

@@ -84,7 +84,7 @@ the return value of the call.
 
 ```sophia
 contract interface VotingType =
-  entrypoint : vote : string => unit
+  entrypoint vote : string => unit
 
 contract Voter =
   entrypoint tryVote(v : VotingType, alt : string) =
@@ -204,7 +204,7 @@ When a `contract` or a `contract interface` implements another `contract interfa
 
 #### Subtyping and variance
 
-Subtyping in Sophia follows common rules that take type variance into account. As described by [Wikipedia](https://en.wikipedia.org/wiki/Covariance_and_contravariance_(computer_science)), 
+Subtyping in Sophia follows common rules that take type variance into account. As described by [Wikipedia](https://en.wikipedia.org/wiki/Covariance_and_contravariance_(computer_science)),
 
 >Variance refers to how subtyping between more complex types relates to subtyping between their components.
 
@@ -224,11 +224,11 @@ A good example of where it matters can be pictured by subtyping of function type
 ```sophia
 contract interface Animal =
   entrypoint age : () => int
-  
+
 contract Dog : Animal =
   entrypoint age() = // ...
   entrypoint woof() = "woof"
-  
+
 contract Cat : Animal =
   entrypoint age() = // ...
   entrypoint meow() = "meow"
@@ -295,6 +295,11 @@ of `A`.
 - When a user-defined type `t('a)` is invariant in `'a`, then `t(A)` can never be
 a subtype of `t(B)`.
 
+#### Type variable limitation
+
+Because of how FATE represents types as values there is a fixed upper limit (256)
+of type variables that can be used in a single type signature.
+
 ## Mutable state
 
 Sophia does not have arbitrary mutable state, but only a limited form of state
@@ -493,6 +498,24 @@ the file, except that error messages will refer to the original source
 locations. The language will try to include each file at most one time automatically,
 so even cyclic includes should be working without any special tinkering.
 
+### Include files using relative paths
+
+When including code from another file using the `include` statement, the path
+is relative to _the file that includes it_. Consider the following file tree:
+```
+c1.aes
+c3.aes
+dir1/c2.aes
+dir1/c3.aes
+```
+
+If `c1.aes` contains `include "c3.aes"` it will include the top level `c3.aes`,
+while if `c2.aes` contained the same line it would as expected include
+`dir1/c3.aes`.
+
+Note: Prior to v7.5.0, it would consider the include path relative to _the main
+contract file_ (or any explicitly set include path).
+
 ## Standard library
 
 Sophia offers [standard library](sophia_stdlib.md) which exposes some
@@ -540,6 +563,7 @@ Sophia has the following types:
 ## Literals
 | Type                 | Constant/Literal example(s)                                                                                                         |
 | ----------           | -------------------------------                                                                                                     |
+| unit                 | ()                                                                                                                                  |
 | int                  | `-1`, `2425`, `4598275923475723498573485768`                                                                                        |
 | address              | `ak_2gx9MEFxKvY9vMG5YnqnXWv1hCsX7rgnfvBLJS4aQurustR1rt`                                                                             |
 | bool                 | `true`, `false`                                                                                                                     |
@@ -554,7 +578,7 @@ Sophia has the following types:
 | state                | `state{ owner = Call.origin, magic_key = #a298105f }`                                                                               |
 | event                | `EventX(0, "Hello")`                                                                                                                |
 | hash                 | `#000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f`                                                                 |
-| signature            | `#000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f` |
+| signature            | `sg_MhibzTP1wWzGCTjtPFr1TiPqRJrrJqw7auvEuF5i3FdoALWqXLBDY6xxRRNUSPHK3EQTnTzF12EyspkxrSMxVHKsZeSMj`, `#000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f` |
 | Chain.ttl            | `FixedTTL(1050)`, `RelativeTTL(50)`                                                                                                 |
 | oracle('a, 'b)       | `ok_2YNyxd6TRJPNrTcEDCe9ra59SVUdp9FR9qWC5msKZWYD9bP9z5`                                                                             |
 | oracle_query('a, 'b) | `oq_2oRvyowJuJnEkxy58Ckkw77XfWJrmRgmGaLzhdqb67SKEL1gPY`                                                                             |
@@ -610,14 +634,28 @@ arithmetic operations:
 - remainder (`x mod y`), satisfying `y * (x / y) + x mod y == x` for non-zero `y`
 - exponentiation (`x ^ y`)
 
-All operations are *safe* with respect to overflow and underflow. 
+All operations are *safe* with respect to overflow and underflow.
 The division and modulo operations throw an arithmetic error if the
 right-hand operand is zero.
 
+Sophia arbitrary-sized integers (FATE) also supports the following bitwise operations:
+- bitwise and (`x band y`)
+- bitwise or (`x bor y`)
+- bitwise xor (`x bxor y`)
+- bitwise not (`bnot x`)
+- arithmetic bitshift left (`x << n`)
+- arithmetic bitshift right (`x >> n`)
+
+Note: Arithmetic bitshift treats the number as a signed integer (in 2s
+complement), and "retains" the topmost bit. I.e. shifting in zeros if the
+topmost bit was 0, and ones if it was one.
+
 ## Bit fields
 
-Sophia integers do not support bit arithmetic. Instead there is a separate
-type `bits`. See the standard library [documentation](sophia_stdlib.md#bits).
+Originally Sophia integers did not support bit arithmetic. Instead we used a
+separate type `bits` (see the standard library
+[documentation](sophia_stdlib.md#bits)) - it is still provided as an
+alternative to bit arithmetic.
 
 A bit field can be of arbitrary size (but it is still represented by the
 corresponding integer, so setting very high bits can be expensive).
@@ -922,16 +960,18 @@ functions are provided.
 
 ## AENS interface
 
-Contracts can interact with the
-[æternity naming system](https://github.com/aeternity/protocol/blob/master/AENS.md).
-For this purpose the [AENS](sophia_stdlib.md#aens) library was exposed.
+Contracts can interact with the [æternity naming
+system](https://github.com/aeternity/protocol/blob/master/AENS.md). For this
+purpose the [AENS](sophia_stdlib.md#aens) and later the
+[AENSv2](sophia_stdlib.md#aensv2) library was exposed.
 
 ### Example
 
 In this example we assume that the name `name` already exists, and is owned by
 an account with address `addr`. In order to allow a contract `ct` to handle
-`name` the account holder needs to create a
-[signature](#delegation-signature) `sig` of `addr | name.hash | ct.address`.
+`name` the account holder needs to create a [delegation
+signature](#delegation-signature) `sig` from the name owner address `addr`, the
+name hash and the contract address.
 
 Armed with this information we can for example write a function that extends
 the name if it expires within 1000 blocks:
@@ -1073,8 +1113,34 @@ however is in the gas consumption — while `abort` returns unused gas, a call t
 
 ## Delegation signature
 
-Some chain operations (`Oracle.<operation>` and `AENS.<operation>`) have an
+Some chain operations (`Oracle.<operation>` and `AENSv2.<operation>`) have an
 optional delegation signature. This is typically used when a user/accounts
-would like to allow a contract to act on it's behalf. The exact data to be
-signed varies for the different operations, but in all cases you should prepend
-the signature data with the `network_id` (`ae_mainnet` for the æternity mainnet, etc.).
+would like to allow a contract to act on it's behalf.
+
+### From Ceres
+
+From the Ceres protocol version the delegation signatures have more structure,
+including a unique tag, `network_id` and identifiers; there are five different
+delegation signatures:
+
+ - AENS wildcard - the user signs: `owner account + contract`
+ - `AENS_PRECLAIM` - the user signs: `owner account + contract`
+ - `AENS_CLAIM, AENS_UPDATE, AENS_TRANSFER, AENS_REVOKE` - the user signs: `owner account + name hash + contract`
+ - `ORACLE_REGISTER, ORACLE_EXTEND` - the user signs: `owner account + contract`
+ - `ORACLE_RESPOND` - the user signs: `query id + contract`
+
+See [Serialized signature
+data](https://github.com/aeternity/protocol/blob/master/contracts/fate.md#from-ceres-serialized-signature-data)
+for the exact structure used.
+
+### Before ceres
+
+The exact data to be signed varies for the different operations, but in all
+cases you should prepend the signature data with the `network_id` (`ae_mainnet`
+for the æternity mainnet, etc.).
+
+There are four different delegation signatures:
+ - `AENS_PRECLAIM` - the user signs: owner `network_id + account + contract`
+ - `AENS_CLAIM, AENS_UPDATE, AENS_TRANSFER, AENS_REVOKE` - the user signs: `network_id + owner account + name hash + contract`
+ - `ORACLE_REGISTER, ORACLE_EXTEND` - the user signs: `network_id + owner account + contract`
+ - `ORACLE_RESPOND` - the user signs: `network_id + query id + contract`

docs/sophia_stdlib.md

@@ -14,6 +14,7 @@ The out-of-the-box namespaces are:
 
 - [Address](#address)
 - [AENS](#aens)
+- [AENSv2](#aensv2)
 - [Auth](#auth)
 - [Bits](#bits)
 - [Bytes](#bytes)
@@ -31,6 +32,7 @@ The following ones need to be included as regular files with `.aes` suffix, for
 include "List.aes"
 ```
 
+- [AENSCompat](#aenscompat)
 - [Bitwise](#bitwise)
 - [BLS12_381](#bls12_381)
 - [Func](#func)
@@ -55,6 +57,12 @@ Address.to_str(a : address) : string
 
 Base58 encoded string
 
+#### to_bytes
+```
+Address.to_bytes(a : address) : bytes(32)
+```
+
+The binary representation of the address.
 
 #### is_contract
 ```
@@ -90,13 +98,10 @@ Cast address to contract type C (where `C` is a contract)
 
 ### AENS
 
-The following functionality is available for interacting with the æternity
-naming system (AENS).
-If `owner` is equal to `Contract.address` the signature `signature` is
-ignored, and can be left out since it is a named argument. Otherwise we need
-a signature to prove that we are allowed to do AENS operations on behalf of
-`owner`. The [signature is tied to a network id](https://github.com/aeternity/protocol/blob/iris/consensus/consensus.md#transaction-signature),
-i.e. the signature material should be prefixed by the network id.
+The old AENS namespace, kept in the compiler to be able to interact with
+contracts from before Ceres, compiled using aesophia compiler version 7.x and
+earlier. Used in [AENSCompat](#aenscompat) when converting between old and new
+pointers.
 
 #### Types
 
@@ -113,12 +118,41 @@ datatype pointee = AccountPt(address) | OraclePt(address)
                  | ContractPt(address) | ChannelPt(address)
 ```
 
+### AENSv2
+
+Note: introduced in v8.0
+
+The following functionality is available for interacting with the æternity
+naming system (AENS).  If `owner` is equal to `Contract.address` the signature
+`signature` is ignored, and can be left out since it is a named argument.
+Otherwise we need a signature to prove that we are allowed to do AENS
+operations on behalf of `owner`. The [signature is tied to a network
+id](https://github.com/aeternity/protocol/blob/iris/consensus/consensus.md#transaction-signature),
+i.e. the signature material should be prefixed by the network id.
+
+#### Types
+
+##### name
+```
+datatype name = Name(address, Chain.ttl, map(string, AENSv2.pointee))
+```
+
+
+##### pointee
+
+```
+datatype pointee = AccountPt(address) | OraclePt(address)
+                 | ContractPt(address) | ChannelPt(address) | DataPt(bytes())
+```
+
+Note: on-chain there is a maximum length enforced for `DataPt`, it is 1024 bytes.
+Sophia itself does _not_ check for this.
 
 #### Functions
 
 ##### resolve
 ```
-AENS.resolve(name : string, key : string) : option('a)
+AENSv2.resolve(name : string, key : string) : option('a)
 ```
 
 Name resolution. Here `name` should be a registered name and `key` one of the attributes
@@ -129,74 +163,107 @@ type checked against this type at run time.
 
 ##### lookup
 ```
-AENS.lookup(name : string) : option(AENS.name)
+AENSv2.lookup(name : string) : option(AENSv2.name)
 ```
 
-If `name` is an active name `AENS.lookup` returns a name object.
+If `name` is an active name `AENSv2.lookup` returns a name object.
 The three arguments to `Name` are `owner`, `expiry` and a map of the
 `pointees` for the name. Note: the expiry of the name is always a fixed TTL.
 For example:
 ```
-let Some(Name(owner, FixedTTL(expiry), ptrs)) = AENS.lookup("example.chain")
+let Some(AENSv2.Name(owner, FixedTTL(expiry), ptrs)) = AENSv2.lookup("example.chain")
 ```
 
+Note: Changed to produce `AENSv2.name` in v8.0 (Ceres protocol upgrade).
 
 ##### preclaim
 ```
-AENS.preclaim(owner : address, commitment_hash : hash, <signature : signature>) : unit
+AENSv2.preclaim(owner : address, commitment_hash : hash, <signature : signature>) : unit
 ```
 
-The [signature](./sophia_features.md#delegation-signature) should be over
-`network id` + `owner address` + `Contract.address` (concatenated as byte arrays).
+The [signature](./sophia_features.md#delegation-signature) should be a
+serialized structure containing `network id`, `owner address`, and
+`Contract.address`.
+
+From Ceres (i.e. FATE VM version 3) the
+[signature](./sophia_features.md#delegation-signature) can also be generic
+(allowing _all_, existing and future, names to be delegated with one
+signature), i.e. containing `network id`, `owner address`, `Contract.address`.
 
 
 ##### claim
 ```
-AENS.claim(owner : address, name : string, salt : int, name_fee : int, <signature : signature>) : unit
+AENSv2.claim(owner : address, name : string, salt : int, name_fee : int, <signature : signature>) : unit
 ```
 
-The [signature](./sophia_features.md#delegation-signature) should be over
-`network id` + `owner address` + `name_hash` + `Contract.address`
-(concatenated as byte arrays)
-using the private key of the `owner` account for signing.
+The [signature](./sophia_features.md#delegation-signature) should be a
+serialized structure containing `network id`, `owner address`, and
+`Contract.address`. Using the private key of `owner address` for signing.
+
+From Ceres (i.e. FATE VM version 3) the
+[signature](./sophia_features.md#delegation-signature) can also be generic
+(allowing _all_, existing and future, names to be delegated with one
+signature), i.e. containing `network id`, `owner address`, `name_hash`, and
+`Contract.address`.
 
 
 ##### transfer
 ```
-AENS.transfer(owner : address, new_owner : address, name : string, <signature : signature>) : unit
+AENSv2.transfer(owner : address, new_owner : address, name : string, <signature : signature>) : unit
 ```
 
 Transfers name to the new owner.
 
-The [signature](./sophia_features.md#delegation-signature) should be over
-`network id` + `owner address` + `name_hash` + `Contract.address`
-(concatenated as byte arrays)
-using the private key of the `owner` account for signing.
+The [signature](./sophia_features.md#delegation-signature) should be a
+serialized structure containing `network id`, `owner address`, and
+`Contract.address`. Using the private key of `owner address` for signing.
+
+From Ceres (i.e. FATE VM version 3) the
+[signature](./sophia_features.md#delegation-signature) can also be generic
+(allowing _all_, existing and future, names to be delegated with one
+signature), i.e. containing `network id`, `owner address`, `name_hash`, and
+`Contract.address`.
 
 
 ##### revoke
 ```
-AENS.revoke(owner : address, name : string, <signature : signature>) : unit
+AENSv2.revoke(owner : address, name : string, <signature : signature>) : unit
 ```
 
 Revokes the name to extend the ownership time.
 
-The [signature](./sophia_features.md#delegation-signature) should be over
-`network id` + `owner address` + `name_hash` + `Contract.address`
-(concatenated as byte arrays)
-using the private key of the `owner` account for signing.
+The [signature](./sophia_features.md#delegation-signature) should be a
+serialized structure containing `network id`, `owner address`, and
+`Contract.address`. Using the private key of `owner address` for signing.
+
+From Ceres (i.e. FATE VM version 3) the
+[signature](./sophia_features.md#delegation-signature) can also be generic
+(allowing _all_, existing and future, names to be delegated with one
+signature), i.e. containing `network id`, `owner address`, `name_hash`, and
+`Contract.address`.
 
 
 ##### update
 ```
-AENS.update(owner : address, name : string, expiry : option(Chain.ttl), client_ttl : option(int),
-            new_ptrs : map(string, AENS.pointee), <signature : signature>) : unit
+AENSv2.update(owner : address, name : string, expiry : option(Chain.ttl), client_ttl : option(int),
+              new_ptrs : option(map(string, AENSv2.pointee)), <signature : signature>) : unit
 ```
 
 Updates the name. If the optional parameters are set to `None` that parameter
 will not be updated, for example if `None` is passed as `expiry` the expiry
 block of the name is not changed.
 
+Note: Changed to consume `AENSv2.pointee` in v8.0 (Ceres protocol upgrade).
+
+The [signature](./sophia_features.md#delegation-signature) should be a
+serialized structure containing `network id`, `owner address`, and
+`Contract.address`. Using the private key of `owner address` for signing.
+
+From Ceres (i.e. FATE VM version 3) the
+[signature](./sophia_features.md#delegation-signature) can also be generic
+(allowing _all_, existing and future, names to be delegated with one
+signature), i.e. containing `network id`, `owner address`, `name_hash`, and
+`Contract.address`.
 
 ### Auth
 
@@ -236,7 +303,10 @@ namespace Chain =
 Auth.tx_hash : option(hash)
 ```
 
-Gets the transaction hash during authentication.
+Gets the transaction hash during authentication. Note: `Auth.tx_hash`
+computation differs between protocol versions (changed in Ceres!), see
+[aeserialisation](https://github.com/aeternity/protocol/blob/master/serializations.md)
+specification for details.
 
 
 ### Bits
@@ -315,7 +385,7 @@ Each bit is true if and only if it was 1 in `a` and 0 in `b`
 
 ### Bytes
 
-#### to_int
+#### to\_int
 ```
 Bytes.to_int(b : bytes(n)) : int
 ```
@@ -323,7 +393,7 @@ Bytes.to_int(b : bytes(n)) : int
 Interprets the byte array as a big endian integer
 
 
-#### to_str
+#### to\_str
 ```
 Bytes.to_str(b : bytes(n)) : string
 ```
@@ -336,7 +406,8 @@ Returns the hexadecimal representation of the byte array
 Bytes.concat : (a : bytes(m), b : bytes(n)) => bytes(m + n)
 ```
 
-Concatenates two byte arrays
+Concatenates two byte arrays. If `m` and `n` are known at compile time, the
+result can be used as a fixed size byte array, otherwise it has type `bytes()`.
 
 
 #### split
@@ -346,6 +417,38 @@ Bytes.split(a : bytes(m + n)) : bytes(m) * bytes(n)
 
 Splits a byte array at given index
 
+#### split\_any
+```
+Bytes.split_any(a : bytes(), at : int) : option(bytes() * bytes(n))
+```
+
+Splits an arbitrary size byte array at index `at`. If `at` is positive split
+from the beginning of the array, if `at` is negative, split `abs(at)` from the
+_end_ of the array. If the array is shorter than `abs(at)` then `None` is
+returned.
+
+#### to\_fixed\_size
+```
+Bytes.to_fixed_size(a : bytes()) : option(bytes(n))
+```
+
+Converts an arbitrary size byte array to a fix size byte array. If `a` is
+not `n` bytes, `None` is returned.
+
+#### to\_any\_size
+```
+Bytes.to_any_size(a : bytes(n)) : bytes()
+```
+
+Converts a fixed size byte array to an arbitrary size byte array. This is a
+no-op at run-time, and only used during type checking.
+
+#### size
+```
+Bytes.size(a : bytes()) : int
+```
+
+Computes the lenght/size of a byte array.
 
 ### Call
 
@@ -381,6 +484,12 @@ Call.gas_price : int
 
 The gas price of the current call.
 
+#### mulmod
+```
+Int.mulmod : (a : int, b : int, q : int) : int
+```
+
+Combined multiplication and modulus, returns `(a * b) mod q`.
 
 #### fee
 ```
@@ -469,39 +578,6 @@ Chain.block_height : int"
 
 The height of the current block (i.e. the block in which the current call will be included).
 
-
-##### coinbase
-```
-Chain.coinbase : address
-```
-
-The address of the account that mined the current block.
-
-
-##### timestamp
-```
-Chain.timestamp : int
-```
-
-The timestamp of the current block (unix time, milliseconds).
-
-
-##### difficulty
-```
-Chain.difficulty : int
-```
-
-The difficulty of the current block.
-
-
-##### gas
-```
-Chain.gas_limit : int
-```
-
-The gas limit of the current block.
-
-
 ##### bytecode_hash
 ```
 Chain.bytecode_hash : 'c => option(hash)
@@ -538,7 +614,6 @@ charging the calling contract. Note that this won't be visible in `Call.value`
 in the `init` call of the new contract. It will be included in
 `Contract.balance`, however.
 
-
 The type `'c` must be instantiated with a contract.
 
 
@@ -565,6 +640,7 @@ main contract Market =
 The typechecker must be certain about the created contract's type, so it is
 worth writing it explicitly as shown in the example.
 
+
 ##### clone
 ```
 Chain.clone : ( ref : 'c, gas : int, value : int, protected : bool, ...
@@ -603,8 +679,8 @@ Example usage:
 ```
 payable contract interface Auction =
   entrypoint init : (int, string) => void
-  stateful payable entrypoint buy : (int) => ()
-  stateful entrypoint sell : (int) => ()
+  stateful payable entrypoint buy : (int) => unit
+  stateful entrypoint sell : (int) => unit
 
 main contract Market =
   type state = list(Auction)
@@ -623,11 +699,71 @@ implementation of the `init` function does not actually return `state`, but
 calls `put` instead. Moreover, FATE prevents even handcrafted calls to `init`.
 
 
+##### coinbase
+```
+Chain.coinbase : address
+```
+
+The address of the account that mined the current block.
+
+
+##### difficulty
+```
+Chain.difficulty : int
+```
+
+The difficulty of the current block.
+
+
 ##### event
 ```
 Chain.event(e : event) : unit
 ```
-Emits the event. To use this function one needs to define the `event` type as a `datatype` in the contract.
+
+Emits the event. To use this function one needs to define the `event` type as a
+`datatype` in the contract.
+
+
+##### gas\_limit
+```
+Chain.gas_limit : int
+```
+
+The gas limit of the current block.
+
+
+##### network\_id
+```
+Chain.network\_id : string
+```
+
+The network id of the chain.
+
+
+#### poseidon
+```
+Crypto.poseidon(x1 : int, x2 : int) : int
+```
+
+Hash two integers (in the scalar field of BLS12-381) to another integer (in the scalar
+field of BLS12-281). This is a ZK/SNARK-friendly hash function.
+
+
+##### spend
+```
+Chain.spend(to : address, amount : int) : unit
+```
+
+Spend `amount` tokens to `to`. Will fail (and abort the contract) if contract
+doesn't have `amount` tokens to transfer, or, if `to` is not `payable`.
+
+
+##### timestamp
+```
+Chain.timestamp : int
+```
+
+The timestamp of the current block (unix time, milliseconds).
 
 
 ### Char
@@ -705,11 +841,14 @@ Hash any object to blake2b
 
 #### verify_sig
 ```
-Crypto.verify_sig(msg : hash, pubkey : address, sig : signature) : bool
+Crypto.verify_sig(msg : bytes(), pubkey : address, sig : signature) : bool
 ```
 
 Checks if the signature of `msg` was made using private key corresponding to
-the `pubkey`
+the `pubkey`.
+
+Note: before v8 of the compiler, `msg` had type `hash` (i.e. `bytes(32)`).
+
 
 #### ecverify_secp256k1
 ```
@@ -742,12 +881,21 @@ Verifies a standard 64-byte ECDSA signature (`R || S`).
 
 ### Int
 
-#### to_str
+#### to\_str
 ```
-Int.to_str : int => string
+Int.to_str(n : int) : string
 ```
 
-Casts integer to string using decimal representation
+Casts the integer to a string (in decimal representation).
+
+#### to\_bytes
+```
+Int.to_bytes(n : int, size : int) : bytes()
+```
+
+Casts the integer to a byte array with `size` bytes (big endian, truncating if
+necessary not preserving signedness). I.e. if you try to squeeze `-129` into a
+single byte that will be indistinguishable from `127`.
 
 
 ### Map
@@ -806,11 +954,11 @@ Oracle.register(<signature : bytes(64)>, acct : address, qfee : int, ttl : Chain
 Registers new oracle answering questions of type `'a` with answers of type `'b`.
 
 * The `acct` is the address of the oracle to register (can be the same as the contract).
-* `signature` is a signature proving that the contract is allowed to register the account -
-  the `network id` + `account address` + `contract address` (concatenated as byte arrays) is
-  [signed](./sophia_features.md#delegation-signature) with the
-  private key of the account, proving you have the private key of the oracle to be. If the
-  address is the same as the contract `sign` is ignored and can be left out entirely.
+* The [signature](./sophia_features.md#delegation-signature) should be a
+  serialized structure containing `network id`, `account address`, and
+  `contract address`. Using the private key of `account address` for signing.
+  Proving you have the private key of the oracle to be. If the address is the same
+  as the contract `sign` is ignored and can be left out entirely.
 * The `qfee` is the minimum query fee to be paid by a user when asking a question of the oracle.
 * The `ttl` is the Time To Live for the oracle in key blocks, either relative to the current
   key block height (`RelativeTTL(delta)`) or a fixed key block height (`FixedTTL(height)`).
@@ -824,7 +972,7 @@ Examples:
 ```
 
 
-#### get_question
+#### get\_question
 ```
 Oracle.get_question(o : oracle('a, 'b), q : oracle_query('a, 'b)) : 'a
 ```
@@ -837,12 +985,11 @@ Checks what was the question of query `q` on oracle `o`
 Oracle.respond(<signature : bytes(64)>, o : oracle('a, 'b), q : oracle_query('a, 'b), 'b) : unit
 ```
 
-Responds to the question `q` on `o`.
-Unless the contract address is the same as the oracle address the `signature`
-(which is an optional, named argument)
+Responds to the question `q` on `o`.  Unless the contract address is the same
+as the oracle address the `signature` (which is an optional, named argument)
 needs to be provided. Proving that we have the private key of the oracle by
-[signing](./sophia_features.md#delegation-signature)
-the `network id` + `oracle query id` + `contract address`
+[signing](./sophia_features.md#delegation-signature) should be a serialized
+structure containing `network id`, `oracle query id`, and `contract address`.
 
 
 #### extend
@@ -855,7 +1002,7 @@ Extends TTL of an oracle.
 * `o` is the oracle being extended
 * `ttl` must be `RelativeTTL`. The time to live of `o` will be extended by this value.
 
-#### query_fee
+#### query\_fee
 ```
 Oracle.query_fee(o : oracle('a, 'b)) : int
 ```
@@ -876,7 +1023,7 @@ Asks the oracle a question.
 The call fails if the oracle could expire before an answer.
 
 
-#### get_answer
+#### get\_answer
 ```
 Oracle.get_answer(o : oracle('a, 'b), q : oracle_query('a, 'b)) : option('b)
 ```
@@ -914,88 +1061,21 @@ It returns `true` iff the oracle query exist and has the expected type.
 These need to be explicitly included (with `.aes` suffix)
 
 
-### Bitwise
+### AENSCompat
 
-Bitwise operations on arbitrary precision integers.
-
-#### bsr
+#### pointee\_to\_V2
 ```
-Bitwise.bsr(n : int, x : int) : int
+AENSCompat.pointee_to_V2(p : AENS.pointee) : AENSv2.pointee
 ```
 
-Logical bit shift `x` right `n` positions.
+Translate old pointee format to new, this is always possible.
 
-
-#### bsl
+#### pointee\_from\_V2
 ```
-Bitwise.bsl(n : int, x : int) : int
+AENSCompat.pointee_from_V2(p2 : AENSv2.pointee) : option(AENS.pointee)
 ```
 
-Logical bit shift `x` left `n` positions.
-
-
-#### bsli
-```
-Bitwise.bsli(n : int, x : int, lim : int) : int
-```
-
-Logical bit shift `x` left `n` positions, limit to `lim` bits.
-
-
-#### band
-```
-Bitwise.band(x : int, y : int) : int
-```
-
-Bitwise `and` of `x` and `y`.
-
-
-#### bor
-```
-Bitwise.bor(x : int, y : int) : int
-```
-
-Bitwise `or` of `x` and `y`.
-
-
-#### bxor
-```
-Bitwise.bxor(x : int, y : int) : int
-```
-
-Bitwise `xor` of `x` and `y`.
-
-
-#### bnot
-```
-Bitwise.bnot(x : int) : int
-```
-
-Bitwise `not` of `x`. Defined and implemented as `bnot(x) = bxor(x, -1)`.
-
-
-#### uband
-```
-Bitwise.uband(x : int, y : int) : int
-```
-
-Bitwise `and` of _non-negative_ numbers `x` and `y`.
-
-
-#### ubor
-```
-Bitwise.ubor(x : int, y : int) : int
-```
-
-Bitwise `or` of _non-negative_ `x` and `y`.
-
-
-#### ubxor
-```
-Bitwise.ubxor(x : int, y : int) : int
-```
-
-Bitwise `xor` of _non-negative_ `x` and `y`.
+Translate new pointee format to old, `DataPt` can't be translated, so `None` is returned in this case.
 
 
 ### BLS12\_381
@@ -2391,6 +2471,15 @@ to_int(s : string) : option(int)
 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.
 
+#### to\_bytes
+```
+to_bytes(s : string) : bytes()
+```
+
+Converts string into byte array. String is UTF-8 encoded. I.e.
+`String.length(s)` is not guaranteed to be equal to
+`Bytes.size(String.to_bytes(s))`.
+
 #### sha3
 ```
 sha3(s : string) : hash

docs/sophia_syntax.md

@@ -30,6 +30,7 @@ interface main using as for hiding
 - `ContractAddress` base58-encoded 32 byte contract address with `ct_` prefix
 - `OracleAddress` base58-encoded 32 byte oracle address with `ok_` prefix
 - `OracleQueryId` base58-encoded 32 byte oracle query id with `oq_` prefix
+- `Signature` base58-encoded 64 byte cryptographic signature with `sg_` prefix
 
 Valid string escape codes are
 
@@ -239,6 +240,7 @@ Expr ::= '(' LamArgs ')' '=>' Block(Stmt)   // Anonymous function    (x) => x +
        | Int | Bytes | String | Char        // Literals              123, 0xff, #00abc123, "foo", '%'
        | AccountAddress | ContractAddress   // Chain identifiers
        | OracleAddress | OracleQueryId      // Chain identifiers
+       | Signature                          // Signature
        | '???'                              // Hole expression       1 + ???
 
 Generator ::= Pattern '<-' Expr   // Generator
@@ -256,8 +258,8 @@ Path ::= Id                 // Record field
 
 BinOp ::= '||' | '&&' | '<' | '>' | '=<' | '>=' | '==' | '!='
         | '::' | '++' | '+' | '-' | '*' | '/' | 'mod' | '^'
-        | '|>'
-UnOp  ::= '-' | '!'
+        | 'band' | 'bor' | 'bxor' | '<<' | '>>' | '|>'
+UnOp  ::= '-' | '!' | 'bnot'
 ```
 
 ## Operators types
@@ -265,10 +267,11 @@ UnOp  ::= '-' | '!'
 | Operators | Type
 | --- | ---
 | `-` `+` `*` `/` `mod` `^` | arithmetic operators
-| `!` `&&` `||` | logical operators
+| `!` `&&` `\|\|` | logical operators
+| `band` `bor` `bxor` `bnot` `<<` `>>` | bitwise operators
 | `==` `!=` `<` `>` `=<` `>=` | comparison operators
 | `::` `++` | list operators
-| `|>` | functional operators
+| `\|>` | functional operators
 
 ## Operator precedence
 
@@ -276,13 +279,17 @@ In order of highest to lowest precedence.
 
 | Operators | Associativity
 | --- | ---
-| `!` | right
+| `!` `bnot`| right
 | `^` | left
 | `*` `/` `mod` | left
 | `-` (unary) | right
 | `+` `-` | left
+| `<<` `>>` | left
 | `::` `++` | right
 | `<` `>` `=<` `>=` `==` `!=` | none
+| `band` | left
+| `bxor` | left
+| `bor` | left
 | `&&` | right
-| `||` | right
-| `|>` | left
+| `\|\|` | right
+| `\|>` | left

priv/stdlib/AENSCompat.aes

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

priv/stdlib/Bitwise.aes

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

priv/stdlib/List.aes

@@ -282,9 +282,9 @@ namespace List =
   private function
     asc : (('a, 'a) => bool, 'a, list('a), list('a)) => list(list('a))
     asc(lt, x, acc, h::t) =
-      if(lt(h, x)) List.reverse(x::acc) :: monotonic_subs(lt, h::t)
+      if(lt(h, x)) reverse(x::acc) :: monotonic_subs(lt, h::t)
       else asc(lt, h, x::acc, t)
-    asc(_, x, acc, []) = [List.reverse(x::acc)]
+    asc(_, x, acc, []) = [reverse(x::acc)]
 
   /** Merges list of sorted lists
    */

priv/stdlib/String.aes

@@ -1,5 +1,8 @@
 include "List.aes"
 namespace String =
+  // Gives a bytes() representation of the string
+  function to_bytes(s : string) : bytes() = StringInternal.to_bytes(s)
+
   // Computes the SHA3/Keccak hash of the string
   function sha3(s : string) : hash    = StringInternal.sha3(s)
   // Computes the SHA256 hash of the string.

rebar.config

@@ -2,8 +2,7 @@
 
 {erl_opts, [debug_info]}.
 
-{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git", {tag, "v3.2.0"}}}
-       , {getopt, "1.0.1"}
+{deps, [ {aebytecode, {git, "https://github.com/aeternity/aebytecode.git", {tag, "v3.4.1"}}}
        , {eblake2, "1.0.0"}
        , {jsx, {git, "https://github.com/talentdeficit/jsx.git", {tag, "2.8.0"}}}
        ]}.
@@ -14,8 +13,8 @@
             {base_plt_apps, [erts, kernel, stdlib, crypto, mnesia]}
            ]}.
 
-{relx, [{release, {aesophia, "7.1.0"},
-         [aesophia, aebytecode, getopt]},
+{relx, [{release, {aesophia, "8.0.1"},
+         [aesophia, aebytecode]},
 
         {dev_mode, true},
         {include_erts, false},

rebar.lock

@@ -1,11 +1,11 @@
 {"1.2.0",
 [{<<"aebytecode">>,
   {git,"https://github.com/aeternity/aebytecode.git",
-       {ref,"2a0a397afad6b45da52572170f718194018bf33c"}},
+       {ref,"6bd6f82c70d800950ea1a2c70c364a4181ff5291"}},
   0},
  {<<"aeserialization">>,
   {git,"https://github.com/aeternity/aeserialization.git",
-       {ref,"eb68fe331bd476910394966b7f5ede7a74d37e35"}},
+       {ref,"b26e6d105424748ba1c27917267b7cff07f37802"}},
   1},
  {<<"base58">>,
   {git,"https://github.com/aeternity/erl-base58.git",
@@ -14,9 +14,9 @@
  {<<"eblake2">>,{pkg,<<"eblake2">>,<<"1.0.0">>},0},
  {<<"enacl">>,
   {git,"https://github.com/aeternity/enacl.git",
-       {ref,"793ddb502f7fe081302e1c42227dca70b09f8e17"}},
+       {ref,"4eb7ec70084ba7c87b1af8797c4c4e90c84f95a2"}},
   2},
- {<<"getopt">>,{pkg,<<"getopt">>,<<"1.0.1">>},0},
+ {<<"getopt">>,{pkg,<<"getopt">>,<<"1.0.1">>},1},
  {<<"jsx">>,
   {git,"https://github.com/talentdeficit/jsx.git",
        {ref,"3074d4865b3385a050badf7828ad31490d860df5"}},

src/aeso_aci.erl

@@ -8,6 +8,7 @@
 %%%-------------------------------------------------------------------
 
 -module(aeso_aci).
+-vsn("8.0.1").
 
 -export([ file/2
         , file/3
@@ -198,7 +199,8 @@ encode_expr({bytes, _, 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 == contract_pubkey; Lit == account_pubkey;
+                              Lit == signature ->
     aeser_api_encoder:encode(Lit, L);
 encode_expr({app, _, {'-', _}, [{int, _, N}]}) ->
   encode_expr({int, [], -N});
@@ -221,16 +223,41 @@ do_render_aci_json(Json) ->
         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
+            JText when is_binary(JText)  -> decode(JText)
         end,
     DecodedContracts = [ decode_contract(C) || C <- Contracts ],
     {ok, list_to_binary(string:join(DecodedContracts, "\n"))}.
 
+
+decode(JSON) ->
+    case code:is_loaded(jsx) of
+        {file, _} ->
+            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;
+        false ->
+            case zj:binary_decode(JSON) of
+                {ok, Decoded} when is_list(Decoded) -> atomize(Decoded);
+                {ok, Decoded} when is_map(Decoded)  -> [atomize(Decoded)];
+                _                                   -> error(bad_aci_json)
+            end
+    end.
+
+atomize(T) when is_map(T) ->
+    maps:fold(fun atomize/3, #{}, T);
+atomize(T) when is_list(T) ->
+    lists:map(fun atomize/1, T);
+atomize(T) ->
+    T.
+
+atomize(K, V, M) when is_binary(K) ->
+    maps:put(binary_to_atom(K), atomize(V), M);
+atomize(K, V, M) ->
+    maps:put(K, V, M).
+
+
 decode_contract(#{contract := #{name := Name,
                                 kind := Kind,
                                 payable := Payable,
@@ -282,6 +309,8 @@ decode_type(#{list := [Et]}) ->
 decode_type(#{map := Ets}) ->
     Ts = decode_types(Ets),
     ["map",$(,lists:join(",", Ts),$)];
+decode_type(#{bytes := any}) ->
+    ["bytes()"];
 decode_type(#{bytes := Len}) ->
     ["bytes(", integer_to_list(Len), ")"];
 decode_type(#{variant := Ets}) ->

src/aeso_ast.erl

@@ -0,0 +1,28 @@
+-module(aeso_ast).
+-vsn("8.0.1").
+
+-export([int/2,
+         line/1,
+         pp/1,
+         pp_typed/1,
+         symbol/2,
+         symbol_name/1
+        ]).
+
+
+symbol(Line, Chars) -> {symbol, Line, Chars}.
+int(Line, Int) -> {'Int', Line, Int}.
+
+line({symbol, Line, _}) -> Line.
+
+symbol_name({symbol, _, Name}) -> Name.
+
+pp(Ast) ->
+    String = prettypr:format(aeso_pretty:decls(Ast, [])),
+    io:format("Ast:\n~s\n", [String]).
+
+pp_typed(TypedAst) ->
+    %% io:format("Typed tree:\n~p\n",[TypedAst]),
+    String = prettypr:format(aeso_pretty:decls(TypedAst, [show_generated])),
+    io:format("Type ast:\n~s\n",[String]).
+

src/aeso_compiler.erl

@@ -7,11 +7,14 @@
 %%% Created : 12 Dec 2017
 %%%-------------------------------------------------------------------
 -module(aeso_compiler).
+-vsn("8.0.1").
 
 -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
@@ -25,7 +28,7 @@
         , validate_byte_code/3
         ]).
 
--include_lib("aebytecode/include/aeb_opcodes.hrl").
+-include("$aebytecode_include/aeb_opcodes.hrl").
 -include("aeso_utils.hrl").
 
 
@@ -40,6 +43,7 @@
                 | {include, {file_system, [string()]} |
                             {explicit_files, #{string() => binary()}}}
                 | {src_file, string()}
+                | {src_dir, string()}
                 | {aci, aeso_aci:aci_type()}.
 -type options() :: [option()].
 
@@ -85,7 +89,9 @@ file(Filename) ->
 file(File, Options0) ->
     Options = add_include_path(File, Options0),
     case read_contract(File) of
-        {ok, Bin} -> from_string(Bin, [{src_file, File} | Options]);
+        {ok, Bin} ->
+            SrcDir = aeso_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, [aeso_errors:new(file_error, Msg)]}
@@ -97,7 +103,7 @@ add_include_path(File, Options) ->
         false ->
             Dir = filename:dirname(File),
             {ok, Cwd} = file:get_cwd(),
-            [{include, {file_system, [Cwd, Dir]}} | Options]
+            [{include, {file_system, [Cwd, aeso_utils:canonical_dir(Dir)]}} | Options]
     end.
 
 -spec from_string(binary() | string(), options()) -> {ok, map()} | {error, [aeso_errors:error()]}.
@@ -117,7 +123,7 @@ from_string1(ContractString, Options) ->
      , warnings := Warnings } = string_to_code(ContractString, Options),
     #{ child_con_env := ChildContracts } = FCodeEnv,
     SavedFreshNames = maps:get(saved_fresh_names, FCodeEnv, #{}),
-    {FateCode, VarsRegs} = aeso_fcode_to_fate:compile(ChildContracts, FCode, SavedFreshNames, Options),
+    FateCode = aeso_fcode_to_fate:compile(ChildContracts, FCode, SavedFreshNames, Options),
     pp_assembler(FateCode, Options),
     ByteCode = aeb_fate_code:serialize(FateCode, []),
     {ok, Version} = version(),
@@ -130,13 +136,7 @@ from_string1(ContractString, Options) ->
             payable => maps:get(payable, FCode),
             warnings => Warnings
            },
-    ResDbg = Res#{variables_registers => VarsRegs},
-    FinalRes =
-        case proplists:get_value(debug_info, Options, false) of
-            true  -> ResDbg;
-            false -> Res
-        end,
-    {ok, maybe_generate_aci(FinalRes, FoldedTypedAst, Options)}.
+    {ok, maybe_generate_aci(Res, FoldedTypedAst, Options)}.
 
 maybe_generate_aci(Result, FoldedTypedAst, Options) ->
     case proplists:get_value(aci, Options) of
@@ -188,30 +188,58 @@ check_call(Source, FunName, Args, Options) ->
     check_call1(Source, FunName, Args, Options).
 
 check_call1(ContractString0, FunName, Args, Options) ->
+    case add_extra_call(ContractString0, {call, FunName, Args}, Options) of
+        {ok, CallName, Code} ->
+            {def, _, _, FcodeArgs} = get_call_body(CallName, Code),
+            {ok, FunName, [ aeso_fcode_to_fate:term_to_fate(A) || A <- FcodeArgs ]};
+        Err = {error, _} ->
+            Err
+    end.
+
+add_extra_call(Contract0, Call, Options) ->
     try
         %% First check the contract without the __call function
         #{fcode := OrgFcode
         , fcode_env := #{child_con_env := ChildContracts}
-        , ast := Ast} = string_to_code(ContractString0, Options),
-        {FateCode, _} = aeso_fcode_to_fate:compile(ChildContracts, OrgFcode, #{}, []),
+        , ast := Ast} = string_to_code(Contract0, Options),
+        FateCode = aeso_fcode_to_fate:compile(ChildContracts, OrgFcode, #{}, []),
         %% collect all hashes and compute the first name without hash collision to
         SymbolHashes = maps:keys(aeb_fate_code:symbols(FateCode)),
         CallName = first_none_match(?CALL_NAME, SymbolHashes,
                                     lists:seq($1, $9) ++ lists:seq($A, $Z) ++ lists:seq($a, $z)),
-        ContractString = insert_call_function(Ast, ContractString0, CallName, FunName, Args),
-        #{fcode := Fcode} = string_to_code(ContractString, Options),
-        CallArgs = arguments_of_body(CallName, FunName, Fcode),
-
-        {ok, FunName, CallArgs}
+        Contract = insert_call_function(Ast, Contract0, CallName, Call),
+        {ok, CallName, string_to_code(Contract, Options)}
     catch
         throw:{error, Errors} -> {error, Errors}
     end.
 
-arguments_of_body(CallName, _FunName, Fcode) ->
+get_call_body(CallName, #{fcode := Fcode}) ->
     #{body := Body} = maps:get({entrypoint, list_to_binary(CallName)}, maps:get(functions, Fcode)),
-    {def, _FName, Args} = Body,
-    %% FName is either {entrypoint, list_to_binary(FunName)} or 'init'
-    [ aeso_fcode_to_fate:term_to_fate(A) || A <- Args ].
+    Body.
+
+encode_value(Contract0, Type, Value, Options) ->
+    case add_extra_call(Contract0, {value, Type, Value}, Options) of
+        {ok, CallName, Code} ->
+            Body = get_call_body(CallName, Code),
+            {ok, aeb_fate_encoding:serialize(aeso_fcode_to_fate:term_to_fate(Body))};
+        Err = {error, _} ->
+            Err
+    end.
+
+decode_value(Contract0, Type, FateValue, Options) ->
+    case add_extra_call(Contract0, {type, Type}, Options) of
+        {ok, CallName, Code} ->
+            #{ folded_typed_ast := TypedAst
+             , type_env         := TypeEnv} = Code,
+            {ok, _, Type0} = get_decode_type(CallName, TypedAst),
+            Type1 = aeso_ast_infer_types:unfold_types_in_type(TypeEnv, Type0,
+                                                              [ unfold_record_types
+                                                              , unfold_variant_types
+                                                              , 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);
@@ -224,14 +252,31 @@ first_none_match(CallName, Hashes, [Char|Chars]) ->
     end.
 
 %% Add the __call function to a contract.
--spec insert_call_function(aeso_syntax:ast(), string(), string(), string(), [string()]) -> string().
-insert_call_function(Ast, Code, Call, FunName, Args) ->
+-spec insert_call_function(aeso_syntax:ast(), string(), string(),
+                           {call, string(), [string()]} | {value, string(), string()} | {type, string()}) -> string().
+insert_call_function(Ast, Code, Call, {call, FunName, Args}) ->
     Ind = last_contract_indent(Ast),
     lists:flatten(
         [ Code,
           "\n\n",
           lists:duplicate(Ind, " "),
           "stateful entrypoint ", Call, "() = ", FunName, "(", string:join(Args, ","), ")\n"
+        ]);
+insert_call_function(Ast, Code, Call, {value, Type, Value}) ->
+    Ind = last_contract_indent(Ast),
+    lists:flatten(
+        [ Code,
+          "\n\n",
+          lists:duplicate(Ind, " "),
+          "entrypoint ", Call, "() : ", Type, " = ", Value, "\n"
+        ]);
+insert_call_function(Ast, Code, Call, {type, Type}) ->
+    Ind = last_contract_indent(Ast),
+    lists:flatten(
+        [ Code,
+          "\n\n",
+          lists:duplicate(Ind, " "),
+          "entrypoint ", Call, "(val : ", Type, ") : ", Type, " = val\n"
         ]).
 
 -spec insert_init_function(string(), options()) -> string().
@@ -270,26 +315,32 @@ to_sophia_value(ContractString, FunName, ok, Data, Options0) ->
     Options = [no_code | Options0],
     try
         Code = string_to_code(ContractString, Options),
-        #{ unfolded_typed_ast := TypedAst, type_env  := TypeEnv} = Code,
+        #{ folded_typed_ast := TypedAst, type_env := TypeEnv} = Code,
         {ok, _, Type0} = get_decode_type(FunName, TypedAst),
-        Type   = aeso_tc_type_unfolding:unfold_types_in_type(TypeEnv, Type0, [unfold_record_types, unfold_variant_types]),
+        Type = aeso_ast_infer_types:unfold_types_in_type(TypeEnv, Type0,
+                                                         [ unfold_record_types
+                                                         , unfold_variant_types
+                                                         , not_unfold_system_alias_types]),
 
-        try
-            {ok, aeso_vm_decode:from_fate(Type, aeb_fate_encoding:deserialize(Data))}
-        catch throw:cannot_translate_to_sophia ->
-                Type1 = prettypr:format(aeso_pretty:type(Type0)),
-                Msg = io_lib:format("Cannot translate FATE value ~p\n  of Sophia type ~s",
-                                    [aeb_fate_encoding:deserialize(Data), Type1]),
-                {error, [aeso_errors:new(data_error, Msg)]};
-              _:_ ->
-                Type1 = prettypr:format(aeso_pretty:type(Type0)),
-                Msg = io_lib:format("Failed to decode binary as type ~s", [Type1]),
-                {error, [aeso_errors:new(data_error, Msg)]}
-        end
+        fate_data_to_sophia_value(Type0, Type, Data)
     catch
         throw:{error, Errors} -> {error, Errors}
     end.
 
+fate_data_to_sophia_value(Type, UnfoldedType, FateData) ->
+    try
+        {ok, aeso_vm_decode:from_fate(UnfoldedType, aeb_fate_encoding:deserialize(FateData))}
+    catch throw:cannot_translate_to_sophia ->
+            Type1 = prettypr:format(aeso_pretty:type(Type)),
+            Msg = io_lib:format("Cannot translate FATE value ~p\n  of Sophia type ~s",
+                                [aeb_fate_encoding:deserialize(FateData), Type1]),
+            {error, [aeso_errors:new(data_error, Msg)]};
+          _:_ ->
+            Type1 = prettypr:format(aeso_pretty:type(Type)),
+            Msg = io_lib:format("Failed to decode binary as type ~s", [Type1]),
+            {error, [aeso_errors:new(data_error, Msg)]}
+    end.
+
 -spec create_calldata(string(), string(), [string()]) ->
           {ok, binary()} | {error, [aeso_errors:error()]}.
 create_calldata(Code, Fun, Args) ->
@@ -316,14 +367,17 @@ decode_calldata(ContractString, FunName, Calldata, Options0) ->
     Options = [no_code | Options0],
     try
         Code = string_to_code(ContractString, Options),
-        #{ unfolded_typed_ast := TypedAst, type_env  := TypeEnv} = Code,
+        #{ 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          = aeso_tc_type_unfolding:unfold_types_in_type(TypeEnv, Type0, [unfold_record_types, unfold_variant_types]),
+        Type          = aeso_ast_infer_types:unfold_types_in_type(TypeEnv, Type0,
+                                                                  [ unfold_record_types
+                                                                  , unfold_variant_types
+                                                                  , not_unfold_system_alias_types]),
         case aeb_fate_abi:decode_calldata(FunName, Calldata) of
             {ok, FateArgs} ->
                 try

src/aeso_errors.erl

@@ -6,6 +6,7 @@
 %%%-------------------------------------------------------------------
 
 -module(aeso_errors).
+-vsn("8.0.1").
 
 -type src_file()   :: no_file | iolist().
 

src/aeso_fcode_to_fate.erl

@@ -8,6 +8,7 @@
 %%%
 %%%-------------------------------------------------------------------
 -module(aeso_fcode_to_fate).
+-vsn("8.0.1").
 
 -export([compile/3, compile/4, term_to_fate/1, term_to_fate/2]).
 
@@ -52,7 +53,8 @@
                tailpos           = true,
                child_contracts   = #{},
                saved_fresh_names = #{},
-               options           = [] }).
+               options           = [],
+               debug_info        = false }).
 
 %% -- Debugging --------------------------------------------------------------
 
@@ -81,24 +83,16 @@ code_error(Err) ->
 compile(FCode, SavedFreshNames, Options) ->
     compile(#{}, FCode, SavedFreshNames, Options).
 compile(ChildContracts, FCode, SavedFreshNames, Options) ->
-    try
-        compile1(ChildContracts, FCode, SavedFreshNames, Options)
-    after
-        put(variables_registers, undefined)
-    end.
-
-compile1(ChildContracts, FCode, SavedFreshNames, Options) ->
     #{ contract_name := ContractName,
        functions     := Functions } = FCode,
     SFuns  = functions_to_scode(ChildContracts, ContractName, Functions, SavedFreshNames, Options),
     SFuns1 = optimize_scode(SFuns, Options),
     FateCode = to_basic_blocks(SFuns1),
     ?debug(compile, Options, "~s\n", [aeb_fate_asm:pp(FateCode)]),
-    FateCode1 = case proplists:get_value(include_child_contract_symbols, Options, false) of
-                    false -> FateCode;
-                    true -> add_child_symbols(ChildContracts, FateCode)
-                end,
-    {FateCode1, get_variables_registers()}.
+    case proplists:get_value(include_child_contract_symbols, Options, false) of
+        false -> FateCode;
+        true  -> add_child_symbols(ChildContracts, FateCode)
+    end.
 
 make_function_id(X) ->
     aeb_fate_code:symbol_identifier(make_function_name(X)).
@@ -123,31 +117,15 @@ functions_to_scode(ChildContracts, ContractName, Functions, SavedFreshNames, Opt
 
 function_to_scode(ChildContracts, ContractName, Functions, Name, Attrs0, Args, Body, ResType, SavedFreshNames, Options) ->
     {ArgTypes, ResType1} = typesig_to_scode(Args, ResType),
-    Attrs = Attrs0 -- [stateful], %% Only track private and payable from here.
+    Attrs = [ A || A <- Attrs0, A == private orelse A == payable ],
     Env = init_env(ChildContracts, ContractName, Functions, Name, Args, SavedFreshNames, Options),
-    [ add_variables_register(Env, Arg, Register) ||
-        proplists:get_value(debug_info, Options, false),
-        {Arg, Register} <- Env#env.vars ],
+    ArgsNames = [ X || {X, _} <- lists:reverse(Env#env.vars) ],
+
+    %% DBG_LOC is added before the function body to make it possible to break
+    %% at the function signature
     SCode = to_scode(Env, Body),
-    {Attrs, {ArgTypes, ResType1}, SCode}.
-
-get_variables_registers() ->
-    case get(variables_registers) of
-        undefined -> #{};
-        Vs        -> Vs
-    end.
-
-add_variables_register(Env = #env{saved_fresh_names = SavedFreshNames}, Name, Register) ->
-    Olds = get_variables_registers(),
-    RealName = maps:get(Name, SavedFreshNames, Name),
-    FunName =
-        case Env#env.current_function of
-            event -> "Chain.event";
-            {entrypoint, BinName} -> binary_to_list(BinName);
-            {local_fun, QualName} -> lists:last(QualName)
-        end,
-    New = {Env#env.contract, FunName, RealName},
-    put(variables_registers, Olds#{New => Register}).
+    DbgSCode = dbg_contract(Env) ++ dbg_loc(Env, Attrs0) ++ dbg_scoped_vars(Env, ArgsNames, SCode),
+    {Attrs, {ArgTypes, ResType1}, DbgSCode}.
 
 -define(tvars, '$tvars').
 
@@ -194,20 +172,20 @@ types_to_scode(Ts) -> lists:map(fun type_to_scode/1, Ts).
 %% -- Environment functions --
 
 init_env(ChildContracts, ContractName, FunNames, Name, Args, SavedFreshNames, Options) ->
-    #env{ vars      = [ {X, {arg, I}} || {I, {X, _}} <- with_ixs(Args) ],
-          contract  = ContractName,
-          child_contracts = ChildContracts,
-          locals    = FunNames,
-          current_function = Name,
-          options = Options,
-          tailpos   = true,
-          saved_fresh_names = SavedFreshNames }.
+    #env{ vars              = [ {X, {arg, I}} || {I, {X, _}} <- with_ixs(Args) ],
+          contract          = ContractName,
+          child_contracts   = ChildContracts,
+          locals            = FunNames,
+          current_function  = Name,
+          options           = Options,
+          tailpos           = true,
+          saved_fresh_names = SavedFreshNames,
+          debug_info        = proplists:get_value(debug_info, Options, false) }.
 
 next_var(#env{ vars = Vars }) ->
     1 + lists:max([-1 | [J || {_, {var, J}} <- Vars]]).
 
 bind_var(Name, Var, Env = #env{ vars = Vars }) ->
-    proplists:get_value(debug_info, Env#env.options, false) andalso add_variables_register(Env, Name, Var),
     Env#env{ vars = [{Name, Var} | Vars] }.
 
 bind_local(Name, Env) ->
@@ -234,7 +212,7 @@ serialize_contract_code(Env, C) ->
             Options = Env#env.options,
             SavedFreshNames = Env#env.saved_fresh_names,
             FCode = maps:get(C, Env#env.child_contracts),
-            {FateCode, _} = compile1(Env#env.child_contracts, FCode, SavedFreshNames, Options),
+            FateCode = compile(Env#env.child_contracts, FCode, SavedFreshNames, Options),
             ByteCode = aeb_fate_code:serialize(FateCode, []),
             {ok, Version} = aeso_compiler:version(),
             OriginalSourceCode = proplists:get_value(original_src, Options, ""),
@@ -258,6 +236,7 @@ lit_to_fate(Env, L) ->
         {bytes, B}           -> aeb_fate_data:make_bytes(B);
         {bool, B}            -> aeb_fate_data:make_boolean(B);
         {account_pubkey, K}  -> aeb_fate_data:make_address(K);
+        {signature, S}       -> aeb_fate_data:make_bytes(S);
         {contract_pubkey, K} -> aeb_fate_data:make_contract(K);
         {oracle_pubkey, K}   -> aeb_fate_data:make_oracle(K);
         {oracle_query_id, H} -> aeb_fate_data:make_oracle_query(H);
@@ -268,97 +247,106 @@ lit_to_fate(Env, L) ->
 term_to_fate(E) -> term_to_fate(#env{}, #{}, E).
 term_to_fate(GlobEnv, E) -> term_to_fate(GlobEnv, #{}, E).
 
-term_to_fate(GlobEnv, _Env, {lit, L}) ->
+term_to_fate(GlobEnv, _Env, {lit, _, L}) ->
     lit_to_fate(GlobEnv, L);
 %% negative literals are parsed as 0 - N
-term_to_fate(_GlobEnv, _Env, {op, '-', [{lit, {int, 0}}, {lit, {int, N}}]}) ->
+term_to_fate(_GlobEnv, _Env, {op, _, '-', [{lit, _, {int, 0}}, {lit, _, {int, N}}]}) ->
     aeb_fate_data:make_integer(-N);
-term_to_fate(_GlobEnv, _Env, nil) ->
+term_to_fate(_GlobEnv, _Env, {nil, _}) ->
     aeb_fate_data:make_list([]);
-term_to_fate(GlobEnv, Env, {op, '::', [Hd, Tl]}) ->
+term_to_fate(GlobEnv, Env, {op, _, '::', [Hd, Tl]}) ->
     %% The Tl will translate into a list, because FATE lists are just lists
     [term_to_fate(GlobEnv, Env, Hd) | term_to_fate(GlobEnv, Env, Tl)];
-term_to_fate(GlobEnv, Env, {tuple, As}) ->
+term_to_fate(GlobEnv, Env, {tuple, _, As}) ->
     aeb_fate_data:make_tuple(list_to_tuple([ term_to_fate(GlobEnv, Env, A) || A<-As]));
-term_to_fate(GlobEnv, Env, {con, Ar, I, As}) ->
+term_to_fate(GlobEnv, Env, {con, _, Ar, I, As}) ->
     FateAs = [ term_to_fate(GlobEnv, Env, A) || A <- As ],
     aeb_fate_data:make_variant(Ar, I, list_to_tuple(FateAs));
-term_to_fate(_GlobEnv, _Env, {builtin, bits_all, []}) ->
+term_to_fate(_GlobEnv, _Env, {builtin, _, bits_all, []}) ->
     aeb_fate_data:make_bits(-1);
-term_to_fate(_GlobEnv, _Env, {builtin, bits_none, []}) ->
+term_to_fate(_GlobEnv, _Env, {builtin, _, bits_none, []}) ->
     aeb_fate_data:make_bits(0);
-term_to_fate(GlobEnv, _Env, {op, bits_set, [B, I]}) ->
+term_to_fate(GlobEnv, _Env, {op, _, bits_set, [B, I]}) ->
     {bits, N} = term_to_fate(GlobEnv, B),
     J         = term_to_fate(GlobEnv, I),
     {bits, N bor (1 bsl J)};
-term_to_fate(GlobEnv, _Env, {op, bits_clear, [B, I]}) ->
+term_to_fate(GlobEnv, _Env, {op, _, bits_clear, [B, I]}) ->
     {bits, N} = term_to_fate(GlobEnv, B),
     J         = term_to_fate(GlobEnv, I),
     {bits, N band bnot (1 bsl J)};
-term_to_fate(GlobEnv, Env, {'let', X, E, Body}) ->
+term_to_fate(GlobEnv, Env, {'let', _, X, E, Body}) ->
     Env1 = Env#{ X => term_to_fate(GlobEnv, Env, E) },
     term_to_fate(GlobEnv, Env1, Body);
-term_to_fate(_GlobEnv, Env, {var, X}) ->
+term_to_fate(_GlobEnv, Env, {var, _, X}) ->
     case maps:get(X, Env, undefined) of
         undefined -> throw(not_a_fate_value);
         V         -> V
     end;
-term_to_fate(_GlobEnv, _Env, {builtin, map_empty, []}) ->
+term_to_fate(_GlobEnv, _Env, {builtin, _, map_empty, []}) ->
     aeb_fate_data:make_map(#{});
-term_to_fate(GlobEnv, Env, {op, map_set, [M, K, V]}) ->
+term_to_fate(GlobEnv, Env, {op, _, map_set, [M, K, V]}) ->
     Map = term_to_fate(GlobEnv, Env, M),
     Map#{term_to_fate(GlobEnv, Env, K) => term_to_fate(GlobEnv, Env, V)};
+term_to_fate(GlobEnv, Env, {builtin, _, bytes_to_any_size, [Bs]}) ->
+    term_to_fate(GlobEnv, Env, Bs);
 term_to_fate(_GlobEnv, _Env, _) ->
     throw(not_a_fate_value).
 
 to_scode(Env, T) ->
     try term_to_fate(Env, T) of
-        V -> [push(?i(V))]
+        V ->
+            FAnn = element(2, T),
+            [dbg_loc(Env, FAnn), push(?i(V))]
     catch throw:not_a_fate_value ->
         to_scode1(Env, T)
     end.
 
-to_scode1(Env, {lit, L}) ->
-    [push(?i(lit_to_fate(Env, L)))];
+to_scode1(Env, {lit, Ann, L}) ->
+    [ dbg_loc(Env, Ann), push(?i(lit_to_fate(Env, L))) ];
 
-to_scode1(_Env, nil) ->
-    [aeb_fate_ops:nil(?a)];
+to_scode1(Env, {nil, Ann}) ->
+    [ dbg_loc(Env, Ann), aeb_fate_ops:nil(?a) ];
 
-to_scode1(Env, {var, X}) ->
-    [push(lookup_var(Env, X))];
+to_scode1(Env, {var, Ann, X}) ->
+    [ dbg_loc(Env, Ann), push(lookup_var(Env, X)) ];
 
-to_scode1(Env, {con, Ar, I, As}) ->
+to_scode1(Env, {con, Ann, Ar, I, As}) ->
     N = length(As),
-    [[to_scode(notail(Env), A) || A <- As],
-     aeb_fate_ops:variant(?a, ?i(Ar), ?i(I), ?i(N))];
+    [ dbg_loc(Env, Ann),
+      [to_scode(notail(Env), A) || A <- As],
+      aeb_fate_ops:variant(?a, ?i(Ar), ?i(I), ?i(N)) ];
 
-to_scode1(Env, {tuple, As}) ->
+to_scode1(Env, {tuple, Ann, As}) ->
     N = length(As),
-    [[ to_scode(notail(Env), A) || A <- As ],
-     tuple(N)];
+    [ dbg_loc(Env, Ann),
+      [ to_scode(notail(Env), A) || A <- As ],
+      tuple(N) ];
 
-to_scode1(Env, {proj, E, I}) ->
-    [to_scode(notail(Env), E),
-     aeb_fate_ops:element_op(?a, ?i(I), ?a)];
+to_scode1(Env, {proj, Ann, E, I}) ->
+    [ dbg_loc(Env, Ann),
+      to_scode(notail(Env), E),
+      aeb_fate_ops:element_op(?a, ?i(I), ?a) ];
 
-to_scode1(Env, {set_proj, R, I, E}) ->
-    [to_scode(notail(Env), E),
-     to_scode(notail(Env), R),
-     aeb_fate_ops:setelement(?a, ?i(I), ?a, ?a)];
+to_scode1(Env, {set_proj, Ann, R, I, E}) ->
+    [ dbg_loc(Env, Ann),
+      to_scode(notail(Env), E),
+      to_scode(notail(Env), R),
+      aeb_fate_ops:setelement(?a, ?i(I), ?a, ?a) ];
 
-to_scode1(Env, {op, Op, Args}) ->
-    call_to_scode(Env, op_to_scode(Op), Args);
+to_scode1(Env, {op, Ann, Op, Args}) ->
+    [ dbg_loc(Env, Ann) | call_to_scode(Env, op_to_scode(Op), Args) ];
 
-to_scode1(Env, {'let', X, {var, Y}, Body}) ->
+to_scode1(Env, {'let', Ann, X, {var, _, Y}, Body}) ->
     Env1 = bind_var(X, lookup_var(Env, Y), Env),
-    to_scode(Env1, Body);
-to_scode1(Env, {'let', X, Expr, Body}) ->
+    [ dbg_loc(Env, Ann) | dbg_scoped_vars(Env1, [X], to_scode(Env1, Body)) ];
+to_scode1(Env, {'let', Ann, X, Expr, Body}) ->
     {I, Env1} = bind_local(X, Env),
-    [ to_scode(notail(Env), Expr),
-      aeb_fate_ops:store({var, I}, {stack, 0}),
-      to_scode(Env1, Body) ];
+    SCode = [ to_scode(notail(Env), Expr),
+              aeb_fate_ops:store({var, I}, {stack, 0}),
+              to_scode(Env1, Body) ],
+    [ dbg_loc(Env, Ann) | dbg_scoped_vars(Env1, [X], SCode) ];
 
-to_scode1(Env = #env{ current_function = Fun, tailpos = true }, {def, Fun, Args}) ->
+to_scode1(Env = #env{ current_function = Fun, tailpos = true, debug_info = false }, {def, Ann, Fun, Args}) ->
     %% Tail-call to current function, f(e0..en). Compile to
     %%      [ let xi = ei ]
     %%      [ STORE argi xi ]
@@ -371,61 +359,62 @@ to_scode1(Env = #env{ current_function = Fun, tailpos = true }, {def, Fun, Args}
                                 aeb_fate_ops:store({var, I}, ?a)],
                         {[I | Is], Acc1, Env2}
                     end, {[], [], Env}, Args),
-    [ Code,
+    [ dbg_loc(Env, Ann),
+      Code,
       [ aeb_fate_ops:store({arg, I}, {var, J})
         || {I, J} <- lists:zip(lists:seq(0, length(Vars) - 1),
                                lists:reverse(Vars)) ],
       loop ];
-to_scode1(Env, {def, Fun, Args}) ->
+to_scode1(Env, {def, Ann, Fun, Args}) ->
     FName = make_function_id(Fun),
     Lbl   = aeb_fate_data:make_string(FName),
-    call_to_scode(Env, local_call(Env, ?i(Lbl)), Args);
-to_scode1(Env, {funcall, Fun, Args}) ->
-    call_to_scode(Env, [to_scode(Env, Fun), local_call(Env, ?a)], Args);
+    [ dbg_loc(Env, Ann) | call_to_scode(Env, local_call(Env, ?i(Lbl)), Args) ];
+to_scode1(Env, {funcall, Ann, Fun, Args}) ->
+    [ dbg_loc(Env, Ann) | call_to_scode(Env, [to_scode(Env, Fun), local_call(Env, ?a)], Args) ];
 
-to_scode1(Env, {builtin, B, Args}) ->
-    builtin_to_scode(Env, B, Args);
+to_scode1(Env, {builtin, Ann, B, Args}) ->
+    [ dbg_loc(Env, Ann) | builtin_to_scode(Env, B, Args) ];
 
-to_scode1(Env, {remote, ArgsT, RetT, Ct, Fun, [Gas, Value, Protected | Args]}) ->
+to_scode1(Env, {remote, Ann, ArgsT, RetT, Ct, Fun, [Gas, Value, Protected | Args]}) ->
     Lbl = make_function_id(Fun),
     {ArgTypes, RetType0} = typesig_to_scode([{"_", T} || T <- ArgsT], RetT),
     ArgType = ?i(aeb_fate_data:make_typerep({tuple, ArgTypes})),
     RetType = ?i(aeb_fate_data:make_typerep(RetType0)),
-    case Protected of
-        {lit, {bool, false}} ->
+    SCode = case Protected of
+        {lit, _, {bool, false}} ->
             case Gas of
-                {builtin, call_gas_left, _} ->
+                {builtin, _, call_gas_left, _} ->
                     Call = aeb_fate_ops:call_r(?a, Lbl, ArgType, RetType, ?a),
                     call_to_scode(Env, Call, [Ct, Value | Args]);
                 _ ->
                     Call = aeb_fate_ops:call_gr(?a, Lbl, ArgType, RetType, ?a, ?a),
                     call_to_scode(Env, Call, [Ct, Value, Gas | Args])
             end;
-        {lit, {bool, true}} ->
+        {lit, _, {bool, true}} ->
             Call = aeb_fate_ops:call_pgr(?a, Lbl, ArgType, RetType, ?a, ?a, ?i(true)),
             call_to_scode(Env, Call, [Ct, Value, Gas | Args]);
         _ ->
             Call = aeb_fate_ops:call_pgr(?a, Lbl, ArgType, RetType, ?a, ?a, ?a),
             call_to_scode(Env, Call, [Ct, Value, Gas, Protected | Args])
-    end;
+    end,
+    [ dbg_loc(Env, Ann) | SCode ];
 
-to_scode1(_Env, {get_state, Reg}) ->
-    [push(?s(Reg))];
-to_scode1(Env, {set_state, Reg, Val}) ->
-    call_to_scode(Env, [{'STORE', ?s(Reg), ?a},
-                        tuple(0)], [Val]);
+to_scode1(Env, {get_state, Ann, Reg}) ->
+    [ dbg_loc(Env, Ann), push(?s(Reg)) ];
+to_scode1(Env, {set_state, Ann, Reg, Val}) ->
+    [ dbg_loc(Env, Ann) | call_to_scode(Env, [{'STORE', ?s(Reg), ?a}, tuple(0)], [Val]) ];
 
-to_scode1(Env, {closure, Fun, FVs}) ->
-    to_scode(Env, {tuple, [{lit, {string, make_function_id(Fun)}}, FVs]});
+to_scode1(Env, {closure, Ann, Fun, FVs}) ->
+    [ to_scode(Env, {tuple, Ann, [{lit, Ann, {string, make_function_id(Fun)}}, FVs]}) ];
 
-to_scode1(Env, {switch, Case}) ->
-    split_to_scode(Env, Case).
+to_scode1(Env, {switch, Ann, Case}) ->
+    [ dbg_loc(Env, Ann) | split_to_scode(Env, Case) ].
 
-local_call( Env, Fun) when Env#env.tailpos -> aeb_fate_ops:call_t(Fun);
-local_call(_Env, Fun)                      -> aeb_fate_ops:call(Fun).
+local_call( Env = #env{debug_info = false}, Fun) when Env#env.tailpos -> aeb_fate_ops:call_t(Fun);
+local_call(_Env, Fun)                                                 -> aeb_fate_ops:call(Fun).
 
-split_to_scode(Env, {nosplit, Expr}) ->
-    [switch_body, to_scode(Env, Expr)];
+split_to_scode(Env, {nosplit, Renames, Expr}) ->
+    [switch_body, dbg_scoped_vars(Env, Renames, to_scode(Env, Expr))];
 split_to_scode(Env, {split, {tuple, _}, X, Alts}) ->
     {Def, Alts1} = catchall_to_scode(Env, X, Alts),
     Arg = lookup_var(Env, X),
@@ -554,6 +543,14 @@ builtin_to_scode(Env, bytes_concat, [_, _] = Args) ->
     call_to_scode(Env, aeb_fate_ops:bytes_concat(?a, ?a, ?a), Args);
 builtin_to_scode(Env, bytes_split, [_, _] = Args) ->
     call_to_scode(Env, aeb_fate_ops:bytes_split(?a, ?a, ?a), Args);
+builtin_to_scode(Env, bytes_split_any, [_, _] = Args) ->
+    call_to_scode(Env, aeb_fate_ops:bytes_split_any(?a, ?a, ?a), Args);
+builtin_to_scode(Env, bytes_to_fixed_size, [_, _] = Args) ->
+    call_to_scode(Env, aeb_fate_ops:bytes_to_fixed_size(?a, ?a, ?a), Args);
+builtin_to_scode(Env, bytes_to_any_size, [A]) ->
+    [to_scode(Env, A)]; %% no_op!
+builtin_to_scode(Env, bytes_size, [_] = Args) ->
+    call_to_scode(Env, aeb_fate_ops:bytes_size(?a, ?a), Args);
 builtin_to_scode(Env, abort, [_] = Args) ->
     call_to_scode(Env, aeb_fate_ops:abort(?a), Args);
 builtin_to_scode(Env, exit, [_] = Args) ->
@@ -575,6 +572,8 @@ builtin_to_scode(_Env, chain_difficulty, []) ->
     [aeb_fate_ops:difficulty(?a)];
 builtin_to_scode(_Env, chain_gas_limit, []) ->
     [aeb_fate_ops:gaslimit(?a)];
+builtin_to_scode(_Env, chain_network_id, []) ->
+    [aeb_fate_ops:network_id(?a)];
 builtin_to_scode(_Env, contract_balance, []) ->
     [aeb_fate_ops:balance(?a)];
 builtin_to_scode(_Env, contract_address, []) ->
@@ -649,7 +648,7 @@ builtin_to_scode(Env, chain_bytecode_hash, [_Addr] = Args) ->
 builtin_to_scode(Env, chain_clone,
                  [InitArgsT, GasCap, Value, Prot, Contract | InitArgs]) ->
     case GasCap of
-        {builtin, call_gas_left, _} ->
+        {builtin, _, call_gas_left, _} ->
             call_to_scode(Env, aeb_fate_ops:clone(?a, ?a, ?a, ?a),
                           [Contract, InitArgsT, Value, Prot | InitArgs]
                          );
@@ -682,6 +681,12 @@ op_to_scode('>=')              -> aeb_fate_ops:egt(?a, ?a, ?a);
 op_to_scode('==')              -> aeb_fate_ops:eq(?a, ?a, ?a);
 op_to_scode('!=')              -> aeb_fate_ops:neq(?a, ?a, ?a);
 op_to_scode('!')               -> aeb_fate_ops:not_op(?a, ?a);
+op_to_scode('bnot')            -> aeb_fate_ops:bin_not(?a, ?a);
+op_to_scode('band')            -> aeb_fate_ops:bin_and(?a, ?a, ?a);
+op_to_scode('bor')             -> aeb_fate_ops:bin_or(?a, ?a, ?a);
+op_to_scode('bxor')            -> aeb_fate_ops:bin_xor(?a, ?a, ?a);
+op_to_scode('<<')              -> aeb_fate_ops:bin_sl(?a, ?a, ?a);
+op_to_scode('>>')              -> aeb_fate_ops:bin_sr(?a, ?a, ?a);
 op_to_scode(map_get)           -> aeb_fate_ops:map_lookup(?a, ?a, ?a);
 op_to_scode(map_get_d)         -> aeb_fate_ops:map_lookup(?a, ?a, ?a, ?a);
 op_to_scode(map_set)           -> aeb_fate_ops:map_update(?a, ?a, ?a, ?a);
@@ -692,6 +697,7 @@ op_to_scode(map_member)        -> aeb_fate_ops:map_member(?a, ?a, ?a);
 op_to_scode(map_size)          -> aeb_fate_ops:map_size_(?a, ?a);
 op_to_scode(stringinternal_length)    -> aeb_fate_ops:str_length(?a, ?a);
 op_to_scode(stringinternal_concat)    -> aeb_fate_ops:str_join(?a, ?a, ?a);
+op_to_scode(stringinternal_to_bytes)  -> aeb_fate_ops:str_to_bytes(?a, ?a);
 op_to_scode(stringinternal_to_list)   -> aeb_fate_ops:str_to_list(?a, ?a);
 op_to_scode(stringinternal_from_list) -> aeb_fate_ops:str_from_list(?a, ?a);
 op_to_scode(stringinternal_to_lower)  -> aeb_fate_ops:str_to_lower(?a, ?a);
@@ -706,7 +712,10 @@ op_to_scode(bits_intersection) -> aeb_fate_ops:bits_and(?a, ?a, ?a);
 op_to_scode(bits_union)        -> aeb_fate_ops:bits_or(?a, ?a, ?a);
 op_to_scode(bits_difference)   -> aeb_fate_ops:bits_diff(?a, ?a, ?a);
 op_to_scode(address_to_str)    -> aeb_fate_ops:addr_to_str(?a, ?a);
+op_to_scode(address_to_bytes)  -> aeb_fate_ops:addr_to_bytes(?a, ?a);
 op_to_scode(int_to_str)        -> aeb_fate_ops:int_to_str(?a, ?a);
+op_to_scode(int_to_bytes)      -> aeb_fate_ops:int_to_bytes(?a, ?a, ?a);
+op_to_scode(int_mulmod)        -> aeb_fate_ops:mulmod(?a, ?a, ?a, ?a);
 op_to_scode(contract_to_address)         -> aeb_fate_ops:contract_to_address(?a, ?a);
 op_to_scode(address_to_contract)         -> aeb_fate_ops:address_to_contract(?a, ?a);
 op_to_scode(crypto_verify_sig)           -> aeb_fate_ops:verify_sig(?a, ?a, ?a, ?a);
@@ -716,6 +725,7 @@ op_to_scode(crypto_ecrecover_secp256k1)  -> aeb_fate_ops:ecrecover_secp256k1(?a,
 op_to_scode(crypto_sha3)                 -> aeb_fate_ops:sha3(?a, ?a);
 op_to_scode(crypto_sha256)               -> aeb_fate_ops:sha256(?a, ?a);
 op_to_scode(crypto_blake2b)              -> aeb_fate_ops:blake2b(?a, ?a);
+op_to_scode(crypto_poseidon)             -> aeb_fate_ops:poseidon(?a, ?a, ?a);
 op_to_scode(stringinternal_sha3)         -> aeb_fate_ops:sha3(?a, ?a);
 op_to_scode(stringinternal_sha256)       -> aeb_fate_ops:sha256(?a, ?a);
 op_to_scode(stringinternal_blake2b)      -> aeb_fate_ops:blake2b(?a, ?a);
@@ -751,6 +761,77 @@ push(A) -> {'STORE', ?a, A}.
 tuple(0) -> push(?i({tuple, {}}));
 tuple(N) -> aeb_fate_ops:tuple(?a, N).
 
+%% -- Debug info functions --
+
+dbg_contract(#env{debug_info = false}) ->
+    [];
+dbg_contract(#env{contract = Contract}) ->
+    [{'DBG_CONTRACT', {immediate, Contract}}].
+
+dbg_loc(#env{debug_info = false}, _) ->
+    [];
+dbg_loc(_Env, Ann) ->
+    File = case proplists:get_value(file, Ann, no_file) of
+                no_file -> "";
+                F       -> F
+            end,
+    Line = proplists:get_value(line, Ann, undefined),
+    case Line of
+        undefined -> [];
+        _         -> [{'DBG_LOC', {immediate, File}, {immediate, Line}}]
+    end.
+
+dbg_scoped_vars(#env{debug_info = false}, _, SCode) ->
+    SCode;
+dbg_scoped_vars(_Env, [], SCode) ->
+    SCode;
+dbg_scoped_vars(Env, [{SavedVarName, Var} | Rest], SCode) ->
+    dbg_scoped_vars(Env, Rest, dbg_scoped_var(Env, SavedVarName, Var, SCode));
+dbg_scoped_vars(Env = #env{saved_fresh_names = SavedFreshNames}, [Var | Rest], SCode) ->
+    SavedVarName = maps:get(Var, SavedFreshNames, Var),
+    dbg_scoped_vars(Env, Rest, dbg_scoped_var(Env, SavedVarName, Var, SCode)).
+
+dbg_scoped_var(Env, SavedVarName, Var, SCode) ->
+    case SavedVarName == "_" orelse is_fresh_name(SavedVarName) of
+        true ->
+            SCode;
+        false ->
+            Register = lookup_var(Env, Var),
+            Def      = [{'DBG_DEF',   {immediate, SavedVarName}, Register}],
+            Undef    = [{'DBG_UNDEF', {immediate, SavedVarName}, Register}],
+            Def ++ dbg_undef(Undef, SCode)
+    end.
+
+is_fresh_name([$% | _]) ->
+    true;
+is_fresh_name(_) ->
+    false.
+
+dbg_undef(_Undef, missing) ->
+    missing;
+dbg_undef(Undef, loop) ->
+    [Undef, loop];
+dbg_undef(Undef, switch_body) ->
+    [switch_body, Undef];
+dbg_undef(Undef, {switch, Arg, Type, Alts, Catch}) ->
+    NewAlts   = [ dbg_undef(Undef, Alt) || Alt <- Alts ],
+    NewCatch  = dbg_undef(Undef, Catch),
+    NewSwitch = {switch, Arg, Type, NewAlts, NewCatch},
+    NewSwitch;
+dbg_undef(Undef, SCode) when is_list(SCode) ->
+    lists:droplast(SCode) ++ [dbg_undef(Undef, lists:last(SCode))];
+dbg_undef(Undef, SCode) when is_tuple(SCode); is_atom(SCode) ->
+    [Mnemonic | _] =
+        case is_tuple(SCode) of
+            true  -> tuple_to_list(SCode);
+            false -> [SCode]
+        end,
+    Op = aeb_fate_opcodes:m_to_op(Mnemonic),
+    case aeb_fate_opcodes:end_bb(Op) of
+        true  -> [Undef, SCode];
+        false -> [SCode, Undef]
+    end.
+
 %% -- Phase II ---------------------------------------------------------------
 %%  Optimize
 
@@ -886,6 +967,10 @@ attributes(I) ->
         loop                                  -> Impure(pc, []);
         switch_body                           -> Pure(none, []);
         'RETURN'                              -> Impure(pc, []);
+        {'DBG_LOC', _, _}                     -> Impure(none, []);
+        {'DBG_DEF', _, _}                     -> Impure(none, []);
+        {'DBG_UNDEF', _, _}                   -> Impure(none, []);
+        {'DBG_CONTRACT', _}                   -> Impure(none, []);
         {'RETURNR', A}                        -> Impure(pc, A);
         {'CALL', A}                           -> Impure(?a, [A]);
         {'CALL_R', A, _, B, C, D}             -> Impure(?a, [A, B, C, D]);
@@ -913,6 +998,13 @@ attributes(I) ->
         {'DIV', A, B, C}                      -> Pure(A, [B, C]);
         {'MOD', A, B, C}                      -> Pure(A, [B, C]);
         {'POW', A, B, C}                      -> Pure(A, [B, C]);
+        {'MULMOD', A, B, C, D}                -> Pure(A, [B, C, D]);
+        {'BAND', A, B, C}                     -> Pure(A, [B, C]);
+        {'BOR', A, B, C}                      -> Pure(A, [B, C]);
+        {'BXOR', A, B, C}                     -> Pure(A, [B, C]);
+        {'BNOT', A, B}                        -> Pure(A, [B]);
+        {'BSL', A, B, C}                      -> Pure(A, [B, C]);
+        {'BSR', A, B, C}                      -> Pure(A, [B, C]);
         {'LT', A, B, C}                       -> Pure(A, [B, C]);
         {'GT', A, B, C}                       -> Pure(A, [B, C]);
         {'EQ', A, B, C}                       -> Pure(A, [B, C]);
@@ -943,9 +1035,11 @@ attributes(I) ->
         {'APPEND', A, B, C}                   -> Pure(A, [B, C]);
         {'STR_JOIN', A, B, C}                 -> Pure(A, [B, C]);
         {'INT_TO_STR', A, B}                  -> Pure(A, B);
+        {'INT_TO_BYTES', A, B, C}             -> Pure(A, [B, C]);
         {'ADDR_TO_STR', A, B}                 -> Pure(A, B);
         {'STR_REVERSE', A, B}                 -> Pure(A, B);
         {'STR_LENGTH', A, B}                  -> Pure(A, B);
+        {'STR_TO_BYTES', A, B}                -> Pure(A, B);
         {'INT_TO_ADDR', A, B}                 -> Pure(A, B);
         {'VARIANT', A, B, C, D}               -> Pure(A, [?a, B, C, D]);
         {'VARIANT_TEST', A, B, C}             -> Pure(A, [B, C]);
@@ -965,18 +1059,23 @@ attributes(I) ->
         {'SHA3', A, B}                        -> Pure(A, [B]);
         {'SHA256', A, B}                      -> Pure(A, [B]);
         {'BLAKE2B', A, B}                     -> Pure(A, [B]);
+        {'POSEIDON', A, B, C}                 -> Pure(A, [B, C]);
         {'VERIFY_SIG', A, B, C, D}            -> Pure(A, [B, C, D]);
         {'VERIFY_SIG_SECP256K1', A, B, C, D}  -> Pure(A, [B, C, D]);
         {'ECVERIFY_SECP256K1', A, B, C, D}    -> Pure(A, [B, C, D]);
         {'ECRECOVER_SECP256K1', A, B, C}      -> Pure(A, [B, C]);
         {'CONTRACT_TO_ADDRESS', A, B}         -> Pure(A, [B]);
         {'ADDRESS_TO_CONTRACT', A, B}         -> Pure(A, [B]);
+        {'ADDRESS_TO_BYTES', A, B}            -> Pure(A, [B]);
         {'AUTH_TX_HASH', A}                   -> Pure(A, []);
         {'AUTH_TX', A}                        -> Pure(A, []);
         {'BYTES_TO_INT', A, B}                -> Pure(A, [B]);
         {'BYTES_TO_STR', A, B}                -> Pure(A, [B]);
         {'BYTES_CONCAT', A, B, C}             -> Pure(A, [B, C]);
         {'BYTES_SPLIT', A, B, C}              -> Pure(A, [B, C]);
+        {'BYTES_SPLIT_ANY', A, B, C}          -> Pure(A, [B, C]);
+        {'BYTES_SIZE', A, B}                  -> Pure(A, B);
+        {'BYTES_TO_FIXED_SIZE', A, B, C}      -> Pure(A, [B, C]);
         {'ORACLE_CHECK', A, B, C, D}          -> Pure(A, [B, C, D]);
         {'ORACLE_CHECK_QUERY', A, B, C, D, E} -> Pure(A, [B, C, D, E]);
         {'IS_ORACLE', A, B}                   -> Pure(A, [B]);
@@ -997,6 +1096,7 @@ attributes(I) ->
         {'MICROBLOCK', A}                     -> Pure(A, []);
         {'DIFFICULTY', A}                     -> Pure(A, []);
         {'GASLIMIT', A}                       -> Pure(A, []);
+        {'NETWORK_ID', A}                     -> Pure(A, []);
         {'GAS', A}                            -> Pure(A, []);
         {'LOG0', A}                           -> Impure(none, [A]);
         {'LOG1', A, B}                        -> Impure(none, [A, B]);
@@ -1081,11 +1181,16 @@ independent({i, _, I}, {i, _, J}) ->
     StackI = lists:member(?a, [WI | RI]),
     StackJ = lists:member(?a, [WJ | RJ]),
 
-    if  WI == pc; WJ == pc   -> false;     %% no jumps
-        not (PureI or PureJ) -> false;     %% at least one is pure
-        StackI and StackJ    -> false;     %% cannot both use the stack
-        WI == WJ             -> false;     %% cannot write to the same register
-        true                 ->
+    ReadStoreI = [] /= [ x || {store, _} <- RI ],
+    ReadStoreJ = [] /= [ x || {store, _} <- RJ ],
+
+    if  WI == pc; WJ == pc       -> false;  %% no jumps
+        not (PureI or PureJ)     -> false;  %% at least one is pure
+        StackI and StackJ        -> false;  %% cannot both use the stack
+        WI == WJ                 -> false;  %% cannot write to the same register
+        ReadStoreI and not PureJ -> false;  %% can't read store/state if other is impure
+        ReadStoreJ and not PureI -> false;  %% can't read store/state if other is impure
+        true                     ->
             %% and cannot write to each other's inputs
             not lists:member(WI, RJ) andalso
             not lists:member(WJ, RI)
@@ -1605,7 +1710,23 @@ bb(_Name, Code) ->
     Blocks  = lists:flatmap(fun split_calls/1, Blocks1),
     Labels  = maps:from_list([ {Ref, I} || {I, {Ref, _}} <- with_ixs(Blocks) ]),
     BBs     = [ set_labels(Labels, B) || B <- Blocks ],
-    maps:from_list(BBs).
+    maps:from_list(dbg_loc_filter(BBs)).
+
+%% Filter DBG_LOC instructions to keep one instruction per line
+dbg_loc_filter(BBs) ->
+    dbg_loc_filter(BBs, [], [], sets:new()).
+
+dbg_loc_filter([], _, AllBlocks, _) ->
+    lists:reverse(AllBlocks);
+dbg_loc_filter([{I, []} | Rest], AllOps, AllBlocks, DbgLocs) ->
+    dbg_loc_filter(Rest, [], [{I, lists:reverse(AllOps)} | AllBlocks], DbgLocs);
+dbg_loc_filter([{I, [Op = {'DBG_LOC', _, _} | Ops]} | Rest], AllOps, AllBlocks, DbgLocs) ->
+    case sets:is_element(Op, DbgLocs) of
+        true  -> dbg_loc_filter([{I, Ops} | Rest], AllOps, AllBlocks, DbgLocs);
+        false -> dbg_loc_filter([{I, Ops} | Rest], [Op | AllOps], AllBlocks, sets:add_element(Op, DbgLocs))
+    end;
+dbg_loc_filter([{I, [Op | Ops]} | Rest], AllOps, AllBlocks, DbgLocs) ->
+    dbg_loc_filter([{I, Ops} | Rest], [Op | AllOps], AllBlocks, DbgLocs).
 
 %% -- Break up scode into basic blocks --
 

src/aeso_parse_lib.erl

@@ -7,6 +7,7 @@
 %%% @end
 %%%-------------------------------------------------------------------
 -module(aeso_parse_lib).
+-vsn("8.0.1").
 
 -export([parse/2,
          return/1, fail/0, fail/1, fail/2, map/2, bind/2,
@@ -15,7 +16,7 @@
          many/1, many1/1, sep/2, sep1/2,
          infixl/2, infixr/2]).
 
--export([current_file/0, set_current_file/1,
+-export([current_file/0, set_current_file/1, current_dir/0, set_current_dir/1,
          current_include_type/0, set_current_include_type/1]).
 
 %% -- Types ------------------------------------------------------------------
@@ -480,6 +481,13 @@ 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/aeso_parser.erl

@@ -3,6 +3,7 @@
 %%% Description :
 %%% Created     : 1 Mar 2018 by Ulf Norell
 -module(aeso_parser).
+-vsn("8.0.1").
 -compile({no_auto_import,[map_get/2]}).
 
 -export([string/1,
@@ -19,6 +20,7 @@
 
 -include("aeso_parse_lib.hrl").
 -import(aeso_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() :: aeso_syntax:ast() | {aeso_syntax:ast(), sets:set(include_hash())} | none().
@@ -58,6 +60,7 @@ run_parser(P, Inp, Opts) ->
 
 parse_and_scan(P, S, Opts) ->
     set_current_file(proplists:get_value(src_file, Opts, no_file)),
+    set_current_dir(proplists:get_value(src_dir, Opts, no_file)),
     set_current_include_type(proplists:get_value(include_type, Opts, none)),
     case aeso_scan:scan(S) of
         {ok, Tokens} -> aeso_parse_lib:parse(P, Tokens);
@@ -264,10 +267,11 @@ type300() ->
 type400() ->
     choice(
     [?RULE(typeAtom(), optional(type_args()),
-          case _2 of
-            none       -> _1;
-            {ok, Args} -> {app_t, get_ann(_1), _1, Args}
-          end),
+          any_bytes(
+            case _2 of
+              none       -> _1;
+              {ok, Args} -> {app_t, get_ann(_1), _1, Args}
+            end)),
      ?RULE(id("bytes"), parens(token(int)),
            {bytes_t, get_ann(_1), element(3, _2)})
     ]).
@@ -299,7 +303,7 @@ stmt() ->
     , {switch, keyword(switch), parens(expr()), maybe_block(branch())}
     , {'if', keyword('if'), parens(expr()), body()}
     , {elif, keyword(elif), parens(expr()), body()}
-    , {else, keyword(else), body()}
+    , {'else', keyword('else'), body()}
     ])).
 
 branch() ->
@@ -323,7 +327,7 @@ 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)}
+    , {'if', keyword('if'), parens(Expr100), Expr150, right(tok('else'), Expr100)}
     , ?RULE(Expr150, optional(right(tok(':'), type())),
             case _2 of
                 none       -> _1;
@@ -333,14 +337,19 @@ expr100() ->
 
 expr150() -> infixl(expr200(), binop('|>')).
 expr200() -> infixr(expr300(), binop('||')).
-expr300() -> infixr(expr400(), binop('&&')).
+expr300() -> infixr(expr325(), binop('&&')).
+expr325() -> infixl(expr350(), binop('bor')).
+expr350() -> infixl(expr375(), binop('bxor')).
+expr375() -> infixl(expr400(), binop('band')).
 expr400() -> infix(expr500(),  binop(['<', '>', '=<', '>=', '==', '!='])).
-expr500() -> infixr(expr600(), binop(['::', '++'])).
+expr500() -> infixr(expr550(), binop(['::', '++'])).
+expr550() -> infixl(expr600(), binop(['<<', '>>'])).
 expr600() -> infixl(expr650(), binop(['+', '-'])).
 expr650() -> ?RULE(many(token('-')), expr700(), prefixes(_1, _2)).
 expr700() -> infixl(expr750(), binop(['*', '/', mod])).
 expr750() -> infixl(expr800(), binop(['^'])).
-expr800() -> ?RULE(many(token('!')), expr900(), prefixes(_1, _2)).
+expr800() -> ?RULE(many(token('!')), expr850(), prefixes(_1, _2)).
+expr850() -> ?RULE(many(token('bnot')), expr900(), prefixes(_1, _2)).
 expr900() -> ?RULE(exprAtom(), many(elim()), elim(_1, _2)).
 
 exprAtom() ->
@@ -517,7 +526,7 @@ id_or_addr() ->
     ?RULE(id(), parse_addr_literal(_1)).
 
 parse_addr_literal(Id = {id, Ann, Name}) ->
-    case lists:member(lists:sublist(Name, 3), ["ak_", "ok_", "oq_", "ct_"]) of
+    case lists:member(lists:sublist(Name, 3), ["ak_", "ok_", "oq_", "ct_", "sg_"]) of
         false -> Id;
         true  ->
             try aeser_api_encoder:decode(list_to_binary(Name)) of
@@ -556,6 +565,7 @@ bracket_list(P) -> brackets(comma_sep(P)).
 -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} ].
@@ -603,7 +613,7 @@ group_ifs([], Acc) ->
 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, _} | _], _) ->
+group_ifs([{'else', Ann, _} | _], _) ->
     fail({Ann, "No matching 'if' for 'else'"});
 group_ifs([{elif, Ann, _, _} | _], _) ->
     fail({Ann, "No matching 'if' for 'elif'"});
@@ -613,14 +623,14 @@ group_ifs([Stmt | Stmts], 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}]) ->
+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) ->
+else_branches([Else = {'else', _, _} | Stmts], Acc) ->
     {lists:reverse([Else | Acc]), Stmts};
 else_branches(Stmts, Acc) ->
     {lists:reverse(Acc), Stmts}.
@@ -696,7 +706,7 @@ expand_includes([], Included, Acc, Opts) ->
     end;
 expand_includes([{include, Ann, {string, _SAnn, File}} | AST], Included, Acc, Opts) ->
     case get_include_code(File, Ann, Opts) of
-        {ok, Code} ->
+        {ok, AbsDir, Code} ->
             Hashed = hash_include(File, Code),
             case sets:is_element(Hashed, Included) of
                 false ->
@@ -706,9 +716,10 @@ expand_includes([{include, Ann, {string, _SAnn, File}} | AST], Included, Acc, Op
                                       _       -> indirect
                                   end,
                     Opts1 = lists:keystore(src_file, 1, Opts, {src_file, File}),
-                    Opts2 = lists:keystore(include_type, 1, Opts1, {include_type, IncludeType}),
+                    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, Opts2) of
+                    case parse_and_scan(file(), Code, Opts3) of
                         {ok, AST1} ->
                             expand_includes(AST1 ++ AST, Included1, Acc, Opts);
                         Err = {error, _} ->
@@ -726,13 +737,12 @@ expand_includes([E | AST], Included, 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);
+            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, Src}
+                Src       -> {ok, File, Src}
             end;
         escript ->
             try
@@ -741,7 +751,7 @@ read_file(File, Opts) ->
                 Archive        = proplists:get_value(archive, Sections),
                 FileName       = binary_to_list(filename:join([aesophia, priv, stdlib, File])),
                 case zip:extract(Archive, [{file_list, [FileName]}, memory]) of
-                    {ok, [{_, Src}]} -> {ok, Src};
+                    {ok, [{_, Src}]} -> {ok, escript, Src};
                     _                -> {error, not_found}
                 end
             catch _:_ ->
@@ -749,6 +759,13 @@ read_file(File, Opts) ->
             end
     end.
 
+read_file_(Path, File) ->
+    AbsFile = filename:join(Path, File),
+    case file:read_file(AbsFile) of
+        {ok, Bin} -> {ok, aeso_utils:canonical_dir(filename:dirname(AbsFile)), Bin};
+        Err       -> Err
+    end.
+
 stdlib_options() ->
     StdLibDir = aeso_stdlib:stdlib_include_path(),
     case filelib:is_dir(StdLibDir) of
@@ -757,23 +774,37 @@ stdlib_options() ->
     end.
 
 get_include_code(File, Ann, Opts) ->
-    case {read_file(File, Opts), read_file(File, stdlib_options())} of
-        {{ok, Bin}, {ok, _}} ->
+    %% 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, binary_to_list(Bin)}
+                false -> {ok, Dir, binary_to_list(Bin)}
             end;
-        {_, {ok, Bin}} ->
-            {ok, binary_to_list(Bin)};
-        {{ok, Bin}, _} ->
-            {ok, binary_to_list(Bin)};
+        {_, {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);
@@ -787,3 +818,7 @@ auto_imports(L) when is_list(L) ->
 auto_imports(T) when is_tuple(T) ->
     auto_imports(tuple_to_list(T));
 auto_imports(_) -> [].
+
+any_bytes({id, Ann, "bytes"})                 -> {bytes_t, Ann, any};
+any_bytes({app_t, _, {id, Ann, "bytes"}, []}) -> {bytes_t, Ann, any};
+any_bytes(Type)                               -> Type.

src/aeso_pretty.erl

@@ -6,6 +6,7 @@
 %%% @end
 %%%-------------------------------------------------------------------
 -module(aeso_pretty).
+-vsn("8.0.1").
 
 -import(prettypr, [text/1, sep/1, above/2, beside/2, nest/2, empty/0]).
 
@@ -275,7 +276,9 @@ type({tuple_t, _, Args}) ->
     tuple_type(Args);
 type({args_t, _, Args}) ->
     args_type(Args);
-type({bytes_t, _, any}) -> text("bytes(_)");
+type({bytes_t, _, any}) -> text("bytes()");
+type({bytes_t, _, '_'}) -> text("bytes(_)");
+type({bytes_t, _, fixed}) -> text("bytes(_)");
 type({bytes_t, _, Len}) ->
     text(lists:concat(["bytes(", Len, ")"]));
 type({if_t, _, Id, Then, Else}) ->
@@ -385,7 +388,8 @@ expr_p(_, {Type, _, Bin})
     when Type == account_pubkey;
          Type == contract_pubkey;
          Type == oracle_pubkey;
-         Type == oracle_query_id ->
+         Type == oracle_query_id;
+         Type == signature ->
     text(binary_to_list(aeser_api_encoder:encode(Type, Bin)));
 expr_p(_, {string, _, <<>>}) -> text("\"\"");
 expr_p(_, {string, _, S}) ->
@@ -416,7 +420,7 @@ 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
         system when HideGenerated -> empty();
@@ -436,15 +440,20 @@ 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};
@@ -454,7 +463,8 @@ bin_prec('^')    -> {750, 750, 800}.
 
 -spec un_prec(aeso_syntax:un_op()) -> {integer(), integer()}.
 un_prec('-')    -> {650, 650};
-un_prec('!')    -> {800, 800}.
+un_prec('!')    -> {800, 800};
+un_prec('bnot') -> {850, 850}.
 
 equals(Ann, A, B) ->
     {app, [{format, infix} | Ann], {'=', Ann}, [A, B]}.
@@ -525,5 +535,5 @@ get_elifs(If = {'if', Ann, Cond, Then, Else}, Elifs) ->
         elif -> get_elifs(Else, [{elif, Ann, Cond, Then} | Elifs]);
         _    -> {lists:reverse(Elifs), If}
     end;
-get_elifs(Else, Elifs) -> {lists:reverse(Elifs), {else, Else}}.
+get_elifs(Else, Elifs) -> {lists:reverse(Elifs), {'else', Else}}.
 

src/aeso_scan.erl

@@ -6,6 +6,7 @@
 %%% @end
 %%%-------------------------------------------------------------------
 -module(aeso_scan).
+-vsn("8.0.1").
 
 -export([scan/1, utf8_encode/1]).
 
@@ -45,7 +46,7 @@ lexer() ->
 
     Keywords = ["contract", "include", "let", "switch", "type", "record", "datatype", "if", "elif", "else", "function",
                 "stateful", "payable", "true", "false", "mod", "public", "entrypoint", "private", "indexed", "namespace",
-                "interface", "main", "using", "as", "for", "hiding"
+                "interface", "main", "using", "as", "for", "hiding", "band", "bor", "bxor", "bnot"
                ],
     KW = string:join(Keywords, "|"),
 

src/aeso_scan_lib.erl

@@ -5,6 +5,7 @@
 %%% @end
 %%%-------------------------------------------------------------------
 -module(aeso_scan_lib).
+-vsn("8.0.1").
 
 -export([compile/1, string/3,
          token/1, token/2, symbol/0, skip/0,

src/aeso_stdlib.erl

@@ -9,9 +9,10 @@
 %%%-------------------------------------------------------------------
 
 -module(aeso_stdlib).
+-vsn("8.0.1").
 
 -export([stdlib_include_path/0]).
 
 stdlib_include_path() ->
-    filename:join([code:priv_dir(aesophia), "stdlib"]).
-
+    {file, Path} = code:is_loaded(?MODULE),
+    filename:join(filename:dirname(filename:dirname(Path)), "priv/stdlib").

src/aeso_syntax.erl

@@ -7,10 +7,11 @@
 %%%-------------------------------------------------------------------
 
 -module(aeso_syntax).
+-vsn("8.0.1").
 
 -export([get_ann/1, get_ann/2, get_ann/3, set_ann/2, qualify/2]).
 
--export_type([ann_line/0, ann_col/0, ann_origin/0, ann_format/0, ann/0]).
+-export_type([ann_file/0, ann_line/0, ann_col/0, ann_origin/0, ann_format/0, ann/0]).
 -export_type([name/0, id/0, con/0, qid/0, qcon/0, tvar/0, op/0]).
 -export_type([bin_op/0, un_op/0]).
 -export_type([decl/0, letbind/0, typedef/0, pragma/0, fundecl/0]).
@@ -24,8 +25,9 @@
 -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().
@@ -99,6 +101,7 @@
      | {contract_pubkey, ann(), binary()}
      | {oracle_pubkey, ann(), binary()}
      | {oracle_query_id, ann(), binary()}
+     | {signature, ann(), binary()}
      | {string, ann(), binary()}
      | {char, ann(), integer()}.
 
@@ -106,8 +109,8 @@
 
 -type bin_op() :: '+' | '-' | '*' | '/' | mod | '^'
                 | '++' | '::' | '<' | '>' | '=<' | '>=' | '==' | '!='
-                | '||' | '&&' | '..' | '|>'.
--type un_op() :: '-' | '!'.
+                | '||' | '&&' | '..' | 'band' | 'bor' | 'bxor' | '>>' | '<<' | '|>'.
+-type un_op() :: '-' | '!' | 'bnot'.
 
 -type expr()
     :: {lam, ann(), [arg()], expr()}

src/aeso_syntax_utils.erl

@@ -5,8 +5,9 @@
 %%% @end
 %%%-------------------------------------------------------------------
 -module(aeso_syntax_utils).
+-vsn("8.0.1").
 
--export([used_ids/1, used_types/2, used/1]).
+-export([used_ids/1, used_ids/2, used_types/2, used/1]).
 
 -record(alg, {zero, plus, scoped}).
 
@@ -110,8 +111,16 @@ 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 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];

src/aeso_tc_ann_manip.erl

@@ -1,17 +0,0 @@
--module(aeso_tc_ann_manip).
-
--export([ pos/1
-        , pos/2
-        , loc/1
-        ]).
-
-src_file(T)      -> aeso_syntax:get_ann(file, T, no_file).
-include_type(T)  -> aeso_syntax:get_ann(include_type, T, none).
-line_number(T)   -> aeso_syntax:get_ann(line, T, 0).
-column_number(T) -> aeso_syntax:get_ann(col, T, 0).
-
-pos(T)    -> aeso_errors:pos(src_file(T), line_number(T), column_number(T)).
-pos(L, C) -> aeso_errors:pos(L, C).
-
-loc(T) ->
-    {src_file(T), include_type(T), line_number(T), column_number(T)}.

src/aeso_tc_constraints.erl

@@ -1,593 +0,0 @@
--module(aeso_tc_constraints).
-
--export([ solve_constraints/1
-        , solve_then_destroy_and_report_unsolved_constraints/1
-        , create_constraints/0
-        , add_is_contract_constraint/2
-        , add_is_contract_constraint/3
-        , add_aens_resolve_constraint/1
-        , add_oracle_type_constraint/2
-        , add_named_argument_constraint/3
-        , add_field_constraint/5
-        , add_dependent_type_constraint/5
-        , add_record_create_constraint/3
-        , freshen_type/2
-        , freshen_type_sig/2
-        ]).
-
-%% -- Duplicated types -------------------------------------------------------
-
--type uvar() :: {uvar, aeso_syntax:ann(), reference()}.
--type named_args_t() :: uvar() | [{named_arg_t, aeso_syntax:ann(), aeso_syntax:id(), utype(), aeso_syntax:expr()}].
--type utype() :: aeso_tc_typedefs:utype().
-
-%% -- Duplicated macros ------------------------------------------------------
-
--define(is_type_id(T), element(1, T) =:= id orelse
-                       element(1, T) =:= qid orelse
-                       element(1, T) =:= con orelse
-                       element(1, T) =:= qcon).
-
-%% -- Moved functions --------------------------------------------------------
-
-unify(A, B, C, D) -> aeso_tc_unify:unify(A, B, C, D).
-
-%% -------
-
-unfold_types_in_type(A, B) -> aeso_tc_type_unfolding:unfold_types_in_type(A, B).
-
-%% -------
-
-qname(A) -> aeso_tc_name_manip:qname(A).
-
-%% -------
-
-type_error(A) -> aeso_tc_errors:type_error(A).
-
-%% -------
-
-is_monomorphic(A) -> aeso_tc_type_utils:is_monomorphic(A).
-is_first_order(A) -> aeso_tc_type_utils:is_first_order(A).
-app_t(A, B, C) -> aeso_tc_type_utils:app_t(A, B, C).
-fresh_uvar(A) -> aeso_tc_type_utils:fresh_uvar(A).
-
-%% ---------------------------------------------------------------------------
-
--type env() :: aeso_tc_env:env().
-
--type why_record() :: aeso_syntax:field(aeso_syntax:expr())
-                    | {var_args, aeso_syntax:ann(), aeso_syntax:expr()}
-                    | {proj, aeso_syntax:ann(), aeso_syntax:expr(), aeso_syntax:id()}.
-
--record(named_argument_constraint,
-    {args :: named_args_t(),
-     name :: aeso_syntax:id(),
-     type :: utype()}).
-
--record(dependent_type_constraint,
-    { named_args_t     :: named_args_t()
-    , named_args       :: [aeso_syntax:arg_expr()]
-    , general_type     :: utype()
-    , specialized_type :: utype()
-    , context          :: term() }).
-
--type named_argument_constraint() :: #named_argument_constraint{} | #dependent_type_constraint{}.
-
--record(field_constraint,
-    { record_t :: utype()
-    , field    :: aeso_syntax:id()
-    , field_t  :: utype()
-    , kind     :: project | create | update %% Projection constraints can match contract
-    , context  :: why_record() }).          %% types, but field constraints only record types.
-
-%% Constraint checking that 'record_t' has precisely 'fields'.
--record(record_create_constraint,
-    { record_t :: utype()
-    , fields   :: [aeso_syntax:id()]
-    , context  :: why_record() }).
-
--record(is_contract_constraint,
-    { contract_t :: utype(),
-      context    :: {contract_literal, aeso_syntax:expr()} |
-                    {address_to_contract, aeso_syntax:ann()} |
-                    {bytecode_hash, aeso_syntax:ann()} |
-                    {var_args, aeso_syntax:ann(), aeso_syntax:expr()},
-      force_def = false :: boolean()
-    }).
-
--type field_constraint() :: #field_constraint{} | #record_create_constraint{} | #is_contract_constraint{}.
-
--type byte_constraint() :: {is_bytes, utype()}
-                         | {add_bytes, aeso_syntax:ann(), concat | split, utype(), utype(), utype()}.
-
--type aens_resolve_constraint() :: {aens_resolve_type, utype()}.
--type oracle_type_constraint() :: {oracle_type, aeso_syntax:ann(), utype()}.
-
--type constraint() :: named_argument_constraint() | field_constraint() | byte_constraint()
-                    | aens_resolve_constraint() | oracle_type_constraint().
-
--spec add_constraint(constraint()) -> true.
-add_constraint(Constraint) ->
-    aeso_tc_ets_manager:ets_insert_ordered(constraints, Constraint).
-
-add_is_contract_constraint(ContractT, Context) ->
-    add_constraint(
-        #is_contract_constraint{
-            contract_t = ContractT,
-            context    = Context }).
-
-add_is_contract_constraint(ContractT, Context, ForceDef) ->
-    add_constraint(
-        #is_contract_constraint{
-            contract_t = ContractT,
-            context    = Context,
-            force_def  = ForceDef }).
-
-add_aens_resolve_constraint(Type) ->
-    add_constraint({aens_resolve_type, Type}).
-
-add_oracle_type_constraint(Ann, Type) ->
-    add_constraint({oracle_type, Ann, Type}).
-
-add_named_argument_constraint(Args, Name, Type) ->
-    add_constraint(
-        #named_argument_constraint{
-            args = Args,
-            name = Name,
-            type = Type }).
-
-add_field_constraint(RecordT, Field, FieldT, Kind, Context) ->
-    add_constraint(#field_constraint{
-        record_t = RecordT,
-        field    = Field,
-        field_t  = FieldT,
-        kind     = Kind,
-        context  = Context }).
-
-add_dependent_type_constraint(NamedArgsT, NamedArgs, GeneralType, SpecializedType, Context) ->
-    add_constraint(#dependent_type_constraint{
-        named_args_t     = NamedArgsT,
-        named_args       = NamedArgs,
-        general_type     = GeneralType,
-        specialized_type = SpecializedType,
-        context          = Context }).
-
-add_record_create_constraint(RecordT, Fields, Context) ->
-    add_constraint(#record_create_constraint{
-        record_t = RecordT,
-        fields   = Fields,
-        context  = Context }).
-
-create_constraints() ->
-    aeso_tc_ets_manager:ets_new(constraints, [ordered_set]).
-
-get_constraints() ->
-    aeso_tc_ets_manager:ets_tab2list_ordered(constraints).
-
-destroy_constraints() ->
-    aeso_tc_ets_manager:ets_delete(constraints).
-
--spec solve_constraints(env()) -> ok.
-solve_constraints(Env) ->
-    %% First look for record fields that appear in only one type definition
-    IsAmbiguous =
-        fun(#field_constraint{
-               record_t = RecordType,
-               field    = Field={id, _Attrs, FieldName},
-               field_t  = FieldType,
-               kind     = Kind,
-               context  = When }) ->
-                Arity = aeso_tc_type_utils:fun_arity(aeso_tc_type_utils:dereference_deep(FieldType)),
-                FieldInfos = case Arity of
-                                 none -> aeso_tc_env:lookup_record_field(Env, FieldName, Kind);
-                                 _    -> aeso_tc_env:lookup_record_field_arity(Env, FieldName, Arity, Kind)
-                             end,
-                case FieldInfos of
-                    [] ->
-                        type_error({undefined_field, Field}),
-                        false;
-                    [Fld] ->
-                        FldType = aeso_tc_env:field_info_field_t(Fld),
-                        RecType = aeso_tc_env:field_info_record_t(Fld),
-                        create_freshen_tvars(),
-                        FreshFldType = freshen(FldType),
-                        FreshRecType = freshen(RecType),
-                        destroy_freshen_tvars(),
-                        unify(Env, FreshFldType, FieldType, {field_constraint, FreshFldType, FieldType, When}),
-                        unify(Env, FreshRecType, RecordType, {record_constraint, FreshRecType, RecordType, When}),
-                        false;
-                    _ ->
-                        %% ambiguity--need cleverer strategy
-                        true
-                end;
-           (_) -> true
-        end,
-    AmbiguousConstraints = lists:filter(IsAmbiguous, get_constraints()),
-
-    % The two passes on AmbiguousConstraints are needed
-    solve_ambiguous_constraints(Env, AmbiguousConstraints ++ AmbiguousConstraints).
-
--spec solve_ambiguous_constraints(env(), [constraint()]) -> ok.
-solve_ambiguous_constraints(Env, Constraints) ->
-    Unknown = solve_known_record_types(Env, Constraints),
-    if Unknown == [] -> ok;
-       length(Unknown) < length(Constraints) ->
-            %% progress! Keep trying.
-            solve_ambiguous_constraints(Env, Unknown);
-       true ->
-            case solve_unknown_record_types(Env, Unknown) of
-                true -> %% Progress!
-                    solve_ambiguous_constraints(Env, Unknown);
-                _ -> ok %% No progress. Report errors later.
-            end
-    end.
-
-solve_then_destroy_and_report_unsolved_constraints(Env) ->
-    solve_constraints(Env),
-    destroy_and_report_unsolved_constraints(Env).
-
-destroy_and_report_unsolved_constraints(Env) ->
-    {FieldCs, OtherCs} =
-        lists:partition(fun(#field_constraint{}) -> true; (_) -> false end,
-                        get_constraints()),
-    {CreateCs, OtherCs1} =
-        lists:partition(fun(#record_create_constraint{}) -> true; (_) -> false end,
-                        OtherCs),
-    {ContractCs, OtherCs2} =
-        lists:partition(fun(#is_contract_constraint{}) -> true; (_) -> false end, OtherCs1),
-    {NamedArgCs, OtherCs3} =
-        lists:partition(fun(#dependent_type_constraint{}) -> true;
-                           (#named_argument_constraint{}) -> true;
-                           (_)                            -> false
-                        end, OtherCs2),
-    {BytesCs, OtherCs4} =
-        lists:partition(fun({is_bytes, _})              -> true;
-                           ({add_bytes, _, _, _, _, _}) -> true;
-                           (_)                          -> false
-                        end, OtherCs3),
-    {AensResolveCs, OtherCs5} =
-        lists:partition(fun({aens_resolve_type, _}) -> true;
-                           (_)                      -> false
-                        end, OtherCs4),
-    {OracleTypeCs, []} =
-        lists:partition(fun({oracle_type, _, _}) -> true;
-                           (_)                   -> false
-                        end, OtherCs5),
-
-    Unsolved = [ S || S <- [ solve_constraint(Env, aeso_tc_type_utils:dereference_deep(C)) || C <- NamedArgCs ],
-                      S == unsolved ],
-    [ type_error({unsolved_named_argument_constraint, Name, Type})
-        || #named_argument_constraint{name = Name, type = Type} <- Unsolved ],
-
-    Unknown = solve_known_record_types(Env, FieldCs),
-    if Unknown == [] -> ok;
-       true ->
-            case solve_unknown_record_types(Env, Unknown) of
-                true   -> ok;
-                Errors -> [ type_error(Err) || Err <- Errors ]
-            end
-    end,
-
-    check_record_create_constraints(Env, CreateCs),
-    check_is_contract_constraints(Env, ContractCs),
-    check_bytes_constraints(Env, BytesCs),
-    check_aens_resolve_constraints(Env, AensResolveCs),
-    check_oracle_type_constraints(Env, OracleTypeCs),
-
-    destroy_constraints().
-
-%% If false, a type error has been emitted, so it's safe to drop the constraint.
--spec check_named_argument_constraint(env(), named_argument_constraint()) -> true | false | unsolved.
-check_named_argument_constraint(_Env, #named_argument_constraint{ args = {uvar, _, _} }) ->
-    unsolved;
-check_named_argument_constraint(Env,
-    #named_argument_constraint{ args = Args,
-                                name = Id = {id, _, Name},
-                                type = Type }) ->
-    case [ T || {named_arg_t, _, {id, _, Name1}, T, _} <- Args, Name1 == Name ] of
-        []  ->
-            type_error({bad_named_argument, Args, Id}),
-            false;
-        [T] -> unify(Env, T, Type, {check_named_arg_constraint, Args, Id, Type}), true
-    end;
-check_named_argument_constraint(Env,
-        #dependent_type_constraint{ named_args_t = NamedArgsT0,
-                                    named_args = NamedArgs,
-                                    general_type = GenType,
-                                    specialized_type = SpecType,
-                                    context = {check_return, App} }) ->
-    NamedArgsT = aeso_tc_type_utils:dereference(NamedArgsT0),
-    case aeso_tc_type_utils:dereference(NamedArgsT0) of
-        [_ | _] = NamedArgsT ->
-            GetVal = fun(Name, Default) ->
-                        hd([ Val || {named_arg, _, {id, _, N}, Val} <- NamedArgs, N == Name] ++
-                           [ Default ])
-                     end,
-            ArgEnv = maps:from_list([ {Name, GetVal(Name, Default)}
-                                      || {named_arg_t, _, {id, _, Name}, _, Default} <- NamedArgsT ]),
-            GenType1 = specialize_dependent_type(ArgEnv, GenType),
-            unify(Env, GenType1, SpecType, {check_expr, App, GenType1, SpecType}),
-            true;
-        _ -> unify(Env, GenType, SpecType, {check_expr, App, GenType, SpecType}), true
-    end.
-
-specialize_dependent_type(Env, Type) ->
-    case aeso_tc_type_utils:dereference(Type) of
-        {if_t, _, {id, _, Arg}, Then, Else} ->
-            Val = maps:get(Arg, Env),
-            case Val of
-                {typed, _, {bool, _, true}, _}  -> Then;
-                {typed, _, {bool, _, false}, _} -> Else;
-                _ ->
-                    type_error({named_argument_must_be_literal_bool, Arg, Val}),
-                    fresh_uvar(aeso_syntax:get_ann(Val))
-            end;
-        _ -> Type   %% Currently no deep dependent types
-    end.
-
-%% -- Bytes constraints --
-
-solve_constraint(_Env, #field_constraint{record_t = {uvar, _, _}}) ->
-    not_solved;
-solve_constraint(Env, C = #field_constraint{record_t = RecType,
-                                            field    = FieldName,
-                                            field_t  = FieldType,
-                                            context  = When}) ->
-    RecId = record_type_name(RecType),
-    Attrs = aeso_syntax:get_ann(RecId),
-    case aeso_tc_env:lookup_type(Env, RecId) of
-        {_, {_Ann, {Formals, {What, Fields}}}} when What =:= record_t; What =:= contract_t ->
-            FieldTypes = [{Name, Type} || {field_t, _, {id, _, Name}, Type} <- Fields],
-            {id, _, FieldString} = FieldName,
-            case proplists:get_value(FieldString, FieldTypes) of
-                undefined ->
-                    type_error({missing_field, FieldName, RecId}),
-                    not_solved;
-                FldType ->
-                    create_freshen_tvars(),
-                    FreshFldType = freshen(FldType),
-                    FreshRecType = freshen(app_t(Attrs, RecId, Formals)),
-                    destroy_freshen_tvars(),
-                    unify(Env, FreshFldType, FieldType, {field_constraint, FreshFldType, FieldType, When}),
-                    unify(Env, FreshRecType, RecType, {record_constraint, FreshRecType, RecType, When}),
-                    C
-            end;
-        _ ->
-            type_error({not_a_record_type, aeso_tc_type_utils:instantiate(RecType), When}),
-            not_solved
-    end;
-solve_constraint(Env, C = #dependent_type_constraint{}) ->
-    check_named_argument_constraint(Env, C);
-solve_constraint(Env, C = #named_argument_constraint{}) ->
-    check_named_argument_constraint(Env, C);
-solve_constraint(_Env, {is_bytes, _}) -> ok;
-solve_constraint(Env, {add_bytes, Ann, _, A0, B0, C0}) ->
-    A = unfold_types_in_type(Env, aeso_tc_type_utils:dereference(A0)),
-    B = unfold_types_in_type(Env, aeso_tc_type_utils:dereference(B0)),
-    C = unfold_types_in_type(Env, aeso_tc_type_utils:dereference(C0)),
-    case {A, B, C} of
-        {{bytes_t, _, M}, {bytes_t, _, N}, _} -> unify(Env, {bytes_t, Ann, M + N}, C, {at, Ann});
-        {{bytes_t, _, M}, _, {bytes_t, _, R}} when R >= M -> unify(Env, {bytes_t, Ann, R - M}, B, {at, Ann});
-        {_, {bytes_t, _, N}, {bytes_t, _, R}} when R >= N -> unify(Env, {bytes_t, Ann, R - N}, A, {at, Ann});
-        _ -> ok
-    end;
-solve_constraint(_, _) -> ok.
-
-check_bytes_constraints(Env, Constraints) ->
-    InAddConstraint = [ T || {add_bytes, _, _, A, B, C} <- Constraints,
-                             T <- [A, B, C],
-                             element(1, T) /= bytes_t ],
-    %% Skip is_bytes constraints for types that occur in add_bytes constraints
-    %% (no need to generate error messages for both is_bytes and add_bytes).
-    Skip = fun({is_bytes, T}) -> lists:member(T, InAddConstraint);
-              (_) -> false end,
-    [ check_bytes_constraint(Env, C) || C <- Constraints, not Skip(C) ].
-
-check_bytes_constraint(Env, {is_bytes, Type}) ->
-    Type1 = unfold_types_in_type(Env, aeso_tc_type_utils:instantiate(Type)),
-    case Type1 of
-        {bytes_t, _, _} -> ok;
-        _               ->
-            type_error({unknown_byte_length, Type})
-    end;
-check_bytes_constraint(Env, {add_bytes, Ann, Fun, A0, B0, C0}) ->
-    A = unfold_types_in_type(Env, aeso_tc_type_utils:instantiate(A0)),
-    B = unfold_types_in_type(Env, aeso_tc_type_utils:instantiate(B0)),
-    C = unfold_types_in_type(Env, aeso_tc_type_utils:instantiate(C0)),
-    case {A, B, C} of
-        {{bytes_t, _, _M}, {bytes_t, _, _N}, {bytes_t, _, _R}} ->
-            ok; %% If all are solved we checked M + N == R in solve_constraint.
-        _ -> type_error({unsolved_bytes_constraint, Ann, Fun, A, B, C})
-    end.
-
-check_aens_resolve_constraints(_Env, []) ->
-    ok;
-check_aens_resolve_constraints(Env, [{aens_resolve_type, Type} | Rest]) ->
-    Type1 = unfold_types_in_type(Env, aeso_tc_type_utils:instantiate(Type)),
-    {app_t, _, {id, _, "option"}, [Type2]} = Type1,
-    case Type2 of
-        {id, _, "string"} -> ok;
-        {id, _, "address"} -> ok;
-        {con, _, _} -> ok;
-        {app_t, _, {id, _, "oracle"}, [_, _]} -> ok;
-        {app_t, _, {id, _, "oracle_query"}, [_, _]} -> ok;
-        _ -> type_error({invalid_aens_resolve_type, aeso_syntax:get_ann(Type), Type2})
-    end,
-    check_aens_resolve_constraints(Env, Rest).
-
-check_oracle_type_constraints(_Env, []) ->
-    ok;
-check_oracle_type_constraints(Env, [{oracle_type, Ann, OType} | Rest]) ->
-    Type = unfold_types_in_type(Env, aeso_tc_type_utils:instantiate(OType)),
-    {app_t, _, {id, _, "oracle"}, [QType, RType]} = Type,
-    is_monomorphic(QType) orelse type_error({invalid_oracle_type, polymorphic,  query,    Ann, Type}),
-    is_monomorphic(RType) orelse type_error({invalid_oracle_type, polymorphic,  response, Ann, Type}),
-    is_first_order(QType) orelse type_error({invalid_oracle_type, higher_order, query,    Ann, Type}),
-    is_first_order(RType) orelse type_error({invalid_oracle_type, higher_order, response, Ann, Type}),
-    check_oracle_type_constraints(Env, Rest).
-
-%% -- Field constraints --
-
-check_record_create_constraints(_, []) -> ok;
-check_record_create_constraints(Env, [C | Cs]) ->
-    #record_create_constraint{
-        record_t = Type,
-        fields   = Fields,
-        context  = When } = C,
-    Type1 = unfold_types_in_type(Env, aeso_tc_type_utils:instantiate(Type)),
-    try aeso_tc_env:lookup_type(Env, record_type_name(Type1)) of
-        {_QId, {_Ann, {_Args, {record_t, RecFields}}}} ->
-            ActualNames = [ Fld || {field_t, _, {id, _, Fld}, _} <- RecFields ],
-            GivenNames  = [ Fld || {id, _, Fld} <- Fields ],
-            case ActualNames -- GivenNames of   %% We know already that we don't have too many fields
-                []      -> ok;
-                Missing -> type_error({missing_fields, When, Type1, Missing})
-            end;
-        _ -> %% We can get here if there are other type errors.
-            ok
-    catch _:_ ->    %% Might be unsolved, we get a different error in that case
-        ok
-    end,
-    check_record_create_constraints(Env, Cs).
-
-is_contract_defined(C) ->
-    aeso_tc_ets_manager:ets_lookup(defined_contracts, qname(C)) =/= [].
-
-check_is_contract_constraints(_Env, []) -> ok;
-check_is_contract_constraints(Env, [C | Cs]) ->
-    #is_contract_constraint{ contract_t = Type, context = Cxt, force_def = ForceDef } = C,
-    Type1 = unfold_types_in_type(Env, aeso_tc_type_utils:instantiate(Type)),
-    TypeName = record_type_name(Type1),
-    case aeso_tc_env:lookup_type(Env, TypeName) of
-        {_, {_Ann, {[], {contract_t, _}}}} ->
-            case not ForceDef orelse is_contract_defined(TypeName) of
-                true -> ok;
-                false -> type_error({contract_lacks_definition, Type1, Cxt})
-                end;
-        _ -> type_error({not_a_contract_type, Type1, Cxt})
-    end,
-    check_is_contract_constraints(Env, Cs).
-
--spec solve_unknown_record_types(env(), [field_constraint()]) -> true | [tuple()].
-solve_unknown_record_types(Env, Unknown) ->
-    UVars = lists:usort([UVar || #field_constraint{record_t = UVar = {uvar, _, _}} <- Unknown]),
-    Solutions = [solve_for_uvar(Env, UVar, [{Kind, When, Field}
-                                            || #field_constraint{record_t = U, field = Field, kind = Kind, context = When} <- Unknown,
-                                               U == UVar])
-                 || UVar <- UVars],
-    case lists:member(true, Solutions) of
-        true  -> true;
-        false -> Solutions
-    end.
-
-%% This will solve all kinds of constraints but will only return the
-%% unsolved field constraints
--spec solve_known_record_types(env(), [constraint()]) -> [field_constraint()].
-solve_known_record_types(Env, Constraints) ->
-    DerefConstraints = lists:map(fun(C = #field_constraint{record_t = RecordType}) ->
-                                        C#field_constraint{record_t = aeso_tc_type_utils:dereference(RecordType)};
-                                    (C) -> aeso_tc_type_utils:dereference_deep(C)
-                                 end, Constraints),
-    SolvedConstraints = lists:map(fun(C) -> solve_constraint(Env, aeso_tc_type_utils:dereference_deep(C)) end, DerefConstraints),
-    Unsolved = DerefConstraints--SolvedConstraints,
-    lists:filter(fun(#field_constraint{}) -> true; (_) -> false end, Unsolved).
-
-record_type_name({app_t, _Attrs, RecId, _Args}) when ?is_type_id(RecId) ->
-    RecId;
-record_type_name(RecId) when ?is_type_id(RecId) ->
-    RecId;
-record_type_name(_Other) ->
-    %% io:format("~p is not a record type\n", [Other]),
-    {id, [{origin, system}], "not_a_record_type"}.
-
-solve_for_uvar(Env, UVar = {uvar, Attrs, _}, Fields0) ->
-    Fields = [{Kind, Fld} || {Kind, _, Fld} <- Fields0],
-    [{_, When, _} | _] = Fields0,    %% Get the location from the first field
-    %% If we have 'create' constraints they must be complete.
-    Covering = lists:usort([ Name || {create, {id, _, Name}} <- Fields ]),
-    %% Does this set of fields uniquely identify a record type?
-    FieldNames = [ Name || {_Kind, {id, _, Name}} <- Fields ],
-    UniqueFields = lists:usort(FieldNames),
-    Candidates = [aeso_tc_env:field_info_record_t(Fld) || Fld <- aeso_tc_env:lookup_record_field(Env, hd(FieldNames))],
-    TypesAndFields = [case aeso_tc_env:lookup_type(Env, record_type_name(RecType)) of
-                        {_, {_, {_, {record_t, RecFields}}}} ->
-                            {RecType, [Field || {field_t, _, {id, _, Field}, _} <- RecFields]};
-                        {_, {_, {_, {contract_t, ConFields}}}} ->
-                            %% TODO: is this right?
-                            {RecType, [Field || {field_t, _, {id, _, Field}, _} <- ConFields]};
-                        false -> %% impossible?
-                            error({no_definition_for, record_type_name(RecType), in, Env})
-                      end
-                      || RecType <- Candidates],
-    PartialSolutions =
-        lists:sort([{RecType, if Covering == [] -> []; true -> RecFields -- Covering end}
-                    || {RecType, RecFields} <- TypesAndFields,
-                       UniqueFields -- RecFields == []]),
-    Solutions = [RecName || {RecName, []} <- PartialSolutions],
-    case {Solutions, PartialSolutions} of
-        {[], []} ->
-            {no_records_with_all_fields, Fields};
-        {[], _} ->
-            case PartialSolutions of
-                [{RecType, Missing} | _] -> %% TODO: better error if ambiguous
-                    {missing_fields, When, RecType, Missing}
-            end;
-        {[RecType], _} ->
-            RecName = record_type_name(RecType),
-            {_, {_, {Formals, {_RecOrCon, _}}}} = aeso_tc_env:lookup_type(Env, RecName),
-            create_freshen_tvars(),
-            FreshRecType = freshen(app_t(Attrs, RecName, Formals)),
-            destroy_freshen_tvars(),
-            unify(Env, UVar, FreshRecType, {solve_rec_type, UVar, Fields}),
-            true;
-        {StillPossible, _} ->
-            {ambiguous_record, Fields, StillPossible}
-    end.
-
-create_freshen_tvars() ->
-    aeso_tc_ets_manager:ets_new(freshen_tvars, [set]).
-
-destroy_freshen_tvars() ->
-    aeso_tc_ets_manager:ets_delete(freshen_tvars).
-
-freshen(Type) ->
-    freshen(aeso_syntax:get_ann(Type), Type).
-
-freshen(Ann, {tvar, _, Name}) ->
-    NewT = case aeso_tc_ets_manager:ets_lookup(freshen_tvars, Name) of
-               []          -> fresh_uvar(Ann);
-               [{Name, T}] -> T
-           end,
-    aeso_tc_ets_manager:ets_insert(freshen_tvars, {Name, NewT}),
-    NewT;
-freshen(Ann, {bytes_t, _, any}) ->
-    X = fresh_uvar(Ann),
-    add_constraint({is_bytes, X}),
-    X;
-freshen(Ann, T) when is_tuple(T) ->
-    list_to_tuple(freshen(Ann, tuple_to_list(T)));
-freshen(Ann, [A | B]) ->
-    [freshen(Ann, A) | freshen(Ann, B)];
-freshen(_, X) ->
-    X.
-
-freshen_type(Ann, Type) ->
-    create_freshen_tvars(),
-    Type1 = freshen(Ann, Type),
-    destroy_freshen_tvars(),
-    Type1.
-
-freshen_type_sig(Ann, TypeSig = {type_sig, _, Constr, _, _, _}) ->
-    FunT = freshen_type(Ann, aeso_tc_type_utils:typesig_to_fun_t(TypeSig)),
-    apply_typesig_constraint(Ann, Constr, FunT),
-    FunT.
-
-apply_typesig_constraint(_Ann, none, _FunT) -> ok;
-apply_typesig_constraint(Ann, address_to_contract, {fun_t, _, [], [_], Type}) ->
-    aeso_tc_constraints:add_is_contract_constraint(Type, {address_to_contract, Ann});
-apply_typesig_constraint(Ann, bytes_concat, {fun_t, _, [], [A, B], C}) ->
-    add_constraint({add_bytes, Ann, concat, A, B, C});
-apply_typesig_constraint(Ann, bytes_split, {fun_t, _, [], [C], {tuple_t, _, [A, B]}}) ->
-    add_constraint({add_bytes, Ann, split, A, B, C});
-apply_typesig_constraint(Ann, bytecode_hash, {fun_t, _, _, [Con], _}) ->
-    aeso_tc_constraints:add_is_contract_constraint(Con, {bytecode_hash, Ann}).

src/aeso_tc_desugar.erl

@@ -1,138 +0,0 @@
--module(aeso_tc_desugar).
-
--export([ desugar/1
-        , desugar_clauses/4
-        , process_blocks/1
-        ]).
-
-%% -- Moved functions --------------------------------------------------------
-
-type_error(A) -> aeso_tc_errors:type_error(A).
-
-%% ---------------------------------------------------------------------------
-
-%% Restructure blocks into multi-clause fundefs (`fun_clauses`).
--spec process_blocks([aeso_syntax:decl()]) -> [aeso_syntax:decl()].
-process_blocks(Decls) ->
-    lists:flatmap(
-      fun({block, Ann, Ds}) -> process_block(Ann, Ds);
-         (Decl)             -> [Decl] end, Decls).
-
--spec process_block(aeso_syntax:ann(), [aeso_syntax:decl()]) -> [aeso_syntax:decl()].
-process_block(_, []) -> [];
-process_block(_, [Decl]) -> [Decl];
-process_block(_Ann, [Decl | Decls]) ->
-    IsThis = fun(Name) -> fun({letfun, _, {id, _, Name1}, _, _, _}) -> Name == Name1;
-                             (_) -> false end end,
-    case Decl of
-        {fun_decl, Ann1, Id = {id, _, Name}, Type} ->
-            {Clauses, Rest} = lists:splitwith(IsThis(Name), Decls),
-            [type_error({mismatched_decl_in_funblock, Name, D1}) || D1 <- Rest],
-            [{fun_clauses, Ann1, Id, Type, Clauses}];
-        {letfun, Ann1, Id = {id, _, Name}, _, _, _} ->
-            {Clauses, Rest} = lists:splitwith(IsThis(Name), [Decl | Decls]),
-            [type_error({mismatched_decl_in_funblock, Name, D1}) || D1 <- Rest],
-            [{fun_clauses, Ann1, Id, {id, [{origin, system} | Ann1], "_"}, Clauses}]
-    end.
-
-desugar_clauses(Ann, Fun, {type_sig, _, _, _, ArgTypes, RetType}, Clauses) ->
-    NeedDesugar =
-        case Clauses of
-            [{letfun, _, _, As, _, [{guarded, _, [], _}]}] -> lists:any(fun({typed, _, {id, _, _}, _}) -> false; (_) -> true end, As);
-            _                                              -> true
-        end,
-    case NeedDesugar of
-        false -> [Clause] = Clauses, Clause;
-        true  ->
-            NoAnn = [{origin, system}],
-            Args = [ {typed, NoAnn, {id, NoAnn, "x#" ++ integer_to_list(I)}, Type}
-                     || {I, Type} <- indexed(1, ArgTypes) ],
-            Tuple = fun([X]) -> X;
-                       (As) -> {typed, NoAnn, {tuple, NoAnn, As}, {tuple_t, NoAnn, ArgTypes}}
-                    end,
-            {letfun, Ann, Fun, Args, RetType, [{guarded, NoAnn, [], {typed, NoAnn,
-               {switch, NoAnn, Tuple(Args),
-                 [ {'case', AnnC, Tuple(ArgsC), GuardedBodies}
-                 || {letfun, AnnC, _, ArgsC, _, GuardedBodies} <- Clauses ]}, RetType}}]}
-    end.
-
-%% -- Pre-type checking desugaring -------------------------------------------
-
-%% Desugars nested record/map updates as follows:
-%%  { x.y = v1, x.z @ z = f(z) } becomes { x @ __x = __x { y = v1, z @ z = f(z) } }
-%%  { [k1].x = v1, [k2].y = v2 } becomes { [k1] @ __x = __x { x = v1 }, [k2] @ __x = __x { y = v2 } }
-%% There's no comparison of k1 and k2 to group the updates if they are equal.
-desugar({record, Ann, Rec, Updates}) ->
-    {record, Ann, Rec, desugar_updates(Updates)};
-desugar({map, Ann, Map, Updates}) ->
-    {map, Ann, Map, desugar_updates(Updates)};
-desugar([H|T]) ->
-  [desugar(H) | desugar(T)];
-desugar(T) when is_tuple(T) ->
-  list_to_tuple(desugar(tuple_to_list(T)));
-desugar(X) -> X.
-
-desugar_updates([]) -> [];
-desugar_updates([Upd | Updates]) ->
-    {Key, MakeField, Rest} = update_key(Upd),
-    {More, Updates1}       = updates_key(Key, Updates),
-    %% Check conflicts
-    case length([ [] || [] <- [Rest | More] ]) of
-        N when N > 1 -> type_error({conflicting_updates_for_field, Upd, Key});
-        _ -> ok
-    end,
-    [MakeField(lists:append([Rest | More])) | desugar_updates(Updates1)].
-
-%% TODO: refactor representation to make this not horrible
-update_key(Fld = {field, _, [Elim], _}) ->
-    {elim_key(Elim), fun(_) -> Fld end, []};
-update_key(Fld = {field, _, [Elim], _, _}) ->
-    {elim_key(Elim), fun(_) -> Fld end, []};
-update_key({field, Ann, [P = {proj, _, {id, _, Name}} | Rest], Value}) ->
-    {Name, fun(Flds) -> {field, Ann, [P], {id, [], "__x"},
-                            desugar(map_or_record(Ann, {id, [], "__x"}, Flds))}
-           end, [{field, Ann, Rest, Value}]};
-update_key({field, Ann, [P = {proj, _, {id, _, Name}} | Rest], Id, Value}) ->
-    {Name, fun(Flds) -> {field, Ann, [P], {id, [], "__x"},
-                            desugar(map_or_record(Ann, {id, [], "__x"}, Flds))}
-           end, [{field, Ann, Rest, Id, Value}]};
-update_key({field, Ann, [K = {map_get, _, _} | Rest], Value}) ->
-    {map_key, fun(Flds) -> {field, Ann, [K], {id, [], "__x"},
-                            desugar(map_or_record(Ann, {id, [], "__x"}, Flds))}
-              end, [{field, Ann, Rest, Value}]};
-update_key({field, Ann, [K = {map_get, _, _, _} | Rest], Value}) ->
-    {map_key, fun(Flds) -> {field, Ann, [K], {id, [], "__x"},
-                            desugar(map_or_record(Ann, {id, [], "__x"}, Flds))}
-              end, [{field, Ann, Rest, Value}]};
-update_key({field, Ann, [K = {map_get, _, _, _} | Rest], Id, Value}) ->
-    {map_key, fun(Flds) -> {field, Ann, [K], {id, [], "__x"},
-                            desugar(map_or_record(Ann, {id, [], "__x"}, Flds))}
-              end, [{field, Ann, Rest, Id, Value}]};
-update_key({field, Ann, [K = {map_get, _, _} | Rest], Id, Value}) ->
-    {map_key, fun(Flds) -> {field, Ann, [K], {id, [], "__x"},
-                            desugar(map_or_record(Ann, {id, [], "__x"}, Flds))}
-              end, [{field, Ann, Rest, Id, Value}]}.
-
-map_or_record(Ann, Val, Flds = [Fld | _]) ->
-    Kind = case element(3, Fld) of
-             [{proj, _, _}       | _] -> record;
-             [{map_get, _, _}    | _] -> map;
-             [{map_get, _, _, _} | _] -> map
-           end,
-    {Kind, Ann, Val, Flds}.
-
-elim_key({proj, _, {id, _, Name}}) -> Name;
-elim_key({map_get, _, _, _})       -> map_key;  %% no grouping on map keys (yet)
-elim_key({map_get, _, _})          -> map_key.
-
-updates_key(map_key, Updates) -> {[], Updates};
-updates_key(Name, Updates) ->
-    Xs = [ {Upd, Name1 == Name, Rest}
-           || Upd <- Updates,
-              {Name1, _, Rest} <- [update_key(Upd)] ],
-    Updates1 = [ Upd  || {Upd, false, _} <- Xs ],
-    More     = [ Rest || {_, true, Rest} <- Xs ],
-    {More, Updates1}.
-
-indexed(I, Xs) ->
-    lists:zip(lists:seq(I, I + length(Xs) - 1), Xs).

src/aeso_tc_env.erl

@@ -1,941 +0,0 @@
--module(aeso_tc_env).
-
-%% Getters
--export([ contract_parents/1
-        , current_function/1
-        , in_guard/1
-        , in_pattern/1
-        , namespace/1
-        , stateful/1
-        , typevars/1
-        , unify_throws/1
-        , used_namespaces/1
-        , vars/1
-        , what/1
-        ]).
-
--export([ field_info_field_t/1
-        , field_info_record_t/1
-        ]).
-
--export([ scope_ann/1
-        , scope_consts/1
-        , scope_funs/1
-        , scope_kind/1
-        ]).
-
-%% Setters
--export([ set_contract_parents/2
-        , set_current_const/2
-        , set_current_function/2
-        , set_in_guard/2
-        , set_in_pattern/2
-        , set_stateful/2
-        , set_used_namespaces/2
-        , set_what/2
-        ]).
-
--export([ push_scope/3
-        , pop_scope/1
-        , get_scope/2
-        , get_current_scope/1
-        , on_scopes/2
-        , switch_scope/2
-        , bind_var/3
-        , bind_vars/2
-        , bind_contract/3
-        , bind_state/1
-        , bind_fun/3
-        , bind_funs/2
-        , bind_tvars/2
-        , bind_type/4
-        , bind_const/4
-        , bind_fields_append/4
-        ]).
-
--export([ lookup_env/4
-        , lookup_type/2
-        , lookup_record_field/2
-        , lookup_record_field/3
-        , lookup_record_field_arity/4
-        ]).
-
-%% Env constructors
--export([ init_env/0
-        , init_env/1
-        , empty_env/0
-        ]).
-
--export([destroy_and_report_type_errors/1]).
-
--export_type([env/0]).
-
--include("aeso_utils.hrl").
-
--record(field_info,
-    { ann      :: aeso_syntax:ann()
-    , field_t  :: utype()
-    , record_t :: utype()
-    , kind     :: contract | record }).
-
--type field_info() :: #field_info{}.
-
--type type_id() :: aeso_syntax:id() | aeso_syntax:qid() | aeso_syntax:con() | aeso_syntax:qcon().
-
--type typedef() :: {[aeso_syntax:tvar()], aeso_syntax:typedef() | {contract_t, [aeso_syntax:field_t()]}}
-                 | {builtin, non_neg_integer()}.
-
--type namespace_alias() :: none | name().
--type namespace_parts() :: none | {for, [name()]} | {hiding, [name()]}.
--type used_namespaces() :: [{qname(), namespace_alias(), namespace_parts()}].
-
--type fun_info()   :: {aeso_syntax:ann(), typesig() | type()}.
--type type_info()  :: {aeso_syntax:ann(), typedef()}.
--type const_info() :: {aeso_syntax:ann(), type()}.
--type var_info()   :: {aeso_syntax:ann(), utype()}.
-
--type fun_env()   :: [{name(), fun_info()}].
--type type_env()  :: [{name(), type_info()}].
--type const_env() :: [{name(), const_info()}].
-
--record(scope, { funs   = [] :: fun_env()
-               , types  = [] :: type_env()
-               , consts = [] :: const_env()
-               , kind   = namespace :: namespace | contract
-               , ann    = [{origin, system}] :: aeso_syntax:ann()
-               }).
-
--type scope() :: #scope{}.
-
--record(env,
-    { scopes           = #{ [] => #scope{}} :: #{ qname() => scope() }
-    , vars             = []                 :: [{name(), var_info()}]
-    , typevars         = unrestricted       :: unrestricted | [name()]
-    , fields           = #{}                :: #{ name() => [field_info()] }    %% fields are global
-    , contract_parents = #{}                :: #{ name() => [name()] }
-    , namespace        = []                 :: qname()
-    , used_namespaces  = []                 :: used_namespaces()
-    , in_pattern       = false              :: boolean()
-    , in_guard         = false              :: boolean()
-    , stateful         = false              :: boolean()
-    , unify_throws     = true               :: boolean()
-    , current_const    = none               :: none | aeso_syntax:id()
-    , current_function = none               :: none | aeso_syntax:id()
-    , what             = top                :: top | namespace | contract | contract_interface
-    }).
-
--opaque env() :: #env{}.
-
-%% -- Duplicated types -------------------------------------------------------
-
--type name() :: string().
--type qname() :: [string()].
--type type() :: aeso_syntax:type().
--type utype() :: aeso_tc_typedefs:utype().
--type typesig() :: aeso_tc_typedefs:typesig().
-
-%% -- Duplicated macros ------------------------------------------------------
-
--define(CONSTRUCTOR_MOCK_NAME, "#__constructor__#").
-
-%% -- Moved functions --------------------------------------------------------
-
-name(A) -> aeso_tc_name_manip:name(A).
-qname(A) -> aeso_tc_name_manip:qname(A).
-qid(A, B) -> aeso_tc_name_manip:qid(A, B).
-qcon(A, B) -> aeso_tc_name_manip:qcon(A, B).
-
-%% -------
-
-type_error(A) -> aeso_tc_errors:type_error(A).
-
-%% -------
-
-warn_potential_shadowing(A, B, C) -> aeso_tc_warnings:warn_potential_shadowing(A, B, C).
-used_include(A) -> aeso_tc_warnings:used_include(A).
-
-%% -------
-
-get_option(A, B) -> aeso_tc_options:get_option(A, B).
-when_warning(A, B) -> aeso_tc_options:when_warning(A, B).
-
-%% -------
-
-fresh_uvar(A) -> aeso_tc_type_utils:fresh_uvar(A).
-
-%% -- Getters ------------------------------------------------------------
-
-contract_parents(#env{contract_parents = ContractParents}) ->
-    ContractParents.
-
-current_function(#env{current_function = CurrentFunction}) ->
-    CurrentFunction.
-
-in_guard(#env{in_guard = InGuard}) ->
-    InGuard.
-
-in_pattern(#env{in_pattern = InPattern}) ->
-    InPattern.
-
-namespace(#env{namespace = Namespace}) ->
-    Namespace.
-
-stateful(#env{stateful = Stateful}) ->
-    Stateful.
-
-typevars(#env{typevars = Typevars}) ->
-    Typevars.
-
-unify_throws(#env{unify_throws = UnifyThrows}) ->
-    UnifyThrows.
-
-used_namespaces(#env{used_namespaces = UsedNamespaces}) ->
-    UsedNamespaces.
-
-vars(#env{vars = Vars}) ->
-    Vars.
-
-what(#env{what = What}) ->
-    What.
-
-%% -- Field Info Getters -------------------------------------------------
-
-field_info_field_t(#field_info{field_t = FieldT}) ->
-    FieldT.
-
-field_info_record_t(#field_info{record_t = RecordT}) ->
-    RecordT.
-
-%% -- Scope Getters ------------------------------------------------------
-
-scope_ann(#scope{ann = Ann}) ->
-    Ann.
-
-scope_consts(#scope{consts = Consts}) ->
-    Consts.
-
-scope_funs(#scope{funs = Funs}) ->
-    Funs.
-
-scope_kind(#scope{kind = Kind}) ->
-    Kind.
-
-%% -- Setters ------------------------------------------------------------
-
-set_contract_parents(ContractParents, Env) ->
-    Env#env{contract_parents = ContractParents}.
-
-set_current_const(CurrentConst, Env) ->
-    Env#env{current_const = CurrentConst}.
-
-set_current_function(CurrentFunction, Env) ->
-    Env#env{current_function = CurrentFunction}.
-
-set_in_guard(InGuard, Env) ->
-    Env#env{in_guard = InGuard}.
-
-set_in_pattern(InPattern, Env) ->
-    Env#env{in_pattern = InPattern}.
-
-set_stateful(Stateful, Env) ->
-    Env#env{stateful = Stateful}.
-
-set_used_namespaces(UsedNamespaces, Env) ->
-    Env#env{used_namespaces = UsedNamespaces}.
-
-set_what(What, Env) ->
-    Env#env{what = What}.
-
-%% -- Environment manipulation -----------------------------------------------
-
--spec switch_scope(qname(), env()) -> env().
-switch_scope(Scope, Env) ->
-    Env#env{namespace = Scope}.
-
--spec push_scope(namespace | contract, aeso_syntax:con(), env()) -> env().
-push_scope(Kind, Con, Env) ->
-    Ann  = aeso_syntax:get_ann(Con),
-    Name = name(Con),
-    New  = Env#env.namespace ++ [Name],
-    Env#env{ namespace = New, scopes = (Env#env.scopes)#{ New => #scope{ kind = Kind, ann = Ann } } }.
-
--spec pop_scope(env()) -> env().
-pop_scope(Env) ->
-    Env#env{ namespace = lists:droplast(Env#env.namespace) }.
-
--spec get_scope(env(), qname()) -> false | scope().
-get_scope(#env{ scopes = Scopes }, Name) ->
-    maps:get(Name, Scopes, false).
-
--spec get_current_scope(env()) -> scope().
-get_current_scope(#env{ namespace = NS, scopes = Scopes }) ->
-    maps:get(NS, Scopes).
-
--spec on_current_scope(env(), fun((scope()) -> scope())) -> env().
-on_current_scope(Env = #env{ namespace = NS, scopes = Scopes }, Fun) ->
-    Scope = get_current_scope(Env),
-    Env#env{ scopes = Scopes#{ NS => Fun(Scope) } }.
-
--spec on_scopes(env(), fun((scope()) -> scope())) -> env().
-on_scopes(Env = #env{ scopes = Scopes }, Fun) ->
-    Env#env{ scopes = maps:map(fun(_, Scope) -> Fun(Scope) end, Scopes) }.
-
--spec bind_var(aeso_syntax:id(), utype(), env()) -> env().
-bind_var({id, Ann, X}, T, Env) ->
-    when_warning(warn_shadowing, fun() -> warn_potential_shadowing(Env, Ann, X) end),
-    Env#env{ vars = [{X, {Ann, T}} | Env#env.vars] }.
-
--spec bind_vars([{aeso_syntax:id(), utype()}], env()) -> env().
-bind_vars([], Env) -> Env;
-bind_vars([{X, T} | Vars], Env) ->
-    bind_vars(Vars, bind_var(X, T, Env)).
-
--spec bind_tvars([aeso_syntax:tvar()], env()) -> env().
-bind_tvars(Xs, Env) ->
-    Env#env{ typevars = [X || {tvar, _, X} <- Xs] }.
-
--spec bind_fun(name(), type() | typesig(), env()) -> env().
-bind_fun(X, Type, Env) ->
-    case lookup_env(Env, term, [], [X]) of
-        false -> force_bind_fun(X, Type, Env);
-        {_QId, {Ann1, _}} ->
-            type_error({duplicate_definition, X, [Ann1, aeso_syntax:get_ann(Type)]}),
-            Env
-    end.
-
--spec force_bind_fun(name(), type() | typesig(), env()) -> env().
-force_bind_fun(X, Type, Env = #env{ what = What }) ->
-    Ann    = aeso_syntax:get_ann(Type),
-    NoCode = get_option(no_code, false),
-    Entry = if X == "init", What == contract, not NoCode ->
-                    {reserved_init, Ann, Type};
-               What == contract; What == contract_interface -> {contract_fun, Ann, Type};
-               true -> {Ann, Type}
-            end,
-    on_current_scope(Env, fun(Scope = #scope{ funs = Funs }) ->
-                            Scope#scope{ funs = [{X, Entry} | Funs] }
-                          end).
-
--spec bind_funs([{name(), type() | typesig()}], env()) -> env().
-bind_funs([], Env) -> Env;
-bind_funs([{Id, Type} | Rest], Env) ->
-    bind_funs(Rest, bind_fun(Id, Type, Env)).
-
--spec bind_type(name(), aeso_syntax:ann(), typedef(), env()) -> env().
-bind_type(X, Ann, Def, Env) ->
-    on_current_scope(Env, fun(Scope = #scope{ types = Types }) ->
-                            Scope#scope{ types = [{X, {Ann, Def}} | Types] }
-                          end).
-
--spec bind_const(name(), aeso_syntax:ann(), type(), env()) -> env().
-bind_const(X, Ann, Type, Env) ->
-    case lookup_env(Env, term, Ann, [X]) of
-        false ->
-            on_current_scope(Env, fun(Scope = #scope{ consts = Consts }) ->
-                                    Scope#scope{ consts = [{X, {Ann, Type}} | Consts] }
-                                end);
-        _ ->
-            type_error({duplicate_definition, X, [Ann, aeso_syntax:get_ann(Type)]}),
-            Env
-    end.
-
-%% Bind state primitives
--spec bind_state(env()) -> env().
-bind_state(Env) ->
-    Ann   = [{origin, system}],
-    Unit  = {tuple_t, Ann, []},
-    State =
-        case lookup_type(Env, {id, Ann, "state"}) of
-            {S, _} -> {qid, Ann, S};
-            false  -> Unit
-        end,
-    Env1 = bind_funs([{"state", State},
-                      {"put", {type_sig, [stateful | Ann], none, [], [State], Unit}}], Env),
-
-    case lookup_type(Env, {id, Ann, "event"}) of
-        {E, _} ->
-            %% We bind Chain.event in a local 'Chain' namespace.
-            Event = {qid, Ann, E},
-            pop_scope(
-              bind_fun("event", {fun_t, Ann, [], [Event], Unit},
-              push_scope(namespace, {con, Ann, "Chain"}, Env1)));
-        false  -> Env1
-    end.
-
-%-spec bind_fields_append(env(), #{ name() => aeso_syntax:decl() }, type(), [aeso_syntax:field_t()]) -> env().
-bind_fields_append(Env, _TypeMap, _, []) -> Env;
-bind_fields_append(Env, TypeMap, RecTy, [{field_t, Ann, Id, Type} | Fields]) ->
-    Env1 = bind_field_append(name(Id), #field_info{ ann = Ann, kind = record, field_t = Type, record_t = RecTy }, Env),
-    bind_fields_append(Env1, TypeMap, RecTy, Fields).
-
--spec bind_field_append(name(), field_info(), env()) -> env().
-bind_field_append(X, Info, Env = #env{ fields = Fields }) ->
-    Fields1 = maps:update_with(X, fun(Infos) -> [Info | Infos] end, [Info], Fields),
-    Env#env{ fields = Fields1 }.
-
--spec bind_field_update(name(), field_info(), env()) -> env().
-bind_field_update(X, Info, Env = #env{ fields = Fields }) ->
-    Fields1 = maps:update_with(X, fun([_ | Infos]) -> [Info | Infos]; ([]) -> [Info] end, [Info], Fields),
-    Env#env{ fields = Fields1 }.
-
--spec bind_fields([{name(), field_info()}], typed | untyped, env()) -> env().
-bind_fields([], _Typing, Env) -> Env;
-bind_fields([{Id, Info} | Rest], Typing, Env) ->
-    NewEnv = case Typing of
-                 untyped -> bind_field_append(Id, Info, Env);
-                 typed   -> bind_field_update(Id, Info, Env)
-             end,
-    bind_fields(Rest, Typing, NewEnv).
-
-%% Contract entrypoints take three named arguments
-%%  gas       : int  = Call.gas_left()
-%%  value     : int  = 0
-%%  protected : bool = false
-contract_call_type({fun_t, Ann, [], Args, Ret}) ->
-    Id    = fun(X) -> {id, Ann, X} end,
-    Int   = Id("int"),
-    Typed = fun(E, T) -> {typed, Ann, E, T} end,
-    Named = fun(Name, Default = {typed, _, _, T}) -> {named_arg_t, Ann, Id(Name), T, Default} end,
-    {fun_t, Ann, [Named("gas",   Typed({app, Ann, Typed({qid, Ann, ["Call", "gas_left"]},
-                                                        {fun_t, Ann, [], [], Int}),
-                                        []}, Int)),
-                  Named("value", Typed({int, Ann, 0}, Int)),
-                  Named("protected", Typed({bool, Ann, false}, Id("bool")))],
-     Args, {if_t, Ann, Id("protected"), {app_t, Ann, {id, Ann, "option"}, [Ret]}, Ret}}.
-
--spec bind_contract(typed | untyped, aeso_syntax:decl(), env()) -> env().
-bind_contract(Typing, {Contract, Ann, Id, _Impls, Contents}, Env)
-  when ?IS_CONTRACT_HEAD(Contract) ->
-    Key         = name(Id),
-    Sys         = [{origin, system}],
-    TypeOrFresh = fun({typed, _, _, Type}) -> Type; (_) -> fresh_uvar(Sys) end,
-    Fields      =
-        [ {field_t, AnnF, Entrypoint, contract_call_type(Type)}
-          || {fun_decl, AnnF, Entrypoint, Type = {fun_t, _, _, _, _}} <- Contents ] ++
-        [ {field_t, AnnF, Entrypoint,
-           contract_call_type(
-             {fun_t, AnnF, [], [TypeOrFresh(Arg) || Arg <- Args], TypeOrFresh(Ret)})
-          }
-          || {letfun, AnnF, Entrypoint = {id, _, Name}, Args, _Type, [{guarded, _, [], Ret}]} <- Contents,
-             Name =/= "init"
-        ] ++
-        %% Predefined fields
-        [ {field_t, Sys, {id, Sys, "address"}, {id, Sys, "address"}} ] ++
-        [ {field_t, Sys, {id, Sys, ?CONSTRUCTOR_MOCK_NAME},
-           contract_call_type(
-             case [ [TypeOrFresh(Arg) || Arg <- Args]
-                    || {letfun, AnnF, {id, _, "init"}, Args, _, _} <- Contents,
-                       aeso_syntax:get_ann(entrypoint, AnnF, false)]
-                 ++ [ Args
-                      || {fun_decl, AnnF, {id, _, "init"}, {fun_t, _, _, Args, _}} <- Contents,
-                         aeso_syntax:get_ann(entrypoint, AnnF, false)]
-                 ++ [ Args
-                      || {fun_decl, AnnF, {id, _, "init"}, {type_sig, _, _, _, Args, _}} <- Contents,
-                         aeso_syntax:get_ann(entrypoint, AnnF, false)]
-             of
-                 [] -> {fun_t, [stateful,payable|Sys], [], [], {id, Sys, "void"}};
-                 [Args] -> {fun_t, [stateful,payable|Sys], [], Args, {id, Sys, "void"}}
-             end
-            )
-          }
-        ],
-    FieldInfo = [ {Entrypoint, #field_info{ ann      = FieldAnn,
-                                            kind     = contract,
-                                            field_t  = Type,
-                                            record_t = Id }}
-                || {field_t, _, {id, FieldAnn, Entrypoint}, Type} <- Fields ],
-    bind_type(Key, Ann, {[], {contract_t, Fields}},
-        bind_fields(FieldInfo, Typing, Env)).
-
-%% What scopes could a given name come from?
--spec possible_scopes(env(), qname()) -> [qname()].
-possible_scopes(#env{ namespace = Current, used_namespaces = UsedNamespaces }, Name) ->
-    Qual = lists:droplast(Name),
-    NewQuals = case lists:filter(fun(X) -> element(2, X) == Qual end, UsedNamespaces) of
-                   [] ->
-                       [Qual];
-                   Namespaces ->
-                       lists:map(fun(X) -> element(1, X) end, Namespaces)
-               end,
-    Ret1 = [ lists:sublist(Current, I) ++ Q || I <- lists:seq(0, length(Current)), Q <- NewQuals ],
-    Ret2 = [ Namespace ++ Q || {Namespace, none, _} <- UsedNamespaces, Q <- NewQuals ],
-    lists:usort(Ret1 ++ Ret2).
-
--spec visible_in_used_namespaces(used_namespaces(), qname()) -> boolean().
-visible_in_used_namespaces(UsedNamespaces, QName) ->
-    Qual = lists:droplast(QName),
-    Name = lists:last(QName),
-    case lists:filter(fun({Ns, _, _}) -> Qual == Ns end, UsedNamespaces) of
-        [] ->
-            true;
-        Namespaces ->
-            IsVisible = fun(Namespace) ->
-                            case Namespace of
-                                {_, _, {for, Names}} ->
-                                    lists:member(Name, Names);
-                                {_, _, {hiding, Names}} ->
-                                    not lists:member(Name, Names);
-                                _ ->
-                                    true
-                            end
-                        end,
-            lists:any(IsVisible, Namespaces)
-    end.
-
--spec lookup_type(env(), type_id()) -> false | {qname(), type_info()}.
-lookup_type(Env, Id) ->
-    lookup_env(Env, type, aeso_syntax:get_ann(Id), qname(Id)).
-
--spec lookup_env(env(), term, aeso_syntax:ann(), qname()) -> false | {qname(), fun_info()};
-                (env(), type, aeso_syntax:ann(), qname()) -> false | {qname(), type_info()}.
-lookup_env(Env, Kind, Ann, Name) ->
-    Var = case Name of
-            [X] when Kind == term -> proplists:get_value(X, Env#env.vars, false);
-            _                     -> false
-          end,
-    case Var of
-        {Ann1, Type} -> {Name, {Ann1, Type}};
-        false ->
-            Names = [ Qual ++ [lists:last(Name)] || Qual <- possible_scopes(Env, Name) ],
-            case [ Res || QName <- Names, Res <- [lookup_env1(Env, Kind, Ann, QName)], Res /= false] of
-                []    -> false;
-                [Res = {_, {AnnR, _}}] ->
-                    when_warning(warn_unused_includes,
-                                 fun() ->
-                                         %% If a file is used from a different file, we
-                                         %% can then mark it as used
-                                         F1 = proplists:get_value(file, Ann, no_file),
-                                         F2 = proplists:get_value(file, AnnR, no_file),
-                                         if
-                                             F1 /= F2 ->
-                                                 used_include(AnnR);
-                                             true ->
-                                                 ok
-                                         end
-                                 end),
-                    Res;
-                Many  ->
-                    type_error({ambiguous_name, qid(Ann, Name), [{qid, A, Q} || {Q, {A, _}} <- Many]}),
-                    false
-            end
-    end.
-
--spec lookup_env1(env(), type | term, aeso_syntax:ann(), qname()) -> false | {qname(), fun_info() | type_info()}.
-lookup_env1(#env{ namespace = Current, used_namespaces = UsedNamespaces, scopes = Scopes }, Kind, Ann, QName) ->
-    Qual = lists:droplast(QName),
-    Name = lists:last(QName),
-    QNameIsEvent = lists:suffix(["Chain", "event"], QName),
-    AllowPrivate = lists:prefix(Qual, Current),
-    %% Get the scope
-    case maps:get(Qual, Scopes, false) of
-        false -> false; %% TODO: return reason for not in scope
-        #scope{ funs = Funs, types = Types, consts = Consts, kind = ScopeKind } ->
-            Defs = case Kind of
-                     type -> Types;
-                     term -> Funs
-                   end,
-            %% Look up the unqualified name
-            case proplists:get_value(Name, Defs, false) of
-                false ->
-                    case proplists:get_value(Name, Consts, false) of
-                        false ->
-                            false;
-                        Const when AllowPrivate; ScopeKind == namespace ->
-                            {QName, Const};
-                        Const ->
-                            type_error({contract_treated_as_namespace_constant, Ann, QName}),
-                            {QName, Const}
-                    end;
-                {reserved_init, Ann1, Type} ->
-                    type_error({cannot_call_init_function, Ann}),
-                    {QName, {Ann1, Type}};  %% Return the type to avoid an extra not-in-scope error
-                {contract_fun, Ann1, Type} when AllowPrivate orelse QNameIsEvent ->
-                    {QName, {Ann1, Type}};
-                {contract_fun, Ann1, Type} ->
-                    type_error({contract_treated_as_namespace_entrypoint, Ann, QName}),
-                    {QName, {Ann1, Type}};
-                {Ann1, _} = E ->
-                    %% Check that it's not private (or we can see private funs)
-                    case not is_private(Ann1) orelse AllowPrivate of
-                        true  ->
-                            case visible_in_used_namespaces(UsedNamespaces, QName) of
-                                true -> {QName, E};
-                                false -> false
-                            end;
-                        false -> false
-                    end
-            end
-    end.
-
--spec lookup_record_field(env(), name()) -> [field_info()].
-lookup_record_field(Env, FieldName) ->
-    maps:get(FieldName, Env#env.fields, []).
-
-%% For 'create' or 'update' constraints we don't consider contract types.
--spec lookup_record_field(env(), name(), create | project | update) -> [field_info()].
-lookup_record_field(Env, FieldName, Kind) ->
-    [ Fld || Fld = #field_info{ kind = K } <- lookup_record_field(Env, FieldName),
-             Kind == project orelse K /= contract ].
-
-lookup_record_field_arity(Env, FieldName, Arity, Kind) ->
-    Fields = lookup_record_field(Env, FieldName, Kind),
-    [ Fld || Fld = #field_info{ field_t = FldType } <- Fields,
-             aeso_tc_type_utils:fun_arity(aeso_tc_type_utils:dereference_deep(FldType)) == Arity ].
-
-is_private(Ann) -> proplists:get_value(private, Ann, false).
-
-option_t(As, T) -> {app_t, As, {id, As, "option"}, [T]}.
-
-init_env() -> init_env([]).
-
-init_env(_Options) -> global_env().
-
--spec empty_env() -> env().
-empty_env() -> #env{}.
-
-%% Environment containing language primitives
--spec global_env() -> env().
-global_env() ->
-    Ann     = [{origin, system}],
-    Int     = {id, Ann, "int"},
-    Char    = {id, Ann, "char"},
-    Bool    = {id, Ann, "bool"},
-    String  = {id, Ann, "string"},
-    Address = {id, Ann, "address"},
-    Hash    = {id, Ann, "hash"},
-    Bits    = {id, Ann, "bits"},
-    Bytes   = fun(Len) -> {bytes_t, Ann, Len} end,
-    Oracle  = fun(Q, R) -> {app_t, Ann, {id, Ann, "oracle"}, [Q, R]} end,
-    Query   = fun(Q, R) -> {app_t, Ann, {id, Ann, "oracle_query"}, [Q, R]} end,
-    Unit    = {tuple_t, Ann, []},
-    List    = fun(T) -> {app_t, Ann, {id, Ann, "list"}, [T]} end,
-    Option  = fun(T) -> {app_t, Ann, {id, Ann, "option"}, [T]} end,
-    Map     = fun(A, B) -> {app_t, Ann, {id, Ann, "map"}, [A, B]} end,
-    Pair    = fun(A, B) -> {tuple_t, Ann, [A, B]} end,
-    FunC    = fun(C, Ts, T) -> {type_sig, Ann, C, [], Ts, T} end,
-    FunC1   = fun(C, S, T) -> {type_sig, Ann, C, [], [S], T} end,
-    Fun     = fun(Ts, T) -> FunC(none, Ts, T) end,
-    Fun1    = fun(S, T) -> Fun([S], T) end,
-    FunCN   = fun(C, Named, Normal, Ret) -> {type_sig, Ann, C, Named, Normal, Ret} end,
-    FunN    = fun(Named, Normal, Ret) -> FunCN(none, Named, Normal, Ret) end,
-    %% Lambda    = fun(Ts, T) -> {fun_t, Ann, [], Ts, T} end,
-    %% Lambda1   = fun(S, T) -> Lambda([S], T) end,
-    StateFun  = fun(Ts, T) -> {type_sig, [stateful|Ann], none, [], Ts, T} end,
-    TVar      = fun(X) -> {tvar, Ann, "'" ++ X} end,
-    SignId    = {id, Ann, "signature"},
-    SignDef   = {bytes, Ann, <<0:64/unit:8>>},
-    Signature = {named_arg_t, Ann, SignId, SignId, {typed, Ann, SignDef, SignId}},
-    SignFun   = fun(Ts, T) -> {type_sig, [stateful|Ann], none, [Signature], Ts, T} end,
-    TTL       = {qid, Ann, ["Chain", "ttl"]},
-    Pointee   = {qid, Ann, ["AENS", "pointee"]},
-    AENSName  = {qid, Ann, ["AENS", "name"]},
-    Fr        = {qid, Ann, ["MCL_BLS12_381", "fr"]},
-    Fp        = {qid, Ann, ["MCL_BLS12_381", "fp"]},
-    Fp2       = {tuple_t, Ann, [Fp, Fp]},
-    G1        = {tuple_t, Ann, [Fp, Fp, Fp]},
-    G2        = {tuple_t, Ann, [Fp2, Fp2, Fp2]},
-    GT        = {tuple_t, Ann, lists:duplicate(12, Fp)},
-    Tx        = {qid, Ann, ["Chain", "tx"]},
-    GAMetaTx  = {qid, Ann, ["Chain", "ga_meta_tx"]},
-    BaseTx    = {qid, Ann, ["Chain", "base_tx"]},
-    PayForTx  = {qid, Ann, ["Chain", "paying_for_tx"]},
-
-    FldT      = fun(Id, T) -> {field_t, Ann, {id, Ann, Id}, T} end,
-    TxFlds    = [{"paying_for", Option(PayForTx)}, {"ga_metas", List(GAMetaTx)},
-                 {"actor", Address}, {"fee", Int}, {"ttl", Int}, {"tx", BaseTx}],
-    TxType    = {record_t, [FldT(N, T) || {N, T} <- TxFlds ]},
-    Stateful  = fun(T) -> setelement(2, T, [stateful|element(2, T)]) end,
-
-    Fee       = Int,
-    [A, Q, R, K, V] = lists:map(TVar, ["a", "q", "r", "k", "v"]),
-
-    MkDefs = fun(Defs) -> [{X, {Ann, if is_integer(T) -> {builtin, T}; true -> T end}} || {X, T} <- Defs] end,
-
-    TopScope = #scope
-        { funs  = MkDefs(
-                     %% Option constructors
-                    [{"None", Option(A)},
-                     {"Some", Fun1(A, Option(A))},
-                     %% TTL constructors
-                     {"RelativeTTL", Fun1(Int, TTL)},
-                     {"FixedTTL",    Fun1(Int, TTL)},
-                     %% Abort/exit
-                     {"abort", Fun1(String, A)},
-                     {"exit", Fun1(String, A)},
-                     {"require", Fun([Bool, String], Unit)}])
-        , types = MkDefs(
-                    [{"int", 0}, {"bool", 0}, {"char", 0}, {"string", 0}, {"address", 0},
-                     {"void", 0},
-                     {"unit", {[], {alias_t, Unit}}},
-                     {"hash", {[], {alias_t, Bytes(32)}}},
-                     {"signature", {[], {alias_t, Bytes(64)}}},
-                     {"bits", 0},
-                     {"option", 1}, {"list", 1}, {"map", 2},
-                     {"oracle", 2}, {"oracle_query", 2}
-                     ]) },
-
-    ChainScope = #scope
-        { funs = MkDefs(
-                     %% Spend transaction.
-                    [{"spend",        StateFun([Address, Int], Unit)},
-                     %% Chain environment
-                     {"balance",      Fun1(Address, Int)},
-                     {"block_hash",   Fun1(Int, Option(Hash))},
-                     {"coinbase",     Address},
-                     {"timestamp",    Int},
-                     {"block_height", Int},
-                     {"difficulty",   Int},
-                     {"gas_limit",    Int},
-                     {"bytecode_hash",FunC1(bytecode_hash, A, Option(Hash))},
-                     {"create",       Stateful(
-                                        FunN([ {named_arg_t, Ann, {id, Ann, "value"}, Int, {typed, Ann, {int, Ann, 0}, Int}}
-                                             ], var_args, A))},
-                     {"clone",        Stateful(
-                                        FunN([ {named_arg_t, Ann, {id, Ann, "gas"}, Int,
-                                                {typed, Ann,
-                                                 {app, Ann,
-                                                  {typed, Ann, {qid, Ann, ["Call","gas_left"]},
-                                                   aeso_tc_type_utils:typesig_to_fun_t(Fun([], Int))
-                                                  },
-                                                  []}, Int
-                                                }}
-                                             , {named_arg_t, Ann, {id, Ann, "value"}, Int, {typed, Ann, {int, Ann, 0}, Int}}
-                                             , {named_arg_t, Ann, {id, Ann, "protected"}, Bool, {typed, Ann, {bool, Ann, false}, Bool}}
-                                             , {named_arg_t, Ann, {id, Ann, "ref"}, A, undefined}
-                                             ], var_args, A))},
-                     %% Tx constructors
-                     {"GAMetaTx",     Fun([Address, Int], GAMetaTx)},
-                     {"PayingForTx",  Fun([Address, Int], PayForTx)},
-                     {"SpendTx",      Fun([Address, Int, String], BaseTx)},
-                     {"OracleRegisterTx",       BaseTx},
-                     {"OracleQueryTx",          BaseTx},
-                     {"OracleResponseTx",       BaseTx},
-                     {"OracleExtendTx",         BaseTx},
-                     {"NamePreclaimTx",         BaseTx},
-                     {"NameClaimTx",            Fun([String], BaseTx)},
-                     {"NameUpdateTx",           Fun([Hash], BaseTx)},
-                     {"NameRevokeTx",           Fun([Hash], BaseTx)},
-                     {"NameTransferTx",         Fun([Address, Hash], BaseTx)},
-                     {"ChannelCreateTx",        Fun([Address], BaseTx)},
-                     {"ChannelDepositTx",       Fun([Address, Int], BaseTx)},
-                     {"ChannelWithdrawTx",      Fun([Address, Int], BaseTx)},
-                     {"ChannelForceProgressTx", Fun([Address], BaseTx)},
-                     {"ChannelCloseMutualTx",   Fun([Address], BaseTx)},
-                     {"ChannelCloseSoloTx",     Fun([Address], BaseTx)},
-                     {"ChannelSlashTx",         Fun([Address], BaseTx)},
-                     {"ChannelSettleTx",        Fun([Address], BaseTx)},
-                     {"ChannelSnapshotSoloTx",  Fun([Address], BaseTx)},
-                     {"ContractCreateTx",       Fun([Int], BaseTx)},
-                     {"ContractCallTx",         Fun([Address, Int], BaseTx)},
-                     {"GAAttachTx",             BaseTx}
-                    ])
-        , types = MkDefs([{"ttl", 0}, {"tx", {[], TxType}},
-                          {"base_tx", 0},
-                          {"paying_for_tx", 0}, {"ga_meta_tx", 0}]) },
-
-    ContractScope = #scope
-        { funs = MkDefs(
-                    [{"address", Address},
-                     {"creator", Address},
-                     {"balance", Int}]) },
-
-    CallScope = #scope
-        { funs = MkDefs(
-                    [{"origin",    Address},
-                     {"caller",    Address},
-                     {"value",     Int},
-                     {"gas_price", Int},
-                     {"fee",       Int},
-                     {"gas_left",  Fun([], Int)}])
-        },
-
-    OracleScope = #scope
-        { funs = MkDefs(
-                    [{"register",     SignFun([Address, Fee, TTL], Oracle(Q, R))},
-                     {"expiry",       Fun([Oracle(Q, R)], Fee)},
-                     {"query_fee",    Fun([Oracle(Q, R)], Fee)},
-                     {"query",        StateFun([Oracle(Q, R), Q, Fee, TTL, TTL], Query(Q, R))},
-                     {"get_question", Fun([Oracle(Q, R), Query(Q, R)], Q)},
-                     {"respond",      SignFun([Oracle(Q, R), Query(Q, R), R], Unit)},
-                     {"extend",       SignFun([Oracle(Q, R), TTL], Unit)},
-                     {"get_answer",   Fun([Oracle(Q, R), Query(Q, R)], option_t(Ann, R))},
-                     {"check",        Fun([Oracle(Q, R)], Bool)},
-                     {"check_query",  Fun([Oracle(Q,R), Query(Q, R)], Bool)}]) },
-
-    AENSScope = #scope
-        { funs = MkDefs(
-                     [{"resolve",  Fun([String, String], option_t(Ann, A))},
-                      {"preclaim", SignFun([Address, Hash], Unit)},
-                      {"claim",    SignFun([Address, String, Int, Int], Unit)},
-                      {"transfer", SignFun([Address, Address, String], Unit)},
-                      {"revoke",   SignFun([Address, String], Unit)},
-                      {"update",   SignFun([Address, String, Option(TTL), Option(Int), Option(Map(String, Pointee))], Unit)},
-                      {"lookup",   Fun([String], option_t(Ann, AENSName))},
-                      %% AENS pointee constructors
-                      {"AccountPt",  Fun1(Address, Pointee)},
-                      {"OraclePt",   Fun1(Address, Pointee)},
-                      {"ContractPt", Fun1(Address, Pointee)},
-                      {"ChannelPt",  Fun1(Address, Pointee)},
-                      %% Name object constructor
-                      {"Name",   Fun([Address, TTL, Map(String, Pointee)], AENSName)}
-                     ])
-        , types = MkDefs([{"pointee", 0}, {"name", 0}]) },
-
-    MapScope = #scope
-        { funs = MkDefs(
-                     [{"from_list",      Fun1(List(Pair(K, V)), Map(K, V))},
-                      {"to_list",        Fun1(Map(K, V), List(Pair(K, V)))},
-                      {"lookup",         Fun([K, Map(K, V)], Option(V))},
-                      {"lookup_default", Fun([K, Map(K, V), V], V)},
-                      {"delete",         Fun([K, Map(K, V)], Map(K, V))},
-                      {"member",         Fun([K, Map(K, V)], Bool)},
-                      {"size",           Fun1(Map(K, V), Int)}]) },
-
-    %% Crypto/Curve operations
-    CryptoScope = #scope
-        { funs = MkDefs(
-                     [{"verify_sig",           Fun([Hash, Address, SignId], Bool)},
-                      {"verify_sig_secp256k1", Fun([Hash, Bytes(64), SignId], Bool)},
-                      {"ecverify_secp256k1",   Fun([Hash, Bytes(20), Bytes(65)], Bool)},
-                      {"ecrecover_secp256k1",  Fun([Hash, Bytes(65)], Option(Bytes(20)))},
-                      {"sha3",     Fun1(A, Hash)},
-                      {"sha256",   Fun1(A, Hash)},
-                      {"blake2b",  Fun1(A, Hash)}]) },
-
-    %% Fancy BLS12-381 crypto operations
-    MCL_BLS12_381_Scope = #scope
-        { funs = MkDefs(
-                     [{"g1_neg",     Fun1(G1, G1)},
-                      {"g1_norm",    Fun1(G1, G1)},
-                      {"g1_valid",   Fun1(G1, Bool)},
-                      {"g1_is_zero", Fun1(G1, Bool)},
-                      {"g1_add",     Fun ([G1, G1], G1)},
-                      {"g1_mul",     Fun ([Fr, G1], G1)},
-
-                      {"g2_neg",     Fun1(G2, G2)},
-                      {"g2_norm",    Fun1(G2, G2)},
-                      {"g2_valid",   Fun1(G2, Bool)},
-                      {"g2_is_zero", Fun1(G2, Bool)},
-                      {"g2_add",     Fun ([G2, G2], G2)},
-                      {"g2_mul",     Fun ([Fr, G2], G2)},
-
-                      {"gt_inv",      Fun1(GT, GT)},
-                      {"gt_add",      Fun ([GT, GT], GT)},
-                      {"gt_mul",      Fun ([GT, GT], GT)},
-                      {"gt_pow",      Fun ([GT, Fr], GT)},
-                      {"gt_is_one",   Fun1(GT, Bool)},
-                      {"pairing",     Fun ([G1, G2], GT)},
-                      {"miller_loop", Fun ([G1, G2], GT)},
-                      {"final_exp",   Fun1(GT, GT)},
-
-                      {"int_to_fr", Fun1(Int, Fr)},
-                      {"int_to_fp", Fun1(Int, Fp)},
-                      {"fr_to_int", Fun1(Fr, Int)},
-                      {"fp_to_int", Fun1(Fp, Int)}
-                     ]),
-          types = MkDefs(
-                     [{"fr",  0}, {"fp",  0}]) },
-
-    %% Authentication
-    AuthScope = #scope
-        { funs = MkDefs(
-                     [{"tx_hash", Option(Hash)},
-                      {"tx",      Option(Tx)}  ]) },
-
-    %% Strings
-    StringScope = #scope
-        { funs = MkDefs(
-                     [{"length",    Fun1(String, Int)},
-                      {"concat",    Fun([String, String], String)},
-                      {"to_list",   Fun1(String, List(Char))},
-                      {"from_list", Fun1(List(Char), String)},
-                      {"to_upper",  Fun1(String, String)},
-                      {"to_lower",  Fun1(String, String)},
-                      {"sha3",      Fun1(String, Hash)},
-                      {"sha256",    Fun1(String, Hash)},
-                      {"blake2b",   Fun1(String, Hash)}
-                     ]) },
-
-    %% Chars
-    CharScope = #scope
-        { funs = MkDefs(
-                     [{"to_int",   Fun1(Char, Int)},
-                      {"from_int", Fun1(Int, Option(Char))}]) },
-
-    %% Bits
-    BitsScope = #scope
-        { funs = MkDefs(
-                     [{"set",          Fun([Bits, Int], Bits)},
-                      {"clear",        Fun([Bits, Int], Bits)},
-                      {"test",         Fun([Bits, Int], Bool)},
-                      {"sum",          Fun1(Bits, Int)},
-                      {"intersection", Fun([Bits, Bits], Bits)},
-                      {"union",        Fun([Bits, Bits], Bits)},
-                      {"difference",   Fun([Bits, Bits], Bits)},
-                      {"none",         Bits},
-                      {"all",          Bits}]) },
-
-    %% Bytes
-    BytesScope = #scope
-        { funs = MkDefs(
-                   [{"to_int", Fun1(Bytes(any), Int)},
-                    {"to_str", Fun1(Bytes(any), String)},
-                    {"concat", FunC(bytes_concat, [Bytes(any), Bytes(any)], Bytes(any))},
-                    {"split",  FunC(bytes_split, [Bytes(any)], Pair(Bytes(any), Bytes(any)))}
-                   ]) },
-
-    %% Conversion
-    IntScope     = #scope{ funs = MkDefs([{"to_str", Fun1(Int,     String)}]) },
-    AddressScope = #scope{ funs = MkDefs([{"to_str", Fun1(Address, String)},
-                                          {"to_contract", FunC(address_to_contract, [Address], A)},
-                                          {"is_oracle", Fun1(Address, Bool)},
-                                          {"is_contract", Fun1(Address, Bool)},
-                                          {"is_payable", Fun1(Address, Bool)}]) },
-
-
-    #env{ scopes =
-            #{ []           => TopScope
-             , ["Chain"]    => ChainScope
-             , ["Contract"] => ContractScope
-             , ["Call"]     => CallScope
-             , ["Oracle"]   => OracleScope
-             , ["AENS"]     => AENSScope
-             , ["Map"]      => MapScope
-             , ["Auth"]     => AuthScope
-             , ["Crypto"]   => CryptoScope
-             , ["MCL_BLS12_381"] => MCL_BLS12_381_Scope
-             , ["StringInternal"] => StringScope
-             , ["Char"]     => CharScope
-             , ["Bits"]     => BitsScope
-             , ["Bytes"]    => BytesScope
-             , ["Int"]      => IntScope
-             , ["Address"]  => AddressScope
-             }
-          , fields =
-             maps:from_list([{N, [#field_info{ ann = [], field_t = T, record_t = Tx, kind = record }]}
-                             || {N, T} <- TxFlds ])
-        }.
-
-destroy_and_report_type_errors(Env) ->
-    Errors0 = lists:reverse(aeso_tc_ets_manager:ets_tab2list(type_errors)),
-    %% io:format("Type errors now: ~p\n", [Errors0]),
-    aeso_tc_errors:destroy_type_errors(),
-    Errors  = [ aeso_tc_errors:mk_error(unqualify(Env, Err)) || Err <- Errors0 ],
-    aeso_errors:throw(Errors).  %% No-op if Errors == []
-
-%% Strip current namespace from error message for nicer printing.
-unqualify(Env, {qid, Ann, Xs}) ->
-    qid(Ann, unqualify1(aeso_tc_env:namespace(Env), Xs));
-unqualify(Env, {qcon, Ann, Xs}) ->
-    qcon(Ann, unqualify1(aeso_tc_env:namespace(Env), Xs));
-unqualify(Env, T) when is_tuple(T) ->
-    list_to_tuple(unqualify(Env, tuple_to_list(T)));
-unqualify(Env, [H | T]) -> [unqualify(Env, H) | unqualify(Env, T)];
-unqualify(_Env, X) -> X.
-
-unqualify1(NS, Xs) ->
-    try lists:split(length(NS), Xs) of
-        {NS, Ys} -> Ys;
-        _        -> Xs
-    catch _:_ -> Xs
-    end.

src/aeso_tc_errors.erl

@@ -1,499 +0,0 @@
--module(aeso_tc_errors).
-
--include("aeso_utils.hrl").
-
--export([cannot_unify/4
-        , type_error/1
-        , create_type_errors/0
-        , destroy_type_errors/0
-        , mk_error/1
-        ]).
-
-%% -- Moved functions --------------------------------------------------------
-
-name(A) -> aeso_tc_name_manip:name(A).
-
-%% -------
-
-pos(A) -> aeso_tc_ann_manip:pos(A).
-pos(A, B) -> aeso_tc_ann_manip:pos(A, B).
-
-%% -------
-
-pp(A) -> aeso_tc_pp:pp(A).
-pp_type(A) -> aeso_tc_pp:pp_type(A).
-pp_type(A, B) -> aeso_tc_pp:pp_type(A, B).
-pp_typed(A, B, C) -> aeso_tc_pp:pp_typed(A, B, C).
-pp_expr(A) -> aeso_tc_pp:pp_expr(A).
-pp_why_record(A) -> aeso_tc_pp:pp_why_record(A).
-pp_when(A) -> aeso_tc_pp:pp_when(A).
-pp_loc(A) -> aeso_tc_pp:pp_loc(A).
-
-%% ---------------------------------------------------------------------------
-
-%% Save unification failures for error messages.
-cannot_unify(A, B, Cxt, When) ->
-    type_error({cannot_unify, A, B, Cxt, When}).
-
-type_error(Err) ->
-    aeso_tc_ets_manager:ets_insert(type_errors, Err).
-
-create_type_errors() ->
-    aeso_tc_ets_manager:ets_new(type_errors, [bag]).
-
-destroy_type_errors() ->
-    aeso_tc_ets_manager:ets_delete(type_errors).
-
-mk_t_err(Pos, Msg) ->
-    aeso_errors:new(type_error, Pos, lists:flatten(Msg)).
-mk_t_err(Pos, Msg, Ctxt) ->
-    aeso_errors:new(type_error, Pos, lists:flatten(Msg), lists:flatten(Ctxt)).
-
-mk_error({no_decls, File}) ->
-    Pos = aeso_errors:pos(File, 0, 0),
-    mk_t_err(Pos, "Empty contract");
-mk_error({mismatched_decl_in_funblock, Name, Decl}) ->
-    Msg = io_lib:format("Mismatch in the function block. Expected implementation/type declaration of ~s function", [Name]),
-    mk_t_err(pos(Decl), Msg);
-mk_error({higher_kinded_typevar, T}) ->
-    Msg = io_lib:format("Type `~s` is a higher kinded type variable "
-                        "(takes another type as an argument)", [pp(aeso_tc_type_utils:instantiate(T))]
-                       ),
-    mk_t_err(pos(T), Msg);
-mk_error({wrong_type_arguments, X, ArityGiven, ArityReal}) ->
-    Msg = io_lib:format("Arity for ~s doesn't match. Expected ~p, got ~p"
-                       , [pp(aeso_tc_type_utils:instantiate(X)), ArityReal, ArityGiven]
-                       ),
-    mk_t_err(pos(X), Msg);
-mk_error({unnamed_map_update_with_default, Upd}) ->
-    Msg = "Invalid map update with default",
-    mk_t_err(pos(Upd), Msg);
-mk_error({fundecl_must_have_funtype, _Ann, Id, Type}) ->
-    Msg = io_lib:format("`~s` was declared with an invalid type `~s`. "
-                       "Entrypoints and functions must have functional types"
-                       , [pp(Id), pp(aeso_tc_type_utils:instantiate(Type))]),
-    mk_t_err(pos(Id), Msg);
-mk_error({cannot_unify, A, B, Cxt, When}) ->
-    VarianceContext = case Cxt of
-                          none -> "";
-                          _    -> io_lib:format(" in a ~p context", [Cxt])
-                      end,
-    Msg = io_lib:format("Cannot unify `~s` and `~s`" ++ VarianceContext,
-                        [pp(aeso_tc_type_utils:instantiate(A)), pp(aeso_tc_type_utils:instantiate(B))]),
-    {Pos, Ctxt} = pp_when(When),
-    mk_t_err(Pos, Msg, Ctxt);
-mk_error({hole_found, Ann, Type}) ->
-    Msg = io_lib:format("Found a hole of type `~s`", [pp(aeso_tc_type_utils:instantiate(Type))]),
-    mk_t_err(pos(Ann), Msg);
-mk_error({unbound_variable, Id}) ->
-    Msg = io_lib:format("Unbound variable `~s`", [pp(Id)]),
-    case Id of
-        {qid, _, ["Chain", "event"]} ->
-            Cxt = "Did you forget to define the event type?",
-            mk_t_err(pos(Id), Msg, Cxt);
-        _ -> mk_t_err(pos(Id), Msg)
-    end;
-mk_error({undefined_field, Id}) ->
-    Msg = io_lib:format("Unbound field ~s", [pp(Id)]),
-    mk_t_err(pos(Id), Msg);
-mk_error({not_a_record_type, Type, Why}) ->
-    Msg = io_lib:format("Not a record type: `~s`", [pp_type(Type)]),
-    {Pos, Ctxt} = pp_why_record(Why),
-    mk_t_err(Pos, Msg, Ctxt);
-mk_error({not_a_contract_type, Type, Cxt}) ->
-    Msg =
-        case Type of
-            {tvar, _, _} ->
-                "Unresolved contract type";
-            _ ->
-                io_lib:format("The type `~s` is not a contract type", [pp_type(Type)])
-        end,
-    {Pos, Cxt1} =
-        case Cxt of
-            {var_args, Ann, Fun} ->
-                {pos(Ann),
-                 io_lib:format("when calling variadic function `~s`", [pp_expr(Fun)])};
-            {contract_literal, Lit} ->
-                {pos(Lit),
-                 io_lib:format("when checking that the contract literal `~s` has the type `~s`",
-                               [pp_expr(Lit), pp_type(Type)])};
-            {address_to_contract, Ann} ->
-                {pos(Ann),
-                 io_lib:format("when checking that the call to `Address.to_contract` has the type `~s`",
-                               [pp_type(Type)])}
-        end,
-    mk_t_err(Pos, Msg, Cxt1);
-mk_error({non_linear_pattern, Pattern, Nonlinear}) ->
-    Msg = io_lib:format("Repeated name~s ~s in the pattern `~s`",
-                        [plural("", "s", Nonlinear),
-                         string:join(lists:map(fun(F) -> "`" ++ F ++ "`" end, Nonlinear), ", "),
-                         pp_expr(Pattern)]),
-    mk_t_err(pos(Pattern), Msg);
-mk_error({ambiguous_record, Fields = [{_, First} | _], Candidates}) ->
-    Msg = io_lib:format("Ambiguous record type with field~s ~s could be one of~s",
-                        [plural("", "s", Fields),
-                         string:join([ "`" ++ pp(F) ++ "`" || {_, F} <- Fields ], ", "),
-                         [ ["\n  - ", "`" ++ pp(C) ++ "`", " (at ", pp_loc(C), ")"] || C <- Candidates ]]),
-    mk_t_err(pos(First), Msg);
-mk_error({missing_field, Field, Rec}) ->
-    Msg = io_lib:format("Record type `~s` does not have field `~s`",
-                        [pp(Rec), pp(Field)]),
-    mk_t_err(pos(Field), Msg);
-mk_error({missing_fields, Ann, RecType, Fields}) ->
-    Msg = io_lib:format("The field~s ~s ~s missing when constructing an element of type `~s`",
-                        [plural("", "s", Fields),
-                         string:join(lists:map(fun(F) -> "`" ++ F ++ "`" end, Fields), ", "),
-                         plural("is", "are", Fields), pp(RecType)]),
-    mk_t_err(pos(Ann), Msg);
-mk_error({no_records_with_all_fields, Fields = [{_, First} | _]}) ->
-    Msg = io_lib:format("No record type with field~s ~s",
-                        [plural("", "s", Fields),
-                         string:join([ "`" ++ pp(F) ++ "`" || {_, F} <- Fields ], ", ")]),
-    mk_t_err(pos(First), Msg);
-mk_error({recursive_types_not_implemented, Types}) ->
-    S = plural(" is", "s are mutually", Types),
-    Msg = io_lib:format("The following type~s recursive, which is not yet supported:~s",
-                        [S, [io_lib:format("\n  - `~s` (at ~s)", [pp(T), pp_loc(T)]) || T <- Types]]),
-    mk_t_err(pos(hd(Types)), Msg);
-mk_error({event_must_be_variant_type, Where}) ->
-    Msg = io_lib:format("The event type must be a variant type", []),
-    mk_t_err(pos(Where), Msg);
-mk_error({indexed_type_must_be_word, Type, Type}) ->
-    Msg = io_lib:format("The indexed type `~s` is not a word type",
-                        [pp_type(Type)]),
-    mk_t_err(pos(Type), Msg);
-mk_error({indexed_type_must_be_word, Type, Type1}) ->
-    Msg = io_lib:format("The indexed type `~s` equals `~s` which is not a word type",
-                        [pp_type(Type), pp_type(Type1)]),
-    mk_t_err(pos(Type), Msg);
-mk_error({event_0_to_3_indexed_values, Constr}) ->
-    Msg = io_lib:format("The event constructor `~s` has too many indexed values (max 3)",
-                        [name(Constr)]),
-    mk_t_err(pos(Constr), Msg);
-mk_error({event_0_to_1_string_values, Constr}) ->
-    Msg = io_lib:format("The event constructor `~s` has too many non-indexed values (max 1)",
-                        [name(Constr)]),
-    mk_t_err(pos(Constr), Msg);
-mk_error({repeated_constructor, Cs}) ->
-    Msg = io_lib:format("Variant types must have distinct constructor names~s",
-                        [[ io_lib:format("\n`~s`  (at ~s)", [pp_typed("  - ", C, T), pp_loc(C)]) || {C, T} <- Cs ]]),
-    mk_t_err(pos(element(1, hd(Cs))), Msg);
-mk_error({bad_named_argument, [], Name}) ->
-    Msg = io_lib:format("Named argument ~s supplied to function expecting no named arguments.",
-                        [pp(Name)]),
-    mk_t_err(pos(Name), Msg);
-mk_error({bad_named_argument, Args, Name}) ->
-    Msg = io_lib:format("Named argument `~s` is not one of the expected named arguments~s",
-                        [pp(Name),
-                        [ io_lib:format("\n  - `~s`", [pp_typed("", Arg, Type)])
-                          || {named_arg_t, _, Arg, Type, _} <- Args ]]),
-    mk_t_err(pos(Name), Msg);
-mk_error({unsolved_named_argument_constraint, Name, Type}) ->
-    Msg = io_lib:format("Named argument ~s supplied to function with unknown named arguments.",
-                        [pp_typed("", Name, Type)]),
-    mk_t_err(pos(Name), Msg);
-mk_error({reserved_entrypoint, Name, Def}) ->
-    Msg = io_lib:format("The name '~s' is reserved and cannot be used for a "
-                        "top-level contract function.", [Name]),
-    mk_t_err(pos(Def), Msg);
-mk_error({duplicate_definition, Name, Locs}) ->
-    Msg = io_lib:format("Duplicate definitions of `~s` at~s",
-                        [Name, [ ["\n  - ", pp_loc(L)] || L <- Locs ]]),
-    mk_t_err(pos(lists:last(Locs)), Msg);
-mk_error({duplicate_scope, Kind, Name, OtherKind, L}) ->
-    Msg = io_lib:format("The ~p `~s` has the same name as a ~p at ~s",
-                        [Kind, pp(Name), OtherKind, pp_loc(L)]),
-    mk_t_err(pos(Name), Msg);
-mk_error({include, _, {string, Pos, Name}}) ->
-    Msg = io_lib:format("Include of `~s` is not allowed, include only allowed at top level.",
-                        [binary_to_list(Name)]),
-    mk_t_err(pos(Pos), Msg);
-mk_error({namespace, _Pos, {con, Pos, Name}, _Def}) ->
-    Msg = io_lib:format("Nested namespaces are not allowed. Namespace `~s` is not defined at top level.",
-                        [Name]),
-    mk_t_err(pos(Pos), Msg);
-mk_error({Contract, _Pos, {con, Pos, Name}, _Impls, _Def}) when ?IS_CONTRACT_HEAD(Contract) ->
-    Msg = io_lib:format("Nested contracts are not allowed. Contract `~s` is not defined at top level.",
-                        [Name]),
-    mk_t_err(pos(Pos), Msg);
-mk_error({type_decl, _, {id, Pos, Name}, _}) ->
-    Msg = io_lib:format("Empty type declarations are not supported. Type `~s` lacks a definition",
-                        [Name]),
-    mk_t_err(pos(Pos), Msg);
-mk_error({stateful_not_allowed, Id, Fun}) ->
-    Msg = io_lib:format("Cannot reference stateful function `~s` in the definition of non-stateful function `~s`.",
-                        [pp(Id), pp(Fun)]),
-    mk_t_err(pos(Id), Msg);
-mk_error({stateful_not_allowed_in_guards, Id}) ->
-    Msg = io_lib:format("Cannot reference stateful function `~s` in a pattern guard.",
-                        [pp(Id)]),
-    mk_t_err(pos(Id), Msg);
-mk_error({value_arg_not_allowed, Value, Fun}) ->
-    Msg = io_lib:format("Cannot pass non-zero value argument `~s` in the definition of non-stateful function `~s`.",
-                        [pp_expr(Value), pp(Fun)]),
-    mk_t_err(pos(Value), Msg);
-mk_error({init_depends_on_state, Which, [_Init | Chain]}) ->
-    WhichCalls = fun("put") -> ""; ("state") -> ""; (_) -> ", which calls" end,
-    Msg = io_lib:format("The `init` function should return the initial state as its result and cannot ~s the state, but it calls~s",
-                        [if Which == put -> "write"; true -> "read" end,
-                         [ io_lib:format("\n  - `~s` (at ~s)~s", [Fun, pp_loc(Ann), WhichCalls(Fun)])
-                           || {[_, Fun], Ann} <- Chain]]),
-    mk_t_err(pos(element(2, hd(Chain))), Msg);
-mk_error({missing_body_for_let, Ann}) ->
-    Msg = io_lib:format("Let binding must be followed by an expression.", []),
-    mk_t_err(pos(Ann), Msg);
-mk_error({public_modifier_in_contract, Decl}) ->
-    Decl1 = mk_entrypoint(Decl),
-    Msg = io_lib:format("Use `entrypoint` instead of `function` for public function `~s`: `~s`",
-                        [pp_expr(element(3, Decl)),
-                         prettypr:format(aeso_pretty:decl(Decl1))]),
-    mk_t_err(pos(Decl), Msg);
-mk_error({init_must_be_an_entrypoint, Decl}) ->
-    Decl1 = mk_entrypoint(Decl),
-    Msg = io_lib:format("The init function must be an entrypoint: ~s",
-                        [prettypr:format(prettypr:nest(2, aeso_pretty:decl(Decl1)))]),
-    mk_t_err(pos(Decl), Msg);
-mk_error({init_must_not_be_payable, Decl}) ->
-    Msg = io_lib:format("The init function cannot be payable. "
-                        "You don't need the 'payable' annotation to be able to attach "
-                        "funds to the create contract transaction.",
-                        []),
-    mk_t_err(pos(Decl), Msg);
-mk_error({proto_must_be_entrypoint, Decl}) ->
-    Decl1 = mk_entrypoint(Decl),
-    Msg = io_lib:format("Use `entrypoint` for declaration of `~s`: `~s`",
-                        [pp_expr(element(3, Decl)),
-                         prettypr:format(aeso_pretty:decl(Decl1))]),
-    mk_t_err(pos(Decl), Msg);
-mk_error({proto_in_namespace, Decl}) ->
-    Msg = io_lib:format("Namespaces cannot contain function prototypes.", []),
-    mk_t_err(pos(Decl), Msg);
-mk_error({entrypoint_in_namespace, Decl}) ->
-    Msg = io_lib:format("Namespaces cannot contain entrypoints. Use `function` instead.", []),
-    mk_t_err(pos(Decl), Msg);
-mk_error({private_entrypoint, Decl}) ->
-    Msg = io_lib:format("The entrypoint `~s` cannot be private. Use `function` instead.",
-                        [pp_expr(element(3, Decl))]),
-    mk_t_err(pos(Decl), Msg);
-mk_error({private_and_public, Decl}) ->
-    Msg = io_lib:format("The function `~s` cannot be both public and private.",
-                        [pp_expr(element(3, Decl))]),
-    mk_t_err(pos(Decl), Msg);
-mk_error({contract_has_no_entrypoints, Con}) ->
-    Msg = io_lib:format("The contract `~s` has no entrypoints. Since Sophia version 3.2, public "
-                        "contract functions must be declared with the `entrypoint` keyword instead of "
-                        "`function`.", [pp_expr(Con)]),
-    mk_t_err(pos(Con), Msg);
-mk_error({definition_in_contract_interface, Ann, {id, _, Id}}) ->
-    Msg = "Contract interfaces cannot contain defined functions or entrypoints.",
-    Cxt = io_lib:format("Fix: replace the definition of `~s` by a type signature.", [Id]),
-    mk_t_err(pos(Ann), Msg, Cxt);
-mk_error({unbound_type, Type}) ->
-    Msg = io_lib:format("Unbound type ~s.", [pp_type(Type)]),
-    mk_t_err(pos(Type), Msg);
-mk_error({new_tuple_syntax, Ann, Ts}) ->
-    Msg = io_lib:format("Invalid type `~s`. The syntax of tuple types changed in Sophia version 4.0. Did you mean `~s`",
-                        [pp_type({args_t, Ann, Ts}), pp_type({tuple_t, Ann, Ts})]),
-    mk_t_err(pos(Ann), Msg);
-mk_error({map_in_map_key, Ann, KeyType}) ->
-    Msg = io_lib:format("Invalid key type `~s`", [pp_type(KeyType)]),
-    Cxt = "Map keys cannot contain other maps.",
-    mk_t_err(pos(Ann), Msg, Cxt);
-mk_error({cannot_call_init_function, Ann}) ->
-    Msg = "The 'init' function is called exclusively by the create contract transaction "
-          "and cannot be called from the contract code.",
-    mk_t_err(pos(Ann), Msg);
-mk_error({contract_treated_as_namespace_entrypoint, Ann, [Con, Fun] = QName}) ->
-    Msg = io_lib:format("Invalid call to contract entrypoint `~s`.", [string:join(QName, ".")]),
-    Cxt = io_lib:format("It must be called as `c.~s` for some `c : ~s`.", [Fun, Con]),
-    mk_t_err(pos(Ann), Msg, Cxt);
-mk_error({contract_treated_as_namespace_constant, Ann, QName}) ->
-    Msg = io_lib:format("Invalid use of the contract constant `~s`.", [string:join(QName, ".")]),
-    Cxt = "Toplevel contract constants can only be used in the contracts where they are defined.",
-    mk_t_err(pos(Ann), Msg, Cxt);
-mk_error({bad_top_level_decl, Decl}) ->
-    What = case element(1, Decl) of
-               letval -> "function or entrypoint";
-               _      -> "contract or namespace"
-           end,
-    Id = element(3, Decl),
-    Msg = io_lib:format("The definition of '~s' must appear inside a ~s.",
-                        [pp_expr(Id), What]),
-    mk_t_err(pos(Decl), Msg);
-mk_error({unknown_byte_length, Type}) ->
-    Msg = io_lib:format("Cannot resolve length of byte array.", []),
-    mk_t_err(pos(Type), Msg);
-mk_error({unsolved_bytes_constraint, Ann, concat, A, B, C}) ->
-    Msg = io_lib:format("Failed to resolve byte array lengths in call to Bytes.concat with arguments of type\n"
-                        "~s  (at ~s)\n~s  (at ~s)\nand result type\n~s  (at ~s)",
-                        [pp_type("  - ", A), pp_loc(A), pp_type("  - ", B),
-                         pp_loc(B), pp_type("  - ", C), pp_loc(C)]),
-    mk_t_err(pos(Ann), Msg);
-mk_error({unsolved_bytes_constraint, Ann, split, A, B, C}) ->
-    Msg = io_lib:format("Failed to resolve byte array lengths in call to Bytes.split with argument of type\n"
-                        "~s  (at ~s)\nand result types\n~s  (at ~s)\n~s  (at ~s)",
-                        [ pp_type("  - ", C), pp_loc(C), pp_type("  - ", A), pp_loc(A),
-                          pp_type("  - ", B), pp_loc(B)]),
-    mk_t_err(pos(Ann), Msg);
-mk_error({failed_to_get_compiler_version, Err}) ->
-    Msg = io_lib:format("Failed to get compiler version. Error: ~p", [Err]),
-    mk_t_err(pos(0, 0), Msg);
-mk_error({compiler_version_mismatch, Ann, Version, Op, Bound}) ->
-    PrintV = fun(V) -> string:join([integer_to_list(N) || N <- V], ".") end,
-    Msg = io_lib:format("Cannot compile with this version of the compiler, "
-                        "because it does not satisfy the constraint"
-                        " ~s ~s ~s", [PrintV(Version), Op, PrintV(Bound)]),
-    mk_t_err(pos(Ann), Msg);
-mk_error({empty_record_or_map_update, Expr}) ->
-    Msg = io_lib:format("Empty record/map update `~s`", [pp_expr(Expr)]),
-    mk_t_err(pos(Expr), Msg);
-mk_error({mixed_record_and_map, Expr}) ->
-    Msg = io_lib:format("Mixed record fields and map keys in `~s`", [pp_expr(Expr)]),
-    mk_t_err(pos(Expr), Msg);
-mk_error({named_argument_must_be_literal_bool, Name, Arg}) ->
-    Msg = io_lib:format("Invalid `~s` argument `~s`. "
-                        "It must be either `true` or `false`.",
-                        [Name, pp_expr(aeso_tc_type_utils:instantiate(Arg))]),
-    mk_t_err(pos(Arg), Msg);
-mk_error({conflicting_updates_for_field, Upd, Key}) ->
-    Msg = io_lib:format("Conflicting updates for field '~s'", [Key]),
-    mk_t_err(pos(Upd), Msg);
-mk_error({ambiguous_main_contract, Ann}) ->
-    Msg = "Could not deduce the main contract. You can point it out manually with the `main` keyword.",
-    mk_t_err(pos(Ann), Msg);
-mk_error({main_contract_undefined, Ann}) ->
-    Msg = "No contract defined.",
-    mk_t_err(pos(Ann), Msg);
-mk_error({multiple_main_contracts, Ann}) ->
-    Msg = "Only one main contract can be defined.",
-    mk_t_err(pos(Ann), Msg);
-mk_error({unify_varargs, When}) ->
-    Msg = "Cannot infer types for variable argument list.",
-    {Pos, Ctxt} = pp_when(When),
-    mk_t_err(Pos, Msg, Ctxt);
-mk_error({clone_no_contract, Ann}) ->
-    Msg = "Chain.clone requires `ref` named argument of contract type.",
-    mk_t_err(pos(Ann), Msg);
-mk_error({contract_lacks_definition, Type, When}) ->
-    Msg = io_lib:format(
-            "~s is not implemented.",
-            [pp_type(Type)]
-           ),
-    {Pos, Ctxt} = pp_when(When),
-    mk_t_err(Pos, Msg, Ctxt);
-mk_error({ambiguous_name, Name, QIds}) ->
-    Msg = io_lib:format("Ambiguous name `~s` could be one of~s",
-                        [pp(Name),
-                         [io_lib:format("\n  - `~s` (at ~s)", [pp(QId), pp_loc(QId)]) || QId <- QIds]]),
-    mk_t_err(pos(Name), Msg);
-mk_error({using_undefined_namespace, Ann, Namespace}) ->
-    Msg = io_lib:format("Cannot use undefined namespace ~s", [Namespace]),
-    mk_t_err(pos(Ann), Msg);
-mk_error({using_undefined_namespace_parts, Ann, Namespace, Parts}) ->
-    PartsStr = lists:concat(lists:join(", ", Parts)),
-    Msg = io_lib:format("The namespace ~s does not define the following names: ~s", [Namespace, PartsStr]),
-    mk_t_err(pos(Ann), Msg);
-mk_error({empty_record_definition, Ann, Name}) ->
-    Msg = io_lib:format("Empty record definitions are not allowed. Cannot define the record `~s`", [Name]),
-    mk_t_err(pos(Ann), Msg);
-mk_error({unimplemented_interface_function, ConId, InterfaceName, FunName}) ->
-    Msg = io_lib:format("Unimplemented entrypoint `~s` from the interface `~s` in the contract `~s`", [FunName, InterfaceName, pp(ConId)]),
-    mk_t_err(pos(ConId), Msg);
-mk_error({referencing_undefined_interface, InterfaceId}) ->
-    Msg = io_lib:format("Trying to implement or extend an undefined interface `~s`", [pp(InterfaceId)]),
-    mk_t_err(pos(InterfaceId), Msg);
-mk_error({missing_definition, Id}) ->
-    Msg = io_lib:format("Missing definition of function `~s`", [name(Id)]),
-    mk_t_err(pos(Id), Msg);
-mk_error({parameterized_state, Ann}) ->
-    Msg = "The state type cannot be parameterized",
-    mk_t_err(pos(Ann), Msg);
-mk_error({parameterized_event, Ann}) ->
-    Msg = "The event type cannot be parameterized",
-    mk_t_err(pos(Ann), Msg);
-mk_error({missing_init_function, Con}) ->
-    Msg = io_lib:format("Missing `init` function for the contract `~s`.", [name(Con)]),
-    Cxt = "The `init` function can only be omitted if the state type is `unit`",
-    mk_t_err(pos(Con), Msg, Cxt);
-mk_error({higher_order_entrypoint, Ann, {id, _, Name}, Thing}) ->
-    What = "higher-order (contains function types)",
-    ThingS = case Thing of
-                 {argument, X, T} -> io_lib:format("argument\n~s`\n", [pp_typed("  `", X, T)]);
-                 {result, T}      -> io_lib:format("return type\n~s`\n", [pp_type("  `", T)])
-             end,
-    Bad = case Thing of
-              {argument, _, _} -> io_lib:format("has a ~s type", [What]);
-              {result, _}      -> io_lib:format("is ~s", [What])
-          end,
-    Msg = io_lib:format("The ~sof entrypoint `~s` ~s",
-                        [ThingS, Name, Bad]),
-    mk_t_err(pos(Ann), Msg);
-mk_error({invalid_aens_resolve_type, Ann, T}) ->
-    Msg = io_lib:format("Invalid return type of `AENS.resolve`:\n"
-                        "~s`\n"
-                        "It must be a `string` or a pubkey type (`address`, `oracle`, etc)",
-                        [pp_type("  `", T)]),
-    mk_t_err(pos(Ann), Msg);
-mk_error({invalid_oracle_type, Why, What, Ann, Type}) ->
-    WhyS = case Why of higher_order -> "higher-order (contain function types)";
-                       polymorphic  -> "polymorphic (contain type variables)" end,
-    Msg = io_lib:format("Invalid oracle type\n~s`", [pp_type("  `", Type)]),
-    Cxt = io_lib:format("The ~s type must not be ~s", [What, WhyS]),
-    mk_t_err(pos(Ann), Msg, Cxt);
-mk_error({interface_implementation_conflict, Contract, I1, I2, Fun}) ->
-    Msg = io_lib:format("Both interfaces `~s` and `~s` implemented by "
-                        "the contract `~s` have a function called `~s`",
-                        [name(I1), name(I2), name(Contract), name(Fun)]),
-    mk_t_err(pos(Contract), Msg);
-mk_error({function_should_be_entrypoint, Impl, Base, Interface}) ->
-    Msg = io_lib:format("`~s` must be declared as an entrypoint instead of a function "
-                        "in order to implement the entrypoint `~s` from the interface `~s`",
-                        [name(Impl), name(Base), name(Interface)]),
-    mk_t_err(pos(Impl), Msg);
-mk_error({entrypoint_cannot_be_stateful, Impl, Base, Interface}) ->
-    Msg = io_lib:format("`~s` cannot be stateful because the entrypoint `~s` in the "
-                        "interface `~s` is not stateful",
-                        [name(Impl), name(Base), name(Interface)]),
-    mk_t_err(pos(Impl), Msg);
-mk_error({entrypoint_must_be_payable, Impl, Base, Interface}) ->
-    Msg = io_lib:format("`~s` must be payable because the entrypoint `~s` in the "
-                        "interface `~s` is payable",
-                        [name(Impl), name(Base), name(Interface)]),
-    mk_t_err(pos(Impl), Msg);
-mk_error({unpreserved_payablity, Kind, ContractCon, InterfaceCon}) ->
-    KindStr = case Kind of
-                  contract -> "contract";
-                  contract_interface -> "interface"
-              end,
-    Msg = io_lib:format("Non-payable ~s `~s` cannot implement payable interface `~s`",
-                        [KindStr, name(ContractCon), name(InterfaceCon)]),
-    mk_t_err(pos(ContractCon), Msg);
-mk_error({mutually_recursive_constants, Consts}) ->
-    Msg = [ "Mutual recursion detected between the constants",
-            [ io_lib:format("\n  - `~s` at ~s", [name(Id), pp_loc(Ann)])
-                || {letval, Ann, Id, _} <- Consts ] ],
-    [{letval, Ann, _, _} | _] = Consts,
-    mk_t_err(pos(Ann), Msg);
-mk_error({invalid_const_id, Ann}) ->
-    Msg = "The name of the compile-time constant cannot have pattern matching",
-    mk_t_err(pos(Ann), Msg);
-mk_error({invalid_const_expr, ConstId}) ->
-    Msg = io_lib:format("Invalid expression in the definition of the constant `~s`", [name(ConstId)]),
-    Cxt = "You can only use the following expressions as constants: "
-          "literals, lists, tuples, maps, and other constants",
-    mk_t_err(pos(aeso_syntax:get_ann(ConstId)), Msg, Cxt);
-mk_error({illegal_const_in_interface, Ann}) ->
-    Msg = "Cannot define toplevel constants inside a contract interface",
-    mk_t_err(pos(Ann), Msg);
-mk_error(Err) ->
-    Msg = io_lib:format("Unknown error: ~p", [Err]),
-    mk_t_err(pos(0, 0), Msg).
-
-mk_entrypoint(Decl) ->
-    Ann   = [entrypoint | lists:keydelete(public, 1,
-                          lists:keydelete(private, 1,
-                            aeso_syntax:get_ann(Decl))) -- [public, private]],
-    aeso_syntax:set_ann(Ann, Decl).
-
-plural(No, _Yes, [_]) -> No;
-plural(_No, Yes, _)   -> Yes.

src/aeso_tc_ets_manager.erl

@@ -1,102 +0,0 @@
--module(aeso_tc_ets_manager).
-
--export([ ets_init/0
-        , ets_new/2
-        , ets_lookup/2
-        , ets_insert/2
-        , ets_insert_new/2
-        , ets_insert_ordered/2
-        , ets_delete/1
-        , ets_delete/2
-        , ets_match_delete/2
-        , ets_tab2list/1
-        , ets_tab2list_ordered/1
-        , ets_tab_exists/1
-        , clean_up_ets/0
-        ]).
-
-%% Clean up all the ets tables (in case of an exception)
-
-ets_tables() ->
-    [options, type_vars, constraints, freshen_tvars, type_errors,
-     defined_contracts, warnings, function_calls, all_functions,
-     type_vars_variance, functions_to_implement].
-
-clean_up_ets() ->
-    [ catch ets_delete(Tab) || Tab <- ets_tables() ],
-    ok.
-
-%% Named interface to ETS tables implemented without names.
-%% The interface functions behave as the standard ETS interface.
-
-ets_init() ->
-    put(aeso_ast_infer_types, #{}).
-
-ets_tab_exists(Name) ->
-    Tabs = get(aeso_ast_infer_types),
-    case maps:find(Name, Tabs) of
-        {ok, _} -> true;
-        error   -> false
-    end.
-
-ets_tabid(Name) ->
-    #{Name := TabId} = get(aeso_ast_infer_types),
-    TabId.
-
-ets_new(Name, Opts) ->
-    %% Ensure the table is NOT named!
-    TabId = ets:new(Name, Opts -- [named_table]),
-    Tabs = get(aeso_ast_infer_types),
-    put(aeso_ast_infer_types, Tabs#{Name => TabId}),
-    Name.
-
-ets_delete(Name) ->
-    Tabs = get(aeso_ast_infer_types),
-    #{Name := TabId} = Tabs,
-    put(aeso_ast_infer_types, maps:remove(Name, Tabs)),
-    ets:delete(TabId).
-
-ets_delete(Name, Key) ->
-    TabId = ets_tabid(Name),
-    ets:delete(TabId, Key).
-
-ets_insert(Name, Object) ->
-    TabId = ets_tabid(Name),
-    ets:insert(TabId, Object).
-
-ets_insert_new(Name, Object) ->
-    TabId = ets_tabid(Name),
-    ets:insert_new(TabId, Object).
-
-ets_lookup(Name, Key) ->
-    TabId = ets_tabid(Name),
-    ets:lookup(TabId, Key).
-
-ets_match_delete(Name, Pattern) ->
-    TabId = ets_tabid(Name),
-    ets:match_delete(TabId, Pattern).
-
-ets_tab2list(Name) ->
-    TabId = ets_tabid(Name),
-    ets:tab2list(TabId).
-
-ets_insert_ordered(_, []) -> true;
-ets_insert_ordered(Name, [H|T]) ->
-    ets_insert_ordered(Name, H),
-    ets_insert_ordered(Name, T);
-ets_insert_ordered(Name, Object) ->
-    Count = next_count(),
-    TabId = ets_tabid(Name),
-    ets:insert(TabId, {Count, Object}).
-
-ets_tab2list_ordered(Name) ->
-    [E || {_, E} <- ets_tab2list(Name)].
-
-next_count() ->
-    V = case get(counter) of
-            undefined ->
-                0;
-            X -> X
-        end,
-    put(counter, V + 1),
-    V.

src/aeso_tc_name_manip.erl

@@ -1,39 +0,0 @@
--module(aeso_tc_name_manip).
-
--export([ name/1
-        , qname/1
-        , qid/2
-        , qcon/2
-        , set_qname/2
-        ]).
-
-%% TODO: types are duplicated
--type name() :: string().
--type qname() :: [string()].
--type type_id() :: aeso_syntax:id() | aeso_syntax:qid() | aeso_syntax:con() | aeso_syntax:qcon().
-
--spec qname(type_id()) -> qname().
-qname({id,   _, X})  -> [X];
-qname({qid,  _, Xs}) -> Xs;
-qname({con,  _, X})  -> [X];
-qname({qcon, _, Xs}) -> Xs.
-
--spec name(Named | {typed, _, Named, _}) -> name() when
-      Named :: aeso_syntax:id() | aeso_syntax:con().
-name({typed, _, X, _}) -> name(X);
-name({id, _, X}) -> X;
-name({con, _, X}) -> X.
-
--spec qid(aeso_syntax:ann(), qname()) -> aeso_syntax:id() | aeso_syntax:qid().
-qid(Ann, [X]) -> {id, Ann, X};
-qid(Ann, Xs)  -> {qid, Ann, Xs}.
-
--spec qcon(aeso_syntax:ann(), qname()) -> aeso_syntax:con() | aeso_syntax:qcon().
-qcon(Ann, [X]) -> {con, Ann, X};
-qcon(Ann, Xs)  -> {qcon, Ann, Xs}.
-
--spec set_qname(qname(), type_id()) -> type_id().
-set_qname(Xs, {id,   Ann, _}) -> qid(Ann, Xs);
-set_qname(Xs, {qid,  Ann, _}) -> qid(Ann, Xs);
-set_qname(Xs, {con,  Ann, _}) -> qcon(Ann, Xs);
-set_qname(Xs, {qcon, Ann, _}) -> qcon(Ann, Xs).

src/aeso_tc_options.erl

@@ -1,48 +0,0 @@
--module(aeso_tc_options).
-
--export([ create_options/1
-        , get_option/2
-        , when_option/2
-        , when_warning/2
-        ]).
-
-%% -- Moved functions --------------------------------------------------------
-
-all_warnings() -> aeso_tc_warnings:all_warnings().
-
-%% ---------------------------------------------------------------------------
-
-create_options(Options) ->
-    aeso_tc_ets_manager:ets_new(options, [set]),
-    Tup = fun(Opt) when is_atom(Opt) -> {Opt, true};
-             (Opt) when is_tuple(Opt) -> Opt end,
-    aeso_tc_ets_manager:ets_insert(options, lists:map(Tup, Options)).
-
-get_option(Key, Default) ->
-    case aeso_tc_ets_manager:ets_lookup(options, Key) of
-        [{_Key, Val}] -> Val;
-        _             -> Default
-    end.
-
-when_option(Opt, Do) ->
-    get_option(Opt, false) andalso Do().
-
-when_warning(Warn, Do) ->
-    case lists:member(Warn, all_warnings()) of
-        false ->
-            %% TODO: An error for passing invalid wanring name should be thrown here.
-            %%       Validation of compiler options might be done at an earlier stage.
-            ok;
-        true ->
-            case aeso_tc_ets_manager:ets_tab_exists(warnings) of
-                true ->
-                    IsEnabled = get_option(Warn, false),
-                    IsAll = get_option(warn_all, false) andalso lists:member(Warn, all_warnings()),
-                    if
-                        IsEnabled orelse IsAll -> Do();
-                        true -> ok
-                    end;
-                false ->
-                    ok
-            end
-    end.

src/aeso_tc_pp.erl

@@ -1,248 +0,0 @@
--module(aeso_tc_pp).
-
--export([ pp/1
-        , pp_type/1
-        , pp_type/2
-        , pp_typed/3
-        , pp_expr/1
-        , pp_why_record/1
-        , pp_loc/1
-        , pp_when/1
-        ]).
-
-%% -- Duplicated types -------------------------------------------------------
-
--type why_record() :: aeso_syntax:field(aeso_syntax:expr())
-                    | {var_args, aeso_syntax:ann(), aeso_syntax:expr()}
-                    | {proj, aeso_syntax:ann(), aeso_syntax:expr(), aeso_syntax:id()}.
-
-%% -- Moved functions --------------------------------------------------------
-
-pos(A) -> aeso_tc_ann_manip:pos(A).
-pos(A, B) -> aeso_tc_ann_manip:pos(A, B).
-loc(A) -> aeso_tc_ann_manip:loc(A).
-
-%% ---------------------------------------------------------------------------
-
--type pos() :: aeso_errors:pos().
-
-if_branches(If = {'if', Ann, _, Then, Else}) ->
-    case proplists:get_value(format, Ann) of
-        elif -> [Then | if_branches(Else)];
-        _    -> [If]
-    end;
-if_branches(E) -> [E].
-
-pp_when({todo, What}) -> {pos(0, 0), io_lib:format("[TODO] ~p", [What])};
-pp_when({at, Ann}) -> {pos(Ann), io_lib:format("at ~s", [pp_loc(Ann)])};
-pp_when({check_typesig, Name, Inferred, Given}) ->
-    {pos(Given),
-     io_lib:format("when checking the definition of `~s`\n"
-                   "  inferred type: `~s`\n"
-                   "  given type:    `~s`",
-         [Name, pp(aeso_tc_type_utils:instantiate(Inferred)), pp(aeso_tc_type_utils:instantiate(Given))])};
-pp_when({infer_app, Fun, NamedArgs, Args, Inferred0, ArgTypes0}) ->
-    Inferred = aeso_tc_type_utils:instantiate(Inferred0),
-    ArgTypes = aeso_tc_type_utils:instantiate(ArgTypes0),
-    {pos(Fun),
-     io_lib:format("when checking the application of\n"
-                   "  `~s`\n"
-                   "to arguments~s",
-                   [pp_typed("", Fun, Inferred),
-                    [ ["\n  ", "`" ++ pp_expr(NamedArg) ++ "`"] || NamedArg <- NamedArgs ] ++
-                    [ ["\n  ", "`" ++ pp_typed("", Arg, ArgT) ++ "`"]
-                       || {Arg, ArgT} <- lists:zip(Args, ArgTypes) ] ])};
-pp_when({field_constraint, FieldType0, InferredType0, Fld}) ->
-    FieldType    = aeso_tc_type_utils:instantiate(FieldType0),
-    InferredType = aeso_tc_type_utils:instantiate(InferredType0),
-    {pos(Fld),
-     case Fld of
-         {var_args, _Ann, _Fun} ->
-             io_lib:format("when checking contract construction of type\n~s (at ~s)\nagainst the expected type\n~s\n",
-                          [pp_type("  ", FieldType),
-                           pp_loc(Fld),
-                           pp_type("  ", InferredType)
-                          ]);
-         {field, _Ann, LV, Id, E} ->
-             io_lib:format("when checking the assignment of the field `~s` to the old value `~s` and the new value `~s`",
-                 [pp_typed("", {lvalue, [], LV}, FieldType),
-                  pp(Id),
-                  pp_typed("", E, InferredType)]);
-         {field, _Ann, LV, E} ->
-             io_lib:format("when checking the assignment of the field `~s` to the value `~s`",
-                 [pp_typed("", {lvalue, [], LV}, FieldType),
-                  pp_typed("", E, InferredType)]);
-         {proj, _Ann, _Rec, _Fld} ->
-             io_lib:format("when checking the record projection `~s` against the expected type `~s`",
-                 [pp_typed("  ", Fld, FieldType),
-                  pp_type("  ", InferredType)])
-     end};
-pp_when({record_constraint, RecType0, InferredType0, Fld}) ->
-    RecType      = aeso_tc_type_utils:instantiate(RecType0),
-    InferredType = aeso_tc_type_utils:instantiate(InferredType0),
-    {Pos, WhyRec} = pp_why_record(Fld),
-    case Fld of
-        {var_args, _Ann, _Fun} ->
-            {Pos,
-             io_lib:format("when checking that contract construction of type\n~s\n~s\n"
-                           "matches the expected type\n~s",
-                           [pp_type("  ", RecType), WhyRec, pp_type("  ", InferredType)]
-                          )
-            };
-        {field, _Ann, _LV, _Id, _E} ->
-            {Pos,
-             io_lib:format("when checking that the record type\n~s\n~s\n"
-                           "matches the expected type\n~s",
-                 [pp_type("  ", RecType), WhyRec, pp_type("  ", InferredType)])};
-        {field, _Ann, _LV, _E} ->
-            {Pos,
-             io_lib:format("when checking that the record type\n~s\n~s\n"
-                           "matches the expected type\n~s",
-                 [pp_type("  ", RecType), WhyRec, pp_type("  ", InferredType)])};
-        {proj, _Ann, Rec, _FldName} ->
-            {pos(Rec),
-             io_lib:format("when checking that the expression\n~s (at ~s)\nhas type\n~s\n~s",
-                 [pp_typed("  ", Rec, InferredType), pp_loc(Rec),
-                  pp_type("  ", RecType), WhyRec])}
-    end;
-pp_when({if_branches, Then, ThenType0, Else, ElseType0}) ->
-    {ThenType, ElseType} = aeso_tc_type_utils:instantiate({ThenType0, ElseType0}),
-    Branches = [ {Then, ThenType} | [ {B, ElseType} || B <- if_branches(Else) ] ],
-    {pos(element(1, hd(Branches))),
-     io_lib:format("when comparing the types of the if-branches\n"
-                   "~s", [ [ io_lib:format("~s (at ~s)\n", [pp_typed("  - ", B, BType), pp_loc(B)])
-                           || {B, BType} <- Branches ] ])};
-pp_when({case_pat, Pat, PatType0, ExprType0}) ->
-    {PatType, ExprType} = aeso_tc_type_utils:instantiate({PatType0, ExprType0}),
-    {pos(Pat),
-     io_lib:format("when checking the type of the pattern `~s` against the expected type `~s`",
-                   [pp_typed("", Pat, PatType),
-                    pp_type(ExprType)])};
-pp_when({check_expr, Expr, Inferred0, Expected0}) ->
-    {Inferred, Expected} = aeso_tc_type_utils:instantiate({Inferred0, Expected0}),
-    {pos(Expr),
-     io_lib:format("when checking the type of the expression `~s` against the expected type `~s`",
-                   [pp_typed("", Expr, Inferred), pp_type(Expected)])};
-pp_when({checking_init_type, Ann}) ->
-    {pos(Ann),
-     io_lib:format("when checking that `init` returns a value of type `state`", [])};
-pp_when({list_comp, BindExpr, Inferred0, Expected0}) ->
-    {Inferred, Expected} = aeso_tc_type_utils:instantiate({Inferred0, Expected0}),
-    {pos(BindExpr),
-     io_lib:format("when checking rvalue of list comprehension binding `~s` against type `~s`",
-                   [pp_typed("", BindExpr, Inferred), pp_type(Expected)])};
-pp_when({check_named_arg_constraint, CArgs, CName, CType}) ->
-    {id, _, Name} = Arg = CName,
-    [Type | _] = [ Type || {named_arg_t, _, {id, _, Name1}, Type, _} <- CArgs, Name1 == Name ],
-    Err = io_lib:format("when checking named argument `~s` against inferred type `~s`",
-                        [pp_typed("", Arg, Type), pp_type(CType)]),
-    {pos(Arg), Err};
-pp_when({checking_init_args, Ann, Con0, ArgTypes0}) ->
-    Con = aeso_tc_type_utils:instantiate(Con0),
-    ArgTypes = aeso_tc_type_utils:instantiate(ArgTypes0),
-    {pos(Ann),
-     io_lib:format("when checking arguments of `~s`'s init entrypoint to match\n(~s)",
-                   [pp_type(Con), string:join([pp_type(A) || A <- ArgTypes], ", ")])
-    };
-pp_when({return_contract, App, Con0}) ->
-    Con = aeso_tc_type_utils:instantiate(Con0),
-    {pos(App)
-    , io_lib:format("when checking that expression returns contract of type `~s`", [pp_type(Con)])
-    };
-pp_when({arg_name, Id1, Id2, When}) ->
-    {Pos, Ctx} = pp_when(When),
-    {Pos
-    , io_lib:format("when unifying names of named arguments: `~s` and `~s`\n~s", [pp_expr(Id1), pp_expr(Id2), Ctx])
-    };
-pp_when({var_args, Ann, Fun}) ->
-    {pos(Ann)
-    , io_lib:format("when resolving arguments of variadic function `~s`", [pp_expr(Fun)])
-    };
-pp_when(unknown) -> {pos(0,0), ""}.
-
--spec pp_why_record(why_record()) -> {pos(), iolist()}.
-pp_why_record({var_args, Ann, Fun}) ->
-    {pos(Ann),
-     io_lib:format("arising from resolution of variadic function `~s`",
-                   [pp_expr(Fun)])};
-pp_why_record(Fld = {field, _Ann, LV, _E}) ->
-    {pos(Fld),
-     io_lib:format("arising from an assignment of the field `~s`",
-                   [pp_expr({lvalue, [], LV})])};
-pp_why_record(Fld = {field, _Ann, LV, _Alias, _E}) ->
-    {pos(Fld),
-     io_lib:format("arising from an assignment of the field `~s`",
-                   [pp_expr({lvalue, [], LV})])};
-pp_why_record({proj, _Ann, Rec, FldName}) ->
-    {pos(Rec),
-     io_lib:format("arising from the projection of the field `~s`",
-         [pp(FldName)])}.
-
-pp_typed(Label, E, T = {type_sig, _, _, _, _, _}) -> pp_typed(Label, E, aeso_tc_type_utils:typesig_to_fun_t(T));
-pp_typed(Label, {typed, _, Expr, _}, Type) ->
-    pp_typed(Label, Expr, Type);
-pp_typed(Label, Expr, Type) ->
-    pp_expr(Label, {typed, [], Expr, Type}).
-
-pp_expr(Expr) ->
-    pp_expr("", Expr).
-pp_expr(Label, Expr) ->
-    prettypr:format(prettypr:beside(prettypr:text(Label), aeso_pretty:expr(Expr, [show_generated])), 80, 80).
-
-pp_type(Type) ->
-    pp_type("", Type).
-pp_type(Label, Type) ->
-    prettypr:format(prettypr:beside(prettypr:text(Label), aeso_pretty:type(Type, [show_generated])), 80, 80).
-
-pp_loc(T) ->
-    {File, IncludeType, Line, Col} = loc(T),
-    case {Line, Col} of
-        {0, 0} -> "(builtin location)";
-        _      -> case IncludeType of
-                      none -> io_lib:format("line ~p, column ~p", [Line, Col]);
-                      _    -> io_lib:format("line ~p, column ~p in ~s", [Line, Col, File])
-                  end
-    end.
-
-pp(T = {type_sig, _, _, _, _, _}) ->
-    pp(aeso_tc_type_utils:typesig_to_fun_t(T));
-pp([]) ->
-    "";
-pp([T]) ->
-    pp(T);
-pp([T|Ts]) ->
-    [pp(T), ", "|pp(Ts)];
-pp({id, _, Name}) ->
-    Name;
-pp({qid, _, Name}) ->
-    string:join(Name, ".");
-pp({con, _, Name}) ->
-    Name;
-pp({qcon, _, Name}) ->
-    string:join(Name, ".");
-pp({uvar, _, Ref}) ->
-    %% Show some unique representation
-    ["?u" | integer_to_list(erlang:phash2(Ref, 16384)) ];
-pp({tvar, _, Name}) ->
-    Name;
-pp({if_t, _, Id, Then, Else}) ->
-    ["if(", pp([Id, Then, Else]), ")"];
-pp({tuple_t, _, []}) ->
-    "unit";
-pp({tuple_t, _, Cpts}) ->
-    ["(", string:join(lists:map(fun pp/1, Cpts), " * "), ")"];
-pp({bytes_t, _, any}) -> "bytes(_)";
-pp({bytes_t, _, Len}) ->
-    ["bytes(", integer_to_list(Len), ")"];
-pp({app_t, _, T, []}) ->
-    pp(T);
-pp({app_t, _, Type, Args}) ->
-    [pp(Type), "(", pp(Args), ")"];
-pp({named_arg_t, _, Name, Type, _Default}) ->
-    [pp(Name), " : ", pp(Type)];
-pp({fun_t, _, Named = {uvar, _, _}, As, B}) ->
-    ["(", pp(Named), " | ", pp(As), ") => ", pp(B)];
-pp({fun_t, _, Named, As, B}) when is_list(Named) ->
-    ["(", pp(Named ++ As), ") => ", pp(B)];
-pp(Other) ->
-    io_lib:format("~p", [Other]).

src/aeso_tc_type_unfolding.erl

@@ -1,134 +0,0 @@
--module(aeso_tc_type_unfolding).
-
--export([ unfold_types_in_type/2
-        , unfold_types_in_type/3
-        , unfold_record_types/2
-        ]).
-
-%% -- Duplicated macros ------------------------------------------------------
-
--define(is_type_id(T), element(1, T) =:= id orelse
-                       element(1, T) =:= qid orelse
-                       element(1, T) =:= con orelse
-                       element(1, T) =:= qcon).
-
-%% -- Moved functions --------------------------------------------------------
-
-type_error(A) -> aeso_tc_errors:type_error(A).
-
-%% -------
-
-used_typedef(A, B) -> aeso_tc_warnings:used_typedef(A, B).
-
-%% -------
-
-when_warning(A, B) -> aeso_tc_options:when_warning(A, B).
-
-%% ---------------------------------------------------------------------------
-
-%% During type inference, record types are represented by their
-%% names. But, before we pass the typed program to the code generator,
-%% we replace record types annotating expressions with their
-%% definition. This enables the code generator to see the fields.
-unfold_record_types(Env, T) ->
-    unfold_types(Env, T, [unfold_record_types]).
-
-unfold_types(Env, {typed, Attr, E, Type}, Options) ->
-    Options1 = [{ann, Attr} | lists:keydelete(ann, 1, Options)],
-    {typed, Attr, unfold_types(Env, E, Options), unfold_types_in_type(Env, Type, Options1)};
-unfold_types(Env, {arg, Attr, Id, Type}, Options) ->
-    {arg, Attr, Id, unfold_types_in_type(Env, Type, Options)};
-unfold_types(Env, {type_sig, Ann, Constr, NamedArgs, Args, Ret}, Options) ->
-    {type_sig, Ann, Constr,
-               unfold_types_in_type(Env, NamedArgs, Options),
-               unfold_types_in_type(Env, Args, Options),
-               unfold_types_in_type(Env, Ret, Options)};
-unfold_types(Env, {type_def, Ann, Name, Args, Def}, Options) ->
-    {type_def, Ann, Name, Args, unfold_types_in_type(Env, Def, Options)};
-unfold_types(Env, {fun_decl, Ann, Name, Type}, Options) ->
-    {fun_decl, Ann, Name, unfold_types(Env, Type, Options)};
-unfold_types(Env, {letfun, Ann, Name, Args, Type, [{guarded, AnnG, [], Body}]}, Options) ->
-    {letfun, Ann, Name, unfold_types(Env, Args, Options), unfold_types_in_type(Env, Type, Options), [{guarded, AnnG, [], unfold_types(Env, Body, Options)}]};
-unfold_types(Env, T, Options) when is_tuple(T) ->
-    list_to_tuple(unfold_types(Env, tuple_to_list(T), Options));
-unfold_types(Env, [H|T], Options) ->
-    [unfold_types(Env, H, Options)|unfold_types(Env, T, Options)];
-unfold_types(_Env, X, _Options) ->
-    X.
-
-unfold_types_in_type(Env, T) ->
-    unfold_types_in_type(Env, T, []).
-
-unfold_types_in_type(Env, {app_t, Ann, Id = {id, _, "map"}, Args = [KeyType0, _]}, Options) ->
-    Args1 = [KeyType, _] = unfold_types_in_type(Env, Args, Options),
-    Ann1 = proplists:get_value(ann, Options, aeso_syntax:get_ann(KeyType0)),
-    [ type_error({map_in_map_key, Ann1, KeyType0}) || has_maps(KeyType) ],
-    {app_t, Ann, Id, Args1};
-unfold_types_in_type(Env, {app_t, Ann, Id, Args}, Options) when ?is_type_id(Id) ->
-    when_warning(warn_unused_typedefs, fun() -> used_typedef(Id, length(Args)) end),
-    UnfoldRecords  = proplists:get_value(unfold_record_types, Options, false),
-    UnfoldVariants = proplists:get_value(unfold_variant_types, Options, false),
-    case aeso_tc_env:lookup_type(Env, Id) of
-        {_, {_, {Formals, {record_t, Fields}}}} when UnfoldRecords, length(Formals) == length(Args) ->
-            {record_t,
-             unfold_types_in_type(Env,
-               subst_tvars(lists:zip(Formals, Args), Fields), Options)};
-        {_, {_, {Formals, {alias_t, Type}}}} when length(Formals) == length(Args) ->
-            unfold_types_in_type(Env, subst_tvars(lists:zip(Formals, Args), Type), Options);
-        {_, {_, {Formals, {variant_t, Constrs}}}} when UnfoldVariants, length(Formals) == length(Args) ->
-            %% TODO: unfolding variant types will not work well if we add recursive types!
-            {variant_t,
-             unfold_types_in_type(Env,
-                subst_tvars(lists:zip(Formals, Args), Constrs), Options)};
-        _ ->
-            %% Not a record type, or ill-formed record type.
-            {app_t, Ann, Id, unfold_types_in_type(Env, Args, Options)}
-    end;
-unfold_types_in_type(Env, Id, Options) when ?is_type_id(Id) ->
-    %% Like the case above, but for types without parameters.
-    when_warning(warn_unused_typedefs, fun() -> used_typedef(Id, 0) end),
-    UnfoldRecords = proplists:get_value(unfold_record_types, Options, false),
-    UnfoldVariants = proplists:get_value(unfold_variant_types, Options, false),
-    case aeso_tc_env:lookup_type(Env, Id) of
-        {_, {_, {[], {record_t, Fields}}}} when UnfoldRecords ->
-            {record_t, unfold_types_in_type(Env, Fields, Options)};
-        {_, {_, {[], {variant_t, Constrs}}}} when UnfoldVariants ->
-            {variant_t, unfold_types_in_type(Env, Constrs, Options)};
-        {_, {_, {[], {alias_t, Type1}}}} ->
-            unfold_types_in_type(Env, Type1, Options);
-        _ ->
-            %% Not a record type, or ill-formed record type
-            Id
-    end;
-unfold_types_in_type(Env, {field_t, Attr, Name, Type}, Options) ->
-    {field_t, Attr, Name, unfold_types_in_type(Env, Type, Options)};
-unfold_types_in_type(Env, {constr_t, Ann, Con, Types}, Options) ->
-    {constr_t, Ann, Con, unfold_types_in_type(Env, Types, Options)};
-unfold_types_in_type(Env, {named_arg_t, Ann, Con, Types, Default}, Options) ->
-    {named_arg_t, Ann, Con, unfold_types_in_type(Env, Types, Options), Default};
-unfold_types_in_type(Env, T, Options) when is_tuple(T) ->
-    list_to_tuple(unfold_types_in_type(Env, tuple_to_list(T), Options));
-unfold_types_in_type(Env, [H|T], Options) ->
-    [unfold_types_in_type(Env, H, Options)|unfold_types_in_type(Env, T, Options)];
-unfold_types_in_type(_Env, X, _Options) ->
-    X.
-
-has_maps({app_t, _, {id, _, "map"}, _}) ->
-    true;
-has_maps(L) when is_list(L) ->
-    lists:any(fun has_maps/1, L);
-has_maps(T) when is_tuple(T) ->
-    has_maps(tuple_to_list(T));
-has_maps(_) -> false.
-
-subst_tvars(Env, Type) ->
-    subst_tvars1([{V, T} || {{tvar, _, V}, T} <- Env], Type).
-
-subst_tvars1(Env, T={tvar, _, Name}) ->
-    proplists:get_value(Name, Env, T);
-subst_tvars1(Env, [H|T]) ->
-    [subst_tvars1(Env, H)|subst_tvars1(Env, T)];
-subst_tvars1(Env, Type) when is_tuple(Type) ->
-    list_to_tuple(subst_tvars1(Env, tuple_to_list(Type)));
-subst_tvars1(_Env, X) ->
-    X.

src/aeso_tc_type_utils.erl

@@ -1,91 +0,0 @@
--module(aeso_tc_type_utils).
-
--export([ fresh_uvar/1
-        , dereference/1
-        , dereference_deep/1
-        , instantiate/1
-        , typesig_to_fun_t/1
-        , fun_arity/1
-        , opposite_variance/1
-        , app_t/3
-        , is_first_order/1
-        , is_monomorphic/1
-        ]).
-
-%% TODO: Find a better place for this function
-fresh_uvar(Attrs) ->
-    {uvar, Attrs, make_ref()}.
-
-dereference(T = {uvar, _, R}) ->
-    case aeso_tc_ets_manager:ets_lookup(type_vars, R) of
-        [] ->
-            T;
-        [{R, Type}] ->
-            dereference(Type)
-    end;
-dereference(T) ->
-    T.
-
-dereference_deep(Type) ->
-    case dereference(Type) of
-        Tup when is_tuple(Tup) ->
-            list_to_tuple(dereference_deep(tuple_to_list(Tup)));
-        [H | T] -> [dereference_deep(H) | dereference_deep(T)];
-        T -> T
-    end.
-
-%% Dereferences all uvars and replaces the uninstantiated ones with a
-%% succession of tvars.
-instantiate(E) ->
-    instantiate1(dereference(E)).
-
-instantiate1({uvar, Attr, R}) ->
-    Next = proplists:get_value(next, aeso_tc_ets_manager:ets_lookup(type_vars, next), 0),
-    TVar = {tvar, Attr, "'" ++ integer_to_tvar(Next)},
-    aeso_tc_ets_manager:ets_insert(type_vars, [{next, Next + 1}, {R, TVar}]),
-    TVar;
-instantiate1({fun_t, Ann, Named, Args, Ret}) ->
-    case dereference(Named) of
-        {uvar, _, R} ->
-            %% Uninstantiated named args map to the empty list
-            NoNames = [],
-            aeso_tc_ets_manager:ets_insert(type_vars, [{R, NoNames}]),
-            {fun_t, Ann, NoNames, instantiate(Args), instantiate(Ret)};
-        Named1 ->
-            {fun_t, Ann, instantiate1(Named1), instantiate(Args), instantiate(Ret)}
-    end;
-instantiate1(T) when is_tuple(T) ->
-    list_to_tuple(instantiate1(tuple_to_list(T)));
-instantiate1([A|B]) ->
-    [instantiate(A)|instantiate(B)];
-instantiate1(X) ->
-    X.
-
-integer_to_tvar(X) when X < 26 ->
-    [$a + X];
-integer_to_tvar(X) ->
-    [integer_to_tvar(X div 26)] ++ [$a + (X rem 26)].
-
-fun_arity({fun_t, _, _, Args, _}) -> length(Args);
-fun_arity(_)                      -> none.
-
-is_monomorphic({tvar, _, _})           -> false;
-is_monomorphic(Ts) when is_list(Ts)    -> lists:all(fun is_monomorphic/1, Ts);
-is_monomorphic(Tup) when is_tuple(Tup) -> is_monomorphic(tuple_to_list(Tup));
-is_monomorphic(_)                      -> true.
-
-is_first_order({fun_t, _, _, _, _})    -> false;
-is_first_order(Ts) when is_list(Ts)    -> lists:all(fun is_first_order/1, Ts);
-is_first_order(Tup) when is_tuple(Tup) -> is_first_order(tuple_to_list(Tup));
-is_first_order(_)                      -> true.
-
-opposite_variance(invariant) -> invariant;
-opposite_variance(covariant) -> contravariant;
-opposite_variance(contravariant) -> covariant;
-opposite_variance(bivariant) -> bivariant.
-
-app_t(_Ann, Name, [])  -> Name;
-app_t(Ann, Name, Args) -> {app_t, Ann, Name, Args}.
-
-typesig_to_fun_t({type_sig, Ann, _Constr, Named, Args, Res}) ->
-    {fun_t, Ann, Named, Args, Res}.

src/aeso_tc_typedefs.erl

@@ -1,20 +0,0 @@
--module(aeso_tc_typedefs).
-
--export_type([utype/0, named_args_t/0, typesig/0]).
-
--type uvar() :: {uvar, aeso_syntax:ann(), reference()}.
-
--type named_args_t() :: uvar() | [{named_arg_t, aeso_syntax:ann(), aeso_syntax:id(), utype(), aeso_syntax:expr()}].
-
--type utype() :: {fun_t, aeso_syntax:ann(), named_args_t(), [utype()] | var_args, utype()}
-               | {app_t, aeso_syntax:ann(), utype(), [utype()]}
-               | {tuple_t, aeso_syntax:ann(), [utype()]}
-               | aeso_syntax:id()  | aeso_syntax:qid()
-               | aeso_syntax:con() | aeso_syntax:qcon()  %% contracts
-               | aeso_syntax:tvar()
-               | {if_t, aeso_syntax:ann(), aeso_syntax:id(), utype(), utype()}  %% Can branch on named argument (protected)
-               | uvar().
-
--type type_constraints() :: none | bytes_concat | bytes_split | address_to_contract | bytecode_hash.
-
--type typesig() :: {type_sig, aeso_syntax:ann(), type_constraints(), [aeso_syntax:named_arg_t()], [aeso_syntax:type()], aeso_syntax:type()}.

src/aeso_tc_unify.erl

@@ -1,190 +0,0 @@
--module(aeso_tc_unify).
-
--export([unify/4]).
-
-
-%% -- Moved functions --------------------------------------------------------
-
-unfold_types_in_type(A, B, C) -> aeso_tc_type_unfolding:unfold_types_in_type(A, B, C).
-
-%% -------
-
-type_error(A) -> aeso_tc_errors:type_error(A).
-cannot_unify(A, B, C, D) -> aeso_tc_errors:cannot_unify(A, B, C, D).
-
-%% -------
-
-opposite_variance(A) -> aeso_tc_type_utils:opposite_variance(A).
-
-%% ---------------------------------------------------------------------------
-
-unify(Env, A, B, When) -> unify0(Env, A, B, covariant, When).
-
-unify0(_, {id, _, "_"}, _, _Variance, _When) -> true;
-unify0(_, _, {id, _, "_"}, _Variance, _When) -> true;
-unify0(Env, A, B, Variance, When) ->
-    Options =
-        case When of    %% Improve source location for map_in_map_key errors
-            {check_expr, E, _, _} -> [{ann, aeso_syntax:get_ann(E)}];
-            _                     -> []
-        end,
-    A1 = aeso_tc_type_utils:dereference(unfold_types_in_type(Env, A, Options)),
-    B1 = aeso_tc_type_utils:dereference(unfold_types_in_type(Env, B, Options)),
-    unify1(Env, A1, B1, Variance, When).
-
-unify1(_Env, {uvar, _, R}, {uvar, _, R}, _Variance, _When) ->
-    true;
-unify1(_Env, {uvar, _, _}, {fun_t, _, _, var_args, _}, _Variance, When) ->
-    type_error({unify_varargs, When});
-unify1(Env, {uvar, A, R}, T, _Variance, When) ->
-    case occurs_check(R, T) of
-        true ->
-            case aeso_tc_env:unify_throws(Env) of
-                true ->
-                    cannot_unify({uvar, A, R}, T, none, When);
-                false ->
-                    ok
-            end,
-            false;
-        false ->
-            aeso_tc_ets_manager:ets_insert(type_vars, {R, T}),
-            true
-    end;
-unify1(Env, T, {uvar, A, R}, Variance, When) ->
-    unify1(Env, {uvar, A, R}, T, Variance, When);
-unify1(_Env, {tvar, _, X}, {tvar, _, X}, _Variance, _When) -> true; %% Rigid type variables
-unify1(Env, [A|B], [C|D], [V|Variances], When) ->
-    unify0(Env, A, C, V, When) andalso unify0(Env, B, D, Variances, When);
-unify1(Env, [A|B], [C|D], Variance, When) ->
-    unify0(Env, A, C, Variance, When) andalso unify0(Env, B, D, Variance, When);
-unify1(_Env, X, X, _Variance, _When) ->
-    true;
-unify1(_Env, _A, {id, _, "void"}, Variance, _When)
-  when Variance == covariant orelse Variance == bivariant ->
-    true;
-unify1(_Env, {id, _, "void"}, _B, Variance, _When)
-  when Variance == contravariant orelse Variance == bivariant ->
-    true;
-unify1(_Env, {id, _, Name}, {id, _, Name}, _Variance, _When) ->
-    true;
-unify1(Env, A = {con, _, NameA}, B = {con, _, NameB}, Variance, When) ->
-    case is_subtype(Env, NameA, NameB, Variance) of
-        true -> true;
-        false ->
-            case aeso_tc_env:unify_throws(Env) of
-                true ->
-                    IsSubtype = is_subtype(Env, NameA, NameB, contravariant) orelse
-                                is_subtype(Env, NameA, NameB, covariant),
-                    Cxt = case IsSubtype of
-                              true  -> Variance;
-                              false -> none
-                          end,
-                    cannot_unify(A, B, Cxt, When);
-                false ->
-                    ok
-            end,
-            false
-    end;
-unify1(_Env, {qid, _, Name}, {qid, _, Name}, _Variance, _When) ->
-    true;
-unify1(_Env, {qcon, _, Name}, {qcon, _, Name}, _Variance, _When) ->
-    true;
-unify1(_Env, {bytes_t, _, Len}, {bytes_t, _, Len}, _Variance, _When) ->
-    true;
-unify1(Env, {if_t, _, {id, _, Id}, Then1, Else1}, {if_t, _, {id, _, Id}, Then2, Else2}, Variance, When) ->
-    unify0(Env, Then1, Then2, Variance, When) andalso
-    unify0(Env, Else1, Else2, Variance, When);
-
-unify1(_Env, {fun_t, _, _, _, _}, {fun_t, _, _, var_args, _}, _Variance, When) ->
-    type_error({unify_varargs, When});
-unify1(_Env, {fun_t, _, _, var_args, _}, {fun_t, _, _, _, _}, _Variance, When) ->
-    type_error({unify_varargs, When});
-unify1(Env, {fun_t, _, Named1, Args1, Result1}, {fun_t, _, Named2, Args2, Result2}, Variance, When)
-  when length(Args1) == length(Args2) ->
-    unify0(Env, Named1, Named2, opposite_variance(Variance), When) andalso
-    unify0(Env, Args1, Args2, opposite_variance(Variance), When) andalso
-    unify0(Env, Result1, Result2, Variance, When);
-unify1(Env, {app_t, _, {Tag, _, F}, Args1}, {app_t, _, {Tag, _, F}, Args2}, Variance, When)
-  when length(Args1) == length(Args2), Tag == id orelse Tag == qid ->
-    Variances = case aeso_tc_ets_manager:ets_lookup(type_vars_variance, F) of
-                    [{_, Vs}] ->
-                        case Variance of
-                            contravariant -> lists:map(fun opposite_variance/1, Vs);
-                            invariant     -> invariant;
-                            _             -> Vs
-                        end;
-                    _ -> invariant
-                end,
-    unify1(Env, Args1, Args2, Variances, When);
-unify1(Env, {tuple_t, _, As}, {tuple_t, _, Bs}, Variance, When)
-  when length(As) == length(Bs) ->
-    unify0(Env, As, Bs, Variance, When);
-unify1(Env, {named_arg_t, _, Id1, Type1, _}, {named_arg_t, _, Id2, Type2, _}, Variance, When) ->
-    unify1(Env, Id1, Id2, Variance, {arg_name, Id1, Id2, When}),
-    unify1(Env, Type1, Type2, Variance, When);
-%% The grammar is a bit inconsistent about whether types without
-%% arguments are represented as applications to an empty list of
-%% parameters or not. We therefore allow them to unify.
-unify1(Env, {app_t, _, T, []}, B, Variance, When) ->
-    unify0(Env, T, B, Variance, When);
-unify1(Env, A, {app_t, _, T, []}, Variance, When) ->
-    unify0(Env, A, T, Variance, When);
-unify1(Env, A, B, _Variance, When) ->
-    case aeso_tc_env:unify_throws(Env) of
-        true ->
-            cannot_unify(A, B, none, When);
-        false ->
-            ok
-    end,
-    false.
-
-is_subtype(_Env, NameA, NameB, invariant) ->
-    NameA == NameB;
-is_subtype(Env, NameA, NameB, covariant) ->
-    is_subtype(Env, NameA, NameB);
-is_subtype(Env, NameA, NameB, contravariant) ->
-    is_subtype(Env, NameB, NameA);
-is_subtype(Env, NameA, NameB, bivariant) ->
-    is_subtype(Env, NameA, NameB) orelse is_subtype(Env, NameB, NameA).
-
-is_subtype(Env, Child, Base) ->
-    Parents = maps:get(Child, aeso_tc_env:contract_parents(Env), []),
-    if
-        Child == Base ->
-            true;
-        Parents == [] ->
-            false;
-        true ->
-            case lists:member(Base, Parents) of
-                true -> true;
-                false -> lists:any(fun(Parent) -> is_subtype(Env, Parent, Base) end, Parents)
-            end
-    end.
-
-occurs_check(R, T) ->
-    occurs_check1(R, aeso_tc_type_utils:dereference(T)).
-
-occurs_check1(R, {uvar, _, R1}) -> R == R1;
-occurs_check1(_, {id, _, _}) -> false;
-occurs_check1(_, {con, _, _}) -> false;
-occurs_check1(_, {qid, _, _}) -> false;
-occurs_check1(_, {qcon, _, _}) -> false;
-occurs_check1(_, {tvar, _, _}) -> false;
-occurs_check1(_, {bytes_t, _, _}) -> false;
-occurs_check1(R, {fun_t, _, Named, Args, Res}) ->
-    occurs_check(R, [Res, Named | Args]);
-occurs_check1(R, {app_t, _, T, Ts}) ->
-    occurs_check(R, [T | Ts]);
-occurs_check1(R, {tuple_t, _, Ts}) ->
-    occurs_check(R, Ts);
-occurs_check1(R, {named_arg_t, _, _, T, _}) ->
-    occurs_check(R, T);
-occurs_check1(R, {record_t, Fields}) ->
-    occurs_check(R, Fields);
-occurs_check1(R, {field_t, _, _, T}) ->
-    occurs_check(R, T);
-occurs_check1(R, {if_t, _, _, Then, Else}) ->
-    occurs_check(R, [Then, Else]);
-occurs_check1(R, [H | T]) ->
-    occurs_check(R, H) orelse occurs_check(R, T);
-occurs_check1(_, []) -> false.

src/aeso_tc_warnings.erl

@@ -1,231 +0,0 @@
--module(aeso_tc_warnings).
-
--export([ warn_potential_shadowing/3
-        , used_include/1
-        , create_unused_functions/0
-        , destroy_and_report_unused_functions/0
-        , destroy_and_report_warnings_as_type_errors/0
-        , potential_unused_include/2
-        , potential_unused_typedefs/2
-        , potential_unused_constants/2
-        , potential_unused_stateful/2
-        , potential_unused_variables/3
-        , potential_unused_function/4
-        , mk_warning/1
-        , used_variable/3
-        , register_function_call/2
-        , used_constant/2
-        , used_stateful/1
-        , warn_potential_negative_spend/3
-        , warn_potential_division_by_zero/3
-        , potential_unused_return_value/1
-        , used_typedef/2
-        , all_warnings/0
-        ]).
-
-%% -- Moved functions --------------------------------------------------------
-
-name(A) -> aeso_tc_name_manip:name(A).
-qname(A) -> aeso_tc_name_manip:qname(A).
-
-%% -------
-
-pos(A) -> aeso_tc_ann_manip:pos(A).
-
-%% -------
-
-pp_loc(A) -> aeso_tc_pp:pp_loc(A).
-
-%% ---------------------------------------------------------------------------
-
-all_warnings() ->
-    [ warn_unused_includes
-    , warn_unused_stateful
-    , warn_unused_variables
-    , warn_unused_constants
-    , warn_unused_typedefs
-    , warn_unused_return_value
-    , warn_unused_functions
-    , warn_shadowing
-    , warn_division_by_zero
-    , warn_negative_spend ].
-
-%% Warnings (Unused includes)
-
-potential_unused_include(Ann, SrcFile) ->
-    IsIncluded = aeso_syntax:get_ann(include_type, Ann, none) =/= none,
-    case IsIncluded of
-        false -> ok;
-        true  ->
-            case aeso_syntax:get_ann(file, Ann, no_file) of
-                no_file -> ok;
-                File    -> aeso_tc_ets_manager:ets_insert(warnings, {unused_include, File, SrcFile})
-            end
-    end.
-
-used_include(Ann) ->
-    case aeso_syntax:get_ann(file, Ann, no_file) of
-        no_file -> ok;
-        File    -> aeso_tc_ets_manager:ets_match_delete(warnings, {unused_include, File, '_'})
-    end.
-
-%% Warnings (Unused stateful)
-
-potential_unused_stateful(Ann, Fun) ->
-    case aeso_syntax:get_ann(stateful, Ann, false) of
-        false -> ok;
-        true  -> aeso_tc_ets_manager:ets_insert(warnings, {unused_stateful, Ann, Fun})
-    end.
-
-used_stateful(Fun) ->
-    aeso_tc_ets_manager:ets_match_delete(warnings, {unused_stateful, '_', Fun}).
-
-%% Warnings (Unused type defs)
-
-potential_unused_typedefs(Namespace, TypeDefs) ->
-    lists:map(fun({type_def, Ann, Id, Args, _}) ->
-        aeso_tc_ets_manager:ets_insert(warnings, {unused_typedef, Ann, Namespace ++ qname(Id), length(Args)}) end, TypeDefs).
-
-used_typedef(TypeAliasId, Arity) ->
-    aeso_tc_ets_manager:ets_match_delete(warnings, {unused_typedef, '_', qname(TypeAliasId), Arity}).
-
-%% Warnings (Unused variables)
-
-potential_unused_variables(Namespace, Fun, Vars0) ->
-    Vars = [ Var || Var = {id, _, VarName} <- Vars0, VarName /= "_" ],
-    lists:map(fun({id, Ann, VarName}) ->
-        aeso_tc_ets_manager:ets_insert(warnings, {unused_variable, Ann, Namespace, Fun, VarName}) end, Vars).
-
-used_variable(Namespace, Fun, [VarName]) ->
-    aeso_tc_ets_manager:ets_match_delete(warnings, {unused_variable, '_', Namespace, Fun, VarName});
-used_variable(_, _, _) -> ok.
-
-%% Warnings (Unused constants)
-
-potential_unused_constants(Env, Consts) ->
-    case aeso_tc_env:what(Env) of
-        namespace -> [];
-        _ ->
-            [ aeso_tc_ets_manager:ets_insert(warnings, {unused_constant, Ann, aeso_tc_env:namespace(Env), Name}) || {letval, _, {id, Ann, Name}, _} <- Consts ]
-    end.
-
-used_constant(Namespace = [Contract], [Contract, ConstName]) ->
-    aeso_tc_ets_manager:ets_match_delete(warnings, {unused_constant, '_', Namespace, ConstName});
-used_constant(_, _) -> ok.
-
-%% Warnings (Unused return value)
-
-potential_unused_return_value({typed, Ann, {app, _, {typed, _, _, {fun_t, _, _, _, {id, _, Type}}}, _}, _}) when Type /= "unit" ->
-    aeso_tc_ets_manager:ets_insert(warnings, {unused_return_value, Ann});
-potential_unused_return_value(_) -> ok.
-
-%% Warnings (Unused functions)
-
-create_unused_functions() ->
-    aeso_tc_ets_manager:ets_new(function_calls, [bag]),
-    aeso_tc_ets_manager:ets_new(all_functions, [set]).
-
-register_function_call(Caller, Callee) ->
-    aeso_tc_ets_manager:ets_insert(function_calls, {Caller, Callee}).
-
-potential_unused_function(Env, Ann, FunQName, FunId) ->
-    case aeso_tc_env:what(Env) of
-        namespace ->
-            aeso_tc_ets_manager:ets_insert(all_functions, {Ann, FunQName, FunId, not aeso_syntax:get_ann(private, Ann, false)});
-        _ ->
-            aeso_tc_ets_manager:ets_insert(all_functions, {Ann, FunQName, FunId, aeso_syntax:get_ann(entrypoint, Ann, false)})
-    end.
-
-remove_used_funs(All) ->
-    {Used, Unused} = lists:partition(fun({_, _, _, IsUsed}) -> IsUsed end, All),
-    CallsByUsed = lists:flatmap(fun({_, F, _, _}) -> aeso_tc_ets_manager:ets_lookup(function_calls, F) end, Used),
-    CalledFuns = sets:from_list(lists:map(fun({_, Callee}) -> Callee end, CallsByUsed)),
-    MarkUsedFun = fun(Fun, Acc) ->
-                      case lists:keyfind(Fun, 2, Acc) of
-                          false -> Acc;
-                          T     -> lists:keyreplace(Fun, 2, Acc, setelement(4, T, true))
-                      end
-                  end,
-    NewUnused = sets:fold(MarkUsedFun, Unused, CalledFuns),
-    case lists:keyfind(true, 4, NewUnused) of
-        false -> NewUnused;
-        _     -> remove_used_funs(NewUnused)
-    end.
-
-destroy_and_report_unused_functions() ->
-    AllFuns = aeso_tc_ets_manager:ets_tab2list(all_functions),
-    lists:map(fun({Ann, _, FunId, _}) -> aeso_tc_ets_manager:ets_insert(warnings, {unused_function, Ann, name(FunId)}) end,
-              remove_used_funs(AllFuns)),
-    aeso_tc_ets_manager:ets_delete(all_functions),
-    aeso_tc_ets_manager:ets_delete(function_calls).
-
-%% Warnings (Shadowing)
-
-warn_potential_shadowing(_, _, "_") -> ok;
-warn_potential_shadowing(Env, Ann, Name) ->
-    Vars = aeso_tc_env:vars(Env),
-    Consts = aeso_tc_env:scope_consts(aeso_tc_env:get_current_scope(Env)),
-    case proplists:get_value(Name, Vars ++ Consts, false) of
-        false -> ok;
-        {AnnOld, _} -> aeso_tc_ets_manager:ets_insert(warnings, {shadowing, Ann, Name, AnnOld})
-    end.
-
-%% Warnings (Division by zero)
-
-warn_potential_division_by_zero(Ann, Op, Args) ->
-    case {Op, Args} of
-        {{'/', _}, [_, {int, _, 0}]} -> aeso_tc_ets_manager:ets_insert(warnings, {division_by_zero, Ann});
-        _ -> ok
-    end.
-
-%% Warnings (Negative spends)
-
-warn_potential_negative_spend(Ann, Fun, Args) ->
-    case {Fun, Args} of
-        { {typed, _, {qid, _, ["Chain", "spend"]}, _}
-        , [_, {typed, _, {app, _, {'-', _}, [{typed, _, {int, _, X}, _}]}, _}]} when X > 0 ->
-            aeso_tc_ets_manager:ets_insert(warnings, {negative_spend, Ann});
-        _ -> ok
-    end.
-
-destroy_and_report_warnings_as_type_errors() ->
-    Warnings = [ mk_warning(Warn) || Warn <- aeso_tc_ets_manager:ets_tab2list(warnings) ],
-    Errors = lists:map(fun mk_t_err_from_warn/1, Warnings),
-    aeso_errors:throw(Errors).  %% No-op if Warnings == []
-
-mk_t_err_from_warn(Warn) ->
-    aeso_warnings:warn_to_err(type_error, Warn).
-
-mk_warning({unused_include, FileName, SrcFile}) ->
-    Msg = io_lib:format("The file `~s` is included but not used.", [FileName]),
-    aeso_warnings:new(aeso_errors:pos(SrcFile, 0, 0), Msg);
-mk_warning({unused_stateful, Ann, FunName}) ->
-    Msg = io_lib:format("The function `~s` is unnecessarily marked as stateful.", [name(FunName)]),
-    aeso_warnings:new(pos(Ann), Msg);
-mk_warning({unused_variable, Ann, _Namespace, _Fun, VarName}) ->
-    Msg = io_lib:format("The variable `~s` is defined but never used.", [VarName]),
-    aeso_warnings:new(pos(Ann), Msg);
-mk_warning({unused_constant, Ann, _Namespace, ConstName}) ->
-    Msg = io_lib:format("The constant `~s` is defined but never used.", [ConstName]),
-    aeso_warnings:new(pos(Ann), Msg);
-mk_warning({unused_typedef, Ann, QName, _Arity}) ->
-    Msg = io_lib:format("The type `~s` is defined but never used.", [lists:last(QName)]),
-    aeso_warnings:new(pos(Ann), Msg);
-mk_warning({unused_return_value, Ann}) ->
-    Msg = io_lib:format("Unused return value.", []),
-    aeso_warnings:new(pos(Ann), Msg);
-mk_warning({unused_function, Ann, FunName}) ->
-    Msg = io_lib:format("The function `~s` is defined but never used.", [FunName]),
-    aeso_warnings:new(pos(Ann), Msg);
-mk_warning({shadowing, Ann, VarName, AnnOld}) ->
-    Msg = io_lib:format("The definition of `~s` shadows an older definition at ~s.", [VarName, pp_loc(AnnOld)]),
-    aeso_warnings:new(pos(Ann), Msg);
-mk_warning({division_by_zero, Ann}) ->
-    Msg = io_lib:format("Division by zero.", []),
-    aeso_warnings:new(pos(Ann), Msg);
-mk_warning({negative_spend, Ann}) ->
-    Msg = io_lib:format("Negative spend.", []),
-    aeso_warnings:new(pos(Ann), Msg);
-mk_warning(Warn) ->
-    Msg = io_lib:format("Unknown warning: ~p", [Warn]),
-    aeso_warnings:new(Msg).

src/aeso_utils.erl

@@ -5,11 +5,24 @@
 %%% @end
 %%%-------------------------------------------------------------------
 -module(aeso_utils).
+-vsn("8.0.1").
 
--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/aeso_vm_decode.erl

@@ -5,16 +5,21 @@
 %%%-------------------------------------------------------------------
 
 -module(aeso_vm_decode).
+-vsn("8.0.1").
 
 -export([ from_fate/2 ]).
 
--include_lib("aebytecode/include/aeb_fate_data.hrl").
+-include("$aebytecode_include/aeb_fate_data.hrl").
 
 -spec from_fate(aeso_syntax:type(), aeb_fate_data:fate_type()) -> aeso_syntax:expr().
 from_fate({id, _, "address"}, ?FATE_ADDRESS(Bin)) -> {account_pubkey, [], Bin};
+from_fate({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({app_t, _, {id, _, "oracle"}, _}, ?FATE_ORACLE(Bin)) -> {oracle_pubkey, [], Bin};
 from_fate({app_t, _, {id, _, "oracle_query"}, _}, ?FATE_ORACLE_Q(Bin)) -> {oracle_query_id, [], Bin};
 from_fate({con, _, _Name},  ?FATE_CONTRACT(Bin)) -> {contract_pubkey, [], Bin};
+from_fate({bytes_t, _, 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) ->
@@ -78,6 +83,7 @@ from_fate_builtin(QType, Val) ->
     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],
@@ -88,7 +94,7 @@ from_fate_builtin(QType, Val) ->
 
         {["AENS", "name"], {variant, [3], 0, {Addr, TTL, Ptrs}}} ->
             App(["AENS","Name"], [Chk(Adr, Addr), Chk(Qid(["Chain", "ttl"]), TTL),
-                              Chk(Map(Str, Qid(["AENS", "pointee"])), Ptrs)]);
+                                  Chk(Map(Str, Qid(["AENS", "pointee"])), Ptrs)]);
 
         {["AENS", "pointee"], {variant, [1, 1, 1, 1], 0, {Addr}}} ->
             App(["AENS","AccountPt"], [Chk(Adr, Addr)]);
@@ -99,6 +105,21 @@ from_fate_builtin(QType, Val) ->
         {["AENS", "pointee"], {variant, [1, 1, 1, 1], 3, {Addr}}} ->
             App(["AENS","ChannelPt"], [Chk(Adr, Addr)]);
 
+        {["AENSv2", "name"], {variant, [3], 0, {Addr, TTL, Ptrs}}} ->
+            App(["AENSv2","Name"], [Chk(Adr, Addr), Chk(Qid(["Chain", "ttl"]), TTL),
+                                    Chk(Map(Str, Qid(["AENSv2", "pointee"])), Ptrs)]);
+
+        {["AENSv2", "pointee"], {variant, [1, 1, 1, 1, 1], 0, {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)]);
 
@@ -170,3 +191,5 @@ make_bits(Set, Zero, I, N) when 0 == N rem 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/aeso_warnings.erl

@@ -1,4 +1,5 @@
 -module(aeso_warnings).
+-vsn("8.0.1").
 
 -record(warn, { pos     :: aeso_errors:pos()
               , message :: iolist()

src/aesophia.app.src

@@ -1,13 +1,12 @@
 {application, aesophia,
  [{description, "Compiler for Aeternity Sophia language"},
-  {vsn, "7.1.0"},
+  {vsn, "8.0.1"},
   {registered, []},
   {applications,
    [kernel,
     stdlib,
     jsx,
     syntax_tools,
-    getopt,
     aebytecode,
     eblake2
    ]},

test/aeso_calldata_tests.erl

@@ -85,6 +85,7 @@ compilable_contracts() ->
      {"funargs", "bitsum", ["Bits.clear(Bits.clear(Bits.all, 4), 2)"]}, %% Order matters for test
      {"funargs", "bitsum", ["Bits.set(Bits.set(Bits.none, 4), 2)"]},
      {"funargs", "read", ["{label = \"question 1\", result = 4}"]},
+     {"funargs", "any_bytes", ["Bytes.to_any_size(#0011AA)"]},
      {"funargs", "sjutton", ["#0011012003100011012003100011012003"]},
      {"funargs", "sextiosju", ["#01020304050607080910111213141516171819202122232425262728293031323334353637383940"
                                "414243444546474849505152535455565758596061626364656667"]},
@@ -116,6 +117,7 @@ compilable_contracts() ->
      {"funargs", "chain_base_tx", ["Chain.NameRevokeTx(#ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)"]},
      {"funargs", "chain_base_tx", ["Chain.NameTransferTx(ak_2dATVcZ9KJU5a8hdsVtTv21pYiGWiPbmVcU1Pz72FFqpk9pSRR, #ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)"]},
      {"funargs", "chain_base_tx", ["Chain.GAAttachTx"]},
+     {"funargs", "sig", ["sg_MhibzTP1wWzGCTjtPFr1TiPqRJrrJqw7auvEuF5i3FdoALWqXLBDY6xxRRNUSPHK3EQTnTzF12EyspkxrSMxVHKsZeSMj"]},
      {"variant_types", "init", []},
      {"basic_auth", "init", []},
      {"address_literals", "init", []},

test/aeso_compiler_tests.erl

@@ -70,6 +70,7 @@ simple_compile_test_() ->
        fun() ->
            #{ warnings := Warnings } = compile("warnings", [warn_all]),
            #{ warnings := [] } = compile("warning_unused_include_no_include", [warn_all]),
+           #{ warnings := [] } = compile("warning_used_record_typedef", [warn_all]),
            check_warnings(warnings(), Warnings)
        end} ] ++
     [].
@@ -161,6 +162,7 @@ compilable_contracts() ->
      "state_handling",
      "events",
      "include",
+     "relative_include",
      "basic_auth",
      "basic_auth_tx",
      "bitcoin_auth",
@@ -170,6 +172,7 @@ compilable_contracts() ->
      "namespace_bug",
      "bytes_to_x",
      "bytes_concat",
+     "bytes_misc",
      "aens",
      "aens_update",
      "tuple_match",
@@ -223,6 +226,7 @@ compilable_contracts() ->
      "unapplied_named_arg_builtin",
      "resolve_field_constraint_by_arity",
      "toplevel_constants",
+     "ceres",
      "test" % Custom general-purpose test file. Keep it last on the list.
     ].
 
@@ -447,6 +451,10 @@ failing_contracts() ->
         [<<?Pos(12, 42)
            "Cannot unify `int` and `string`\n"
            "when checking the type of the expression `r.foo() : map(int, string)` "
+           "against the expected type `map(string, int)`">>,
+         <<?Pos(12, 42)
+           "Cannot unify `string` and `int`\n"
+           "when checking the type of the expression `r.foo() : map(int, string)` "
            "against the expected type `map(string, int)`">>])
     , ?TYPE_ERROR(not_toplevel_include,
                   [<<?Pos(2, 11)
@@ -604,6 +612,21 @@ failing_contracts() ->
         [<<?Pos(3, 5)
            "Unbound variable `Chain.event`\n"
            "Did you forget to define the event type?">>])
+    , ?TYPE_ERROR(bad_bytes_to_x,
+        [<<?Pos(3, 35)
+           "Cannot resolve length of byte array in\n"
+           "  the result of a call to Bytes.to_fixed_size">>,
+         <<?Pos(4, 36)
+           "Cannot unify `bytes()` and `bytes(4)`\nwhen checking the application of\n"
+           "  `Bytes.to_fixed_size : (bytes()) => option('a)`\n"
+           "to arguments\n"
+           "  `b : bytes(4)`">>,
+         <<?Pos(4, 36)
+           "Cannot resolve length of byte array in\n"
+           "  the result of a call to Bytes.to_fixed_size">>,
+         <<?Pos(5, 35)
+           "Cannot resolve length of byte array in\n"
+           "  the first argument of a call to Bytes.to_any_size">>])
     , ?TYPE_ERROR(bad_bytes_concat,
         [<<?Pos(12, 40)
            "Failed to resolve byte array lengths in call to Bytes.concat with arguments of type\n"
@@ -628,7 +651,8 @@ failing_contracts() ->
            "and result type\n"
            "  - 'c  (at line 16, column 39)">>,
          <<?Pos(19, 25)
-           "Cannot resolve length of byte array.">>])
+           "Cannot resolve type of byte array in\n"
+           "  the first argument of a call to Bytes.to_str">>])
     , ?TYPE_ERROR(bad_bytes_split,
          [<<?Pos(13, 5)
             "Failed to resolve byte array lengths in call to Bytes.split with argument of type\n"
@@ -871,10 +895,10 @@ failing_contracts() ->
                      "Trying to implement or extend an undefined interface `Z`">>
                   ])
     , ?TYPE_ERROR(polymorphism_contract_interface_same_name_different_type,
-                  [<<?Pos(9,5)
-                     "Duplicate definitions of `f` at\n"
-                     "  - line 8, column 5\n"
-                     "  - line 9, column 5">>])
+                  [<<?Pos(5,5)
+                     "Cannot unify `char` and `int`\n"
+                     "when implementing the entrypoint `f` from the interface `I1`">>
+                  ])
     , ?TYPE_ERROR(polymorphism_contract_missing_implementation,
                   [<<?Pos(4,20)
                      "Unimplemented entrypoint `f` from the interface `I1` in the contract `I2`">>
@@ -928,6 +952,9 @@ failing_contracts() ->
                    <<?Pos(67,36)
                      "Cannot unify `Cat` and `Animal` in a contravariant context\n"
                      "when checking the application of\n  `DT_INV : ((Cat) => Cat) => dt_inv(Cat)`\nto arguments\n  `f_c_to_a : (Cat) => Animal`">>,
+                   <<?Pos(67,36)
+                     "Cannot unify `Cat` and `Animal` in a invariant context\n"
+                     "when checking the type of the expression `DT_INV(f_c_to_a) : dt_inv(Cat)` against the expected type `dt_inv(Animal)`">>,
                    <<?Pos(68,36)
                      "Cannot unify `Cat` and `Animal` in a invariant context\n"
                      "when checking the type of the expression `DT_INV(f_c_to_c) : dt_inv(Cat)` against the expected type `dt_inv(Animal)`">>,
@@ -976,6 +1003,9 @@ failing_contracts() ->
                    <<?Pos(116,59)
                      "Cannot unify `Cat` and `Animal` in a contravariant context\n"
                      "when checking the type of the expression `DT_A_CONTRA_B_CONTRA(f_c_to_c_to_u) : dt_a_contra_b_contra(Cat, Cat)` against the expected type `dt_a_contra_b_contra(Animal, Animal)`">>,
+                   <<?Pos(116,59)
+                     "Cannot unify `Cat` and `Animal` in a contravariant context\n"
+                     "when checking the type of the expression `DT_A_CONTRA_B_CONTRA(f_c_to_c_to_u) : dt_a_contra_b_contra(Cat, Cat)` against the expected type `dt_a_contra_b_contra(Animal, Animal)`">>,
                    <<?Pos(119,59)
                      "Cannot unify `Cat` and `Animal` in a contravariant context\n"
                      "when checking the type of the expression `DT_A_CONTRA_B_CONTRA(f_c_to_a_to_u) : dt_a_contra_b_contra(Cat, Animal)` against the expected type `dt_a_contra_b_contra(Animal, Cat)`">>,
@@ -1019,6 +1049,9 @@ failing_contracts() ->
                    <<?Pos(19,13)
                      "Cannot unify `Cat` and `Animal` in a contravariant context\n"
                      "when checking the type of the pattern `o07 : oracle(Animal, Cat)` against the expected type `oracle(Cat, Animal)`">>,
+                   <<?Pos(19,13)
+                     "Cannot unify `Animal` and `Cat` in a covariant context\n"
+                     "when checking the type of the pattern `o07 : oracle(Animal, Cat)` against the expected type `oracle(Cat, Animal)`">>,
                    <<?Pos(20,13)
                      "Cannot unify `Cat` and `Animal` in a contravariant context\n"
                      "when checking the type of the pattern `o08 : oracle(Animal, Cat)` against the expected type `oracle(Cat, Cat)`">>,
@@ -1043,6 +1076,9 @@ failing_contracts() ->
                    <<?Pos(42,13)
                      "Cannot unify `Animal` and `Cat` in a covariant context\n"
                      "when checking the type of the pattern `q13 : oracle_query(Cat, Cat)` against the expected type `oracle_query(Animal, Animal)`">>,
+                   <<?Pos(42,13)
+                     "Cannot unify `Animal` and `Cat` in a covariant context\n"
+                     "when checking the type of the pattern `q13 : oracle_query(Cat, Cat)` against the expected type `oracle_query(Animal, Animal)`">>,
                    <<?Pos(43,13)
                      "Cannot unify `Animal` and `Cat` in a covariant context\n"
                      "when checking the type of the pattern `q14 : oracle_query(Cat, Cat)` against the expected type `oracle_query(Animal, Cat)`">>,
@@ -1104,19 +1140,19 @@ failing_contracts() ->
                   ])
     , ?TYPE_ERROR(polymorphic_aens_resolve,
                   [<<?Pos(4,5)
-                     "Invalid return type of `AENS.resolve`:\n"
+                     "Invalid return type of `AENSv2.resolve`:\n"
                      "  `'a`\n"
                      "It must be a `string` or a pubkey type (`address`, `oracle`, etc)">>
                   ])
     , ?TYPE_ERROR(bad_aens_resolve,
                   [<<?Pos(6,5)
-                     "Invalid return type of `AENS.resolve`:\n"
+                     "Invalid return type of `AENSv2.resolve`:\n"
                      "  `list(int)`\n"
                      "It must be a `string` or a pubkey type (`address`, `oracle`, etc)">>
                   ])
     , ?TYPE_ERROR(bad_aens_resolve_using,
                   [<<?Pos(7,5)
-                     "Invalid return type of `AENS.resolve`:\n"
+                     "Invalid return type of `AENSv2.resolve`:\n"
                      "  `list(int)`\n"
                      "It must be a `string` or a pubkey type (`address`, `oracle`, etc)">>
                   ])
@@ -1266,6 +1302,10 @@ failing_contracts() ->
                    <<?Pos(3,9)
                      "The name of the compile-time constant cannot have pattern matching">>
                   ])
+    , ?TYPE_ERROR(too_many_tvars,
+                  [<<?Pos(2,3)
+                     "Too many type variables (max 256) in definition of `too_many`">>
+                  ])
     ].
 
 validation_test_() ->
@@ -1313,7 +1353,9 @@ validate(Contract1, Contract2) ->
                   true  -> [debug_mode];
                   false -> []
               end ++
-                  [{include, {file_system, [aeso_test_utils:contract_path()]}}]);
+                  [ {src_file, lists:concat([Contract2, ".aes"])}
+                  , {include, {file_system, [aeso_test_utils:contract_path()]}}
+                  ]);
         Error -> print_and_throw(Error)
     end.
 

test/aeso_encode_decode_tests.erl

@@ -0,0 +1,40 @@
+-module(aeso_encode_decode_tests).
+
+-compile([export_all, nowarn_export_all]).
+
+-include_lib("eunit/include/eunit.hrl").
+
+-define(EMPTY, "contract C =\n  entrypoint f() = true").
+
+encode_decode_test_() ->
+    [ {lists:flatten(io_lib:format("Testing encode-decode roundtrip for ~p : ~p", [Value, {EType, DType}])),
+       fun() ->
+           {ok, SerRes} = aeso_compiler:encode_value(?EMPTY, EType, Value, []),
+           {ok, Expr} = aeso_compiler:decode_value(?EMPTY, DType, SerRes, []),
+           Value2 = prettypr:format(aeso_pretty:expr(Expr)),
+           ?assertEqual(Value, Value2)
+       end} || {Value, EType, DType} <- test_data() ].
+
+test_data() ->
+    lists:map(fun({V, T}) -> {V, T, T};
+                 ({V, T1, T2}) -> {V, T1, T2} end, data()).
+
+data() ->
+    [ {"42", "int"}
+    , {"- 42", "int"}
+    , {"true", "bool"}
+    , {"ak_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ", "address"}
+    , {"ct_Ez6MyeTMm17YnTnDdHTSrzMEBKmy7Uz2sXu347bTDPgVH2ifJ", "C"}
+    , {"Some(42)", "option(int)"}
+    , {"None", "option(int)"}
+    , {"(true, 42)", "bool * int"}
+    , {"{[1] = true, [3] = false}", "map(int, bool)"}
+    , {"()", "unit"}
+    , {"#000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f", "hash"}
+    , {"#000102030405060708090a0b0c0d0e0f000102030405060708090a0b0c0d0e0f", "bytes(32)"}
+    , {"sg_MhibzTP1wWzGCTjtPFr1TiPqRJrrJqw7auvEuF5i3FdoALWqXLBDY6xxRRNUSPHK3EQTnTzF12EyspkxrSMxVHKsZeSMj", "signature"}
+    , {"sg_MhibzTP1wWzGCTjtPFr1TiPqRJrrJqw7auvEuF5i3FdoALWqXLBDY6xxRRNUSPHK3EQTnTzF12EyspkxrSMxVHKsZeSMj", "bytes(64)", "signature"}
+    , {"#0102030405060708090a0b0c0d0e0f101718192021222324252627282930313233343536373839401a1b1c1d1e1f202122232425262728293031323334353637", "bytes(64)"}
+    , {"#0102030405060708090a0b0c0d0e0f101718192021222324252627282930313233343536373839401a1b1c1d1e1f202122232425262728293031323334353637", "signature", "bytes(64)"}
+    ].
+

test/aeso_parser_tests.erl

@@ -53,7 +53,7 @@ simple_contracts_test_() ->
             %% associativity
             [ RightAssoc(Op) || Op <- ["||", "&&", "::", "++"] ],
             [ NonAssoc(Op)   || Op <- ["==", "!=", "<", ">", "=<", ">="] ],
-            [ LeftAssoc(Op)  || Op <- ["+", "-", "*", "/", "mod"] ],
+            [ LeftAssoc(Op)  || Op <- ["+", "-", "*", "/", "mod", "band", "bor", "bxor", "<<", ">>"] ],
 
             %% precedence
             [ Stronger(Op2, Op1) || [T1 , T2 | _] <- tails(Tiers), Op1 <- T1, Op2 <- T2 ],

test/aeso_scan_tests.erl

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

test/contracts/aens.aes

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

test/contracts/aens_update.aes

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

test/contracts/bad_aens_resolve.aes

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

test/contracts/bad_aens_resolve_using.aes

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

test/contracts/bad_bytes_to_x.aes

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

test/contracts/bytes_misc.aes

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

test/contracts/bytes_to_x.aes

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

test/contracts/ceres.aes

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

test/contracts/chain.aes

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

test/contracts/dir1/bar.aes

@@ -0,0 +1,4 @@
+include "../dir2/baz.aes"
+namespace D =
+  function g() = E.h()
+

test/contracts/dir2/baz.aes

@@ -0,0 +1,3 @@
+namespace E =
+  function h() = 42
+

test/contracts/funargs.aes

@@ -20,6 +20,8 @@ contract FunctionArguments =
   entrypoint read(a : answer(int)) =
      a.result
 
+  entrypoint any_bytes(b : bytes()) = b
+
   entrypoint sjutton(b : bytes(17)) =
      b
 
@@ -57,3 +59,5 @@ contract FunctionArguments =
   entrypoint chain_ga_meta_tx(tx : Chain.ga_meta_tx) = true
   entrypoint chain_paying_for_tx(tx : Chain.paying_for_tx) = true
   entrypoint chain_base_tx(tx : Chain.base_tx) = true
+
+  entrypoint sig(sg : signature) = true

test/contracts/polymorphic_aens_resolve.aes

@@ -1,7 +1,7 @@
 contract PolymorphicAENSresolve =
 
   function fail() : option('a) =
-    AENS.resolve("foo.aet", "whatever")
+    AENSv2.resolve("foo.aet", "whatever")
 
   entrypoint main_fun() = ()
 

test/contracts/relative_include.aes

@@ -0,0 +1,3 @@
+include "./dir1/bar.aes"
+contract C =
+  entrypoint f() = D.g()

test/contracts/too_many_tvars.aes

@@ -0,0 +1,60 @@
+contract C =
+  entrypoint too_many(
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _)) = 0
+
+  entrypoint not_too_many(
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _, _, _, _, _),
+      (_, _, _, _, _, _)) = 0

test/contracts/unapplied_builtins.aes

@@ -2,10 +2,10 @@
 // Named argument builtins are:
 //    Oracle.register
 //    Oracle.respond
-//    AENS.preclaim
-//    AENS.claim
-//    AENS.transfer
-//    AENS.revoke
+//    AENSv2.preclaim
+//    AENSv2.claim
+//    AENSv2.transfer
+//    AENSv2.revoke
 //    Oracle.extend
 include "String.aes"
 contract UnappliedBuiltins =
@@ -28,7 +28,7 @@ contract UnappliedBuiltins =
   function oracle_get_answer()           = Oracle.get_answer   : (o, _) => _
   function oracle_check()                = Oracle.check        : o => _
   function oracle_check_query()          = Oracle.check_query  : (o, _) => _
-  function aens_resolve()                = AENS.resolve        : (_, _) => option(string)
+  function aens_resolve()                = AENSv2.resolve      : (_, _) => option(string)
   function map_lookup()                  = Map.lookup          : (_, m) => _
   function map_lookup_default()          = Map.lookup_default  : (_, m, _) => _
   function map_member()                  = Map.member          : (_, m) => _
@@ -36,7 +36,7 @@ contract UnappliedBuiltins =
   function map_delete()                  = Map.delete : (_, m) => _
   function map_from_list()               = Map.from_list : _ => m
   function map_to_list()                 = Map.to_list : m => _
-  function crypto_verify_sig()           = Crypto.verify_sig
+  function crypto_verify_sig()           = Crypto.verify_sig : (bytes(), _, _) => _
   function crypto_verify_sig_secp256k1() = Crypto.verify_sig_secp256k1
   function crypto_ecverify_secp256k1()   = Crypto.ecverify_secp256k1
   function crypto_ecrecover_secp256k1()  = Crypto.ecrecover_secp256k1

test/contracts/warning_used_record_typedef.aes

@@ -0,0 +1,5 @@
+contract Test =
+    type option_int = option(int)
+    record option_point = {x: int, y: option_int}
+
+    entrypoint test_option_record(a: option_point) = a

zomp.meta

@@ -0,0 +1,21 @@
+{name,"Sophia Compiler"}.
+{type,lib}.
+{modules,[]}.
+{prefix,none}.
+{desc,"The Sophia smart contract language for FATE blockchains"}.
+{author,"QPQ AG & Aeternity Foundation"}.
+{package_id,{"otpr","aesophia",{8,0,1}}}.
+{deps,[{"otpr","aebytecode",{3,2,1}},
+       {"otpr","getopt",{1,0,2}},
+       {"otpr","eblake2",{1,0,0}},
+       {"otpr","zj",{1,1,0}}]}.
+{key_name,none}.
+{a_email,[]}.
+{c_email,[]}.
+{copyright,"(c) 2024 QPQ AG, 2018 Aeternity Foundation"}.
+{file_exts,[]}.
+{license,skip}.
+{repo_url,"https://gitlab.com/ioecs/aesophia"}.
+{tags,["gaju","gajumaru","blockchain","sophia","crypto","ae","compiler",
+       "puck"]}.
+{ws_url,[]}.

zomp_prep

@@ -0,0 +1,19 @@
+#! /bin/bash
+
+# This is a small pre-packaging source generation and include correction script that should be
+# run before packaging this project for use with ZX/Zomp.
+
+rm -rf _build
+cd src
+for f in $(ls *.erl)
+do
+    echo "Updating includes in: $f"
+    sed -i 's/aebytecode\/include\///g' "$f"
+    sed -i 's/\.\.\/include\///g' "$f"
+    sed -i 's/include_lib/include/g' "$f"
+done
+sed -i 's/aeb_opcodes\.hrl/\$aebytecode_include\/aeb_opcodes\.hrl/' aeso_compiler.erl
+sed -i 's/aeb_fate_data\.hrl/\$aebytecode_include\/aeb_fate_data\.hrl/' aeso_vm_decode.erl
+cd ..
+rm -f ebin/*.beam
+rm -f rebar*