Merge pull request #1795 from ton-blockchain/tolk-v1.1

Tolk v1.1: built-in map<K,V>, enums, private and readonly fields, methods overloading

Author: EmelyanenkoK

crypto/smartcont/tolk-stdlib/common.tolk

@@ -1,5 +1,5 @@
 // A part of standard library for Tolk
-tolk 1.0
+tolk 1.1
 
 /**
   Gas and payment related primitives.
@@ -32,24 +32,24 @@ fun setGasLimitToMaximum(): void
 fun setGasLimit(limit: int): void
     asm "SETGASLIMIT"
 
-/// Calculates fee (amount in nanotoncoins to be paid) for a transaction which consumed [gasUsed] gas units.
+/// 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"
 
-/// Same as [calculateGasFee], but without flat price (you have supposed to read https://docs.ton.org/develop/howto/fees-low-level)
+/// Same as [calculateGasFee], but without flat price. [Docs about fees](https://docs.ton.org/develop/howto/fees-low-level)
 fun calculateGasFeeWithoutFlatPrice(workchain: int8, gasUsed: coins): coins
     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).
+/// 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"
 
 /// 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 [calculateForwardFee], but without lump price (you have supposed to read https://docs.ton.org/develop/howto/fees-low-level)
+/// Same as [calculateForwardFee], but without lump price. [Docs about fees](https://docs.ton.org/develop/howto/fees-low-level)
 fun calculateForwardFeeWithoutLumpPrice(workchain: int8, bits: int, cells: int): coins
     asm(cells bits workchain) "GETFORWARDFEESIMPLE"
 

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

@@ -1,5 +1,5 @@
 // A part of standard library for Tolk
-tolk 1.0
+tolk 1.1
 
 /**
     Lisp-style lists are nested 2-elements tuples: `[1, [2, [3, null]]]` represents list `[1, 2, 3]`.

crypto/smartcont/tolk-stdlib/lisp-lists.tolk

@@ -1,9 +1,12 @@
 // A part of standard library for Tolk
-tolk 1.0
+tolk 1.1
 
 /**
-    Dictionaries are represented as `cell` data type (cells can store anything, dicts in particular).
-    Currently, they have very low-level API very close to TVM internals.
+    Low-level API working with TVM dictionaries.
+    Not recommended to use, since it's very complicated and error-prone.
+    Use `map<K, V>` instead, it's even more efficient then low-level dict API.
+
+    Dictionaries are represented as `cell` data type.
     Most of functions are duplicated for three common cases:
     - iDict* - dicts with signed integer keys
     - uDict* - dicts with unsigned integer keys
@@ -14,10 +17,12 @@ tolk 1.0
  */
 
 /// In @stdlib/common.tolk, there is a type alias:
-/// `type dict = cell?`
+/// ```
+/// type dict = cell?
+/// ```
 /// For clarity, we use "dict" instead of a "cell?" where a cell-dictionary is assumed.
 
-/// Creates an empty dictionary, which is actually a null value. Equivalent to PUSHNULL
+/// Creates an empty dictionary, which is actually a null value. Equivalent to `PUSHNULL`
 @pure
 fun createEmptyDict(): dict
     asm "NEWDICT"
@@ -86,28 +91,28 @@ fun dict.uDictSetIfExists(mutate self, keyLen: int, key: int, value: slice): boo
 
 
 @pure
-fun dict.iDictGetRef(self, keyLen: int, key: int): (dict, bool)
+fun dict.iDictGetRef(self, keyLen: int, key: int): (cell?, bool)
     asm(key self keyLen) "DICTIGETREF" "NULLSWAPIFNOT"
 
 @pure
-fun dict.uDictGetRef(self, keyLen: int, key: int): (dict, bool)
+fun dict.uDictGetRef(self, keyLen: int, key: int): (cell?, bool)
     asm(key self keyLen) "DICTUGETREF" "NULLSWAPIFNOT"
 
 @pure
-fun dict.sDictGetRef(self, keyLen: int, key: slice): (dict, bool)
+fun dict.sDictGetRef(self, keyLen: int, key: slice): (cell?, bool)
     asm(key self keyLen) "DICTGETREF" "NULLSWAPIFNOT"
 
 
 @pure
-fun dict.iDictGetRefOrNull(self, keyLen: int, key: int): dict
+fun dict.iDictGetRefOrNull(self, keyLen: int, key: int): cell?
     asm(key self keyLen) "DICTIGETOPTREF"
 
 @pure
