Merge pull request #1741 from ton-blockchain/tolk-v1.0

Tolk v1.0: lazy loading, AST inlining, peephole optimizations, TVM 11

Author: EmelyanenkoK

crypto/smartcont/tolk-stdlib/common.tolk

@@ -1,69 +1,70 @@
 // A part of standard library for Tolk
-tolk 0.99
+tolk 1.0
 
 /**
   Gas and payment related primitives.
  */
 
 /// Returns amount of gas (in gas units) consumed in current Computation Phase.
 fun getGasConsumedAtTheMoment(): int
-    asm "GASCONSUMED";
+    asm "GASCONSUMED"
 
 /// This function is required to be called when you process an external message (from an outer world)
 /// and "accept" it to blockchain.
 /// Without calling this function, an external message would be discarded.
 /// As an effect, the current smart contract agrees to buy some gas to finish the current transaction.
 /// For more details, check [accept_message effects](https://ton.org/docs/#/smart-contracts/accept).
 fun acceptExternalMessage(): void
-    asm "ACCEPT";
+    asm "ACCEPT"
 
 /// When processing an internal message, by default, the limit of gas consumption is determined by incoming message.
 /// Functions [setGasLimit] and [setGasLimitToMaximum] allow you to change this behavior.
 /// Sets current gas limit `gl` to its maximal allowed value `gm`, and resets the gas credit `gc` to zero,
 /// decreasing the value of `gr` by `gc` in the process.
 fun setGasLimitToMaximum(): void
-    asm "ACCEPT";
+    asm "ACCEPT"
 
 /// When processing an internal message, by default, the limit of gas consumption is determined by incoming message.
 /// Functions [setGasLimit] and [setGasLimitToMaximum] allow you to change this behavior.
 /// Sets current gas limit `gl` to the minimum of limit and `gm`, and resets the gas credit `gc` to zero.
 /// If the gas consumed so far (including the present instruction) exceeds the resulting value of `gl`,
 /// an (unhandled) out of gas exception is thrown before setting new gas limits.
 fun setGasLimit(limit: int): void
-    asm "SETGASLIMIT";
+    asm "SETGASLIMIT"
 
 /// Calculates fee (amount in nanotoncoins to be paid) for a transaction which consumed [gasUsed] gas units.
 fun calculateGasFee(workchain: int8, gasUsed: int): coins
-    asm(gasUsed workchain) "GETGASFEE";
+    asm(gasUsed workchain) "GETGASFEE"
 
 /// Same as [calculateGasFee], but without flat price (you have supposed to read https://docs.ton.org/develop/howto/fees-low-level)
 fun calculateGasFeeWithoutFlatPrice(workchain: int8, gasUsed: coins): coins
-    asm(gasUsed workchain) "GETGASFEESIMPLE";
+    asm(gasUsed workchain) "GETGASFEESIMPLE"
 
 /// Calculates amount of nanotoncoins you should pay for storing a contract of provided size for [seconds].
 /// [bits] and [cells] represent contract state (code + data).
 fun calculateStorageFee(workchain: int8, seconds: int, bits: int, cells: int): coins
-    asm(cells bits seconds workchain) "GETSTORAGEFEE";
+    asm(cells bits seconds workchain) "GETSTORAGEFEE"
 
-/// Calculates amount of nanotoncoins you should pay to send a message of specified size.
-fun calculateMessageFee(workchain: int8, bits: int, cells: int): coins
-    asm(cells bits workchain) "GETFORWARDFEE";
+/// Calculates amount of nanotoncoins you should pay to send a message of a specified size.
+fun calculateForwardFee(workchain: int8, bits: int, cells: int): coins
+    asm(cells bits workchain) "GETFORWARDFEE"
 
-/// Same as [calculateMessageFee], but without lump price (you have supposed to read https://docs.ton.org/develop/howto/fees-low-level)
-fun calculateMessageFeeWithoutLumpPrice(workchain: int8, bits: int, cells: int): coins
-    asm(cells bits workchain) "GETFORWARDFEESIMPLE";
+/// Same as [calculateForwardFee], but without lump price (you have supposed to read https://docs.ton.org/develop/howto/fees-low-level)
+fun calculateForwardFeeWithoutLumpPrice(workchain: int8, bits: int, cells: int): coins
+    asm(cells bits workchain) "GETFORWARDFEESIMPLE"
 
 /// Calculates fee that was paid by the sender of an incoming internal message.
-fun calculateOriginalMessageFee(workchain: int8, incomingFwdFee: coins): coins
-    asm(incomingFwdFee workchain) "GETORIGINALFWDFEE";
+@deprecated("use modern `onInternalMessage` and access `in.originalForwardFee` directly")
+fun calculateOriginalForwardFee(workchain: int8, incomingFwdFee: coins): coins
+    asm(incomingFwdFee workchain) "GETORIGINALFWDFEE"
 
 /// Returns the amount of nanotoncoins current contract debts for storage. ("due" and "debt" are synonyms)
 /// If it has no debt, `0` is returned.
 fun contract.getStorageDuePayment(): coins
-    asm "DUEPAYMENT";
+    asm "DUEPAYMENT"
 
 /// Returns the amount of nanotoncoins charged for storage.
 /// (during storage phase preceeding to current computation phase)
 @pure
 fun contract.getStoragePaidPayment(): coins
-    asm "STORAGEFEES";
+    asm "STORAGEFEES"

crypto/smartcont/tolk-stdlib/gas-payments.tolk

@@ -1,5 +1,5 @@
 // A part of standard library for Tolk
-tolk 0.99
+tolk 1.0
 
 /**
     Lisp-style lists are nested 2-elements tuples: `[1, [2, [3, null]]]` represents list `[1, 2, 3]`.
@@ -9,25 +9,25 @@ tolk 0.99
 
 @pure
 fun createEmptyList(): tuple
-    asm "PUSHNULL";
+    asm "PUSHNULL"
 
 /// Adds an element to the beginning of lisp-style list.
 /// Note, that it does not mutate the list: instead, it returns a new one (it's a lisp pattern).
 @pure
 fun listPrepend<X>(head: X, tail: tuple?): tuple
-    asm "CONS";
+    asm "CONS"
 
 /// Extracts the head and the tail of lisp-style list.
 @pure
 fun listSplit<X>(list: tuple): (X, tuple?)
-    asm "UNCONS";
+    asm "UNCONS"
 
 /// Returns the head of lisp-style list.
 @pure
 fun listGetHead<X>(list: tuple): X
-    asm "CAR";
+    asm "CAR"
 
 /// Returns the tail of lisp-style list.
 @pure
 fun listGetTail(list: tuple): tuple?
-    asm "CDR";
+    asm "CDR"