-fun dict.uDictGetRefOrNull(self, keyLen: int, key: int): dict
+fun dict.uDictGetRefOrNull(self, keyLen: int, key: int): cell?
     asm(key self keyLen) "DICTUGETOPTREF"
 
 @pure
-fun dict.sDictGetRefOrNull(self, keyLen: int, key: slice): dict
+fun dict.sDictGetRefOrNull(self, keyLen: int, key: slice): cell?
     asm(key self keyLen) "DICTGETOPTREF"
 
 
@@ -138,11 +143,11 @@ fun dict.sDictSetAndGet(mutate self, keyLen: int, key: slice, value: slice): (sl
 
 
 @pure
-fun dict.iDictSetAndGetRefOrNull(mutate self, keyLen: int, key: int, value: cell): dict
+fun dict.iDictSetAndGetRefOrNull(mutate self, keyLen: int, key: int, value: cell): cell?
     asm(value key self keyLen) "DICTISETGETOPTREF"
 
 @pure
-fun dict.uDictSetAndGetRefOrNull(mutate self, keyLen: int, key: int, value: cell): dict
+fun dict.uDictSetAndGetRefOrNull(mutate self, keyLen: int, key: int, value: cell): cell?
     asm(value key self keyLen) "DICTUSETGETOPTREF"
 
 
@@ -228,15 +233,15 @@ fun dict.sDictGetFirst(self, keyLen: int): (slice?, slice?, bool)
     asm (-> 1 0 2) "DICTMIN" "NULLSWAPIFNOT2"
 
 @pure
-fun dict.iDictGetFirstAsRef(self, keyLen: int): (int?, dict, bool)
+fun dict.iDictGetFirstAsRef(self, keyLen: int): (int?, cell?, bool)
     asm (-> 1 0 2) "DICTIMINREF" "NULLSWAPIFNOT2"
 
 @pure
-fun dict.uDictGetFirstAsRef(self, keyLen: int): (int?, dict, bool)
+fun dict.uDictGetFirstAsRef(self, keyLen: int): (int?, cell?, bool)
     asm (-> 1 0 2) "DICTUMINREF" "NULLSWAPIFNOT2"
 
 @pure
-fun dict.sDictGetFirstAsRef(self, keyLen: int): (slice?, dict, bool)
+fun dict.sDictGetFirstAsRef(self, keyLen: int): (slice?, cell?, bool)
     asm (-> 1 0 2) "DICTMINREF" "NULLSWAPIFNOT2"
 
 
@@ -253,15 +258,15 @@ fun dict.sDictGetLast(self, keyLen: int): (slice?, slice?, bool)
     asm (-> 1 0 2) "DICTMAX" "NULLSWAPIFNOT2"
 
 @pure
-fun dict.iDictGetLastAsRef(self, keyLen: int): (int?, dict, bool)
+fun dict.iDictGetLastAsRef(self, keyLen: int): (int?, cell?, bool)
     asm (-> 1 0 2) "DICTIMAXREF" "NULLSWAPIFNOT2"
 
 @pure
-fun dict.uDictGetLastAsRef(self, keyLen: int): (int?, dict, bool)
+fun dict.uDictGetLastAsRef(self, keyLen: int): (int?, cell?, bool)
     asm (-> 1 0 2) "DICTUMAXREF" "NULLSWAPIFNOT2"
 
 @pure
-fun dict.sDictGetLastAsRef(self, keyLen: int): (slice?, dict, bool)
+fun dict.sDictGetLastAsRef(self, keyLen: int): (slice?, cell?, bool)
     asm (-> 1 0 2) "DICTMAXREF" "NULLSWAPIFNOT2"
 
 
@@ -273,6 +278,10 @@ fun dict.iDictGetNext(self, keyLen: int, pivot: int): (int?, slice?, bool)
 fun dict.uDictGetNext(self, keyLen: int, pivot: int): (int?, slice?, bool)
     asm(pivot self keyLen -> 1 0 2) "DICTUGETNEXT" "NULLSWAPIFNOT2"
 
+@pure
+fun dict.sDictGetNext(self, keyLen: int, pivot: slice): (slice?, slice?, bool)
+    asm(pivot self keyLen -> 1 0 2) "DICTGETNEXT" "NULLSWAPIFNOT2"
+
 @pure
 fun dict.iDictGetNextOrEqual(self, keyLen: int, pivot: int): (int?, slice?, bool)
     asm(pivot self keyLen -> 1 0 2) "DICTIGETNEXTEQ" "NULLSWAPIFNOT2"
@@ -281,6 +290,10 @@ fun dict.iDictGetNextOrEqual(self, keyLen: int, pivot: int): (int?, slice?, bool
 fun dict.uDictGetNextOrEqual(self, keyLen: int, pivot: int): (int?, slice?, bool)
     asm(pivot self keyLen -> 1 0 2) "DICTUGETNEXTEQ" "NULLSWAPIFNOT2"
 
+@pure
+fun dict.sDictGetNextOrEqual(self, keyLen: int, pivot: slice): (slice?, slice?, bool)
+    asm(pivot self keyLen -> 1 0 2) "DICTGETNEXTEQ" "NULLSWAPIFNOT2"
+
 
 @pure
 fun dict.iDictGetPrev(self, keyLen: int, pivot: int): (int?, slice?, bool)
@@ -290,6 +303,10 @@ fun dict.iDictGetPrev(self, keyLen: int, pivot: int): (int?, slice?, bool)
 fun dict.uDictGetPrev(self, keyLen: int, pivot: int): (int?, slice?, bool)
     asm(pivot self keyLen -> 1 0 2) "DICTUGETPREV" "NULLSWAPIFNOT2"
 
+@pure
+fun dict.sDictGetPrev(self, keyLen: int, pivot: slice): (slice?, slice?, bool)
+    asm(pivot self keyLen -> 1 0 2) "DICTGETPREV" "NULLSWAPIFNOT2"
+
 @pure
 fun dict.iDictGetPrevOrEqual(self, keyLen: int, pivot: int): (int?, slice?, bool)
     asm(pivot self keyLen -> 1 0 2) "DICTIGETPREVEQ" "NULLSWAPIFNOT2"
@@ -298,9 +315,13 @@ fun dict.iDictGetPrevOrEqual(self, keyLen: int, pivot: int): (int?, slice?, bool
 fun dict.uDictGetPrevOrEqual(self, keyLen: int, pivot: int): (int?, slice?, bool)
     asm(pivot self keyLen -> 1 0 2) "DICTUGETPREVEQ" "NULLSWAPIFNOT2"
 
+@pure
+fun dict.sDictGetPrevOrEqual(self, keyLen: int, pivot: slice): (slice?, slice?, bool)
+    asm(pivot self keyLen -> 1 0 2) "DICTGETPREVEQ" "NULLSWAPIFNOT2"
+
 
 /**
- Prefix dictionary primitives.
+    Prefix dictionary primitives.
  */
 
 @pure

crypto/smartcont/tolk-stdlib/tvm-dicts.tolk

@@ -1,5 +1,5 @@
 // A part of standard library for Tolk
-tolk 1.0
+tolk 1.1
 
 /// Usually `c3` has a continuation initialized by the whole code of the contract. It is used for function calls.
 /// The primitive returns the current value of `c3`.
@@ -14,12 +14,12 @@ fun getTvmRegisterC3(): continuation
 fun setTvmRegisterC3(c: continuation): void
     asm "c3 POP"
 
-/// Transforms a `slice` [s] into a simple ordinary continuation `c`, with `c.code = s` and an empty stack and savelist.
+/// Transforms a slice into a simple ordinary continuation, with `c.code = s` and an empty stack and savelist.
 @pure
 fun transformSliceToContinuation(s: slice): continuation
     asm "BLESS"
 
-/// Moves a variable or a value [x] to the top of the stack.
+/// Moves a variable to the top of the stack.
 @pure
 fun T.stackMoveToTop(mutate self): void
     asm "NOP"

crypto/smartcont/tolk-stdlib/tvm-lowlevel.tolk

@@ -257,6 +257,32 @@ fun test119(a: int, b: int) {
     return (l, c, d);
 }
 
+struct Point {
+    x: int
+    y: int
+}
+
+struct ROLine {
+    readonly from: Point
+    readonly to: Point
+}
+
+fun eq<T>(v: T) { return v }
+
+@method_id(120)
+fun test120() {
+    val p: Point = { x: 10, y: 20 };
+    eq(p).x = 30;
+    return p;
+}
+
+@method_id(121)
+fun test121(l: ROLine) {
+    eq(l.from).x = eq(l.to).y;
+    eq(l.from).y += 10;
+    return l
+}
+
 
 
 fun main(value: int, ) {
@@ -288,6 +314,8 @@ fun main(value: int, ) {
 @testcase | 117 |        | [ 20 ]
 @testcase | 118 | 3      | 10 3 0 1
 @testcase | 119 | 1 2    | 2 2 4
+@testcase | 120 |        | 10 20
+@testcase | 121 | null   | (null)
 
 
 @fif_codegen

tolk-tester/tests/assignment-tests.tolk

@@ -179,7 +179,11 @@ fun test11(a: int, b: int) {
     return ((b < a), (b <= a), (b > a), (b >= a));
 }
 
-fun main() {}
+fun main() {
+    // mark used to codegen them
+    cmp1; cmp2; cmp3; cmp4;
+    leq1; leq2; leq3; leq4;
+}
 
 /**
 @testcase | 101 | 10      | 10 15 100 12 3 110 300

tolk-tester/tests/calls-tests.tolk

@@ -16,6 +16,16 @@ fun endCell(b: builder): cell
 fun beginParse(c: cell): slice
     asm "CTOS";
 
+@noinline
+fun triggerOverflowIntConst() {
+    return beginCell().storeInt(10, 4)
+}
+
+@noinline
+fun triggerOverflowUintConst() {
+    return beginCell().storeUint(123, 6)
+}
+
 @method_id(101)
 fun test1(): [int,int,int,int,int] {
     var b: builder = beginCell().storeUint(1, 32);
@@ -249,6 +259,7 @@ fun test18() {
   return (s.loadUint(14), s.loadInt(8), s.loadUint(4));
 }
 
+@method_id(119)
 fun test19() {
     // numbers with potential overflow for STU are not joined, check via codegen
     var b = beginCell();
@@ -267,6 +278,7 @@ fun test20() {
   return (s.loadBool(), s.loadBool(), s.loadBool(), s.loadUint(8), s.loadBool(), s.loadCoins());
 }
 
+@method_id(121)
 fun test21(s: slice) {
     // successive skipBits are also joined
     var x = 8;
@@ -433,6 +445,30 @@ fun test34(p: int, n: int) {
     return b;
 }
 
+@method_id(135)
+fun test35(overflowMode: int) {
+    try {
+        val b: builder = match (overflowMode) {
+            1 => triggerOverflowIntConst(), 
+            2 => triggerOverflowUintConst(),
+            3 => beginCell().storeUint(10, -4),
+            4 => beginCell().storeInt(100, 1),
+            5 => beginCell().storeInt(1, 0),
+            6 => beginCell().storeInt(115792089237316195423570985008687907853269984665640564039457584007913129639935, 256),
+            7 => beginCell().storeInt(15, 4),
+            8 => beginCell().storeUint(1<<170, 169),
+            else => beginCell(),
+        };
+        return b.endCell().beginParse().loadUint(1) * 1000
+    }
+    catch (ex) { return ex }
+}
+
+@method_id(136)
+fun test36() {
+    return beginCell().storeInt(0, 0)
+}
+
 fun main(): int {
     return 0;
 }
@@ -467,6 +503,15 @@ fun main(): int {
 @testcase | 132 | 0   | BC{00080000000a}
 @testcase | 133 | 0   | BC{00020a}
 @testcase | 134 | 0 8 | BC{00020a}
+@testcase | 135 | 1   | 5
+@testcase | 135 | 2   | 5
+@testcase | 135 | 3   | 5
+@testcase | 135 | 4   | 5
+@testcase | 135 | 5   | 5
+@testcase | 135 | 6   | 5
+@testcase | 135 | 7   | 5
+@testcase | 135 | 8   | 5
+@testcase | 136 |     | BC{0000}
 
 We test that consequtive storeInt/storeUint with constants are joined into a single number
 
@@ -628,4 +673,32 @@ We test that consequtive storeInt/storeUint with constants are joined into a sin
   }>
 """
 
+@fif_codegen
+"""
+  triggerOverflowIntConst() PROC:<{ 
+    10 PUSHINT
+    NEWC
+    4 STI
+  }>
+"""
+
+@fif_codegen
+"""
+  triggerOverflowUintConst() PROC:<{ 
+    123 PUSHINT
+    NEWC
+    6 STU
+  }>
+"""
+
+@fif_codegen
+"""
+  test36() PROC:<{ 
+    0 PUSHINT
+    NEWC
+    OVER
+    STIX
+  }>
+"""
+
  */